diff --git a/.coveragerc b/.coveragerc index 527b44f8a6..cf062df2cc 100644 --- a/.coveragerc +++ b/.coveragerc @@ -1,2 +1,6 @@ [run] -omit =./act/tests/*, ./act/*version*py +omit = + *tests* + act/*version*py + versioneer.py + setup.py diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md new file mode 100644 index 0000000000..2c8d7bc34e --- /dev/null +++ b/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,15 @@ +* ACT version: +* Python version: +* Operating System: + +### Description + +Describe what you were trying to get done. +Tell us what happened, what went wrong, and what you expected to happen. + +### What I Did + +``` +Paste the command(s) you ran and the output. +If there was a crash, please include the traceback here. +``` diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000000..edc910234e --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,7 @@ + + +- [ ] Closes #xxxx +- [ ] Tests added +- [ ] Documentation reflects changes +- [ ] PEP8 Standards or use of linter +- [ ] Xarray Dataset or DataArray variable naming follows 'ds' or 'da' naming diff --git a/.github/workflows/antivirus.yml b/.github/workflows/antivirus.yml new file mode 100644 index 0000000000..25b1d9bf84 --- /dev/null +++ b/.github/workflows/antivirus.yml @@ -0,0 +1,14 @@ +on: + pull_request: + types: [assigned, opened, synchronize, reopened, closed] + +jobs: + gitavscan: + runs-on: ubuntu-latest + name: AV scan + steps: + - uses: actions/checkout@v3 + - name: Git AV Scan + uses: djdefi/gitavscan@main + with: + full: '--full' diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml new file mode 100644 index 0000000000..c4329ad51c --- /dev/null +++ b/.github/workflows/build-docs.yml @@ -0,0 +1,52 @@ +name: build-docs + +on: + push: + branches: + - main + pull_request: + branches: + - main + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +# This job installs dependencies, build the website, and pushes it to `gh-pages` +jobs: + deploy-website: + runs-on: ubuntu-latest + defaults: + run: + shell: bash -l {0} + steps: + - uses: actions/checkout@v3 + + # Install dependencies + - name: Setup Conda Environment + uses: mamba-org/setup-micromamba@v1 + with: + environment-file: docs/environment_docs.yml + environment-name: act-docs + cache-downloads: true + + - name: Install ACT + run: | + pip install -e . --no-deps --force-reinstall + # Build the website + - name: Build the site + run: | + cd docs + make html + env: + ARM_USERNAME: ${{ secrets.ARM_USERNAME }} + ARM_PASSWORD: ${{ secrets.ARM_PASSWORD }} + AIRNOW_API: ${{ secrets.AIRNOW_API }} + # Push the book's HTML to github-pages + - name: GitHub Pages action + uses: peaceiris/actions-gh-pages@v3.8.0 + if: github.ref == 'refs/heads/main' + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: docs/build/html + cname: https://arm-doe.github.io/ACT/ diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000000..b478c72225 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,73 @@ +name: Run Unit Tests CI + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +# Cancel concurrent runs +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +env: + ARM_USERNAME: ${{ secrets.ARM_USERNAME }} + ARM_PASSWORD: ${{ secrets.ARM_PASSWORD }} + AIRNOW_API: ${{ secrets.AIRNOW_API }} + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + COVERALLS_TOKEN: ${{ secrets.COVERLALLS_REPO_TOKEN }} + +jobs: + build: + name: ${{ matrix.os }}-${{ matrix.python-version }} + if: github.repository == 'ARM-DOE/ACT' + runs-on: ${{ matrix.os }}-latest + defaults: + run: + shell: bash -l {0} + strategy: + fail-fast: false + matrix: + python-version: ["3.9", "3.10", "3.11", "3.12"] + os: [macOS, ubuntu, Windows] + inlcude: + - os: macos-latest + PLAT: arm64 + INTERFACE64: "" + platform: [x64] + + steps: + - uses: actions/checkout@v3 + + - name: Setup Conda Environment + uses: mamba-org/setup-micromamba@v1 + with: + create-args: python=${{ matrix.python-version }} + environment-file: ./continuous_integration/environment_actions.yml + environment-name: act_env + + - name: Install ACT + run: | + python -m pip install -e . --no-deps --force-reinstall + + - 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 + # Switching back to original flake + python -m flake8 --max-line-length=127 --ignore=F401,E402,W504,W605,F403 + - name: Test with pytest + run: | + python -m pytest -v --mpl --cov=./ --cov-report=xml + + - name: Upload code coverage to Codecov + uses: codecov/codecov-action@v2.1.0 + with: + file: ./coverage.xml + flags: unittests + env_vars: OS,PYTHON + name: codecov-umbrella + fail_ci_if_error: false diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml new file mode 100644 index 0000000000..c2fb38c867 --- /dev/null +++ b/.github/workflows/codeql-analysis.yml @@ -0,0 +1,74 @@ +# For most projects, this workflow file will not need changing; you simply need +# to commit it to your repository. +# +# You may wish to alter this file to override the set of languages analyzed, +# or to provide custom queries or build logic. +# +# ******** NOTE ******** +# We have attempted to detect the languages in your repository. Please check +# the `language` matrix defined below to confirm you have the correct set of +# supported CodeQL languages. +# +name: "CodeQL" + +on: + push: + branches: [ main ] + pull_request: + # The branches below must be a subset of the branches above + branches: [ main ] + schedule: + - cron: '42 7 * * 5' + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + analyze: + name: Analyze + runs-on: ubuntu-latest + permissions: + actions: read + contents: read + security-events: write + + strategy: + fail-fast: false + matrix: + language: [ 'python' ] + # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ] + # Learn more about CodeQL language support at https://git.io/codeql-language-support + + steps: + - name: Checkout repository + uses: actions/checkout@v3 + + # Initializes the CodeQL tools for scanning. + - name: Initialize CodeQL + uses: github/codeql-action/init@v1 + with: + languages: ${{ matrix.language }} + # If you wish to specify custom queries, you can do so here or in a config file. + # By default, queries listed here will override any specified in a config file. + # Prefix the list here with "+" to use these queries and those in the config file. + # queries: ./path/to/local/query, your-org/your-repo/queries@main + + # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). + # If this step fails, then you should remove it and run the build manually (see below) + - name: Autobuild + uses: github/codeql-action/autobuild@v1 + + # ℹī¸ Command-line programs to run using the OS shell. + # 📚 https://git.io/JvXDl + + # ✏ī¸ If the Autobuild fails above, remove it and uncomment the following three lines + # and modify them (or add more) to build your code if your project + # uses a compiled language + + #- run: | + # make bootstrap + # make release + + - name: Perform CodeQL Analysis + uses: github/codeql-action/analyze@v1 diff --git a/.github/workflows/pypi-release.yml b/.github/workflows/pypi-release.yml new file mode 100644 index 0000000000..a427a4b024 --- /dev/null +++ b/.github/workflows/pypi-release.yml @@ -0,0 +1,74 @@ +name: Build and Upload ACT Release to PyPI +on: + release: + types: + - published + +jobs: + build-artifacts: + runs-on: ubuntu-latest + if: github.repository == 'ARM-DOE/ACT' + steps: + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + - uses: actions/setup-python@v4 + name: Install Python + with: + python-version: 3.11 + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install setuptools setuptools-scm wheel twine check-manifest + - name: Build tarball and wheels + run: | + git clean -xdf + git restore -SW . + python -m build --sdist --wheel . + - name: Check built artifacts + run: | + python -m twine check dist/* + pwd + if [ -f dist/act-atmos-0.0.0.tar.gz ]; then + echo "❌ INVALID VERSION NUMBER" + exit 1 + else + echo "✅ Looks good" + fi + - uses: actions/upload-artifact@v3 + with: + name: releases + path: dist + + test-built-dist: + needs: build-artifacts + runs-on: ubuntu-latest + steps: + - uses: actions/setup-python@v4 + name: Install Python + with: + python-version: "3.x" + - uses: actions/download-artifact@v3 + with: + name: releases + path: dist + - name: List contents of built dist + run: | + ls -ltrh + ls -ltrh dist + upload-to-pypi: + needs: test-built-dist + if: github.event_name == 'release' + runs-on: ubuntu-latest + steps: + - uses: actions/download-artifact@v3 + with: + name: releases + path: dist + - name: Publish package to PyPI + uses: pypa/gh-action-pypi-publish@v1.8.10 + with: + user: __token__ + password: ${{ secrets.PYPI_TOKEN }} + verbose: true diff --git a/.gitignore b/.gitignore index 600ad1e64c..f4b26ec422 100644 --- a/.gitignore +++ b/.gitignore @@ -81,3 +81,23 @@ target/ # Files on local computer *.xml + +# Test files downloaded locally +**/bck_Radar_FMCW_Bright_Band/ +**/bck_Radar_FMCW_Moment/ +**/ctd_449RWP_Bright_Band/ +**/ctd_449RWP_Sub-Hour_Temp/ +**/ctd_449RWP_Sub-Hour_Wind/ +**/ctd_449RWP_Wind/ +**/ctd_915RWP_Sub-Hour_Temp/ +**/ctd_915RWP_Sub-Hour_Wind/ +**/ctd_915RWP_Temp/ +**/ctd_915RWP_Wind/ +**/ctd_GpsTrimble/ +**/ctd_Pressure/ +**/ctd_Radar_S-band_Bright_Band/ +**/ctd_Radar_S-band_Moment/ +**/kps_Radar_FMCW_Moment/ +**/BARR_DP1.00002.001/ +data/*ctd +act/tests/data/*stats* diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000000..16784b30d8 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,35 @@ +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.4.0 + hooks: + - id: trailing-whitespace + - id: end-of-file-fixer + - id: check-docstring-first + - id: check-json + - id: check-yaml + - id: double-quote-string-fixer + - id: debug-statements + - id: mixed-line-ending + + - repo: https://github.com/asottile/pyupgrade + rev: v3.3.1 + hooks: + - id: pyupgrade + args: + - '--py38-plus' + + - repo: https://github.com/psf/black + rev: 23.3.0 + hooks: + - id: black + - id: black-jupyter + + - repo: https://github.com/PyCQA/flake8 + rev: 6.0.0 + hooks: + - id: flake8 + + - repo: https://github.com/PyCQA/isort + rev: 5.12.0 + hooks: + - id: isort diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index e4bf8742e2..0000000000 --- a/.travis.yml +++ /dev/null @@ -1,31 +0,0 @@ -sudo: false -language: python -env: - global: - # Doctr deploy key for ARM-DOE/ACT - - secure: "hT9zNd40Rn45cDKKMiucnwDAjdXQJm86zWgr0fBV7mwe+kqHYk94NVtD5X6khkwkNSisYz+x9R4bK5eQV1o54S1rwhNDNIfLqMDW6lrtGEw/2YFXDKnzUYpWTx7zGa9agEZM7IM6UjYdDWa2E1KMq42rVTWUGuhQuYtA8vfAPUjAIRzJ8YvvVedlsnFHYnecGlszNiWTI+z/SIL0O6iGOlhXto4wbC+PpFiOoR8wAQSe+YqjjJxm4mmd13oIg6pxNEbIXx14BxlVnyS2FvpBJ3oMVuNrp2yk2EYew2s6gEfrGPxxrxpQnK8ugZGtsYmmMx9u5NRB140VIL3+kN82WuWn9NPPb4696I+nulmXpNxLQ6/J9E9DPQoRVb5OzT5DAyCnK0nU5jOxdqrTwP/FDc9uLZceyEYOnSF3bIcdu8oadkjspnu8h0vDOv2Zn1T2ViToNFvgLbkxm9IvgdgjwXmsyOrNRBCv9a73sHg3Y9XYvoz163QnyLTIXicYiPirreYQL/uHkRkqfaIEXB6ejtwPsr7fW0KXjSOCxkC9/NKFJa1LbFaw7NM+RBxUIi9Ic8dpgNbhedSXxDLuUYzlG4crZP8JacH58lzcyP5cUSlnLjcZ9WqTwg5Dbt2KV4bxMSUeRA3SybSbo3ojkHvtDTvjLCefHpjEFxaXzupkDvw=" - - -matrix: - include: - - python: 3.7 - env: - - PYTHON_VERSION="3.7" - - DOC_BUILD="true" - - python: 3.8 - sudo: yes - dist: xenial - env: - - PYTHON_VERSION="3.8" - - DOC_BUILD="true" -install: - - source continuous_integration/install.sh - - pip install pytest-cov - - pip install coveralls - - pip install metpy -script: - - eval xvfb-run pytest --mpl --cov=act/ --cov-config=.coveragerc - - flake8 --max-line-length=115 --ignore=F401,E402,W504,W605 -after_success: - - coveralls - - source continuous_integration/build_docs.sh; diff --git a/CODEOWNERS b/CODEOWNERS new file mode 100644 index 0000000000..a68ea45af3 --- /dev/null +++ b/CODEOWNERS @@ -0,0 +1,9 @@ +# https://help.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax + +# These owners will be the default owners for everything in +# the repo. Unless a later match takes precedence, + +* @AdamTheisen @zssherman @mgrover1 + +# any files in the intake_esm directory at the root of the +# repository and any of its subdirectories. diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000..34d17c1a21 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,129 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, religion, or sexual identity +and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Treating others with dignity and respect +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the + overall community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or + advances of any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email + address or phone number, without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +concerns@arm.gov. +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series +of actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or +permanent ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within +the community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.0, available at +https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. + +Community Impact Guidelines were inspired by [Mozilla's code of conduct +enforcement ladder](https://github.com/mozilla/diversity). + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see the FAQ at +https://www.contributor-covenant.org/faq. Translations are available at +https://www.contributor-covenant.org/translations. diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index d1c3eb158e..1c131a7c9d 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -66,11 +66,13 @@ to `act`. 4. Create or modified code so that it produces doc string and follows standards. -5. PEP8 check using flake8. +5. Install your `pre-commit ` hooks, by using `pre-commit install` -6. Local unit testing using Pytest. +6. Set up environment variables (Optional) -7. Commit your changes and push your branch to GitHub and submit a pull +7. Local unit testing using Pytest. + +8. Commit your changes and push your branch to GitHub and submit a pull request through the GitHub website. Fork and Cloning the ACT Repository @@ -128,7 +130,7 @@ To delete a branch both locally and remotely, if done with it:: git branch -d or in this case:: - + git push origin --delete wind_rose_plot git branch -d wind_rose_plot @@ -175,13 +177,13 @@ For example: .. code-block:: python - import glob - import os - - import numpy as np - import numpy.ma as ma + import glob + import os + + import numpy as np + import numpy.ma as ma - from .dataset import ACTAccessor + from .dataset import ACTAccessor Following the main function def line, but before the code within it, a doc string is needed to explain arguments, returns, references if needed, and @@ -196,38 +198,38 @@ An example: .. code-block:: python - def read_netcdf(filenames, variables=None): + def read_arm_netcdf(filenames, variables=None): - """ - Returns `xarray.Dataset` with stored data and metadata from a - user-defined query of standard netCDF files from a single - datastream. + """ + Returns `xarray.Dataset` with stored data and metadata from a + user-defined query of standard netCDF files from a single + datastream. - Parameters - ---------- - filenames : str or list - Name of file(s) to read - variables : list, optional - List of variable name(s) to read + Parameters + ---------- + filenames : str or list + Name of file(s) to read + variables : list, optional + List of variable name(s) to read - Returns - ------- - act_obj : Object - ACT dataset + Returns + ------- + act_obj : Object + ACT dataset - Examples - -------- - This example will load the example sounding data used for unit - testing. + Examples + -------- + This example will load the example sounding data used for unit + testing. - .. code-block:: python + .. code-block:: python - import act + import act - the_ds, the_flag = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE_WILDCARD) - print(the_ds.act.datastream) - """ + the_ds, the_flag = act.io.arm.read_arm_netcdf( + act.tests.sample_files.EXAMPLE_SONDE_WILDCARD) + print(the_ds.act.datastream) + """ As seen, each argument has what type of object it is, an explanation of what it is, mention of units, and if an argument has a default value, a @@ -239,8 +241,8 @@ An example: .. code-block:: python - def _get_value(self): - """ Gets a value that is used in a public function. """ + def _get_value(self): + """Gets a value that is used in a public function.""" Code Style ---------- @@ -268,7 +270,7 @@ To install pylint:: To use pylint:: - pylint path/to/code/to/check.py + pylint path/to/code/to/check.py Both of these tools are highly configurable to suit a user's taste. Refer to the tools documentation for details on this process. @@ -276,6 +278,51 @@ the tools documentation for details on this process. - https://flake8.pycqa.org/en/latest/ - https://www.pylint.org/ +Naming Convenction +---------------------------------------- + +Discovery +~~~~~~~~~ +When adding discovery modules or functions please adhere to the following +* Filenames should just include the name of the organization (arm) or portal (airnow) and no other filler words like get or download +* Functions should follow [get/download]_[org/portal]_[data/other description]. If it is getting data but not downloading a file, it should start with get, like get_asos_data. If it downloads a file, it should start with download. The other description can vary depending on what you are retrieving. Please check out the existing functions for ideas. + +IO +~~ +Similarly, for the io modules, the names should not have filler and just be the organization or portal name. The functions should clearly indicate what it is doing like read_arm_netcdf instead of read_netcdf if the function is specific to ARM files. + +Adding Secrets and Environment Variables +---------------------------------------- +In some cases, unit tests (as noted in the next section), need some username/password/token information +and that is not something that is good to make public. For these instances, it is recommended that users +set up environment variables for testing. The following environment variables should be set on the user's +local machine using the user's own credentials for all tests to run properly. + +Atmospheric Radiation Measurement User Facility - https://adc.arm.gov/armlive/ + + ARM_USERNAME + + ARM_PASSWORD + +Environmental Protection Agency AirNow - https://docs.airnowapi.org/ + + AIRNOW_API + +If adding tests that require new environment variables to be set, please reach out to the ACT development +team through the pull request. The ACT development team will need to do the following to ensure it works +properly when merged in. Note, due to security purposes these secrets are not available to the actions in +a pull request but will be available once merged it. + +1.) Add a GitHub Secret to ACT settings that's the same as that in the test file + +2.) Add this name to the "env" area of the GitHub Workflow yml files in .github/workflows/* + +3.) If the amount of code will impact the decrease in coverage during testing, update the threshold in coveralls + +4.) Upon merge, this should automatically pull in the secrets for the testing but there have been quirks. +Ensure that tests run properly + + Unit Testing ------------ @@ -293,21 +340,21 @@ An example: .. code-block:: python - import act - import numpy as np - import xarray as xr + import act + import numpy as np + import xarray as xr - def test_correct_ceil(): - # Make a fake dataset to test with, just an array with 1e-7 - # for half of it. - fake_data = 10 * np.ones((300, 20)) - fake_data[:, 10:] = -1 - arm_obj = {} - arm_obj['backscatter'] = xr.DataArray(fake_data) - arm_obj = act.corrections.ceil.correct_ceil(arm_obj) - assert np.all(arm_obj['backscatter'].data[:, 10:] == -7) - assert np.all(arm_obj['backscatter'].data[:, 1:10] == 1) + def test_correct_ceil(): + # Make a fake dataset to test with, just an array with 1e-7 + # for half of it. + fake_data = 10 * np.ones((300, 20)) + fake_data[:, 10:] = -1 + arm_obj = {} + arm_obj["backscatter"] = xr.DataArray(fake_data) + arm_obj = act.corrections.ceil.correct_ceil(arm_obj) + assert np.all(arm_obj["backscatter"].data[:, 10:] == -7) + assert np.all(arm_obj["backscatter"].data[:, 1:10] == 1) Pytest is used to run unit tests in ACT. @@ -343,7 +390,7 @@ filename is the filename and location, such as:: pytest /home/user/act/act/tests/test_correct.py Relative paths can also be used:: - + cd ACT pytest ./act/tests/test_correct.py @@ -351,6 +398,12 @@ For more on pytest: - https://docs.pytest.org/en/latest/ +Note: When testing ACT, the unit tests will download files from different +datastreams as part of the tests. These files will download to the directory +from where the tests were ran. These files will need to be added to the +.gitignore if they are in a location that isn't caught by the .gitignore. +More on using git can be seen below. + Adding Changes to GitHub ------------------------ diff --git a/LICENSE.txt b/LICENSE.txt index cb34cb5aa3..da1e3ba6fc 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,7 +1,7 @@ Copyright Š 2019, UChicago Argonne, LLC All Rights Reserved Software Name: Atmospheric data Community Toolkit (ACT) -By: Argonne National Laboratory, University of Oklahoma, and +By: Argonne National Laboratory, University of Oklahoma, and Oak Ridge National Laboratory OPEN SOURCE LICENSE diff --git a/MANIFEST.in b/MANIFEST.in index 65598ad098..0dbcb3a227 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -7,16 +7,17 @@ include LICENSE.txt recursive-exclude * __pycache__ recursive-exclude * *.py[co] -recursive-include act/plotting *.txt +recursive-include act/plotting *.txt +recursive-include tests *.py *.png recursive-include docs *.rst conf.py Makefile make.bat -recursive-include act/tests/data * - include versioneer.py include act/_version.py include act/utils/conf/de421.bsp +include act/io/conf/*.yaml + # If including data files in the package, add them like: # include path/to/data_file diff --git a/README.rst b/README.rst index dd5b65ad8e..d828e20b3c 100644 --- a/README.rst +++ b/README.rst @@ -1,153 +1,195 @@ -======================================== -Atmospheric data Community Toolkit (ACT) -======================================== - -|AnacondaCloud| |Travis| |Coveralls| - -|CondaDownloads| |Zenodo| |ARM| - -.. |AnacondaCloud| image:: https://anaconda.org/conda-forge/act-atmos/badges/version.svg - :target: https://anaconda.org/conda-forge/act-atmos - -.. |CondaDownloads| image:: https://anaconda.org/conda-forge/act-atmos/badges/downloads.svg - :target: https://anaconda.org/conda-forge/act-atmos/files - -.. |Travis| image:: https://img.shields.io/travis/ARM-DOE/ACT.svg - :target: https://travis-ci.org/ARM-DOE/ACT - -.. |Zenodo| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.3855537.svg - :target: https://doi.org/10.5281/zenodo.3855537 - -.. |Coveralls| image:: https://coveralls.io/repos/github/ARM-DOE/ACT/badge.svg - :target: https://coveralls.io/github/ARM-DOE/ACT - -.. |ARM| image:: https://img.shields.io/badge/Sponsor-ARM-blue.svg?colorA=00c1de&colorB=00539c - :target: https://www.arm.gov/ - - -The Atmospheric data Community Toolkit (ACT) is an open source Python toolkit for working with atmospheric time-series datasets of varying dimensions. The toolkit is meant to have functions for every part of the scientific process; discovery, IO, quality control, corrections, retrievals, visualization, and analysis. It is meant to be a community platform for sharing code with the goal of reducing duplication of effort and better connecting the science community with programs such as the `Atmospheric Radiation Measurement (ARM) User Facility `_. Overarching development goals will be updated on a regular basis as part of the `Roadmap `_ . - -|act| - -.. |act| image:: ./docs/source/act_plots.png - -Important Links -~~~~~~~~~~~~~~~ - -* Documentation: https://arm-doe.github.io/ACT/ -* Examples: https://arm-doe.github.io/ACT/source/auto_examples/index.html -* Issue Tracker: https://github.com/ARM-DOE/ACT/issues - -Citing -~~~~~~ - -If you use ACT to prepare a publication, please cite the DOI listed in the badge above, which is updated with every version release to ensure that contributors get appropriate credit. DOI is provided through Zenodo. - -Dependencies -~~~~~~~~~~~~ - -* `xarray `_ -* `NumPy `_ -* `SciPy `_ -* `matplotlib `_ -* `skyfield `_ -* `pandas `_ -* `dask `_ -* `Pint `_ -* `PyProj `_ -* `Proj `_ -* `Six `_ -* `Requests `_ - -Optional Dependencies -~~~~~~~~~~~~~~~~~~~~~ - -* `MPL2NC `_ Reading binary MPL data. -* `Cartopy `_ Mapping and geoplots -* `MetPy `_ >= V1.0 Skew-T plotting and some stabilities indices calculations - -Installation -~~~~~~~~~~~~ - -ACT can be installed a few different ways. One way is to install using pip. -When installing with pip, the ACT dependencies found in -`requirements.txt `_ will also be installed. To install using pip:: - - pip install act-atmos - -The easiest method for installing ACT is to use the conda packages from -the latest release. To do this you must download and install -`Anaconda `_ or -`Miniconda `_. -With Anaconda or Miniconda install, it is recommended to create a new conda -environment when using ACT or even other packages. To create a new -environment based on the `environment.yml `_:: - - conda env create -f environment.yml - -Or for a basic environment and downloading optional dependencies as needed:: - - conda create -n act_env -c conda-forge python=3.7 act-atmos - -Basic command in a terminal or command prompt to install the latest version of -ACT:: - - conda install -c conda-forge act-atmos - -To update an older version of ACT to the latest release use:: - - conda update -c conda-forge act-atmos - -If you do not wish to use Anaconda or Miniconda as a Python environment or want -to use the latest, unreleased version of ACT see the section below on -**Installing from source**. - -Installing from Source -~~~~~~~~~~~~~~~~~~~~~~ - -Installing ACT from source is the only way to get the latest updates and -enhancement to the software that have no yet made it into a release. -The latest source code for ACT can be obtained from the GitHub repository, -https://github.com/ARM-DOE/ACT. Either download and unpack the -`zip file `_ of -the source code or use git to checkout the repository:: - - git clone https://github.com/ARM-DOE/ACT.git - -To install in your home directory, use:: - - python setup.py install --user - -To install for all users on Unix/Linux:: - - python setup.py build - sudo python setup.py install - -Contributing -~~~~~~~~~~~~ - -ACT is an open source, community software project. Contributions to the -package are welcomed from all users. - -The latest source code can be obtained with the command:: - - git clone https://github.com/ARM-DOE/ACT.git - -If you are planning on making changes that you would like included in ACT, -forking the repository is highly recommended. - -We welcome contributions for all uses of ACT, provided the code can be -distributed under the BSD 3-clause license. A copy of this license is -available in the **LICENSE.txt** file in this directory. For more on -contributing, see the `contributor's guide. `_ - -Testing -~~~~~~~ - -After installation, you can launch the test suite from outside the -source directory (you will need to have pytest installed):: - - $ pytest --mpl --pyargs act - -In-place installs can be tested using the `pytest` command from within -the source directory. +======================================== +Atmospheric data Community Toolkit (ACT) +======================================== + +|AnacondaCloud| |CodeCovStatus| |Build| |Docs| + +|CondaDownloads| |Zenodo| |ARM| + +.. |AnacondaCloud| image:: https://anaconda.org/conda-forge/act-atmos/badges/version.svg + :target: https://anaconda.org/conda-forge/act-atmos + +.. |CondaDownloads| image:: https://anaconda.org/conda-forge/act-atmos/badges/downloads.svg + :target: https://anaconda.org/conda-forge/act-atmos/files + +.. |Zenodo| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.3855537.svg + :target: https://doi.org/10.5281/zenodo.3855537 + +.. |CodeCovStatus| image:: https://codecov.io/gh/ARM-DOE/ACT/branch/main/graph/badge.svg + :target: https://codecov.io/gh/ARM-DOE/ACT + +.. |ARM| image:: https://img.shields.io/badge/Sponsor-ARM-blue.svg?colorA=00c1de&colorB=00539c + :target: https://www.arm.gov/ + +.. |Docs| image:: https://github.com/ARM-DOE/ACT/actions/workflows/build-docs.yml/badge.svg + :target: https://github.com/ARM-DOE/ACT/actions/workflows/build-docs.yml + +.. |Build| image:: https://github.com/ARM-DOE/ACT/actions/workflows/ci.yml/badge.svg + :target: https://github.com/ARM-DOE/ACT/actions/workflows/ci.yml + +The Atmospheric data Community Toolkit (ACT) is an open source Python toolkit for working with atmospheric time-series datasets of varying dimensions. The toolkit has functions for every part of the scientific process; discovery, IO, quality control, corrections, retrievals, visualization, and analysis. It is a community platform for sharing code with the goal of reducing duplication of effort and better connecting the science community with programs such as the `Atmospheric Radiation Measurement (ARM) User Facility `_. Overarching development goals will be updated on a regular basis as part of the `Roadmap `_ . + +|act| + +.. |act| image:: ./docs/source/act_plots.png + +Please report any issues or feature requests by sumitting an `Issue `_. Additionally, our `discussions boards `_ are open for ideas, general discussions or questions, and show and tell! + +Version 2.0 +~~~~~~~~~~~ + +ACT will soon have a version 2.0 release. This release will contain many function +naming changes such as IO and Discovery module function naming changes. To +prepare for this release, a `v2.0 `_ +has been provided that explains the changes and how to work with the new syntax. + +To test out the release candidate 2.0.0-rc.0 of ACT, use:: + + pip install git+https://github.com/ARM-DOE/ACT.git@v2.0.0-rc.0 + +Please report any bugs of the release candidate to the Issue Tracker mentioned in +the Important Links section below. + +Important Links +~~~~~~~~~~~~~~~ + +* Documentation: https://arm-doe.github.io/ACT/ +* Examples: https://arm-doe.github.io/ACT/source/auto_examples/index.html +* Issue Tracker: https://github.com/ARM-DOE/ACT/issues + +Citing +~~~~~~ + +If you use ACT to prepare a publication, please cite the DOI listed in the badge above, which is updated with every version release to ensure that contributors get appropriate credit. DOI is provided through Zenodo. + +Dependencies +~~~~~~~~~~~~ + +* `xarray `_ +* `NumPy `_ +* `SciPy `_ +* `matplotlib `_ +* `skyfield `_ +* `pandas `_ +* `dask `_ +* `Pint `_ +* `PyProj `_ +* `Six `_ +* `Requests `_ +* `MetPy `_ +* `ffspec `_ +* `lazy_loader `_ +* `cmweather `_ + +Optional Dependencies +~~~~~~~~~~~~~~~~~~~~~ + +* `MPL2NC `_ Reading binary MPL data. +* `Cartopy `_ Mapping and geoplots +* `Py-ART `_ Reading radar files, plotting and corrections +* `scikit-posthocs `_ Using interquartile range or generalized Extreme Studentized Deviate quality control tests +* `icartt `_ icartt is an ICARTT file format reader and writer for Python +* `PySP2 `_ PySP2 is a python package for reading and processing Single Particle Soot Photometer (SP2) datasets. +* `MoviePy `_ MoviePy is a python package for creating movies from images + +Installation +~~~~~~~~~~~~ + +ACT can be installed a few different ways. One way is to install using pip. +When installing with pip, the ACT dependencies found in +`requirements.txt `_ will also be installed. To install using pip:: + + pip install act-atmos + +The easiest method for installing ACT is to use the conda packages from +the latest release. To do this you must download and install +`Anaconda `_ or +`Miniconda `_. +With Anaconda or Miniconda install, it is recommended to create a new conda +environment when using ACT or even other packages. To create a new +environment based on the `environment.yml `_:: + + conda env create -f environment.yml + +Or for a basic environment and downloading optional dependencies as needed:: + + conda create -n act_env -c conda-forge python=3.12 act-atmos + +Basic command in a terminal or command prompt to install the latest version of +ACT:: + + conda install -c conda-forge act-atmos + +To update an older version of ACT to the latest release use:: + + conda update -c conda-forge act-atmos + +If you are using mamba:: + + mamba install -c conda-forge act-atmos + +If you do not wish to use Anaconda or Miniconda as a Python environment or want +to use the latest, unreleased version of ACT see the section below on +**Installing from source**. + +Installing from Source +~~~~~~~~~~~~~~~~~~~~~~ + +Installing ACT from source is the only way to get the latest updates and +enhancement to the software that have no yet made it into a release. +The latest source code for ACT can be obtained from the GitHub repository, +https://github.com/ARM-DOE/ACT. Either download and unpack the +`zip file `_ of +the source code or use git to checkout the repository:: + + git clone https://github.com/ARM-DOE/ACT.git + +To install in your home directory, use:: + + python setup.py install --user + +To install for all users on Unix/Linux:: + + python setup.py build + sudo python setup.py install + +Development install using pip from within the ACT directory:: + + pip install -e . + +Contributing +~~~~~~~~~~~~ + +ACT is an open source, community software project. Contributions to the +package are welcomed from all users. + +The latest source code can be obtained with the command:: + + git clone https://github.com/ARM-DOE/ACT.git + +If you are planning on making changes that you would like included in ACT, +forking the repository is highly recommended. + +We welcome contributions for all uses of ACT, provided the code can be +distributed under the BSD 3-clause license. A copy of this license is +available in the **LICENSE.txt** file in this directory. For more on +contributing, see the `contributor's guide. `_ + +Testing +~~~~~~~ +For testing, we use pytest. To install pytest:: + + $ conda install -c conda-forge pytest + +And for matplotlib image testing with pytest:: + + $ conda install -c conda-forge pytest-mpl + +After installation, you can launch the test suite from outside the +source directory (you will need to have pytest installed and for the mpl +argument need pytest-mpl):: + + $ pytest --mpl --pyargs act + +In-place installs can be tested using the `pytest` command from within +the source directory. diff --git a/act/__init__.py b/act/__init__.py index 0e639db88a..81ae36fd04 100644 --- a/act/__init__.py +++ b/act/__init__.py @@ -1,20 +1,34 @@ -from . import io -from . import plotting -from . import corrections -from . import utils -from . import tests -from . import discovery -from . import retrievals -from . import qc -from ._version import get_versions +""" +ACT: The Atmospheric Community Toolkit +====================================== + +""" + +import lazy_loader as lazy # No more pandas warnings from pandas.plotting import register_matplotlib_converters + +from ._version import get_versions + register_matplotlib_converters() +# Import early so these classes are available to the object +from .qc import QCFilter, QCTests, clean + +# Import the lazy loaded modules +submodules = [ + 'corrections', + 'discovery', + 'io', + 'qc', + 'utils', + 'retrievals', + 'plotting', + 'tests', +] +__getattr__, __dir__, _ = lazy.attach(__name__, submodules) + # Version for source builds vdict = get_versions() -__version__ = vdict["version"] - -# Version for releases -# __version__ = "0.1" +__version__ = vdict['version'] diff --git a/act/_version.py b/act/_version.py index 4acef3125f..7ccbb4bb48 100644 --- a/act/_version.py +++ b/act/_version.py @@ -1,4 +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 @@ -23,10 +22,10 @@ def get_keywords(): # 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} + git_refnames = '$Format:%d$' + git_full = '$Format:%H$' + git_date = '$Format:%ci$' + keywords = {'refnames': git_refnames, 'full': git_full, 'date': git_date} return keywords @@ -39,11 +38,11 @@ def get_config(): # these strings are filled in when 'setup.py versioneer' creates # _version.py cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "pep440-post" - cfg.tag_prefix = "v" - cfg.parentdir_prefix = "None" - cfg.versionfile_source = "act/_version.py" + cfg.VCS = 'git' + cfg.style = 'pep440-post' + cfg.tag_prefix = 'v' + cfg.parentdir_prefix = 'None' + cfg.versionfile_source = 'act/_version.py' cfg.verbose = False return cfg @@ -58,17 +57,18 @@ class NotThisMethod(Exception): 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): +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 @@ -76,30 +76,33 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, 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)) + p = subprocess.Popen( + [c] + args, + cwd=cwd, + env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr else None), + ) break - except EnvironmentError: + except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: - print("unable to run %s" % dispcmd) + print('unable to run %s' % dispcmd) print(e) return None, None else: if verbose: - print("unable to find command, tried %s" % (commands,)) + print(f'unable to find command, tried {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) + print('unable to run %s (error)' % dispcmd) + print('stdout was %s' % stdout) return None, p.returncode return stdout, p.returncode @@ -116,20 +119,26 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): 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} + 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)) + 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") +@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 @@ -138,32 +147,32 @@ def git_get_keywords(versionfile_abs): # _version.py. keywords = {} try: - f = open(versionfile_abs, "r") + f = open(versionfile_abs) for line in f.readlines(): - if line.strip().startswith("git_refnames ="): + 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 ="): + 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 ="): + keywords['full'] = mo.group(1) + if line.strip().startswith('git_date ='): mo = re.search(r'=\s*"(.*)"', line) if mo: - keywords["date"] = mo.group(1) + keywords['date'] = mo.group(1) f.close() - except EnvironmentError: + except OSError: pass return keywords -@register_vcs_handler("git", "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") + 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 @@ -171,17 +180,17 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # 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"): + 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(",")]) + print('keywords are unexpanded, not using') + raise NotThisMethod('unexpanded keywords, not a git-archive tarball') + refs = {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)]) + TAG = 'tag: ' + tags = {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 @@ -190,30 +199,37 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # 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)]) + tags = {r for r in refs if re.search(r'\d', r)} if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) + print("discarding '%s', no digits" % ','.join(refs - tags)) if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) + 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):] + 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} + 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} + 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") +@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. @@ -221,56 +237,63 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): 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"] + 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) + 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) + 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) + 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) + 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 + 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 + dirty = git_describe.endswith('-dirty') + pieces['dirty'] = dirty if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] + git_describe = git_describe[: git_describe.rindex('-dirty')] # now we have TAG-NUM-gHEX or HEX - if "-" in git_describe: + 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) + pieces['error'] = "unable to parse git-describe output: '%s'" % describe_out return pieces # tag @@ -279,37 +302,37 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): 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)) + pieces['error'] = "tag '{}' doesn't start with prefix '{}'".format( + full_tag, + tag_prefix, + ) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] + pieces['closest-tag'] = full_tag[len(tag_prefix) :] # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) + pieces['distance'] = int(mo.group(2)) # commit: short hex revision ID - pieces["short"] = mo.group(3) + 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 + 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) + 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 "+" + if '+' in pieces.get('closest-tag', ''): + return '.' + return '+' def render_pep440(pieces): @@ -321,19 +344,18 @@ def render_pep440(pieces): 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"]: + 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" + 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" + rendered = '0+untagged.%d.g%s' % (pieces['distance'], pieces['short']) + if pieces['dirty']: + rendered += '.dirty' return rendered @@ -343,13 +365,13 @@ def render_pep440_pre(pieces): Exceptions: 1: no tags. 0.post.devDISTANCE """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] + 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"] + rendered = '0.post.dev%d' % pieces['distance'] return rendered @@ -363,20 +385,20 @@ def render_pep440_post(pieces): 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" + 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"] + rendered += 'g%s' % pieces['short'] else: # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] + rendered = '0.post%d' % pieces['distance'] + if pieces['dirty']: + rendered += '.dev0' + rendered += '+g%s' % pieces['short'] return rendered @@ -388,17 +410,17 @@ def render_pep440_old(pieces): 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" + 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" + rendered = '0.post%d' % pieces['distance'] + if pieces['dirty']: + rendered += '.dev0' return rendered @@ -410,15 +432,15 @@ def render_git_describe(pieces): 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"]) + 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" + rendered = pieces['short'] + if pieces['dirty']: + rendered += '-dirty' return rendered @@ -431,47 +453,53 @@ def render_git_describe_long(pieces): 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"]) + 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" + 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": + 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": + elif style == 'pep440-pre': rendered = render_pep440_pre(pieces) - elif style == "pep440-post": + elif style == 'pep440-post': rendered = render_pep440_post(pieces) - elif style == "pep440-old": + elif style == 'pep440-old': rendered = render_pep440_old(pieces) - elif style == "git-describe": + elif style == 'git-describe': rendered = render_git_describe(pieces) - elif style == "git-describe-long": + 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")} + return { + 'version': rendered, + 'full-revisionid': pieces['long'], + 'dirty': pieces['dirty'], + 'error': None, + 'date': pieces.get('date'), + } def get_versions(): @@ -485,8 +513,7 @@ def get_versions(): verbose = cfg.verbose try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) + return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) except NotThisMethod: pass @@ -498,10 +525,13 @@ def get_versions(): 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} + 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) @@ -515,6 +545,10 @@ def get_versions(): except NotThisMethod: pass - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} + return { + 'version': '0+unknown', + 'full-revisionid': None, + 'dirty': None, + 'error': 'unable to compute version', + 'date': None, + } diff --git a/act/config.py b/act/config.py new file mode 100644 index 0000000000..361d3fc854 --- /dev/null +++ b/act/config.py @@ -0,0 +1,13 @@ +""" +Configuration file for the Python Atmospheric data Community Toolkit (ACT) +The values for a number of ACT parameters and the default metadata created +when reading files, correcting fields, etc. is controlled by this single +Python configuration file. + +Examples: +--------- +from act.config import DEFAULT_DATASTREAM_NAME + +""" + +DEFAULT_DATASTREAM_NAME = 'act_datastream' diff --git a/act/corrections/__init__.py b/act/corrections/__init__.py index a4f0d6eafa..611f83116f 100644 --- a/act/corrections/__init__.py +++ b/act/corrections/__init__.py @@ -1,24 +1,18 @@ """ -================================= -act.corrections (act.corrections) -================================= - -.. currentmodule:: act.corrections - The procedures in this module contain corrections for various datasets. -.. autosummary:: - :toctree: generated/ - - ceil.correct_ceil - doppler_lidar.correct_dl - mpl.correct_mpl - raman_lidar.correct_rl - ship.correct_wind """ -from . import ceil -from . import mpl -from . import ship -from . import doppler_lidar -from . import raman_lidar +import lazy_loader as lazy + +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=['ceil', 'doppler_lidar', 'mpl', 'raman_lidar', 'ship'], + submod_attrs={ + 'ceil': ['correct_ceil'], + 'doppler_lidar': ['correct_dl'], + 'mpl': ['correct_mpl'], + 'raman_lidar': ['correct_rl'], + 'ship': ['correct_wind'], + }, +) diff --git a/act/corrections/ceil.py b/act/corrections/ceil.py index fc5aeda95c..0654f06db9 100644 --- a/act/corrections/ceil.py +++ b/act/corrections/ceil.py @@ -1,9 +1,11 @@ -""" Functions for correcting ceilometer data. """ +""" +This module contains functions for correcting ceilometer data +""" import numpy as np -def correct_ceil(obj, fill_value=1e-7, var_name='backscatter'): +def correct_ceil(ds, fill_value=1e-7, var_name='backscatter'): """ This procedure corrects ceilometer data by filling all zero and negative values of backscatter with fill_value and then converting @@ -11,24 +13,28 @@ def correct_ceil(obj, fill_value=1e-7, var_name='backscatter'): Parameters ---------- - obj : Dataset object + ds : xarray.Dataset The ceilometer dataset to correct. The backscatter data should be in linear space. var_name : str - The variable name of data in the object. + The variable name of data in the dataset. fill_value : float The fill_value to use. The fill_value is entered in linear space. Returns ------- - obj : Dataset object + ds : xarray.Dataset The ceilometer dataset containing the corrected values. """ - backscat = obj[var_name].data - backscat[backscat <= 0] = fill_value - backscat = np.log10(backscat) + data = ds[var_name].data + data[data <= 0] = fill_value + data = np.log10(data) - obj[var_name].data = backscat + ds[var_name].values = data + if 'units' in ds[var_name].attrs: + ds[var_name].attrs['units'] = 'log(' + ds[var_name].attrs['units'] + ')' + else: + ds[var_name].attrs['units'] = 'log(unknown)' - return obj + return ds diff --git a/act/corrections/doppler_lidar.py b/act/corrections/doppler_lidar.py index 2c42fe8ebd..72b8e14e37 100644 --- a/act/corrections/doppler_lidar.py +++ b/act/corrections/doppler_lidar.py @@ -1,10 +1,11 @@ -""" Functions for correction doppler lidar data. """ +""" +This module contains functions for correcting doppler lidar data +""" import numpy as np -def correct_dl(obj, var_name='attenuated_backscatter', range_normalize=True, - fill_value=1e-7): +def correct_dl(ds, var_name='attenuated_backscatter', range_normalize=True, fill_value=1e-7): """ This procedure corrects doppler lidar data by filling all zero and negative values of backscatter with fill_value and then converting @@ -13,11 +14,11 @@ def correct_dl(obj, var_name='attenuated_backscatter', range_normalize=True, Parameters ---------- - obj : Dataset object + ds : xarray.Dataset The doppler lidar dataset to correct. The backscatter data should be in linear space. var_name : str - The variable name of data in the object. + The variable name of data in the dataset. range_normalize : bool Option to range normalize the data. fill_value : float @@ -25,29 +26,27 @@ def correct_dl(obj, var_name='attenuated_backscatter', range_normalize=True, Returns ------- - obj : Dataset object + ds : xarray.Dataset The doppler lidar dataset containing the corrected values. """ - backscat = obj[var_name].values + data = ds[var_name].values if range_normalize: # This will get the name of the coordinate dimension so it's not assumed # via position or name - height_name = list(set(obj[var_name].dims) - set(['time']))[0] - height = obj[height_name].values - + height_name = list(set(ds[var_name].dims) - {'time'})[0] + height = ds[height_name].values height = height / np.max(height) + data = data * height**2 - backscat = backscat * height ** 2 - - backscat[backscat <= 0] = fill_value - obj[var_name].values = np.log10(backscat) + data[data <= 0] = fill_value + ds[var_name].values = np.log10(data) # Updating the units to correctly indicate the values are log values if range_normalize: - obj[var_name].attrs['units'] = 'log( Range normalized ' + obj[var_name].attrs['units'] + ')' + ds[var_name].attrs['units'] = 'log( Range normalized ' + ds[var_name].attrs['units'] + ')' else: - obj[var_name].attrs['units'] = 'log(' + obj[var_name].attrs['units'] + ')' + ds[var_name].attrs['units'] = 'log(' + ds[var_name].attrs['units'] + ')' - return obj + return ds diff --git a/act/corrections/mpl.py b/act/corrections/mpl.py index 096177c7b1..73e2616df1 100644 --- a/act/corrections/mpl.py +++ b/act/corrections/mpl.py @@ -1,19 +1,25 @@ -""" Functions for correcting MPL data. """ +""" +This module contains corrections for micropulse lidars + +""" +import warnings import numpy as np import xarray as xr -import warnings -def correct_mpl(obj, co_pol_var_name='signal_return_co_pol', - cross_pol_var_name='signal_return_cross_pol', - co_pol_afterpuls_var_name='afterpulse_correction_co_pol', - cross_pol_afterpulse_var_name='afterpulse_correction_cross_pol', - overlap_corr_var_name='overlap_correction', - overlap_corr_heights_var_name='overlap_correction_heights', - range_bins_var_name='range_bins', - height_var_name='height', - ratio_var_name='cross_co_ratio'): +def correct_mpl( + ds, + co_pol_var_name='signal_return_co_pol', + cross_pol_var_name='signal_return_cross_pol', + co_pol_afterpuls_var_name='afterpulse_correction_co_pol', + cross_pol_afterpulse_var_name='afterpulse_correction_cross_pol', + overlap_corr_var_name='overlap_correction', + overlap_corr_heights_var_name='overlap_correction_heights', + range_bins_var_name='range_bins', + height_var_name='height', + ratio_var_name='cross_co_ratio', +): """ This procedure corrects MPL data: 1.) Throw out data before laser firing (heights < 0). @@ -35,14 +41,14 @@ def correct_mpl(obj, co_pol_var_name='signal_return_co_pol', Parameters ---------- - obj : Xarray Dataset - The ACT Xarray Dataset containg data + ds : xarray.Dataset + The Xarray Dataset containing data co_pol_var_name : str The Co-polar variable name used in Dataset cross_pol_var_name : str The Cross-polar variable name used in Dataset co_pol_afterpuls_var_name : str - The Co-polar after pluse variable name used in Dataset + The Co-polar after pulse variable name used in Dataset cross_pol_afterpulse_var_name : str The Cross-polar afterpulse variable name used in Dataset overlap_corr_var_name : str @@ -59,72 +65,74 @@ def correct_mpl(obj, co_pol_var_name='signal_return_co_pol', Returns ------- - obj : Xarray Dataset - The ACT Object containing the corrected values. The orginal Xarray Dataset + ds : xarray.Dataset + Xarray dataset containing the corrected values. The original Xarray Dataset passed in is modified. """ - data_dims = obj[co_pol_var_name].dims + data_dims = ds[co_pol_var_name].dims # Overlap Correction Variable - op = obj[overlap_corr_var_name].values + op = ds[overlap_corr_var_name].values if len(op.shape) > 1: op = op[0, :] - op_height = obj[overlap_corr_heights_var_name].values + op_height = ds[overlap_corr_heights_var_name].values if len(op_height.shape) > 1: op_height = op_height[0, :] - # Check if height has dimentionality of time and height. If so reduce height - # to only dimentionality of height in object before removing values less than 0. - if len(obj[height_var_name].shape) > 1: - reduce_dim_name = {'time'} & set(obj[height_var_name].dims) - obj[height_var_name] = obj[height_var_name].reduce( - func=np.median, dim=reduce_dim_name, keep_attrs=True) + # Check if height has dimentionality of time and height. If so reduce + # height to only dimentionality of height in the dataset before removing + # values less than 0. + if len(ds[height_var_name].shape) > 1: + reduce_dim_name = {'time'} & set(ds[height_var_name].dims) + ds[height_var_name] = ds[height_var_name].reduce( + func=np.median, dim=reduce_dim_name, keep_attrs=True + ) # 1 - Remove negative height data - obj = obj.where(obj[height_var_name] > 0., drop=True) - height = obj[height_var_name].values + ds = ds.where(ds[height_var_name].load() > 0.0, drop=True) + height = ds[height_var_name].values # Get indices for calculating background - if len(obj.height.shape) > 1: - ind = [obj.height.shape[1] - 50, obj.height.shape[1] - 2] + if len(ds.height.shape) > 1: + ind = [ds.height.shape[1] - 50, ds.height.shape[1] - 2] else: - ind = [obj.height.shape[0] - 50, obj.height.shape[0] - 2] + ind = [ds.height.shape[0] - 50, ds.height.shape[0] - 2] # Subset last gates into new dataset - dummy = obj.isel(range_bins=xr.DataArray(np.arange(ind[0], ind[1]))) + dummy = ds.isel(range_bins=xr.DataArray(np.arange(ind[0], ind[1]))) # Turn off warnings - warnings.filterwarnings("ignore") + warnings.filterwarnings('ignore') # Run through co and cross pol data for corrections co_bg = dummy[co_pol_var_name] - co_bg = co_bg.where(co_bg > -9998.) + co_bg = co_bg.where(co_bg.load() > -9998.0) co_bg = co_bg.mean(dim='dim_0').values x_bg = dummy[cross_pol_var_name] - x_bg = x_bg.where(x_bg > -9998.) + x_bg = x_bg.where(x_bg.load() > -9998.0) x_bg = x_bg.mean(dim='dim_0').values # Seems to be the fastest way of removing background signal at the moment - co_data = obj[co_pol_var_name].where(obj[co_pol_var_name] > 0).values - x_data = obj[cross_pol_var_name].where(obj[cross_pol_var_name] > 0).values - for i in range(len(obj['time'].values)): + co_data = ds[co_pol_var_name].where(ds[co_pol_var_name].load() > 0).values + x_data = ds[cross_pol_var_name].where(ds[cross_pol_var_name].load() > 0).values + for i in range(len(ds['time'].values)): co_data[i, :] = co_data[i, :] - co_bg[i] x_data[i, :] = x_data[i, :] - x_bg[i] # After Pulse Correction Variable - co_ap = obj[co_pol_afterpuls_var_name].values + co_ap = ds[co_pol_afterpuls_var_name].values # Fix dimentionality if backwards - co_ap_dims = obj[co_pol_afterpuls_var_name].dims + co_ap_dims = ds[co_pol_afterpuls_var_name].dims if len(co_ap_dims) > 1 and co_ap_dims[::-1] == data_dims: co_ap = np.transpose(co_ap) - x_ap = obj[cross_pol_afterpulse_var_name].values + x_ap = ds[cross_pol_afterpulse_var_name].values # Fix dimentionality if backwards - x_ap_dims = obj[cross_pol_afterpulse_var_name].dims + x_ap_dims = ds[cross_pol_afterpulse_var_name].dims if len(x_ap_dims) > 1 and x_ap_dims[::-1] == data_dims: x_ap = np.transpose(x_ap) @@ -137,7 +145,7 @@ def correct_mpl(obj, co_pol_var_name='signal_return_co_pol', x_data = x_data * height ** 2 # Overlap Correction - for j in range(obj[range_bins_var_name].size): + for j in range(ds[range_bins_var_name].size): if len(height.shape) > 1: idx = (np.abs(op_height - height[0, j])).argmin() else: @@ -149,26 +157,26 @@ def correct_mpl(obj, co_pol_var_name='signal_return_co_pol', # Create the co/cross ratio variable if ratio_var_name is not None: - ratio = (x_data / (x_data + co_data)) * 100. - obj[ratio_var_name] = obj[co_pol_var_name].copy(data=ratio) - obj[ratio_var_name].attrs['long_name'] = 'Cross-pol / Co-pol ratio * 100' - obj[ratio_var_name].attrs['units'] = 'LDR' + ratio = (x_data / (x_data + co_data)) * 100.0 + ds[ratio_var_name] = ds[co_pol_var_name].copy(data=ratio) + ds[ratio_var_name].attrs['long_name'] = 'Cross-pol / Co-pol ratio * 100' + ds[ratio_var_name].attrs['units'] = '1' try: - del obj[ratio_var_name].attrs['ancillary_variables'] - del obj[ratio_var_name].attrs['description'] + del ds[ratio_var_name].attrs['ancillary_variables'] + del ds[ratio_var_name].attrs['description'] except KeyError: pass # Convert data to decibels - co_data = 10. * np.log10(co_data) - x_data = 10. * np.log10(x_data) + co_data = 10.0 * np.log10(co_data) + x_data = 10.0 * np.log10(x_data) - # Write data to object - obj[co_pol_var_name].values = co_data - obj[cross_pol_var_name].values = x_data + # Write data to Xarray dataset + ds[co_pol_var_name].values = co_data + ds[cross_pol_var_name].values = x_data # Update units - obj[co_pol_var_name].attrs['units'] = f"10 * log10({obj[co_pol_var_name].attrs['units']})" - obj[cross_pol_var_name].attrs['units'] = f"10 * log10({obj[cross_pol_var_name].attrs['units']})" + ds[co_pol_var_name].attrs['units'] = f"10 * log10({ds[co_pol_var_name].attrs['units']})" + ds[cross_pol_var_name].attrs['units'] = f"10 * log10({ds[cross_pol_var_name].attrs['units']})" - return obj + return ds diff --git a/act/corrections/raman_lidar.py b/act/corrections/raman_lidar.py index 80bb091e0e..f2cd61b047 100644 --- a/act/corrections/raman_lidar.py +++ b/act/corrections/raman_lidar.py @@ -1,10 +1,16 @@ -""" Functions for correcting raman lidar data. """ +""" +This module contains functions for correcting raman lidar data +""" import numpy as np -def correct_rl(obj, var_name='depolarization_counts_high', fill_value=1e-7, - range_normalize_log_values=False): +def correct_rl( + ds, + var_name='depolarization_counts_high', + fill_value=1e-7, + range_normalize_log_values=False, +): """ This procedure corrects raman lidar data by filling all zero and negative values of backscatter with fill_value and then converting @@ -14,11 +20,11 @@ def correct_rl(obj, var_name='depolarization_counts_high', fill_value=1e-7, Parameters ---------- - obj : Dataset object + ds : xarray.Dataset The doppler lidar dataset to correct. The backscatter data should be in linear space. var_name : str - The variable name of data in the object. + The variable name of data in the dataset. fill_value : float The fill_value to use. The fill_value is entered in linear space. range_normalize_log_values : boolean @@ -26,50 +32,50 @@ def correct_rl(obj, var_name='depolarization_counts_high', fill_value=1e-7, Returns ------- - obj : Dataset object + ds : xarray.Dataset The raman lidar dataset containing the corrected values. """ # This will get the name of the coordinate dimension so it's not assumed # via position or name. - height_name = list(set(obj[var_name].dims) - set(['time']))[0] + height_name = list(set(ds[var_name].dims) - {'time'})[0] - # Check if the height dimension is a variable in the object. If not - # use global attributes to derive the values and put into object. + # Check if the height dimension is a variable in the dataset. If not + # use global attributes to derive the values and put into dataset. # - # Asking for a variable name in the object that is also a dimension + # Asking for a variable name in the dataset that is also a dimension # but does not exist will return an index array starting at 0. - height = obj[height_name].values - if height_name not in list(obj.data_vars): + height = ds[height_name].values + if height_name not in list(ds.data_vars): # Determin which mode we are correcting level = height_name.split('_')[0] - att_name = [i for i in list(obj.attrs) if - 'vertical_resolution_' + level + '_channels' in i] + att_name = [i for i in list(ds.attrs) if 'vertical_resolution_' + level + '_channels' in i] # Extract information from global attributes - bin_size_raw = (obj.attrs[att_name[0]]).split() - bins_before_shot = float(obj.attrs['number_of_bins_before_shot']) + bin_size_raw = (ds.attrs[att_name[0]]).split() + bins_before_shot = float(ds.attrs['number_of_bins_before_shot']) bin_size = float(bin_size_raw[0]) height = (height + 1) * bin_size height = height - bins_before_shot * bin_size - obj[height_name] = (height_name, height, - {'long_name': 'Height above ground', - 'units': bin_size_raw[1]}) + ds[height_name] = ( + height_name, + height, + {'long_name': 'Height above ground', 'units': bin_size_raw[1]}, + ) if range_normalize_log_values: - height = height ** 2 # Range normalize values - backscat = obj[var_name].values + height = height**2 # Range normalize values + backscat = ds[var_name].values # Doing this trick with height to change the array shape so it # will broadcast correclty against backscat backscat = backscat * height[None, :] backscat[backscat <= 0] = fill_value - if np.shape(obj[var_name].values) != np.shape(np.log10(backscat)): - obj[var_name].values = np.reshape(np.log10(backscat), - np.shape(obj[var_name].values)) + if np.shape(ds[var_name].values) != np.shape(np.log10(backscat)): + ds[var_name].values = np.reshape(np.log10(backscat), np.shape(ds[var_name].values)) else: - obj[var_name].values = np.log10(backscat) + ds[var_name].values = np.log10(backscat) # Updating the units to correctly indicate the values are log values - obj[var_name].attrs['units'] = 'log(' + obj[var_name].attrs['units'] + ')' + ds[var_name].attrs['units'] = 'log(' + ds[var_name].attrs['units'] + ')' - return obj + return ds diff --git a/act/corrections/ship.py b/act/corrections/ship.py index 58515a6052..0e277aca95 100644 --- a/act/corrections/ship.py +++ b/act/corrections/ship.py @@ -1,11 +1,18 @@ -""" Functions for correcting wind speed and direction for ship motion. """ +""" +This module contains functions for correcting data for ship motion +""" import numpy as np -def correct_wind(obj, wspd_name='wind_speed', wdir_name='wind_direction', - heading_name='yaw', cog_name='course_over_ground', - sog_name='speed_over_ground'): +def correct_wind( + ds, + wspd_name='wind_speed', + wdir_name='wind_direction', + heading_name='yaw', + cog_name='course_over_ground', + sog_name='speed_over_ground', +): """ This procedure corrects wind speed and direction for ship motion based on equations from NOAA tech. memo. PSD-311. A Guide to Making @@ -14,7 +21,7 @@ def correct_wind(obj, wspd_name='wind_speed', wdir_name='wind_direction', Parameters ---------- - obj : Dataset object + ds : xarray.Dataset The ceilometer dataset to correct. The backscatter data should be in linear space. wspd_name : string @@ -30,8 +37,8 @@ def correct_wind(obj, wspd_name='wind_speed', wdir_name='wind_direction', Returns ------- - obj : Dataset object - The dataset containing the corrected values. + ds : xarray.Dataset + The Xarray dataset containing the corrected values. References ---------- @@ -42,11 +49,11 @@ def correct_wind(obj, wspd_name='wind_speed', wdir_name='wind_direction', """ # Set variables to be used and convert to radians - rels = obj[wspd_name] - reld = np.deg2rad(obj[wdir_name]) - head = np.deg2rad(obj[heading_name]) - cog = np.deg2rad(obj[cog_name]) - sog = obj[sog_name] + rels = ds[wspd_name] + reld = np.deg2rad(ds[wdir_name]) + head = np.deg2rad(ds[heading_name]) + cog = np.deg2rad(ds[cog_name]) + sog = ds[sog_name] # Calculate winds based on method in the document denoted above relsn = rels * np.cos(head + reld) @@ -58,17 +65,17 @@ def correct_wind(obj, wspd_name='wind_speed', wdir_name='wind_direction', un = relsn - sogn ue = relse - soge - dirt = np.mod(np.rad2deg(np.arctan2(ue, un)) + 360., 360) - ut = np.sqrt(un ** 2. + ue ** 2) + dirt = np.mod(np.rad2deg(np.arctan2(ue, un)) + 360.0, 360) + ut = np.sqrt(un**2.0 + ue**2) # Create data arrays and add corrected wind direction and speed - # to the initial object that was passed in - wdir_da = obj[wdir_name].copy(data=dirt) + # to the initial dataset that was passed in + wdir_da = ds[wdir_name].copy(data=dirt) wdir_da.attrs['long_name'] = 'Wind direction corrected to ship motion' - obj[wdir_name + '_corrected'] = wdir_da + ds[wdir_name + '_corrected'] = wdir_da - wspd_da = obj[wspd_name].copy(data=ut) + wspd_da = ds[wspd_name].copy(data=ut) wspd_da.attrs['long_name'] = 'Wind speed corrected to ship motion' - obj[wspd_name + '_corrected'] = wspd_da + ds[wspd_name + '_corrected'] = wspd_da - return obj + return ds diff --git a/act/discovery/__init__.py b/act/discovery/__init__.py index 59d1fbf077..c0a5fab10d 100644 --- a/act/discovery/__init__.py +++ b/act/discovery/__init__.py @@ -1,21 +1,21 @@ """ -============================= -act.discovery (act.discovery) -============================= +This module contains procedures for exploring and downloading data +from a variety of web services -.. currentmodule:: act.discovery - -This module contains procedures for exploring and downloading data on -ARM Data Discovery. - -.. autosummary:: - :toctree: generated/ - - download_data - croptype - get_asos """ -from .get_armfiles import download_data -from .get_CropScape import croptype -from .get_asos import get_asos +import lazy_loader as lazy + +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=['arm', 'cropscape', 'airnow', 'noaapsl', 'neon', 'surfrad'], + submod_attrs={ + 'arm': ['download_arm_data', 'get_arm_doi'], + 'asos': ['get_asos_data'], + 'airnow': ['get_airnow_bounded_obs', 'get_airnow_obs', 'get_airnow_forecast'], + 'cropscape': ['get_crop_type'], + 'noaapsl': ['download_noaa_psl_data'], + 'neon': ['get_neon_site_products', 'get_neon_product_avail', 'download_neon_data'], + 'surfrad': ['download_surfrad_data'] + }, +) diff --git a/act/discovery/airnow.py b/act/discovery/airnow.py new file mode 100644 index 0000000000..7b458e780c --- /dev/null +++ b/act/discovery/airnow.py @@ -0,0 +1,246 @@ +import pandas as pd +import numpy as np +import xarray as xr + + +def get_airnow_forecast(token, date, zipcode=None, latlon=None, distance=25): + """ + This tool will get current or historical AQI values and categories for a + reporting area by either Zip code or Lat/Lon coordinate. + https://docs.airnowapi.org/ + + Parameters + ---------- + token : str + The access token for accesing the AirNowAPI web server + date : str + The date of the data to be acquired. Format is YYYY-MM-DD + zipcode : str + The zipcode of the location for the data request. + If zipcode is not defined then a latlon coordinate must be defined. + latlon : array + The latlon coordinate of the loaction for the data request. + If latlon is not defined then a zipcode must be defined. + distance : int + If no reporting are is associated with the specified zipcode or latlon, + return a forcast from a nearby reporting area with this distance (in miles). + Default is 25 miles + + Returns + ------- + ds : xarray.Dataset + Returns an Xarray dataset object + + Example + ------- + act.discovery.get_AirNow_forecast(token='XXXXXX', zipcode='60440', date='2012-05-31') + + """ + + # default beginning of the query url + query_url = ('https://airnowapi.org/aq/forecast/') + + # checking is either a zipcode or latlon coordinate is defined + # if neither is defined then error is raised + if (zipcode is None) and (latlon is None): + raise NameError("Zipcode or latlon must be defined") + + if zipcode: + url = (query_url + ('zipcode/?' + 'format=text/csv' + '&zipCode=' + + str(zipcode) + '&date=' + str(date) + + '&distance=' + str(distance) + + '&API_KEY=' + str(token))) + + if latlon: + url = (query_url + ('latLong/?' + 'format=text/csv' + + '&latitude=' + str(latlon[0]) + '&longitude=' + + str(latlon[1]) + '&date=' + str(date) + + '&distance=' + str(distance) + + '&API_KEY=' + str(token))) + + df = pd.read_csv(url) + + # converting to xarray dataset object + ds = df.to_xarray() + + return ds + + +def get_airnow_obs(token, date=None, zipcode=None, latlon=None, distance=25): + """ + This tool will get current or historical observed AQI values and categories for a + reporting area by either Zip code or Lat/Lon coordinate. + https://docs.airnowapi.org/ + + Parameters + ---------- + token : str + The access token for accesing the AirNowAPI web server + date : str + The date of the data to be acquired. Format is YYYY-MM-DD + Default is None which will pull most recent observations + zipcode : str + The zipcode of the location for the data request. + If zipcode is not defined then a latlon coordinate must be defined. + latlon : array + The latlon coordinate of the loaction for the data request. + If latlon is not defined then a zipcode must be defined. + distance : int + If no reporting are is associated with the specified zipcode or latlon, + return a forcast from a nearby reporting area with this distance (in miles). + Default is 25 miles + + Returns + ------- + ds : xarray.Dataset + Returns an xarray dataset object + + Example + ------- + act.discovery.get_AirNow_obs(token='XXXXXX', date='2021-12-01', zipcode='60440') + act.discovery.get_AirNow_obs(token='XXXXXX', latlon=[45,-87]) + + """ + + # default beginning of the query url + query_url = ('https://www.airnowapi.org/aq/observation/') + + # checking is either a zipcode or latlon coordinate is defined + # if neither is defined then error is raised + if (zipcode is None) and (latlon is None): + raise NameError("Zipcode or latlon must be defined") + + # setting the observation type to either current or historical based on the date + if date is None: + obs_type = 'current' + if zipcode: + url = (query_url + ('zipCode/' + str(obs_type) + '/?' + 'format=text/csv' + + '&zipCode=' + str(zipcode) + '&distance=' + str(distance) + + '&API_KEY=' + str(token))) + if latlon: + url = (query_url + ('latLong/' + str(obs_type) + '/?' + 'format=text/csv' + + '&latitude=' + str(latlon[0]) + + '&longitude=' + str(latlon[1]) + '&distance=' + + str(distance) + '&API_KEY=' + str(token))) + else: + obs_type = 'historical' + if zipcode: + url = (query_url + ('zipCode/' + str(obs_type) + '/?' + 'format=text/csv' + + '&zipCode=' + str(zipcode) + '&date=' + str(date) + + 'T00-0000&distance=' + str(distance) + '&API_KEY=' + str(token))) + if latlon: + url = (query_url + ('latLong/' + str(obs_type) + '/?' + 'format=text/csv' + + '&latitude=' + str(latlon[0]) + + '&longitude=' + str(latlon[1]) + '&date=' + + str(date) + 'T00-0000&distance=' + str(distance) + + '&API_KEY=' + str(token))) + + df = pd.read_csv(url) + + # converting to xarray + ds = df.to_xarray() + + return ds + + +def get_airnow_bounded_obs(token, start_date, end_date, latlon_bnds, parameters='OZONE,PM25', data_type='B', + mon_type=0): + """ + Get AQI values or data concentrations for a specific date and time range and set of + parameters within a geographic area of intrest + https://docs.airnowapi.org/ + + Parameters + ---------- + token : str + The access token for accesing the AirNowAPI web server + start_date : str + The start date and hour (in UTC) of the data request. + Format is YYYY-MM-DDTHH + end_date : str + The end date and hour (in UTC) of the data request. + Format is YYYY-MM-DDTHH + latlon_bnds : str + Lat/Lon bounding box of the area of intrest. + Format is 'minX,minY,maxX,maxY' + parameters : str + Parameters to return data for. Options are: + Ozone, PM25, PM10, CO, NO2, SO2 + Format is 'PM25,PM10' + mon_type : int + The type of monitor to be returned. Default is 0 + 0-Permanent, 1-Mobile onlt, 2-Permanent & Mobile + data_type : char + The type of data to be returned. + A-AQI, C-Concentrations, B-AQI & Concentrations + + Returns + ------- + ds : xarray.Dataset + Returns an xarray dataset object + + """ + + verbose = 1 + inc_raw_con = 1 + + url = ('https://www.airnowapi.org/aq/data/?startDate=' + str(start_date) + + '&endDate=' + str(end_date) + '¶meters=' + str(parameters) + + '&BBOX=' + str(latlon_bnds) + '&dataType=' + str(data_type) + + '&format=text/csv' + '&verbose=' + str(verbose) + + '&monitorType=' + str(mon_type) + '&includerawconcentrations=' + + str(inc_raw_con) + '&API_KEY=' + str(token)) + + # Set Column names + names = ['latitude', 'longitude', 'time', 'parameter', 'concentration', 'unit', + 'raw_concentration', 'AQI', 'category', 'site_name', 'site_agency', 'aqs_id', 'full_aqs_id'] + + # Read data into CSV + df = pd.read_csv(url, names=names) + + # Each line is a different time or site or variable so need to parse out + sites = df['site_name'].unique() + times = df['time'].unique() + variables = list(df['parameter'].unique()) + ['AQI', 'category', 'raw_concentration'] + latitude = [list(df['latitude'].loc[df['site_name'] == s])[0] for s in sites] + longitude = [list(df['longitude'].loc[df['site_name'] == s])[0] for s in sites] + aqs_id = [list(df['aqs_id'].loc[df['site_name'] == s])[0] for s in sites] + + # Set up the dataset ahead of time + ds = xr.Dataset( + data_vars={ + 'latitude': (['sites'], latitude), + 'longitude': (['sites'], longitude), + 'aqs_id': (['sites'], aqs_id) + }, + coords={ + 'time': (['time'], times), + 'sites': (['sites'], sites) + } + ) + + # Set up emtpy data with nans + data = np.empty((len(variables), len(times), len(sites))) + data[:] = np.nan + + # For each variable, pull out the data from specific sites and times + for v in range(len(variables)): + for t in range(len(times)): + for s in range(len(sites)): + if variables[v] in ['AQI', 'category', 'raw_concentration']: + result = df.loc[(df['time'] == times[t]) & (df['site_name'] == sites[s])] + if len(result[variables[v]]) > 0: + data[v, t, s] = list(result[variables[v]])[0] + atts = {'units': ''} + else: + result = df.loc[(df['time'] == times[t]) & (df['site_name'] == sites[s]) & (df['parameter'] == variables[v])] + if len(result['concentration']) > 0: + data[v, t, s] = list(result['concentration'])[0] + atts = {'units': list(result['unit'])[0]} + + # Add variables to the dataset + ds[variables[v]] = xr.DataArray(data=data[v, :, :], dims=['time', 'sites'], attrs=atts) + + times = pd.to_datetime(times) + ds = ds.assign_coords({'time': times}) + return ds diff --git a/act/discovery/get_armfiles.py b/act/discovery/arm.py similarity index 50% rename from act/discovery/get_armfiles.py rename to act/discovery/arm.py index 8973111887..ab831771b0 100644 --- a/act/discovery/get_armfiles.py +++ b/act/discovery/arm.py @@ -1,17 +1,26 @@ -""" Module for downloading ARM data. """ +""" +Script for downloading data from ARM's Live Data Webservice + +""" import argparse import json -import sys import os +import sys +from datetime import timedelta +import requests +import textwrap +import warnings + try: from urllib.request import urlopen except ImportError: from urllib import urlopen +from act.utils import date_parser + -def download_data(username, token, datastream, - startdate, enddate, time=None, output=None): +def download_arm_data(username, token, datastream, startdate, enddate, time=None, output=None): """ This tool will help users utilize the ARM Live Data Webservice to download ARM data. @@ -25,9 +34,15 @@ def download_data(username, token, datastream, datastream : str The name of the datastream to acquire. startdate : str - The start date of the data to acquire. Format is YYYY-MM-DD. + The start date of the data to acquire. Formats accepted are + YYYY-MM-DD, DD.MM.YYYY, DD/MM/YYYY, YYYYMMDD, YYYY/MM/DD or + any of the previous formats with THH:MM:SS added onto the end + (ex. 2020-09-15T12:00:00). enddate : str - The end date of the data to acquire. Format is YYYY-MM-DD. + The end date of the data to acquire. Formats accepted are + YYYY-MM-DD, DD.MM.YYYY, DD/MM/YYYY, YYYYMMDD or YYYY/MM/DD, or + any of the previous formats with THH:MM:SS added onto the end + (ex. 2020-09-15T13:00:00). time: str or None The specific time. Format is HHMMSS. Set to None to download all files in the given date interval. @@ -63,8 +78,6 @@ def download_data(username, token, datastream, Author: Michael Giansiracusa Email: giansiracumt@ornl.gov - Web Tools Contact: Ranjeet Devarakonda zzr@ornl.gov - Examples -------- This code will download the netCDF files from the sgpmetE13.b1 datastream @@ -75,8 +88,9 @@ def download_data(username, token, datastream, .. code-block:: python - act.discovery.download_data('userName','XXXXXXXXXXXXXXXX', 'sgpmetE13.b1', - '2017-01-14', '2017-01-20') + act.discovery.download_data( + "userName", "XXXXXXXXXXXXXXXX", "sgpmetE13.b1", "2017-01-14", "2017-01-20" + ) """ # default start and end are empty @@ -84,20 +98,27 @@ def download_data(username, token, datastream, # start and end strings for query_url are constructed # if the arguments were provided if startdate: - start = "&start={}".format(startdate) + start_datetime = date_parser(startdate, return_datetime=True) + start = start_datetime.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z' + start = f'&start={start}' if enddate: - end = "&end={}".format(enddate) + end_datetime = date_parser(enddate, return_datetime=True) + # If the start and end date are the same, and a day to the end date + if start_datetime == end_datetime: + end_datetime += timedelta(hours=23, minutes=59, seconds=59) + end = end_datetime.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z' + end = f'&end={end}' # build the url to query the web service using the arguments provided - query_url = ('https://adc.arm.gov/armlive/livedata/query?' + - 'user={0}&ds={1}{2}{3}&wt=json').format( - ':'.join([username, token]), datastream, start, end) + query_url = ( + 'https://adc.arm.gov/armlive/livedata/query?' + 'user={0}&ds={1}{2}{3}&wt=json' + ).format(':'.join([username, token]), datastream, start, end) # get url response, read the body of the message, # and decode from bytes type to utf-8 string - response_body = urlopen(query_url).read().decode("utf-8") + response_body = urlopen(query_url).read().decode('utf-8') # if the response is an html doc, then there was an error with the user - if response_body[1:14] == "!DOCTYPE html": - raise ConnectionRefusedError("Error with user. Check username or token.") + if response_body[1:14] == '!DOCTYPE html': + raise ConnectionRefusedError('Error with user. Check username or token.') # parse into json object response_body_json = json.loads(response_body) @@ -113,31 +134,80 @@ def download_data(username, token, datastream, # not testing, response is successful and files were returned if response_body_json is None: - print("ARM Data Live Webservice does not appear to be functioning") + print('ARM Data Live Webservice does not appear to be functioning') return [] - num_files = len(response_body_json["files"]) + num_files = len(response_body_json['files']) file_names = [] - if response_body_json["status"] == "success" and num_files > 0: + if response_body_json['status'] == 'success' and num_files > 0: for fname in response_body_json['files']: if time is not None: if time not in fname: continue - print("[DOWNLOADING] {}".format(fname)) # construct link to web service saveData function - save_data_url = ("https://adc.arm.gov/armlive/livedata/" + - "saveData?user={0}&file={1}").format( - ':'.join([username, token]), fname) + save_data_url = ( + 'https://adc.arm.gov/armlive/livedata/' + 'saveData?user={0}&file={1}' + ).format(':'.join([username, token]), fname) output_file = os.path.join(output_dir, fname) # make directory if it doesn't exist if not os.path.isdir(output_dir): os.makedirs(output_dir) # create file and write bytes to file with open(output_file, 'wb') as open_bytes_file: - open_bytes_file.write(urlopen(save_data_url).read()) + data = urlopen(save_data_url).read() + if 'This data file is not available' in str(data): + print(fname + ' is not available for download') + continue + else: + print(f'[DOWNLOADING] {fname}') + open_bytes_file.write(data) file_names.append(output_file) + # Get ARM DOI and print it out + doi = get_arm_doi(datastream, start_datetime.strftime('%Y-%m-%d'), end_datetime.strftime('%Y-%m-%d')) + print('\nIf you use these data to prepare a publication, please cite:\n') + print(textwrap.fill(doi, width=80)) + print('') else: - print("No files returned or url status error.\n" - "Check datastream name, start, and end date.") + print( + 'No files returned or url status error.\n' 'Check datastream name, start, and end date.' + ) return file_names + + +def get_arm_doi(datastream, startdate, enddate): + """ + This function will return a citation with DOI, if available, for specified + datastream and date range + + Parameters + ---------- + datastream : str + The name of the datastream to get a DOI for. This must be ARM standard names + startdate : str + Start date for the citation in the format YY-MM-DD + enddate : str + End date for the citation in the format YY-MM-DD + + Returns + ------- + doi : str + Returns the citation as a string + + """ + + # Get the DOI information + doi_url = 'https://adc.arm.gov/citationservice/citation/datastream?id=' + datastream + '&citationType=apa' + doi_url += '&startDate=' + startdate + doi_url += '&endDate=' + enddate + try: + doi = requests.get(url=doi_url) + except ValueError as err: + return "Webservice potentially down or arguments are not valid: " + err + + if len(doi.text) > 0: + doi = doi.json()['citation'] + else: + doi = 'Please check your arguments. No DOI Found' + + return doi diff --git a/act/discovery/asos.py b/act/discovery/asos.py new file mode 100644 index 0000000000..5f5ae27534 --- /dev/null +++ b/act/discovery/asos.py @@ -0,0 +1,284 @@ +""" +Script for downloading ASOS data from the Iowa Mesonet API + +""" + +import json +import time +import warnings +from datetime import datetime + +import numpy as np +import pandas as pd +import xarray as xr +from six import StringIO + +try: + from urllib.request import urlopen +except ImportError: + from urllib2 import urlopen + + +def get_asos_data(time_window, lat_range=None, lon_range=None, station=None): + """ + Returns all of the station observations from the Iowa Mesonet from either + a given latitude and longitude window or a given station code. + + Parameters + ---------- + time_window: tuple + A 2 member list or tuple containing the start and end times. The + times must be python datetimes. + lat_range: tuple + The latitude window to grab all of the ASOS observations from. + lon_range: tuple + The longitude window to grab all of the ASOS observations from. + station: str + The station ID to grab the ASOS observations from. + + Returns + ------- + asos_ds: dict of xarray.Datasets + A dictionary of ACT datasets whose keys are the ASOS station IDs. + + Examples + -------- + If you want to obtain timeseries of ASOS observations for Chicago O'Hare + Airport, simply do:: + + $ time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 10, 10, 0)] + $ station = "KORD" + $ my_asoses = act.discovery.get_asos(time_window, station="ORD") + """ + # First query the database for all of the JSON info for every station + # Only add stations whose lat/lon are within the Grid's boundaries + regions = """AF AL_ AI_ AQ_ AG_ AR_ AK AL AM_ + AO_ AS_ AR AW_ AU_ AT_ + AZ_ BA_ BE_ BB_ BG_ BO_ BR_ BF_ + BT_ BS_ BI_ BM_ BB_ BY_ BZ_ BJ_ BW_ AZ CA CA_AB + CA_BC CD_ CK_ CF_ CG_ CL_ CM_ CO CO_ CN_ CR_ CT + CU_ CV_ CY_ CZ_ DE DK_ DJ_ DM_ DO_ + DZ EE_ ET_ FK_ FM_ FJ_ FI_ FR_ GF_ PF_ + GA_ GM_ GE_ DE_ GH_ GI_ KY_ GB_ GR_ GL_ GD_ + GU_ GT_ GN_ GW_ GY_ HT_ HN_ HK_ HU_ IS_ IN_ + ID_ IR_ IQ_ IE_ IL_ IT_ CI_ JM_ JP_ + JO_ KZ_ KE_ KI_ KW_ LA_ LV_ LB_ LS_ LR_ LY_ + LT_ LU_ MK_ MG_ MW_ MY_ MV_ ML_ CA_MB + MH_ MR_ MU_ YT_ MX_ MD_ MC_ MA_ MZ_ MM_ NA_ NP_ + AN_ NL_ CA_NB NC_ CA_NF NF_ NI_ + NE_ NG_ MP_ KP_ CA_NT NO_ CA_NS CA_NU OM_ + CA_ON PK_ PA_ PG_ PY_ PE_ PH_ PN_ PL_ + PT_ CA_PE PR_ QA_ CA_QC RO_ RU_RW_ SH_ KN_ + LC_ VC_ WS_ ST_ CA_SK SA_ SN_ RS_ SC_ + SL_ SG_ SK_ SI_ SB_ SO_ ZA_ KR_ ES_ LK_ SD_ SR_ + SZ_ SE_ CH_ SY_ TW_ TJ_ TZ_ TH_ + TG_ TO_ TT_ TU TN_ TR_ TM_ UG_ UA_ AE_ UN_ UY_ + UZ_ VU_ VE_ VN_ VI_ YE_ CA_YT ZM_ ZW_ + EC_ EG_ FL GA GQ_ HI HR_ IA ID IL IO_ IN KS + KH_ KY KM_ LA MA MD ME + MI MN MO MS MT NC ND NE NH NJ NM NV NY OH OK + OR PA RI SC SV_ SD TD_ TN TX UT VA VT VG_ + WA WI WV WY""" + + networks = ['AWOS'] + metadata_list = {} + if lat_range is not None and lon_range is not None: + lon_min, lon_max = lon_range + lat_min, lat_max = lat_range + for region in regions.split(): + networks.append(f'{region}_ASOS') + + site_list = [] + for network in networks: + # Get metadata + uri = ('https://mesonet.agron.iastate.edu/' 'geojson/network/%s.geojson') % (network,) + data = urlopen(uri) + jdict = json.load(data) + for site in jdict['features']: + lat = site['geometry']['coordinates'][1] + lon = site['geometry']['coordinates'][0] + if lat >= lat_min and lat <= lat_max: + if lon >= lon_min and lon <= lon_max: + station_metadata_dict = {} + station_metadata_dict['site_latitude'] = lat + station_metadata_dict['site_longitude'] = lat + for my_keys in site['properties']: + station_metadata_dict[my_keys] = site['properties'][my_keys] + metadata_list[site['properties']['sid']] = station_metadata_dict + site_list.append(site['properties']['sid']) + elif station is not None: + site_list = [station] + for region in regions.split(): + networks.append(f'{region}_ASOS') + for network in networks: + # Get metadata + uri = ('https://mesonet.agron.iastate.edu/' 'geojson/network/%s.geojson') % (network,) + data = urlopen(uri) + jdict = json.load(data) + for site in jdict['features']: + lat = site['geometry']['coordinates'][1] + lon = site['geometry']['coordinates'][0] + if site['properties']['sid'] == station: + station_metadata_dict = {} + station_metadata_dict['site_latitude'] = lat + station_metadata_dict['site_longitude'] = lon + for my_keys in site['properties']: + if my_keys == 'elevation': + station_metadata_dict['elevation'] = ( + '%f meter' % site['properties'][my_keys] + ) + else: + station_metadata_dict[my_keys] = site['properties'][my_keys] + metadata_list[station] = station_metadata_dict + + # Get station metadata + else: + raise ValueError('Either both lat_range and lon_range or station must ' + 'be specified!') + + # Get the timestamp for each request + start_time = time_window[0] + end_time = time_window[1] + + SERVICE = 'http://mesonet.agron.iastate.edu/cgi-bin/request/asos.py?' + service = SERVICE + 'data=all&tz=Etc/UTC&format=comma&latlon=yes&' + + service += start_time.strftime('year1=%Y&month1=%m&day1=%d&hour1=%H&minute1=%M&') + service += end_time.strftime('year2=%Y&month2=%m&day2=%d&hour2=%H&minute2=%M') + asos_ds = {} + for stations in site_list: + uri = f'{service}&station={stations}' + print(f'Downloading: {stations}') + data = _download_data(uri) + buf = StringIO() + buf.write(data) + buf.seek(0) + + my_df = pd.read_csv(buf, skiprows=5, na_values='M') + + if len(my_df['lat'].values) == 0: + warnings.warn( + 'No data available at station %s between time %s and %s' + % ( + stations, + start_time.strftime('%Y-%m-%d %H:%M:%S'), + end_time.strftime('%Y-%m-%d %H:%M:%S'), + ) + ) + else: + + def to_datetime(x): + return datetime.strptime(x, '%Y-%m-%d %H:%M') + + my_df['time'] = my_df['valid'].apply(to_datetime) + my_df = my_df.set_index('time') + my_df = my_df.drop('valid', axis=1) + my_df = my_df.drop('station', axis=1) + my_df = my_df.to_xarray() + + my_df.attrs = metadata_list[stations] + my_df['lon'].attrs['units'] = 'degree' + my_df['lon'].attrs['long_name'] = 'Longitude' + my_df['lat'].attrs['units'] = 'degree' + my_df['lat'].attrs['long_name'] = 'Latitude' + + my_df['tmpf'].attrs['units'] = 'degrees Fahrenheit' + my_df['tmpf'].attrs['long_name'] = 'Temperature in degrees Fahrenheit' + + # Fahrenheit to Celsius + my_df['temp'] = (5.0 / 9.0 * my_df['tmpf']) - 32.0 + my_df['temp'].attrs['units'] = 'degrees Celsius' + my_df['temp'].attrs['long_name'] = 'Temperature in degrees Celsius' + my_df['dwpf'].attrs['units'] = 'degrees Fahrenheit' + my_df['dwpf'].attrs['long_name'] = 'Dewpoint temperature in degrees Fahrenheit' + + # Fahrenheit to Celsius + my_df['dwpc'] = (5.0 / 9.0 * my_df['tmpf']) - 32.0 + my_df['dwpc'].attrs['units'] = 'degrees Celsius' + my_df['dwpc'].attrs['long_name'] = 'Dewpoint temperature in degrees Celsius' + my_df['relh'].attrs['units'] = 'percent' + my_df['relh'].attrs['long_name'] = 'Relative humidity' + my_df['drct'].attrs['units'] = 'degrees' + my_df['drct'].attrs['long_name'] = 'Wind speed in degrees' + my_df['sknt'].attrs['units'] = 'knots' + my_df['sknt'].attrs['long_name'] = 'Wind speed in knots' + my_df['spdms'] = my_df['sknt'] * 0.514444 + my_df['spdms'].attrs['units'] = 'm s-1' + my_df['spdms'].attrs['long_name'] = 'Wind speed in meters per second' + my_df['u'] = -np.sin(np.deg2rad(my_df['drct'])) * my_df['spdms'] + my_df['u'].attrs['units'] = 'm s-1' + my_df['u'].attrs['long_name'] = 'Zonal component of surface wind' + my_df['v'] = -np.cos(np.deg2rad(my_df['drct'])) * my_df['spdms'] + my_df['v'].attrs['units'] = 'm s-1' + my_df['v'].attrs['long_name'] = 'Meridional component of surface wind' + my_df['mslp'].attrs['units'] = 'mb' + my_df['mslp'].attrs['long_name'] = 'Mean Sea Level Pressure' + my_df['alti'].attrs['units'] = 'in Hg' + my_df['alti'].attrs['long_name'] = 'Atmospheric pressure in inches of Mercury' + my_df['vsby'].attrs['units'] = 'mi' + my_df['vsby'].attrs['long_name'] = 'Visibility' + my_df['vsbykm'] = my_df['vsby'] * 1.60934 + my_df['vsbykm'].attrs['units'] = 'km' + my_df['vsbykm'].attrs['long_name'] = 'Visibility' + my_df['gust'] = my_df['gust'] * 0.514444 + my_df['gust'].attrs['units'] = 'm s-1' + my_df['gust'].attrs['long_name'] = 'Wind gust speed' + my_df['skyc1'].attrs['long_name'] = 'Sky level 1 coverage' + my_df['skyc2'].attrs['long_name'] = 'Sky level 2 coverage' + my_df['skyc3'].attrs['long_name'] = 'Sky level 3 coverage' + my_df['skyc4'].attrs['long_name'] = 'Sky level 4 coverage' + my_df['skyl1'] = my_df['skyl1'] * 0.3048 + my_df['skyl2'] = my_df['skyl2'] * 0.3048 + my_df['skyl3'] = my_df['skyl3'] * 0.3048 + my_df['skyl4'] = my_df['skyl4'] * 0.3048 + my_df['skyl1'].attrs['long_name'] = 'Sky level 1 altitude' + my_df['skyl2'].attrs['long_name'] = 'Sky level 2 altitude' + my_df['skyl3'].attrs['long_name'] = 'Sky level 3 altitude' + my_df['skyl4'].attrs['long_name'] = 'Sky level 4 altitude' + my_df['skyl1'].attrs['long_name'] = 'meter' + my_df['skyl2'].attrs['long_name'] = 'meter' + my_df['skyl3'].attrs['long_name'] = 'meter' + my_df['skyl4'].attrs['long_name'] = 'meter' + + my_df['wxcodes'].attrs['long_name'] = 'Weather code' + my_df['ice_accretion_1hr'] = my_df['ice_accretion_1hr'] * 2.54 + my_df['ice_accretion_1hr'].attrs['units'] = 'cm' + my_df['ice_accretion_1hr'].attrs['long_name'] = '1 hour ice accretion' + my_df['ice_accretion_3hr'] = my_df['ice_accretion_3hr'] * 2.54 + my_df['ice_accretion_3hr'].attrs['units'] = 'cm' + my_df['ice_accretion_3hr'].attrs['long_name'] = '3 hour ice accretion' + my_df['ice_accretion_6hr'] = my_df['ice_accretion_3hr'] * 2.54 + my_df['ice_accretion_6hr'].attrs['units'] = 'cm' + my_df['ice_accretion_6hr'].attrs['long_name'] = '6 hour ice accretion' + my_df['peak_wind_gust'] = my_df['peak_wind_gust'] * 0.514444 + my_df['peak_wind_gust'].attrs['units'] = 'm s-1' + my_df['peak_wind_gust'].attrs['long_name'] = 'Peak wind gust speed' + my_df['peak_wind_drct'].attrs['drct'] = 'degree' + my_df['peak_wind_drct'].attrs['long_name'] = 'Peak wind gust direction' + my_df['u_peak'] = -np.sin(np.deg2rad(my_df['peak_wind_drct'])) * my_df['peak_wind_gust'] + my_df['u_peak'].attrs['units'] = 'm s-1' + my_df['u_peak'].attrs['long_name'] = 'Zonal component of surface wind' + my_df['v_peak'] = -np.cos(np.deg2rad(my_df['peak_wind_drct'])) * my_df['peak_wind_gust'] + my_df['v_peak'].attrs['units'] = 'm s-1' + my_df['v_peak'].attrs['long_name'] = 'Meridional component of surface wind' + my_df['metar'].attrs['long_name'] = 'Raw METAR code' + my_df.attrs['_datastream'] = stations + buf.close() + + asos_ds[stations] = my_df + return asos_ds + + +def _download_data(uri): + attempt = 0 + while attempt < 6: + try: + data = urlopen(uri, timeout=300).read().decode('utf-8') + if data is not None and not data.startswith('ERROR'): + return data + except Exception as exp: + print(f'download_data({uri}) failed with {exp}') + time.sleep(5) + attempt += 1 + + print('Exhausted attempts to download, returning empty data') + return '' diff --git a/act/discovery/get_CropScape.py b/act/discovery/cropscape.py similarity index 82% rename from act/discovery/get_CropScape.py rename to act/discovery/cropscape.py index cf886eb706..07308929f9 100644 --- a/act/discovery/get_CropScape.py +++ b/act/discovery/cropscape.py @@ -1,24 +1,26 @@ """ -act.discovery.get_CropScape ----------------------------- - Function for getting CropScape data based on an entered lat/lon. """ + import datetime import requests -import pyproj + +try: + from pyproj import Transformer +except ImportError: + from pyproj.transformer import Transformer -def croptype(lat=None, lon=None, year=None): +def get_crop_type(lat=None, lon=None, year=None): """ Function for working with the CropScape API to get a crop type based on the lat,lon, and year entered. The lat/lon is converted to the projection used by CropScape before pased to the API. Note, the requests library is indicating a bad handshake with the server so 'verify' is currently - set to False which is unsecure. Use at your own risk until it can be resolved. - CropScape - Copyright Š Center For Spatial Information Science and Systems - 2009 - 2018 + set to False which is unsecure. Use at your own risk until it can be + resolved. CropScape - Copyright Š Center For Spatial Information Science + and Systems 2009 - 2018 Parameters ---------- @@ -40,16 +42,15 @@ def croptype(lat=None, lon=None, year=None): .. code-block :: python - type = act.discovery.get_CropScape.croptype(36.8172,-97.1709,'2018') + type = act.discovery.get_cropscape.croptype(36.8172,-97.1709,'2018') """ - # Return if lat/lon are not passed in if lat is None or lon is None: - raise RuntimeError(("Lat and Lon need to be provided")) + raise RuntimeError('Lat and Lon need to be provided') # Set the CropScape Projection - projection_string = ( + outproj = ( 'PROJCS["NAD_1983_Albers",' 'GEOGCS["NAD83",' 'DATUM["North_American_Datum_1983",' @@ -69,15 +70,15 @@ def croptype(lat=None, lon=None, year=None): 'PARAMETER["longitude_of_center",-96],' 'PARAMETER["false_easting",0],' 'PARAMETER["false_northing",0],' - 'UNIT["meters",1]]') - - outproj = pyproj.CRS(projection_string) + 'UNIT["meters",1]]' + ) # Set the input projection to be lat/lon - inproj = pyproj.Proj("+init=EPSG:4326") + inproj = 'EPSG:4326' # Get the x/y coordinates for CropScape - x, y = pyproj.transform(inproj, outproj, lon, lat) + transformer = Transformer.from_crs(inproj, outproj) + x, y = transformer.transform(lat, lon) # Build URL url = 'https://nassgeodata.gmu.edu/axis2/services/CDLService/GetCDLValue?' diff --git a/act/discovery/get_asos.py b/act/discovery/get_asos.py deleted file mode 100644 index 7c6fca7a23..0000000000 --- a/act/discovery/get_asos.py +++ /dev/null @@ -1,279 +0,0 @@ -import xarray as xr -import json -import time -import pandas as pd -import numpy as np -import warnings - -from six import StringIO -from datetime import datetime - -try: - from urllib.request import urlopen -except ImportError: - from urllib2 import urlopen - - -def get_asos(time_window, lat_range=None, - lon_range=None, station=None): - """ - Returns all of the station observations from the Iowa Mesonet from either - a given latitude and longitude window or a given station code. - - Parameters - ---------- - time_window: tuple - A 2 member list or tuple containing the start and end times. The - times must be python datetimes. - lat_range: tuple - The latitude window to grab all of the ASOS observations from. - lon_range: tuple - The longitude window to grab all of the ASOS observations from. - station: str - The station ID to grab the ASOS observations from. - - Returns - ------- - asos_ds: dict of xarray datasets - A dictionary of ACT datasets whose keys are the ASOS station IDs. - - Examples - -------- - If you want to obtain timeseries of ASOS observations for Chicago O'Hare - Airport, simply do:: - - $ time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 10, 10, 0)] - $ station = "KORD" - $ my_asoses = act.discovery.get_asos(time_window, station="ORD") - """ - - # First query the database for all of the JSON info for every station - # Only add stations whose lat/lon are within the Grid's boundaries - regions = """AF AL_ AI_ AQ_ AG_ AR_ AK AL AM_ - AO_ AS_ AR AW_ AU_ AT_ - AZ_ BA_ BE_ BB_ BG_ BO_ BR_ BF_ - BT_ BS_ BI_ BM_ BB_ BY_ BZ_ BJ_ BW_ AZ CA CA_AB - CA_BC CD_ CK_ CF_ CG_ CL_ CM_ CO CO_ CN_ CR_ CT - CU_ CV_ CY_ CZ_ DE DK_ DJ_ DM_ DO_ - DZ EE_ ET_ FK_ FM_ FJ_ FI_ FR_ GF_ PF_ - GA_ GM_ GE_ DE_ GH_ GI_ KY_ GB_ GR_ GL_ GD_ - GU_ GT_ GN_ GW_ GY_ HT_ HN_ HK_ HU_ IS_ IN_ - ID_ IR_ IQ_ IE_ IL_ IT_ CI_ JM_ JP_ - JO_ KZ_ KE_ KI_ KW_ LA_ LV_ LB_ LS_ LR_ LY_ - LT_ LU_ MK_ MG_ MW_ MY_ MV_ ML_ CA_MB - MH_ MR_ MU_ YT_ MX_ MD_ MC_ MA_ MZ_ MM_ NA_ NP_ - AN_ NL_ CA_NB NC_ CA_NF NF_ NI_ - NE_ NG_ MP_ KP_ CA_NT NO_ CA_NS CA_NU OM_ - CA_ON PK_ PA_ PG_ PY_ PE_ PH_ PN_ PL_ - PT_ CA_PE PR_ QA_ CA_QC RO_ RU_RW_ SH_ KN_ - LC_ VC_ WS_ ST_ CA_SK SA_ SN_ RS_ SC_ - SL_ SG_ SK_ SI_ SB_ SO_ ZA_ KR_ ES_ LK_ SD_ SR_ - SZ_ SE_ CH_ SY_ TW_ TJ_ TZ_ TH_ - TG_ TO_ TT_ TU TN_ TR_ TM_ UG_ UA_ AE_ UN_ UY_ - UZ_ VU_ VE_ VN_ VI_ YE_ CA_YT ZM_ ZW_ - EC_ EG_ FL GA GQ_ HI HR_ IA ID IL IO_ IN KS - KH_ KY KM_ LA MA MD ME - MI MN MO MS MT NC ND NE NH NJ NM NV NY OH OK - OR PA RI SC SV_ SD TD_ TN TX UT VA VT VG_ - WA WI WV WY""" - - networks = ["AWOS"] - metadata_list = {} - if lat_range is not None and lon_range is not None: - lon_min, lon_max = lon_range - lat_min, lat_max = lat_range - for region in regions.split(): - networks.append("%s_ASOS" % (region,)) - - site_list = [] - for network in networks: - # Get metadata - uri = ("https://mesonet.agron.iastate.edu/" - "geojson/network/%s.geojson") % (network,) - data = urlopen(uri) - jdict = json.load(data) - for site in jdict["features"]: - lat = site["geometry"]["coordinates"][1] - lon = site["geometry"]["coordinates"][0] - if lat >= lat_min and lat <= lat_max: - if lon >= lon_min and lon <= lon_max: - station_metadata_dict = {} - station_metadata_dict["site_latitude"] = lat - station_metadata_dict["site_longitude"] = lat - for my_keys in site["properties"]: - station_metadata_dict[my_keys] = site["properties"][my_keys] - metadata_list[site["properties"]["sid"]] = station_metadata_dict - site_list.append(site["properties"]["sid"]) - elif station is not None: - site_list = [station] - for region in regions.split(): - networks.append("%s_ASOS" % (region,)) - for network in networks: - # Get metadata - uri = ("https://mesonet.agron.iastate.edu/" - "geojson/network/%s.geojson") % (network,) - data = urlopen(uri) - jdict = json.load(data) - for site in jdict["features"]: - lat = site["geometry"]["coordinates"][1] - lon = site["geometry"]["coordinates"][0] - if site["properties"]["sid"] == station: - station_metadata_dict = {} - station_metadata_dict["site_latitude"] = lat - station_metadata_dict["site_longitude"] = lon - for my_keys in site["properties"]: - if my_keys == "elevation": - station_metadata_dict["elevation"] = \ - '%f meter' % site["properties"][my_keys] - else: - station_metadata_dict[my_keys] = \ - site["properties"][my_keys] - metadata_list[station] = station_metadata_dict - - # Get station metadata - else: - raise ValueError("Either both lat_range and lon_range or station must " + - "be specified!") - - # Get the timestamp for each request - start_time = time_window[0] - end_time = time_window[1] - - SERVICE = "http://mesonet.agron.iastate.edu/cgi-bin/request/asos.py?" - service = SERVICE + "data=all&tz=Etc/UTC&format=comma&latlon=yes&" - - service += start_time.strftime("year1=%Y&month1=%m&day1=%d&hour1=%H&minute1=%M&") - service += end_time.strftime("year2=%Y&month2=%m&day2=%d&hour2=%H&minute2=%M") - station_obs = {} - for stations in site_list: - uri = "%s&station=%s" % (service, stations) - print("Downloading: %s" % (stations,)) - data = _download_data(uri) - buf = StringIO() - buf.write(data) - buf.seek(0) - - my_df = pd.read_csv(buf, skiprows=5, na_values="M") - - if len(my_df['lat'].values) == 0: - warnings.warn( - "No data available at station %s between time %s and %s" % - (stations, start_time.strftime('%Y-%m-%d %H:%M:%S'), - end_time.strftime('%Y-%m-%d %H:%M:%S'))) - else: - def to_datetime(x): - return datetime.strptime(x, "%Y-%m-%d %H:%M") - - my_df["time"] = my_df["valid"].apply(to_datetime) - my_df = my_df.set_index("time") - my_df = my_df.drop("valid", axis=1) - my_df = my_df.drop("station", axis=1) - my_df = my_df.to_xarray() - - my_df.attrs = metadata_list[stations] - my_df["lon"].attrs["units"] = "degree" - my_df["lon"].attrs["long_name"] = "Longitude" - my_df["lat"].attrs["units"] = "degree" - my_df["lat"].attrs["long_name"] = "Latitude" - - my_df["tmpf"].attrs["units"] = "degrees Fahrenheit" - my_df["tmpf"].attrs["long_name"] = "Temperature in degrees Fahrenheit" - - # Fahrenheit to Celsius - my_df["temp"] = (5. / 9. * my_df["tmpf"]) - 32.0 - my_df["temp"].attrs["units"] = "degrees Celsius" - my_df["temp"].attrs["long_name"] = "Temperature in degrees Celsius" - my_df["dwpf"].attrs["units"] = "degrees Fahrenheit" - my_df["dwpf"].attrs["long_name"] = "Dewpoint temperature in degrees Fahrenheit" - - # Fahrenheit to Celsius - my_df["dwpc"] = (5. / 9. * my_df["tmpf"]) - 32.0 - my_df["dwpc"].attrs["units"] = "degrees Celsius" - my_df["dwpc"].attrs["long_name"] = "Dewpoint temperature in degrees Celsius" - my_df["relh"].attrs["units"] = "percent" - my_df["relh"].attrs["long_name"] = "Relative humidity" - my_df["drct"].attrs["units"] = "degrees" - my_df["drct"].attrs["long_name"] = "Wind speed in degrees" - my_df["sknt"].attrs["units"] = "knots" - my_df["sknt"].attrs["long_name"] = "Wind speed in knots" - my_df["spdms"] = my_df["sknt"] * 0.514444 - my_df["spdms"].attrs["units"] = "m s-1" - my_df["spdms"].attrs["long_name"] = "Wind speed in meters per second" - my_df['u'] = -np.sin(np.deg2rad(my_df["drct"])) * my_df["spdms"] - my_df['u'].attrs["units"] = "m s-1" - my_df['u'].attrs["long_name"] = "Zonal component of surface wind" - my_df['v'] = -np.cos(np.deg2rad(my_df["drct"])) * my_df["spdms"] - my_df['v'].attrs["units"] = "m s-1" - my_df['v'].attrs["long_name"] = "Meridional component of surface wind" - my_df["mslp"].attrs["units"] = "mb" - my_df["mslp"].attrs["long_name"] = "Mean Sea Level Pressure" - my_df["alti"].attrs["units"] = "in Hg" - my_df["alti"].attrs["long_name"] = "Atmospheric pressure in inches of Mercury" - my_df["vsby"].attrs["units"] = "mi" - my_df["vsby"].attrs["long_name"] = "Visibility" - my_df["vsbykm"] = my_df["vsby"] * 1.60934 - my_df["vsbykm"].attrs["units"] = 'km' - my_df["vsbykm"].attrs["long_name"] = "Visibility" - my_df["gust"] = my_df["gust"] * 0.514444 - my_df["gust"].attrs["units"] = 'm s-1' - my_df["gust"].attrs["long_name"] = "Wind gust speed" - my_df["skyc1"].attrs["long_name"] = "Sky level 1 coverage" - my_df["skyc2"].attrs["long_name"] = "Sky level 2 coverage" - my_df["skyc3"].attrs["long_name"] = "Sky level 3 coverage" - my_df["skyc4"].attrs["long_name"] = "Sky level 4 coverage" - my_df["skyl1"] = my_df["skyl1"] * 0.3048 - my_df["skyl2"] = my_df["skyl2"] * 0.3048 - my_df["skyl3"] = my_df["skyl3"] * 0.3048 - my_df["skyl4"] = my_df["skyl4"] * 0.3048 - my_df["skyl1"].attrs["long_name"] = "Sky level 1 altitude" - my_df["skyl2"].attrs["long_name"] = "Sky level 2 altitude" - my_df["skyl3"].attrs["long_name"] = "Sky level 3 altitude" - my_df["skyl4"].attrs["long_name"] = "Sky level 4 altitude" - my_df["skyl1"].attrs["long_name"] = "meter" - my_df["skyl2"].attrs["long_name"] = "meter" - my_df["skyl3"].attrs["long_name"] = "meter" - my_df["skyl4"].attrs["long_name"] = "meter" - - my_df["wxcodes"].attrs["long_name"] = "Weather code" - my_df["ice_accretion_1hr"] = my_df["ice_accretion_1hr"] * 2.54 - my_df["ice_accretion_1hr"].attrs["units"] = "cm" - my_df["ice_accretion_1hr"].attrs["long_name"] = "1 hour ice accretion" - my_df["ice_accretion_3hr"] = my_df["ice_accretion_3hr"] * 2.54 - my_df["ice_accretion_3hr"].attrs["units"] = "cm" - my_df["ice_accretion_3hr"].attrs["long_name"] = "3 hour ice accretion" - my_df["ice_accretion_6hr"] = my_df["ice_accretion_3hr"] * 2.54 - my_df["ice_accretion_6hr"].attrs["units"] = "cm" - my_df["ice_accretion_6hr"].attrs["long_name"] = "6 hour ice accretion" - my_df["peak_wind_gust"] = my_df["peak_wind_gust"] * 0.514444 - my_df["peak_wind_gust"].attrs["units"] = 'm s-1' - my_df["peak_wind_gust"].attrs["long_name"] = "Peak wind gust speed" - my_df["peak_wind_drct"].attrs["drct"] = 'degree' - my_df["peak_wind_drct"].attrs["long_name"] = "Peak wind gust direction" - my_df['u_peak'] = -np.sin(np.deg2rad(my_df["peak_wind_drct"])) * my_df["peak_wind_gust"] - my_df['u_peak'].attrs["units"] = "m s-1" - my_df['u_peak'].attrs["long_name"] = "Zonal component of surface wind" - my_df['v_peak'] = -np.cos(np.deg2rad(my_df["peak_wind_drct"])) * my_df["peak_wind_gust"] - my_df['v_peak'].attrs["units"] = "m s-1" - my_df['v_peak'].attrs["long_name"] = "Meridional component of surface wind" - my_df["metar"].attrs["long_name"] = "Raw METAR code" - my_df.attrs['_datastream'] = stations - buf.close() - - station_obs[stations] = my_df - return station_obs - - -def _download_data(uri): - attempt = 0 - while attempt < 6: - try: - data = urlopen(uri, timeout=300).read().decode("utf-8") - if data is not None and not data.startswith("ERROR"): - return data - except Exception as exp: - print("download_data(%s) failed with %s" % (uri, exp)) - time.sleep(5) - attempt += 1 - - print("Exhausted attempts to download, returning empty data") - return "" diff --git a/act/discovery/neon.py b/act/discovery/neon.py new file mode 100644 index 0000000000..cfe3eff2c1 --- /dev/null +++ b/act/discovery/neon.py @@ -0,0 +1,163 @@ +""" +Function for downloading data from NSF NEON program +using their API. + +NEON sites can be found through the NEON website +https://www.neonscience.org/field-sites/explore-field-sites + +""" + +import json +import requests +import os +import shutil +import pandas as pd + + +def get_neon_site_products(site_code, print_to_screen=False): + """ + Returns a list of data products available for a NEON site + NEON sites can be found through the NEON website + https://www.neonscience.org/field-sites/explore-field-sites + + Parameters + ---------- + site : str + NEON site identifier. Required variable + print_to_screen : boolean + If set to True will print to screen + + Returns + ------- + products : list + Returns 2D list of data product code and title + + """ + + # Every request begins with the server's URL + server = 'http://data.neonscience.org/api/v0/' + + # Make request, using the sites/ endpoint + site_request = requests.get(server + 'sites/' + site_code) + + # Convert to Python JSON object + site_json = site_request.json() + + products = {} + # View product code and name for every available data product + for product in site_json['data']['dataProducts']: + if print_to_screen: + print(product['dataProductCode'], product['dataProductTitle']) + products[product['dataProductCode']] = product['dataProductTitle'] + + return products + + +def get_neon_product_avail(site_code, product_code, print_to_screen=False): + """ + Returns a list of data products available for a NEON site + NEON sites can be found through the NEON website + https://www.neonscience.org/field-sites/explore-field-sites + + Parameters + ---------- + site : str + NEON site identifier. Required variable + product_code : str + NEON product code. Required variable + print_to_screen : boolean + If set to True will print to screen + + Returns + ------- + dates : list + Returns list of available months of data + + """ + + # Every request begins with the server's URL + server = 'http://data.neonscience.org/api/v0/' + + # Make request, using the sites/ endpoint + site_request = requests.get(server + 'sites/' + site_code) + + # Convert to Python JSON object + site_json = site_request.json() + + # View product code and name for every available data product + for product in site_json['data']['dataProducts']: + if product['dataProductCode'] != product_code: + continue + if print_to_screen: + print(product['availableMonths']) + dates = product['availableMonths'] + + return dates + + +def download_neon_data(site_code, product_code, start_date, end_date=None, output_dir=None): + """ + Returns a list of data products available for a NEON site. Please be sure to view the + readme files that are downloaded as well as there may be a number of different products. + + If you want more information on the NEON file formats, please see: + https://www.neonscience.org/data-samples/data-management/data-formats-conventions + + NEON sites can be found through the NEON website + https://www.neonscience.org/field-sites/explore-field-sites + + Please be sure to acknowledge and cite the NEON program and data products appropriately: + https://www.neonscience.org/data-samples/data-policies-citation + + Parameters + ---------- + site : str + NEON site identifier. Required variable + product_code : str + NEON product code. Required variable + start_date : str + Start date of the range to download in YYYY-MM format + end_date : str + End date of the range to download in YYYY-MM format. + If None, will just download data for start_date + output_dir : str + Local directory to store the data. If None, will default to + [current working directory]/[site_code]_[product_code] + + Returns + ------- + files : list + Returns a list of files that were downloaded + + """ + + # Every request begins with the server's URL + server = 'http://data.neonscience.org/api/v0/' + + # Get dates to pass in + if end_date is not None: + date_range = pd.date_range(start_date, end_date, freq='MS').strftime('%Y-%m').tolist() + else: + date_range = [start_date] + + # For each month, download data for specified site/product + files = [] + for date in date_range: + # Make Request + data_request = requests.get(server + 'data/' + product_code + '/' + site_code + '/' + date) + data_json = data_request.json() + + if output_dir is None: + output_dir = os.path.join(os.getcwd(), site_code + '_' + product_code) + if not os.path.exists(output_dir): + os.makedirs(output_dir) + + for file in data_json['data']['files']: + print('[DOWNLOADING] ', file['name']) + output_filename = os.path.join(output_dir, file['name']) + with requests.get(file['url'], stream=True) as r: + with open(output_filename, 'wb') as f: + shutil.copyfileobj(r.raw, f) + files.append(output_filename) + + return files diff --git a/act/discovery/noaapsl.py b/act/discovery/noaapsl.py new file mode 100644 index 0000000000..30b55ff2c2 --- /dev/null +++ b/act/discovery/noaapsl.py @@ -0,0 +1,169 @@ +""" +Function for downloading data from NOAA PSL Profiler Network + +""" +import json +from datetime import datetime +import pandas as pd +import numpy as np +import os + +try: + from urllib.request import urlopen +except ImportError: + from urllib import urlopen + + +def download_noaa_psl_data(site=None, instrument=None, startdate=None, enddate=None, + hour=None, output=None): + """ + Function to download data from the NOAA PSL Profiler Network Data Library + https://psl.noaa.gov/data/obs/datadisplay/ + + Parameters + ---------- + site : str + 3 letter NOAA site identifier. Required variable + instrument : str + Name of the dataset to download. Options currently include (name prior to -). Required variable + 'Parsivel' - Parsivel disdrometer data + 'Pressure', 'Datalogger', 'Net Radiation', 'Temp/RH', 'Solar Radiation' - Surface meteorology/radiation data + 'Tipping Bucket', 'TBRG', 'Wind Speed', 'Wind Direction' - Surface meteorology/radiation data + 'Wind Speed and Direction' - Surface meteorology/radiation data + 'GpsTrimble' - GPS Trimble water vapor data + 'Radar S-band Moment' - 3 GHz Precipitation Profiler moment data + 'Radar S-band Bright Band' - 3 GHz Precipitation Profiler bright band data + '449RWP Bright Band' - 449 MHz Wind Profiler bright band data + '449RWP Wind' - 449 MHz Wind Profiler wind data + '449RWP Sub-Hour Wind' - 449 MHz Wind Profiler sub-hourly wind data + '449RWP Sub-Hour Temp' - 449 MHz Wind Profiler sub-hourly temperature data + '915RWP Wind' - 915 MHz Wind Profiler wind data + '915RWP Temp' - 915 MHz Wind Profiler temperature data + '915RWP Sub-Hour Wind' - 915 MHz Wind Profiler sub-hourly wind data + '915WP Sub-Hour Temp' - 915 MHz Wind Profiler sub-hourly temperature data + 'Radar FMCW Moment' - FMCW Radar moments data + 'Radar FMCW Bright Band' - FMCW Radar bright band data + startdate : str + The start date of the data to acquire. Format is YYYYMMDD. Required variable + enddate : str + The end date of the data to acquire. Format is YYYYMMDD + hour : str + Two digit hour of file to dowload if wanting a specific time + output : str + The output directory for the data. Set to None to make a folder in the + current working directory with the same name as *datastream* to place + the files in. + + Returns + ------- + files : list + Returns list of files retrieved + + """ + + if (site is None) or (instrument is None) or (startdate is None): + raise ValueError('site, instrument, and startdate need to be set') + + datastream = site + '_' + instrument.replace(' ', '_') + # Convert dates to day of year (doy) for NOAA folder structure + s_doy = datetime.strptime(startdate, '%Y%m%d').timetuple().tm_yday + year = datetime.strptime(startdate, '%Y%m%d').year + if enddate is None: + enddate = startdate + e_doy = datetime.strptime(enddate, '%Y%m%d').timetuple().tm_yday + + # Set base URL + url = 'https://downloads.psl.noaa.gov/psd2/data/realtime/' + + # Set list of strings that all point to the surface meteorology dataset + met_ds = ['Pressure', 'Datalogger', 'Net Radiation', 'Temp/RH', + 'Solar Radiation', 'Tipping Bucket', 'TBRG', 'Wind Speed', + 'Wind Direction', 'Wind Speed and Direction'] + + # Add to the url depending on which instrument is requested + if 'Parsivel' in instrument: + url += 'DisdrometerParsivel/Stats/' + elif any([d in instrument for d in met_ds]): + url += 'CsiDatalogger/SurfaceMet/' + elif 'GpsTrimble' in instrument: + url += 'GpsTrimble/WaterVapor/' + elif 'Radar S-band Moment' in instrument: + url += 'Radar3000/PopMoments/' + elif 'Radar S-band Bright Band' in instrument: + url += 'Radar3000/BrightBand/' + elif '449RWP Bright Band' in instrument: + url += 'Radar449/BrightBand/' + elif '449RWP Wind' in instrument: + url += 'Radar449/WwWind/' + elif '449RWP Sub-Hour Wind' in instrument: + url += 'Radar449/WwWindSubHourly/' + elif '449RWP Sub-Hour Temp' in instrument: + url += 'Radar449/WwTempSubHourly/' + elif '915RWP Wind' in instrument: + url += 'Radar915/WwWind/' + elif '915RWP Temp' in instrument: + url += 'Radar915/WwTemp/' + elif '915RWP Sub-Hour Wind' in instrument: + url += 'Radar915/WwWindSubHourly/' + elif '915RWP Sub-Hour Temp' in instrument: + url += 'Radar915/WwTempSubHourly/' + elif 'Radar FMCW Moment' in instrument: + url += 'RadarFMCW/PopMoments/' + elif 'Radar FMCW Bright Band' in instrument: + url += 'RadarFMCW/BrightBand/' + else: + raise ValueError('Instrument not supported') + + # Construct output directory + if output: + # Output files to directory specified + output_dir = os.path.join(output) + else: + # If no folder given, add datastream folder + # to current working dir to prevent file mix-up + output_dir = os.path.join(os.getcwd(), datastream) + + if not os.path.isdir(output_dir): + os.makedirs(output_dir) + + # Set up doy ranges, taking into account changes for a new year + prev_doy = 0 + if e_doy < s_doy: + r = list(range(s_doy, 366)) + list(range(1, e_doy + 1)) + else: + r = list(range(s_doy, e_doy + 1)) + + # Set filename variable to return + filenames = [] + + # Loop through each doy in range + for doy in r: + # if the previous day is greater than current, assume a new year + # i.e. 365 -> 001 + if prev_doy > doy: + year += 1 + # Add site, year, and 3-digit day to url + new_url = url + site + '/' + str(year) + '/' + str(doy).zfill(3) + '/' + + # User pandas to get a list of filenames to download + # Exclude the first and last records which are "parent directory" and "nan" + files = pd.read_html(new_url, skiprows=[1])[0]['Name'] + files = list(files[1:-1]) + + # Write each file out to a file with same name as online + for f in files: + if hour is not None: + if (str(doy).zfill(3) + str(hour)) not in f and\ + (str(doy).zfill(3) + '.' + str(hour)) not in f: + continue + output_file = os.path.join(output_dir, f) + try: + print('Downloading ' + f) + with open(output_file, 'wb') as open_bytes_file: + open_bytes_file.write(urlopen(new_url + f).read()) + filenames.append(output_file) + except Exception: + pass + prev_doy = doy + + return filenames diff --git a/act/discovery/surfrad.py b/act/discovery/surfrad.py new file mode 100644 index 0000000000..c6ba6fd356 --- /dev/null +++ b/act/discovery/surfrad.py @@ -0,0 +1,115 @@ +""" +Function for downloading data from +NOAA Surface Radiation Budget network + +""" +import json +from datetime import datetime +import pandas as pd +import numpy as np +import os +import re +import requests + +try: + from urllib.request import urlopen +except ImportError: + from urllib import urlopen + + +def download_surfrad_data(site=None, startdate=None, enddate=None, output=None): + """ + Function to download data from the NOAA Surface Radiation Budget network. + https://gml.noaa.gov/grad/surfrad/ + + Parameters + ---------- + site : str + 3 letter NOAA site identifier. Required variable + List of sites can be found at https://gml.noaa.gov/grad/surfrad/sitepage.html + startdate : str + The start date of the data to acquire. Format is YYYYMMDD. Required variable + enddate : str + The end date of the data to acquire. Format is YYYYMMDD + output : str + The output directory for the data. Set to None to make a folder in the + current working directory with the same name as *datastream* to place + the files in. + + Returns + ------- + files : list + Returns list of files retrieved + + """ + + if (site is None) or (startdate is None): + raise ValueError('site and startdate need to be set') + + site = site.lower() + site_dict = { + 'bnd': 'Bondville_IL', + 'tbl': 'Boulder_CO', + 'dra': 'Desert_Rock_NV', + 'fpk': 'Fort_Peck_MT', + 'gwn': 'Goodwin_Creek_MS', + 'psu': 'Penn_State_PA', + 'sxf': 'Sioux_Falls_SD', + } + site_name = site_dict[site] + + # Convert dates to day of year (doy) for NOAA folder structure + s_doy = datetime.strptime(startdate, '%Y%m%d').timetuple().tm_yday + year = datetime.strptime(startdate, '%Y%m%d').year + if enddate is None: + enddate = startdate + e_doy = datetime.strptime(enddate, '%Y%m%d').timetuple().tm_yday + + # Set base URL + url = 'https://gml.noaa.gov/aftp/data/radiation/surfrad/' + + # Construct output directory + if output: + # Output files to directory specified + output_dir = os.path.join(output) + else: + # If no folder given, add datastream folder + # to current working dir to prevent file mix-up + output_dir = os.path.join(os.getcwd(), site_name + '_surfrad') + + if not os.path.isdir(output_dir): + os.makedirs(output_dir) + + # Set up doy ranges, taking into account changes for a new year + prev_doy = 0 + if e_doy < s_doy: + r = list(range(s_doy, 366)) + list(range(1, e_doy + 1)) + else: + r = list(range(s_doy, e_doy + 1)) + + # Set filename variable to return + filenames = [] + + # Loop through each doy in range + for doy in r: + # if the previous day is greater than current, assume a new year + # i.e. 365 -> 001 + if prev_doy > doy: + year += 1 + + # Add filename to url + file = site + str(year)[2:4] + str(doy) + '.dat' + new_url = url + site_name + '/' + str(year) + '/' + file + + # Write each file out to a file with same name as online + output_file = os.path.join(output_dir, file) + try: + print('Downloading ' + file) + with open(output_file, 'wb') as open_bytes_file: + open_bytes_file.write(urlopen(new_url).read()) + filenames.append(output_file) + except Exception: + pass + prev_doy = doy + + return filenames diff --git a/act/io/__init__.py b/act/io/__init__.py index 0bf33c5634..6549c83612 100644 --- a/act/io/__init__.py +++ b/act/io/__init__.py @@ -1,23 +1,44 @@ """ -=============== -act.io (act.io) -=============== - -.. currentmodule:: act.io - This module contains procedures for reading and writing various ARM datasets. -.. autosummary:: - :toctree: generated/ - - armfiles.check_arm_standards - armfiles.create_obj_from_arm_dod - armfiles.read_netcdf - csvfiles.read_csv - mpl.read_sigma_mplv5 """ -from . import armfiles -from . import csvfiles -from . import mpl -from . import noaagml +import lazy_loader as lazy + +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=['arm', 'text', 'icartt', 'mpl', 'neon', 'noaagml', 'noaapsl', 'pysp2', 'hysplit'], + submod_attrs={ + 'arm': [ + 'WriteDataset', + 'check_arm_standards', + 'create_ds_from_arm_dod', + 'read_arm_netcdf', + 'check_if_tar_gz_file', + 'read_arm_mmcr', + ], + 'text': ['read_csv'], + 'icartt': ['read_icartt'], + 'mpl': ['proc_sigma_mplv5_read', 'read_sigma_mplv5'], + 'neon': ['read_neon_csv'], + 'noaagml': [ + 'read_gml', + 'read_gml_co2', + 'read_gml_halo', + 'read_gml_met', + 'read_gml_ozone', + 'read_gml_radiation', + 'read_surfrad', + ], + 'noaapsl': [ + 'read_psl_wind_profiler', + 'read_psl_wind_profiler_temperature', + 'read_psl_parsivel', + 'read_psl_radar_fmcw_moment', + 'read_psl_surface_met', + ], + 'pysp2': ['read_hk_file', 'read_sp2', 'read_sp2_dat'], + 'sodar': ['read_mfas_sodar'], + 'hysplit': ['read_hysplit'] + }, +) diff --git a/act/io/arm.py b/act/io/arm.py new file mode 100644 index 0000000000..8f9aa38ed4 --- /dev/null +++ b/act/io/arm.py @@ -0,0 +1,890 @@ +""" +This module contains I/O operations for loading files that were created for the +Atmospheric Radiation Measurement program supported by the Department of Energy +Office of Science. +""" + +import copy +import datetime as dt +import glob +import json +import re +import tarfile +import tempfile +import urllib +import warnings +from os import PathLike +from pathlib import Path, PosixPath + +import numpy as np +import xarray as xr +from cftime import num2date +from netCDF4 import Dataset + +import act +import act.utils as utils +from act.config import DEFAULT_DATASTREAM_NAME +from act.utils.io_utils import cleanup_files, is_gunzip_file, unpack_gzip, unpack_tar + + +def read_arm_netcdf( + filenames, + concat_dim=None, + return_None=False, + combine='by_coords', + decode_times=True, + use_cftime=True, + use_base_time=False, + combine_attrs='override', + cleanup_qc=False, + keep_variables=None, + **kwargs, +): + """ + + Returns `xarray.Dataset` with stored data and metadata from a user-defined + query of ARM-standard netCDF files from a single datastream. Has some procedures + to ensure time is correctly fomatted in returned Dataset. + + Parameters + ---------- + filenames : str, pathlib.PosixPath, list of str, list of pathlib.PosixPath + Name of file(s) to read. + concat_dim : str + Dimension to concatenate files along. + return_None : boolean + Catch IOError exception when file not found and return None. + Default is False. + combine : str + String used by xarray.open_mfdataset() to determine how to combine + data files into one Dataset. See Xarray documentation for options. + decode_times : boolean + Standard Xarray option to decode time values from int/float to python datetime values. + Appears the default is to do this anyway but need this option to allow correct usage + of use_base_time. + use_cftime : boolean + Option to use cftime library to parse the time units string and correctly + establish the time values with a units string containing timezone offset. + This is used because the Pandas units string parser does not correctly recognize + time zone offset. Code will automatically detect cftime object and convert to datetime64 + in returned Dataset. + use_base_time : boolean + Option to use ARM time variables base_time and time_offset. Useful when the time variable + is not included (older files) or when the units attribute is incorrectly formatted. Will use + the values of base_time and time_offset as seconds since epoch and create datetime64 values + for time coordinate. If set will change decode_times and use_cftime to False. + combine_attrs : str + String indicating how to combine attrs of the datasets being merged + cleanup_qc : boolean + Call clean.cleanup() method to convert to standardized ancillary quality control + variables. This will not allow any keyword options, so if non-default behavior is + desired will need to call clean.cleanup() method on the dataset after reading the data. + keep_variables : str or list of str + Variable names to read from data file. Works by creating a list of variable names + to exclude from reading and passing into open_mfdataset() via drop_variables keyword. + Still allows use of drop_variables keyword for variables not listed in first file to + read. + **kwargs : keywords + Keywords to pass through to xarray.open_mfdataset(). + + Returns + ------- + ds : xarray.Dataset (or None) + ACT Xarray dataset (or None if no data file(s) found). + + Examples + -------- + This example will load the example sounding data used for unit testing. + + .. code-block :: python + + import act + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_SONDE_WILDCARD) + print(ds) + + """ + + ds = None + filenames, cleanup_temp_directory = check_if_tar_gz_file(filenames) + + file_dates = [] + file_times = [] + + # If requested to use base_time and time_offset, set keywords to correct attribute values + # to pass into xarray open_mfdataset(). Need to turn off decode_times and use_cftime + # or else will try to convert base_time and time_offset. Depending on values of attributes + # may cause a failure. + if use_base_time: + decode_times = False + use_cftime = False + + # Add funciton keywords to kwargs dictionary for passing into open_mfdataset. + kwargs['combine'] = combine + kwargs['concat_dim'] = concat_dim + kwargs['decode_times'] = decode_times + kwargs['use_cftime'] = use_cftime + if len(filenames) > 1 and not isinstance(filenames, str): + kwargs['combine_attrs'] = combine_attrs + + # Check if keep_variables is set. If so determine correct drop_variables + if keep_variables is not None: + drop_variables = None + if 'drop_variables' in kwargs.keys(): + drop_variables = kwargs['drop_variables'] + kwargs['drop_variables'] = keep_variables_to_drop_variables( + filenames, keep_variables, drop_variables=drop_variables + ) + + # Create an exception tuple to use with try statements. Doing it this way + # so we can add the FileNotFoundError if requested. Can add more error + # handling in the future. + except_tuple = (ValueError,) + if return_None: + except_tuple = except_tuple + (FileNotFoundError, OSError) + + try: + # Read data file with Xarray function + ds = xr.open_mfdataset(filenames, **kwargs) + + except except_tuple as exception: + # If requested return None for File not found error + if type(exception).__name__ == 'FileNotFoundError': + return None + + # If requested return None for File not found error + if type(exception).__name__ == 'OSError' and exception.args[0] == 'no files to open': + return None + + # Look at error message and see if could be nested error message. If so + # update combine keyword and try again. This should allow reading files + # without a time variable but base_time and time_offset variables. + if ( + kwargs['combine'] != 'nested' + and type(exception).__name__ == 'ValueError' + and exception.args[0] == 'Could not find any dimension coordinates ' + 'to use to order the datasets for concatenation' + ): + kwargs['combine'] = 'nested' + ds = xr.open_mfdataset(filenames, **kwargs) + + else: + # When all else fails raise the orginal exception + raise exception + + # If requested use base_time and time_offset to derive time. Assumes that the units + # of both are in seconds and that the value is number of seconds since epoch. + if use_base_time: + time = num2date( + ds['base_time'].values + ds['time_offset'].values, ds['base_time'].attrs['units'] + ) + time = time.astype('datetime64[ns]') + + # Need to use a new Dataset creation to correctly index time for use with + # .group and .resample methods in Xarray Datasets. + temp_ds = xr.Dataset({'time': (ds['time'].dims, time, ds['time'].attrs)}) + ds['time'] = temp_ds['time'] + del temp_ds + for att_name in ['units', 'ancillary_variables']: + try: + del ds['time'].attrs[att_name] + except KeyError: + pass + + # Xarray has issues reading a CF formatted time units string if it contains + # timezone offset without a [+|-] preceeding timezone offset. + # https://github.com/pydata/xarray/issues/3644 + # To ensure the times are read in correctly need to set use_cftime=True. + # This will read in time as cftime object. But Xarray uses numpy datetime64 + # natively. This will convert the cftime time values to numpy datetime64. + desired_time_precision = 'datetime64[ns]' + for var_name in ['time', 'time_offset']: + try: + if 'time' in ds.dims and type(ds[var_name].values[0]).__module__.startswith('cftime.'): + # If we just convert time to datetime64 the group, sel, and other Xarray + # methods will not work correctly because time is not indexed. Need to + # use the formation of a Dataset to correctly set the time indexing. + temp_ds = xr.Dataset( + { + var_name: ( + ds[var_name].dims, + ds[var_name].values.astype(desired_time_precision), + ds[var_name].attrs, + ) + } + ) + ds[var_name] = temp_ds[var_name] + del temp_ds + + # If time_offset is in file try to convert base_time as well + if var_name == 'time_offset': + ds['base_time'].values = ds['base_time'].values.astype(desired_time_precision) + ds['base_time'] = ds['base_time'].astype(desired_time_precision) + except KeyError: + pass + + # Check if "time" variable is not in the netCDF file. If so try to use + # base_time and time_offset to make time variable. Basically a fix for incorrectly + # formatted files. May require using decode_times=False to initially read the data. + if 'time' in ds.dims and not np.issubdtype(ds['time'].dtype, np.datetime64): + try: + ds['time'] = ds['time_offset'] + except (KeyError, ValueError): + pass + + # Adding support for wildcards + if isinstance(filenames, str): + filenames = glob.glob(filenames) + elif isinstance(filenames, PosixPath): + filenames = [filenames] + + # Get file dates and times that were read in to the dataset + filenames.sort() + for f in filenames: + f = Path(f).name + pts = re.match(r'(^[a-zA-Z0-9]+)\.([0-9a-z]{2})\.([\d]{8})\.([\d]{6})\.([a-z]{2,3}$)', f) + # If Not ARM format, read in first time for info + if pts is not None: + pts = pts.groups() + file_dates.append(pts[2]) + file_times.append(pts[3]) + else: + if ds['time'].size > 1: + dummy = ds['time'].values[0] + else: + dummy = ds['time'].values + file_dates.append(utils.numpy_to_arm_date(dummy)) + file_times.append(utils.numpy_to_arm_date(dummy, returnTime=True)) + + # Add attributes + ds.attrs['_file_dates'] = file_dates + ds.attrs['_file_times'] = file_times + is_arm_file_flag = check_arm_standards(ds) + + # Ensure that we have _datastream set whether or no there's + # a datastream attribute already. + if is_arm_file_flag == 0: + ds.attrs['_datastream'] = DEFAULT_DATASTREAM_NAME + else: + ds.attrs['_datastream'] = ds.attrs['datastream'] + + ds.attrs['_arm_standards_flag'] = is_arm_file_flag + + if cleanup_qc: + ds.clean.cleanup() + + if cleanup_temp_directory: + cleanup_files(files=filenames) + + return ds + + +def keep_variables_to_drop_variables(filenames, keep_variables, drop_variables=None): + """ + Returns a list of variable names to exclude from reading by passing into + `Xarray.open_dataset` drop_variables keyword. This can greatly help reduce + loading time and disk space use of the Dataset. + + When passed a netCDF file name, will open the file using the netCDF4 library to get + list of variable names. There is less overhead reading the varible names using + netCDF4 library than Xarray. If more than one filename is provided or string is + used for shell syntax globbing, will use the first file in the list. + + Parameters + ---------- + filenames : str, pathlib.PosixPath or list of str + Name of file(s) to read. + keep_variables : str or list of str + Variable names desired to keep. Do not need to list associated dimention + names. These will be automatically kept as well. + drop_variables : str or list of str + Variable names to explicitly add to returned list. May be helpful if a variable + exists in a file that is not in the first file in the list. + + Returns + ------- + drop_vars : list of str + Variable names to exclude from returned Dataset by using drop_variables keyword + when calling Xarray.open_dataset(). + + Examples + -------- + .. code-block :: python + + import act + filename = '/data/datastream/hou/houkasacrcfrM1.a1/houkasacrcfrM1.a1.20220404.*.nc' + drop_vars = act.io.arm.keep_variables_to_drop_variables( + filename, ['lat','lon','alt','crosspolar_differential_phase'], + drop_variables='variable_name_that_only_exists_in_last_file_of_the_day') + + """ + read_variables = [] + return_variables = [] + + if isinstance(keep_variables, str): + keep_variables = [keep_variables] + + if isinstance(drop_variables, str): + drop_variables = [drop_variables] + + # If filenames is a list subset to first file name. + if isinstance(filenames, (list, tuple)): + filename = filenames[0] + # If filenames is a string, check if it needs to be expanded in shell + # first. Then use first returned file name. Else use the string filename. + elif isinstance(filenames, str): + filename = glob.glob(filenames) + if len(filename) == 0: + return return_variables + else: + filename.sort() + filename = filename[0] + + # Use netCDF4 library to extract the variable and dimension names. + rootgrp = Dataset(filename, 'r') + read_variables = list(rootgrp.variables) + # Loop over the variables to exclude needed coordinate dimention names. + dims_to_keep = [] + for var_name in keep_variables: + try: + dims_to_keep.extend(list(rootgrp[var_name].dimensions)) + except IndexError: + pass + + rootgrp.close() + + # Remove names not matching keep_varibles excluding the associated coordinate dimentions + return_variables = set(read_variables) - set(keep_variables) - set(dims_to_keep) + + # Add drop_variables to list + if drop_variables is not None: + return_variables = set(return_variables) | set(drop_variables) + + return list(return_variables) + + +def check_arm_standards(ds): + """ + + Checks to see if an xarray dataset conforms to ARM standards. + + Parameters + ---------- + ds : Xarray Dataset + The dataset to check. + + Returns + ------- + flag : int + The flag corresponding to whether or not the file conforms + to ARM standards. Bit packed, so 0 for no, 1 for yes + + """ + the_flag = 1 << 0 + if 'datastream' not in ds.attrs.keys(): + the_flag = 0 + + # Check if the historical global attribute name is + # used instead of updated name of 'datastream'. If so + # correct the global attributes and flip flag. + if 'zeb_platform' in ds.attrs.keys(): + ds.attrs['datastream'] = copy.copy(ds.attrs['zeb_platform']) + del ds.attrs['zeb_platform'] + the_flag = 1 << 0 + + return the_flag + + +def create_ds_from_arm_dod( + proc, set_dims, version='', fill_value=-9999.0, scalar_fill_dim=None, local_file=False +): + """ + + Queries the ARM DOD api and builds a dataset based on the ARM DOD and + the dimension sizes that are passed in. + + Parameters + ---------- + proc : string + Process to create the dataset off of. This is normally in the + format of inst.level. i.e. vdis.b1 or kazrge.a1. If local file + is true, this points to the path of the .dod file. + set_dims : dict + Dictionary of dims from the DOD and the corresponding sizes. + Time is required. Code will try and pull from DOD, unless set + through this variable + Note: names need to match exactly what is in the dod + i.e. {'drop_diameter': 50, 'time': 1440} + version : string + Version number of the ingest to use. If not set, defaults to + latest version + fill_value : float + Fill value for non-dimension variables. Dimensions cannot have + duplicate values and are incrementally set (0, 1, 2) + scalar_fill_dim : str + Depending on how the dataset is set up, sometimes the scalar values + are dimensioned to the main dimension. i.e. a lat/lon is set to have + a dimension of time. This is a way to set it up similarly. + local_file: bool + If true, the DOD will be loaded from a file whose name is proc. + If false, the DOD will be pulled from PCM. + Returns + ------- + ds : xarray.Dataset + ACT Xarray dataset populated with all variables and attributes. + + Examples + -------- + .. code-block :: python + + dims = {'time': 1440, 'drop_diameter': 50} + ds = act.io.arm.create_ds_from_arm_dod( + 'vdis.b1', dims, version='1.2', scalar_fill_dim='time') + + """ + # Set base url to get DOD information + if local_file is False: + base_url = 'https://pcm.arm.gov/pcm/api/dods/' + + # Get data from DOD api + with urllib.request.urlopen(base_url + proc) as url: + data = json.loads(url.read().decode()) + else: + with open(proc) as file: + data = json.loads(file.read()) + + # Check version numbers and alert if requested version in not available + keys = list(data['versions'].keys()) + if version not in keys: + warnings.warn( + ' '.join( + ['Version:', version, 'not available or not specified. Using Version:', keys[-1]] + ), + UserWarning, + ) + version = keys[-1] + + # Create empty xarray dataset + ds = xr.Dataset() + + # Get the global attributes and add to dataset + atts = {} + for a in data['versions'][version]['atts']: + if a['name'] == 'string': + continue + if a['value'] is None: + a['value'] = '' + atts[a['name']] = a['value'] + + ds.attrs = atts + + # Get variable information and create dataarrays that are + # then added to the dataset + # If not passed in through set_dims, will look to the DOD + # if not set in the DOD, then will raise error + variables = data['versions'][version]['vars'] + dod_dims = data['versions'][version]['dims'] + for d in dod_dims: + if d['name'] not in list(set_dims.keys()): + if d['length'] > 0: + set_dims[d['name']] = d['length'] + else: + raise ValueError( + 'Dimension length not set in DOD for ' + + d['name'] + + ', nor passed in through set_dim' + ) + for v in variables: + dims = v['dims'] + dim_shape = [] + # Using provided dimension data, fill array accordingly for easy overwrite + if len(dims) == 0: + if scalar_fill_dim is None: + data_na = fill_value + else: + data_na = np.full(set_dims[scalar_fill_dim], fill_value) + v['dims'] = scalar_fill_dim + else: + for d in dims: + dim_shape.append(set_dims[d]) + if len(dim_shape) == 1 and v['name'] == dims[0]: + data_na = np.arange(dim_shape[0]) + else: + data_na = np.full(dim_shape, fill_value) + + # Get attribute information. Had to do some things to get to print to netcdf + atts = {} + str_flag = False + for a in v['atts']: + if a['name'] == 'string': + str_flag = True + continue + if a['value'] is None: + continue + if str_flag and a['name'] == 'units': + continue + atts[a['name']] = a['value'] + + da = xr.DataArray(data=data_na, dims=v['dims'], name=v['name'], attrs=atts) + ds[v['name']] = da + + return ds + + +@xr.register_dataset_accessor('write') +class WriteDataset: + """ + + Class for cleaning up Dataset before writing to file. + + """ + + def __init__(self, xarray_ds): + self._ds = xarray_ds + + def write_netcdf( + self, + cleanup_global_atts=True, + cleanup_qc_atts=True, + join_char='__', + make_copy=True, + cf_compliant=False, + delete_global_attrs=['qc_standards_version', 'qc_method', 'qc_comment'], + FillValue=-9999, + cf_convention='CF-1.8', + **kwargs, + ): + """ + + This is a wrapper around Dataset.to_netcdf to clean up the Dataset before + writing to disk. Some things are added to global attributes during ACT reading + process, and QC variables attributes are modified during QC cleanup process. + This will modify before writing to disk to better + match Climate & Forecast standards. + + Parameters + ---------- + cleanup_global_atts : boolean + Option to cleanup global attributes by removing any global attribute + that starts with an underscore. + cleanup_qc_atts : boolean + Option to convert attributes that would be written as string array + to be a single character string. CF 1.7 does not allow string attribures. + Will use a single space a delimeter between values and join_char to replace + white space between words. + join_char : str + The character sting to use for replacing white spaces between words when converting + a list of strings to single character string attributes. + make_copy : boolean + Make a copy before modifying Dataset to write. For large Datasets this + may add processing time and memory. If modifying the Dataset is OK + try setting to False. + cf_compliant : boolean + Option to output file with additional attributes to make file Climate & Forecast + complient. May require runing .clean.cleanup() method on the dataset to fix other + issues first. This does the best it can but it may not be truely complient. You + should read the CF documents and try to make complient before writing to file. + delete_global_attrs : list + Optional global attributes to be deleted. Defaults to some standard + QC attributes that are not needed. Can add more or set to None to not + remove the attributes. + FillValue : int, float + The value to use as a _FillValue in output file. This is used to fix + issues with how Xarray handles missing_value upon reading. It's confusing + so not a perfect fix. Set to None to leave Xarray to do what it wants. + Set to a value to be the value used as _FillValue in the file and data + array. This should then remove missing_value attribute from the file as well. + cf_convention : str + The Climate and Forecast convention string to add to Conventions attribute. + **kwargs : keywords + Keywords to pass through to Dataset.to_netcdf() + + Examples + -------- + .. code-block :: python + + ds.write.write_netcdf(path='output.nc') + + """ + + if make_copy: + write_ds = copy.deepcopy(self._ds) + else: + write_ds = self._ds + + encoding = {} + if cleanup_global_atts: + for attr in list(write_ds.attrs): + if attr.startswith('_'): + del write_ds.attrs[attr] + + if cleanup_qc_atts: + check_atts = ['flag_meanings', 'flag_assessments'] + for var_name in list(write_ds.data_vars): + if 'standard_name' not in write_ds[var_name].attrs.keys(): + continue + + for attr_name in check_atts: + try: + att_values = write_ds[var_name].attrs[attr_name] + if isinstance(att_values, (list, tuple)): + att_values = [ + att_value.replace(' ', join_char) for att_value in att_values + ] + write_ds[var_name].attrs[attr_name] = ' '.join(att_values) + + except KeyError: + pass + + # Tell .to_netcdf() to not add a _FillValue attribute for + # quality control variables. + if FillValue is not None: + encoding[var_name] = {'_FillValue': None} + + # Clean up _FillValue vs missing_value mess by creating an + # encoding dictionary with each variable's _FillValue set to + # requested fill value. May need to improve upon this for data type + # and other issues in the future. + if FillValue is not None: + skip_variables = ['base_time', 'time_offset', 'qc_time'] + list(encoding.keys()) + for var_name in list(write_ds.data_vars): + if var_name not in skip_variables: + encoding[var_name] = {'_FillValue': FillValue} + + if delete_global_attrs is not None: + for attr in delete_global_attrs: + try: + del write_ds.attrs[attr] + except KeyError: + pass + + for var_name in list(write_ds.keys()): + if 'string' in list(write_ds[var_name].attrs.keys()): + att = write_ds[var_name].attrs['string'] + write_ds[var_name].attrs[var_name + '_string'] = att + del write_ds[var_name].attrs['string'] + + # If requested update global attributes and variables attributes for required + # CF attributes. + if cf_compliant: + # Get variable names and standard name for each variable + var_names = list(write_ds.keys()) + standard_names = [] + for var_name in var_names: + try: + standard_names.append(write_ds[var_name].attrs['standard_name']) + except KeyError: + standard_names.append(None) + + # Check if time varible has axis and standard_name attribute + coord_name = 'time' + try: + write_ds[coord_name].attrs['axis'] + except KeyError: + try: + write_ds[coord_name].attrs['axis'] = 'T' + except KeyError: + pass + + try: + write_ds[coord_name].attrs['standard_name'] + except KeyError: + try: + write_ds[coord_name].attrs['standard_name'] = 'time' + except KeyError: + pass + + # Try to determine type of dataset by coordinate dimention named time + # and other factors + try: + write_ds.attrs['FeatureType'] + except KeyError: + dim_names = list(write_ds.dims) + FeatureType = None + if dim_names == ['time']: + FeatureType = 'timeSeries' + elif len(dim_names) == 2 and 'time' in dim_names and 'bound' in dim_names: + FeatureType = 'timeSeries' + elif len(dim_names) >= 2 and 'time' in dim_names: + for var_name in var_names: + dims = list(write_ds[var_name].dims) + if len(dims) == 2 and 'time' in dims: + prof_dim = list(set(dims) - {'time'})[0] + if write_ds[prof_dim].values.size > 2: + FeatureType = 'timeSeriesProfile' + break + + if FeatureType is not None: + write_ds.attrs['FeatureType'] = FeatureType + + # Add axis and positive attributes to variables with standard_name + # equal to 'altitude' + alt_variables = [ + var_names[ii] for ii, sn in enumerate(standard_names) if sn == 'altitude' + ] + for var_name in alt_variables: + try: + write_ds[var_name].attrs['axis'] + except KeyError: + write_ds[var_name].attrs['axis'] = 'Z' + + try: + write_ds[var_name].attrs['positive'] + except KeyError: + write_ds[var_name].attrs['positive'] = 'up' + + # Check if the Conventions global attribute lists the CF convention + try: + Conventions = write_ds.attrs['Conventions'] + Conventions = Conventions.split() + cf_listed = False + for ii in Conventions: + if ii.startswith('CF-'): + cf_listed = True + break + if not cf_listed: + Conventions.append(cf_convention) + write_ds.attrs['Conventions'] = ' '.join(Conventions) + + except KeyError: + write_ds.attrs['Conventions'] = str(cf_convention) + + # Reorder global attributes to ensure history is last + try: + history = copy.copy(write_ds.attrs['history']) + del write_ds.attrs['history'] + write_ds.attrs['history'] = history + except KeyError: + pass + current_time = dt.datetime.now().replace(microsecond=0) + if 'history' in list(write_ds.attrs.keys()): + write_ds.attrs['history'] += ''.join( + [ + '\n', + str(current_time), + ' created by ACT ', + str(act.__version__), + ' act.io.write.write_netcdf', + ] + ) + + if hasattr(write_ds, 'time_bounds') and not write_ds.time.encoding: + write_ds.time.encoding.update(write_ds.time_bounds.encoding) + + write_ds.to_netcdf(encoding=encoding, **kwargs) + + +def check_if_tar_gz_file(filenames): + """ + Unpacks gunzip and/or TAR file contents and returns Xarray Dataset + + ... + + Parameters + ---------- + filenames : str, pathlib.Path + Filenames to check if gunzip and/or tar files. + + + Returns + ------- + filenames : Paths to extracted files from gunzip or TAR files + + """ + + cleanup = False + if isinstance(filenames, (str, PathLike)): + try: + if is_gunzip_file(filenames) or tarfile.is_tarfile(str(filenames)): + tmpdirname = tempfile.mkdtemp() + cleanup = True + if is_gunzip_file(filenames): + filenames = unpack_gzip(filenames, write_directory=tmpdirname) + + if tarfile.is_tarfile(str(filenames)): + filenames = unpack_tar(filenames, write_directory=tmpdirname, randomize=False) + except Exception: + pass + + return filenames, cleanup + + +def read_arm_mmcr(filenames): + """ + + Reads in ARM MMCR files and splits up the variables into specific + mode variables based on what's in the files. MMCR files have the modes + interleaved and are not readable using xarray so some modifications are + needed ahead of time. + + Parameters + ---------- + filenames : str, pathlib.PosixPath or list of str + Name of file(s) to read. + + Returns + ------- + ds : xarray.Dataset (or None) + ACT Xarray dataset (or None if no data file(s) found). + + """ + + # Sort the files to make sure they concatenate right + filenames.sort() + + # Run through each file and read it in using netCDF4, then + # read it in with xarray + multi_ds = [] + for f in filenames: + nc = Dataset(f, 'a') + # Change heights name to range to read appropriately to xarray + if 'heights' in nc.dimensions: + nc.renameDimension('heights', 'range') + if nc is not None: + ds = xr.open_dataset(xr.backends.NetCDF4DataStore(nc)) + multi_ds.append(ds) + # Concatenate datasets together + if len(multi_ds) > 1: + ds = xr.concat(multi_ds, dim='time') + else: + ds = multi_ds[0] + + # Get mdoes and ranges with time/height modes + modes = ds['mode'].values + mode_vars = [] + for v in ds: + if 'range' in ds[v].dims and 'time' in ds[v].dims and len(ds[v].dims) == 2: + mode_vars.append(v) + + # For each mode, run extract data variables if available + # saves as individual variables in the file. + for m in modes: + if len(ds['ModeDescription'].shape) > 1: + mode_desc = ds['ModeDescription'].values[0, m] + if np.isnan(ds['heights'].values[0, m, :]).all(): + continue + range_data = ds['heights'].values[0, m, :] + else: + mode_desc = ds['ModeDescription'].values[m] + if np.isnan(ds['heights'].values[m, :]).all(): + continue + range_data = ds['heights'].values[m, :] + mode_desc = str(mode_desc).split('_')[-1][0:-1] + mode_desc = str(mode_desc).split('\'')[0] + idx = np.where(ds['ModeNum'].values == m)[0] + idy = np.where(~np.isnan(range_data))[0] + for v in mode_vars: + new_var_name = v + '_' + mode_desc + time_name = 'time_' + mode_desc + range_name = 'range_' + mode_desc + data = ds[v].values[idx, :] + data = data[:, idy] + attrs = ds[v].attrs + da = xr.DataArray( + data=data, + coords={time_name: ds['time'].values[idx], range_name: range_data[idy]}, + dims=[time_name, range_name], + attrs=attrs, + ) + ds[new_var_name] = da + + return ds diff --git a/act/io/armfiles.py b/act/io/armfiles.py deleted file mode 100644 index 556a4d71e6..0000000000 --- a/act/io/armfiles.py +++ /dev/null @@ -1,567 +0,0 @@ -""" -=============== -act.io.armfiles -=============== - -This module contains I/O operations for loading files that were created for the -Atmospheric Radiation Measurement program supported by the Department of Energy -Office of Science. - -""" -# import standard modules -import glob -import xarray as xr -import numpy as np -import urllib -import json -import copy -import act.utils as utils -import warnings - - -def read_netcdf(filenames, concat_dim='time', return_None=False, - combine='by_coords', use_cftime=True, cftime_to_datetime64=True, - **kwargs): - """ - Returns `xarray.Dataset` with stored data and metadata from a user-defined - query of ARM-standard netCDF files from a single datastream. Has some procedures - to ensure time is correctly fomatted in returned Dataset. - - Parameters - ---------- - filenames : str or list - Name of file(s) to read. - concat_dim : str - Dimension to concatenate files along. Default value is 'time.' - return_None : bool, optional - Catch IOError exception when file not found and return None. - Default is False. - combine : str - String used by xarray.open_mfdataset() to determine how to combine - data files into one Dataset. See Xarray documentation for options. - 'nested' will remove attributes that differ between files vs. - 'by_coords' which will use the last file's attribute value. - Default is 'by_coords'. - use_cftime : boolean - Option to use cftime library to parse the time units string and correctly - establish the time values with a units string containing timezone offset. - This will return the time in cftime format. See cftime_to_datetime64 if - don't want to convert the times in xarray dataset from cftime to numpy datetime64. - cftime_to_datetime64 : boolean - If time is stored as cftime in xarray dataset convert to numpy datetime64. If time - precision requried is sub millisecond set decode_times=False but leave - cftime_to_datetime64=True. This will force it to use base_time and time_offset - to set time. - **kwargs : keywords - Keywords to pass through to xarray.open_mfdataset(). - - Returns - ------- - act_obj : Object (or None) - ACT dataset (or None if no data file(s) found). - - Examples - -------- - This example will load the example sounding data used for unit testing. - - .. code-block:: python - - import act - - the_ds, the_flag = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE_WILDCARD) - print(the_ds.attrs._datastream) - - """ - file_dates = [] - file_times = [] - - # Add funciton keywords to kwargs dictionary for passing into open_mfdataset. - kwargs['combine'] = combine - kwargs['concat_dim'] = concat_dim - kwargs['use_cftime'] = use_cftime - - # Create an exception tuple to use with try statements. Doing it this way - # so we can add the FileNotFoundError if requested. Can add more error - # handling in the future. - except_tuple = (ValueError, ) - if return_None: - except_tuple = except_tuple + (FileNotFoundError, OSError) - - try: - # Read data file with Xarray function - arm_ds = xr.open_mfdataset(filenames, **kwargs) - - except except_tuple as exception: - # If requested return None for File not found error - if type(exception).__name__ == 'FileNotFoundError': - return None - - # If requested return None for File not found error - if type(exception).__name__ == 'OSError' and exception.args[0] == 'no files to open': - return None - - # Look at error message and see if could be nested error message. If so - # update combine keyword and try again. This should allow reading files - # without a time variable but base_time and time_offset variables. - if (kwargs['combine'] != 'nested' and type(exception).__name__ == 'ValueError' and - exception.args[0] == "Could not find any dimension coordinates " - "to use to order the datasets for concatenation"): - kwargs['combine'] = 'nested' - arm_ds = xr.open_mfdataset(filenames, **kwargs) - - else: - # When all else fails raise the orginal exception - raise exception - - # Xarray has issues reading a CF formatted time units string if it contains - # timezone offset without a [+|-] preceeding timezone offset. - # https://github.com/pydata/xarray/issues/3644 - # To ensure the times are read in correctly need to set use_cftime=True. - # This will read in time as cftime object. But Xarray uses numpy datetime64 - # natively. This will convert the cftime time values to numpy datetime64. cftime - # does not preserve the time past ms precision. We will use ms precision for - # the conversion. - desired_time_precision = 'datetime64[ms]' - for var_name in ['time', 'time_offset']: - try: - if (cftime_to_datetime64 and 'time' in arm_ds.dims and - type(arm_ds[var_name].values[0]).__module__.startswith('cftime.')): - # If we just convert time to datetime64 the group, sel, and other Xarray - # methods will not work correctly because time is not indexed. Need to - # use the formation of a Dataset to correctly set the time indexing. - temp_ds = xr.Dataset( - {var_name: (arm_ds[var_name].dims, - arm_ds[var_name].astype(desired_time_precision), - arm_ds[var_name].attrs)}) - arm_ds[var_name] = temp_ds[var_name] - temp_ds.close() - - # If time_offset is in file try to convert base_time as well - if var_name == 'time_offset': - arm_ds['base_time'].values = \ - arm_ds['base_time'].values.astype(desired_time_precision) - except KeyError: - pass - - # Check if "time" variable is not in the netCDF file. If so try to use - # base_time and time_offset to make time variable. Basically a fix for incorrectly - # formatted files. May require using decode_times=False to initially read the data. - if (cftime_to_datetime64 and 'time' in arm_ds.dims and - 'time' not in arm_ds.coords and 'time_offset' in arm_ds.data_vars): - try: - arm_ds = arm_ds.rename({'time_offset': 'time'}) - arm_ds = arm_ds.set_coords('time') - del arm_ds['time'].attrs['units'] - except (KeyError, ValueError): - pass - - # If "time" is not a datetime64 use base_time to calcualte corect values to datetime64 - # by adding base_time to time_offset. time_offset was renamed to time above. - if (cftime_to_datetime64 and 'time' in arm_ds.dims and 'base_time' in arm_ds.data_vars and - not np.issubdtype(arm_ds['time'].values.dtype, np.datetime64) and - not type(arm_ds['time'].values[0]).__module__.startswith('cftime.')): - # Use microsecond precision to create time since epoch. Then convert to datetime64 - if arm_ds['base_time'].values == arm_ds['time_offset'].values[0]: - time = arm_ds['time_offset'].values - else: - time = (arm_ds['base_time'].values + - arm_ds['time_offset'].values * 1000000.).astype('datetime64[us]') - # Need to use a new Dataset creation to correctly index time for use with - # .group and .resample methods in Xarray Datasets. - temp_ds = xr.Dataset({'time': (arm_ds['time'].dims, time, arm_ds['time'].attrs)}) - - arm_ds['time'] = temp_ds['time'] - temp_ds.close() - for att_name in ['units', 'ancillary_variables']: - try: - del arm_ds['time'].attrs[att_name] - except KeyError: - pass - - # Adding support for wildcards - if isinstance(filenames, str): - filenames = glob.glob(filenames) - - # Get file dates and times that were read in to the object - filenames.sort() - for f in filenames: - # If Not ARM format, read in first time for infos - if len(f.split('/')[-1].split('.')) == 5: - file_dates.append(f.split('.')[-3]) - file_times.append(f.split('.')[-2]) - else: - if arm_ds['time'].size > 1: - dummy = arm_ds['time'].values[0] - else: - dummy = arm_ds['time'].values - file_dates.append(utils.numpy_to_arm_date(dummy)) - file_times.append(utils.numpy_to_arm_date(dummy, returnTime=True)) - - # Add attributes - arm_ds.attrs['_file_dates'] = file_dates - arm_ds.attrs['_file_times'] = file_times - is_arm_file_flag = check_arm_standards(arm_ds) - - # Ensure that we have _datastream set whether or no there's - # a datastream attribute already. - if is_arm_file_flag == 0: - arm_ds.attrs['_datastream'] = "act_datastream" - else: - arm_ds.attrs['_datastream'] = arm_ds.attrs['datastream'] - - arm_ds.attrs['_arm_standards_flag'] = is_arm_file_flag - - return arm_ds - - -def check_arm_standards(ds): - """ - Checks to see if an xarray dataset conforms to ARM standards. - - Parameters - ---------- - ds : xarray dataset - The dataset to check. - - Returns - ------- - flag : int - The flag corresponding to whether or not the file conforms - to ARM standards. Bit packed, so 0 for no, 1 for yes - - """ - the_flag = (1 << 0) - if 'datastream' not in ds.attrs.keys(): - the_flag = 0 - - return the_flag - - -def create_obj_from_arm_dod(proc, set_dims, version='', fill_value=-9999., - scalar_fill_dim=None): - """ - Queries the ARM DOD api and builds an object based on the ARM DOD and - the dimension sizes that are passed in. - - Parameters - ---------- - proc : string - Process to create the object off of. This is normally in the - format of inst.level. i.e. vdis.b1 or kazrge.a1 - set_dims : dict - Dictionary of dims from the DOD and the corresponding sizes. - Time is required. Code will try and pull from DOD, unless set - through this variable - Note: names need to match exactly what is in the dod - i.e. {'drop_diameter': 50, 'time': 1440} - version : string - Version number of the ingest to use. If not set, defaults to - latest version - fill_value : float - Fill value for non-dimension variables. Dimensions cannot have - duplicate values and are incrementally set (0, 1, 2) - fill_value : str - Depending on how the object is set up, sometimes the scalar values - are dimensioned to the main dimension. i.e. a lat/lon is set to have - a dimension of time. This is a way to set it up similarly. - - Returns - ------- - obj : xarray Dataset - ACT object populated with all variables and attributes. - - Examples - -------- - .. code-block:: python - - dims = {'time': 1440, 'drop_diameter': 50} - obj = act.io.armfiles.create_obj_from_arm_dod( - 'vdis.b1', dims, version='1.2', scalar_fill_dim='time') - - """ - # Set base url to get DOD information - base_url = 'https://pcm.arm.gov/pcm/api/dods/' - - # Get data from DOD api - with urllib.request.urlopen(base_url + proc) as url: - data = json.loads(url.read().decode()) - - # Check version numbers and alert if requested version in not available - keys = list(data['versions'].keys()) - if version not in keys: - warnings.warn(' '.join(['Version:', version, - 'not available or not specified. Using Version:', keys[-1]]), - UserWarning) - version = keys[-1] - - # Create empty xarray dataset - obj = xr.Dataset() - - # Get the global attributes and add to dataset - atts = {} - for a in data['versions'][version]['atts']: - if a['name'] == 'string': - continue - if a['value'] is None: - a['value'] = '' - atts[a['name']] = a['value'] - - obj.attrs = atts - - # Get variable information and create dataarrays that are - # then added to the dataset - # If not passed in through set_dims, will look to the DOD - # if not set in the DOD, then will raise error - variables = data['versions'][version]['vars'] - dod_dims = data['versions'][version]['dims'] - for d in dod_dims: - if d['name'] not in list(set_dims.keys()): - if d['length'] > 0: - set_dims[d['name']] = d['length'] - else: - raise ValueError('Dimension length not set in DOD for ' + d['name'] + - ', nor passed in through set_dim') - for v in variables: - dims = v['dims'] - dim_shape = [] - # Using provided dimension data, fill array accordingly for easy overwrite - if len(dims) == 0: - if scalar_fill_dim is None: - data_na = fill_value - else: - data_na = np.full(set_dims[scalar_fill_dim], fill_value) - v['dims'] = scalar_fill_dim - else: - for d in dims: - dim_shape.append(set_dims[d]) - if len(dim_shape) == 1 and v['name'] == dims[0]: - data_na = np.arange(dim_shape[0]) - else: - data_na = np.full(dim_shape, fill_value) - - # Get attribute information. Had to do some things to get to print to netcdf - atts = {} - str_flag = False - for a in v['atts']: - if a['name'] == 'string': - str_flag = True - continue - if a['value'] is None: - continue - if str_flag and a['name'] == 'units': - continue - atts[a['name']] = a['value'] - - da = xr.DataArray(data=data_na, dims=v['dims'], name=v['name'], attrs=atts) - obj[v['name']] = da - - return obj - - -@xr.register_dataset_accessor('write') -class WriteDataset(object): - """ - Class for cleaning up Dataset before writing to file. - """ - def __init__(self, xarray_obj): - self._obj = xarray_obj - - def write_netcdf(self, cleanup_global_atts=True, cleanup_qc_atts=True, - join_char='__', make_copy=True, cf_compliant=False, - delete_global_attrs=['qc_standards_version', 'qc_method', 'qc_comment'], - FillValue=-9999, cf_convention='CF-1.8', **kwargs): - """ - This is a wrapper around Dataset.to_netcdf to clean up the Dataset before - writing to disk. Some things are added to global attributes during ACT reading - process, and QC variables attributes are modified during QC cleanup process. - This will modify before writing to disk to better - match Climate & Forecast standards. - - Parameters - ---------- - cleanup_global_atts : boolean - Option to cleanup global attributes by removing any global attribute - that starts with an underscore. - cleanup_qc_atts : boolean - Option to convert attributes that would be written as string array - to be a single character string. CF 1.7 does not allow string attribures. - Will use a single space a delimeter between values and join_char to replace - white space between words. - join_char : str - The character sting to use for replacing white spaces between words when converting - a list of strings to single character string attributes. - make_copy : boolean - Make a copy before modifying Dataset to write. For large Datasets this - may add processing time and memory. If modifying the Dataset is OK - try setting to False. - cf_compliant : boolean - Option to output file with additional attributes to make file Climate & Forecast - complient. May require runing .clean.cleanup() method on the object to fix other - issues first. This does the best it can but it may not be truely complient. You - should read the CF documents and try to make complient before writing to file. - delete_global_attrs : list - Optional global attributes to be deleted. Defaults to some standard - QC attributes that are not needed. Can add more or set to None to not - remove the attributes. - FillValue : int, float - The value to use as a _FillValue in output file. This is used to fix - issues with how Xarray handles missing_value upon reading. It's confusing - so not a perfect fix. Set to None to leave Xarray to do what it wants. - Set to a value to be the value used as _FillValue in the file and data - array. This should then remove missing_value attribute from the file as well. - cf_convention : str - The Climate and Forecast convention string to add to Conventions attribute. - **kwargs : keywords - Keywords to pass through to Dataset.to_netcdf() - - Examples - -------- - .. code-block:: python - - ds_object.write.write_netcdf(path='output.nc') - - """ - - encoding = {} - if cleanup_global_atts or cleanup_qc_atts: - if make_copy: - write_obj = copy.deepcopy(self._obj) - else: - write_obj = self._obj - - for attr in list(write_obj.attrs): - if attr.startswith('_'): - del write_obj.attrs[attr] - - check_atts = ['flag_meanings', 'flag_assessments'] - for var_name in list(write_obj.data_vars): - if 'standard_name' not in write_obj[var_name].attrs.keys(): - continue - for attr_name in check_atts: - try: - if isinstance(write_obj[var_name].attrs[attr_name], (list, tuple)): - att_values = write_obj[var_name].attrs[attr_name] - for ii, att_value in enumerate(att_values): - att_values[ii] = att_value.replace(' ', join_char) - - write_obj[var_name].attrs[attr_name] = ' '.join(att_values) - except KeyError: - pass - - # Tell .to_netcdf() to not add a _FillValue attribute for - # quality control variables. - if FillValue is not None: - encoding[var_name] = {'_FillValue': None} - - # Clean up _FillValue vs missing_value mess by creating an - # encoding dictionary with each variable's _FillValue set to - # requested fill value. May need to improve upon this for data type - # and other issues in the future. - if FillValue is not None: - skip_variables = (['base_time', 'time_offset', 'qc_time'] + - list(encoding.keys())) - for var_name in list(write_obj.data_vars): - if var_name not in skip_variables: - encoding[var_name] = {'_FillValue': FillValue} - - if delete_global_attrs is not None: - for attr in delete_global_attrs: - try: - del write_obj.attrs[attr] - except KeyError: - pass - - # If requested update global attributes and variables attributes for required - # CF attributes. - if cf_compliant: - # Get variable names and standard name for each variable - var_names = list(write_obj.keys()) - standard_names = [] - for var_name in var_names: - try: - standard_names.append(write_obj[var_name].attrs['standard_name']) - except KeyError: - standard_names.append(None) - - # Check if time varible has axis and standard_name attribute - coord_name = 'time' - try: - write_obj[coord_name].attrs['axis'] - except KeyError: - try: - write_obj[coord_name].attrs['axis'] = 'T' - except KeyError: - pass - - try: - write_obj[coord_name].attrs['standard_name'] - except KeyError: - try: - write_obj[coord_name].attrs['standard_name'] = 'time' - except KeyError: - pass - - # Try to determine type of dataset by coordinate dimention named time - # and other factors - try: - write_obj.attrs['FeatureType'] - except KeyError: - dim_names = list(write_obj.dims) - FeatureType = None - if dim_names == ['time']: - FeatureType = "timeSeries" - elif len(dim_names) == 2 and 'time' in dim_names and 'bound' in dim_names: - FeatureType = "timeSeries" - elif len(dim_names) >= 2 and 'time' in dim_names: - for var_name in var_names: - dims = list(write_obj[var_name].dims) - if len(dims) == 2 and 'time' in dims: - prof_dim = list(set(dims) - set(['time']))[0] - if write_obj[prof_dim].values.size > 2: - FeatureType = "timeSeriesProfile" - break - - if FeatureType is not None: - write_obj.attrs['FeatureType'] = FeatureType - - # Add axis and positive attributes to variables with standard_name - # equal to 'altitude' - alt_variables = [var_names[ii] for ii, sn in enumerate(standard_names) if sn == 'altitude'] - for var_name in alt_variables: - try: - write_obj[var_name].attrs['axis'] - except KeyError: - write_obj[var_name].attrs['axis'] = 'Z' - - try: - write_obj[var_name].attrs['positive'] - except KeyError: - write_obj[var_name].attrs['positive'] = 'up' - - # Check if the Conventions global attribute lists the CF convention - try: - Conventions = write_obj.attrs['Conventions'] - Conventions = Conventions.split() - cf_listed = False - for ii in Conventions: - if ii.startswith('CF-'): - cf_listed = True - break - if not cf_listed: - Conventions.append(cf_convention) - write_obj.attrs['Conventions'] = ' '.join(Conventions) - - except KeyError: - write_obj.attrs['Conventions'] = str(cf_convention) - - # Reorder global attributes to ensure history is last - try: - global_attrs = write_obj.attrs - history = copy.copy(global_attrs['history']) - del global_attrs['history'] - global_attrs['history'] = history - except KeyError: - pass - - write_obj.to_netcdf(encoding=encoding, **kwargs) diff --git a/act/io/conf/noaapsl_SurfaceMet.yaml b/act/io/conf/noaapsl_SurfaceMet.yaml new file mode 100644 index 0000000000..8735c1b9e7 --- /dev/null +++ b/act/io/conf/noaapsl_SurfaceMet.yaml @@ -0,0 +1,545 @@ +rjy: + info: + name: Roaring Judy, CO + lat: + value: 38.717235 + long_name: North latitude + units: degree_N + standard_name: latitude + lon: + value: 106.852563 + long_name: West longitude + units: degree_W + standard_name: longitude + alt: + value: 2498. + long_name: Altitude above mean sea level + units: m + standard_name: altitude + operational_date_range1: + _date_range: ['2021-09-28 03:20:00', '3000-01-01 00:00:00'] + Datalogger_ID: + _delete: True + Year: + _delete: True + J_day: + _delete: True + HoursMinutes: + _delete: True + Pressure: + long_name: Atmospheric Presure + units: mb + standard_name: air_pressure + _type: float32 + Temperature: + long_name: Atmospheric Temperature + units: degC + standard_name: air_temperature + _type: float32 + Relative_Humidity: + long_name: Atmospheric Relative_Humidity + units: percent + standard_name: relative_humidity + _type: float32 + Wind_Speed_Scalar: + long_name: Scalar Wind Speed + units: m/s + _type: float32 + Wind_Speed_Vector: + long_name: Vector Wind Speed + units: m/s + standard_name: wind_speed + _type: float32 + Wind_Direction: + long_name: Wind Direction + units: degree + standard_name: wind_from_direction + _type: float32 + Wind_Direction_STD: + long_name: Wind Direction Standard Deviation + units: degree + standard_name: wind_from_direction + cell_method: "time: standard_deviation" + _type: float32 + Battery_Voltage: + long_name: Logger Battery Voltage + units: V + _type: float32 + Wind_Speed_Max: + long_name: Maximum Wind Speed + units: m/s + standard_name: wind_speed_of_gust + _type: float32 + +kps: + info: + name: Kettle Ponds, CO + lat: + value: 38.942005 + long_name: North latitude + units: degree_N + standard_name: latitude + lon: + value: 106.973006 + long_name: West longitude + units: degree_W + standard_name: longitude + alt: + value: 2863. + long_name: Altitude above mean sea level + units: m + standard_name: altitude + operational_date_range1: + _date_range: ['2022-01-01 00:00:00', '3000-01-01 00:00:00'] + Datalogger_ID: + _delete: True + Year: + _delete: True + J_day: + _delete: True + HoursMinutes: + _delete: True + Pressure: + long_name: Atmospheric Presure + units: mb + standard_name: air_pressure + _type: float32 + Temperature: + long_name: Atmospheric Temperature + units: degC + standard_name: air_temperature + _type: float32 + Relative_Humidity: + long_name: Atmospheric Relative_Humidity + units: percent + standard_name: relative_humidity + _type: float32 + Wind_Speed_Scalar: + long_name: Scalar Wind Speed + units: m/s + _type: float32 + Wind_Direction: + long_name: Wind Direction + units: degree + standard_name: wind_from_direction + _type: float32 + Upward_Longwave_Irradiance: + long_name: Upward Longwave Irradiance + units: W/m^2 + _type: float32 + Downward_Longwave_Irradiance: + long_name: Downward Longwave Irradiance + units: W/m^2 + _type: float32 + Upward_Shortwave_Irradiance: + long_name: Upward Shortwave Irradiance + units: W/m^2 + _type: float32 + Downward_Shortwave_Irradiance: + long_name: Downward Shortwave Irradiance + units: W/m^2 + _type: float32 + Soil_Heat_Flux: + long_name: Soil Heat Flux Plate A + units: W/m^2 + _type: float32 + Unknown1: + _delete: True + Snow_Depth: + long_name: Snow Depth + units: m + _type: float32 + Unknown2: + _delete: True + Unknown3: + _delete: True + Unknown4: + _delete: True + Unknown5: + _delete: True + Unknown6: + _delete: True + Unknown7: + _delete: True + Unknown8: + _delete: True + Unknown9: + _delete: True + Unknown10: + _delete: True + Unknown11: + _delete: True + Unknown12: + _delete: True + Unknown13: + _delete: True + +ayp: + info: + name: Avery Picnic, CO + lat: + value: 38.972425 + long_name: North latitude + units: degree_N + standard_name: latitude + lon: + value: 106.99685 + long_name: West longitude + units: degree_W + standard_name: longitude + alt: + value: 2934. + long_name: Altitude above mean sea level + units: m + standard_name: altitude + operational_date_range1: + _date_range: ['2022-01-27 00:00:00', '3000-01-01 00:00:00'] + Datalogger_ID: + _delete: True + Year: + _delete: True + J_day: + _delete: True + HoursMinutes: + _delete: True + Pressure: + long_name: Atmospheric Presure + units: mb + standard_name: air_pressure + _type: float32 + Temperature: + long_name: Atmospheric Temperature + units: degC + standard_name: air_temperature + _type: float32 + Relative_Humidity: + long_name: Atmospheric Relative_Humidity + units: percent + standard_name: relative_humidity + _type: float32 + Wind_Speed_Scalar: + long_name: Scalar Wind Speed + units: m/s + _type: float32 + Wind_Direction: + long_name: Wind Direction + units: degree + standard_name: wind_from_direction + _type: float32 + Upward_Longwave_Irradiance: + long_name: Upward Longwave Irradiance + units: W/m^2 + _type: float32 + Downward_Longwave_Irradiance: + long_name: Downward Longwave Irradiance + units: W/m^2 + _type: float32 + Upward_Shortwave_Irradiance: + long_name: Upward Shortwave Irradiance + units: W/m^2 + _type: float32 + Downward_Shortwave_Irradiance: + long_name: Downward Shortwave Irradiance + units: W/m^2 + _type: float32 + Soil_Heat_Flux_A: + long_name: Soil Heat Flux Plate A + units: W/m^2 + _type: float32 + Soil_Heat_Flux_B: + long_name: Soil Heat Flux Plate B + units: W/m^2 + _type: float32 + Snow_Depth: + long_name: Snow Depth + units: m + _type: float32 + Soil_Temp_5cm: + long_name: Soil Temperature at 5 cm + units: degC + _type: float32 + _missing_value: 99999 + Soil_Temp_10cm: + long_name: Soil Temperature at 10 cm + units: degC + _type: float32 + _missing_value: 99999 + Soil_Temp_20cm: + long_name: Soil Temperature at 20 cm + units: degC + _type: float32 + _missing_value: 99999 + Soil_Temp_30cm: + long_name: Soil Temperature at 30 cm + units: degC + _type: float32 + _missing_value: 99999 + Soil_Temp_40cm: + long_name: Soil Temperature at 40 cm + units: degC + _type: float32 + _missing_value: 99999 + Soil_Temp_50cm: + long_name: Soil Temperature at 50 cm + units: degC + _type: float32 + _missing_value: 99999 + Soil_Water_Content_5cm: + long_name: Soil Water Content at 5 cm + units: percent + _type: float32 + _missing_value: 99999 + Soil_Water_Content_10cm: + long_name: Soil Water Content at 10 cm + units: percent + _type: float32 + _missing_value: 99999 + Soil_Water_Content_20cm: + long_name: Soil Water Content at 20 cm + units: percent + _type: float32 + _missing_value: 99999 + Soil_Water_Content_30cm: + long_name: Soil Water Content at 30 cm + units: percent + _type: float32 + _missing_value: 99999 + Soil_Water_Content_40cm: + long_name: Soil Water Content at 40 cm + units: percent + _type: float32 + _missing_value: 99999 + Soil_Water_Content_50cm: + long_name: Soil Water Content at 50 cm + units: percent + _type: float32 + _missing_value: 99999 + +rfe: + info: + name: Rifle (P031), CO + lat: + value: 39.51550 + long_name: North latitude + units: degree_N + standard_name: latitude + lon: + value: 107.9086 + long_name: West longitude + units: degree_W + standard_name: longitude + alt: + value: 1658. + long_name: Altitude above mean sea level + units: m + standard_name: altitude + operational_date_range1: + _date_range: ['2021-10-07 13:00:00', '3000-01-01 00:00:00'] + Datalogger_ID: + _delete: True + Year: + _delete: True + J_day: + _delete: True + HoursMinutes: + _delete: True + Pressure: + long_name: Atmospheric Presure + units: mb + standard_name: air_pressure + _type: float32 + Temperature: + long_name: Atmospheric Temperature + units: degC + standard_name: air_temperature + _type: float32 + Relative_Humidity: + long_name: Atmospheric Relative_Humidity + units: percent + standard_name: relative_humidity + _type: float32 + Wind_Speed_Scalar: + long_name: Scalar Wind Speed + units: m/s + _type: float32 + Wind_Direction: + long_name: Wind Direction + units: degree + standard_name: wind_from_direction + _type: float32 + +pvl: + info: + name: Platteville, CO + lat: + value: 40.18 + long_name: North latitude + units: degree_N + standard_name: latitude + lon: + value: 104.73 + long_name: West longitude + units: degree_W + standard_name: longitude + alt: + value: 1503. + long_name: Altitude above mean sea level + units: m + standard_name: altitude + operational_date_range1: + _date_range: ['2017-09-01 00:00:00', '3000-01-01 00:00:00'] + + Datalogger_ID: + _delete: True + Year: + _delete: True + J_day: + _delete: True + HoursMinutes: + _delete: True + Pressure: + long_name: Atmospheric Presure + units: mb + standard_name: air_pressure + _type: float32 + Temperature: + long_name: Atmospheric Temperature + units: degC + standard_name: air_temperature + _type: float32 + Relative_Humidity: + long_name: Atmospheric Relative_Humidity + units: percent + standard_name: relative_humidity + _type: float32 + Wind_Speed_Scalar: + long_name: Scalar Wind Speed + units: m/s + _type: float32 + Wind_Speed_Vector: + long_name: Vector Wind Speed + units: m/s + standard_name: wind_speed + _type: float32 + Wind_Direction: + long_name: Wind Direction + units: degree + standard_name: wind_from_direction + _type: float32 + Wind_Direction_STD: + long_name: Wind Direction Standard Deviation + units: degree + standard_name: wind_from_direction + cell_method: "time: standard_deviation" + _type: float32 + Solar_Radiation: + long_name: Solar Radiation + units: 'W/m^2' + Battery_Voltage: + long_name: Logger Battery Voltage + units: V + _type: float32 + Precipitation: + long_name: Precipitation + units: mm + _type: float32 + Wind_Speed_Max: + long_name: Maximum Wind Speed + units: m/s + standard_name: wind_speed_of_gust + _type: float32 + +mnt: + info: + name: Montrose (P029), CO + lat: + value: 38.4392 + long_name: North latitude + units: degree_N + standard_name: latitude + lon: + value: 107.6380 + long_name: West longitude + units: degree_W + standard_name: longitude + alt: + value: 2456. + long_name: Altitude above mean sea level + units: m + standard_name: altitude + operational_date_range2: + _date_range: ['2019-02-14 19:00:00', '3000-01-01 00:00:00'] + Datalogger_ID: + _delete: True + Year: + _delete: True + J_day: + _delete: True + HoursMinutes: + _delete: True + Pressure: + long_name: Atmospheric Presure + units: mb + standard_name: air_pressure + _type: float32 + Temperature: + long_name: Atmospheric Temperature + units: degC + standard_name: air_temperature + _type: float32 + Relative_Humidity: + long_name: Atmospheric Relative_Humidity + units: percent + standard_name: relative_humidity + _type: float32 + Wind_Speed_Scalar: + long_name: Scalar Wind Speed + units: m/s + _type: float32 + Wind_Direction: + long_name: Wind Direction + units: degree + standard_name: wind_from_direction + _type: float32 + operational_date_range1: + _date_range: ['2012-06-22 00:00:00', '2019-02-14 18:59:00'] + Datalogger_ID: + _delete: True + Year: + _delete: True + J_day: + _delete: True + HoursMinutes: + _delete: True + Pressure: + long_name: Atmospheric Presure + units: mb + standard_name: air_pressure + _type: float32 + Temperature: + long_name: Atmospheric Temperature + units: degC + standard_name: air_temperature + _type: float32 + Relative_Humidity: + long_name: Atmospheric Relative_Humidity + units: percent + standard_name: relative_humidity + _type: float32 + Wind_Speed_Scalar: + long_name: Scalar Wind Speed + units: m/s + _type: float32 + Wind_Direction: + long_name: Wind Direction + units: degree + standard_name: wind_from_direction + _type: float32 + Precipitation: + long_name: Precipitation + units: mm + _type: float32 + Hail: + long_name: Hail + units: mm + _type: float32 diff --git a/act/io/csvfiles.py b/act/io/csvfiles.py deleted file mode 100644 index 44327574be..0000000000 --- a/act/io/csvfiles.py +++ /dev/null @@ -1,93 +0,0 @@ -""" -=============== -act.io.csvfiles -=============== -This module contains I/O operations for loading csv files. - -""" - -# import standard modules -import pandas as pd -import pathlib - -from .armfiles import check_arm_standards - - -def read_csv(filename, sep=',', engine='python', column_names=None, - skipfooter=0, **kwargs): - - """ - Returns an `xarray.Dataset` with stored data and metadata from user-defined - query of CSV files. - - Parameters - ---------- - filenames : str or list - Name of file(s) to read. - sep : str - The separator between columns in the csv file. - column_names : list or None - The list of column names in the csv file. - verbose : bool - If true, will print if a file is not found. - - Additional keyword arguments will be passed into pandas.read_csv. - - Returns - ------- - act_obj : Object - ACT dataset. Will be None if the file is not found. - - Examples - -------- - This example will load the example sounding data used for unit testing: - - .. code-block:: python - - import act - the_ds, the_flag = act.io.csvfiles.read( - act.tests.sample_files.EXAMPLE_CSV_WILDCARD) - - """ - - # Convert to string if filename is a pathlib - if isinstance(filename, pathlib.PurePath): - filename = str(filename) - - if isinstance(filename, list) and isinstance(filename[0], pathlib.PurePath): - filename = [str(ii) for ii in filename] - - # Read data using pandas read_csv - arm_ds = pd.read_csv(filename, sep=sep, names=column_names, - skipfooter=skipfooter, engine=engine, **kwargs) - - # Set Coordinates if there's a variable date_time - if 'date_time' in arm_ds: - arm_ds.date_time = arm_ds.date_time.astype('datetime64') - arm_ds.time = arm_ds.date_time - arm_ds = arm_ds.set_index('time') - - # Convert to xarray DataSet - arm_ds = arm_ds.to_xarray() - - # Set additional variables - # Since we cannot assume a standard naming convention setting - # file_date and file_time to the first time in the file - x_coord = arm_ds.coords.to_index().values[0] - if isinstance(x_coord, str): - x_coord_dt = pd.to_datetime(x_coord) - arm_ds.attrs['_file_dates'] = x_coord_dt.strftime('%Y%m%d') - arm_ds.attrs['_file_times'] = x_coord_dt.strftime('%H%M%S') - - # Check for standard ARM datastream name, if none, assume the file is ARM - # standard format. - is_arm_file_flag = check_arm_standards(arm_ds) - if is_arm_file_flag == 0: - arm_ds.attrs['_datastream'] = '.'.join(filename.split('/')[-1].split('.')[0:2]) - - # Add additional attributes, site, standards flag, etc... - arm_ds.attrs['_site'] = str(arm_ds.attrs['_datastream'])[0:3] - - arm_ds.attrs['_arm_standards_flag'] = is_arm_file_flag - - return arm_ds diff --git a/act/io/hysplit.py b/act/io/hysplit.py new file mode 100644 index 0000000000..f0c410d0eb --- /dev/null +++ b/act/io/hysplit.py @@ -0,0 +1,105 @@ +import os +import xarray as xr +import numpy as np +import pandas as pd + +from datetime import datetime +from .text import read_csv + + +def read_hysplit(filename, base_year=2000): + """ + Reads an input HYSPLIT trajectory for plotting in ACT. + + Parameters + ---------- + filename: str + The input file name. + base_year: int + The first year of the century in which the data are contained. + + Returns + ------- + ds: xarray Dataset + The ACT dataset containing the HYSPLIT trajectories + """ + + ds = xr.Dataset({}) + num_lines = 0 + with open(filename, 'r') as filebuf: + num_grids = int(filebuf.readline().split()[0]) + num_lines += 1 + grid_times = [] + grid_names = [] + forecast_hours = np.zeros(num_grids) + for i in range(num_grids): + data = filebuf.readline().split() + num_lines += 1 + grid_names.append(data[0]) + grid_times.append( + datetime(year=int(data[1]), month=int(data[2]), day=int(data[3]), hour=int(data[4]))) + forecast_hours[i] = int(data[5]) + ds["grid_forecast_hour"] = xr.DataArray(forecast_hours, dims=["num_grids"]) + ds["grid_forecast_hour"].attrs["standard_name"] = "Grid forecast hour" + ds["grid_forecast_hour"].attrs["units"] = "Hour [UTC]" + ds["grid_times"] = xr.DataArray(np.array(grid_times), dims=["num_grids"]) + data_line = filebuf.readline().split() + num_lines += 1 + ds.attrs["trajectory_direction"] = data_line[1] + ds.attrs["vertical_motion_calculation_method"] = data_line[2] + num_traj = int(data_line[0]) + traj_times = [] + start_lats = np.zeros(num_traj) + start_lons = np.zeros(num_traj) + start_alt = np.zeros(num_traj) + for i in range(num_traj): + data = filebuf.readline().split() + num_lines += 1 + traj_times.append( + datetime(year=(base_year + int(data[0])), month=int(data[1]), + day=int(data[2]), hour=int(data[3]))) + start_lats[i] = float(data[4]) + start_lons[i] = float(data[5]) + start_alt[i] = float(data[6]) + + ds["start_latitude"] = xr.DataArray(start_lats, dims=["num_trajectories"]) + ds["start_latitude"].attrs["long_name"] = "Trajectory start latitude" + ds["start_latitude"].attrs["units"] = "degree" + ds["start_longitude"] = xr.DataArray(start_lats, dims=["num_trajectories"]) + ds["start_longitude"].attrs["long_name"] = "Trajectory start longitude" + ds["start_longitude"].attrs["units"] = "degree" + ds["start_altitude"] = xr.DataArray(start_alt, dims=["num_trajectories"]) + ds["start_altitude"].attrs["long_name"] = "Trajectory start altitude" + ds["start_altitude"].attrs["units"] = "degree" + data = filebuf.readline().split() + num_lines += 1 + var_list = ["trajectory_number", "grid_number", "year", "month", "day", + "hour", "minute", "forecast_hour", "age", "lat", "lon", "alt"] + for variable in data[1:]: + var_list.append(variable) + input_df = pd.read_csv( + filename, sep='\s+', index_col=False, names=var_list, skiprows=12) + input_df['year'] = base_year + input_df['year'] + input_df['time'] = pd.to_datetime(input_df[["year", "month", "day", "hour", "minute"]], + format='%y%m%d%H%M') + input_df = input_df.set_index("time") + del input_df["year"] + del input_df["month"] + del input_df["day"] + del input_df["hour"] + del input_df["minute"] + ds = ds.merge(input_df.to_xarray()) + ds.attrs['datastream'] = 'hysplit' + ds["trajectory_number"].attrs["standard_name"] = "Trajectory number" + ds["trajectory_number"].attrs["units"] = "1" + ds["grid_number"].attrs["standard_name"] = "Grid number" + ds["grid_number"].attrs["units"] = "1" + ds["age"].attrs["standard_name"] = "Grid number" + ds["age"].attrs["units"] = "1" + ds["lat"].attrs["standard_name"] = "Latitude" + ds["lat"].attrs["units"] = "degree" + ds["lon"].attrs["standard_name"] = "Longitude" + ds["lon"].attrs["units"] = "degree" + ds["alt"].attrs["standard_name"] = "Altitude" + ds["alt"].attrs["units"] = "meter" + return ds diff --git a/act/io/icartt.py b/act/io/icartt.py new file mode 100644 index 0000000000..2941d29186 --- /dev/null +++ b/act/io/icartt.py @@ -0,0 +1,173 @@ +""" +Modules for Reading/Writing the International Consortium for Atmospheric +Research on Transport and Transformation (ICARTT) file format standards V2.0 + +References: + ICARTT V2.0 Standards/Conventions: + - https://www.earthdata.nasa.gov/s3fs-public/imported/ESDS-RFC-029v2.pdf + +""" +import numpy as np +import xarray as xr + +try: + import icartt + _ICARTT_AVAILABLE = True + _format = icartt.Formats.FFI1001 +except ImportError: + _ICARTT_AVAILABLE = False + _format = None + + +def read_icartt(filename, format=_format, + return_None=False, **kwargs): + """ + + Returns `xarray.Dataset` with stored data and metadata from a user-defined + query of ICARTT from a single datastream. Has some procedures to ensure + time is correctly fomatted in returned Dataset. + + Parameters + ---------- + filename : str + Name of file to read. + format : str + ICARTT Format to Read: FFI1001 or FFI2110. + return_None : bool, optional + Catch IOError exception when file not found and return None. + Default is False. + **kwargs : keywords + keywords to pass on through to icartt.Dataset. + + Returns + ------- + ds : xarray.Dataset (or None) + ACT Xarray dataset (or None if no data file(s) found). + + Examples + -------- + This example will load the example sounding data used for unit testing. + + .. code-block :: python + + import act + ds = act.io.icartt.read_icartt(act.tests.sample_files.AAF_SAMPLE_FILE) + print(ds.attrs['_datastream']) + + """ + if not _ICARTT_AVAILABLE: + raise ImportError( + "ICARTT is required to use to read ICARTT files but is not installed") + + ds = None + + # Create an exception tuple to use with try statements. Doing it this way + # so we can add the FileNotFoundError if requested. Can add more error + # handling in the future. + except_tuple = (ValueError,) + if return_None: + except_tuple = except_tuple + (FileNotFoundError, OSError) + + try: + # Read data file with ICARTT dataset. + ict = icartt.Dataset(filename, format=format, **kwargs) + + except except_tuple as exception: + # If requested return None for File not found error + if type(exception).__name__ == 'FileNotFoundError': + return None + + # If requested return None for File not found error + if (type(exception).__name__ == 'OSError' + and exception.args[0] == 'no files to open'): + return None + + # Define the Uncertainty for each variable. Note it may not be calculated. + # If not calculated, assign 'N/A' to the attribute + uncertainty = ict.normalComments[6].split(':')[1].split(',') + + # Define the Upper and Lower Limit of Detection Flags + ulod_flag = ict.normalComments[7].split(':')[1] + ulod_value = ict.normalComments[8].split(':')[1].split(',') + llod_flag = ict.normalComments[9].split(':')[1] + llod_value = ict.normalComments[10].split(':')[1].split(',') + + # Convert ICARTT Object to Xarray Dataset + ds_container = [] + # Counter for uncertainty/LOD values + counter = 0 + + # Loop over ICART variables, convert to Xarray DataArray, Append. + for key in ict.variables: + # Note time is the only independent variable within ICARTT + # Short name for time must be "Start_UTC" for ICARTT files. + if key != 'Start_UTC': + if key == 'qc_flag': + key2 = 'quality_flag' + else: + key2 = key + da = xr.DataArray(ict.data[key], + coords=dict(time=ict.times), + name=key2, dims=['time']) + # Assume if Uncertainity does not match the number of variables, + # values were not set within the file. Needs to be string! + if len(uncertainty) != len(ict.variables): + da.attrs['uncertainty'] = 'N/A' + else: + da.attrs['uncertainty'] = uncertainty[counter] + + # Assume if ULOD does not match the number of variables within the + # the file, ULOD values were not set. + if len(ulod_value) != len(ict.variables): + da.attrs['ULOD_Value'] = 'N/A' + else: + da.attrs['ULOD_Value'] = ulod_value[counter] + + # Assume if LLOD does not match the number of variables within the + # the file, LLOD values were not set. + if len(llod_value) != len(ict.variables): + da.attrs['LLOD_Value'] = 'N/A' + else: + da.attrs['LLOD_Value'] = llod_value[counter] + # Define the meta data: + da.attrs['units'] = ict.variables[key].units + da.attrs['mvc'] = ict.variables[key].miss + da.attrs['scale_factor'] = ict.variables[key].scale + da.attrs['ULOD_Flag'] = ulod_flag + da.attrs['LLOD_Flag'] = llod_flag + # Append to ds container + ds_container.append(da.to_dataset(name=key2)) + # up the counter + counter += 1 + + # Concatenate each of the Xarray DataArrays into a single Xarray DataSet + ds = xr.merge(ds_container) + + # Assign ICARTT Meta data to Xarray DataSet + ds.attrs['PI'] = ict.PIName + ds.attrs['PI_Affiliation'] = ict.PIAffiliation + ds.attrs['Platform'] = ict.dataSourceDescription + ds.attrs['Mission'] = ict.missionName + ds.attrs['DateOfCollection'] = ict.dateOfCollection + ds.attrs['DateOfRevision'] = ict.dateOfRevision + ds.attrs['Data_Interval'] = ict.dataIntervalCode + ds.attrs['Independent_Var'] = str(ict.independentVariable) + ds.attrs['Dependent_Var_Num'] = len(ict.dependentVariables) + ds.attrs['PI_Contact'] = ict.normalComments[0].split('\n')[0].split(':')[-1] + ds.attrs['Platform'] = ict.normalComments[1].split(':')[-1] + ds.attrs['Location'] = ict.normalComments[2].split(':')[-1] + ds.attrs['Associated_Data'] = ict.normalComments[3].split(':')[-1] + ds.attrs['Instrument_Info'] = ict.normalComments[4].split(':')[-1] + ds.attrs['Data_Info'] = ict.normalComments[5][11:] + ds.attrs['DM_Contact'] = ict.normalComments[11].split(':')[-1] + ds.attrs['Project_Info'] = ict.normalComments[12].split(':')[-1] + ds.attrs['Stipulations'] = ict.normalComments[13].split(':')[-1] + ds.attrs['Comments'] = ict.normalComments[14].split(':')[-1] + ds.attrs['Revision'] = ict.normalComments[15].split(':')[-1] + ds.attrs['Revision_Comments'] = ict.normalComments[15 + 1].split(':')[-1] + + # Assign Additional ARM meta data to Xarray DatatSet + ds.attrs['_datastream'] = filename.split('/')[-1].split('_')[0] + + # Return Xarray Dataset + return ds diff --git a/act/io/mpl.py b/act/io/mpl.py index f95f4b94ea..7307276d14 100644 --- a/act/io/mpl.py +++ b/act/io/mpl.py @@ -1,8 +1,4 @@ """ -========== -act.io.mpl -========== - This module contains I/O operations for loading MPL files. """ @@ -11,12 +7,9 @@ import shutil import subprocess import tempfile - -import xarray as xr import dask - -from act.io.armfiles import check_arm_standards - +import xarray as xr +from act.io.arm import check_arm_standards if shutil.which('mpl2nc') is not None: MPLIMPORT = True @@ -24,8 +17,15 @@ MPLIMPORT = False -def read_sigma_mplv5(filename, save_nc=False, out_nc_path=None, afterpulse=None, - dead_time=None, overlap=None, **kwargs): +def read_sigma_mplv5( + filename, + save_nc=False, + out_nc_path=None, + afterpulse=None, + dead_time=None, + overlap=None, + **kwargs, +): """ Returns `xarray.Dataset` with stored data and metadata from a user-defined SIGMA MPL V5 files. File is converted to netCDF using mpl2nc an optional @@ -52,27 +52,36 @@ def read_sigma_mplv5(filename, save_nc=False, out_nc_path=None, afterpulse=None, """ if not MPLIMPORT: raise ImportError( - 'The module mpl2nc is not installed and is needed to read ' - 'mpl binary files!') + 'The module mpl2nc is not installed and is needed to read ' 'mpl binary files!' + ) if isinstance(filename, str): filename = [filename] task = [] for f in filename: - task.append(dask.delayed(proc_sigma_mplv5_read)(f, save_nc=save_nc, - out_nc_path=out_nc_path, afterpulse=afterpulse, dead_time=dead_time, - overlap=overlap, **kwargs)) - - results = dask.compute(*task) + task.append( + dask.delayed(proc_sigma_mplv5_read)( + f, + save_nc=save_nc, + out_nc_path=out_nc_path, + afterpulse=afterpulse, + dead_time=dead_time, + overlap=overlap, + **kwargs, + ) + ) + + results_ds = dask.compute(*task) + + ds = xr.concat(results_ds, 'time') - obj = xr.concat(results, 'time') - - return obj + return ds -def proc_sigma_mplv5_read(f, save_nc=False, out_nc_path=None, afterpulse=None, - dead_time=None, overlap=None, **kwargs): +def proc_sigma_mplv5_read( + f, save_nc=False, out_nc_path=None, afterpulse=None, dead_time=None, overlap=None, **kwargs +): """ Returns `xarray.Dataset` with stored data and metadata from a user-defined SIGMA MPL V5 files. File is converted to netCDF using mpl2nc an optional @@ -97,8 +106,7 @@ def proc_sigma_mplv5_read(f, save_nc=False, out_nc_path=None, afterpulse=None, """ - datastream_name = '.'.join( - f.split('/')[-1].split('.')[0:2]) + datastream_name = '.'.join(f.split('/')[-1].split('.')[0:2]) if '.bin' not in f: mpl = True tmpfile1 = tempfile.mkstemp(suffix='.bin', dir='.')[1] @@ -121,9 +129,7 @@ def proc_sigma_mplv5_read(f, save_nc=False, out_nc_path=None, afterpulse=None, # Specify the output, will use a temporary file if no output specified if save_nc: if out_nc_path is None: - raise ValueError( - 'You are using save_nc, please specify ' - 'an out_nc_path') + raise ValueError('You are using save_nc, please specify ' 'an out_nc_path') subprocess.call(call + ' ' + out_nc_path, shell=True) ds = xr.open_dataset(out_nc_path, **kwargs) @@ -138,8 +144,7 @@ def proc_sigma_mplv5_read(f, save_nc=False, out_nc_path=None, afterpulse=None, # Swap the coordinates to be time and range ds = ds.swap_dims({'profile': 'time'}) - ds = ds.assign_coords({'time': ds.time, - 'range': ds.range}) + ds = ds.assign_coords({'time': ds.time, 'range': ds.range}) # Add metadata is_arm_file_flag = check_arm_standards(ds) diff --git a/act/io/neon.py b/act/io/neon.py new file mode 100644 index 0000000000..86d9bbd3eb --- /dev/null +++ b/act/io/neon.py @@ -0,0 +1,108 @@ +""" +Modules for reading in NOAA PSL data. +""" + +import datetime as dt + +import numpy as np +import pandas as pd +import xarray as xr + +from .text import read_csv + + +def read_neon_csv(files, variable_files=None, position_files=None): + """ + Reads in the NEON formatted csv files from local paths or urls + and returns an Xarray dataset. + + Parameters + ---------- + filepath : list + Files to read in + variable_files : list + Name of variable files to read with metadata. Optional but the Dataset will not + have any metadata + position_files : list + Name of file to read with sensor positions. Optional, but the Dataset will not + have any location information + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset + + """ + + # Raise error if empty list is passed in + if len(files) == 0: + raise ValueError('File list is empty') + if isinstance(files, str): + files = [files] + + # Read in optional files + multi_ds = [] + if variable_files is not None: + if isinstance(variable_files, str): + variable_files = [variable_files] + df = pd.read_csv(variable_files[0]) + + if position_files is not None: + if isinstance(position_files, str): + position_files = [position_files] + loc_df = pd.read_csv(position_files[0], dtype=str) + + # Run through each file and read into a dataset + for i, f in enumerate(files): + ds = read_csv(f) + # Create standard time variable + time = [pd.to_datetime(t).replace(tzinfo=None) for t in ds['startDateTime'].values] + ds['time'] = xr.DataArray(data=time, dims=['index']) + ds['time'].attrs['units'] = '' + ds = ds.swap_dims({'index': 'time'}) + ds = ds.drop_vars('index') + + # Add some metadata + site_code = f.split('/')[-1].split('.')[2] + resolution = f.split('/')[-1].split('.')[9] + hor_loc = f.split('/')[-1].split('.')[6] + ver_loc = f.split('/')[-1].split('.')[7] + ds.attrs['_sites'] = site_code + ds.attrs['averaging_interval'] = resolution.split('_')[-1] + ds.attrs['HOR.VER'] = hor_loc + '.' + ver_loc + + # Add in metadata from the variables file + if variable_files is not None: + for v in ds: + dummy = df.loc[(df['table'] == resolution) & (df['fieldName'] == v)] + ds[v].attrs['units'] = str(dummy['units'].values[0]) + ds[v].attrs['long_name'] = str(dummy['description'].values[0]) + ds[v].attrs['format'] = str(dummy['pubFormat'].values[0]) + + # Add in sensor position data + if position_files is not None: + dloc = loc_df.loc[loc_df['HOR.VER'] == hor_loc + '.' + ver_loc] + idx = dloc.index.values + if len(idx) > 0: + ds['lat'] = xr.DataArray(data=float(loc_df['referenceLatitude'].values[idx])) + ds['lon'] = xr.DataArray(data=float(loc_df['referenceLongitude'].values[idx])) + ds['alt'] = xr.DataArray(data=float(loc_df['referenceElevation'].values[idx])) + variables = [ + 'xOffset', + 'yOffset', + 'zOffset', + 'eastOffset', + 'northOffset', + 'pitch', + 'roll', + 'azimuth', + 'xAzimuth', + 'yAzimuth', + ] + for v in variables: + ds[v] = xr.DataArray(data=float(loc_df[v].values[idx])) + multi_ds.append(ds) + + ds = xr.merge(multi_ds) + + return ds diff --git a/act/io/noaagml.py b/act/io/noaagml.py index db980b3fa0..59ee908a47 100644 --- a/act/io/noaagml.py +++ b/act/io/noaagml.py @@ -1,16 +1,23 @@ -import act +""" +Modules for reading in NOAA GML data + +""" +import re +from datetime import datetime from pathlib import Path + import numpy as np -from datetime import datetime +import pandas as pd import xarray as xr -import re +from .text import read_csv -def read_gml(filename, datatype=None, **kwargs): + +def read_gml(filename, datatype=None, remove_time_vars=True, convert_missing=True, **kwargs): """ - Function to call or guess what reading NOAA GML daga routine to use. It tries to - guess the correct reading function to call based on filename. It mostly - works, but you may want to specify for best results. + Function to call or guess what reading NOAA GML daga routine to use. It + tries to guess the correct reading function to call based on filename. + It mostly works, but you may want to specify for best results. Parameters ---------- @@ -21,12 +28,18 @@ def read_gml(filename, datatype=None, **kwargs): Data file type that bypasses the guessing from filename format and goes directly to the reading routine. Options include [MET, RADIATION, OZONE, CO2, HALO] + remove_time_vars : bool + Some variables are convereted into coordinate variables in Xarray + DataSet and not needed after conversion. This will remove those + variables. + convert_missing : bool + Convert missing value indicator in CSV to NaN in Xarray DataSet. **kwargs : keywords - Keywords to pass through to reading routine. + Keywords to pass through to instrument specific reading routine. Returns ------- - dataset : Xarray.dataset + ds : xarray.Dataset Standard ARM Xarray dataset with the data cleaned up to have units, long_name, correct type and some other stuff. @@ -34,19 +47,22 @@ def read_gml(filename, datatype=None, **kwargs): if datatype is not None: if datatype.upper() == 'MET': - return read_gml_met(filename, **kwargs) -# elif datatype.upper() == 'AEROSOL': -# return None + return read_gml_met(filename, convert_missing=convert_missing, **kwargs) elif datatype.upper() == 'RADIATION': - return read_gml_radiation(filename, **kwargs) + return read_gml_radiation( + filename, + remove_time_vars=remove_time_vars, + convert_missing=convert_missing, + **kwargs, + ) elif datatype.upper() == 'OZONE': return read_gml_ozone(filename, **kwargs) elif datatype.upper() == 'CO2': - return read_gml_co2(filename, **kwargs) + return read_gml_co2(filename, convert_missing=convert_missing, **kwargs) elif datatype.upper() == 'HALO': return read_gml_halo(filename, **kwargs) else: - raise ValueError("datatype is unknown") + raise ValueError('datatype is unknown') else: test_filename = filename @@ -56,37 +72,40 @@ def read_gml(filename, datatype=None, **kwargs): test_filename = str(Path(test_filename).name) if test_filename.startswith('met_') and test_filename.endswith('.txt'): - return read_gml_met(filename, **kwargs) + return read_gml_met(filename, convert_missing=convert_missing, **kwargs) if test_filename.startswith('co2_') and test_filename.endswith('.txt'): - return read_gml_co2(filename, **kwargs) - -# if test_filename.startswith('ESRL-GMD-AEROSOL_v') and test_filename.endswith('.nc'): -# ds_data = xr.open_dataset(str(filename), group='data') -# ds_absorption = xr.open_dataset(str(filename), group='data/light_absorption') -# ds_concentration = xr.open_dataset(str(filename), group='data/particle_concentration') -# ds_scattering = xr.open_dataset(str(filename), group='data/light_scattering') -# return (ds_data, ds_absorption, ds_concentration, ds_scattering) + return read_gml_co2(filename, convert_missing=convert_missing, **kwargs) result = re.match(r'([a-z]{3})([\d]{5}).dat', test_filename) if result is not None: - return read_gml_radiation(filename, **kwargs) - - ozone_pattern = [r'[a-z]{3}_[\d]{2}_[\d]{4}_hour.dat', - r'[a-z]{3}_[\d]{4}_all_minute.dat', - r'[a-z]{3}_[\d]{2}_[\d]{4}_5minute.dat', - r'[a-z]{3}_[\d]{2}_[\d]{4}_min.dat', - r'[a-z]{3}_o3_6m_hour_[\d]{2}_[\d]{4}.dat', - r'[a-z]{3}_ozone_houry__[\d]{4}'] + return read_gml_radiation( + filename, + remove_time_vars=remove_time_vars, + convert_missing=convert_missing, + **kwargs, + ) + + ozone_pattern = [ + r'[a-z]{3}_[\d]{4}_[\d]{2}_hour.dat', + r'[a-z]{3}_[\d]{2}_[\d]{4}_hour.dat', + r'[a-z]{3}_[\d]{4}_all_minute.dat', + r'[a-z]{3}_[\d]{2}_[\d]{4}_5minute.dat', + r'[a-z]{3}_[\d]{2}_[\d]{4}_min.dat', + r'[a-z]{3}_o3_6m_hour_[\d]{2}_[\d]{4}.dat', + r'[a-z]{3}_ozone_houry__[\d]{4}', + ] for pattern in ozone_pattern: result = re.match(pattern, test_filename) if result is not None: return read_gml_ozone(filename, **kwargs) - ozone_pattern = [r'[a-z]{3}_CCl4_Day.dat', - r'[a-z]{3}_CCl4_All.dat', - r'[a-z]{3}_CCl4_MM.dat', - r'[a-z]{3}_MC_MM.dat'] + ozone_pattern = [ + r'[a-z]{3}_CCl4_Day.dat', + r'[a-z]{3}_CCl4_All.dat', + r'[a-z]{3}_CCl4_MM.dat', + r'[a-z]{3}_MC_MM.dat', + ] for pattern in ozone_pattern: result = re.match(pattern, test_filename) if result is not None: @@ -104,72 +123,113 @@ def read_gml_halo(filename, **kwargs): Returns ------- - dataset : Xarray.dataset + ds : xarray.Dataset Standard ARM Xarray dataset with the data cleaned up to have units, long_name, correct type and some other stuff. **kwargs : keywords Keywords to pass through to ACT read_csv() routine. """ - ds = None if filename is None: return ds variables = { - 'CCl4catsBRWm': - {'long_name': 'Carbon Tetrachloride (CCl4) daily median', 'units': 'ppt', - '_FillValue': np.nan, '__type': np.float32, '__rename': 'CCl4'}, - 'CCl4catsBRWmsd': - {'long_name': 'Carbon Tetrachloride (CCl4) standard deviation', 'units': 'ppt', - '_FillValue': np.nan, '__type': np.float32, '__rename': 'CCl4_std_dev'}, - 'CCl4catsBRWsd': - {'long_name': 'Carbon Tetrachloride (CCl4) standard deviation', 'units': 'ppt', - '_FillValue': np.nan, '__type': np.float32, '__rename': 'CCl4_std_dev'}, - 'CCl4catsBRWn': - {'long_name': 'Number of samples', 'units': 'count', - '__type': np.int16, '__rename': 'number_of_samples'}, - 'CCl4catsBRWunc': - {'long_name': 'Carbon Tetrachloride (CCl4) uncertainty', 'units': 'ppt', - '_FillValue': np.nan, - '__type': np.float32, '__rename': 'CCl4_uncertainty'}, - 'MCcatsBRWm': - {'long_name': 'Methyl Chloroform (CH3CCl3)', 'units': 'ppt', - '_FillValue': np.nan, - '__type': np.float32, '__rename': 'methyl_chloroform'}, - 'MCcatsBRWunc': - {'long_name': 'Methyl Chloroform (CH3CCl3) uncertainty', 'units': 'ppt', - '_FillValue': np.nan, - '__type': np.float32, '__rename': 'methyl_chloroform_uncertainty'}, - 'MCcatsBRWsd': - {'long_name': 'Methyl Chloroform (CH3CCl3) standard deviation', 'units': 'ppt', - '_FillValue': np.nan, - '__type': np.float32, '__rename': 'methyl_chloroform_std_dev'}, - 'MCcatsBRWmsd': - {'long_name': 'Methyl Chloroform (CH3CCl3) standard deviation', 'units': 'ppt', - '_FillValue': np.nan, - '__type': np.float32, '__rename': 'methyl_chloroform_std_dev'}, - 'MCcatsBRWn': - {'long_name': 'Number of samples', 'units': 'count', - '__type': np.int16, '__rename': 'number_of_samples'}, - 'MCritsBRWm': - {'long_name': 'Methyl Chloroform (CH3CCl3)', 'units': 'ppt', - '_FillValue': np.nan, - '__type': np.float32, '__rename': 'methyl_chloroform'}, - 'MCritsBRWsd': - {'long_name': 'Methyl Chloroform (CH3CCl3) standard deviation', 'units': 'ppt', - '_FillValue': np.nan, - '__type': np.float32, '__rename': 'methyl_chloroform_std_dev'}, - 'MCritsBRWn': - {'long_name': 'Number of samples', 'units': 'count', - '__type': np.int16, '__rename': 'number_of_samples'}, + 'CCl4catsBRWm': { + 'long_name': 'Carbon Tetrachloride (CCl4) daily median', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'CCl4', + }, + 'CCl4catsBRWmsd': { + 'long_name': 'Carbon Tetrachloride (CCl4) standard deviation', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'CCl4_std_dev', + }, + 'CCl4catsBRWsd': { + 'long_name': 'Carbon Tetrachloride (CCl4) standard deviation', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'CCl4_std_dev', + }, + 'CCl4catsBRWn': { + 'long_name': 'Number of samples', + 'units': 'count', + '__type': np.int16, + '__rename': 'number_of_samples', + }, + 'CCl4catsBRWunc': { + 'long_name': 'Carbon Tetrachloride (CCl4) uncertainty', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'CCl4_uncertainty', + }, + 'MCcatsBRWm': { + 'long_name': 'Methyl Chloroform (CH3CCl3)', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'methyl_chloroform', + }, + 'MCcatsBRWunc': { + 'long_name': 'Methyl Chloroform (CH3CCl3) uncertainty', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'methyl_chloroform_uncertainty', + }, + 'MCcatsBRWsd': { + 'long_name': 'Methyl Chloroform (CH3CCl3) standard deviation', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'methyl_chloroform_std_dev', + }, + 'MCcatsBRWmsd': { + 'long_name': 'Methyl Chloroform (CH3CCl3) standard deviation', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'methyl_chloroform_std_dev', + }, + 'MCcatsBRWn': { + 'long_name': 'Number of samples', + 'units': 'count', + '__type': np.int16, + '__rename': 'number_of_samples', + }, + 'MCritsBRWm': { + 'long_name': 'Methyl Chloroform (CH3CCl3)', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'methyl_chloroform', + }, + 'MCritsBRWsd': { + 'long_name': 'Methyl Chloroform (CH3CCl3) standard deviation', + 'units': 'ppt', + '_FillValue': np.nan, + '__type': np.float32, + '__rename': 'methyl_chloroform_std_dev', + }, + 'MCritsBRWn': { + 'long_name': 'Number of samples', + 'units': 'count', + '__type': np.int16, + '__rename': 'number_of_samples', + }, } test_filename = filename if isinstance(test_filename, (list, tuple)): test_filename = test_filename[0] - with open(test_filename, 'r') as fc: + with open(test_filename) as fc: header = 0 while True: line = fc.readline().strip() @@ -177,8 +237,9 @@ def read_gml_halo(filename, **kwargs): break header += 1 - ds = act.io.csvfiles.read_csv(filename, sep=r'\s+', header=header, - na_values=['Nan', 'NaN', 'nan', 'NAN']) + ds = read_csv( + filename, sep=r'\s+', header=header, na_values=['Nan', 'NaN', 'nan', 'NAN'], **kwargs + ) var_names = list(ds.data_vars) year_name, month_name, day_name, hour_name, min_name = None, None, None, None, None for var_name in var_names: @@ -193,20 +254,33 @@ def read_gml_halo(filename, **kwargs): elif var_name.endswith('min'): min_name = var_name - timestamp = np.full(ds[var_names[0]].size, np.nan, dtype='datetime64[s]') + timestamp = np.full(ds[var_names[0]].size, np.nan, dtype='datetime64[ns]') for ii in range(0, len(timestamp)): if min_name is not None: - ts = datetime(ds[year_name].values[ii], ds[month_name].values[ii], ds[day_name].values[ii], - ds[hour_name].values[ii], ds[min_name].values[ii]) + ts = datetime( + ds[year_name].values[ii], + ds[month_name].values[ii], + ds[day_name].values[ii], + ds[hour_name].values[ii], + ds[min_name].values[ii], + ) elif hour_name is not None: - ts = datetime(ds[year_name].values[ii], ds[month_name].values[ii], ds[day_name].values[ii], - ds[hour_name].values[ii]) + ts = datetime( + ds[year_name].values[ii], + ds[month_name].values[ii], + ds[day_name].values[ii], + ds[hour_name].values[ii], + ) elif day_name is not None: - ts = datetime(ds[year_name].values[ii], ds[month_name].values[ii], ds[day_name].values[ii]) + ts = datetime( + ds[year_name].values[ii], + ds[month_name].values[ii], + ds[day_name].values[ii], + ) else: ts = datetime(ds[year_name].values[ii], ds[month_name].values[ii], 1) - timestamp[ii] = np.datetime64(ts) + timestamp[ii] = np.datetime64(ts, 'ns') for var_name in [year_name, month_name, day_name, hour_name, min_name]: try: @@ -250,7 +324,7 @@ def read_gml_co2(filename=None, convert_missing=True, **kwargs): Returns ------- - dataset : Xarray.dataset + ds : xarray.Dataset Standard ARM Xarray dataset with the data cleaned up to have units, long_name, correct type and some other stuff. **kwargs : keywords @@ -261,64 +335,97 @@ def read_gml_co2(filename=None, convert_missing=True, **kwargs): if filename is None: return ds - variables = {'site_code': None, - 'year': None, - 'month': None, - 'day': None, - 'hour': None, - 'minute': None, - 'second': None, - 'time_decimal': None, - 'value': - {'long_name': 'Carbon monoxide in dry air', 'units': 'ppm', - '_FillValue': -999.99, - 'comment': ('Mole fraction reported in units of micromol mol-1 ' - '(10-6 mol per mol of dry air); abbreviated as ppm (parts per million).'), - '__type': np.float32, '__rename': 'co2'}, - 'value_std_dev': - {'long_name': 'Carbon monoxide in dry air', 'units': 'ppm', - '_FillValue': -99.99, - 'comment': ('This is the standard deviation of the reported mean value ' - 'when nvalue is greater than 1. See provider_comment if available.'), - '__type': np.float32, '__rename': 'co2_std_dev'}, - 'nvalue': - {'long_name': 'Number of measurements contributing to reported value', - 'units': '1', '_FillValue': -9, - '__type': np.int16, '__rename': 'number_of_measurements'}, - 'latitude': - {'long_name': 'Latitude at which air sample was collected', - 'units': 'degrees_north', '_FillValue': -999.999, 'standard_name': "latitude", - '__type': np.float32}, - 'longitude': - {'long_name': 'Latitude at which air sample was collected', - 'units': 'degrees_east', '_FillValue': -999.999, 'standard_name': "longitude", - '__type': np.float32}, - 'altitude': - {'long_name': 'Sample altitude', - 'units': 'm', '_FillValue': -999.999, 'standard_name': "altitude", - 'comment': ('Altitude for this dataset is the sum of surface elevation ' - '(masl) and sample intake height (magl)'), - '__type': np.float32}, - 'intake_height': - {'long_name': 'Sample intake height above ground level', - 'units': 'm', '_FillValue': -999.999, - '__type': np.float32}, - } + variables = { + 'site_code': None, + 'year': None, + 'month': None, + 'day': None, + 'hour': None, + 'minute': None, + 'second': None, + 'time_decimal': None, + 'value': { + 'long_name': 'Carbon monoxide in dry air', + 'units': 'ppm', + '_FillValue': -999.99, + 'comment': ( + 'Mole fraction reported in units of micromol mol-1 ' + '(10-6 mol per mol of dry air); abbreviated as ppm (parts per million).' + ), + '__type': np.float32, + '__rename': 'co2', + }, + 'value_std_dev': { + 'long_name': 'Carbon monoxide in dry air', + 'units': 'ppm', + '_FillValue': -99.99, + 'comment': ( + 'This is the standard deviation of the reported mean value ' + 'when nvalue is greater than 1. See provider_comment if available.' + ), + '__type': np.float32, + '__rename': 'co2_std_dev', + }, + 'nvalue': { + 'long_name': 'Number of measurements contributing to reported value', + 'units': '1', + '_FillValue': -9, + '__type': np.int16, + '__rename': 'number_of_measurements', + }, + 'latitude': { + 'long_name': 'Latitude at which air sample was collected', + 'units': 'degrees_north', + '_FillValue': -999.999, + 'standard_name': 'latitude', + '__type': np.float32, + }, + 'longitude': { + 'long_name': 'Latitude at which air sample was collected', + 'units': 'degrees_east', + '_FillValue': -999.999, + 'standard_name': 'longitude', + '__type': np.float32, + }, + 'altitude': { + 'long_name': 'Sample altitude', + 'units': 'm', + '_FillValue': -999.999, + 'standard_name': 'altitude', + 'comment': ( + 'Altitude for this dataset is the sum of surface elevation ' + '(masl) and sample intake height (magl)' + ), + '__type': np.float32, + }, + 'intake_height': { + 'long_name': 'Sample intake height above ground level', + 'units': 'm', + '_FillValue': -999.999, + '__type': np.float32, + }, + } test_filename = filename if isinstance(test_filename, (list, tuple)): test_filename = test_filename[0] - with open(test_filename, 'r') as fc: + with open(test_filename) as fc: skiprows = int(fc.readline().strip().split()[-1]) - 1 - ds = act.io.csvfiles.read_csv(filename, sep=r'\s+', skiprows=skiprows) + ds = read_csv(filename, sep=r'\s+', skiprows=skiprows, **kwargs) - timestamp = np.full(ds['year'].size, np.nan, dtype='datetime64[s]') + timestamp = np.full(ds['year'].size, np.nan, dtype='datetime64[ns]') for ii in range(0, len(timestamp)): - ts = datetime(ds['year'].values[ii], ds['month'].values[ii], ds['day'].values[ii], - ds['hour'].values[ii], ds['minute'].values[ii], ds['second'].values[ii]) - timestamp[ii] = np.datetime64(ts) + ts = datetime( + ds['year'].values[ii], + ds['month'].values[ii], + ds['day'].values[ii], + ds['hour'].values[ii], + ds['minute'].values[ii], + ds['second'].values[ii], + ) + timestamp[ii] = np.datetime64(ts, 'ns') ds = ds.rename({'index': 'time'}) ds = ds.assign_coords(time=timestamp) @@ -365,12 +472,24 @@ def read_gml_co2(filename=None, convert_missing=True, **kwargs): var_name = 'co2' qc_var_name = ds.qcfilter.create_qc_variable(var_name) - ds.qcfilter.add_test(var_name, index=bad_index, test_assessment='Bad', - test_meaning='Obvious problems during collection or analysis') - ds.qcfilter.add_test(var_name, index=suspect_index, test_assessment='Indeterminate', - test_meaning=('Likely valid but does not meet selection criteria determined by ' - 'the goals of a particular investigation')) - ds[qc_var_name].attrs['comment'] = 'This quality control flag is provided by the contributing PIs' + ds.qcfilter.add_test( + var_name, + index=bad_index, + test_assessment='Bad', + test_meaning='Obvious problems during collection or analysis', + ) + ds.qcfilter.add_test( + var_name, + index=suspect_index, + test_assessment='Indeterminate', + test_meaning=( + 'Likely valid but does not meet selection criteria determined by ' + 'the goals of a particular investigation' + ), + ) + ds[qc_var_name].attrs[ + 'comment' + ] = 'This quality control flag is provided by the contributing PIs' del ds['qcflag'] return ds @@ -378,7 +497,7 @@ def read_gml_co2(filename=None, convert_missing=True, **kwargs): def read_gml_ozone(filename=None, **kwargs): """ - Function to read carbon dioxide data from NOAA GML. + Function to read ozone data from NOAA GML. Parameters ---------- @@ -389,11 +508,11 @@ def read_gml_ozone(filename=None, **kwargs): Returns ------- - dataset : Xarray.dataset + ds : xarray.Dataset Standard ARM Xarray dataset with the data cleaned up to have units, long_name, correct type and some other stuff. - """ + """ ds = None if filename is None: return ds @@ -402,7 +521,7 @@ def read_gml_ozone(filename=None, **kwargs): if isinstance(test_filename, (list, tuple)): test_filename = test_filename[0] - with open(test_filename, 'r') as fc: + with open(test_filename) as fc: skiprows = 0 while True: line = fc.readline().strip().split() @@ -413,14 +532,18 @@ def read_gml_ozone(filename=None, **kwargs): pass skiprows += 1 - ds = act.io.csvfiles.read_csv(filename, sep=r'\s+', skiprows=skiprows) + ds = read_csv(filename, sep=r'\s+', skiprows=skiprows, **kwargs) ds.attrs['station'] = str(ds['STN'].values[0]).lower() - timestamp = np.full(ds['YEAR'].size, np.nan, dtype='datetime64[s]') + timestamp = np.full(ds['YEAR'].size, np.nan, dtype='datetime64[ns]') for ii in range(0, len(timestamp)): - ts = datetime(ds['YEAR'].values[ii], ds['MON'].values[ii], ds['DAY'].values[ii], - ds['HR'].values[ii]) - timestamp[ii] = np.datetime64(ts) + ts = datetime( + ds['YEAR'].values[ii], + ds['MON'].values[ii], + ds['DAY'].values[ii], + ds['HR'].values[ii], + ) + timestamp[ii] = np.datetime64(ts, 'ns') ds = ds.rename({'index': 'time'}) ds = ds.assign_coords(time=timestamp) @@ -439,7 +562,7 @@ def read_gml_ozone(filename=None, **kwargs): return ds -def read_gml_radiation(filename=None, convert_missing=True, **kwargs): +def read_gml_radiation(filename=None, convert_missing=True, remove_time_vars=True, **kwargs): """ Function to read radiation data from NOAA GML. @@ -451,12 +574,16 @@ def read_gml_radiation(filename=None, convert_missing=True, **kwargs): Option to convert missing values to NaN. If turned off will set variable attribute to missing value expected. This works well to preserve the data type best for writing to a netCDF file. + remove_time_vars : boolean + Some column names in the CSV file are used for creating the time + coordinate variable in the returend Xarray DataSet. Once used the + variables are not needed and will be removed from DataSet. **kwargs : keywords Keywords to pass through to ACT read_csv() routine. Returns ------- - dataset : Xarray.dataset + ds : xarray.Dataset Standard ARM Xarray dataset with the data cleaned up to have units, long_name, correct type and some other stuff. """ @@ -465,102 +592,170 @@ def read_gml_radiation(filename=None, convert_missing=True, **kwargs): if filename is None: return ds - column_names = {'year': None, - 'jday': None, - 'month': None, - 'day': None, - 'hour': None, - 'minute': None, - 'decimal_time': None, - 'solar_zenith_angle': - {'units': 'degree', - 'long_name': 'Solar zenith angle', - '_FillValue': -9999.9, '__type': np.float32}, - 'downwelling_global_solar': - {'units': 'W/m^2', - 'long_name': 'Downwelling global solar', - '_FillValue': -9999.9, '__type': np.float32}, - 'upwelling_global_solar': - {'units': 'W/m^2', - 'long_name': 'Upwelling global solar', - '_FillValue': -9999.9, '__type': np.float32}, - 'direct_normal_solar': - {'units': 'W/m^2', - 'long_name': 'Direct-normal solar', - '_FillValue': -9999.9, '__type': np.float32}, - 'downwelling_diffuse_solar': - {'units': 'W/m^2', - 'long_name': 'Downwelling diffuse solar', - '_FillValue': -9999.9, '__type': np.float32}, - 'downwelling_thermal_infrared': - {'units': 'W/m^2', - 'long_name': 'Downwelling thermal infrared', - '_FillValue': -9999.9, '__type': np.float32}, - 'downwelling_infrared_case_temp': - {'units': 'degK', - 'long_name': 'Downwelling infrared case temp', - '_FillValue': -9999.9, '__type': np.float32}, - 'downwelling_infrared_dome_temp': - {'units': 'degK', - 'long_name': 'downwelling infrared dome temp', - '_FillValue': -9999.9, '__type': np.float32}, - 'upwelling_thermal_infrared': - {'units': 'W/m^2', - 'long_name': 'Upwelling thermal infrared', - '_FillValue': -9999.9, '__type': np.float32}, - 'upwelling_infrared_case_temp': - {'units': 'degK', - 'long_name': 'Upwelling infrared case temp', - '_FillValue': -9999.9, '__type': np.float32}, - 'upwelling_infrared_dome_temp': - {'units': 'degK', - 'long_name': 'Upwelling infrared dome temp', - '_FillValue': -9999.9, '__type': np.float32}, - 'global_UVB': - {'units': 'mW/m^2', - 'long_name': 'global ultraviolet-B', - '_FillValue': -9999.9, '__type': np.float32}, - 'par': - {'units': 'W/m^2', - 'long_name': 'Photosynthetically active radiation', - '_FillValue': -9999.9, '__type': np.float32}, - 'net_solar': - {'units': 'W/m^2', - 'long_name': 'Net solar (downwelling_global_solar - upwelling_global_solar)', - '_FillValue': -9999.9, '__type': np.float32}, - 'net_infrared': - {'units': 'W/m^2', - 'long_name': ('Net infrared (downwelling_thermal_infrared - ' - 'upwelling_thermal_infrared)'), - '_FillValue': -9999.9, '__type': np.float32}, - 'net_radiation': - {'units': 'W/m^2', - 'long_name': 'Net radiation (net_solar + net_infrared)', - '_FillValue': -9999.9, '__type': np.float32}, - 'air_temperature_10m': - {'units': 'degC', - 'long_name': '10-meter air temperature', - '_FillValue': -9999.9, '__type': np.float32}, - 'relative_humidity': - {'units': '%', - 'long_name': 'Relative humidity', - '_FillValue': -9999.9, '__type': np.float32}, - 'wind_speed': - {'units': 'm/s', - 'long_name': 'Wind speed', - '_FillValue': -9999.9, '__type': np.float32}, - 'wind_direction': - {'units': 'degree', - 'long_name': 'Wind direction (clockwise from north)', - '_FillValue': -9999.9, '__type': np.float32}, - 'station_pressure': - {'units': 'millibar', - 'long_name': 'Station atmospheric pressure', - '_FillValue': -9999.9, '__type': np.float32}, - } + column_names = { + 'year': None, + 'jday': None, + 'month': None, + 'day': None, + 'hour': None, + 'minute': None, + 'decimal_time': None, + 'solar_zenith_angle': { + 'units': 'degree', + 'long_name': 'Solar zenith angle', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'downwelling_global_solar': { + 'units': 'W/m^2', + 'long_name': 'Downwelling global solar', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'upwelling_global_solar': { + 'units': 'W/m^2', + 'long_name': 'Upwelling global solar', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'direct_normal_solar': { + 'units': 'W/m^2', + 'long_name': 'Direct-normal solar', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'downwelling_diffuse_solar': { + 'units': 'W/m^2', + 'long_name': 'Downwelling diffuse solar', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'downwelling_thermal_infrared': { + 'units': 'W/m^2', + 'long_name': 'Downwelling thermal infrared', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'downwelling_infrared_case_temp': { + 'units': 'degK', + 'long_name': 'Downwelling infrared case temp', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'downwelling_infrared_dome_temp': { + 'units': 'degK', + 'long_name': 'downwelling infrared dome temp', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'upwelling_thermal_infrared': { + 'units': 'W/m^2', + 'long_name': 'Upwelling thermal infrared', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'upwelling_infrared_case_temp': { + 'units': 'degK', + 'long_name': 'Upwelling infrared case temp', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'upwelling_infrared_dome_temp': { + 'units': 'degK', + 'long_name': 'Upwelling infrared dome temp', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'global_UVB': { + 'units': 'mW/m^2', + 'long_name': 'global ultraviolet-B', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'par': { + 'units': 'W/m^2', + 'long_name': 'Photosynthetically active radiation', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'net_solar': { + 'units': 'W/m^2', + 'long_name': 'Net solar (downwelling_global_solar - upwelling_global_solar)', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'net_infrared': { + 'units': 'W/m^2', + 'long_name': ( + 'Net infrared (downwelling_thermal_infrared - ' 'upwelling_thermal_infrared)' + ), + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'net_radiation': { + 'units': 'W/m^2', + 'long_name': 'Net radiation (net_solar + net_infrared)', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'air_temperature_10m': { + 'units': 'degC', + 'long_name': '10-meter air temperature', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'relative_humidity': { + 'units': '%', + 'long_name': 'Relative humidity', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'wind_speed': { + 'units': 'm/s', + 'long_name': 'Wind speed', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'wind_direction': { + 'units': 'degree', + 'long_name': 'Wind direction (clockwise from north)', + '_FillValue': -9999.9, + '__type': np.float32, + }, + 'station_pressure': { + 'units': 'millibar', + 'long_name': 'Station atmospheric pressure', + '_FillValue': -9999.9, + '__type': np.float32, + }, + } + + # Add additinal column names for NOAA SPASH campaign + if str(Path(filename).name).startswith('cbc') or str(Path(filename).name).startswith('ckp'): + column_names['SPN1_total'] = { + 'units': 'W/m^2', + 'long_name': 'SPN1 total average', + '_FillValue': -9999.9, + '__type': np.float32, + } + column_names['SPN1_diffuse'] = { + 'units': 'W/m^2', + 'long_name': 'SPN1 diffuse average', + '_FillValue': -9999.9, + '__type': np.float32, + } names = list(column_names.keys()) - skip_vars = ['year', 'jday', 'month', 'day', 'hour', 'minute', 'decimal_time', 'solar_zenith_angle'] + skip_vars = [ + 'year', + 'jday', + 'month', + 'day', + 'hour', + 'minute', + 'decimal_time', + 'solar_zenith_angle', + ] num = 1 for ii, name in enumerate(column_names.keys()): if name in skip_vars: @@ -568,10 +763,13 @@ def read_gml_radiation(filename=None, convert_missing=True, **kwargs): names.insert(ii + num, 'qc_' + name) num += 1 - ds = act.io.csvfiles.read_csv(filename, sep=r'\s+', header=0, skiprows=2, column_names=names) + ds = read_csv(filename, sep=r'\s+', header=None, skiprows=2, column_names=names, **kwargs) + + if isinstance(filename, (list, tuple)): + filename = filename[0] if ds is not None: - with open(filename, 'r') as fc: + with open(filename) as fc: lat = None lon = None alt = None @@ -587,19 +785,42 @@ def read_gml_radiation(filename=None, convert_missing=True, **kwargs): alt = np.array(line[2], dtype=np.float32) alt_unit = str(line[3]) - ds['lat'] = xr.DataArray(lat, attrs={'long_name': 'Latitude', 'units': 'degree_north', - 'standard_name': 'latitude'}) - ds['lon'] = xr.DataArray(lon, attrs={'long_name': 'Longitude', 'units': 'degree_east', - 'standard_name': 'longitude'}) - ds['alt'] = xr.DataArray(alt, attrs={'long_name': 'Latitude', 'units': alt_unit, - 'standard_name': 'altitude'}) + ds['lat'] = xr.DataArray( + lat, + attrs={ + 'long_name': 'Latitude', + 'units': 'degree_north', + 'standard_name': 'latitude', + }, + ) + ds['lon'] = xr.DataArray( + lon, + attrs={ + 'long_name': 'Longitude', + 'units': 'degree_east', + 'standard_name': 'longitude', + }, + ) + ds['alt'] = xr.DataArray( + alt, + attrs={ + 'long_name': 'Latitude', + 'units': alt_unit, + 'standard_name': 'altitude', + }, + ) ds.attrs['location'] = station - timestamp = np.full(ds['year'].size, np.nan, dtype='datetime64[s]') + timestamp = np.full(ds['year'].size, np.nan, dtype='datetime64[ns]') for ii in range(0, len(timestamp)): - ts = datetime(ds['year'].values[ii], ds['month'].values[ii], ds['day'].values[ii], - ds['hour'].values[ii], ds['minute'].values[ii]) - timestamp[ii] = np.datetime64(ts) + ts = datetime( + ds['year'].values[ii], + ds['month'].values[ii], + ds['day'].values[ii], + ds['hour'].values[ii], + ds['minute'].values[ii], + ) + timestamp[ii] = np.datetime64(ts, 'ns') ds = ds.rename({'index': 'time'}) ds = ds.assign_coords(time=timestamp) @@ -631,21 +852,39 @@ def read_gml_radiation(filename=None, convert_missing=True, **kwargs): if not var_name.startswith('qc_'): continue data_var_name = var_name.replace('qc_', '', 1) - attrs = {'long_name': f"Quality control variable for: {ds[data_var_name].attrs['long_name']}", - 'units': '1', 'standard_name': 'quality_flag', - 'flag_values': [0, 1, 2], - 'flag_meanings': ['Not failing any tests', 'Knowingly bad value', - 'Should be used with scrutiny'], - 'flag_assessments': ['Good', 'Bad', 'Indeterminate']} + attrs = { + 'long_name': f"Quality control variable for: {ds[data_var_name].attrs['long_name']}", + 'units': '1', + 'standard_name': 'quality_flag', + 'flag_values': [0, 1, 2], + 'flag_meanings': [ + 'Not failing any tests', + 'Knowingly bad value', + 'Should be used with scrutiny', + ], + 'flag_assessments': ['Good', 'Bad', 'Indeterminate'], + } ds[var_name].attrs = attrs ds[data_var_name].attrs['ancillary_variables'] = var_name + if remove_time_vars: + remove_var_names = [ + 'year', + 'jday', + 'month', + 'day', + 'hour', + 'minute', + 'decimal_time', + ] + ds = ds.drop_vars(remove_var_names) + return ds def read_gml_met(filename=None, convert_missing=True, **kwargs): """ - Function to read meteorlogical data from NOAA GML. + Function to read meteorological data from NOAA GML. Parameters ---------- @@ -660,7 +899,7 @@ def read_gml_met(filename=None, convert_missing=True, **kwargs): Returns ------- - dataset : Xarray.dataset + ds : xarray.Dataset Standard ARM Xarray dataset with the data cleaned up to have units, long_name, correct type and some other stuff. """ @@ -669,43 +908,73 @@ def read_gml_met(filename=None, convert_missing=True, **kwargs): if filename is None: return ds - column_names = {'station': None, - 'year': None, - 'month': None, - 'day': None, - 'hour': None, - 'minute': None, - 'wind_direction': - {'units': 'degree', - 'long_name': 'Average wind direction from which the wind is blowing', - '_FillValue': -999, '__type': np.int16}, - 'wind_speed': - {'units': 'm/s', 'long_name': 'Average wind speed', '_FillValue': -999.9, - '__type': np.float32}, - 'wind_steadiness_factor': - {'units': '1', 'long_name': '100 times the ratio of the vector wind speed to the ' - 'average wind speed for the hour', '_FillValue': -9, '__type': np.int16}, - 'barometric_pressure': - {'units': 'hPa', 'long_name': 'Station barometric pressure', '_FillValue': -999.90, - '__type': np.float32}, - 'temperature_2m': - {'units': 'degC', 'long_name': 'Temperature at 2 meters above ground level', - '_FillValue': -999.9, '__type': np.float32}, - 'temperature_10m': - {'units': 'degC', 'long_name': 'Temperature at 10 meters above ground level', - '_FillValue': -999.9, '__type': np.float32}, - 'temperature_tower_top': - {'units': 'degC', 'long_name': 'Temperature at top of instrument tower', - '_FillValue': -999.9, '__type': np.float32}, - 'realitive_humidity': - {'units': 'percent', 'long_name': 'Relative humidity', '_FillValue': -99, - '__type': np.int16}, - 'preciptation_intensity': - {'units': 'mm/hour', 'long_name': 'Amount of precipitation per hour', - '_FillValue': -99, '__type': np.int16, - 'comment': ('The precipitation amount is measured with an unheated ' - 'tipping bucket rain gauge.')} - } + column_names = { + 'station': None, + 'year': None, + 'month': None, + 'day': None, + 'hour': None, + 'minute': None, + 'wind_direction': { + 'units': 'degree', + 'long_name': 'Average wind direction from which the wind is blowing', + '_FillValue': -999, + '__type': np.int16, + }, + 'wind_speed': { + 'units': 'm/s', + 'long_name': 'Average wind speed', + '_FillValue': -999.9, + '__type': np.float32, + }, + 'wind_steadiness_factor': { + 'units': '1', + 'long_name': '100 times the ratio of the vector wind speed to the ' + 'average wind speed for the hour', + '_FillValue': -9, + '__type': np.int16, + }, + 'barometric_pressure': { + 'units': 'hPa', + 'long_name': 'Station barometric pressure', + '_FillValue': -999.90, + '__type': np.float32, + }, + 'temperature_2m': { + 'units': 'degC', + 'long_name': 'Temperature at 2 meters above ground level', + '_FillValue': -999.9, + '__type': np.float32, + }, + 'temperature_10m': { + 'units': 'degC', + 'long_name': 'Temperature at 10 meters above ground level', + '_FillValue': -999.9, + '__type': np.float32, + }, + 'temperature_tower_top': { + 'units': 'degC', + 'long_name': 'Temperature at top of instrument tower', + '_FillValue': -999.9, + '__type': np.float32, + }, + 'realitive_humidity': { + 'units': 'percent', + 'long_name': 'Relative humidity', + '_FillValue': -99, + '__type': np.int16, + }, + 'preciptation_intensity': { + 'units': 'mm/hour', + 'long_name': 'Amount of precipitation per hour', + '_FillValue': -99, + '__type': np.int16, + 'comment': ( + 'The precipitation amount is measured with an unheated ' + 'tipping bucket rain gauge.' + ), + }, + } minutes = True test_filename = filename @@ -716,26 +985,33 @@ def read_gml_met(filename=None, convert_missing=True, **kwargs): minutes = False del column_names['minute'] - ds = act.io.csvfiles.read_csv(filename, sep=r'\s+', header=0, column_names=column_names.keys()) + ds = read_csv(filename, sep=r'\s+', header=None, column_names=column_names.keys(), **kwargs) if ds is not None: - - timestamp = np.full(ds['year'].size, np.nan, dtype='datetime64[s]') + timestamp = np.full(ds['year'].size, np.nan, dtype='datetime64[ns]') for ii in range(0, len(timestamp)): if minutes: - ts = datetime(ds['year'].values[ii], ds['month'].values[ii], ds['day'].values[ii], - ds['hour'].values[ii], ds['minute'].values[ii]) + ts = datetime( + ds['year'].values[ii], + ds['month'].values[ii], + ds['day'].values[ii], + ds['hour'].values[ii], + ds['minute'].values[ii], + ) else: - ts = datetime(ds['year'].values[ii], ds['month'].values[ii], ds['day'].values[ii], - ds['hour'].values[ii]) + ts = datetime( + ds['year'].values[ii], + ds['month'].values[ii], + ds['day'].values[ii], + ds['hour'].values[ii], + ) - timestamp[ii] = np.datetime64(ts) + timestamp[ii] = np.datetime64(ts, 'ns') ds = ds.rename({'index': 'time'}) ds = ds.assign_coords(time=timestamp) ds['time'].attrs['long_name'] = 'Time' for var_name, value in column_names.items(): - if value is None: del ds[var_name] else: @@ -759,3 +1035,241 @@ def read_gml_met(filename=None, convert_missing=True, **kwargs): pass return ds + + +def read_surfrad(filename, **kwargs): + """ + Function to read in NOAA SurfRad data + + Parameters + ---------- + filename : list + Data files full path name or url to file + **kwargs : keywords + Keywords to pass through to instrument specific reading routine. + + Returns + ------- + ds : xarray.Dataset + Standard ARM Xarray dataset with the data cleaned up to have units, + long_name, correct type and some other stuff. + + """ + + names = [ + 'year', + 'jday', + 'month', + 'day', + 'hour', + 'minute', + 'dec_time', + 'solar_zenith_angle', + 'downwelling_global', + 'qc_downwelling_global', + 'upwelling_global', + 'qc_upwelling_global', + 'direct_normal', + 'qc_direct_normal', + 'downwelling_diffuse', + 'qc_downwelling_diffuse', + 'downwelling_ir', + 'qc_downwelling_ir', + 'downwelling_ir_casetemp', + 'qc_downwelling_ir_casetemp', + 'downwelling_ir_dometemp', + 'qc_downwelling_ir_dometemp', + 'upwelling_ir', + 'qc_upwelling_ir', + 'upwelling_ir_casetemp', + 'qc_upwelling_ir_casetemp', + 'upwelling_ir_dometemp', + 'qc_upwelling_ir_dometemp', + 'global_uvb', + 'qc_global_uvb', + 'par', + 'qc_par', + 'net_radiation', + 'qc_net_radiation', + 'net_ir', + 'qc_net_ir', + 'total_net', + 'qc_total_net', + 'temperature', + 'qc_temperature', + 'relative_humidity', + 'qc_relative_humidity', + 'wind_speed', + 'qc_wind_speed', + 'wind_direction', + 'qc_wind_direction', + 'pressure', + 'qc_pressure', + ] + for i, f in enumerate(filename): + new_df = pd.read_csv(f, names=names, skiprows=2, delimiter=r'\s+', header=None) + if i == 0: + df = new_df + else: + df = pd.concat([df, new_df]) + + # Create time variable and add as the coordinate + ds = df.to_xarray() + year = ds['year'].values + month = ds['month'].values + day = ds['day'].values + hour = ds['hour'].values + minute = ds['minute'].values + time = [datetime(year[i], month[i], day[i], hour[i], minute[i]) for i in range(len(year))] + ds = ds.assign_coords(index=time) + ds = ds.rename(index='time') + + # Add attributes + attrs = { + 'year': {'long_name': 'Year', 'units': 'unitless'}, + 'jday': {'long_name': 'Julian day', 'units': 'unitless'}, + 'month': {'long_name': 'Month', 'units': 'unitless'}, + 'day': {'long_name': 'Day of the month', 'units': 'unitless'}, + 'hour': {'long_name': 'Hour', 'units': 'unitless'}, + 'minute': {'long_name': 'Minutes', 'units': 'unitless'}, + 'dec_time': {'long_name': 'Decimal time', 'units': 'unitless'}, + 'solar_zenith_angle': {'long_name': 'Solar zenith angle', 'units': 'deg'}, + 'downwelling_global': { + 'long_name': 'Downwelling global solar', + 'units': 'W m^-2', + 'standard_name': 'surface_downwelling_shortwave_flux_in_air', + }, + 'upwelling_global': { + 'long_name': 'Upwelling global solar', + 'units': 'W m^-2', + 'standard_name': 'surface_upwelling_shortwave_flux_in_air', + }, + 'direct_normal': { + 'long_name': 'Direct normal solar', + 'units': 'W m^-2', + 'standard_name': 'surface_direct_downwelling_shortwave_flux_in_air', + }, + 'downwelling_diffuse': { + 'long_name': 'Downwelling diffuse solar', + 'units': 'W m^-2', + 'standard_name': 'diffuse_downwelling_shortwave_flux_in_air', + }, + 'downwelling_ir': { + 'long_name': 'Downwelling thermal infrared', + 'units': 'W m^-2', + 'standard_name': 'net_downward_longwave_flux_in_air', + }, + 'downwelling_ir_casetemp': { + 'long_name': 'Downwelling thermal infrared case temperature', + 'units': 'K', + }, + 'downwelling_ir_dometemp': { + 'long_name': 'Downwelling thermal infrared dome temperature', + 'units': 'K', + }, + 'upwelling_ir': { + 'long_name': 'Upwelling thermal infrared', + 'units': 'W m^-2', + 'standard_name': 'net_upward_longwave_flux_in_air', + }, + 'upwelling_ir_casetemp': { + 'long_name': 'Upwelling thermal infrared case temperature', + 'units': 'K', + }, + 'upwelling_ir_dometemp': { + 'long_name': 'Upwelling thermal infrared dome temperature', + 'units': 'K', + }, + 'global_uvb': {'long_name': 'Global UVB', 'units': 'milliWatts m^-2'}, + 'par': { + 'long_name': 'Photosynthetically active radiation', + 'units': 'W m^-2', + 'standard_name': 'surface_downwelling_photosynthetic_radiative_flux_in_air', + }, + 'net_radiation': { + 'long_name': 'Net solar (downwelling_global-upwelling_global)', + 'units': 'W m^-2', + 'standard_name': 'surface_net_downward_shortwave_flux', + }, + 'net_ir': { + 'long_name': 'Net infrared (downwelling_ir-upwelling_ir)', + 'units': 'W m^-2', + 'standard_name': 'surface_net_downward_longwave_flux', + }, + 'total_net': { + 'long_name': 'Total Net radiation (net_radiation + net_ir)', + 'units': 'W m^-2', + }, + 'temperature': { + 'long_name': '10-meter air temperature', + 'units': 'degC', + 'standard_name': 'air_temperature', + }, + 'relative_humidity': { + 'long_name': 'Relative humidity', + 'units': '%', + 'standard_name': 'relative_humidity', + }, + 'wind_speed': {'long_name': 'Wind speed', 'units': 'ms^-1', 'standard_name': 'wind_speed'}, + 'wind_direction': { + 'long_name': 'Wind direction, clockwise from North', + 'units': 'deg', + 'standard_name': 'wind_from_direction', + }, + 'pressure': { + 'long_name': 'Station pressure', + 'units': 'mb', + 'standard_name': 'air_pressure', + }, + } + + for v in ds: + if v in attrs: + ds[v].attrs = attrs[v] + + # Add attributes to all QC variables + qc_vars = [ + 'downwelling_global', + 'upwelling_global', + 'direct_normal', + 'downwelling_diffuse', + 'downwelling_ir', + 'downwelling_ir_casetemp', + 'downwelling_ir_dometemp', + 'upwelling_ir', + 'upwelling_ir_casetemp', + 'upwelling_ir_dometemp', + 'global_uvb', + 'par', + 'net_radiation', + 'net_ir', + 'total_net', + 'temperature', + 'relative_humidity', + 'wind_speed', + 'wind_direction', + 'pressure', + ] + + for v in qc_vars: + atts = { + 'long_name': 'Quality check results on variable: ' + v, + 'units': '1', + 'description': ''.join( + [ + 'A QC flag of zero indicates that the corresponding data point is good,', + ' having passed all QC checks. A value greater than 0 indicates that', + ' the data failed one level of QC. For example, a QC value of 1 means', + ' that the recorded value is beyond a physically possible range, or it has', + ' been affected adversely in some manner to produce a knowingly bad value.', + ' A value of 2 indicates that the data value failed the second level QC check,', + ' indicating that the data value may be physically possible but should be used', + ' with scrutiny, and so on.', + ] + ), + } + ds['qc_' + v].attrs = atts + + ds.attrs['datastream'] = 'SURFRAD Site: ' + filename[0].split('/')[-1][0:3] + + return ds diff --git a/act/io/noaapsl.py b/act/io/noaapsl.py new file mode 100644 index 0000000000..a5e2da5e46 --- /dev/null +++ b/act/io/noaapsl.py @@ -0,0 +1,1189 @@ +""" +Modules for reading in NOAA PSL data. +""" + +import datetime as dt +import re +from datetime import datetime, timedelta +from itertools import groupby +from os import path as ospath + +import fsspec +import numpy as np +import pandas as pd +import xarray as xr +import yaml + +from .text import read_csv + + +def read_psl_wind_profiler(filepath, transpose=True): + """ + Returns two `xarray.Datasets` with stored data and metadata from a + user-defined NOAA PSL wind profiler file each containing + a different mode. This works for both 449 MHz and 915 MHz Weber + Wuertz and Weber Wuertz sub-hourly files. + + Parameters + ---------- + filepath : str + Name of file(s) to read. + transpose : bool + True to transpose the data. + + Return + ------ + mode_one_ds : xarray.Dataset + Standard Xarray dataset with the first mode data. + mode_two_ds : xarray.Dataset + Standard Xarray dataset with the second mode data. + + """ + # Open the file, read in the lines as a list, and return that list + file = fsspec.open(filepath).open() + lines = file.readlines() + lines = [x.decode().rstrip()[:] for x in lines][1:] + + # Separate sections based on the $ separator in the file + sections_of_file = (list(g) for _, g in groupby(lines, key='$'.__ne__)) + + # Count how many lines need to be skipped when reading into pandas + start_line = 0 + list_of_datasets = [] + for section in sections_of_file: + if section[0] != '$': + list_of_datasets.append( + _parse_psl_wind_lines(filepath, section, line_offset=start_line) + ) + start_line += len(section) + + # Return two datasets for each mode and the merge of datasets of the + # same mode. + mode_one_ds = xr.concat(list_of_datasets[0::2], dim='time') + mode_two_ds = xr.concat(list_of_datasets[1::2], dim='time') + if transpose: + mode_one_ds = mode_one_ds.transpose('HT', 'time') + mode_two_ds = mode_two_ds.transpose('HT', 'time') + return mode_one_ds, mode_two_ds + + +def read_psl_wind_profiler_temperature(filepath, transpose=True): + """ + Returns `xarray.Dataset` with stored data and metadata from a user-defined + NOAA PSL wind profiler temperature file. + + Parameters + ---------- + filepath : str + Name of file(s) to read. + transpose : bool + True to transpose the data. + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset with the data. + + """ + # Open the file, read in the lines as a list, and return that list + file = fsspec.open(filepath).open() + lines = file.readlines() + lines = [x.decode().rstrip()[:] for x in lines][1:] + + # Separate sections based on the $ separator in the file + sections_of_file = (list(g) for _, g in groupby(lines, key='$'.__ne__)) + + # Count how many lines need to be skipped when reading into pandas + start_line = 0 + list_of_datasets = [] + for section in sections_of_file: + if section[0] != '$': + list_of_datasets.append( + _parse_psl_temperature_lines(filepath, section, line_offset=start_line) + ) + start_line += len(section) + + # Merge the resultant datasets together + if transpose: + return xr.concat(list_of_datasets, dim='time').transpose('HT', 'time') + else: + return xr.concat(list_of_datasets, dim='time') + + +def _parse_psl_wind_lines(filepath, lines, line_offset=0): + """ + Reads lines related to wind in a psl file. + + Parameters + ---------- + filepath : str + Name of file(s) to read. + lines : list + List of strings containing the lines to parse. + line_offset : int (default = 0) + Offset to start reading the pandas data table. + + Returns + ------- + ds : xarray.Dataset + Xarray dataset with wind data. + + """ + # 1 - site + site = lines[0] + + # 2 - datetype + datatype, _, version = filter_list(lines[1].split(' ')) + + # 3 - station lat, lon, elevation + latitude, longitude, elevation = filter_list(lines[2].split(' ')).astype(float) + + # 4 - year, month, day, hour, minute, second, utc + time = parse_date_line(lines[3]) + + # 5 - Consensus averaging time, number of beams, number of range gates + consensus_average_time, number_of_beams, number_of_range_gates = filter_list( + lines[4].split(' ') + ).astype(int) + + # 7 - number of coherent integrations, number of spectral averages, + # pulse width, inner pulse period' + # Values duplicate as oblique and vertical values + ( + number_coherent_integrations_obl, + number_coherent_integrations_vert, + number_spectral_averages_obl, + number_spectral_averages_vert, + pulse_width_obl, + pulse_width_vert, + inner_pulse_period_obl, + inner_pulse_period_vert, + ) = filter_list(lines[6].split(' ')).astype(int) + + # 8 - full-scale doppler value, delay to first gate, number of gates, + # spacing of gates. Values duplicate as oblique and vertical values. + ( + full_scale_doppler_obl, + full_scale_doppler_vert, + beam_vertical_correction, + delay_first_gate_obl, + delay_first_gate_vert, + number_of_gates_obl, + number_of_gates_vert, + spacing_of_gates_obl, + spacing_of_gates_vert, + ) = filter_list(lines[7].split(' ')).astype(float) + + # 9 - beam azimuth (degrees clockwise from north) + ( + beam_azimuth1, + beam_elevation1, + beam_azimuth2, + beam_elevation2, + beam_azimuth3, + beam_elevation3, + ) = filter_list(lines[8].split(' ')).astype(float) + + beam_azimuth = np.array([beam_azimuth1, beam_azimuth2, beam_azimuth3], dtype='float32') + beam_elevation = np.array([beam_elevation1, beam_elevation2, beam_elevation3], dtype='float32') + + # Read in the data table section using pandas + df = pd.read_csv(filepath, skiprows=line_offset + 10, delim_whitespace=True) + + # Only read in the number of rows for a given set of gates + df = df.iloc[: int(number_of_range_gates)] + + # Grab a list of valid columns, except time + columns = set(list(df.columns)) - {'time'} + # Set the data types to be floats + df = df[list(columns)].astype(float) + + # Nan values are encoded as 999999 - let's reflect that + df = df.replace(999999.0, np.nan) + + # Ensure the height array is stored as a float + df['HT'] = df.HT.astype(float) + + # Set the height as an index + df = df.set_index('HT') + + # Rename the count and snr columns more usefully + df = df.rename( + columns={ + 'RAD': 'RAD1', + 'RAD.1': 'RAD2', + 'RAD.2': 'RAD3', + 'CNT': 'CNT1', + 'CNT.1': 'CNT2', + 'CNT.2': 'CNT3', + 'SNR': 'SNR1', + 'SNR.1': 'SNR2', + 'SNR.2': 'SNR3', + 'QC': 'QC1', + 'QC.1': 'QC2', + 'QC.2': 'QC3', + } + ) + + # Convert to an xaray dataset + ds = df.to_xarray() + + # Add attributes to variables + # Height + ds['HT'].attrs['long_name'] = 'height_above_ground' + ds['HT'].attrs['units'] = 'km' + + # Add time to our dataset + ds['time'] = time + + # Add in our additional attributes + ds.attrs['site_identifier'] = site.strip() + ds.attrs['data_type'] = datatype + ds.attrs['latitude'] = latitude + ds.attrs['longitude'] = longitude + ds.attrs['elevation'] = elevation + ds.attrs['beam_elevation'] = beam_elevation + ds.attrs['beam_azimuth'] = beam_azimuth + ds.attrs['revision_number'] = version + ds.attrs[ + 'data_description' + ] = 'https://psl.noaa.gov/data/obs/data/view_data_type_info.php?SiteID=ctd&DataOperationalID=5855&OperationalID=2371' + ds.attrs['consensus_average_time'] = consensus_average_time + ds.attrs['oblique-beam_vertical_correction'] = int(beam_vertical_correction) + ds.attrs['number_of_beams'] = int(number_of_beams) + ds.attrs['number_of_range_gates'] = int(number_of_range_gates) + + # Handle oblique and vertical attributes. + ds.attrs['number_of_gates_oblique'] = int(number_of_gates_obl) + ds.attrs['number_of_gates_vertical'] = int(number_of_gates_vert) + ds.attrs['number_spectral_averages_oblique'] = int(number_spectral_averages_obl) + ds.attrs['number_spectral_averages_vertical'] = int(number_spectral_averages_vert) + ds.attrs['pulse_width_oblique'] = int(pulse_width_obl) + ds.attrs['pulse_width_vertical'] = int(pulse_width_vert) + ds.attrs['inner_pulse_period_oblique'] = int(inner_pulse_period_obl) + ds.attrs['inner_pulse_period_vertical'] = int(inner_pulse_period_vert) + ds.attrs['full_scale_doppler_value_oblique'] = float(full_scale_doppler_obl) + ds.attrs['full_scale_doppler_value_vertical'] = float(full_scale_doppler_vert) + ds.attrs['delay_to_first_gate_oblique'] = int(delay_first_gate_obl) + ds.attrs['delay_to_first_gate_vertical'] = int(delay_first_gate_vert) + ds.attrs['spacing_of_gates_oblique'] = int(spacing_of_gates_obl) + ds.attrs['spacing_of_gates_vertical'] = int(spacing_of_gates_vert) + return ds + + +def _parse_psl_temperature_lines(filepath, lines, line_offset=0): + """ + Reads lines related to temperature in a psl file. + + Parameters + ---------- + filepath : str + Name of file(s) to read. + lines : list + List of strings containing the lines to parse. + line_offset : int (default = 0) + Offset to start reading the pandas data table. + + Returns + ------- + ds : xarray.Dataset + Xarray dataset with temperature data. + + """ + # 1 - site + site = lines[0] + + # 2 - datetype + datatype, _, version = filter_list(lines[1].split(' ')) + + # 3 - station lat, lon, elevation + latitude, longitude, elevation = filter_list(lines[2].split(' ')).astype(float) + + # 4 - year, month, day, hour, minute, second, utc + time = parse_date_line(lines[3]) + + # 5 - Consensus averaging time, number of beams, number of range gates. + consensus_average_time, number_of_beams, number_of_range_gates = filter_list( + lines[4].split(' ') + ).astype(int) + + # 7 - number of coherent integrations, number of spectral averages, + # pulse width, inner pulse period. + ( + number_coherent_integrations, + number_spectral_averages, + pulse_width, + inner_pulse_period, + ) = filter_list(lines[6].split(' ')).astype(int) + + # 8 - full-scale doppler value, delay to first gate, number of gates, + # spacing of gates. + full_scale_doppler, delay_first_gate, number_of_gates, spacing_of_gates = filter_list( + lines[7].split(' ') + ).astype(float) + + # 9 - beam azimuth (degrees clockwise from north) + beam_azimuth, beam_elevation = filter_list(lines[8].split(' ')).astype(float) + + # Read in the data table section using pandas + df = pd.read_csv(filepath, skiprows=line_offset + 10, delim_whitespace=True) + + # Only read in the number of rows for a given set of gates + df = df.iloc[: int(number_of_gates)] + + # Grab a list of valid columns, except time + columns = set(list(df.columns)) - {'time'} + + # Set the data types to be floats + df = df[list(columns)].astype(float) + + # Nan values are encoded as 999999 - let's reflect that + df = df.replace(999999.0, np.nan) + + # Ensure the height array is stored as a float + df['HT'] = df.HT.astype(float) + + # Set the height as an index + df = df.set_index('HT') + + # Rename the count and snr columns more usefully + df = df.rename( + columns={ + 'CNT': 'CNT_T', + 'CNT.1': 'CNT_Tc', + 'CNT.2': 'CNT_W', + 'SNR': 'SNR_T', + 'SNR.1': 'SNR_Tc', + 'SNR.2': 'SNR_W', + } + ) + + # Convert to an xaray dataset + ds = df.to_xarray() + + # Add attributes to variables + # Height + ds['HT'].attrs['long_name'] = 'height_above_ground' + ds['HT'].attrs['units'] = 'km' + + # Temperature + ds['T'].attrs['long_name'] = 'average_uncorrected_RASS_temperature' + ds['T'].attrs['units'] = 'degC' + ds['Tc'].attrs['long_name'] = 'average_corrected_RASS_temperature' + ds['Tc'].attrs['units'] = 'degC' + + # Vertical motion (w) + ds['W'].attrs['long_name'] = 'average_vertical_wind' + ds['W'].attrs['units'] = 'm/s' + + # Add time to our dataset + ds['time'] = time + + # Add in our additional attributes + ds.attrs['site_identifier'] = site.strip() + ds.attrs['data_type'] = datatype + ds.attrs['latitude'] = latitude + ds.attrs['longitude'] = longitude + ds.attrs['elevation'] = elevation + ds.attrs['beam_elevation'] = beam_elevation + ds.attrs['beam_azimuth'] = beam_azimuth + ds.attrs['revision_number'] = version + ds.attrs[ + 'data_description' + ] = 'https://psl.noaa.gov/data/obs/data/view_data_type_info.php?SiteID=ctd&DataOperationalID=5855&OperationalID=2371' + ds.attrs['consensus_average_time'] = consensus_average_time + ds.attrs['number_of_beams'] = int(number_of_beams) + ds.attrs['number_of_gates'] = int(number_of_gates) + ds.attrs['number_of_range_gates'] = int(number_of_range_gates) + ds.attrs['number_spectral_averages'] = int(number_spectral_averages) + ds.attrs['pulse_width'] = pulse_width + ds.attrs['inner_pulse_period'] = inner_pulse_period + ds.attrs['full_scale_doppler_value'] = full_scale_doppler + ds.attrs['spacing_of_gates'] = spacing_of_gates + + return ds + + +def filter_list(list_of_strings): + """ + Parses a list of strings, remove empty strings, and return a numpy array + """ + return np.array(list(filter(None, list_of_strings))) + + +def parse_date_line(list_of_strings): + """ + Parses the date line in PSL files + """ + year, month, day, hour, minute, second, utc_offset = filter_list( + list_of_strings.split(' ') + ).astype(int) + year += 2000 + return datetime(year, month, day, hour, minute, second) + + +def read_psl_surface_met(filenames, conf_file=None): + """ + Returns `xarray.Dataset` with stored data and metadata from a user-defined + NOAA PSL SurfaceMet file. + + Parameters + ---------- + filenames : str, list of str + Name of file(s) to read. + conf_file : str or Pathlib.path + Default to ./conf/noaapsl_SurfaceMet.yaml + Filename containing relative or full path to configuration + YAML file used to describe the file format for each PSL site. + If the site is not defined in the default file, the default file + can be copied to a local location, and the missing site added. + Then point to that updated configuration file. An issue can be + opened on GitHub to request the missing site to the configuration + file. + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset with the data + + """ + + if isinstance(filenames, str): + site = ospath.basename(filenames)[:3] + else: + site = ospath.basename(filenames[0])[:3] + + if conf_file is None: + conf_file = ospath.join(ospath.dirname(__file__), 'conf', 'noaapsl_SurfaceMet.yaml') + + # Read configuration YAML file + with open(conf_file) as fp: + try: + result = yaml.load(fp, Loader=yaml.FullLoader) + except AttributeError: + result = yaml.load(fp) + + # Extract dictionary of just corresponding site + try: + result = result[site] + except KeyError: + raise RuntimeError( + f"Configuration for site '{site}' currently not available. " + 'You can manually add the site configuration to a copy of ' + 'noaapsl_SurfaceMet.yaml and set conf_file= name of copied file ' + 'until the site is added.' + ) + + # Extract date and time from filename to use in extracting format from YAML file. + search_result = re.match(r'[a-z]{3}(\d{2})(\d{3})\.(\d{2})m', ospath.basename(filenames[0])) + yy, doy, hh = search_result.groups() + if yy > '70': + yy = f'19{yy}' + else: + yy = f'20{yy}' + + # Extract location information from configuration file. + try: + location_info = result['info'] + except KeyError: + location_info = None + + # Loop through each date range for the site to extract the correct file format from conf file. + file_datetime = ( + datetime.strptime(f'{yy}-01-01', '%Y-%m-%d') + + timedelta(int(doy) - 1) + + timedelta(hours=int(hh)) + ) + for ii in result.keys(): + if ii == 'info': + continue + + date_range = [ + datetime.strptime(jj, '%Y-%m-%d %H:%M:%S') for jj in result[ii]['_date_range'] + ] + if file_datetime >= date_range[0] and file_datetime <= date_range[1]: + result = result[ii] + del result['_date_range'] + break + + # Read data files by passing in column names from configuration file. + ds = read_csv(filenames, column_names=list(result.keys())) + + # Calculate numpy datetime64 values from first 4 columns of the data file. + time = np.array(ds['Year'].values - 1970, dtype='datetime64[Y]') + day = np.array(np.array(ds['J_day'].values - 1, dtype='timedelta64[D]')) + hourmin = ds['HoursMinutes'].values + 10000 + hour = [int(str(ii)[1:3]) for ii in hourmin] + hour = np.array(hour, dtype='timedelta64[h]') + minute = [int(str(ii)[3:]) for ii in hourmin] + minute = np.array(minute, dtype='timedelta64[m]') + time = time + day + hour + minute + time = time.astype('datetime64[ns]') + # Update Dataset to use "time" coordinate and assigned calculated times + ds = ds.assign_coords(index=time) + ds = ds.rename(index='time') + + # Loop through configuraton dictionary and apply attributes or + # perform action for specific attributes. + for var_name in result: + for key, value in result[var_name].items(): + if key == '_delete' and value is True: + del ds[var_name] + continue + + if key == '_type': + dtype = result[var_name][key] + ds[var_name] = ds[var_name].astype(dtype) + continue + + if key == '_missing_value': + data_values = ds[var_name].values + data_values[data_values == result[var_name][key]] = np.nan + ds[var_name].values = data_values + continue + + ds[var_name].attrs[key] = value + + # Add location information to Dataset + if location_info is not None: + ds.attrs['location_description'] = location_info['name'] + for var_name in ['lat', 'lon', 'alt']: + value = location_info[var_name]['value'] + del location_info[var_name]['value'] + ds[var_name] = xr.DataArray(data=value, attrs=location_info[var_name]) + + return ds + + +def read_psl_parsivel(files): + """ + Returns `xarray.Dataset` with stored data and metadata from a user-defined + NOAA PSL parsivel + + Parameters + ---------- + files : str or list + Name of file(s) or urls to read. + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset with the data for the parsivel + + """ + + # Define the names for the variables + names = [ + 'time', + 'B1', + 'B2', + 'B3', + 'B4', + 'B5', + 'B6', + 'B7', + 'B8', + 'B9', + 'B10', + 'B11', + 'B12', + 'B13', + 'B14', + 'B15', + 'B16', + 'B17', + 'B18', + 'B19', + 'B20', + 'B21', + 'B22', + 'B23', + 'B24', + 'B25', + 'B26', + 'B27', + 'B28', + 'B29', + 'B30', + 'B31', + 'B32', + 'blackout', + 'good', + 'bad', + 'number_detected_particles', + 'precip_rate', + 'precip_amount', + 'precip_accumulation', + 'equivalent_radar_reflectivity', + 'number_in_error', + 'dirty', + 'very_dirty', + 'damaged', + 'laserband_amplitude', + 'laserband_amplitude_stdev', + 'sensor_temperature', + 'sensor_temperature_stdev', + 'sensor_voltage', + 'sensor_voltage_stdev', + 'heating_current', + 'heating_current_stdev', + 'number_rain_particles', + 'number_non_rain_particles', + 'number_ambiguous_particles', + 'precip_type', + ] + + # Define the particle sizes and class width sizes based on + # https://psl.noaa.gov/data/obs/data/view_data_type_info.php?SiteID=ctd&DataOperationalID=5890 + vol_equiv_diam = [ + 0.062, + 0.187, + 0.312, + 0.437, + 0.562, + 0.687, + 0.812, + 0.937, + 1.062, + 1.187, + 1.375, + 1.625, + 1.875, + 2.125, + 2.375, + 2.75, + 3.25, + 3.75, + 4.25, + 4.75, + 5.5, + 6.5, + 7.5, + 8.5, + 9.5, + 11.0, + 13.0, + 15.0, + 17.0, + 19.0, + 21.5, + 24.5, + ] + class_size_width = [ + 0.125, + 0.125, + 0.125, + 0.125, + 0.125, + 0.125, + 0.125, + 0.125, + 0.125, + 0.125, + 0.250, + 0.250, + 0.250, + 0.250, + 0.250, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, + 2.0, + 2.0, + 2.0, + 2.0, + 2.0, + 3.0, + 3.0, + ] + + if not isinstance(files, list): + files = [files] + + # Loop through each file or url and append the dataframe into data for concatenations + data = [] + end_time = [] + for f in files: + df = pd.read_table(f, skiprows=[0, 1, 2], names=names, index_col=0, sep=r'\s+') + # Reading the table twice to get the date so it can be parsed appropriately + date = pd.read_table(f, nrows=0).to_string().split(' ')[-3] + time = df.index + start_time = [] + form = '%y%j%H:%M:%S:%f' + for t in time: + start_time.append(pd.to_datetime(date + ':' + t.split('-')[0], format=form)) + end_time.append(pd.to_datetime(date + ':' + t.split('-')[1], format=form)) + df.index = start_time + data.append(df) + + df = pd.concat(data) + + # Create a 2D size distribution variable from all the B* variables + dsd = [] + for n in names: + if 'B' not in n: + continue + dsd.append(list(df[n])) + + # Convert the dataframe to xarray DataSet and add variables + ds = df.to_xarray() + ds = ds.rename({'index': 'time'}) + long_name = 'Drop Size Distribution' + attrs = {'long_name': long_name, 'units': 'count'} + da = xr.DataArray( + np.transpose(dsd), + dims=['time', 'particle_size'], + coords=[ds['time'].values, vol_equiv_diam], + ) + ds['number_density_drops'] = da + + attrs = {'long_name': 'Particle class size average', 'units': 'mm'} + da = xr.DataArray( + class_size_width, dims=['particle_size'], coords=[vol_equiv_diam], attrs=attrs + ) + ds['class_size_width'] = da + + attrs = {'long_name': 'Class size width', 'units': 'mm'} + da = xr.DataArray(vol_equiv_diam, dims=['particle_size'], coords=[vol_equiv_diam], attrs=attrs) + ds['particle_size'] = da + + attrs = {'long_name': 'End time of averaging interval'} + da = xr.DataArray(end_time, dims=['time'], coords=[ds['time'].values], attrs=attrs) + ds['interval_end_time'] = da + + # Define the attribuets and metadata and add into the DataSet + attrs = { + 'blackout': { + 'long_name': 'Number of samples excluded during PC clock sync', + 'units': 'count', + }, + 'good': {'long_name': 'Number of samples that passed QC checks', 'units': 'count'}, + 'bad': {'long_name': 'Number of samples that failed QC checks', 'units': 'count'}, + 'number_detected_particles': { + 'long_name': 'Total number of detected particles', + 'units': 'count', + }, + 'precip_rate': {'long_name': 'Precipitation rate', 'units': 'mm/hr'}, + 'precip_amount': {'long_name': 'Interval accumulation', 'units': 'mm'}, + 'precip_accumulation': {'long_name': 'Event accumulation', 'units': 'mm'}, + 'equivalent_radar_reflectivity': {'long_name': 'Radar Reflectivity', 'units': 'dB'}, + 'number_in_error': { + 'long_name': 'Number of samples that were reported dirt, very dirty, or damaged', + 'units': 'count', + }, + 'dirty': { + 'long_name': 'Laser glass is dirty but measurement is still possible', + 'units': 'unitless', + }, + 'very_dirty': { + 'long_name': 'Laser glass is dirty, partially covered no further measurements are possible', + 'units': 'unitless', + }, + 'damaged': {'long_name': 'Laser damaged', 'units': 'unitless'}, + 'laserband_amplitude': { + 'long_name': 'Average signal amplitude of the laser strip', + 'units': 'unitless', + }, + 'laserband_amplitude_stdev': { + 'long_name': 'Standard deviation of the signal amplitude of the laser strip', + 'units': 'unitless', + }, + 'sensor_temperature': {'long_name': 'Average sensor temperature', 'units': 'degC'}, + 'sensor_temperature_stdev': { + 'long_name': 'Standard deviation of sensor temperature', + 'units': 'degC', + }, + 'sensor_voltage': {'long_name': 'Sensor power supply voltage', 'units': 'V'}, + 'sensor_voltage_stdev': { + 'long_name': 'Standard deviation of the sensor power supply voltage', + 'units': 'V', + }, + 'heating_current': {'long_name': 'Average heating system current', 'units': 'A'}, + 'heating_current_stdev': { + 'long_name': 'Standard deviation of heating system current', + 'units': 'A', + }, + 'number_rain_particles': { + 'long_name': 'Number of particles detected as rain', + 'units': 'unitless', + }, + 'number_non_rain_particles': { + 'long_name': 'Number of particles detected not as rain', + 'units': 'unitless', + }, + 'number_ambiguous_particles': { + 'long_name': 'Number of particles detected as ambiguous', + 'units': 'unitless', + }, + 'precip_type': { + 'long_name': 'Precipitation type (1=rain; 2=mixed; 3=snow)', + 'units': 'unitless', + }, + 'number_density_drops': {'long_name': 'Drop Size Distribution', 'units': 'count'}, + } + + for v in ds: + if v in attrs: + ds[v].attrs = attrs[v] + + return ds + + +def read_psl_radar_fmcw_moment(files): + """ + Returns `xarray.Dataset` with stored data and metadata from + NOAA PSL FMCW Radar files. See References section for details. + + Parameters + ---------- + files : str or list + Name of file(s) to read. Currently does not support reading URLs but files can + be downloaded easily using the act.discovery.download_noaa_psl_data function. + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset with the data for the parsivel + + References + ---------- + Johnston, Paul E., James R. Jordan, Allen B. White, David A. Carter, David M. Costa, and Thomas E. Ayers. + "The NOAA FM-CW snow-level radar." Journal of Atmospheric and Oceanic Technology 34, no. 2 (2017): 249-267. + + """ + + ds = _parse_psl_radar_moments(files) + + return ds + + +def read_psl_radar_sband_moment(files): + """ + Returns `xarray.Dataset` with stored data and metadata from + NOAA PSL S-band Radar files. + + Parameters + ---------- + files : str or list + Name of file(s) to read. Currently does not support reading URLs but files can + be downloaded easily using the act.discovery.download_noaa_psl_data function. + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset with the data for the parsivel + + """ + + ds = _parse_psl_radar_moments(files) + + return ds + + +def _parse_psl_radar_moments(files): + """ + Returns `xarray.Dataset` with stored data and metadata from + NOAA PSL FMCW and S-Band Radar files. + + Parameters + ---------- + files : str or list + Name of file(s) to read. Currently does not support reading URLs but files can + be downloaded easily using the act.discovery.download_noaa_psl_data function. + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset with the data for the parsivel + + """ + # Set the initial dictionary to convert to xarray dataset + data = { + 'site': {'dims': ['file'], 'data': [], 'attrs': {'long_name': 'NOAA site code'}}, + 'lat': { + 'dims': ['file'], + 'data': [], + 'attrs': {'long_name': 'North Latitude', 'units': 'degree_N'}, + }, + 'lon': { + 'dims': ['file'], + 'data': [], + 'attrs': {'long_name': 'East Longitude', 'units': 'degree_E'}, + }, + 'alt': { + 'dims': ['file'], + 'data': [], + 'attrs': {'long_name': 'Altitude above mean sea level', 'units': 'm'}, + }, + 'freq': { + 'dims': ['file'], + 'data': [], + 'attrs': {'long_name': 'Operating Frequency; Ignore for FMCW', 'units': 'Hz'}, + }, + 'azimuth': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Azimuth angle', 'units': 'deg'}, + }, + 'elevation': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Elevation angle', 'units': 'deg'}, + }, + 'beam_direction_code': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Beam direction code', 'units': ''}, + }, + 'year': {'dims': ['time'], 'data': [], 'attrs': {'long_name': '2-digit year', 'units': ''}}, + 'day_of_year': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Day of the year', 'units': ''}, + }, + 'hour': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Hour of the day', 'units': ''}, + }, + 'minute': {'dims': ['time'], 'data': [], 'attrs': {'long_name': 'Minutes', 'units': ''}}, + 'second': {'dims': ['time'], 'data': [], 'attrs': {'long_name': 'Seconds', 'units': ''}}, + 'interpulse_period': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Interpulse Period', 'units': 'ms'}, + }, + 'pulse_width': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Pulse width', 'units': 'ns'}, + }, + 'first_range_gate': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Range to first range gate', 'units': 'm'}, + }, + 'range_between_gates': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Distance between range gates', 'units': 'm'}, + }, + 'n_gates': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Number of range gates', 'units': 'count'}, + }, + 'n_coherent_integration': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Number of cohrent integration', 'units': 'count'}, + }, + 'n_averaged_spectra': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Number of average spectra', 'units': 'count'}, + }, + 'n_points_spectrum': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Number of points in spectra', 'units': 'count'}, + }, + 'n_code_bits': { + 'dims': ['time'], + 'data': [], + 'attrs': {'long_name': 'Number of code bits', 'units': 'count'}, + }, + 'radial_velocity': { + 'dims': ['time', 'range'], + 'data': [], + 'attrs': {'long_name': 'Radial velocity', 'units': 'm/s'}, + }, + 'snr': { + 'dims': ['time', 'range'], + 'data': [], + 'attrs': {'long_name': 'Signal-to-noise ratio - not range corrected', 'units': 'dB'}, + }, + 'signal_power': { + 'dims': ['time', 'range'], + 'data': [], + 'attrs': {'long_name': 'Signal Power - not range corrected', 'units': 'dB'}, + }, + 'spectral_width': { + 'dims': ['time', 'range'], + 'data': [], + 'attrs': {'long_name': 'Spectral width', 'units': 'm/s'}, + }, + 'noise_amplitude': { + 'dims': ['time', 'range'], + 'data': [], + 'attrs': {'long_name': 'noise_amplitude', 'units': 'dB'}, + }, + 'qc_variable': { + 'dims': ['time', 'range'], + 'data': [], + 'attrs': {'long_name': 'QC Value - not used', 'units': ''}, + }, + 'time': {'dims': ['time'], 'data': [], 'attrs': {'long_name': 'Datetime', 'units': ''}}, + 'range': {'dims': ['range'], 'data': [], 'attrs': {'long_name': 'Range', 'units': 'm'}}, + 'reflectivity_uncalibrated': { + 'dims': ['time', 'range'], + 'data': [], + 'attrs': {'long_name': 'Range', 'units': 'dB'}, + }, + } + + # Separate out the names as they will be accessed in different parts of the code + h1_names = ['site', 'lat', 'lon', 'alt', 'freq'] + h2_names = [ + 'azimuth', + 'elevation', + 'beam_direction_code', + 'year', + 'day_of_year', + 'hour', + 'minute', + 'second', + ] + h3_names = [ + 'interpulse_period', + 'pulse_width', + 'first_range_gate', + 'range_between_gates', + 'n_gates', + 'n_coherent_integration', + 'n_averaged_spectra', + 'n_points_spectrum', + 'n_code_bits', + ] + names = { + 'radial_velocity': 0, + 'snr': 1, + 'signal_power': 2, + 'spectral_width': 3, + 'noise_amplitude': 4, + 'qc_variable': 5, + } + + # If file is a string, convert to list for handling. + if not isinstance(files, list): + files = [files] + + # Run through each file and read the data in + for f in files: + # Read in the first line of the file which has site, lat, lon, etc... + df = str(pd.read_table(f, nrows=0).columns[0]).split(' ') + ctr = 0 + for d in df: + if len(d) > 0: + if d == 'lat' or d == 'lon': + data[h1_names[ctr]]['data'].append(float(d) / 100.0) + else: + data[h1_names[ctr]]['data'].append(d) + ctr += 1 + + # Set counts and errors + error = False + error_ct = 0 + ct = 0 + # Loop through while there's no errors i.e. eof + while error is False: + try: + # Read in the initial headers to get information used to parse data + if ct == 0: + df = str(pd.read_table(f, nrows=0, skiprows=[0]).columns[0]).split(' ') + ctr = 0 + for d in df: + if len(d) > 0: + data[h2_names[ctr]]['data'].append(d) + ctr += 1 + # Read in third row of header information + df = str(pd.read_table(f, nrows=0, skiprows=[0, 1]).columns[0]).split(' ') + ctr = 0 + for d in df: + if len(d) > 0: + data[h3_names[ctr]]['data'].append(d) + ctr += 1 + # Read in the data based on number of gates + df = pd.read_csv( + f, + skiprows=[0, 1, 2], + nrows=int(data['n_gates']['data'][-1]) - 1, + delim_whitespace=True, + names=list(names.keys()), + ) + index2 = 0 + else: + # Set indices for parsing data, reading 2 headers and then the columns of data + index1 = ct * int(data['n_gates']['data'][-1]) + index2 = index1 + int(data['n_gates']['data'][-1]) + 2 * ct + 4 + df = str( + pd.read_table(f, nrows=0, skiprows=list(range(index2 - 1))).columns[0] + ).split(' ') + ctr = 0 + for d in df: + if len(d) > 0: + data[h2_names[ctr]]['data'].append(d) + ctr += 1 + df = str( + pd.read_table(f, nrows=0, skiprows=list(range(index2))).columns[0] + ).split(' ') + ctr = 0 + for d in df: + if len(d) > 0: + data[h3_names[ctr]]['data'].append(d) + ctr += 1 + df = pd.read_csv( + f, + skiprows=list(range(index2 + 1)), + nrows=int(data['n_gates']['data'][-1]) - 1, + delim_whitespace=True, + names=list(names.keys()), + ) + + # Add data from the columns to the dictionary + for n in names: + data[n]['data'].append(df[n].to_list()) + + # Calculate the range based on number of gates, range to first gate and range between gates + if len(data['range']['data']) == 0: + ranges = float(data['first_range_gate']['data'][-1]) + np.array( + range(int(data['n_gates']['data'][-1]) - 1) + ) * float(data['range_between_gates']['data'][-1]) + data['range']['data'] = ranges + + # Calculate a time + time = dt.datetime( + int('20' + data['year']['data'][-1]), + 1, + 1, + int(data['hour']['data'][-1]), + int(data['minute']['data'][-1]), + int(data['second']['data'][-1]), + ) + dt.timedelta(days=int(data['day_of_year']['data'][-1]) - 1) + data['time']['data'].append(time) + + # Range correct the snr which converts it essentially to an uncalibrated reflectivity + snr_rc = data['snr']['data'][-1] - 20.0 * np.log10(1.0 / (ranges / 1000.0) ** 2) + data['reflectivity_uncalibrated']['data'].append(snr_rc) + except Exception as e: + # Handle errors, if end of file then continue on, if something else + # try the next block of data but if it errors another time in this file move on + if isinstance(e, pd.errors.EmptyDataError) or error_ct > 1: + error = True + else: + print(e) + pass + error_ct += 1 + ct += 1 + + # Convert dictionary to Dataset + ds = xr.Dataset().from_dict(data) + + return ds diff --git a/act/io/pysp2.py b/act/io/pysp2.py new file mode 100644 index 0000000000..31a185101f --- /dev/null +++ b/act/io/pysp2.py @@ -0,0 +1,83 @@ +try: + import pysp2 + + PYSP2_AVAILABLE = True +except ImportError: + PYSP2_AVAILABLE = False + + +def read_hk_file(file_name): + """ + This procedure will read in an SP2 housekeeping file and then + store the timeseries data into a pandas DataFrame. + + Parameters + ---------- + file_name: str + The file name to read in + + Returns + ------- + hk_ds: xarray.Dataset + The housekeeping information in an xarray Dataset + """ + if PYSP2_AVAILABLE: + return pysp2.io.read_hk_file(file_name) + else: + raise ModuleNotFoundError( + 'PySP2 must be installed in order to read SP2 data and housekeeping files.' + ) + + +def read_sp2(file_name, debug=False, arm_convention=True): + """ + Loads a binary SP2 raw data file and returns all of the wave forms + into an xarray Dataset. + + Parameters + ---------- + file_name: str + The name of the .sp2b file to read. + debug: bool + Set to true for verbose output. + arm_convention: bool + If True, then the file name will follow ARM standard naming conventions. + If False, then the file name follows the SP2 default naming convention. + + Returns + ------- + ds: xarray.Dataset + The xarray Dataset containing the raw SP2 waveforms for each particle. + """ + if PYSP2_AVAILABLE: + return pysp2.io.read_sp2(file_name, debug, arm_convention) + else: + raise ModuleNotFoundError( + 'PySP2 must be installed in order to read SP2 data and housekeeping files.' + ) + + +def read_sp2_dat(file_name, type): + """ + This reads the .dat files that generate the intermediate parameters used + by the Igor processing. Wildcards are supported. + + Parameters + ---------- + file_name: str + The name of the file to save to. Use a wildcard to open multiple files at once. + type: str + This parameter must be one of: + 'particle': Load individual particle timeseries from .dat file + 'conc': Load timeseries of concentrations. + Returns + ------- + ds: xarray.Dataset + The xarray dataset to store the parameters in. + """ + if PYSP2_AVAILABLE: + return pysp2.io.read_dat(file_name, type) + else: + raise ModuleNotFoundError( + 'PySP2 must be installed in order to read SP2 data and housekeeping files.' + ) diff --git a/act/io/sodar.py b/act/io/sodar.py new file mode 100644 index 0000000000..15dc238f45 --- /dev/null +++ b/act/io/sodar.py @@ -0,0 +1,205 @@ +""" +This module contains I/O operations for loading Sodar files. + +""" + +import datetime as dt +import re + +import fsspec +import numpy as np +import pandas as pd +import xarray as xr + +from act.io.noaapsl import filter_list + + +def read_mfas_sodar(filepath): + """ + Returns `xarray.Dataset` with stored data and metadata from a user-defined + Flat Array MFAS Sodar file. More information can be found here: + https://www.scintec.com/products/flat-array-sodar-mfas/ + + Parameters + ---------- + filepath : str + Name of file to read. + + Return + ------ + ds : xarray.Dataset + Standard Xarray dataset with the data. + + """ + file = fsspec.open(filepath).open() + lines = file.readlines() + lines = [x.decode().rstrip()[:] for x in lines] + + # Retrieve number of height values from line 3. + _, _, len_height = filter_list(lines[3].split()).astype(int) + + # Retrieve metadata + file_dict, variable_dict = _metadata_retrieval(lines) + + # Retrieve datetimes and time indices from when datetime rows appear + skip_time_ind = [] + datetimes = [] + fmt = '%Y-%m-%d %H:%M:%S' + for i, line in enumerate(lines): + match = re.search(r'\d{4}-\d{2}-\d{2}\ \d{2}:\d{2}:\d{2}', line) + if match is None: + continue + else: + date_object = dt.datetime.strptime(match.group(0), fmt) + datetimes.append(date_object) + skip_time_ind.append(i) + + datetimes = np.delete(datetimes, 0) + # Create datetime column with matching datetimes to heights + data_times = pd.DataFrame(datetimes, columns=['Dates']) + repeat_times = data_times.loc[data_times.index.repeat(len_height)] + + # This is used to pull only actual data. + # Code can be added as well to read in the metadata from the first few rows. + skip_meta_ind = np.arange(0, skip_time_ind[1] + 1, 1) + skip_full_ind = np.append(skip_meta_ind, skip_time_ind) + skip_full_ind = np.unique(skip_full_ind) + + # Column row appears 1 row after first time, retrieve column names from that. + columns = np.delete(filter_list(lines[skip_time_ind[1] + 1].split(' ')), 0).tolist() + + # Tmp column allows for the # column to be pushed over and dropped. + tmp_columns = columns + ['tmp'] + + # Parse data to a dataframe skipping rows that aren't data. + # tmp_columns is used to removed '#' column that causes + # columns to move over by one. + df = pd.read_table(filepath, + sep=r'\s+', + skiprows=skip_full_ind, + names=tmp_columns, + usecols=columns) + + df = df[~df['W'].isin(['dir'])].reset_index(drop=True) + + # Set index to datetime column. + df = df.set_index(repeat_times['Dates']) + + # Convert dataframe to xarray dataset. + ds = df.to_xarray() + + # Convert height to float. + ds['z'] = ds.z.astype(float) + + # Convert all variables from string to float. + ds = ds.astype(float) + + # Convert variables that should be int back to int. + ds['error'] = ds.error.astype(int) + ds['PGz'] = ds.PGz.astype(int) + + # Get unique time and height values. + time_dim = np.unique(ds.Dates.values) + height_dim = np.unique(ds.z.values) + + # Use unique time and height values to reindex data to be two dimensional. + ind = pd.MultiIndex.from_product((time_dim, height_dim), names=('time', 'height')) + + # Xarray 2023.9 contains new syntax, adding try and except for + # previous version. + try: + mindex_coords = xr.Coordinates.from_pandas_multiindex(ind, 'Dates') + ds = ds.assign_coords(mindex_coords).unstack("Dates") + except AttributeError: + ds = ds.assign(Dates=ind).unstack("Dates") + + # Add file metadata. + for key in file_dict.keys(): + ds.attrs[key] = file_dict[key] + + # Add metadata to the attributes of each variable. + for key in variable_dict.keys(): + ds[key].attrs = variable_dict[key] + + # Change fill values to nans for floats and 0 for ints. + # We can't use xr.replace as the fill value changes between variables. + for var in ds.data_vars: + if var == 'error': + continue + elif var == 'PGz': + data_with_fill = ds[var].values + data_with_fill[data_with_fill == 99] = 0 + ds[var].values = data_with_fill + else: + data_with_fill = ds[var].values + fill_value = ds[var].attrs['_FillValue'] + data_with_fill[data_with_fill == fill_value] = np.nan + ds[var].values = data_with_fill + + # Drop z as its already a coordinate and give coordinate the same attributes. + ds.height.attrs = ds['z'].attrs + ds = ds.drop_vars('z') + + return ds + + +def _metadata_retrieval(lines): + # File format from line 0. + _format = lines[0] + + # Sodar type from line 2. + instrument_type = lines[2] + + # Create np.array of lines to use np.argwhere + line_array = np.array(lines) + + # Retrieve indices of file information and the end of the metadata block. + file_info_ind = np.argwhere(line_array == '# file information')[0][0] + file_type_ind = np.argwhere(line_array == '# file type')[0][0] + + # Index the section of file information. + file_def = line_array[file_info_ind + 2:file_type_ind - 1] + + # Create a dictionary of file information to be plugged in later to the xarray + # dataset attributes. + file_dict = {} + for line in file_def: + key, value = filter_list(line.split(':')) + file_dict[key.strip()] = value.strip() + file_dict['format'] = _format + file_dict['instrument_type'] = instrument_type + + # Change values from strings to float where need be. + file_dict['antenna azimuth angle [deg]'] = float(file_dict['antenna azimuth angle [deg]']) + file_dict['height above ground [m]'] = float(file_dict['height above ground [m]']) + file_dict['height above sea level [m]'] = float(file_dict['height above sea level [m]']) + + # Retrieve indices of variable information. + variable_info_ind = np.argwhere(line_array == '# variable definitions')[0][0] + data_ind = np.argwhere(line_array == '# beginning of data block')[0][0] + + # Index the section of variable information. + variable_def = line_array[variable_info_ind + 2 :data_ind - 1] + + # Create a dictionary of variable information to be plugged in later to the xarray + # variable attributes. Skipping error code as it does not have metadata similar to + # the rest of the variables. + variable_dict = {} + for i, line in enumerate(variable_def): + if 'error code' in line: + continue + else: + temp_var_dict = {} + key, symbol, units, _type, error_mask, fill_value = filter_list(line.split('#')) + temp_var_dict['variable_name'] = key.strip() + temp_var_dict['symbol'] = symbol.strip() + temp_var_dict['units'] = units.strip() + temp_var_dict['type'] = _type.strip() + temp_var_dict['error_mask'] = error_mask.strip() + if key.strip() == 'PGz': + temp_var_dict['_FillValue'] = int(fill_value) + else: + temp_var_dict['_FillValue'] = float(fill_value) + variable_dict[symbol.strip()] = temp_var_dict + + return file_dict, variable_dict diff --git a/act/io/text.py b/act/io/text.py new file mode 100644 index 0000000000..b0ddca63bd --- /dev/null +++ b/act/io/text.py @@ -0,0 +1,105 @@ +""" +This module contains I/O operations for loading csv files. + +""" + +import pathlib + +import pandas as pd + +from act.io.arm import check_arm_standards + + +def read_csv( + filename, sep=',', engine='python', column_names=None, skipfooter=0, ignore_index=True, **kwargs +): + """ + Returns an `xarray.Dataset` with stored data and metadata from user-defined + query of CSV files. + + Parameters + ---------- + filenames : str or list + Name of file(s) to read. + sep : str + The separator between columns in the csv file. + column_names : list or None + The list of column names in the csv file. + verbose : bool + If true, will print if a file is not found. + ignore_index : bool + Keyword for pandas concat function. If True, do not use the index + values along the concatenation axis. The resulting axis will be labeled + 0, â€Ļ, n - 1. This is useful if you are concatenating datasets where the + concatenation axis does not have meaningful indexing information. Note + the index values on the other axes are still respected in the join. + + Additional keyword arguments will be passed into pandas.read_csv. + + Returns + ------- + ds : xarray.Dataset + ACT Xarray dataset. Will be None if the file is not found. + + Examples + -------- + This example will load the example sounding data used for unit testing: + + .. code-block:: python + + import act + + ds = act.io.csv.read(act.tests.sample_files.EXAMPLE_CSV_WILDCARD) + + """ + + # Convert to string if filename is a pathlib or not a list + if isinstance(filename, (pathlib.PurePath, str)): + filename = [str(filename)] + + if isinstance(filename, list) and isinstance(filename[0], pathlib.PurePath): + filename = [str(ii) for ii in filename] + + # Read data using pandas read_csv one file at a time and append to + # list. Then concatinate the list into one pandas dataframe. + li = [] + for fl in filename: + df = pd.read_csv( + fl, sep=sep, names=column_names, skipfooter=skipfooter, engine=engine, **kwargs + ) + li.append(df) + + if len(li) == 1: + df = li[0] + else: + df = pd.concat(li, axis=0, ignore_index=ignore_index) + + # Set Coordinates if there's a variable date_time + if 'date_time' in df: + df.date_time = df.date_time.astype('datetime64[ns]') + df.time = df.date_time + df = df.set_index('time') + + # Convert to xarray DataSet + ds = df.to_xarray() + + # Set additional variables + # Since we cannot assume a standard naming convention setting + # file_date and file_time to the first time in the file + x_coord = ds.coords.to_index().values[0] + if isinstance(x_coord, str): + x_coord_dt = pd.to_datetime(x_coord) + ds.attrs['_file_dates'] = x_coord_dt.strftime('%Y%m%d') + ds.attrs['_file_times'] = x_coord_dt.strftime('%H%M%S') + + # Check for standard ARM datastream name, if none, assume the file is ARM + # standard format. + is_arm_file_flag = check_arm_standards(ds) + if is_arm_file_flag == 0: + ds.attrs['_datastream'] = '.'.join(filename[0].split('/')[-1].split('.')[0:2]) + + # Add additional attributes, site, standards flag, etc... + ds.attrs['_site'] = str(ds.attrs['_datastream'])[0:3] + ds.attrs['_arm_standards_flag'] = is_arm_file_flag + + return ds diff --git a/act/plotting/HistogramDisplay.py b/act/plotting/HistogramDisplay.py deleted file mode 100644 index ff374936a8..0000000000 --- a/act/plotting/HistogramDisplay.py +++ /dev/null @@ -1,508 +0,0 @@ -""" Module for Histogram Plotting. """ - -import matplotlib.pyplot as plt -import numpy as np -import xarray as xr - -from .plot import Display -from ..utils import datetime_utils as dt_utils - - -class HistogramDisplay(Display): - """ - This class is used to make histogram plots. It is inherited from Display - and therefore contains all of Display's attributes and methods. - - Examples - -------- - To create a TimeSeriesDisplay with 3 rows, simply do: - - .. code-block:: python - - ds = act.read_netcdf(the_file) - disp = act.plotting.HistogramDisplay( - ds, subplot_shape=(3,), figsize=(15,5)) - - The HistogramDisplay constructor takes in the same keyword arguments as - plt.subplots. For more information on the plt.subplots keyword arguments, - see the `matplotlib documentation - `_. - If no subplot_shape is provided, then no figure or axis will be created - until add_subplots or plots is called. - - """ - def __init__(self, obj, subplot_shape=(1,), ds_name=None, **kwargs): - super().__init__(obj, subplot_shape, ds_name, **kwargs) - - def set_xrng(self, xrng, subplot_index=(0,)): - """ - Sets the x range of the plot. - - Parameters - ---------- - xrng : 2 number array - The x limits of the plot. - subplot_index : 1 or 2D tuple, list, or array - The index of the subplot to set the x range of. - - """ - if self.axes is None: - raise RuntimeError("set_xrng requires the plot to be displayed.") - - if not hasattr(self, 'xrng') and len(self.axes.shape) == 2: - self.xrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2), - dtype='datetime64[D]') - elif not hasattr(self, 'xrng') and len(self.axes.shape) == 1: - self.xrng = np.zeros((self.axes.shape[0], 2), - dtype='datetime64[D]') - - self.axes[subplot_index].set_xlim(xrng) - self.xrng[subplot_index, :] = np.array(xrng) - - def set_yrng(self, yrng, subplot_index=(0,)): - """ - Sets the y range of the plot. - - Parameters - ---------- - yrng : 2 number array - The y limits of the plot. - subplot_index : 1 or 2D tuple, list, or array - The index of the subplot to set the x range of. - - """ - if self.axes is None: - raise RuntimeError("set_yrng requires the plot to be displayed.") - - if not hasattr(self, 'yrng') and len(self.axes.shape) == 2: - self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) - elif not hasattr(self, 'yrng') and len(self.axes.shape) == 1: - self.yrng = np.zeros((self.axes.shape[0], 2)) - - if yrng[0] == yrng[1]: - yrng[1] = yrng[1] + 1 - - self.axes[subplot_index].set_ylim(yrng) - self.yrng[subplot_index, :] = yrng - - def plot_stacked_bar_graph(self, field, dsname=None, bins=None, - sortby_field=None, sortby_bins=None, - subplot_index=(0, ), set_title=None, - density=False, **kwargs): - """ - This procedure will plot a stacked bar graph of a histogram. - - Parameters - ---------- - field : str - The name of the field to take the histogram of. - dsname : str or None - The name of the datastream the field is contained in. Set - to None to let ACT automatically determine this. - bins : array-like or None - The histogram bin boundaries to use. Set to None to use - numpy's default boundaries. - sortby_field : str or None - Set this option to a field name in order to sort the histograms - by a given field parameter. For example, one can sort histograms of CO2 - concentration by temperature. - sortby_bins : array-like or None - The bins to sort the histograms by. - subplot_index : tuple - The subplot index to place the plot in - set_title : str - The title of the plot. - density: bool - Set to True to plot a p.d.f. instead of a frequency histogram. - - Other keyword arguments will be passed into :func:`matplotlib.pyplot.bar`. - - Returns - ------- - return_dict : dict - A dictionary containing the plot axis handle, bin boundaries, and - generated histogram. - - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " + - "or more datasets in the TimeSeriesDisplay " + - "object.")) - elif dsname is None: - dsname = list(self._arm.keys())[0] - - xdata = self._arm[dsname][field] - - if 'units' in xdata.attrs: - xtitle = ''.join(['(', xdata.attrs['units'], ')']) - else: - xtitle = field - - if sortby_field is not None: - ydata = self._arm[dsname][sortby_field] - - if bins is not None and sortby_bins is None and sortby_field is not None: - # We will defaut the y direction to have the same # of bins as x - sortby_bins = np.linspace(ydata.values.min(), ydata.values.max(), len(bins)) - - # Get the current plotting axis, add day/night background and plot data - if self.fig is None: - self.fig = plt.figure() - - if self.axes is None: - self.axes = np.array([plt.axes()]) - self.fig.add_axes(self.axes[0]) - - if sortby_field is not None: - if 'units' in ydata.attrs: - ytitle = ''.join(['(', ydata.attrs['units'], ')']) - else: - ytitle = field - if bins is None: - my_hist, x_bins, y_bins = np.histogram2d( - xdata.values.flatten(), ydata.values.flatten(), density=density) - else: - my_hist, x_bins, y_bins = np.histogram2d( - xdata.values.flatten(), ydata.values.flatten(), - density=density, bins=[bins, sortby_bins]) - x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 - self.axes[subplot_index].bar( - x_inds, my_hist[:, 0].flatten(), - label=(str(y_bins[0]) + " to " + str(y_bins[1])), **kwargs) - for i in range(1, len(y_bins) - 1): - self.axes[subplot_index].bar( - x_inds, my_hist[:, i].flatten(), - bottom=my_hist[:, i - 1], - label=(str(y_bins[i]) + " to " + str(y_bins[i + 1])), **kwargs) - self.axes[subplot_index].legend() - else: - if bins is None: - bmin = np.nanmin(xdata) - bmax = np.nanmax(xdata) - bins = np.arange(bmin, bmax, (bmax - bmin) / 10.) - my_hist, bins = np.histogram( - xdata.values.flatten(), bins=bins, density=density) - x_inds = (bins[:-1] + bins[1:]) / 2.0 - self.axes[subplot_index].bar(x_inds, my_hist) - - # Set Title - if set_title is None: - set_title = ' '.join([dsname, field, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) - self.axes[subplot_index].set_title(set_title) - self.axes[subplot_index].set_ylabel("count") - self.axes[subplot_index].set_xlabel(xtitle) - - return_dict = {} - return_dict["plot_handle"] = self.axes[subplot_index] - if 'x_bins' in locals(): - return_dict["x_bins"] = x_bins - return_dict["y_bins"] = y_bins - else: - return_dict["bins"] = bins - return_dict["histogram"] = my_hist - - return return_dict - - def plot_size_distribution(self, field, bins, time=None, dsname=None, - subplot_index=(0, ), set_title=None, - **kwargs): - """ - This procedure plots a stairstep plot of a size distribution. This is - useful for plotting size distributions and waveforms. - - Parameters - ---------- - field : str - The name of the field to plot the spectrum from. - bins : str or array-like - The name of the field that stores the bins for the spectra. - time : none or datetime - If None, spectra to plot will be automatically determined. - Otherwise, specify this field for the time period to plot. - dsname : str - The name of the Dataset to plot. Set to None to have - ACT automatically determine this. - subplot_index : tuple - The subplot index to place the plot in. - set_title : str or None - Use this to set the title. - - Additional keyword arguments will be passed into :func:`matplotlib.pyplot.step` - - Returns - ------- - ax : matplotlib axis handle - The matplotlib axis handle referring to the plot. - - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " + - "or more datasets in the TimeSeriesDisplay " + - "object.")) - elif dsname is None: - dsname = list(self._arm.keys())[0] - - xdata = self._arm[dsname][field] - - if isinstance(bins, str): - bins = self._arm[dsname][bins] - else: - bins = xr.DataArray(bins) - - if 'units' in bins.attrs: - xtitle = ''.join(['(', bins.attrs['units'], ')']) - else: - xtitle = 'Bin #' - - if 'units' in xdata.attrs: - ytitle = ''.join(['(', xdata.attrs['units'], ')']) - else: - ytitle = field - - if(len(xdata.dims) > 1 and time is None): - raise ValueError(("Input data has more than one dimension, " + - "you must specify a time to plot!")) - elif len(xdata.dims) > 1: - xdata = xdata.sel(time=time, method='nearest') - - if(len(bins.dims) > 1 or len(bins.values) != len(xdata.values)): - raise ValueError("Bins must be a one dimensional field whose " + - "length is equal to the field length!") - - # Get the current plotting axis, add day/night background and plot data - if self.fig is None: - self.fig = plt.figure() - - if self.axes is None: - self.axes = np.array([plt.axes()]) - self.fig.add_axes(self.axes[0]) - - # Set Title - if set_title is None: - set_title = ' '.join([dsname, field, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) - - self.axes[subplot_index].set_title(set_title) - self.axes[subplot_index].step(bins.values, xdata.values) - self.axes[subplot_index].set_xlabel(xtitle) - self.axes[subplot_index].set_ylabel(ytitle) - - return self.axes[subplot_index] - - def plot_stairstep_graph(self, field, dsname=None, bins=None, - sortby_field=None, sortby_bins=None, - subplot_index=(0, ), - set_title=None, - density=False, **kwargs): - """ - This procedure will plot a stairstep plot of a histogram. - - Parameters - ---------- - field : str - The name of the field to take the histogram of. - dsname : str or None - The name of the datastream the field is contained in. Set - to None to let ACT automatically determine this. - bins : array-like or None - The histogram bin boundaries to use. Set to None to use - numpy's default boundaries. - sortby_field : str or None - Set this option to a field name in order to sort the histograms - by a given field parameter. For example, one can sort histograms of CO2 - concentration by temperature. - sortby_bins : array-like or None - The bins to sort the histograms by. - subplot_index : tuple - The subplot index to place the plot in. - set_title : str - The title of the plot. - density : bool - Set to True to plot a p.d.f. instead of a frequency histogram. - - Other keyword arguments will be passed into :func:`matplotlib.pyplot.step`. - - Returns - ------- - return_dict : dict - A dictionary containing the plot axis handle, bin boundaries, and - generated histogram. - - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " + - "or more datasets in the TimeSeriesDisplay " + - "object.")) - elif dsname is None: - dsname = list(self._arm.keys())[0] - - xdata = self._arm[dsname][field] - - if 'units' in xdata.attrs: - xtitle = ''.join(['(', xdata.attrs['units'], ')']) - else: - xtitle = field - - if sortby_field is not None: - ydata = self._arm[dsname][sortby_field] - - if bins is not None and sortby_bins is None and sortby_field is not None: - # We will defaut the y direction to have the same # of bins as x - sortby_bins = np.linspace(ydata.values.min(), ydata.values.max(), len(bins)) - - # Get the current plotting axis, add day/night background and plot data - if self.fig is None: - self.fig = plt.figure() - - if self.axes is None: - self.axes = np.array([plt.axes()]) - self.fig.add_axes(self.axes[0]) - - if sortby_field is not None: - if 'units' in ydata.attrs: - ytitle = ''.join(['(', ydata.attrs['units'], ')']) - else: - ytitle = field - if bins is None: - my_hist, x_bins, y_bins = np.histogram2d( - xdata.values.flatten(), ydata.values.flatten(), density=density) - else: - my_hist, x_bins, y_bins = np.histogram2d( - xdata.values.flatten(), ydata.values.flatten(), - density=density, bins=[bins, sortby_bins]) - x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 - self.axes[subplot_index].step( - x_inds, my_hist[:, 0].flatten(), - label=(str(y_bins[0]) + " to " + str(y_bins[1])), **kwargs) - for i in range(1, len(y_bins) - 1): - self.axes[subplot_index].step( - x_inds, my_hist[:, i].flatten(), - label=(str(y_bins[i]) + " to " + str(y_bins[i + 1])), **kwargs) - self.axes[subplot_index].legend() - else: - my_hist, bins = np.histogram( - xdata.values.flatten(), bins=bins, density=density) - x_inds = (bins[:-1] + bins[1:]) / 2.0 - self.axes[subplot_index].step(x_inds, my_hist, **kwargs) - - # Set Title - if set_title is None: - set_title = ' '.join([dsname, field, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) - self.axes[subplot_index].set_title(set_title) - self.axes[subplot_index].set_ylabel("count") - self.axes[subplot_index].set_xlabel(xtitle) - - return_dict = {} - return_dict["plot_handle"] = self.axes[subplot_index] - if 'x_bins' in locals(): - return_dict["x_bins"] = x_bins - return_dict["y_bins"] = y_bins - else: - return_dict["bins"] = bins - return_dict["histogram"] = my_hist - - return return_dict - - def plot_heatmap(self, x_field, y_field, dsname=None, x_bins=None, y_bins=None, - subplot_index=(0, ), set_title=None, - density=False, **kwargs): - """ - This procedure will plot a heatmap of a histogram from 2 variables. - - Parameters - ---------- - x_field : str - The name of the field to take the histogram of on the X axis. - y_field : str - The name of the field to take the histogram of on the Y axis. - dsname : str or None - The name of the datastream the field is contained in. Set - to None to let ACT automatically determine this. - x_bins : array-like or None - The histogram bin boundaries to use for the variable on the X axis. - Set to None to use numpy's default boundaries. - y_bins : array-like or None - The histogram bin boundaries to use for the variable on the Y axis. - Set to None to use numpy's default boundaries. - subplot_index : tuple - The subplot index to place the plot in - set_title : str - The title of the plot. - density : bool - Set to True to plot a p.d.f. instead of a frequency histogram. - - Other keyword arguments will be passed into :func:`matplotlib.pyplot.pcolormesh`. - - Returns - ------- - return_dict : dict - A dictionary containing the plot axis handle, bin boundaries, and - generated histogram. - - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) - elif dsname is None: - dsname = list(self._arm.keys())[0] - - xdata = self._arm[dsname][x_field] - - if 'units' in xdata.attrs: - xtitle = ''.join(['(', xdata.attrs['units'], ')']) - else: - xtitle = x_field - ydata = self._arm[dsname][y_field] - - if x_bins is not None and y_bins is None: - # We will defaut the y direction to have the same # of bins as x - y_bins = np.linspace(ydata.values.min(), ydata.values.max(), len(x_bins)) - - # Get the current plotting axis, add day/night background and plot data - if self.fig is None: - self.fig = plt.figure() - - if self.axes is None: - self.axes = np.array([plt.axes()]) - self.fig.add_axes(self.axes[0]) - - if 'units' in ydata.attrs: - ytitle = ''.join(['(', ydata.attrs['units'], ')']) - else: - ytitle = y_field - - if x_bins is None: - my_hist, x_bins, y_bins = np.histogram2d( - xdata.values.flatten(), ydata.values.flatten(), density=density) - else: - my_hist, x_bins, y_bins = np.histogram2d( - xdata.values.flatten(), ydata.values.flatten(), - density=density, bins=[x_bins, y_bins]) - x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 - y_inds = (y_bins[:-1] + y_bins[1:]) / 2.0 - xi, yi = np.meshgrid(x_inds, y_inds, indexing='ij') - mesh = self.axes[subplot_index].pcolormesh(xi, yi, my_hist, **kwargs) - - # Set Title - if set_title is None: - set_title = ' '.join([dsname, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) - self.axes[subplot_index].set_title(set_title) - self.axes[subplot_index].set_ylabel(ytitle) - self.axes[subplot_index].set_xlabel(xtitle) - self.add_colorbar(mesh, title="count", subplot_index=subplot_index) - - return_dict = {} - return_dict["plot_handle"] = self.axes[subplot_index] - return_dict["x_bins"] = x_bins - return_dict["y_bins"] = y_bins - return_dict["histogram"] = my_hist - - return return_dict diff --git a/act/plotting/SkewTDisplay.py b/act/plotting/SkewTDisplay.py deleted file mode 100644 index 4c27636a45..0000000000 --- a/act/plotting/SkewTDisplay.py +++ /dev/null @@ -1,370 +0,0 @@ -""" -act.plotting.SkewTDisplay -------------------------- - -Stores the class for SkewTDisplay. - -""" - -# Import third party libraries -import matplotlib.pyplot as plt -import numpy as np -import warnings - -try: - from pkg_resources import DistributionNotFound - import metpy.calc as mpcalc - METPY_AVAILABLE = True -except ImportError: - METPY_AVAILABLE = False -except (ModuleNotFoundError, DistributionNotFound): - warnings.warn("MetPy is installed but could not be imported. " + - "Please check your MetPy installation. Some features " + - "will be disabled.", ImportWarning) - METPY_AVAILABLE = False - -# Import Local Libs -from ..utils import datetime_utils as dt_utils -from copy import deepcopy -from .plot import Display - -if METPY_AVAILABLE: - from metpy.units import units - from metpy.plots import SkewT - - -class SkewTDisplay(Display): - """ - A class for making Skew-T plots. - - This is inherited from the :func:`act.plotting.Display` - class and has therefore has the same attributes as that class. - See :func:`act.plotting.Display` - for more information. There are no additional attributes or parameters - to this class. - - In order to create Skew-T plots, ACT needs the MetPy package to be - installed on your system. More information about - MetPy go here: https://unidata.github.io/MetPy/latest/index.html. - - Examples - -------- - Here is an example of how to make a Skew-T plot using ACT: - - .. code-block :: python - - sonde_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE1) - - skewt = act.plotting.SkewTDisplay(sonde_ds) - skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp') - plt.show() - - """ - def __init__(self, obj, subplot_shape=(1,), ds_name=None, **kwargs): - # We want to use our routine to handle subplot adding, not the main - # one - if not METPY_AVAILABLE: - raise ImportError("MetPy need to be installed on your system to " + - "make Skew-T plots.") - new_kwargs = kwargs.copy() - super().__init__(obj, None, ds_name, - subplot_kw=dict(projection='skewx'), **new_kwargs) - - # Make a SkewT object for each subplot - self.add_subplots(subplot_shape, **kwargs) - - def add_subplots(self, subplot_shape=(1,), **kwargs): - """ - Adds subplots to the Display object. The current - figure in the object will be deleted and overwritten. - - Parameters - ---------- - subplot_shape : 1 or 2D tuple, list, or array - The structure of the subplots in (rows, cols). - subplot_kw : dict, optional - The kwargs to pass into fig.subplots. - **kwargs : keyword arguments - Any other keyword arguments that will be passed - into :func:`matplotlib.pyplot.figure` when the figure - is made. The figure is only made if the *fig* - property is None. See the matplotlib - documentation for further details on what keyword - arguments are available. - - """ - del self.axes - if self.fig is None: - self.fig = plt.figure(**kwargs) - self.SkewT = np.empty(shape=subplot_shape, dtype=SkewT) - self.axes = np.empty(shape=subplot_shape, dtype=plt.Axes) - if len(subplot_shape) == 1: - for i in range(subplot_shape[0]): - subplot_tuple = (subplot_shape[0], 1, i + 1) - self.SkewT[i] = SkewT(fig=self.fig, subplot=subplot_tuple) - self.axes[i] = self.SkewT[i].ax - elif len(subplot_shape) == 2: - for i in range(subplot_shape[0]): - for j in range(subplot_shape[1]): - subplot_tuple = (subplot_shape[0], - subplot_shape[1], - i * subplot_shape[1] + j + 1) - self.SkewT[i, j] = SkewT(fig=self.fig, subplot=subplot_tuple) - self.axes[i, j] = self.SkewT[i, j].ax - else: - raise ValueError("Subplot shape must be 1 or 2D!") - - def set_xrng(self, xrng, subplot_index=(0,)): - """ - Sets the x range of the plot. - - Parameters - ---------- - xrng : 2 number array. - The x limits of the plot. - subplot_index : 1 or 2D tuple, list, or array - The index of the subplot to set the x range of. - - """ - if self.axes is None: - raise RuntimeError("set_xrng requires the plot to be displayed.") - - if not hasattr(self, 'xrng') or np.all(self.xrng == 0): - if len(self.axes.shape) == 2: - self.xrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) - else: - self.xrng = np.zeros((self.axes.shape[0], 2)) - - self.axes[subplot_index].set_xlim(xrng) - self.xrng[subplot_index, :] = np.array(xrng) - - def set_yrng(self, yrng, subplot_index=(0,)): - """ - Sets the y range of the plot. - - Parameters - ---------- - yrng : 2 number array - The y limits of the plot. - subplot_index : 1 or 2D tuple, list, or array - The index of the subplot to set the x range of. - - """ - if self.axes is None: - raise RuntimeError("set_yrng requires the plot to be displayed.") - - if not hasattr(self, 'yrng') or np.all(self.yrng == 0): - if len(self.axes.shape) == 2: - self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) - else: - self.yrng = np.zeros((self.axes.shape[0], 2)) - - if not hasattr(self, 'yrng') and len(self.axes.shape) == 2: - self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) - elif not hasattr(self, 'yrng') and len(self.axes.shape) == 1: - self.yrng = np.zeros((self.axes.shape[0], 2)) - - if yrng[0] == yrng[1]: - yrng[1] = yrng[1] + 1 - - self.axes[subplot_index].set_ylim(yrng) - self.yrng[subplot_index, :] = yrng - - def plot_from_spd_and_dir(self, spd_field, dir_field, - p_field, t_field, td_field, dsname=None, - **kwargs): - """ - This plot will make a sounding plot from wind data that is given - in speed and direction. - - Parameters - ---------- - spd_field : str - The name of the field corresponding to the wind speed. - dir_field : str - The name of the field corresponding to the wind direction - in degrees from North. - p_field : str - The name of the field containing the atmospheric pressure. - t_field : str - The name of the field containing the atmospheric temperature. - td_field : str - The name of the field containing the dewpoint. - dsname : str or None - The name of the datastream to plot. Set to None to make ACT - attempt to automatically determine this. - kwargs : dict - Additional keyword arguments will be passed into - :func:`act.plotting.SkewTDisplay.plot_from_u_and_v` - - Returns - ------- - ax : matplotlib axis handle - The matplotlib axis handle corresponding to the plot. - - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) - elif dsname is None: - dsname = list(self._arm.keys())[0] - - # Make temporary field called tempu, tempv - spd = self._arm[dsname][spd_field].values - dir = self._arm[dsname][dir_field].values - tempu = -np.sin(np.deg2rad(dir)) * spd - tempv = -np.cos(np.deg2rad(dir)) * spd - self._arm[dsname]["temp_u"] = deepcopy(self._arm[dsname][spd_field]) - self._arm[dsname]["temp_v"] = deepcopy(self._arm[dsname][spd_field]) - self._arm[dsname]["temp_u"].values = tempu - self._arm[dsname]["temp_v"].values = tempv - the_ax = self.plot_from_u_and_v("temp_u", "temp_v", p_field, - t_field, td_field, dsname, **kwargs) - del self._arm[dsname]["temp_u"], self._arm[dsname]["temp_v"] - return the_ax - - def plot_from_u_and_v(self, u_field, v_field, p_field, - t_field, td_field, dsname=None, subplot_index=(0,), - p_levels_to_plot=None, show_parcel=True, - shade_cape=True, shade_cin=True, set_title=None, - plot_barbs_kwargs=dict(), plot_kwargs=dict(),): - """ - This function will plot a Skew-T from a sounding dataset. The wind - data must be given in u and v. - - Parameters - ---------- - u_field : str - The name of the field containing the u component of the wind. - v_field : str - The name of the field containing the v component of the wind. - p_field : str - The name of the field containing the pressure. - t_field : str - The name of the field containing the temperature. - td_field : str - The name of the field containing the dewpoint temperature. - dsname : str or None - The name of the datastream to plot. Set to None to make ACT - attempt to automatically determine this. - subplot_index : tuple - The index of the subplot to make the plot on. - p_levels_to_plot : 1D array - The pressure levels to plot the wind barbs on. Set to None - to have ACT to use neatly spaced defaults of - 50, 100, 200, 300, 400, 500, 600, 700, 750, 800, - 850, 900, 950, and 1000 hPa. - show_parcel : bool - Set to True to show the temperature of a parcel lifted - from the surface. - shade_cape : bool - Set to True to shade the CAPE red. - shade_cin : bool - Set to True to shade the CIN blue. - set_title : None or str - The title of the plot is set to this. Set to None to use - a default title. - plot_barbs_kwargs : dict - Additional keyword arguments to pass into MetPy's - SkewT.plot_barbs. - plot_kwargs : dict - Additional keyword arguments to pass into MetPy's - SkewT.plot. - - Returns - ------- - ax : matplotlib axis handle - The axis handle to the plot. - - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) - elif dsname is None: - dsname = list(self._arm.keys())[0] - - if p_levels_to_plot is None: - p_levels_to_plot = np.array([50., 100., 200., 300., 400., - 500., 600., 700., 750., 800., - 850., 900., 950., 1000.]) - T = self._arm[dsname][t_field] - T_units = self._arm[dsname][t_field].attrs["units"] - if T_units == "C": - T_units = "degC" - - T = T.values * getattr(units, T_units) - Td = self._arm[dsname][td_field] - Td_units = self._arm[dsname][td_field].attrs["units"] - if Td_units == "C": - Td_units = "degC" - - Td = Td.values * getattr(units, Td_units) - u = self._arm[dsname][u_field] - u_units = self._arm[dsname][u_field].attrs["units"] - u = u.values * getattr(units, u_units) - - v = self._arm[dsname][v_field] - v_units = self._arm[dsname][v_field].attrs["units"] - v = v.values * getattr(units, v_units) - - p = self._arm[dsname][p_field] - p_units = self._arm[dsname][p_field].attrs["units"] - p = p.values * getattr(units, p_units) - - u_red = np.zeros_like(p_levels_to_plot) * getattr(units, u_units) - v_red = np.zeros_like(p_levels_to_plot) * getattr(units, v_units) - p_levels_to_plot = p_levels_to_plot * getattr(units, p_units) - for i in range(len(p_levels_to_plot)): - index = np.argmin(np.abs(p_levels_to_plot[i] - p)) - u_red[i] = u[index].magnitude * getattr(units, u_units) - v_red[i] = v[index].magnitude * getattr(units, v_units) - - u_red = u_red.magnitude - v_red = v_red.magnitude - self.SkewT[subplot_index].plot(p, T, 'r', **plot_kwargs) - self.SkewT[subplot_index].plot(p, Td, 'g', **plot_kwargs) - self.SkewT[subplot_index].plot_barbs( - p_levels_to_plot, u_red, v_red, **plot_barbs_kwargs) - - prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC') - if show_parcel: - # Only plot where prof > T - lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0]) - self.SkewT[subplot_index].plot( - lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black', - **plot_kwargs) - self.SkewT[subplot_index].plot( - p, prof, 'k', linewidth=2, **plot_kwargs) - - if shade_cape: - self.SkewT[subplot_index].shade_cape( - p, T, prof, linewidth=2) - - if shade_cin: - self.SkewT[subplot_index].shade_cin( - p, T, prof, linewidth=2) - - # Set Title - if set_title is None: - set_title = ' '.join( - [dsname, 'on', - dt_utils.numpy_to_arm_date(self._arm[dsname].time.values[0])]) - - self.axes[subplot_index].set_title(set_title) - - # Set Y Limit - our_data = p.magnitude - if np.isfinite(our_data).any(): - yrng = [np.nanmax(our_data), np.nanmin(our_data)] - else: - yrng = [1000., 100.] - self.set_yrng(yrng, subplot_index) - - # Set X Limit - xrng = [np.nanmin(T.magnitude) - 10., np.nanmax(T.magnitude) + 10.] - self.set_xrng(xrng, subplot_index) - - return self.axes[subplot_index] diff --git a/act/plotting/WindRoseDisplay.py b/act/plotting/WindRoseDisplay.py deleted file mode 100644 index 5ea0c76e88..0000000000 --- a/act/plotting/WindRoseDisplay.py +++ /dev/null @@ -1,225 +0,0 @@ -""" -act.plotting.WindRoseDisplay ----------------------------- - -Stores the class for WindRoseDisplay. - -""" - -import matplotlib.pyplot as plt -import numpy as np -import warnings - -from .plot import Display -# Import Local Libs -from ..utils import datetime_utils as dt_utils - - -class WindRoseDisplay(Display): - """ - A class for handing wind rose plots. - - This is inherited from the :func:`act.plotting.Display` - class and has therefore has the same attributes as that class. - See :func:`act.plotting.Display` - for more information. There are no additional attributes or parameters - to this class. - - Examples - -------- - To create a WindRoseDisplay object, simply do: - - .. code-block :: python - - sonde_ds = act.io.armfiles.read_netcdf('sonde_data.nc') - WindDisplay = act.plotting.WindRoseDisplay(sonde_ds, figsize=(8,10)) - - """ - def __init__(self, obj, subplot_shape=(1,), ds_name=None, **kwargs): - super().__init__(obj, subplot_shape, ds_name, - subplot_kw=dict(projection='polar'), **kwargs) - - def set_thetarng(self, trng=(0., 360.), subplot_index=(0,)): - """ - Sets the theta range of the wind rose plot. - - Parameters - ---------- - trng : 2-tuple - The range (in degrees). - subplot_index : 2-tuple - The index of the subplot to set the degree range of. - - """ - if self.axes is not None: - self.axes[subplot_index].set_thetamin(trng[0]) - self.axes[subplot_index].set_thetamax(trng[1]) - self.trng = trng - else: - raise RuntimeError(("Axes must be initialized before" + - " changing limits!")) - print(self.trng) - - def set_rrng(self, rrng, subplot_index=(0,)): - """ - Sets the range of the radius of the wind rose plot. - - Parameters - ---------- - rrng : 2-tuple - The range for the plot radius (in %). - subplot_index : 2-tuple - The index of the subplot to set the radius range of. - - """ - if self.axes is not None: - self.axes[subplot_index].set_rmin(rrng[0]) - self.axes[subplot_index].set_rmax(rrng[1]) - self.rrng = rrng - else: - raise RuntimeError(("Axes must be initialized before" + - " changing limits!")) - - def plot(self, dir_field, spd_field, dsname=None, subplot_index=(0,), - cmap=None, set_title=None, num_dirs=20, spd_bins=None, - tick_interval=3, legend_loc=0, legend_bbox=None, legend_title=None, - calm_threshold=1., - **kwargs): - """ - Makes the wind rose plot from the given dataset. - - Parameters - ---------- - dir_field : str - The name of the field representing the wind direction (in degrees). - spd_field : str - The name of the field representing the wind speed. - dsname : str - The name of the datastream to plot from. Set to None to - let ACT automatically try to determine this. - subplot_index : 2-tuple - The index of the subplot to place the plot on. - cmap : str or matplotlib colormap - The name of the matplotlib colormap to use. - set_title : str - The title of the plot. - num_dirs : int - The number of directions to split the wind rose into. - spd_bins : 1D array-like - The bin boundaries to sort the wind speeds into. - tick_interval : int - The interval (in %) for the ticks on the radial axis. - legend_loc : int - Legend location using matplotlib legend code - legend_bbox : tuple - Legend bounding box coordinates - legend_title : string - Legend title - calm_threshold : float - Winds below this threshold are considered to be calm. - **kwargs : keyword arguments - Additional keyword arguments will be passed into :func:plt.bar - - Returns - ------- - ax : matplotlib axis handle - The matplotlib axis handle corresponding to the plot. - - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) - elif dsname is None: - dsname = list(self._arm.keys())[0] - - # Get data and dimensions - dir_data = self._arm[dsname][dir_field].values - spd_data = self._arm[dsname][spd_field].values - - # Get the current plotting axis, add day/night background and plot data - if self.fig is None: - self.fig = plt.figure() - - if self.axes is None: - self.axes = np.array([plt.axes(projection='polar')]) - self.fig.add_axes(self.axes[0]) - - if spd_bins is None: - spd_bins = np.linspace(0, np.nanmax(spd_data), 10) - - # Make the bins so that 0 degrees N is in the center of the first bin - # We need to wrap around - - deg_width = 360. / num_dirs - dir_bins_mid = np.linspace(0., 360. - 3 * deg_width / 2., num_dirs) - wind_hist = np.zeros((num_dirs, len(spd_bins) - 1)) - - for i in range(num_dirs): - if i == 0: - with warnings.catch_warnings(): - warnings.filterwarnings("ignore", "invalid value encountered in.*") - the_range = np.logical_or(dir_data < deg_width / 2., - dir_data > 360. - deg_width / 2.) - else: - with warnings.catch_warnings(): - warnings.filterwarnings("ignore", "invalid value encountered in.*") - the_range = np.logical_and( - dir_data >= dir_bins_mid[i] - deg_width / 2, - dir_data <= dir_bins_mid[i] + deg_width / 2) - hist, bins = np.histogram(spd_data[the_range], spd_bins) - wind_hist[i] = hist - - wind_hist = wind_hist / np.sum(wind_hist) * 100 - mins = np.deg2rad(dir_bins_mid) - - # Do the first level - if 'units' in self._arm[dsname][spd_field].attrs.keys(): - units = self._arm[dsname][spd_field].attrs['units'] - else: - units = '' - the_label = ("%3.1f" % spd_bins[0] + - '-' + "%3.1f" % spd_bins[1] + " " + units) - our_cmap = plt.cm.get_cmap(cmap) - our_colors = our_cmap(np.linspace(0, 1, len(spd_bins))) - - bars = [self.axes[subplot_index].bar(mins, wind_hist[:, 0], - bottom=0, - label=the_label, - width=0.8 * np.deg2rad(deg_width), - color=our_colors[0], - **kwargs)] - for i in range(1, len(spd_bins) - 1): - the_label = ("%3.1f" % spd_bins[i] + - '-' + "%3.1f" % spd_bins[i + 1] + " " + units) - # Changing the bottom to be a sum of the previous speeds so that - # it positions it correctly - Adam Theisen - bars.append(self.axes[subplot_index].bar( - mins, wind_hist[:, i], label=the_label, - bottom=np.sum(wind_hist[:, :i], axis=1), width=0.8 * np.deg2rad(deg_width), - color=our_colors[i], **kwargs)) - self.axes[subplot_index].legend(loc=legend_loc, bbox_to_anchor=legend_bbox, - title=legend_title) - self.axes[subplot_index].set_theta_zero_location("N") - self.axes[subplot_index].set_theta_direction(-1) - - # Add an annulus with text stating % of time calm - pct_calm = np.sum(spd_data <= calm_threshold) / len(spd_data) * 100 - self.axes[subplot_index].set_rorigin(-2.5) - self.axes[subplot_index].annotate("%3.2f%%\n calm" % pct_calm, xy=(0, -2.5), ha='center', va='center') - - # Set the ticks to be nice numbers - tick_max = tick_interval * round( - np.nanmax(np.cumsum(wind_hist, axis=1)) / tick_interval) - rticks = np.arange(0, tick_max, tick_interval) - rticklabels = [("%d" % x + '%') for x in rticks] - self.axes[subplot_index].set_rticks(rticks) - self.axes[subplot_index].set_yticklabels(rticklabels) - - # Set Title - if set_title is None: - set_title = ' '.join([dsname, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) - self.axes[subplot_index].set_title(set_title) - return self.axes[subplot_index] diff --git a/act/plotting/__init__.py b/act/plotting/__init__.py index e79ccd79bd..68547a9a3c 100644 --- a/act/plotting/__init__.py +++ b/act/plotting/__init__.py @@ -1,47 +1,50 @@ """ -=========================== -act.plotting (act.plotting) -=========================== - -.. currentmodule:: act.plotting - This module contains classes for displaying data. :func:`act.plotting.Display` is the base class on which all other Display classes are inherited from. If you are making a new Display object, please make it inherited from this class. | :func:`act.plotting.ContourDisplay` handles the plotting of contour plots. +| :func:`act.plotting.DistributionDisplay` handles the plotting of distribution-related plots. | :func:`act.plotting.GeographicPlotDisplay` handles the plotting of lat-lon plots. -| :func:`act.plotting.HistogramDisplay` handles the plotting of histogram plots. | :func:`act.plotting.SkewTDisplay` handles the plotting of Skew-T diagrams. | :func:`act.plotting.TimeSeriesDisplay` handles the plotting of timeseries. | :func:`act.plotting.WindRoseDisplay` handles the plotting of wind rose plots. | :func:`act.plotting.XSectionDisplay` handles the plotting of cross sections. -.. autosummary:: - :toctree: generated/ - - plot.Display - ContourDisplay - GeographicPlotDisplay - HistogramDisplay - SkewTDisplay - TimeSeriesDisplay - WindRoseDisplay - XSectionDisplay - common.parse_ax - common.parse_ax_fig - common.get_date_format - act_cmap """ -from .plot import Display -from .TimeSeriesDisplay import TimeSeriesDisplay -from .ContourDisplay import ContourDisplay -from .WindRoseDisplay import WindRoseDisplay -from .SkewTDisplay import SkewTDisplay -from .XSectionDisplay import XSectionDisplay -from .GeoDisplay import GeographicPlotDisplay -from .HistogramDisplay import HistogramDisplay +import lazy_loader as lazy + +# Load colormaps +import cmweather + +# Eagerly load in common from . import common -from . import act_cmap + +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=[ + 'act_cmap', + '_act_cmap', + 'common', + 'contourdisplay', + 'geodisplay', + 'plot', + 'skewtdisplay', + 'timeseriesdisplay', + 'windrosedisplay', + 'xsectiondisplay', + 'distributiondisplay', + ], + submod_attrs={ + 'contourdisplay': ['ContourDisplay'], + 'geodisplay': ['GeographicPlotDisplay'], + 'plot': ['Display', 'GroupByDisplay'], + 'skewtdisplay': ['SkewTDisplay'], + 'timeseriesdisplay': ['TimeSeriesDisplay'], + 'windrosedisplay': ['WindRoseDisplay'], + 'xsectiondisplay': ['XSectionDisplay'], + 'distributiondisplay' : ['DistributionDisplay'], + }, +) diff --git a/act/plotting/_act_cmap.py b/act/plotting/_act_cmap.py deleted file mode 100644 index 6d112e492a..0000000000 --- a/act/plotting/_act_cmap.py +++ /dev/null @@ -1,49 +0,0 @@ -""" -act.plotting._act_cmap - -Data for colorblind friendly colormaps. - -""" -import numpy as np -import os - - -def yuv_rainbow_24(nc): - path1 = np.linspace(0.8 * np.pi, 1.8 * np.pi, nc) - path2 = np.linspace(-0.33 * np.pi, 0.33 * np.pi, nc) - - y = np.concatenate([np.linspace(0.3, 0.85, nc * 2 // 5), - np.linspace(0.9, 0.0, nc - nc * 2 // 5)]) - u = 0.40 * np.sin(path1) - v = 0.55 * np.sin(path2) + 0.1 - - rgb_from_yuv = np.array([[1, 0, 1.13983], - [1, -0.39465, -0.58060], - [1, 2.03211, 0]]) - cmap_dict = {'blue': [], 'green': [], 'red': []} - for i in range(len(y)): - yuv = np.array([y[i], u[i], v[i]]) - rgb = rgb_from_yuv.dot(yuv) - red_tuple = (i / (len(y) - 1.0), rgb[0], rgb[0]) - green_tuple = (i / (len(y) - 1.0), rgb[1], rgb[1]) - blue_tuple = (i / (len(y) - 1.0), rgb[2], rgb[2]) - cmap_dict['blue'].append(blue_tuple) - cmap_dict['red'].append(red_tuple) - cmap_dict['green'].append(green_tuple) - - return cmap_dict - - -# balance colormap from cmocean project -# courtesy Kristen Thyng - -# Thyng, K. M., Greene, C. A., Hetland, R. D., Zimmerle, H. M., & DiMarco, S. F. (2016). -# True colors of oceanography. Oceanography, 29(3), 10. - -# HomeyerRainbow developed by Cameron Homeyer with assistance from Bobby Jackson - - -data_dir = os.path.split(__file__)[0] -bal_rgb_vals = np.genfromtxt(os.path.join(data_dir, 'balance-rgb.txt')) - -datad = {'HomeyerRainbow': yuv_rainbow_24(15), 'balance': bal_rgb_vals} diff --git a/act/plotting/act_cmap.py b/act/plotting/act_cmap.py deleted file mode 100644 index 566ec0f8e0..0000000000 --- a/act/plotting/act_cmap.py +++ /dev/null @@ -1,103 +0,0 @@ -""" -act.plotting.act_cmap -===================== -Colorblind friendly colormaps. - -.. autosummary:: - :toctree: generated/ - - _generate_cmap - -Available colormaps (reversed versions also provided), these -colormaps are available within matplotlib with names act_COLORMAP': - - * HomeyerRainbow - -""" - -from __future__ import print_function, division - -import matplotlib as mpl -import matplotlib.cm -import matplotlib.colors as colors - -from ._act_cmap import datad, yuv_rainbow_24 - - -def _reverser(f): - """ perform reversal. """ - def freversed(x): - """ f specific reverser. """ - return f(1 - x) - return freversed - - -def revcmap(data): - """ Can only handle specification *data* in dictionary format. """ - data_r = {} - for key, val in data.items(): - if callable(val): - valnew = _reverser(val) - # This doesn't work: lambda x: val(1-x) - # The same "val" (the first one) is used - # each time, so the colors are identical - # and the result is shades of gray. - else: - # Flip x and exchange the y values facing x = 0 and x = 1. - valnew = [(1.0 - x, y1, y0) for x, y0, y1 in reversed(val)] - data_r[key] = valnew - return data_r - - -def _reverse_cmap_spec(spec): - """ Reverses cmap specification *spec*, can handle both dict and tuple - type specs. """ - - if isinstance(spec, dict) and 'red' in spec.keys(): - return revcmap(spec) - else: - revspec = list(reversed(spec)) - if len(revspec[0]) == 2: # e.g., (1, (1.0, 0.0, 1.0)) - revspec = [(1.0 - a, b) for a, b in revspec] - return revspec - - -def _generate_cmap(name, lutsize): - """ Generates the requested cmap from it's name *name*. The lut size is - *lutsize*. """ - - spec = datad[name] - - # Generate the colormap object. - if isinstance(spec, dict) and 'red' in spec.keys(): - return colors.LinearSegmentedColormap(name, spec, lutsize) - else: - return colors.LinearSegmentedColormap.from_list(name, spec, lutsize) - - -cmap_d = dict() - -LUTSIZE = mpl.rcParams['image.lut'] - -# need this list because datad is changed in loop -_cmapnames = list(datad.keys()) - -# Generate the reversed specifications ... - -for cmapname in _cmapnames: - spec = datad[cmapname] - spec_reversed = _reverse_cmap_spec(spec) - datad[cmapname + '_r'] = spec_reversed - -# Precache the cmaps with ``lutsize = LUTSIZE`` ... - -# Use datad.keys() to also add the reversed ones added in the section above: -for cmapname in datad.keys(): - cmap_d[cmapname] = _generate_cmap(cmapname, LUTSIZE) - -locals().update(cmap_d) - -# register the colormaps so that they can be accessed with the names act_XXX -for name, cmap in cmap_d.items(): - full_name = 'act_' + name - mpl.cm.register_cmap(name=full_name, cmap=cmap) diff --git a/act/plotting/balance-rgb.txt b/act/plotting/balance-rgb.txt deleted file mode 100644 index 64485eaa7c..0000000000 --- a/act/plotting/balance-rgb.txt +++ /dev/null @@ -1,256 +0,0 @@ -9.317630180115785143e-02 1.111733294776027225e-01 2.615123885530547532e-01 -9.697151501690241815e-02 1.168702109792841837e-01 2.730963071061036085e-01 -1.009688451686782534e-01 1.223931506799195018e-01 2.849103610759459171e-01 -1.049927013864766501e-01 1.278243708004132007e-01 2.968738052891420898e-01 -1.089874020283561201e-01 1.331935038256579495e-01 3.089538370897204067e-01 -1.129223008178065757e-01 1.385131449459734432e-01 3.211528356563003173e-01 -1.167787372671460905e-01 1.437907235567953967e-01 3.334763137669404798e-01 -1.205463368759411846e-01 1.490330498991488395e-01 3.459192712822865556e-01 -1.242159653236002137e-01 1.542448960991174289e-01 3.584824902114073786e-01 -1.277778433781233958e-01 1.594292997650425259e-01 3.711737182907450250e-01 -1.312243830518974863e-01 1.645899274655008293e-01 3.839938980982077199e-01 -1.345490385720651272e-01 1.697307784244891371e-01 3.969402498465131601e-01 -1.377440294143187915e-01 1.748552489081271477e-01 4.100132193954066917e-01 -1.407996250839473606e-01 1.799660943911219058e-01 4.232173781877683894e-01 -1.437072840727513789e-01 1.850671827584920992e-01 4.365502201613832844e-01 -1.464560785040432134e-01 1.901619264187031366e-01 4.500130967746718835e-01 -1.490348239402249919e-01 1.952544786288682443e-01 4.636036238706138235e-01 -1.514309258266629821e-01 2.003493745808981319e-01 4.773185296806868871e-01 -1.536266468153191511e-01 2.054503782969492598e-01 4.911623505831314018e-01 -1.556073044691906326e-01 2.105638989188344801e-01 5.051241984185815825e-01 -1.573534941852142433e-01 2.156962129560367203e-01 5.191977165014443063e-01 -1.588411077773489166e-01 2.208540630983729658e-01 5.333780986311171812e-01 -1.600396310676128475e-01 2.260448054488821412e-01 5.476626851250718797e-01 -1.609205321230856855e-01 2.312792188936386995e-01 5.620307968352061812e-01 -1.614455266589641669e-01 2.365687572657042548e-01 5.764661948566720540e-01 -1.615687582201552897e-01 2.419271731798259828e-01 5.909472809712390529e-01 -1.612352769386722617e-01 2.473711867632350236e-01 6.054446786315181850e-01 -1.603793369556453796e-01 2.529213001868846900e-01 6.199179403497330210e-01 -1.589165703217830516e-01 2.586022090180682964e-01 6.343183928801525706e-01 -1.567387388150081051e-01 2.644444177118183137e-01 6.485832602021305293e-01 -1.537422741701028883e-01 2.704875236386605764e-01 6.625942914402649375e-01 -1.497539850217274870e-01 2.767772906869140348e-01 6.762428866538948702e-01 -1.446190280141932405e-01 2.833703371099008383e-01 6.893303155405390292e-01 -1.381506719438430897e-01 2.903290266080994497e-01 7.016166706228140759e-01 -1.301937481102784511e-01 2.977137475582261605e-01 7.127928058673724809e-01 -1.207056294812082625e-01 3.055623316038361126e-01 7.225101391519437311e-01 -1.098226938414934850e-01 3.138651882979107688e-01 7.304694442052537262e-01 -9.795843445627248902e-02 3.225431024585883599e-01 7.365271649499161022e-01 -8.570023827886968926e-02 3.314661612751826358e-01 7.407718073497575606e-01 -7.367688675533522191e-02 3.404967458048910878e-01 7.434693436710165804e-01 -6.252232597310111717e-02 3.495197377754474255e-01 7.449562973790243570e-01 -5.283258403911513662e-02 3.584600781237165523e-01 7.455451847703780111e-01 -4.520938539971628561e-02 3.672749347230809258e-01 7.454889092261348660e-01 -4.023631323597558207e-02 3.759418522020857023e-01 7.449841371058433248e-01 -3.831576485736640919e-02 3.844536826035842014e-01 7.441746283479093726e-01 -3.948349528027724625e-02 3.928137536670130436e-01 7.431581338661337188e-01 -4.345843888396401511e-02 4.010237097170425424e-01 7.420243047032398787e-01 -4.962431895510652918e-02 4.090953160508887798e-01 7.408166831290733390e-01 -5.739800117053886486e-02 4.170346954168047682e-01 7.395877539875740370e-01 -6.626017539288729663e-02 4.248521500099918247e-01 7.383650122111450331e-01 -7.582789138192139178e-02 4.325572249230948407e-01 7.371697936237424642e-01 -8.583710398799437868e-02 4.401583433039914506e-01 7.360206802189788178e-01 -9.611023898027164225e-02 4.476635745571445613e-01 7.349312516211791158e-01 -1.065303883460570755e-01 4.550804241299538089e-01 7.339117735870001047e-01 -1.170216465020320479e-01 4.624159111924117660e-01 7.329693696980987827e-01 -1.275357983203295742e-01 4.696767197731893662e-01 7.321074968220891988e-01 -1.380432121650685962e-01 4.768686794858796318e-01 7.313295149248254523e-01 -1.485266661140711986e-01 4.839970747487774561e-01 7.306374469250058734e-01 -1.589774367328510296e-01 4.910666599003393196e-01 7.300322634722052895e-01 -1.693927097070233589e-01 4.980816767007848478e-01 7.295140990156090410e-01 -1.797738575018875684e-01 5.050458714090990675e-01 7.290824177866462863e-01 -1.901252883653588299e-01 5.119625097219066001e-01 7.287361439246872186e-01 -2.004536741991692628e-01 5.188343886055641896e-01 7.284737667569484154e-01 -2.107674308545827713e-01 5.256638445778923918e-01 7.282934299212738827e-01 -2.210763664417479957e-01 5.324527583974503209e-01 7.281930113726282627e-01 -2.313914398990180310e-01 5.392025564688637251e-01 7.281702001646749300e-01 -2.417245888287989919e-01 5.459142096302009861e-01 7.282225751002735503e-01 -2.520885959217774586e-01 5.525882304010224511e-01 7.283476897674903139e-01 -2.624969693582706598e-01 5.592246702775622857e-01 7.285431679898072277e-01 -2.729638158446638374e-01 5.658231192947545951e-01 7.288068131774058100e-01 -2.835036864649327915e-01 5.723827108458280355e-01 7.291367343046032401e-01 -2.941313761905648416e-01 5.789021356407471064e-01 7.295314900628433463e-01 -3.048616586033888742e-01 5.853796696249742304e-01 7.299902509334000866e-01 -3.157089391891977348e-01 5.918132215225327952e-01 7.305129762764809298e-01 -3.266868146870496870e-01 5.982004061606387424e-01 7.311005998876300982e-01 -3.378075337747806772e-01 6.045386495071959354e-01 7.317552128195412564e-01 -3.490818000871770965e-01 6.108253115449155946e-01 7.324796800093837934e-01 -3.605169723334935572e-01 6.170578982409773428e-01 7.332792190500567742e-01 -3.721163789840524760e-01 6.232343167456089184e-01 7.341612307067191256e-01 -3.838798790902256397e-01 6.293530561660979350e-01 7.351337469132933622e-01 -3.958028137607393915e-01 6.354134382185918639e-01 7.362060213183361235e-01 -4.078755353103907799e-01 6.414158575290970221e-01 7.373884640869047269e-01 -4.200825599604326444e-01 6.473620651543986471e-01 7.386930839012650907e-01 -4.324066537782813580e-01 6.532548504780409937e-01 7.401294470548486215e-01 -4.448270147115060968e-01 6.590982595876608841e-01 7.417069328868316491e-01 -4.573210929073768805e-01 6.648973878622411737e-01 7.434335263117878290e-01 -4.698658823662555939e-01 6.706581495075844002e-01 7.453153847182404368e-01 -4.824391638200489774e-01 6.763869948243975694e-01 7.473565606883062484e-01 -4.950205546820442004e-01 6.820906132919950515e-01 7.495589040396917202e-01 -5.075922656244505893e-01 6.877756591216436233e-01 7.519221394187723950e-01 -5.201395209800695474e-01 6.934485275105084501e-01 7.544440922042097153e-01 -5.326506556783058288e-01 6.991151975856019218e-01 7.571210204550441469e-01 -5.451151059190834092e-01 7.047815278674717243e-01 7.599492971931861574e-01 -5.575181558550945660e-01 7.104543187762520917e-01 7.629291415211207905e-01 -5.698635397781144363e-01 7.161365136199150383e-01 7.660488334775965580e-01 -5.821485860154738123e-01 7.218322109491160932e-01 7.693023567855580280e-01 -5.943602368020499682e-01 7.275477994362923306e-01 7.726916325476315128e-01 -6.065080899095934841e-01 7.332844479726540188e-01 7.762041114816310428e-01 -6.185864665812587093e-01 7.390466790641196937e-01 7.798383670352863062e-01 -6.305963554035781682e-01 7.448373397672364282e-01 7.835892177406345027e-01 -6.425403291413834816e-01 7.506587685331359561e-01 7.874510644025978223e-01 -6.544185977825304201e-01 7.565137308188258913e-01 7.914204294842384080e-01 -6.662315287143806275e-01 7.624048800378464552e-01 7.954941819359623301e-01 -6.779850393157120791e-01 7.683332855369554570e-01 7.996659972294575258e-01 -6.896755013217630292e-01 7.743024253591546113e-01 8.039360994237751967e-01 -7.013107513266423343e-01 7.803126348729136907e-01 8.082975524678305268e-01 -7.128885314512861671e-01 7.863668558670167119e-01 8.127502175082055302e-01 -7.244112448085553435e-01 7.924667152464015540e-01 8.172911293271547528e-01 -7.358836989688380958e-01 7.986130654557248576e-01 8.219158971644889844e-01 -7.473044386446877629e-01 8.048084510111997991e-01 8.266243361574353576e-01 -7.586759860087319840e-01 8.110542493572184819e-01 8.314137476978961105e-01 -7.700007022560961811e-01 8.173518180665149124e-01 8.362815657919246970e-01 -7.812789490175476859e-01 8.237030526155880716e-01 8.412265533654796901e-01 -7.925116214732782494e-01 8.301096652946458043e-01 8.462470956714009951e-01 -8.036997510351909790e-01 8.365733017623517842e-01 8.513414099007207136e-01 -8.148431081888104499e-01 8.430959697406819053e-01 8.565084542610862384e-01 -8.259421593641688153e-01 8.496794646156250463e-01 8.617465433522450979e-01 -8.369967539127278755e-01 8.563257710703112702e-01 8.670541605111352634e-01 -8.480038340013845710e-01 8.630377874332209043e-01 8.724315628924932398e-01 -8.589628398368314155e-01 8.698176873531217046e-01 8.778768407867350021e-01 -8.698718779534676537e-01 8.766681056859056964e-01 8.833884311630415542e-01 -8.807225950585577667e-01 8.835937613774932364e-01 8.889689808541467730e-01 -8.915125639987498962e-01 8.905976582376062822e-01 8.946157932523199907e-01 -9.022321856472953483e-01 8.976851819173250480e-01 9.003303399902121695e-01 -9.128629530771473766e-01 9.048646775143293075e-01 9.061201920398328502e-01 -9.233906674988954233e-01 9.121434538185491103e-01 9.119872701021832784e-01 -9.337690699519377580e-01 9.195389121458987791e-01 9.179604265763980919e-01 -9.438768578707728008e-01 9.270905817099515112e-01 9.241478407896098757e-01 -9.450241336950316873e-01 9.267273985243987822e-01 9.232017297254778709e-01 -9.401771503305338396e-01 9.175010969420787088e-01 9.127353023021862466e-01 -9.357788176131993652e-01 9.081849602977229985e-01 9.019958970504049489e-01 -9.316195516453253944e-01 8.988455936080792519e-01 8.911247259869568005e-01 -9.276366903952597553e-01 8.895015346080178409e-01 8.801625091446737548e-01 -9.237963723082156520e-01 8.801619939913720714e-01 8.691306632065185500e-01 -9.200767818087643990e-01 8.708323115565800299e-01 8.580426479951916985e-01 -9.164622665155582881e-01 8.615158650696722598e-01 8.469079246742292622e-01 -9.129409700010679973e-01 8.522148302070590153e-01 8.357335125969563849e-01 -9.095033897880691054e-01 8.429306461313940124e-01 8.245249535921664874e-01 -9.061413505699446036e-01 8.336643536120030840e-01 8.132870275157044748e-01 -9.028482401464246188e-01 8.244164969479621519e-01 8.020234992942889551e-01 -8.996183458250350817e-01 8.151873435674267254e-01 7.907375926293952473e-01 -8.964464017336835067e-01 8.059770371403549571e-01 7.794323253122593664e-01 -8.933280984986637918e-01 7.967854062668440207e-01 7.681100636805964221e-01 -8.902585423162623357e-01 7.876125240246927284e-01 7.567737971546929510e-01 -8.872341531517662361e-01 7.784580066111700392e-01 7.454255275413548265e-01 -8.842515223931736168e-01 7.693214239645329577e-01 7.340672060990318659e-01 -8.813075692568397290e-01 7.602022354826803996e-01 7.227005864751234743e-01 -8.783989821496545058e-01 7.511000050313838550e-01 7.113277185683902770e-01 -8.755220238171187441e-01 7.420144833045193566e-01 6.999511354610528091e-01 -8.726749843514796101e-01 7.329446408023255755e-01 6.885716411869530207e-01 -8.698547215416584377e-01 7.238900130170270453e-01 6.771913952144653637e-01 -8.670596624933959440e-01 7.148495108503407636e-01 6.658111988100340328e-01 -8.642855405275950975e-01 7.058231520382152180e-01 6.544344321908397433e-01 -8.615312235931757989e-01 6.968096810882964398e-01 6.430616521710770250e-01 -8.587945613193220806e-01 6.878082471826545419e-01 6.316944172411573799e-01 -8.560737697641845889e-01 6.788178389092562881e-01 6.203340096274330140e-01 -8.533647514077651319e-01 6.698384520573987810e-01 6.089840337795546787e-01 -8.506671813652186831e-01 6.608684511065675560e-01 5.976445430267850467e-01 -8.479803760976425409e-01 6.519062997089123401e-01 5.863159553827915760e-01 -8.452992890124730874e-01 6.429524288345007665e-01 5.750030931030669645e-01 -8.426233261680482478e-01 6.340052727647743636e-01 5.637064935396088883e-01 -8.399526706457652869e-01 6.250628349958033958e-01 5.524259435430849408e-01 -8.372823606159069953e-01 6.161255232979981900e-01 5.411665126797099434e-01 -8.346115013722664733e-01 6.071918418882036317e-01 5.299292934604437066e-01 -8.319416971332159738e-01 5.982589838531851001e-01 5.187128588454869016e-01 -8.292658393187906096e-01 5.893284247613858051e-01 5.075248627530006829e-01 -8.265865191963318592e-01 5.803968068112989043e-01 4.963630791145096643e-01 -8.239007716165898110e-01 5.714634777707676694e-01 4.852311209906218226e-01 -8.212047236427109098e-01 5.625283035002011101e-01 4.741337367172645534e-01 -8.185028441784485409e-01 5.535866371885466153e-01 4.630669974760600605e-01 -8.157857974447502158e-01 5.446412013022012832e-01 4.520417208585162938e-01 -8.130598755024439628e-01 5.356861530869529986e-01 4.410523109242584505e-01 -8.103157295614864530e-01 5.267242547499885186e-01 4.301100025814295069e-01 -8.075600763067809496e-01 5.177491168092126506e-01 4.192090517728162546e-01 -8.047829983640772955e-01 5.087638530967844019e-01 4.083617627821872209e-01 -8.019913643823087801e-01 4.997616265469864705e-01 3.975626288212918968e-01 -7.991776069093209367e-01 4.907441098507538402e-01 3.868219510427612362e-01 -7.963412506983238437e-01 4.817086347924898759e-01 3.761426799347312722e-01 -7.934853391750592566e-01 4.726500967551418020e-01 3.655242898980974875e-01 -7.906020861628313412e-01 4.635701843716890092e-01 3.549783159786080722e-01 -7.876922078438237662e-01 4.544650164439674178e-01 3.445075235304189132e-01 -7.847584433242353885e-01 4.453290095612297272e-01 3.341130019968927001e-01 -7.817943763481589592e-01 4.361626378195018194e-01 3.238062118505327658e-01 -7.787986023472407426e-01 4.269628178617235204e-01 3.135938243777520174e-01 -7.757700306772615795e-01 4.177259860608659170e-01 3.034828822113839197e-01 -7.727073763310282617e-01 4.084484227667745659e-01 2.934814547614346680e-01 -7.696090956246998127e-01 3.991262801626034307e-01 2.835988305456279002e-01 -7.664733140591651894e-01 3.897556205902359405e-01 2.738457322824414675e-01 -7.632977462662783319e-01 3.803324674237734127e-01 2.642345539395078435e-01 -7.600796083228246180e-01 3.708528707479538111e-01 2.547796171102231777e-01 -7.568155232311498670e-01 3.613129902046505748e-01 2.454974414736316723e-01 -7.535014210471865370e-01 3.517091973617619272e-01 2.364070204678299647e-01 -7.501324359996863755e-01 3.420381997805444496e-01 2.275300884680255264e-01 -7.467083678923864820e-01 3.322917332197801166e-01 2.188868097223075626e-01 -7.432206214135255173e-01 3.224689513722865386e-01 2.105072965395320406e-01 -7.396626352495903056e-01 3.125667176366879740e-01 2.024226257801388651e-01 -7.360276592028781595e-01 3.025817058357924139e-01 1.946669682951213953e-01 -7.323075054306246168e-01 2.925115926125090304e-01 1.872788656593587786e-01 -7.284886793139783157e-01 2.823599622393618280e-01 1.803025816545419935e-01 -7.245597795551689257e-01 2.721283507524605572e-01 1.737830391183990686e-01 -7.205052554891407945e-01 2.618237699935750395e-01 1.677681078164939554e-01 -7.163077524522897255e-01 2.514568470079543427e-01 1.623050371038979034e-01 -7.119477511381474555e-01 2.410431671523047270e-01 1.574376915741905747e-01 -7.074046106878864038e-01 2.306029576903746436e-01 1.532027782639572566e-01 -7.026577763956233236e-01 2.201603247696940491e-01 1.496264194674281345e-01 -6.976856380676357272e-01 2.097462458983016809e-01 1.467193374830310926e-01 -6.924700993857928477e-01 1.993923480969033712e-01 1.444757571309586708e-01 -6.869956304794752056e-01 1.891326217641629281e-01 1.428720296451389260e-01 -6.812509389222788370e-01 1.790005719286615893e-01 1.418684919672574540e-01 -6.752290404511711586e-01 1.690283951735306323e-01 1.414126182563193168e-01 -6.689272347019628029e-01 1.592460113853382819e-01 1.414436246187784352e-01 -6.623462930327670417e-01 1.496814992323431404e-01 1.418966965532167945e-01 -6.554894621920681619e-01 1.403622590219790744e-01 1.427060758527507467e-01 -6.483618361407726960e-01 1.313154491044398742e-01 1.438093776439538507e-01 -6.409690900196458596e-01 1.225708994915949840e-01 1.451466621124405387e-01 -6.333171868548845840e-01 1.141616381299322275e-01 1.466635532234118466e-01 -6.254117682555888624e-01 1.061263207405454406e-01 1.483083323541042609e-01 -6.172580943089347461e-01 9.850955940169045522e-02 1.500342818055006577e-01 -6.088612137441752337e-01 9.136271116346880716e-02 1.517946748017894032e-01 -6.002260075568476294e-01 8.474268845605749390e-02 1.535471889644061949e-01 -5.913580665313180607e-01 7.870937974751122945e-02 1.552475962263118736e-01 -5.822640724597829553e-01 7.332110668924821106e-02 1.568528524628541587e-01 -5.729523242155735163e-01 6.862870182587510470e-02 1.583209522546889236e-01 -5.634337248699358147e-01 6.466696013382158825e-02 1.596097119552595534e-01 -5.537224099506778963e-01 6.144626935987178989e-02 1.606779590153868675e-01 -5.438351395676241928e-01 5.894914800814857886e-02 1.614895452047331870e-01 -5.337912133736735232e-01 5.712858102881844535e-02 1.620138116792186611e-01 -5.236119994512118403e-01 5.591095129374230172e-02 1.622265257547594042e-01 -5.133214710039554207e-01 5.519900277454217047e-02 1.621082697921440163e-01 -5.029415119053961547e-01 5.489268743951671026e-02 1.616521201270082198e-01 -4.924920560465744224e-01 5.489497800522934179e-02 1.608594568967110505e-01 -4.819970419875420631e-01 5.509874164212420766e-02 1.597294678457327477e-01 -4.714685312956432006e-01 5.543752958786138385e-02 1.582803570073196830e-01 -4.609298385556733768e-01 5.581817450175154821e-02 1.565161535498545142e-01 -4.503882306974699712e-01 5.620093240974462917e-02 1.544603609580012249e-01 -4.398550445667638309e-01 5.653967482715421822e-02 1.521296397207116124e-01 -4.293395854267749168e-01 5.679892905513854451e-02 1.495413040881575784e-01 -4.188488052114383020e-01 5.695351275720081374e-02 1.467131019928892832e-01 -4.083874753510262079e-01 5.698679735961746651e-02 1.436626150429021476e-01 -3.979584206972520133e-01 5.688899115379054960e-02 1.404067946849407167e-01 -3.875661805934746962e-01 5.664744510513378128e-02 1.369596232193354413e-01 -3.772162562473511671e-01 5.624858727791105101e-02 1.333332882463785507e-01 -3.669009710312429173e-01 5.571027577451325569e-02 1.295456315830630090e-01 -3.566289201162299305e-01 5.501236188184371184e-02 1.256041268313332904e-01 -3.463946141954395985e-01 5.416713051157899528e-02 1.215221064681567403e-01 -3.362018241761821069e-01 5.316577293008726418e-02 1.173074037138401304e-01 -3.260424402261492549e-01 5.202497987647033972e-02 1.129713889339670624e-01 -3.159278573165507087e-01 5.071934147936141973e-02 1.085175153831856448e-01 -3.058440467352613878e-01 4.927677960771512794e-02 1.039569210271578392e-01 -2.957906289005873823e-01 4.769542811326495796e-02 9.929501197500162357e-02 -2.857761694878986902e-01 4.595516903310007534e-02 9.453469664208309642e-02 -2.757883929056377248e-01 4.407729543414404955e-02 8.968329380554104779e-02 -2.658251433737037206e-01 4.206161274965801444e-02 8.474472186508703875e-02 -2.558840557281191197e-01 3.990046570244704105e-02 7.972236454569985031e-02 -2.459622220783502511e-01 3.762595141506584057e-02 7.461913567560218841e-02 -2.360563646646140490e-01 3.529747994604028744e-02 6.943744239412558139e-02 \ No newline at end of file diff --git a/act/plotting/common.py b/act/plotting/common.py index eea7cf3e32..e258e9da39 100644 --- a/act/plotting/common.py +++ b/act/plotting/common.py @@ -1,7 +1,4 @@ """ -act.plotting.common -------------------- - Functions common between plotting modules. """ diff --git a/act/plotting/ContourDisplay.py b/act/plotting/contourdisplay.py similarity index 75% rename from act/plotting/ContourDisplay.py rename to act/plotting/contourdisplay.py index 6392b729da..cbfe7ef69d 100644 --- a/act/plotting/ContourDisplay.py +++ b/act/plotting/contourdisplay.py @@ -1,13 +1,10 @@ """ -act.plotting.ContourDisplay ---------------------------- - Stores the class for ContourDisplay. """ -from scipy.interpolate import Rbf import numpy as np +from scipy.interpolate import Rbf # Import Local Libs from .plot import Display @@ -20,13 +17,22 @@ class ContourDisplay(Display): contains all of Display's attributes and methods. """ - def __init__(self, obj, subplot_shape=(1,), ds_name=None, **kwargs): - super().__init__(obj, subplot_shape, ds_name, **kwargs) - def create_contour(self, fields=None, time=None, function='cubic', - subplot_index=(0,), contour='contourf', - grid_delta=(0.01, 0.01), grid_buffer=0.1, - twod_dim_value=None, **kwargs): + def __init__(self, ds, subplot_shape=(1,), ds_name=None, **kwargs): + super().__init__(ds, subplot_shape, ds_name, **kwargs) + + def create_contour( + self, + fields=None, + time=None, + function='cubic', + subplot_index=(0,), + contour='contourf', + grid_delta=(0.01, 0.01), + grid_buffer=0.1, + twod_dim_value=None, + **kwargs, + ): """ Extracts, grids, and creates a contour plot. If subplots have not been added yet, an axis will be created assuming that there is only going @@ -37,7 +43,7 @@ def create_contour(self, fields=None, time=None, function='cubic', fields : dict Dictionary of fields to use for x, y, and z data. time : datetime - Time in which to slice through objects. + Time in which to slice through the datasets. function : string Defaults to cubic function for interpolation. See scipy.interpolate.Rbf for additional options. @@ -68,36 +74,36 @@ def create_contour(self, fields=None, time=None, function='cubic', x = [] y = [] z = [] - for ds in self._arm: - obj = self._arm[ds] - if ds not in fields: + for dsname in self._ds: + ds = self._ds[dsname] + if dsname not in fields: continue - field = fields[ds] - if obj[field[2]].sel(time=time).values.size > 1: - dim_values = obj[obj[field[2]].dims[1]].values + field = fields[dsname] + if ds[field[2]].sel(time=time).values.size > 1: + dim_values = ds[ds[field[2]].dims[1]].values if twod_dim_value is None: dim_index = 0 else: - dim_index = np.where((dim_values == twod_dim_value)) + dim_index = np.where(dim_values == twod_dim_value) if dim_index[0].size == 0: continue - if np.isnan(obj[field[2]].sel(time=time).values[dim_index]): + if np.isnan(ds[field[2]].sel(time=time).values[dim_index]): continue - z.append(obj[field[2]].sel(time=time).values[dim_index].tolist()) + z.append(ds[field[2]].sel(time=time).values[dim_index].tolist()) else: - if np.isnan(obj[field[2]].sel(time=time).values): + if np.isnan(ds[field[2]].sel(time=time).values): continue - z.append(obj[field[2]].sel(time=time).values.tolist()) + z.append(ds[field[2]].sel(time=time).values.tolist()) - if obj[field[0]].values.size > 1: - x.append(obj[field[0]].sel(time=time).values.tolist()) + if ds[field[0]].values.size > 1: + x.append(ds[field[0]].sel(time=time).values.tolist()) else: - x.append(obj[field[0]].values.tolist()) + x.append(ds[field[0]].values.tolist()) - if obj[field[1]].values.size > 1: - y.append(obj[field[1]].sel(time=time).values.tolist()) + if ds[field[1]].values.size > 1: + y.append(ds[field[1]].sel(time=time).values.tolist()) else: - y.append(obj[field[1]].values.tolist()) + y.append(ds[field[1]].values.tolist()) # Create a meshgrid for gridding onto xs = np.arange(np.min(x) - grid_buffer, np.max(x) + grid_buffer, grid_delta[0]) @@ -115,7 +121,8 @@ def create_contour(self, fields=None, time=None, function='cubic', self.contourf(xi, yi, zi, subplot_index=subplot_index, **kwargs) else: raise ValueError( - "Invalid contour plot type. Please choose either 'contourf' or 'contour'") + "Invalid contour plot type. Please choose either 'contourf' or 'contour'" + ) return self.axes[subplot_index] @@ -177,10 +184,17 @@ def contour(self, x, y, z, subplot_index=(0,), **kwargs): return self.axes[subplot_index] - def plot_vectors_from_spd_dir(self, fields, time=None, subplot_index=(0,), - mesh=False, function='cubic', - grid_delta=(0.01, 0.01), - grid_buffer=0.1, **kwargs): + def plot_vectors_from_spd_dir( + self, + fields, + time=None, + subplot_index=(0,), + mesh=False, + function='cubic', + grid_delta=(0.01, 0.01), + grid_buffer=0.1, + **kwargs, + ): """ Extracts, grids, and creates a contour plot. If subplots have not been added yet, an axis will be created @@ -191,7 +205,7 @@ def plot_vectors_from_spd_dir(self, fields, time=None, subplot_index=(0,), fields : dict Dictionary of fields to use for x, y, and z data. time : datetime - Time in which to slice through objects. + Time in which to slice through datasets. mesh : boolean Set to True to interpolate u and v to grid and create wind barbs. function : string @@ -216,20 +230,20 @@ def plot_vectors_from_spd_dir(self, fields, time=None, subplot_index=(0,), y = [] wspd = [] wdir = [] - for ds in self._arm: - obj = self._arm[ds] - field = fields[ds] - if obj[field[0]].values.size > 1: - x.append(obj[field[0]].sel(time=time).values.tolist()) + for dsname in self._ds: + ds = self._ds[dsname] + field = fields[dsname] + if ds[field[0]].values.size > 1: + x.append(ds[field[0]].sel(time=time).values.tolist()) else: - x.append(obj[field[0]].values.tolist()) + x.append(ds[field[0]].values.tolist()) - if obj[field[1]].values.size > 1: - y.append(obj[field[1]].sel(time=time).values.tolist()) + if ds[field[1]].values.size > 1: + y.append(ds[field[1]].sel(time=time).values.tolist()) else: - y.append(obj[field[1]].values.tolist()) - wspd.append(obj[field[2]].sel(time=time).values.tolist()) - wdir.append(obj[field[3]].sel(time=time).values.tolist()) + y.append(ds[field[1]].values.tolist()) + wspd.append(ds[field[2]].sel(time=time).values.tolist()) + wdir.append(ds[field[3]].sel(time=time).values.tolist()) # Calculate u and v tempu = -np.sin(np.deg2rad(wdir)) * wspd @@ -288,8 +302,7 @@ def barbs(self, x, y, u, v, subplot_index=(0,), **kwargs): return self.axes[subplot_index] - def plot_station(self, fields, time=None, subplot_index=(0,), - text_color='white', **kwargs): + def plot_station(self, fields, time=None, subplot_index=(0,), text_color='white', **kwargs): """ Extracts, grids, and creates a contour plot. If subplots have not been added yet, an axis will be created assuming that there is only @@ -300,7 +313,7 @@ def plot_station(self, fields, time=None, subplot_index=(0,), fields : dict Dictionary of fields to use for x, y, and z data. time : datetime - Time in which to slice through objects. + Time in which to slice through datasets. subplot_index : 1 or 2D tuple, list, or array The index of the subplot to set the x range of. text_color : string @@ -316,36 +329,36 @@ def plot_station(self, fields, time=None, subplot_index=(0,), """ # Get x, y, and data by looping through each dictionary # item and extracting data from appropriate time - for ds in self._arm: - obj = self._arm[ds] - field = fields[ds] + for dsname in self._ds: + ds = self._ds[dsname] + field = fields[dsname] for i, f in enumerate(field): if i == 0: - if obj[f].values.size > 1: - x = obj[f].sel(time=time).values.tolist() + if ds[f].values.size > 1: + x = ds[f].sel(time=time).values.tolist() else: - x = obj[f].values.tolist() + x = ds[f].values.tolist() elif i == 1: - if obj[f].values.size > 1: - y = obj[f].sel(time=time).values.tolist() + if ds[f].values.size > 1: + y = ds[f].sel(time=time).values.tolist() else: - y = obj[f].values.tolist() + y = ds[f].values.tolist() self.axes[subplot_index].plot(x, y, '*', **kwargs) else: - data = obj[f].sel(time=time).values.tolist() + data = ds[f].sel(time=time).values.tolist() offset = 0.02 if i == 2: - x1 = x - 3. * offset + x1 = x - 3.0 * offset y1 = y + offset if i == 3: x1 = x + offset y1 = y + offset if i == 4: x1 = x + offset - y1 = y - 2. * offset + y1 = y - 2.0 * offset if i == 5: - x1 = x - 3. * offset - y1 = y - 2. * offset + x1 = x - 3.0 * offset + y1 = y - 2.0 * offset if data < 5: string = str(round(data, 1)) else: diff --git a/act/plotting/distributiondisplay.py b/act/plotting/distributiondisplay.py new file mode 100644 index 0000000000..0dec535c43 --- /dev/null +++ b/act/plotting/distributiondisplay.py @@ -0,0 +1,857 @@ +""" Module for Distribution Plotting. """ + +import matplotlib.pyplot as plt +import numpy as np +import xarray as xr +import pandas as pd + +from ..utils import datetime_utils as dt_utils +from .plot import Display + + +class DistributionDisplay(Display): + """ + This class is used to make distribution related plots. It is inherited from Display + and therefore contains all of Display's attributes and methods. + + Examples + -------- + To create a DistributionDisplay with 3 rows, simply do: + + .. code-block:: python + + ds = act.io.read_arm_netcdf(the_file) + disp = act.plotting.DistsributionDisplay(ds, subplot_shape=(3,), figsize=(15, 5)) + + The DistributionDisplay constructor takes in the same keyword arguments as + plt.subplots. For more information on the plt.subplots keyword arguments, + see the `matplotlib documentation + `_. + If no subplot_shape is provided, then no figure or axis will be created + until add_subplots or plots is called. + + """ + + def __init__(self, ds, subplot_shape=(1,), ds_name=None, **kwargs): + super().__init__(ds, subplot_shape, ds_name, **kwargs) + + def set_xrng(self, xrng, subplot_index=(0,)): + """ + Sets the x range of the plot. + + Parameters + ---------- + xrng : 2 number array + The x limits of the plot. + subplot_index : 1 or 2D tuple, list, or array + The index of the subplot to set the x range of. + + """ + if self.axes is None: + raise RuntimeError('set_xrng requires the plot to be displayed.') + + if not hasattr(self, 'xrng') and len(self.axes.shape) == 2: + self.xrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2), dtype='datetime64[D]') + elif not hasattr(self, 'xrng') and len(self.axes.shape) == 1: + self.xrng = np.zeros((self.axes.shape[0], 2), dtype='datetime64[D]') + + self.axes[subplot_index].set_xlim(xrng) + self.xrng[subplot_index, :] = np.array(xrng) + + def set_yrng(self, yrng, subplot_index=(0,)): + """ + Sets the y range of the plot. + + Parameters + ---------- + yrng : 2 number array + The y limits of the plot. + subplot_index : 1 or 2D tuple, list, or array + The index of the subplot to set the x range of. + + """ + if self.axes is None: + raise RuntimeError('set_yrng requires the plot to be displayed.') + + if not hasattr(self, 'yrng') and len(self.axes.shape) == 2: + self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) + elif not hasattr(self, 'yrng') and len(self.axes.shape) == 1: + self.yrng = np.zeros((self.axes.shape[0], 2)) + + if yrng[0] == yrng[1]: + yrng[1] = yrng[1] + 1 + + self.axes[subplot_index].set_ylim(yrng) + self.yrng[subplot_index, :] = yrng + + def _get_data(self, dsname, fields): + if isinstance(fields, str): + fields = [fields] + return self._ds[dsname][fields].dropna('time') + + def plot_stacked_bar( + self, + field, + dsname=None, + bins=10, + sortby_field=None, + sortby_bins=None, + subplot_index=(0,), + set_title=None, + density=False, + hist_kwargs=dict(), + **kwargs, + ): + """ + This procedure will plot a stacked bar graph of a histogram. + + Parameters + ---------- + field : str + The name of the field to take the histogram of. + dsname : str or None + The name of the datastream the field is contained in. Set + to None to let ACT automatically determine this. + bins : array-like or int + The histogram bin boundaries to use. If not specified, numpy's + default 10 is used. + sortby_field : str or None + Set this option to a field name in order to sort the histograms + by a given field parameter. For example, one can sort histograms of CO2 + concentration by temperature. + sortby_bins : array-like or None + The bins to sort the histograms by. + subplot_index : tuple + The subplot index to place the plot in + set_title : str + The title of the plot. + density : bool + Set to True to plot a p.d.f. instead of a frequency histogram. + hist_kwargs : dict + Additional keyword arguments to pass to numpy histogram. + + Other keyword arguments will be passed into :func:`matplotlib.pyplot.bar`. + + Returns + ------- + return_dict : dict + A dictionary containing the plot axis handle, bin boundaries, and + generated histogram. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + + 'or more datasets in the TimeSeriesDisplay ' + + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + if sortby_field is not None: + ds = self._get_data(dsname, [field, sortby_field]) + xdata, ydata = ds[field], ds[sortby_field] + else: + xdata = self._get_data(dsname, field)[field] + + if 'units' in xdata.attrs: + xtitle = ''.join(['(', xdata.attrs['units'], ')']) + else: + xtitle = field + + if sortby_bins is None and sortby_field is not None: + # We will defaut the y direction to have the same # of bins as x + if isinstance(bins, int): + n_bins = bins + else: + n_bins = len(bins) + sortby_bins = np.linspace(ydata.values.min(), ydata.values.max(), n_bins) + + # Get the current plotting axis + if self.fig is None: + self.fig = plt.figure() + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + if sortby_field is not None: + if 'units' in ydata.attrs: + ytitle = ''.join(['(', ydata.attrs['units'], ')']) + else: + ytitle = field + my_hist, x_bins, y_bins = np.histogram2d( + xdata.values.flatten(), + ydata.values.flatten(), + density=density, + bins=[bins, sortby_bins], + **hist_kwargs) + x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 + self.axes[subplot_index].bar( + x_inds, + my_hist[:, 0].flatten(), + label=(str(y_bins[0]) + ' to ' + str(y_bins[1])), + **kwargs, + ) + for i in range(1, len(y_bins) - 1): + self.axes[subplot_index].bar( + x_inds, + my_hist[:, i].flatten(), + bottom=my_hist[:, i - 1], + label=(str(y_bins[i]) + ' to ' + str(y_bins[i + 1])), + **kwargs, + ) + self.axes[subplot_index].legend() + else: + my_hist, bins = np.histogram(xdata.values.flatten(), bins=bins, + density=density, **hist_kwargs) + x_inds = (bins[:-1] + bins[1:]) / 2.0 + self.axes[subplot_index].bar(x_inds, my_hist) + + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + field, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + self.axes[subplot_index].set_title(set_title) + self.axes[subplot_index].set_ylabel('count') + self.axes[subplot_index].set_xlabel(xtitle) + + return_dict = {} + return_dict['plot_handle'] = self.axes[subplot_index] + if 'x_bins' in locals(): + return_dict['x_bins'] = x_bins + return_dict['y_bins'] = y_bins + else: + return_dict['bins'] = bins + return_dict['histogram'] = my_hist + + return return_dict + + def plot_size_distribution( + self, field, bins, time=None, dsname=None, subplot_index=(0,), set_title=None, **kwargs + ): + """ + This procedure plots a stairstep plot of a size distribution. This is + useful for plotting size distributions and waveforms. + + Parameters + ---------- + field : str + The name of the field to plot the spectrum from. + bins : str or array-like + The name of the field that stores the bins for the spectra. + time : none or datetime + If None, spectra to plot will be automatically determined. + Otherwise, specify this field for the time period to plot. + dsname : str + The name of the Dataset to plot. Set to None to have + ACT automatically determine this. + subplot_index : tuple + The subplot index to place the plot in. + set_title : str or None + Use this to set the title. + + Additional keyword arguments will be passed into :func:`matplotlib.pyplot.step` + + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle referring to the plot. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + + 'or more datasets in the TimeSeriesDisplay ' + + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + xdata = self._get_data(dsname, field)[field] + + if isinstance(bins, str): + bins = self._ds[dsname][bins] + else: + bins = xr.DataArray(bins) + + if 'units' in bins.attrs: + xtitle = ''.join(['(', bins.attrs['units'], ')']) + else: + xtitle = 'Bin #' + + if 'units' in xdata.attrs: + ytitle = ''.join(['(', xdata.attrs['units'], ')']) + else: + ytitle = field + + if len(xdata.dims) > 1 and time is None: + raise ValueError( + 'Input data has more than one dimension, ' + 'you must specify a time to plot!' + ) + elif len(xdata.dims) > 1: + xdata = xdata.sel(time=time, method='nearest') + + if len(bins.dims) > 1 or len(bins.values) != len(xdata.values): + raise ValueError( + 'Bins must be a one dimensional field whose ' + + 'length is equal to the field length!' + ) + + # Get the current plotting axis + if self.fig is None: + self.fig = plt.figure() + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + field, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + if time is not None: + t = pd.Timestamp(time) + set_title += ''.join([' at ', ':'.join([str(t.hour), str(t.minute), str(t.second)])]) + self.axes[subplot_index].set_title(set_title) + self.axes[subplot_index].step(bins.values, xdata.values, **kwargs) + self.axes[subplot_index].set_xlabel(xtitle) + self.axes[subplot_index].set_ylabel(ytitle) + + return self.axes[subplot_index] + + def plot_stairstep( + self, + field, + dsname=None, + bins=10, + sortby_field=None, + sortby_bins=None, + subplot_index=(0,), + set_title=None, + density=False, + hist_kwargs=dict(), + **kwargs, + ): + """ + This procedure will plot a stairstep plot of a histogram. + + Parameters + ---------- + field : str + The name of the field to take the histogram of. + dsname : str or None + The name of the datastream the field is contained in. Set + to None to let ACT automatically determine this. + bins : array-like or int + The histogram bin boundaries to use. If not specified, numpy's + default 10 is used. + sortby_field : str or None + Set this option to a field name in order to sort the histograms + by a given field parameter. For example, one can sort histograms of CO2 + concentration by temperature. + sortby_bins : array-like or None + The bins to sort the histograms by. + subplot_index : tuple + The subplot index to place the plot in. + set_title : str + The title of the plot. + density : bool + Set to True to plot a p.d.f. instead of a frequency histogram. + hist_kwargs : dict + Additional keyword arguments to pass to numpy histogram. + + Other keyword arguments will be passed into :func:`matplotlib.pyplot.step`. + + Returns + ------- + return_dict : dict + A dictionary containing the plot axis handle, bin boundaries, and + generated histogram. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + + 'or more datasets in the TimeSeriesDisplay ' + + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + xdata = self._get_data(dsname, field)[field] + + if 'units' in xdata.attrs: + xtitle = ''.join(['(', xdata.attrs['units'], ')']) + else: + xtitle = field + + if sortby_field is not None: + ydata = self._ds[dsname][sortby_field] + + if sortby_bins is None and sortby_field is not None: + if isinstance(bins, int): + n_bins = bins + else: + n_bins = len(bins) + # We will defaut the y direction to have the same # of bins as x + sortby_bins = np.linspace(ydata.values.min(), ydata.values.max(), n_bins) + + # Get the current plotting axis, add day/night background and plot data + if self.fig is None: + self.fig = plt.figure() + + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + if sortby_field is not None: + if 'units' in ydata.attrs: + ytitle = ''.join(['(', ydata.attrs['units'], ')']) + else: + ytitle = field + my_hist, x_bins, y_bins = np.histogram2d( + xdata.values.flatten(), + ydata.values.flatten(), + density=density, + bins=[bins, sortby_bins], + **hist_kwargs + ) + x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 + self.axes[subplot_index].step( + x_inds, + my_hist[:, 0].flatten(), + label=(str(y_bins[0]) + ' to ' + str(y_bins[1])), + **kwargs, + ) + for i in range(1, len(y_bins) - 1): + self.axes[subplot_index].step( + x_inds, + my_hist[:, i].flatten(), + label=(str(y_bins[i]) + ' to ' + str(y_bins[i + 1])), + **kwargs, + ) + self.axes[subplot_index].legend() + else: + my_hist, bins = np.histogram(xdata.values.flatten(), bins=bins, + density=density, **hist_kwargs) + + x_inds = (bins[:-1] + bins[1:]) / 2.0 + self.axes[subplot_index].step(x_inds, my_hist, **kwargs) + + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + field, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + self.axes[subplot_index].set_title(set_title) + self.axes[subplot_index].set_ylabel('count') + self.axes[subplot_index].set_xlabel(xtitle) + + return_dict = {} + return_dict['plot_handle'] = self.axes[subplot_index] + if 'x_bins' in locals(): + return_dict['x_bins'] = x_bins + return_dict['y_bins'] = y_bins + else: + return_dict['bins'] = bins + return_dict['histogram'] = my_hist + + return return_dict + + def plot_heatmap( + self, + x_field, + y_field, + dsname=None, + x_bins=None, + y_bins=None, + subplot_index=(0,), + set_title=None, + density=False, + set_shading='auto', + hist_kwargs=dict(), + threshold=None, + **kwargs, + ): + """ + This procedure will plot a heatmap of a histogram from 2 variables. + + Parameters + ---------- + x_field : str + The name of the field to take the histogram of on the X axis. + y_field : str + The name of the field to take the histogram of on the Y axis. + dsname : str or None + The name of the datastream the field is contained in. Set + to None to let ACT automatically determine this. + x_bins : array-like, int, or None + The histogram bin boundaries to use for the variable on the X axis. + Set to None to use numpy's default boundaries. + If an int, will indicate the number of bins to use + y_bins : array-like, int, or None + The histogram bin boundaries to use for the variable on the Y axis. + Set to None to use numpy's default boundaries. + If an int, will indicate the number of bins to use + subplot_index : tuple + The subplot index to place the plot in + set_title : str + The title of the plot. + density : bool + Set to True to plot a p.d.f. instead of a frequency histogram. + set_shading : string + Option to to set the matplotlib.pcolormesh shading parameter. + Default to 'auto' + threshold : float + Value on which to threshold the histogram results for plotting. + Setting to 0 will ensure that all 0 values are removed from the plot + making it easier to distringuish between 0 and low values + hist_kwargs : Additional keyword arguments to pass to numpy histogram. + + Other keyword arguments will be passed into :func:`matplotlib.pyplot.pcolormesh`. + + Returns + ------- + return_dict : dict + A dictionary containing the plot axis handle, bin boundaries, and + generated histogram. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + ds = self._get_data(dsname, [x_field, y_field]) + xdata, ydata = ds[x_field], ds[y_field] + + if 'units' in xdata.attrs: + xtitle = ''.join(['(', xdata.attrs['units'], ')']) + else: + xtitle = x_field + + if x_bins is not None and isinstance(x_bins, int): + x_bins = np.linspace(xdata.values.min(), xdata.values.max(), x_bins) + + if y_bins is not None and isinstance(x_bins, int): + y_bins = np.linspace(ydata.values.min(), ydata.values.max(), y_bins) + + if x_bins is not None and y_bins is None: + # We will defaut the y direction to have the same # of bins as x + y_bins = np.linspace(ydata.values.min(), ydata.values.max(), len(x_bins)) + + # Get the current plotting axis, add day/night background and plot data + if self.fig is None: + self.fig = plt.figure() + + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + if 'units' in ydata.attrs: + ytitle = ''.join(['(', ydata.attrs['units'], ')']) + else: + ytitle = y_field + + if x_bins is None: + my_hist, x_bins, y_bins = np.histogram2d( + xdata.values.flatten(), ydata.values.flatten(), density=density, + **hist_kwargs) + else: + my_hist, x_bins, y_bins = np.histogram2d( + xdata.values.flatten(), + ydata.values.flatten(), + density=density, + bins=[x_bins, y_bins], + **hist_kwargs + ) + # Adding in the ability to threshold the heatmaps + if threshold is not None: + my_hist[my_hist <= threshold] = np.nan + + x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 + y_inds = (y_bins[:-1] + y_bins[1:]) / 2.0 + xi, yi = np.meshgrid(x_inds, y_inds, indexing='ij') + mesh = self.axes[subplot_index].pcolormesh(xi, yi, my_hist, shading=set_shading, **kwargs) + + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + self.axes[subplot_index].set_title(set_title) + self.axes[subplot_index].set_ylabel(ytitle) + self.axes[subplot_index].set_xlabel(xtitle) + self.add_colorbar(mesh, title='count', subplot_index=subplot_index) + + return_dict = {} + return_dict['plot_handle'] = self.axes[subplot_index] + return_dict['x_bins'] = x_bins + return_dict['y_bins'] = y_bins + return_dict['histogram'] = my_hist + + return return_dict + + def set_ratio_line(self, subplot_index=(0, )): + """ + Sets the 1:1 ratio line. + + Parameters + ---------- + subplot_index : 1 or 2D tuple, list, or array + The index of the subplot to set the x range of. + + """ + if self.axes is None: + raise RuntimeError('set_ratio_line requires the plot to be displayed.') + # Define the xticks of the figure + xlims = self.axes[subplot_index].get_xticks() + ratio = np.linspace(xlims, xlims[-1]) + self.axes[subplot_index].plot(ratio, ratio, 'k--') + + def plot_scatter(self, + x_field, + y_field, + m_field=None, + dsname=None, + cbar_label=None, + set_title=None, + subplot_index=(0,), + **kwargs, + ): + """ + This procedure will produce a scatter plot from 2 variables. + + Parameters + ---------- + x_field : str + The name of the field to display on the X axis. + y_field : str + The name of the field to display on the Y axis. + m_field : str + The name of the field to display on the markers. + cbar_label : str + The desired name to plot for the colorbar + set_title : str + The desired title for the plot. + Default title is created from the datastream. + dsname : str or None + The name of the datastream the field is contained in. Set + to None to let ACT automatically determine this. + subplot_index : tuple + The subplot index to place the plot in + + Other keyword arguments will be passed into :func:`matplotlib.pyplot.scatter`. + + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle of the plot + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + if m_field is None: + mdata = None + ds = self._get_data(dsname, [x_field, y_field]) + xdata, ydata = ds[x_field], ds[y_field] + else: + ds = self._get_data(dsname, [x_field, y_field, m_field]) + xdata, ydata, mdata = ds[x_field], ds[y_field], ds[m_field] + + # Define the x-axis label. If units are avaiable, plot. + if 'units' in xdata.attrs: + xtitle = x_field + ''.join([' (', xdata.attrs['units'], ')']) + else: + xtitle = x_field + + # Define the y-axis label. If units are available, plot + if 'units' in ydata.attrs: + ytitle = y_field + ''.join([' (', ydata.attrs['units'], ')']) + else: + ytitle = y_field + + # Get the current plotting axis, add day/night background and plot data + if self.fig is None: + self.fig = plt.figure() + + # Define the axes for the figure + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + # Display the scatter plot, pass keyword args for unspecified attributes + scc = self.axes[subplot_index].scatter(xdata, ydata, c=mdata, **kwargs) + + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + + # Check to see if a colorbar label was set + if mdata is not None: + if cbar_label is None: + # Define the y-axis label. If units are available, plot + if 'units' in mdata.attrs: + ztitle = m_field + ''.join([' (', mdata.attrs['units'], ')']) + else: + ztitle = m_field + else: + ztitle = cbar_label + # Plot the colorbar + cbar = plt.colorbar(scc) + cbar.ax.set_ylabel(ztitle) + + # Define the axe title, x-axis label, y-axis label + self.axes[subplot_index].set_title(set_title) + self.axes[subplot_index].set_ylabel(ytitle) + self.axes[subplot_index].set_xlabel(xtitle) + + return self.axes[subplot_index] + + def plot_violin(self, + field, + positions=None, + dsname=None, + vert=True, + showmeans=True, + showmedians=True, + showextrema=True, + subplot_index=(0,), + set_title=None, + **kwargs, + ): + """ + This procedure will produce a violin plot for the selected + field (or fields). + + Parameters + ---------- + field : str or list + The name of the field (or fields) to display on the X axis. + positions : array-like, Default: None + The positions of the ticks along dependent axis. + dsname : str or None + The name of the datastream the field is contained in. Set + to None to let ACT automatically determine this. + vert : Boolean, Default: True + Display violin plot vertical. False will display horizontal. + showmeans : Boolean; Default: False + If True, will display the mean of the datastream. + showmedians : Boolean; Default: False + If True, will display the medium of the datastream. + showextrema: Boolean; Default: False + If True, will display the extremes of the datastream. + subplot_index : tuple + The subplot index to place the plot in + set_title : str + The title of the plot. + + Other keyword arguments will be passed into :func:`matplotlib.pyplot.violinplot`. + + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle of the plot + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + if dsname is None: + dsname = list(self._ds.keys())[0] + + ds = self._get_data(dsname, field) + ndata = ds[field] + + # Get the current plotting axis, add day/night background and plot data + if self.fig is None: + self.fig = plt.figure() + + # Define the axes for the figure + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + # Define the axe label. If units are avaiable, plot. + if 'units' in ndata.attrs: + axtitle = field + ''.join([' (', ndata.attrs['units'], ')']) + else: + axtitle = field + + # Display the scatter plot, pass keyword args for unspecified attributes + scc = self.axes[subplot_index].violinplot(ndata, + positions=positions, + vert=vert, + showmeans=showmeans, + showmedians=showmedians, + showextrema=showextrema, + **kwargs + ) + if showmeans is True: + scc['cmeans'].set_edgecolor('red') + scc['cmeans'].set_label('mean') + if showmedians is True: + scc['cmedians'].set_edgecolor('black') + scc['cmedians'].set_label('median') + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + + # Define the axe title, x-axis label, y-axis label + self.axes[subplot_index].set_title(set_title) + if vert is True: + self.axes[subplot_index].set_ylabel(axtitle) + if positions is None: + self.axes[subplot_index].set_xticks([]) + else: + self.axes[subplot_index].set_xlabel(axtitle) + if positions is None: + self.axes[subplot_index].set_yticks([]) + + return self.axes[subplot_index] diff --git a/act/plotting/GeoDisplay.py b/act/plotting/geodisplay.py similarity index 55% rename from act/plotting/GeoDisplay.py rename to act/plotting/geodisplay.py index 72b016bcc9..b01d425b43 100644 --- a/act/plotting/GeoDisplay.py +++ b/act/plotting/geodisplay.py @@ -1,20 +1,22 @@ """ -act.plotting.GeoDisplay ------------------------ - Stores the class for GeographicPlotDisplay. """ +import warnings + +import matplotlib import matplotlib.pyplot as plt import numpy as np import pandas as pd from .plot import Display + try: import cartopy.crs as ccrs - from cartopy.io.img_tiles import Stamen import cartopy.feature as cfeature + from cartopy.io import img_tiles + CARTOPY_AVAILABLE = True except ImportError: CARTOPY_AVAILABLE = False @@ -23,7 +25,7 @@ class GeographicPlotDisplay(Display): """ A class for making geographic tracer plot of aircraft, ship or other moving - platform plot.. + platform plot. This is inherited from the :func:`act.plotting.Display` class and has therefore has the same attributes as that class. @@ -36,21 +38,37 @@ class and has therefore has the same attributes as that class. Cartopy go here:https://scitools.org.uk/cartopy/docs/latest/ . """ - def __init__(self, obj, ds_name=None, **kwargs): + + def __init__(self, ds, ds_name=None, **kwargs): if not CARTOPY_AVAILABLE: - raise ImportError("Cartopy needs to be installed on your " - "system to make geographic display plots.") - super().__init__(obj, ds_name, **kwargs) + raise ImportError( + 'Cartopy needs to be installed on your ' 'system to make geographic display plots.' + ) + super().__init__(ds, ds_name, **kwargs) if self.fig is None: self.fig = plt.figure(**kwargs) - def geoplot(self, data_field=None, lat_field='lat', - lon_field='lon', dsname=None, cbar_label=None, title=None, - projection=None, plot_buffer=0.08, - stamen='terrain-background', tile=8, cartopy_feature=None, - cmap='rainbow', text=None, gridlines=True, **kwargs): + def geoplot( + self, + data_field=None, + lat_field='lat', + lon_field='lon', + dsname=None, + cbar_label=None, + title=None, + projection=None, + plot_buffer=0.08, + img_tile=None, + img_tile_args={}, + tile=8, + cartopy_feature=None, + cmap='rainbow', + text=None, + gridlines=True, + **kwargs, + ): """ - Creates a latttude and longitude plot of a time series data set with + Creates a latitude and longitude plot of a time series data set with data values indicated by color and described with a colorbar. Latitude values must be in degree north (-90 to 90) and longitude must be in degree east (-180 to 180). @@ -58,11 +76,11 @@ def geoplot(self, data_field=None, lat_field='lat', Parameters ---------- data_field : str - Name of data filed in object to plot. + Name of data field in the dataset to plot. lat_field : str - Name of latitude field in object to use. + Name of latitude field in the dataset to use. lon_field : str - Name of longitude field in object to use. + Name of longitude field in the dataset to use. dsname : str or None The name of the datastream to plot. Set to None to make ACT attempt to automatically determine this. @@ -73,14 +91,21 @@ def geoplot(self, data_field=None, lat_field='lat', Plot title. projection : cartopy.crs object Project to use on plot. See - https://scitools.org.uk/cartopy/docs/latest/crs/projections.html + https://scitools.org.uk/cartopy/docs/latest/reference/projections.html?highlight=projections plot_buffer : float Buffer to add around data on plot in lat and lon dimension. - stamen : str - Dataset to use for background image. Set to None to not use - background image. + img_tile : str + Image to use for the plot background. Set to None to not use + background image. For all image background types, see: + https://scitools.org.uk/cartopy/docs/v0.16/cartopy/io/img_tiles.html + Default is None. + img_tile_args : dict + Keyword arguments for the chosen img_tile. These arguments can be + found for the corresponding img_tile here: + https://scitools.org.uk/cartopy/docs/v0.16/cartopy/io/img_tiles.html + Default is an empty dictionary. tile : int - Tile zoom to use with background image. Higer number indicates + Tile zoom to use with background image. Higher number indicates more resolution. A value of 8 is typical for a normal sonde plot. cartopy_feature : list of str or str Cartopy feature to add to plot. @@ -98,70 +123,84 @@ def geoplot(self, data_field=None, lat_field='lat', on what keyword arguments are available. """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the GeographicPlotDisplay " - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the GeographicPlotDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] if data_field is None: - raise ValueError(("You must enter the name of the data " - "to be plotted.")) + raise ValueError('You must enter the name of the data ' 'to be plotted.') if projection is None: if CARTOPY_AVAILABLE: projection = ccrs.PlateCarree() - # Extract data from object + # Extract data from the dataset try: - lat = self._arm[dsname][lat_field].values + lat = self._ds[dsname][lat_field].values except KeyError: - raise ValueError(("You will need to provide the name of the " - "field if not '{}' to use for latitued " - "data.").format(lat_field)) + raise ValueError( + ( + 'You will need to provide the name of the ' + "field if not '{}' to use for latitude " + 'data.' + ).format(lat_field) + ) try: - lon = self._arm[dsname][lon_field].values + lon = self._ds[dsname][lon_field].values except KeyError: - raise ValueError(("You will need to provide the name of the " - "field if not '{}' to use for longitude " - "data.").format(lon_field)) + raise ValueError( + ( + 'You will need to provide the name of the ' + "field if not '{}' to use for longitude " + 'data.' + ).format(lon_field) + ) # Set up metadata information for display on plot if cbar_label is None: try: cbar_label = ( - self._arm[dsname][data_field].attrs['long_name'] + - ' (' + self._arm[dsname][data_field].attrs['units'] + ')') + self._ds[dsname][data_field].attrs['long_name'] + + ' (' + + self._ds[dsname][data_field].attrs['units'] + + ')' + ) except KeyError: cbar_label = data_field lat_limits = [np.nanmin(lat), np.nanmax(lat)] lon_limits = [np.nanmin(lon), np.nanmax(lon)] - box_size = np.max([np.abs(np.diff(lat_limits)), - np.abs(np.diff(lon_limits))]) + box_size = np.max([np.abs(np.diff(lat_limits)), np.abs(np.diff(lon_limits))]) bx_buf = box_size * plot_buffer - lat_center = np.sum(lat_limits) / 2. - lon_center = np.sum(lon_limits) / 2. + lat_center = np.sum(lat_limits) / 2.0 + lon_center = np.sum(lon_limits) / 2.0 - lat_limits = [lat_center - box_size / 2. - bx_buf, - lat_center + box_size / 2. + bx_buf] - lon_limits = [lon_center - box_size / 2. - bx_buf, - lon_center + box_size / 2. + bx_buf] + lat_limits = [ + lat_center - box_size / 2.0 - bx_buf, + lat_center + box_size / 2.0 + bx_buf, + ] + lon_limits = [ + lon_center - box_size / 2.0 - bx_buf, + lon_center + box_size / 2.0 + bx_buf, + ] - data = self._arm[dsname][data_field].values + data = self._ds[dsname][data_field].values # Create base plot projection ax = plt.axes(projection=projection) plt.subplots_adjust(left=0.01, right=0.99, bottom=0.05, top=0.93) - ax.set_extent([lon_limits[0], lon_limits[1], lat_limits[0], - lat_limits[1]], crs=projection) + ax.set_extent([lon_limits[0], lon_limits[1], lat_limits[0], lat_limits[1]], crs=projection) if title is None: try: - dim = list(self._arm[dsname][data_field].dims) - ts = pd.to_datetime(str(self._arm[dsname][dim[0]].values[0])) + dim = list(self._ds[dsname][data_field].dims) + ts = pd.to_datetime(str(self._ds[dsname][dim[0]].values[0])) date = ts.strftime('%Y-%m-%d') time_str = ts.strftime('%H:%M:%S') plt.title(' '.join([dsname, 'at', date, time_str])) @@ -170,13 +209,13 @@ def geoplot(self, data_field=None, lat_field='lat', else: plt.title(title) - if stamen: - tiler = Stamen(stamen) + if img_tile is not None: + tiler = getattr(img_tiles, img_tile)(**img_tile_args) ax.add_image(tiler, tile) colorbar_map = None if cmap is not None: - colorbar_map = plt.cm.get_cmap(cmap) + colorbar_map = matplotlib.colormaps.get_cmap(cmap) sc = ax.scatter(lon, lat, c=data, cmap=colorbar_map, **kwargs) cbar = plt.colorbar(sc) cbar.ax.set_ylabel(cbar_label) @@ -205,18 +244,28 @@ def geoplot(self, data_field=None, lat_field='lat', if gridlines: if projection == ccrs.PlateCarree() or projection == ccrs.Mercator: - gl = ax.gridlines(crs=projection, draw_labels=True, - linewidth=1, color='gray', alpha=0.5, - linestyle='--') - gl.xlabels_top = False - gl.ylabels_left = True - gl.xlabels_bottom = True - gl.ylabels_right = False + gl = ax.gridlines( + crs=projection, + draw_labels=True, + linewidth=1, + color='gray', + alpha=0.5, + linestyle='--', + ) + gl.top_labels = False + gl.left_labels = True + gl.bottom_labels = True + gl.right_labels = False gl.xlabel_style = {'size': 6, 'color': 'gray'} gl.ylabel_style = {'size': 6, 'color': 'gray'} else: # Labels are only currently supported for PlateCarree and Mercator - gl = ax.gridlines(draw_labels=False, linewidth=1, color='gray', - alpha=0.5, linestyle='--') + gl = ax.gridlines( + draw_labels=False, + linewidth=1, + color='gray', + alpha=0.5, + linestyle='--', + ) return ax diff --git a/act/plotting/plot.py b/act/plotting/plot.py index b2ca7e934f..0d5a31eca1 100644 --- a/act/plotting/plot.py +++ b/act/plotting/plot.py @@ -1,19 +1,18 @@ """ -act.plotting.plot -================= - Class for creating timeseries plots from ACT datasets. """ +import warnings + # Import third party libraries import matplotlib.pyplot as plt import numpy as np -import warnings import xarray as xr +import inspect -class Display(object): +class Display: """ This class is the base class for all of the other Display object types in ACT. This contains the common attributes and routines @@ -51,8 +50,8 @@ class with this set to None will create a new figure handle. See the Parameters ---------- - obj : ACT Dataset, dict, or tuple - The ACT Dataset to display in the object. If more than one dataset + ds : ACT xarray.Dataset, dict, or tuple + The ACT xarray dataset to display in the object. If more than one dataset is to be specified, then a tuple can be used if all of the datasets conform to ARM standards. Otherwise, a dict with a key corresponding to the name of each datastream will need to be supplied in order @@ -71,29 +70,35 @@ class with this set to None will create a new figure handle. See the Keyword arguments passed to :func:`plt.figure`. """ - def __init__(self, obj, subplot_shape=(1,), ds_name=None, - subplot_kw=None, **kwargs): - if isinstance(obj, xr.Dataset): - if 'datastream' in obj.attrs.keys() is not None: - self._arm = {obj.attrs['datastream']: obj} + + def __init__(self, ds, subplot_shape=(1,), ds_name=None, subplot_kw=None, + **kwargs): + if isinstance(ds, xr.Dataset): + if 'datastream' in ds.attrs.keys() is not None: + self._ds = {ds.attrs['datastream']: ds} elif ds_name is not None: - self._arm = {ds_name: obj} + self._ds = {ds_name: ds} else: - warnings.warn(("Could not discern datastream" + - "name and dict or tuple were " + - "not provided. Using default" + - "name of act_datastream!"), UserWarning) - - self._arm = {'act_datastream': obj} - - # Automatically name by datastream if a tuple of object is supplied - if isinstance(obj, tuple): - self._arm = {} - for objs in obj: - self._arm[objs.attrs['datastream']] = objs - - if isinstance(obj, dict): - self._arm = obj + warnings.warn( + ( + 'Could not discern datastream' + + 'name and dict or tuple were ' + + 'not provided. Using default' + + 'name of act_datastream!' + ), + UserWarning, + ) + + self._ds = {'act_datastream': ds} + + # Automatically name by datastream if a tuple of datasets is supplied + if isinstance(ds, tuple): + self._ds = {} + for multi_ds in ds: + self._ds[multi_ds.attrs['datastream']] = multi_ds + + if isinstance(ds, dict): + self._ds = ds self.fields = {} self.ds = {} @@ -101,24 +106,23 @@ def __init__(self, obj, subplot_shape=(1,), ds_name=None, self.xrng = np.zeros((1, 2)) self.yrng = np.zeros((1, 2)) - for dsname in self._arm.keys(): - self.fields[dsname] = self._arm[dsname].variables - if '_datastream' in self._arm[dsname].attrs.keys(): - self.ds[dsname] = str(self._arm[dsname].attrs['_datastream']) + for dsname in self._ds.keys(): + self.fields[dsname] = self._ds[dsname].variables + if '_datastream' in self._ds[dsname].attrs.keys(): + self.ds[dsname] = str(self._ds[dsname].attrs['_datastream']) else: - self.ds[dsname] = "act_datastream" - if '_file_dates' in self._arm[dsname].attrs.keys(): - self.file_dates[dsname] = self._arm[dsname].attrs['_file_dates'] + self.ds[dsname] = 'act_datastream' + if '_file_dates' in self._ds[dsname].attrs.keys(): + self.file_dates[dsname] = self._ds[dsname].attrs['_file_dates'] self.fig = None self.axes = None self.plot_vars = [] self.cbs = [] if subplot_shape is not None: - self.add_subplots(subplot_shape, subplot_kw=subplot_kw, - **kwargs) + self.add_subplots(subplot_shape, subplot_kw=subplot_kw, **kwargs) - def add_subplots(self, subplot_shape=(1,), subplot_kw=None, + def add_subplots(self, subplot_shape=(1,), secondary_y=False, subplot_kw=None, **kwargs): """ Adds subplots to the Display object. The current @@ -143,23 +147,21 @@ def add_subplots(self, subplot_shape=(1,), subplot_kw=None, if len(subplot_shape) == 2: fig, ax = plt.subplots( - subplot_shape[0], subplot_shape[1], - subplot_kw=subplot_kw, - **kwargs) + subplot_shape[0], subplot_shape[1], subplot_kw=subplot_kw, **kwargs + ) self.xrng = np.zeros((subplot_shape[0], subplot_shape[1], 2)) self.yrng = np.zeros((subplot_shape[0], subplot_shape[1], 2)) if subplot_shape[0] == 1: ax = ax.reshape(1, subplot_shape[1]) elif len(subplot_shape) == 1: - fig, ax = plt.subplots( - subplot_shape[0], 1, subplot_kw=subplot_kw, **kwargs) + fig, ax = plt.subplots(subplot_shape[0], 1, subplot_kw=subplot_kw, **kwargs) if subplot_shape[0] == 1: ax = np.array([ax]) self.xrng = np.zeros((subplot_shape[0], 2)) self.yrng = np.zeros((subplot_shape[0], 2)) else: - raise ValueError(("subplot_shape must be a 1 or 2 dimensional" + - "tuple list, or array!")) + raise ValueError('subplot_shape must be a 1 or 2 dimensional' + 'tuple list, or array!') + self.fig = fig self.axes = ax @@ -184,13 +186,15 @@ def put_display_in_subplot(self, display, subplot_index): """ if len(display.axes) > 1: - raise RuntimeError("Only single plots can be made as subplots " + - "of another Display object!") - + raise RuntimeError( + 'Only single plots can be made as subplots ' + 'of another Display object!' + ) my_projection = display.axes[0].name + plt.close(display.fig) display.fig = self.fig self.fig.delaxes(self.axes[subplot_index]) + the_shape = self.axes.shape if len(the_shape) == 1: second_value = 1 @@ -198,9 +202,11 @@ def put_display_in_subplot(self, display, subplot_index): second_value = the_shape[1] self.axes[subplot_index] = self.fig.add_subplot( - the_shape[0], second_value, + the_shape[0], + second_value, (second_value - 1) * the_shape[0] + subplot_index[0] + 1, - projection=my_projection) + projection=my_projection, + ) display.axes = np.array([self.axes[subplot_index]]) @@ -229,7 +235,8 @@ def assign_to_figure_axis(self, fig, ax): self.fig = fig self.axes = np.array([ax]) - def add_colorbar(self, mappable, title=None, subplot_index=(0, )): + def add_colorbar(self, mappable, title=None, subplot_index=(0,), pad=None, + width=None, **kwargs): """ Adds a colorbar to the plot. @@ -240,7 +247,13 @@ def add_colorbar(self, mappable, title=None, subplot_index=(0, )): title : str The title of the colorbar. Set to None to have no title. subplot_index : 1 or 2D tuple, list, or array - The index of the subplot to set the x range of. + The index of the subplot to set the x range + pad : float + Padding to right of plot for placement of the colorbar + width : float + Width of the colorbar + **kwargs : keyword arguments + The keyword arguments for :func:`plt.colorbar` Returns ------- @@ -249,19 +262,166 @@ def add_colorbar(self, mappable, title=None, subplot_index=(0, )): """ if self.axes is None: - raise RuntimeError("add_colorbar requires the plot " - "to be displayed.") + raise RuntimeError('add_colorbar requires the plot ' 'to be displayed.') fig = self.fig ax = self.axes[subplot_index] + if pad is None: + pad = 0.01 + + if width is None: + width = 0.01 + # Give the colorbar it's own axis so the 2D plots line up with 1D box = ax.get_position() - pad, width = 0.01, 0.01 cax = fig.add_axes([box.xmax + pad, box.ymin, width, box.height]) - cbar = plt.colorbar(mappable, cax=cax) - cbar.ax.set_ylabel(title, rotation=270, fontsize=8, labelpad=3) + cbar = plt.colorbar(mappable, cax=cax, **kwargs) + if title is not None: + cbar.ax.set_ylabel(title, rotation=270, fontsize=8, labelpad=3) cbar.ax.tick_params(labelsize=6) self.cbs.append(cbar) return cbar + + def group_by(self, units): + """ + Group the Display by specific units of time. + + Parameters + ---------- + units: str + One of: 'year', 'month', 'day', 'hour', 'minute', 'second'. + Group the plot by this unit of time (year, month, etc.) + Returns + ------- + groupby: act.plotting.DisplayGroupby + The DisplayGroupby object to be retuned. + """ + return DisplayGroupby(self, units) + + +class DisplayGroupby(object): + def __init__(self, display, units): + """ + + Parameters + ---------- + display: Display + The Display object to group by time. + units: str + The time units to group by. Can be one of: + 'year', 'month', 'day', 'hour', 'minute', 'second' + """ + self.display = display + self._groupby = {} + self.mapping = {} + self.xlims = {} + self.units = units + self.isTimeSeriesDisplay = hasattr(self.display, 'time_height_scatter') + num_groups = 0 + datastreams = list(display._ds.keys()) + for key in datastreams: + self._groupby[key] = display._ds[key].groupby('time.%s' % units) + num_groups = max([num_groups, len(self._groupby[key])]) + + def plot_group(self, func_name, dsname=None, **kwargs): + """ + Plots each group created in :func:`act.plotting.Display.group_by` into each subplot of the display. + Parameters + ---------- + func_name: str + The name of the plotting function in the Display that you are grouping. + dsname: str or None + The name of the datastream to plot + + Additional keyword objects are passed into *func_name*. + + Returns + ------- + axis: Array of matplotlib axes handles + The array of matplotlib axes handles that correspond to each subplot. + """ + if dsname is None: + dsname = list(self.display._ds.keys())[0].split('_')[0] + + func = getattr(self.display, func_name) + + if not callable(func): + raise RuntimeError("The specified string is not a function of " + "the Display object.") + subplot_shape = self.display.axes.shape + + i = 0 + wrap_around = False + old_ds = self.display._ds + for key in self._groupby.keys(): + if dsname == key: + self.display._ds = {} + for k, ds in self._groupby[key]: + num_years = len(np.unique(ds.time.dt.year)) + self.display._ds[key + '_%d' % k] = ds + if i >= np.prod(subplot_shape): + i = 0 + wrap_around = True + if len(subplot_shape) == 2: + subplot_index = (int(i / subplot_shape[1]), i % subplot_shape[1]) + else: + subplot_index = (i % subplot_shape[0],) + args, varargs, varkw, _, _, _, _ = inspect.getfullargspec(func) + if "subplot_index" in args: + kwargs["subplot_index"] = subplot_index + if "time_rng" in args: + kwargs["time_rng"] = (ds.time.values.min(), ds.time.values.max()) + if num_years > 1 and self.isTimeSeriesDisplay: + first_year = ds.time.dt.year[0] + for yr, ds1 in ds.groupby('time.year'): + if ds1.time.dt.year[0] % 4 == 0: + days_in_year = 366 + else: + days_in_year = 365 + year_diff = ds1.time.dt.year - first_year + time_diff = np.array( + [np.timedelta64(x * days_in_year, 'D') for x in year_diff.values]) + ds1['time'] = ds1.time - time_diff + self.display._ds[key + '%d_%d' % (k, yr)] = ds1 + func(dsname=key + '%d_%d' % (k, yr), label=str(yr), **kwargs) + self.mapping[key + '%d_%d' % (k, yr)] = subplot_index + self.xlims[key + '%d_%d' % (k, yr)] = (ds1.time.values.min(), ds1.time.values.max()) + del self.display._ds[key + '_%d' % k] + else: + func(dsname=key + '_%d' % k, **kwargs) + self.mapping[key + '_%d' % k] = subplot_index + if self.isTimeSeriesDisplay: + self.xlims[key + '_%d' % k] = (ds.time.values.min(), ds.time.values.max()) + i = i + 1 + + if wrap_around is False and i < np.prod(subplot_shape): + while i < np.prod(subplot_shape): + if len(subplot_shape) == 2: + subplot_index = (int(i / subplot_shape[1]), i % subplot_shape[1]) + else: + subplot_index = (i % subplot_shape[0],) + self.display.axes[subplot_index].axis('off') + i = i + 1 + + for i in range(1, np.prod(subplot_shape)): + if len(subplot_shape) == 2: + subplot_index = (int(i / subplot_shape[1]), i % subplot_shape[1]) + else: + subplot_index = (i % subplot_shape[0],) + + try: + self.display.axes[subplot_index].get_legend().remove() + except AttributeError: + pass + if self.isTimeSeriesDisplay: + key_list = list(self.display._ds.keys()) + for k in key_list: + time_min, time_max = self.xlims[k] + subplot_index = self.mapping[k] + self.display.set_xrng([time_min, time_max], subplot_index) + + self.display._ds = old_ds + + return self.display.axes diff --git a/act/plotting/skewtdisplay.py b/act/plotting/skewtdisplay.py new file mode 100644 index 0000000000..36190cf457 --- /dev/null +++ b/act/plotting/skewtdisplay.py @@ -0,0 +1,844 @@ +""" +Stores the class for SkewTDisplay. + +""" + +import warnings +from copy import deepcopy + +import matplotlib.pyplot as plt + +# Import third party libraries +import metpy +import metpy.calc as mpcalc +import numpy as np +import scipy +from metpy.plots import Hodograph, SkewT +from metpy.units import units + +from ..retrievals import calculate_stability_indicies + +# Import Local Libs +from ..utils import datetime_utils as dt_utils +from .plot import Display + + +class SkewTDisplay(Display): + """ + A class for making Skew-T plots. + + This is inherited from the :func:`act.plotting.Display` + class and has therefore has the same attributes as that class. + See :func:`act.plotting.Display` + for more information. There are no additional attributes or parameters + to this class. + + In order to create Skew-T plots, ACT needs the MetPy package to be + installed on your system. More information about + MetPy go here: https://unidata.github.io/MetPy/latest/index.html. + + Examples + -------- + Here is an example of how to make a Skew-T plot using ACT: + + .. code-block :: python + + sonde_ds = act.io.arm.read_arm_netcdf( + act.tests.sample_files.EXAMPLE_SONDE1) + + skewt = act.plotting.SkewTDisplay(sonde_ds) + skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp') + plt.show() + + """ + + def __init__(self, ds, subplot_shape=(1,), subplot=None, ds_name=None, set_fig=None, **kwargs): + # We want to use our routine to handle subplot adding, not the main + # one + new_kwargs = kwargs.copy() + super().__init__(ds, None, ds_name, subplot_kw=dict(projection='skewx'), + **new_kwargs) + + # Make a SkewT object for each subplot + self.add_subplots(subplot_shape, set_fig=set_fig, subplot=subplot, **kwargs) + + def add_subplots(self, subplot_shape=(1,), set_fig=None, subplot=None, **kwargs): + """ + Adds subplots to the Display object. The current + figure in the object will be deleted and overwritten. + + Parameters + ---------- + subplot_shape : 1 or 2D tuple, list, or array + The structure of the subplots in (rows, cols). + subplot_kw : dict, optional + The kwargs to pass into fig.subplots. + set_fig : matplotlib figure, optional + Figure to pass to SkewT + **kwargs : keyword arguments + Any other keyword arguments that will be passed + into :func:`matplotlib.pyplot.figure` when the figure + is made. The figure is only made if the *fig* + property is None. See the matplotlib + documentation for further details on what keyword + arguments are available. + + """ + del self.axes + if self.fig is None and set_fig is None: + self.fig = plt.figure(**kwargs) + if set_fig is not None: + self.fig = set_fig + self.SkewT = np.empty(shape=subplot_shape, dtype=SkewT) + self.axes = np.empty(shape=subplot_shape, dtype=plt.Axes) + if len(subplot_shape) == 1: + for i in range(subplot_shape[0]): + if subplot is None: + subplot_tuple = (subplot_shape[0], 1, i + 1) + else: + subplot_tuple = subplot + self.SkewT[i] = SkewT(fig=self.fig, subplot=subplot_tuple) + self.axes[i] = self.SkewT[i].ax + elif len(subplot_shape) == 2: + for i in range(subplot_shape[0]): + for j in range(subplot_shape[1]): + subplot_tuple = ( + subplot_shape[0], + subplot_shape[1], + i * subplot_shape[1] + j + 1, + ) + self.SkewT[i, j] = SkewT(fig=self.fig, subplot=subplot_tuple) + self.axes[i, j] = self.SkewT[i, j].ax + else: + raise ValueError('Subplot shape must be 1 or 2D!') + + def set_xrng(self, xrng, subplot_index=(0,)): + """ + Sets the x range of the plot. + + Parameters + ---------- + xrng : 2 number array. + The x limits of the plot. + subplot_index : 1 or 2D tuple, list, or array + The index of the subplot to set the x range of. + + """ + if self.axes is None: + raise RuntimeError('set_xrng requires the plot to be displayed.') + + if not hasattr(self, 'xrng') or np.all(self.xrng == 0): + if len(self.axes.shape) == 2: + self.xrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) + else: + self.xrng = np.zeros((self.axes.shape[0], 2)) + + self.axes[subplot_index].set_xlim(xrng) + self.xrng[subplot_index, :] = np.array(xrng) + + def set_yrng(self, yrng, subplot_index=(0,)): + """ + Sets the y range of the plot. + + Parameters + ---------- + yrng : 2 number array + The y limits of the plot. + subplot_index : 1 or 2D tuple, list, or array + The index of the subplot to set the x range of. + + """ + if self.axes is None: + raise RuntimeError('set_yrng requires the plot to be displayed.') + + if not hasattr(self, 'yrng') or np.all(self.yrng == 0): + if len(self.axes.shape) == 2: + self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) + else: + self.yrng = np.zeros((self.axes.shape[0], 2)) + + if not hasattr(self, 'yrng') and len(self.axes.shape) == 2: + self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) + elif not hasattr(self, 'yrng') and len(self.axes.shape) == 1: + self.yrng = np.zeros((self.axes.shape[0], 2)) + + if yrng[0] == yrng[1]: + yrng[1] = yrng[1] + 1 + + self.axes[subplot_index].set_ylim(yrng) + self.yrng[subplot_index, :] = yrng + + def plot_from_spd_and_dir( + self, spd_field, dir_field, p_field, t_field, td_field, dsname=None, **kwargs + ): + """ + This plot will make a sounding plot from wind data that is given + in speed and direction. + + Parameters + ---------- + spd_field : str + The name of the field corresponding to the wind speed. + dir_field : str + The name of the field corresponding to the wind direction + in degrees from North. + p_field : str + The name of the field containing the atmospheric pressure. + t_field : str + The name of the field containing the atmospheric temperature. + td_field : str + The name of the field containing the dewpoint. + dsname : str or None + The name of the datastream to plot. Set to None to make ACT + attempt to automatically determine this. + kwargs : dict + Additional keyword arguments will be passed into + :func:`act.plotting.SkewTDisplay.plot_from_u_and_v` + + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle corresponding to the plot. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + # Make temporary field called tempu, tempv + spd = self._ds[dsname][spd_field].values * units(self._ds[dsname][spd_field].attrs['units']) + dir = self._ds[dsname][dir_field].values * units(self._ds[dsname][dir_field].attrs['units']) + tempu, tempv = mpcalc.wind_components(spd, dir) + + self._ds[dsname]['temp_u'] = deepcopy(self._ds[dsname][spd_field]) + self._ds[dsname]['temp_v'] = deepcopy(self._ds[dsname][spd_field]) + self._ds[dsname]['temp_u'].values = tempu + self._ds[dsname]['temp_v'].values = tempv + the_ax = self.plot_from_u_and_v( + 'temp_u', 'temp_v', p_field, t_field, td_field, dsname, **kwargs + ) + del self._ds[dsname]['temp_u'], self._ds[dsname]['temp_v'] + return the_ax + + def plot_from_u_and_v( + self, + u_field, + v_field, + p_field, + t_field, + td_field, + dsname=None, + subplot_index=(0,), + p_levels_to_plot=None, + show_parcel=True, + shade_cape=True, + shade_cin=True, + set_title=None, + smooth_p=3, + plot_dry_adiabats=False, + plot_moist_adiabats=False, + plot_mixing_lines=False, + plot_barbs_kwargs=dict(), + plot_kwargs=dict(), + dry_adiabats_kwargs=dict(), + moist_adiabats_kwargs=dict(), + mixing_lines_kwargs=dict(), + ): + """ + This function will plot a Skew-T from a sounding dataset. The wind + data must be given in u and v. + + Parameters + ---------- + u_field : str + The name of the field containing the u component of the wind. + v_field : str + The name of the field containing the v component of the wind. + p_field : str + The name of the field containing the pressure. + t_field : str + The name of the field containing the temperature. + td_field : str + The name of the field containing the dewpoint temperature. + dsname : str or None + The name of the datastream to plot. Set to None to make ACT + attempt to automatically determine this. + subplot_index : tuple + The index of the subplot to make the plot on. + p_levels_to_plot : 1D array + The pressure levels to plot the wind barbs on. Set to None + to have ACT to use neatly spaced defaults of + 25, 50, 75, 100, 150, 200, 250, 300, 400, 500, 600, 700, 750, 800, + 850, 900, 950, and 1000 hPa. + show_parcel : bool + Set to true to calculate the profile a parcel takes through the atmosphere + using the metpy.calc.parcel_profile function. From their documentation, + the parcel starts at the surface temperature and dewpoint, is lifted up + dry adiabatically to the LCL and then moist adiabatically from there. + shade_cape : bool + Set to True to shade the CAPE red. + shade_cin : bool + Set to True to shade the CIN blue. + set_title : None or str + The title of the plot is set to this. Set to None to use + a default title. + smooth_p : int + If pressure is not in descending order, will smooth the data + using this many points to try and work around the issue. + Default is 3 but inthe pbl retrieval code we have to default to 5 at times + plot_barbs_kwargs : dict + Additional keyword arguments to pass into MetPy's + SkewT.plot_barbs. + plot_kwargs : dict + Additional keyword arguments to pass into MetPy's + SkewT.plot. + dry_adiabats_kwargs : dict + Additional keyword arguments to pass into MetPy's plot_dry_adiabats function + moist_adiabats_kwargs : dict + Additional keyword arguments to pass into MetPy's plot_moist_adiabats function + mixing_lines_kwargs : dict + Additional keyword arguments to pass into MetPy's plot_mixing_lines function + + Returns + ------- + ax : matplotlib axis handle + The axis handle to the plot. + + References + ---------- + May, R. M., Arms, S. C., Marsh, P., Bruning, E., Leeman, J. R., Goebbert, K., Thielen, J. E., + Bruick, Z., and Camron, M. D., 2023: MetPy: A Python Package for Meteorological Data. + Unidata, Unidata/MetPy, doi:10.5065/D6WW7G29. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + if p_levels_to_plot is None: + p_levels_to_plot = np.array( + [ + 25.0, + 50.0, + 75.0, + 100.0, + 150.0, + 200.0, + 250.0, + 300.0, + 400.0, + 500.0, + 600.0, + 700.0, + 750.0, + 800.0, + 850.0, + 900.0, + 950.0, + 1000.0, + ] + ) * units('hPa') + + # Get pressure and smooth if not in order + p = self._ds[dsname][p_field] + if not all(p[i] <= p[i + 1] for i in range(len(p) - 1)): + if 'time' in self._ds: + self._ds[dsname][p_field] = ( + self._ds[dsname][p_field].rolling(time=smooth_p, min_periods=1, center=True).mean() + ) + p = self._ds[dsname][p_field] + + p_units = self._ds[dsname][p_field].attrs['units'] + p = p.values * getattr(units, p_units) + if len(np.shape(p)) == 2: + p = np.reshape(p, p.shape[0] * p.shape[1]) + + T = self._ds[dsname][t_field] + T_units = self._ds[dsname][t_field].attrs['units'] + if T_units == 'C': + T_units = 'degC' + + T = T.values * getattr(units, T_units) + if len(np.shape(T)) == 2: + T = np.reshape(T, T.shape[0] * T.shape[1]) + + Td = self._ds[dsname][td_field] + Td_units = self._ds[dsname][td_field].attrs['units'] + if Td_units == 'C': + Td_units = 'degC' + + Td = Td.values * getattr(units, Td_units) + if len(np.shape(Td)) == 2: + Td = np.reshape(Td, Td.shape[0] * Td.shape[1]) + + u = self._ds[dsname][u_field] + u_units = self._ds[dsname][u_field].attrs['units'] + u = u.values * getattr(units, u_units) + if len(np.shape(u)) == 2: + u = np.reshape(u, u.shape[0] * u.shape[1]) + + v = self._ds[dsname][v_field] + v_units = self._ds[dsname][v_field].attrs['units'] + v = v.values * getattr(units, v_units) + if len(np.shape(v)) == 2: + v = np.reshape(v, v.shape[0] * v.shape[1]) + + u_red = np.zeros_like(p_levels_to_plot) * getattr(units, u_units) + v_red = np.zeros_like(p_levels_to_plot) * getattr(units, v_units) + + # Check p_levels_to_plot units, and convert to p units if needed + if not hasattr(p_levels_to_plot, 'units'): + p_levels_to_plot = p_levels_to_plot * getattr(units, p_units) + else: + p_levels_to_plot = p_levels_to_plot.to(p_units) + + for i in range(len(p_levels_to_plot)): + index = np.argmin(np.abs(p_levels_to_plot[i] - p)) + u_red[i] = u[index].magnitude * getattr(units, u_units) + v_red[i] = v[index].magnitude * getattr(units, v_units) + + self.SkewT[subplot_index].plot(p, T, 'r', **plot_kwargs) + self.SkewT[subplot_index].plot(p, Td, 'g', **plot_kwargs) + self.SkewT[subplot_index].plot_barbs( + p_levels_to_plot.magnitude, u_red, v_red, **plot_barbs_kwargs + ) + + # Metpy fix if Pressure does not decrease monotonically in + # your sounding. + try: + prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC') + except metpy.calc.exceptions.InvalidSoundingError: + p = scipy.ndimage.median_filter(p, 3, output=float) + p = metpy.units.units.Quantity(p, p_units) + prof = mpcalc.parcel_profile(p, T[0], Td[0]).to('degC') + + if show_parcel: + # Only plot where prof > T + lcl_pressure, lcl_temperature = mpcalc.lcl(p[0], T[0], Td[0]) + self.SkewT[subplot_index].plot( + lcl_pressure, lcl_temperature, 'ko', markerfacecolor='black', **plot_kwargs + ) + self.SkewT[subplot_index].plot(p, prof, 'k', linewidth=2, **plot_kwargs) + + if shade_cape: + self.SkewT[subplot_index].shade_cape(p, T, prof, linewidth=2) + + if shade_cin: + self.SkewT[subplot_index].shade_cin(p, T, prof, linewidth=2) + + # Get plot temperatures from x-axis as t0 + t0 = self.SkewT[subplot_index].ax.get_xticks() * getattr(units, T_units) + + # Add minimum pressure to pressure levels to plot + if np.nanmin(p.magnitude) < np.nanmin(p_levels_to_plot.magnitude): + plp = np.insert(p_levels_to_plot.magnitude, 0, np.nanmin(p.magnitude)) * units('hPa') + else: + plp = p_levels_to_plot + + # New options for plotting dry and moist adiabats as well as the mixing lines + if plot_dry_adiabats: + self.SkewT[subplot_index].plot_dry_adiabats(pressure=plp, t0=t0, **dry_adiabats_kwargs) + + if plot_moist_adiabats: + self.SkewT[subplot_index].plot_moist_adiabats(t0=t0, pressure=plp, **moist_adiabats_kwargs) + + if plot_mixing_lines: + self.SkewT[subplot_index].plot_mixing_lines(pressure=plp, **mixing_lines_kwargs) + + # Set Title + if set_title is None: + if 'time' in self._ds[dsname]: + title_time = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + elif '_file_dates' in self._ds[dsname].attrs: + title_time = self._ds[dsname].attrs['_file_dates'][0] + else: + title_time = '' + set_title = ' '.join([dsname, 'on', title_time[0]]) + + self.axes[subplot_index].set_title(set_title) + + # Set Y Limit + our_data = p.magnitude + if np.isfinite(our_data).any(): + yrng = [np.nanmax(our_data), np.nanmin(our_data)] + else: + yrng = [1000.0, 100.0] + self.set_yrng(yrng, subplot_index) + + # Set X Limit + xrng = [np.nanmin(T.magnitude) - 10.0, np.nanmax(T.magnitude) + 10.0] + self.set_xrng(xrng, subplot_index) + + return self.axes[subplot_index] + + def plot_hodograph( + self, + spd_field, + dir_field, + color_field=None, + set_fig=None, + set_axes=None, + component_range=80, + dsname=None, + uv_flag=False, + ): + """ + This will plot a hodograph from the radiosonde wind data using + MetPy + + Parameters + ---------- + spd_field : str + The name of the field corresponding to the wind speed. + dir_field : str + The name of the field corresponding to the wind direction + in degrees from North. + color_field : str, optional + The name of the field if wanting to shade by another variable + set_fig : matplotlib figure, optional + The figure to plot on + set_axes : matplotlib axes, optional + The specific axes to plot on + component_range : int + Range of the hodograph. Default is 80 + dsname : str + Name of the datastream to plot if multiple in the plot object + uv_flag : boolean + If set to True, spd_field and dir_field will be treated as the + U and V wind variable names + + Returns + ------- + self.axes : matplotlib axes + + """ + + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + # Get the current plotting axis + if set_fig is not None: + self.fig = set_fig + if set_axes is not None: + self.axes = set_axes + + if self.fig is None: + self.fig = plt.figure() + + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + # Calculate u/v wind components from speed/direction + if uv_flag is False: + spd = self._ds[dsname][spd_field].values * units( + self._ds[dsname][spd_field].attrs['units'] + ) + dir = self._ds[dsname][dir_field].values * units( + self._ds[dsname][dir_field].attrs['units'] + ) + u, v = mpcalc.wind_components(spd, dir) + else: + u = self._ds[dsname][spd_field].values * units( + self._ds[dsname][spd_field].attrs['units'] + ) + v = self._ds[dsname][dir_field].values * units( + self._ds[dsname][dir_field].attrs['units'] + ) + + # Plot out the data using the Hodograph method + h = Hodograph(self.axes, component_range=component_range) + h.add_grid(increment=20) + if color_field is None: + h.plot(u, v) + else: + data = self._ds[dsname][color_field].values * units( + self._ds[dsname][color_field].attrs['units'] + ) + h.plot_colormapped(u, v, data) + + return self.axes + + def add_stability_info( + self, + temp_name='tdry', + td_name='dp', + p_name='pres', + overwrite_data=None, + add_data=None, + set_fig=None, + set_axes=None, + dsname=None, + ): + """ + This plot will make a sounding plot from wind data that is given + in speed and direction. + + Parameters + ---------- + temp_name : str + The name of the temperature field. + td_name : str + The name of the dewpoint field. + p_name : str + The name of the pressure field. + overwrite_data : dict + A disctionary of variables/values to write out instead + of the ones calculated by MetPy. Needs to be of the form + .. code-block:: python + + overwrite_data={'LCL': 234, 'CAPE': 25} + ... + add_data : dict + A dictionary of variables and values to write out in + addition to the MetPy calculated ones + set_fig : matplotlib figure, optional + The figure to plot on + set_axes : matplotlib axes, optional + The specific axes to plot on + dsname : str + Name of the datastream to plot if multiple in the plot object + + Returns + ------- + self.axes : matplotlib axes + + """ + + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + # Get the current plotting axis + if set_fig is not None: + self.fig = set_fig + if set_axes is not None: + self.axes = set_axes + + if self.fig is None: + self.fig = plt.figure() + + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + self.axes.spines['top'].set_visible(False) + self.axes.spines['right'].set_visible(False) + self.axes.spines['bottom'].set_visible(False) + self.axes.spines['left'].set_visible(False) + self.axes.get_xaxis().set_ticks([]) + self.axes.get_yaxis().set_ticks([]) + ct = 0 + if overwrite_data is None: + # Calculate stability indicies + ds_sonde = calculate_stability_indicies( + self._ds[dsname], + temp_name=temp_name, + td_name=td_name, + p_name=p_name, + ) + + # Add MetPy calculated variables to the list + variables = { + 'lifted_index': 'Lifted Index', + 'surface_based_cape': 'SBCAPE', + 'surface_based_cin': 'SBCIN', + 'most_unstable_cape': 'MUCAPE', + 'most_unstable_cin': 'MUCIN', + 'lifted_condensation_level_temperature': 'LCL Temp', + 'lifted_condensation_level_pressure': 'LCL Pres', + } + for i, v in enumerate(variables): + var_string = str(np.round(ds_sonde[v].values, 2)) + self.axes.text( + -0.05, + (0.98 - (0.1 * i)), + variables[v] + ': ', + transform=self.axes.transAxes, + fontsize=10, + verticalalignment='top', + ) + self.axes.text( + 0.95, + (0.98 - (0.1 * i)), + var_string, + transform=self.axes.transAxes, + fontsize=10, + verticalalignment='top', + horizontalalignment='right', + ) + ct += 1 + else: + # If overwrite_data is set, the user passes in their own dictionary + for i, v in enumerate(overwrite_data): + var_string = str(np.round(overwrite_data[v], 2)) + self.axes.text( + -0.05, + (0.98 - (0.1 * i)), + v + ': ', + transform=self.axes.transAxes, + fontsize=10, + verticalalignment='top', + ) + self.axes.text( + 0.95, + (0.98 - (0.1 * i)), + var_string, + transform=self.axes.transAxes, + fontsize=10, + verticalalignment='top', + horizontalalignment='right', + ) + # User can also add variables to the existing ones calculated by MetPy + if add_data is not None: + for i, v in enumerate(add_data): + var_string = str(np.round(add_data[v], 2)) + self.axes.text( + -0.05, + (0.98 - (0.1 * (i + ct))), + v + ': ', + transform=self.axes.transAxes, + fontsize=10, + verticalalignment='top', + ) + self.axes.text( + 0.95, + (0.98 - (0.1 * (i + ct))), + var_string, + transform=self.axes.transAxes, + fontsize=10, + verticalalignment='top', + horizontalalignment='right', + ) + return self.axes + + def plot_enhanced_skewt( + self, + spd_name='wspd', + dir_name='deg', + temp_name='tdry', + td_name='dp', + p_name='pres', + overwrite_data=None, + add_data=None, + color_field=None, + component_range=80, + uv_flag=False, + dsname=None, + figsize=(14, 10), + layout='constrained', + ): + """ + This will plot an enhanced Skew-T plot with a Hodograph on the top right + and the stability parameters on the lower right. This will create a new + figure so that one does not need to be defined through subplot_shape. + + Requires Matplotlib v 3.7 and higher + + Parameters + ---------- + spd_name : str + The name of the field corresponding to the wind speed. + dir_name : str + The name of the field corresponding to the wind direction + in degrees from North. + temp_name : str + The name of the temperature field. + td_name : str + The name of the dewpoint field. + p_name : str + The name of the pressure field. + overwrite_data : dict + A disctionary of variables/values to write out instead + of the ones calculated by MetPy. Needs to be of the form + .. code-block:: python + + overwrite_data={'LCL': 234, 'CAPE': 25} + ... + add_data : dict + A dictionary of variables and values to write out in + addition to the MetPy calculated ones + color_field : str, optional + The name of the field if wanting to shade by another variable + component_range : int + Range of the hodograph. Default is 80 + uv_flag : boolean + If set to True, spd_field and dir_field will be treated as the + U and V wind variable names + dsname : str + Name of the datastream to plot if multiple in the plot object + figsize : tuple + Figure size for the plot + layout : str + String to pass to matplotlib.figure.Figure object layout keyword + argument. Choice of 'constrained,' 'compressed,' 'tight,' or None. + Default is 'constrained'. + + Returns + ------- + self.axes : matplotlib axes + + """ + + # Set up the figure and axes + # Close existing figure as a new one will be created + plt.close('all') + subplot_kw = {'a': {'projection': 'skewx'}} + fig, axs = plt.subplot_mosaic( + [['a', 'a', 'b'], ['a', 'a', 'b'], ['a', 'a', 'c'], ['a', 'a', 'c']], + layout=layout, + per_subplot_kw=subplot_kw, + ) + self.fig = fig + self.axes = axs + + # Plot out the Skew-T + display = SkewTDisplay(self._ds, set_fig=fig, subplot=axs['a'], figsize=figsize) + if uv_flag is True: + display.plot_from_u_and_v(spd_name, dir_name, p_name, temp_name, td_name) + else: + display.plot_from_spd_and_dir(spd_name, dir_name, p_name, temp_name, td_name) + + # Plot the hodograph + display.plot_hodograph( + spd_name, + dir_name, + set_axes=axs['b'], + color_field=color_field, + component_range=component_range, + dsname=dsname, + uv_flag=uv_flag, + ) + + # Add Stability information + display.add_stability_info( + set_axes=axs['c'], + temp_name=temp_name, + td_name=td_name, + p_name=p_name, + overwrite_data=overwrite_data, + add_data=add_data, + dsname=dsname, + ) + return self.axes diff --git a/act/plotting/TimeSeriesDisplay.py b/act/plotting/timeseriesdisplay.py similarity index 52% rename from act/plotting/TimeSeriesDisplay.py rename to act/plotting/timeseriesdisplay.py index f1d9b82643..70aee57dce 100644 --- a/act/plotting/TimeSeriesDisplay.py +++ b/act/plotting/timeseriesdisplay.py @@ -1,31 +1,29 @@ """ -act.plotting.TimeSeriesDisplay ------------------------------- - Stores the class for TimeSeriesDisplay. """ -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd import datetime as dt +import textwrap import warnings +from copy import deepcopy +from re import search, search as re_search -from re import search as re_search +import matplotlib as mpl +import matplotlib.dates as mdates +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd from matplotlib import colors as mplcolors from mpl_toolkits.axes_grid1 import make_axes_locatable +from scipy.interpolate import NearestNDInterpolator -from .plot import Display -# Import Local Libs -from . import common -from ..utils import datetime_utils as dt_utils -from ..utils.datetime_utils import reduce_time_ranges, determine_time_delta from ..qc.qcfilter import parse_bit -from ..utils import data_utils +from ..utils import data_utils, datetime_utils as dt_utils +from ..utils.datetime_utils import determine_time_delta, reduce_time_ranges from ..utils.geo_utils import get_sunrise_sunset_noon -from copy import deepcopy -from scipy.interpolate import NearestNDInterpolator +from . import common +from .plot import Display class TimeSeriesDisplay(Display): @@ -41,9 +39,8 @@ class TimeSeriesDisplay(Display): .. code-block:: python - ds = act.read_netcdf(the_file) - disp = act.plotting.TimeSeriesDisplay( - ds, subplot_shape=(3,), figsize=(15,5)) + ds = act.io.read_arm_netcdf(the_file) + disp = act.plotting.TimeSeriesDisplay(ds, subplot_shape=(3,), figsize=(15, 5)) The TimeSeriesDisplay constructor takes in the same keyword arguments as plt.subplots. For more information on the plt.subplots keyword arguments, @@ -53,10 +50,11 @@ class TimeSeriesDisplay(Display): until add_subplots or plots is called. """ - def __init__(self, obj, subplot_shape=(1,), ds_name=None, **kwargs): - super().__init__(obj, subplot_shape, ds_name, **kwargs) - def day_night_background(self, dsname=None, subplot_index=(0, )): + def __init__(self, ds, subplot_shape=(1,), ds_name=None, **kwargs): + super().__init__(ds, subplot_shape, ds_name, **kwargs) + + def day_night_background(self, dsname=None, subplot_index=(0,)): """ Colorcodes the background according to sunrise/sunset. @@ -70,41 +68,36 @@ def day_night_background(self, dsname=None, subplot_index=(0, )): subplot_index : 1 or 2D tuple, list, or array The index to the subplot to place the day and night background in. - Returns - ------- - None - """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream to derive the " + - "information needed for the day and night " + - "background when 2 or more datasets are in " + - "the display object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream to derive the ' + + 'information needed for the day and night ' + + 'background when 2 or more datasets are in ' + + 'the display object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] # Get File Dates try: - file_dates = self._arm[dsname].attrs['_file_dates'] + file_dates = self._ds[dsname].attrs['_file_dates'] except KeyError: file_dates = [] if len(file_dates) == 0: - sdate = dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0]) - edate = dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[-1]) + sdate = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]) + edate = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[-1]) file_dates = [sdate, edate] all_dates = dt_utils.dates_between(file_dates[0], file_dates[-1]) if self.axes is None: - raise RuntimeError("day_night_background requires the plot to " - "be displayed.") + raise RuntimeError('day_night_background requires the plot to ' 'be displayed.') ax = self.axes[subplot_index] # Find variable names for latitude and longitude - variables = list(self._arm[dsname].data_vars) + variables = list(self._ds[dsname].data_vars) lat_name = [var for var in ['lat', 'latitude'] if var in variables] lon_name = [var for var in ['lon', 'longitude'] if var in variables] if len(lat_name) == 0: @@ -121,13 +114,13 @@ def day_night_background(self, dsname=None, subplot_index=(0, )): if lat_name is None or lon_name is None: for var in variables: try: - if self._arm[dsname][var].attrs['standard_name'] == 'latitude': + if self._ds[dsname][var].attrs['standard_name'] == 'latitude': lat_name = var except KeyError: pass try: - if self._arm[dsname][var].attrs['standard_name'] == 'longitude': + if self._ds[dsname][var].attrs['standard_name'] == 'longitude': lon_name = var except KeyError: pass @@ -138,51 +131,51 @@ def day_night_background(self, dsname=None, subplot_index=(0, )): if lat_name is None or lon_name is None: return - try: - if self._arm[dsname][lat_name].data.size > 1: - # Look for non-NaN values to use for locaiton. If not found use first value. - lat = self._arm[dsname][lat_name].values - index = np.where(np.isfinite(lat))[0] - if index.size == 0: - index = [0] - lat = float(lat[index[0]]) - # Look for non-NaN values to use for locaiton. If not found use first value. - lon = self._arm[dsname][lon_name].values - index = np.where(np.isfinite(lon))[0] - if index.size == 0: - index = [0] - lon = float(lon[index[0]]) - else: - lat = float(self._arm[dsname][lat_name].values) - lon = float(self._arm[dsname][lon_name].values) - except AttributeError: - return + # Extract latitude and longitude scalar from variable. If variable is a vector look + # for first non-Nan value. + lat_lon_list = [np.nan, np.nan] + for ii, var_name in enumerate([lat_name, lon_name]): + try: + values = self._ds[dsname][var_name].values + if values.size == 1: + lat_lon_list[ii] = float(values) + else: + # Look for non-NaN values to use for latitude locaiton. If not found use first value. + index = np.where(np.isfinite(values))[0] + if index.size == 0: + lat_lon_list[ii] = float(values[0]) + else: + lat_lon_list[ii] = float(values[index[0]]) + except AttributeError: + pass - if not np.isfinite(lat): - warnings.warn(f"Latitude value in dataset of '{lat}' is not finite. ", - RuntimeWarning) - return + for value, name in zip(lat_lon_list, ['Latitude', 'Longitude']): + if not np.isfinite(value): + warnings.warn(f"{name} value in dataset equal to '{value}' is not finite. ", RuntimeWarning) + return - if not np.isfinite(lon): - warnings.warn(f"Longitude value in dataset of '{lon}' is not finite. ", - RuntimeWarning) - return + lat = lat_lon_list[0] + lon = lat_lon_list[1] lat_range = [-90, 90] if not (lat_range[0] <= lat <= lat_range[1]): - warnings.warn(f"Latitude value in dataset of '{lat}' not within acceptable " - f"range of {lat_range[0]} <= latitude <= {lat_range[1]}. ", - RuntimeWarning) + warnings.warn( + f"Latitude value in dataset of '{lat}' not within acceptable " + f'range of {lat_range[0]} <= latitude <= {lat_range[1]}. ', + RuntimeWarning, + ) return lon_range = [-180, 180] if not (lon_range[0] <= lon <= lon_range[1]): - warnings.warn(f"Longitude value in dataset of '{lon}' not within acceptable " - f"range of {lon_range[0]} <= longitude <= {lon_range[1]}. ", - RuntimeWarning) + warnings.warn( + f"Longitude value in dataset of '{lon}' not within acceptable " + f'range of {lon_range[0]} <= longitude <= {lon_range[1]}. ', + RuntimeWarning, + ) return - # initialize the plot to a gray background for total darkness + # Initialize the plot to a gray background for total darkness rect = ax.patch rect.set_facecolor('0.85') @@ -203,7 +196,7 @@ def day_night_background(self, dsname=None, subplot_index=(0, )): for ii in noon: ax.axvline(x=ii, linestyle='--', color='y', zorder=1) - def set_xrng(self, xrng, subplot_index=(0, )): + def set_xrng(self, xrng, subplot_index=(0, 0)): """ Sets the x range of the plot. @@ -216,21 +209,39 @@ def set_xrng(self, xrng, subplot_index=(0, )): """ if self.axes is None: - raise RuntimeError("set_xrng requires the plot to be displayed.") - - if not hasattr(self, 'xrng') and len(self.axes.shape) == 2: - self.xrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2), - dtype='datetime64[D]') - elif not hasattr(self, 'xrng') and len(self.axes.shape) == 1: - self.xrng = np.zeros((self.axes.shape[0], 2), - dtype='datetime64[D]') - - with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=UserWarning) - self.axes[subplot_index].set_xlim(xrng) - self.xrng[subplot_index, :] = np.array(xrng, dtype='datetime64[D]') + raise RuntimeError('set_xrng requires the plot to be displayed.') + + # If the xlim is set to the same value for range it will throw a warning + # This is to catch that and expand the range so we avoid the warning. + if xrng[0] == xrng[1]: + if isinstance(xrng[0], np.datetime64): + print(f'\nAttempting to set xlim range to single value {xrng[0]}. ' + 'Expanding range by 2 seconds.\n') + xrng[0] -= np.timedelta64(1, 's') + xrng[1] += np.timedelta64(1, 's') + elif isinstance(xrng[0], dt.datetime): + print(f'\nAttempting to set xlim range to single value {xrng[0]}. ' + 'Expanding range by 2 seconds.\n') + xrng[0] -= dt.timedelta(seconds=1) + xrng[1] += dt.timedelta(seconds=1) + self.axes[subplot_index].set_xlim(xrng) + + # Make sure that the xrng value is a numpy array not pandas + if isinstance(xrng[0], pd.Timestamp): + xrng = [x.to_numpy() for x in xrng if isinstance(x, pd.Timestamp)] + + # Make sure that the xrng value is a numpy array not datetime.datetime + if isinstance(xrng[0], dt.datetime): + xrng = [np.datetime64(x) for x in xrng if isinstance(x, dt.datetime)] + + if len(subplot_index) < 2: + self.xrng[subplot_index, 0] = xrng[0].astype('datetime64[D]').astype(float) + self.xrng[subplot_index, 1] = xrng[1].astype('datetime64[D]').astype(float) + else: + self.xrng[subplot_index][0] = xrng[0].astype('datetime64[D]').astype(float) + self.xrng[subplot_index][1] = xrng[1].astype('datetime64[D]').astype(float) - def set_yrng(self, yrng, subplot_index=(0, )): + def set_yrng(self, yrng, subplot_index=(0,), match_axes_ylimits=False): """ Sets the y range of the plot. @@ -239,11 +250,16 @@ def set_yrng(self, yrng, subplot_index=(0, )): yrng : 2 number array The y limits of the plot. subplot_index : 1 or 2D tuple, list, or array - The index of the subplot to set the x range of. + The index of the subplot to set the y range of. This is + ignored if match_axes_ylimits is True. + match_axes_ylimits : boolean + If True, all axes in the display object will have matching + provided ylims. Default is False. This is especially useful + when utilizing a groupby display with many axes. """ if self.axes is None: - raise RuntimeError("set_yrng requires the plot to be displayed.") + raise RuntimeError('set_yrng requires the plot to be displayed.') if not hasattr(self, 'yrng') and len(self.axes.shape) == 2: self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2)) @@ -253,27 +269,61 @@ def set_yrng(self, yrng, subplot_index=(0, )): if yrng[0] == yrng[1]: yrng[1] = yrng[1] + 1 - self.axes[subplot_index].set_ylim(yrng) - self.yrng[subplot_index, :] = yrng - - def plot(self, field, dsname=None, subplot_index=(0, ), - cmap=None, set_title=None, - add_nan=False, day_night_background=False, - invert_y_axis=False, abs_limits=(None, None), time_rng=None, - y_rng=None, use_var_for_y=None, - assessment_overplot=False, - overplot_marker='.', - overplot_behind=False, - overplot_markersize=6, - assessment_overplot_category={'Incorrect': ['Bad', 'Incorrect'], - 'Suspect': ['Indeterminate', 'Suspect']}, - assessment_overplot_category_color={'Incorrect': 'red', 'Suspect': 'orange'}, - force_line_plot=False, labels=False, cbar_label=None, secondary_y=False, - **kwargs): + # Sets all axes ylims to the same values. + if match_axes_ylimits: + for i in range(self.axes.shape[0]): + for j in range(self.axes.shape[1]): + self.axes[i, j].set_ylim(yrng) + else: + self.axes[subplot_index].set_ylim(yrng) + + try: + self.yrng[subplot_index, :] = yrng + except IndexError: + self.yrng[subplot_index] = yrng + + def plot( + self, + field, + dsname=None, + subplot_index=(0,), + cmap=None, + set_title=None, + add_nan=False, + day_night_background=False, + invert_y_axis=False, + abs_limits=(None, None), + time_rng=None, + y_rng=None, + use_var_for_y=None, + set_shading='auto', + assessment_overplot=False, + overplot_marker='.', + overplot_behind=False, + overplot_markersize=6, + assessment_overplot_category={ + 'Incorrect': ['Bad', 'Incorrect'], + 'Suspect': ['Indeterminate', 'Suspect'], + }, + assessment_overplot_category_color={'Incorrect': 'red', 'Suspect': 'orange'}, + force_line_plot=False, + labels=False, + cbar_label=None, + cbar_h_adjust=None, + y_axis_flag_meanings=False, + colorbar_labels=None, + cb_friendly=False, + match_line_label_color=False, + **kwargs, + ): """ Makes a timeseries plot. If subplots have not been added yet, an axis will be created assuming that there is only going to be one plot. + If plotting a high data volume 2D dataset, it may take some time to plot. + In order to speed up your plot creation, please resample your data to a + lower resolution dataset. + Parameters ---------- field : str @@ -309,6 +359,9 @@ def plot(self, field, dsname=None, subplot_index=(0, ), instances where data has an index-based dimension instead of a height-based dimension. If shapes of arrays do not match it will automatically revert back to the original ydata. + set_shading : string + Option to to set the matplotlib.pcolormesh shading parameter. + Default to 'auto' assessment_overplot : boolean Option to overplot quality control colored symbols over plotted data using flag_assessment categories. @@ -333,8 +386,31 @@ def plot(self, field, dsname=None, subplot_index=(0, ), number of lines plotted. cbar_label : str Option to overwrite default colorbar label. - secondary_y : boolean - Option to plot on secondary y axis. + cbar_h_adjust : float + Option to adjust location of colorbar horizontally. Positive values + move to right negative values move to left. + y_axis_flag_meanings : boolean or int + When set to True and plotting state variable with flag_values and + flag_meanings attributes will replace y axis numerical values + with flag_meanings value. Set to a positive number larger than 1 + to indicate maximum word length to use. If text is longer that the + value and has space characters will split text over multiple lines. + colorbar_labels : dict + A dictionary containing values for plotting a 2D array of state variables. + The dictionary uses data values as keys and a dictionary containing keys + 'text' and 'color' for each data value to plot. + + Example: + {0: {'text': 'Clear sky', 'color': 'white'}, + 1: {'text': 'Liquid', 'color': 'green'}, + 2: {'text': 'Ice', 'color': 'blue'}, + 3: {'text': 'Mixed phase', 'color': 'purple'}} + cb_friendly : boolean + Set to true if you want to use the integrated colorblind friendly + colors for green/red based on the Homeyer colormap. + match_line_label_color : boolean + Will set the y label to match the line color in the plot. This + will only work if the time series plot is a line plot. **kwargs : keyword arguments The keyword arguments for :func:`plt.plot` (1D timeseries) or :func:`plt.pcolormesh` (2D timeseries). @@ -345,17 +421,29 @@ def plot(self, field, dsname=None, subplot_index=(0, ), The matplotlib axis handle of the plot. """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] + + if y_axis_flag_meanings: + kwargs['linestyle'] = '' + + if cb_friendly: + cmap = 'HomeyerRainbow' + assessment_overplot_category_color['Bad'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) + assessment_overplot_category_color['Incorrect'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) + assessment_overplot_category_color['Not Failing'] = (0.0, 0.4240129715562796, 0.4240129715562796), + assessment_overplot_category_color['Acceptable'] = (0.0, 0.4240129715562796, 0.4240129715562796), # Get data and dimensions - data = self._arm[dsname][field] - dim = list(self._arm[dsname][field].dims) - xdata = self._arm[dsname][dim[0]] + data = self._ds[dsname][field] + dim = list(self._ds[dsname][field].dims) + xdata = self._ds[dsname][dim[0]] if 'units' in data.attrs: ytitle = ''.join(['(', data.attrs['units'], ')']) @@ -366,10 +454,10 @@ def plot(self, field, dsname=None, subplot_index=(0, ), cbar_default = ytitle if len(dim) > 1: if use_var_for_y is None: - ydata = self._arm[dsname][dim[1]] + ydata = self._ds[dsname][dim[1]] else: - ydata = self._arm[dsname][use_var_for_y] - ydata_dim1 = self._arm[dsname][dim[1]] + ydata = self._ds[dsname][use_var_for_y] + ydata_dim1 = self._ds[dsname][dim[1]] if np.shape(ydata) != np.shape(ydata_dim1): ydata = ydata_dim1 units = ytitle @@ -384,12 +472,17 @@ def plot(self, field, dsname=None, subplot_index=(0, ), if force_line_plot is True: if labels is True: labels = [' '.join([str(d), units]) for d in ydata.values] - ytitle = f"({data.attrs['units']})" + if 'units' in data.attrs.keys(): + units = data.attrs['units'] + ytitle = ''.join(['(', units, ')']) + else: + units = '' + ytitle = dim[1] ydata = None else: ydata = None - # Get the current plotting axis, add day/night background and plot data + # Get the current plotting axis if self.fig is None: self.fig = plt.figure() @@ -397,30 +490,44 @@ def plot(self, field, dsname=None, subplot_index=(0, ), self.axes = np.array([plt.axes()]) self.fig.add_axes(self.axes[0]) - # Set up secondary y axis if requested - if secondary_y is False: - ax = self.axes[subplot_index] + ax = self.axes[subplot_index] + + if colorbar_labels is not None: + flag_values = list(colorbar_labels.keys()) + flag_meanings = [value['text'] for key, value in colorbar_labels.items()] + cbar_colors = [value['color'] for key, value in colorbar_labels.items()] + cmap = mpl.colors.ListedColormap(cbar_colors) + for ii, flag_meaning in enumerate(flag_meanings): + if len(flag_meaning) > 20: + flag_meaning = textwrap.fill(flag_meaning, width=20) + flag_meanings[ii] = flag_meaning else: - ax = self.axes[subplot_index].twinx() + flag_values = None + flag_meanings = None + cbar_colors = None if ydata is None: + # Add in nans to ensure the data does not connect the line. + if add_nan is True: + xdata, data = data_utils.add_in_nan(xdata, data) + if day_night_background is True: self.day_night_background(subplot_index=subplot_index, dsname=dsname) # If limiting data being plotted use masked arrays # Need to do it this way because of autoscale() method if abs_limits[0] is not None and abs_limits[1] is not None: - data = np.ma.masked_outside( - data, abs_limits[0], abs_limits[1]) + data = np.ma.masked_outside(data, abs_limits[0], abs_limits[1]) elif abs_limits[0] is not None and abs_limits[1] is None: - data = np.ma.masked_less_equal( - data, abs_limits[0]) + data = np.ma.masked_less_equal(data, abs_limits[0]) elif abs_limits[0] is None and abs_limits[1] is not None: - data = np.ma.masked_greater_equal( - data, abs_limits[1]) + data = np.ma.masked_greater_equal(data, abs_limits[1]) # Plot the data - lines = ax.plot(xdata, data, '.', **kwargs) + if 'marker' not in kwargs.keys(): + kwargs['marker'] = '.' + + lines = ax.plot(xdata, data, **kwargs) # Check if we need to call legend method after plotting. This is only # called when no assessment overplot is called. @@ -442,17 +549,27 @@ def plot(self, field, dsname=None, subplot_index=(0, ), zorder = None if force_line_plot or overplot_behind: zorder = 0 - overplot_markersize *= 2. + overplot_markersize *= 2.0 for assessment, categories in assessment_overplot_category.items(): - flag_data = self._arm[dsname].qcfilter.get_masked_data( - field, rm_assessments=categories, return_inverse=True) + flag_data = self._ds[dsname].qcfilter.get_masked_data( + field, rm_assessments=categories, return_inverse=True + ) if np.invert(flag_data.mask).any() and np.isfinite(flag_data).any(): + try: + flag_data.mask = np.logical_or(data.mask, flag_data.mask) + except AttributeError: + pass qc_ax = ax.plot( - xdata, flag_data, marker=overplot_marker, linestyle='', + xdata, + flag_data, + marker=overplot_marker, + linestyle='', markersize=overplot_markersize, color=assessment_overplot_category_color[assessment], - label=assessment, zorder=zorder) + label=assessment, + zorder=zorder, + ) # If labels keyword is set need to add labels for calling legend if isinstance(labels, list): # If plotting forced_line_plot need to subset the Line2D object @@ -470,24 +587,68 @@ def plot(self, field, dsname=None, subplot_index=(0, ), elif add_legend: ax.legend() + # Change y axis to text from flag_meanings if requested. + if y_axis_flag_meanings: + flag_meanings = self._ds[dsname][field].attrs['flag_meanings'] + flag_values = self._ds[dsname][field].attrs['flag_values'] + # If keyword is larger than 1 assume this is the maximum character length + # desired and insert returns to wrap text. + if y_axis_flag_meanings > 1: + for ii, flag_meaning in enumerate(flag_meanings): + if len(flag_meaning) > y_axis_flag_meanings: + flag_meaning = textwrap.fill(flag_meaning, width=y_axis_flag_meanings) + flag_meanings[ii] = flag_meaning + + ax.set_yticks(flag_values) + ax.set_yticklabels(flag_meanings) + else: # Add in nans to ensure the data are not streaking if add_nan is True: xdata, data = data_utils.add_in_nan(xdata, data) - mesh = ax.pcolormesh(xdata, ydata, data.transpose(), - cmap=cmap, edgecolors='face', **kwargs) + + # Sets shading parameter to auto. Matplotlib will check deminsions. + # If X,Y and C are same deminsions shading is set to nearest. + # If X and Y deminsions are 1 greater than C shading is set to flat. + if 'edgecolors' not in kwargs.keys(): + kwargs['edgecolors'] = 'face' + mesh = ax.pcolormesh( + np.asarray(xdata), + ydata, + data.transpose(), + shading=set_shading, + cmap=cmap, + **kwargs, + ) # Set Title if set_title is None: - set_title = ' '.join([dsname, field, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) + if isinstance(self._ds[dsname].time.values[0], np.datetime64): + set_title = ' '.join( + [ + dsname, + field, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + else: + date_result = search( + r'\d{4}-\d{1,2}-\d{1,2}', self._ds[dsname].time.attrs['units'] + ) + if date_result is not None: + set_title = ' '.join([dsname, field, 'on', date_result.group(0)]) + else: + set_title = ' '.join([dsname, field]) - if secondary_y is False: - ax.set_title(set_title) + ax.set_title(set_title) # Set YTitle - ax.set_ylabel(ytitle) + if not y_axis_flag_meanings: + if match_line_label_color and len(ax.get_lines()) > 0: + ax.set_ylabel(ytitle, color=ax.get_lines()[0].get_color()) + else: + ax.set_ylabel(ytitle) # Set X Limit - We want the same time axes for all subplots if not hasattr(self, 'time_rng'): @@ -512,36 +673,46 @@ def plot(self, field, dsname=None, subplot_index=(0, ), else: our_data = ydata - if np.isfinite(our_data).any(): + finite = np.isfinite(our_data) + # If finite is returned as DataArray or Dask array extract values. + try: + finite = finite.values + except AttributeError: + pass + + if finite.any(): + our_data = our_data[finite] if invert_y_axis is False: - yrng = [np.nanmin(our_data), np.nanmax(our_data)] + yrng = [np.min(our_data), np.max(our_data)] else: - yrng = [np.nanmax(our_data), np.nanmin(our_data)] + yrng = [np.max(our_data), np.min(our_data)] else: yrng = [0, 1] # Check if current range is outside of new range an only set # values that work for all data plotted. - current_yrng = ax.get_ylim() - - if yrng[0] > current_yrng[0]: - yrng[0] = current_yrng[0] - if yrng[1] < current_yrng[1]: - yrng[1] = current_yrng[1] + if isinstance(yrng[0], np.datetime64): + yrng = mdates.datestr2num([str(yrng[0]), str(yrng[1])]) - # Set y range the normal way if not secondary y - # If secondary, just use set_ylim - if secondary_y is False: - self.set_yrng(yrng, subplot_index) + current_yrng = ax.get_ylim() + if invert_y_axis is False: + if yrng[0] > current_yrng[0]: + yrng[0] = current_yrng[0] + if yrng[1] < current_yrng[1]: + yrng[1] = current_yrng[1] else: - ax.set_ylim(yrng) + if yrng[0] < current_yrng[0]: + yrng[0] = current_yrng[0] + if yrng[1] > current_yrng[1]: + yrng[1] = current_yrng[1] + + self.set_yrng(yrng, subplot_index) # Set X Format if len(subplot_index) == 1: - days = (self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0]) + days = self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0] else: - days = (self.xrng[subplot_index[0], subplot_index[1], 1] - - self.xrng[subplot_index[0], subplot_index[1], 0]) + days = self.xrng[subplot_index][1] - self.xrng[subplot_index][0] myFmt = common.get_date_format(days) ax.xaxis.set_major_formatter(myFmt) @@ -556,15 +727,32 @@ def plot(self, field, dsname=None, subplot_index=(0, ), if ydata is not None: if cbar_label is None: - self.add_colorbar(mesh, title=cbar_default, subplot_index=subplot_index) + cbar_title = cbar_default else: - self.add_colorbar(mesh, title=''.join(['(', cbar_label, ')']), - subplot_index=subplot_index) + cbar_title = ''.join(['(', cbar_label, ')']) + + if colorbar_labels is not None: + cbar_title = None + cbar = self.add_colorbar( + mesh, + title=cbar_title, + subplot_index=subplot_index, + values=flag_values, + pad=cbar_h_adjust, + ) + cbar.set_ticks(flag_values) + cbar.set_ticklabels(flag_meanings) + cbar.ax.tick_params(labelsize=10) + else: + self.add_colorbar( + mesh, title=cbar_title, subplot_index=subplot_index, pad=cbar_h_adjust + ) return ax - def plot_barbs_from_spd_dir(self, dir_field, spd_field, pres_field=None, - dsname=None, **kwargs): + def plot_barbs_from_spd_dir( + self, speed_field, direction_field, pres_field=None, dsname=None, **kwargs + ): """ This procedure will make a wind barb plot timeseries. If a pressure field is given and the wind fields are 1D, which, for @@ -577,12 +765,12 @@ def plot_barbs_from_spd_dir(self, dir_field, spd_field, pres_field=None, Parameters ---------- - dir_field : str + speed_field : str + The name of the field specifying the wind speed in m/s. + direction_field : str The name of the field specifying the wind direction in degrees. 0 degrees is defined to be north and increases clockwise like what is used in standard meteorological notation. - spd_field : str - The name of the field specifying the wind speed in m/s. pres_field : str The name of the field specifying pressure or height. If using height coordinates, then we recommend setting invert_y_axis @@ -603,7 +791,7 @@ def plot_barbs_from_spd_dir(self, dir_field, spd_field, pres_field=None, -------- ..code-block :: python - sonde_ds = act.io.armfiles.read_netcdf( + sonde_ds = act.io.arm.read_arm_netcdf( act.tests.sample_files.EXAMPLE_TWP_SONDE_WILDCARD) BarbDisplay = act.plotting.TimeSeriesDisplay( {'sonde_darwin': sonde_ds}, figsize=(10,5)) @@ -611,34 +799,43 @@ def plot_barbs_from_spd_dir(self, dir_field, spd_field, pres_field=None, num_barbs_x=20) """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] # Make temporary field called tempu, tempv - spd = self._arm[dsname][spd_field] - dir = self._arm[dsname][dir_field] + spd = self._ds[dsname][speed_field] + dir = self._ds[dsname][direction_field] tempu = -np.sin(np.deg2rad(dir)) * spd tempv = -np.cos(np.deg2rad(dir)) * spd - self._arm[dsname]["temp_u"] = deepcopy(self._arm[dsname][spd_field]) - self._arm[dsname]["temp_v"] = deepcopy(self._arm[dsname][spd_field]) - self._arm[dsname]["temp_u"].values = tempu - self._arm[dsname]["temp_v"].values = tempv - the_ax = self.plot_barbs_from_u_v("temp_u", "temp_v", pres_field, - dsname, **kwargs) - del self._arm[dsname]["temp_u"], self._arm[dsname]["temp_v"] + self._ds[dsname]['temp_u'] = deepcopy(self._ds[dsname][speed_field]) + self._ds[dsname]['temp_v'] = deepcopy(self._ds[dsname][speed_field]) + self._ds[dsname]['temp_u'].values = tempu + self._ds[dsname]['temp_v'].values = tempv + the_ax = self.plot_barbs_from_u_v('temp_u', 'temp_v', pres_field, dsname, **kwargs) + del self._ds[dsname]['temp_u'], self._ds[dsname]['temp_v'] return the_ax - def plot_barbs_from_u_v(self, u_field, v_field, pres_field=None, - dsname=None, subplot_index=(0, ), - set_title=None, - day_night_background=False, - invert_y_axis=True, - num_barbs_x=20, num_barbs_y=20, - use_var_for_y=None, **kwargs): + def plot_barbs_from_u_v( + self, + u_field, + v_field, + pres_field=None, + dsname=None, + subplot_index=(0,), + set_title=None, + day_night_background=False, + invert_y_axis=True, + num_barbs_x=20, + num_barbs_y=20, + use_var_for_y=None, + **kwargs, + ): """ This function will plot a wind barb timeseries from u and v wind data. If pres_field is given, a time-height series will be plotted @@ -691,18 +888,20 @@ def plot_barbs_from_u_v(self, u_field, v_field, pres_field=None, constructed plot. """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] # Get data and dimensions - u = self._arm[dsname][u_field].values - v = self._arm[dsname][v_field].values - dim = list(self._arm[dsname][u_field].dims) - xdata = self._arm[dsname][dim[0]].values + u = self._ds[dsname][u_field].values + v = self._ds[dsname][v_field].values + dim = list(self._ds[dsname][u_field].dims) + xdata = self._ds[dsname][dim[0]].values num_x = xdata.shape[-1] barb_step_x = round(num_x / num_barbs_x) if barb_step_x == 0: @@ -710,10 +909,10 @@ def plot_barbs_from_u_v(self, u_field, v_field, pres_field=None, if len(dim) > 1 and pres_field is None: if use_var_for_y is None: - ydata = self._arm[dsname][dim[1]] + ydata = self._ds[dsname][dim[1]] else: - ydata = self._arm[dsname][use_var_for_y] - ydata_dim1 = self._arm[dsname][dim[1]] + ydata = self._ds[dsname][use_var_for_y] + ydata_dim1 = self._ds[dsname][dim[1]] if np.shape(ydata) != np.shape(ydata_dim1): ydata = ydata_dim1 if 'units' in ydata.attrs: @@ -730,20 +929,16 @@ def plot_barbs_from_u_v(self, u_field, v_field, pres_field=None, elif pres_field is not None: # What we will do here is do a nearest-neighbor interpolation # for each member of the series. Coordinates are time, pressure - pres = self._arm[dsname][pres_field] - u_interp = NearestNDInterpolator( - (xdata, pres.values), u, rescale=True) - v_interp = NearestNDInterpolator( - (xdata, pres.values), v, rescale=True) + pres = self._ds[dsname][pres_field] + u_interp = NearestNDInterpolator((xdata, pres.values), u, rescale=True) + v_interp = NearestNDInterpolator((xdata, pres.values), v, rescale=True) barb_step_x = 1 barb_step_y = 1 - x_times = pd.date_range(xdata.min(), xdata.max(), - periods=num_barbs_x) + x_times = pd.date_range(xdata.min(), xdata.max(), periods=num_barbs_x) if num_barbs_y == 1: y_levels = pres.mean() else: - y_levels = np.linspace(np.nanmin(pres), np.nanmax(pres), - num_barbs_y) + y_levels = np.linspace(np.nanmin(pres), np.nanmax(pres), num_barbs_y) xdata, ydata = np.meshgrid(x_times, y_levels, indexing='ij') u = u_interp(xdata, ydata) v = v_interp(xdata, ydata) @@ -759,69 +954,89 @@ def plot_barbs_from_u_v(self, u_field, v_field, pres_field=None, if self.fig is None: self.fig = plt.figure() + # Set up or get current axes if self.axes is None: self.axes = np.array([plt.axes()]) self.fig.add_axes(self.axes[0]) + ax = self.axes[subplot_index] + if ydata is None: ydata = np.ones(xdata.shape) if 'cmap' in kwargs.keys(): - map_color = np.sqrt(np.power(u[::barb_step_x], 2) + - np.power(v[::barb_step_x], 2)) + map_color = np.sqrt(np.power(u[::barb_step_x], 2) + np.power(v[::barb_step_x], 2)) map_color[np.isnan(map_color)] = 0 - ax = self.axes[subplot_index].barbs(xdata[::barb_step_x], - ydata[::barb_step_x], - u[::barb_step_x], - v[::barb_step_x], map_color, - **kwargs) - plt.colorbar(ax, ax=[self.axes[subplot_index]], - label='Wind Speed (' + - self._arm[dsname][u_field].attrs['units'] + ')') + barbs = ax.barbs( + xdata[::barb_step_x], + ydata[::barb_step_x], + u[::barb_step_x], + v[::barb_step_x], + map_color, + **kwargs, + ) + plt.colorbar( + barbs, + ax=[ax], + label='Wind Speed (' + self._ds[dsname][u_field].attrs['units'] + ')', + ) else: - self.axes[subplot_index].barbs(xdata[::barb_step_x], - ydata[::barb_step_x], - u[::barb_step_x], - v[::barb_step_x], - **kwargs) - self.axes[subplot_index].set_yticks([]) + ax.barbs( + xdata[::barb_step_x], + ydata[::barb_step_x], + u[::barb_step_x], + v[::barb_step_x], + **kwargs, + ) + ax.set_yticks([]) else: if 'cmap' in kwargs.keys(): - map_color = np.sqrt(np.power(u[::barb_step_x, ::barb_step_y], 2) + - np.power(v[::barb_step_x, ::barb_step_y], 2)) + map_color = np.sqrt( + np.power(u[::barb_step_x, ::barb_step_y], 2) + + np.power(v[::barb_step_x, ::barb_step_y], 2) + ) map_color[np.isnan(map_color)] = 0 - ax = self.axes[subplot_index].barbs( + barbs = ax.barbs( xdata[::barb_step_x, ::barb_step_y], ydata[::barb_step_x, ::barb_step_y], u[::barb_step_x, ::barb_step_y], - v[::barb_step_x, ::barb_step_y], map_color, - **kwargs) - plt.colorbar(ax, ax=[self.axes[subplot_index]], - label='Wind Speed (' + - self._arm[dsname][u_field].attrs['units'] + ')') + v[::barb_step_x, ::barb_step_y], + map_color, + **kwargs, + ) + plt.colorbar( + barbs, + ax=[ax], + label='Wind Speed (' + self._ds[dsname][u_field].attrs['units'] + ')', + ) else: - ax = self.axes[subplot_index].barbs( + barbs = ax.barbs( xdata[::barb_step_x, ::barb_step_y], ydata[::barb_step_x, ::barb_step_y], u[::barb_step_x, ::barb_step_y], v[::barb_step_x, ::barb_step_y], - **kwargs) + **kwargs, + ) if day_night_background is True: self.day_night_background(subplot_index=subplot_index, dsname=dsname) # Set Title if set_title is None: - set_title = ' '.join([dsname, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) + set_title = ' '.join( + [ + dsname, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) - self.axes[subplot_index].set_title(set_title) + ax.set_title(set_title) # Set YTitle if 'ytitle' in locals(): - self.axes[subplot_index].set_ylabel(ytitle) + ax.set_ylabel(ytitle) # Set X Limit - We want the same time axes for all subplots time_rng = [xdata.min(), xdata.max()] @@ -849,24 +1064,38 @@ def plot_barbs_from_u_v(self, u_field, v_field, pres_field=None, # Set X Format if len(subplot_index) == 1: - days = (self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0]) + days = self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0] else: - days = (self.xrng[subplot_index[0], subplot_index[1], 1] - - self.xrng[subplot_index[0], subplot_index[1], 0]) + days = ( + self.xrng[subplot_index[0], subplot_index[1], 1] + - self.xrng[subplot_index[0], subplot_index[1], 0] + ) # Put on an xlabel, but only if we are making the bottom-most plot if subplot_index[0] == self.axes.shape[0] - 1: - self.axes[subplot_index].set_xlabel('Time [UTC]') + ax.set_xlabel('Time [UTC]') myFmt = common.get_date_format(days) - self.axes[subplot_index].xaxis.set_major_formatter(myFmt) + ax.xaxis.set_major_formatter(myFmt) + self.axes[subplot_index] = ax + return self.axes[subplot_index] def plot_time_height_xsection_from_1d_data( - self, data_field, pres_field, dsname=None, subplot_index=(0, ), - set_title=None, day_night_background=False, num_time_periods=20, - num_y_levels=20, invert_y_axis=True, cbar_label=None, - **kwargs): + self, + data_field, + pres_field, + dsname=None, + subplot_index=(0,), + set_title=None, + day_night_background=False, + num_time_periods=20, + num_y_levels=20, + invert_y_axis=True, + cbar_label=None, + set_shading='auto', + **kwargs, + ): """ This will plot a time-height cross section from 1D datasets using nearest neighbor interpolation on a regular time by height grid. @@ -896,6 +1125,9 @@ def plot_time_height_xsection_from_1d_data( pressure coordinates). cbar_label : str Option to overwrite default colorbar label. + set_shading : string + Option to to set the matplotlib.pcolormesh shading parameter. + Default to 'auto' **kwargs : keyword arguments Additional keyword arguments will be passed into :func:`plt.pcolormesh` @@ -906,49 +1138,54 @@ def plot_time_height_xsection_from_1d_data( The matplotlib axis handle pointing to the plot. """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2" - "or more datasets in the TimeSeriesDisplay" - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2' + 'or more datasets in the TimeSeriesDisplay' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] - dim = list(self._arm[dsname][data_field].dims) + dim = list(self._ds[dsname][data_field].dims) if len(dim) > 1: - raise ValueError(("plot_time_height_xsection_from_1d_data only " - "supports 1-D datasets. For datasets with 2 or " - "more dimensions use plot().")) + raise ValueError( + 'plot_time_height_xsection_from_1d_data only ' + 'supports 1-D datasets. For datasets with 2 or ' + 'more dimensions use plot().' + ) # Get data and dimensions - data = self._arm[dsname][data_field].values - xdata = self._arm[dsname][dim[0]].values + data = self._ds[dsname][data_field].values + xdata = self._ds[dsname][dim[0]].values # What we will do here is do a nearest-neighbor interpolation for each # member of the series. Coordinates are time, pressure - pres = self._arm[dsname][pres_field] - u_interp = NearestNDInterpolator( - (xdata, pres.values), data, rescale=True) + pres = self._ds[dsname][pres_field] + u_interp = NearestNDInterpolator((xdata, pres.values), data, rescale=True) # Mask points where we have no data # Count number of unique days - x_times = pd.date_range(xdata.min(), xdata.max(), - periods=num_time_periods) + x_times = pd.date_range(xdata.min(), xdata.max(), periods=num_time_periods) y_levels = np.linspace(np.nanmin(pres), np.nanmax(pres), num_y_levels) tdata, ydata = np.meshgrid(x_times, y_levels, indexing='ij') data = u_interp(tdata, ydata) ytitle = ''.join(['(', pres.attrs['units'], ')']) - units = (data_field + ' (' + - self._arm[dsname][data_field].attrs['units'] + ')') + units = data_field + ' (' + self._ds[dsname][data_field].attrs['units'] + ')' # Get the current plotting axis, add day/night background and plot data if self.fig is None: self.fig = plt.figure() + # Set up or get current axes if self.axes is None: self.axes = np.array([plt.axes()]) self.fig.add_axes(self.axes[0]) - mesh = self.axes[subplot_index].pcolormesh( - x_times, y_levels, np.transpose(data), **kwargs) + ax = self.axes[subplot_index] + + mesh = ax.pcolormesh( + x_times, y_levels, np.transpose(data), shading=set_shading, **kwargs + ) if day_night_background is True: self.day_night_background(subplot_index=subplot_index, dsname=dsname) @@ -956,17 +1193,21 @@ def plot_time_height_xsection_from_1d_data( # Set Title if set_title is None: set_title = ' '.join( - [dsname, 'on', - dt_utils.numpy_to_arm_date(self._arm[dsname].time.values[0])]) + [ + dsname, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) - self.axes[subplot_index].set_title(set_title) + ax.set_title(set_title) # Set YTitle if 'ytitle' in locals(): - self.axes[subplot_index].set_ylabel(ytitle) + ax.set_ylabel(ytitle) # Set X Limit - We want the same time axes for all subplots - time_rng = [x_times[-1], x_times[0]] + time_rng = [x_times[0], x_times[-1]] self.set_xrng(time_rng, subplot_index) @@ -991,14 +1232,16 @@ def plot_time_height_xsection_from_1d_data( # Set X Format if len(subplot_index) == 1: - days = (self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0]) + days = self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0] else: - days = (self.xrng[subplot_index[0], subplot_index[1], 1] - - self.xrng[subplot_index[0], subplot_index[1], 0]) + days = ( + self.xrng[subplot_index[0], subplot_index[1], 1] + - self.xrng[subplot_index[0], subplot_index[1], 0] + ) # Put on an xlabel, but only if we are making the bottom-most plot if subplot_index[0] == self.axes.shape[0] - 1: - self.axes[subplot_index].set_xlabel('Time [UTC]') + ax.set_xlabel('Time [UTC]') if ydata is not None: if cbar_label is None: @@ -1006,13 +1249,25 @@ def plot_time_height_xsection_from_1d_data( else: self.add_colorbar(mesh, title=cbar_label, subplot_index=subplot_index) myFmt = common.get_date_format(days) - self.axes[subplot_index].xaxis.set_major_formatter(myFmt) + ax.xaxis.set_major_formatter(myFmt) return self.axes[subplot_index] def time_height_scatter( - self, data_field=None, dsname=None, cmap='rainbow', - alt_label=None, alt_field='alt', cb_label=None, **kwargs): + self, + data_field=None, + alt_field='alt', + dsname=None, + cmap='rainbow', + alt_label=None, + cb_label=None, + subplot_index=(0,), + plot_alt_field=False, + cb_friendly=False, + day_night_background=False, + set_title=None, + **kwargs, + ): """ Create a time series plot of altitude and data variable with color also indicating value with a color bar. The Color bar is @@ -1022,9 +1277,9 @@ def time_height_scatter( Parameters ---------- data_field : str - Name of data field in the object to plot on second y-axis. - height_field : str - Name of height field in the object to plot on first y-axis. + Name of data field in the dataset to plot on second y-axis. + alt_field : str + Variable to use for y-axis. dsname : str or None The name of the datastream to plot. cmap : str @@ -1032,66 +1287,145 @@ def time_height_scatter( alt_label : str Altitude first y-axis label to use. If None, will try to use long_name and units. - alt_field : str - Label for field in the object to plot on first y-axis. cb_label : str Colorbar label to use. If not set will try to use long_name and units. + subplot_index : 1 or 2D tuple, list, or array + The index of the subplot to set the x range of. + plot_alt_field : boolean + Set to true to plot the altitude field on the secondary y-axis + cb_friendly : boolean + If set to True will use the Homeyer colormap + day_night_background : boolean + If set to True will plot the day_night_background + set_title : str + Title to set on the plot **kwargs : keyword arguments Any other keyword arguments that will be passed into TimeSeriesDisplay.plot module when the figure is made. """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] + + # Set up or get current plot figure + if self.fig is None: + self.fig = plt.figure() + + # Set up or get current axes + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + if cb_friendly: + cmap = 'HomeyerRainbow' + + ax = self.axes[subplot_index] # Get data and dimensions - data = self._arm[dsname][data_field] - altitude = self._arm[dsname][alt_field] - dim = list(self._arm[dsname][data_field].dims) - xdata = self._arm[dsname][dim[0]] + data = self._ds[dsname][data_field] + altitude = self._ds[dsname][alt_field] + dim = list(self._ds[dsname][data_field].dims) + xdata = self._ds[dsname][dim[0]] if alt_label is None: try: - alt_label = (altitude.attrs['long_name'] + - ''.join([' (', altitude.attrs['units'], ')'])) + alt_label = altitude.attrs['long_name'] + ''.join( + [' (', altitude.attrs['units'], ')'] + ) except KeyError: alt_label = alt_field if cb_label is None: try: - cb_label = (data.attrs['long_name'] + - ''.join([' (', data.attrs['units'], ')'])) + cb_label = data.attrs['long_name'] + ''.join([' (', data.attrs['units'], ')']) except KeyError: cb_label = data_field - colorbar_map = plt.cm.get_cmap(cmap) - self.fig.subplots_adjust(left=0.1, right=0.86, - bottom=0.16, top=0.91) - ax1 = self.plot(alt_field, color='black', **kwargs) - ax1.set_ylabel(alt_label) - ax2 = ax1.twinx() - sc = ax2.scatter(xdata.values, data.values, c=data.values, - marker='.', cmap=colorbar_map) - cbaxes = self.fig.add_axes( - [self.fig.subplotpars.right + 0.02, self.fig.subplotpars.bottom, - 0.02, self.fig.subplotpars.top - self.fig.subplotpars.bottom]) - cbar = plt.colorbar(sc, cax=cbaxes) - ax2.set_ylim(cbar.mappable.get_clim()) + if 'units' in data.attrs: + ytitle = ''.join(['(', data.attrs['units'], ')']) + else: + ytitle = data_field + + # Set Title + if set_title is None: + if isinstance(self._ds[dsname].time.values[0], np.datetime64): + set_title = ' '.join( + [ + dsname, + data_field, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + else: + date_result = search( + r'\d{4}-\d{1,2}-\d{1,2}', self._ds[dsname].time.attrs['units'] + ) + if date_result is not None: + set_title = ' '.join([dsname, data_field, 'on', date_result.group(0)]) + else: + set_title = ' '.join([dsname, data_field]) + + # Plot scatter data + sc = ax.scatter(xdata.values, data.values, c=data.values, cmap=cmap, **kwargs) + + ax.set_title(set_title) + if plot_alt_field: + self.fig.subplots_adjust(left=0.1, right=0.8, bottom=0.15, top=0.925) + pad = 0.02 + (0.02 * len(str(int(np.nanmax(altitude.values))))) + cbar = self.fig.colorbar(sc, pad=pad, cmap=cmap) + + ax2 = ax.twinx() + ax2.set_ylabel(alt_label) + ax2.scatter(xdata.values, altitude.values, color='black') + else: + cbar = self.fig.colorbar(sc, cmap=cmap) + + if day_night_background is True: + self.day_night_background(subplot_index=subplot_index, dsname=dsname) cbar.ax.set_ylabel(cb_label) - ax2.set_yticklabels([]) - return self.axes[0] + # Set X Limit - We want the same time axes for all subplots + self.time_rng = [xdata.min().values, xdata.max().values] + self.set_xrng(self.time_rng, subplot_index) + + # Set X Format + if len(subplot_index) == 1: + days = self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0] + else: + days = ( + self.xrng[subplot_index[0], subplot_index[1], 1] + - self.xrng[subplot_index[0], subplot_index[1], 0] + ) + myFmt = common.get_date_format(days) + ax.xaxis.set_major_formatter(myFmt) + ax.set_xlabel('Time (UTC)') + ax.set_ylabel(ytitle) + + self.axes[subplot_index] = ax + + return self.axes[subplot_index] def qc_flag_block_plot( - self, data_field=None, dsname=None, - subplot_index=(0, ), time_rng=None, assessment_color=None, - edgecolor='face', **kwargs): + self, + data_field=None, + dsname=None, + subplot_index=(0,), + time_rng=None, + assessment_color=None, + edgecolor='face', + set_shading='auto', + cb_friendly=False, + **kwargs, + ): """ Create a time series plot of embedded quality control values using broken barh plotting. @@ -1099,7 +1433,7 @@ def qc_flag_block_plot( Parameters ---------- data_field : str - Name of data field in the object to plot corresponding quality + Name of data field in the dataset to plot corresponding quality control. dsname : None or str If there is more than one datastream in the display object the @@ -1113,18 +1447,36 @@ def qc_flag_block_plot( assessment_color : dict Dictionary lookup to override default assessment to color. Make sure assessment work is correctly set with case syntax. + edgecolor : str or list + Color name, list of color names or 'face' as defined in matplotlib.axes.Axes.broken_barh + set_shading : string + Option to to set the matplotlib.pcolormesh shading parameter. + Default to 'auto' + cb_friendly : boolean + Set to true if you want to use the integrated colorblind friendly + colors for green/red based on the Homeyer colormap **kwargs : keyword arguments The keyword arguments for :func:`plt.broken_barh`. """ # Color to plot associated with assessment. - color_lookup = {'Bad': 'red', - 'Incorrect': 'red', - 'Indeterminate': 'orange', - 'Suspect': 'orange', - 'Missing': 'darkgray', - 'Not Failing': 'green', - 'Acceptable': 'green'} + color_lookup = { + 'Bad': 'red', + 'Incorrect': 'red', + 'Indeterminate': 'orange', + 'Suspect': 'orange', + 'Missing': 'darkgray', + 'Not Failing': 'green', + 'Acceptable': 'green', + } + if cb_friendly: + color_lookup['Bad'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) + color_lookup['Incorrect'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) + color_lookup['Not Failing'] = (0.0, 0.4240129715562796, 0.4240129715562796) + color_lookup['Acceptable'] = (0.0, 0.4240129715562796, 0.4240129715562796) + color_lookup['Indeterminate'] = (1.0, 0.6470588235294118, 0.0) + color_lookup['Suspect'] = (1.0, 0.6470588235294118, 0.0) + color_lookup['Missing'] = (0.6627450980392157, 0.6627450980392157, 0.6627450980392157) if assessment_color is not None: for asses, color in assessment_color.items(): @@ -1135,17 +1487,21 @@ def qc_flag_block_plot( color_lookup['Indeterminate'] = color # Set up list of test names to use for missing values - missing_val_long_names = ['Value equal to missing_value*', - 'Value set to missing_value*', - 'Value is equal to missing_value*', - 'Value is set to missing_value*'] - - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) + missing_val_long_names = [ + 'Value equal to missing_value*', + 'Value set to missing_value*', + 'Value is equal to missing_value*', + 'Value is set to missing_value*', + ] + + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] # Set up or get current plot figure if self.fig is None: @@ -1159,32 +1515,31 @@ def qc_flag_block_plot( ax = self.axes[subplot_index] # Set X Limit - We want the same time axes for all subplots - data = self._arm[dsname][data_field] - dim = list(self._arm[dsname][data_field].dims) - xdata = self._arm[dsname][dim[0]] + data = self._ds[dsname][data_field] + dim = list(self._ds[dsname][data_field].dims) + xdata = self._ds[dsname][dim[0]] # Get data and attributes - qc_data_field = self._arm[dsname].qcfilter.check_for_ancillary_qc(data_field, - add_if_missing=False, - cleanup=False) + qc_data_field = self._ds[dsname].qcfilter.check_for_ancillary_qc( + data_field, add_if_missing=False, cleanup=False + ) if qc_data_field is None: - raise ValueError(f"No quality control ancillary variable in Dataset for {data_field}") + raise ValueError(f'No quality control ancillary variable in Dataset for {data_field}') - flag_masks = self._arm[dsname][qc_data_field].attrs['flag_masks'] - flag_meanings = self._arm[dsname][qc_data_field].attrs['flag_meanings'] - flag_assessments = self._arm[dsname][qc_data_field].attrs['flag_assessments'] + flag_masks = self._ds[dsname][qc_data_field].attrs['flag_masks'] + flag_meanings = self._ds[dsname][qc_data_field].attrs['flag_meanings'] + flag_assessments = self._ds[dsname][qc_data_field].attrs['flag_assessments'] # Get time ranges for green blocks time_delta = determine_time_delta(xdata.values) - barh_list_green = reduce_time_ranges(xdata.values, time_delta=time_delta, - broken_barh=True) + barh_list_green = reduce_time_ranges(xdata.values, time_delta=time_delta, broken_barh=True) # Set background to gray indicating not available data ax.set_facecolor('dimgray') # Check if plotting 2D data vs 1D data. 2D data will be summarized by # assessment category instead of showing each test. - data_shape = self._arm[dsname][qc_data_field].shape + data_shape = self._ds[dsname][qc_data_field].shape if len(data_shape) > 1: cur_assessments = list(set(flag_assessments)) cur_assessments.sort() @@ -1193,7 +1548,7 @@ def qc_flag_block_plot( plot_colors = [] tick_names = [] - index = self._arm[dsname][qc_data_field].values == 0 + index = self._ds[dsname][qc_data_field].values == 0 if index.any(): qc_data[index] = 0 plot_colors.append(color_lookup['Not Failing']) @@ -1203,8 +1558,9 @@ def qc_flag_block_plot( if assess not in color_lookup: color_lookup[assess] = list(mplcolors.CSS4_COLORS.keys())[ii] ii += 1 - assess_data = self._arm[dsname].qcfilter.get_masked_data(data_field, - rm_assessments=assess) + assess_data = self._ds[dsname].qcfilter.get_masked_data( + data_field, rm_assessments=assess + ) if assess_data.mask.any(): qc_data[assess_data.mask] = ii @@ -1222,8 +1578,9 @@ def qc_flag_block_plot( if re_search(val, flag_meaning): test_num = parse_bit(flag_masks[ii])[0] missing_test_nums.append(test_num) - assess_data = self._arm[dsname].qcfilter.get_masked_data(data_field, - rm_tests=missing_test_nums) + assess_data = self._ds[dsname].qcfilter.get_masked_data( + data_field, rm_tests=missing_test_nums + ) if assess_data.mask.any(): qc_data[assess_data.mask] = -1 plot_colors.append(color_lookup['Missing']) @@ -1232,40 +1589,61 @@ def qc_flag_block_plot( # Create a masked array to allow not plotting where values are missing qc_data = np.ma.masked_equal(qc_data, -1) - dims = self._arm[dsname][qc_data_field].dims - xvalues = self._arm[dsname][dims[0]].values - yvalues = self._arm[dsname][dims[1]].values + dims = self._ds[dsname][qc_data_field].dims + xvalues = self._ds[dsname][dims[0]].values + yvalues = self._ds[dsname][dims[1]].values cMap = mplcolors.ListedColormap(plot_colors) - mesh = ax.pcolormesh(xvalues, yvalues, np.transpose(qc_data), cmap=cMap, vmin=0) + print(plot_colors) + mesh = ax.pcolormesh( + xvalues, + yvalues, + np.transpose(qc_data), + cmap=cMap, + vmin=0, + shading=set_shading, + ) divider = make_axes_locatable(ax) # Determine correct placement of words on colorbar - tick_nums = ((np.arange(0, len(tick_names) * 2 + 1) / - (len(tick_names) * 2) * np.nanmax(qc_data))[1::2]) + tick_nums = ( + np.arange(0, len(tick_names) * 2 + 1) / (len(tick_names) * 2) * np.nanmax(qc_data) + )[1::2] cax = divider.append_axes('bottom', size='5%', pad=0.3) - cbar = self.fig.colorbar(mesh, cax=cax, orientation='horizontal', spacing='uniform', - ticks=tick_nums, shrink=0.5) + cbar = self.fig.colorbar( + mesh, + cax=cax, + orientation='horizontal', + spacing='uniform', + ticks=tick_nums, + shrink=0.5, + ) cbar.ax.set_xticklabels(tick_names) # Set YTitle - dim_name = list(set(self._arm[dsname][qc_data_field].dims) - set(['time'])) + dim_name = list(set(self._ds[dsname][qc_data_field].dims) - {'time'}) try: - ytitle = f"{dim_name[0]} ({self._arm[dsname][dim_name[0]].attrs['units']})" + ytitle = f"{dim_name[0]} ({self._ds[dsname][dim_name[0]].attrs['units']})" ax.set_ylabel(ytitle) except KeyError: pass # Add which tests were set as text to the plot unique_values = [] - for ii in np.unique(self._arm[dsname][qc_data_field].values): + for ii in np.unique(self._ds[dsname][qc_data_field].values): unique_values.extend(parse_bit(ii)) if len(unique_values) > 0: unique_values = list(set(unique_values)) unique_values.sort() unique_values = [str(ii) for ii in unique_values] - self.fig.text(0.5, -0.35, f"QC Tests Tripped: {', '.join(unique_values)}", - transform=ax.transAxes, horizontalalignment='center', - verticalalignment='center', fontweight='bold') + self.fig.text( + 0.5, + -0.35, + f"QC Tests Tripped: {', '.join(unique_values)}", + transform=ax.transAxes, + horizontalalignment='center', + verticalalignment='center', + fontweight='bold', + ) else: @@ -1273,36 +1651,50 @@ def qc_flag_block_plot( for ii, assess in enumerate(flag_assessments): if assess not in color_lookup: color_lookup[assess] = list(mplcolors.CSS4_COLORS.keys())[ii] + # Plot green data first. - ax.broken_barh(barh_list_green, (ii, ii + 1), facecolors=color_lookup['Not Failing'], - edgecolor=edgecolor, **kwargs) + ax.broken_barh( + barh_list_green, + (ii, ii + 1), + facecolors=color_lookup['Not Failing'], + edgecolor=edgecolor, + **kwargs, + ) + # Get test number from flag_mask bitpacked number test_nums.append(parse_bit(flag_masks[ii])) # Get masked array data to use mask for finding if/where test is set - data = self._arm[dsname].qcfilter.get_masked_data( - data_field, rm_tests=test_nums[-1]) + data = self._ds[dsname].qcfilter.get_masked_data( + data_field, rm_tests=test_nums[-1] + ) if np.any(data.mask): # Get time ranges from time and masked data - barh_list = reduce_time_ranges(xdata.values[data.mask], - time_delta=time_delta, - broken_barh=True) + barh_list = reduce_time_ranges( + xdata.values[data.mask], time_delta=time_delta, broken_barh=True + ) # Check if the bit set is indicating missing data. If so change # to different plotting color than what is in flag_assessments. for val in missing_val_long_names: if re_search(val, flag_meanings[ii]): - assess = "Missing" + assess = 'Missing' break # Lay down blocks of tripped tests using correct color - ax.broken_barh(barh_list, (ii, ii + 1), - facecolors=color_lookup[assess], - edgecolor=edgecolor, **kwargs) + ax.broken_barh( + barh_list, + (ii, ii + 1), + facecolors=color_lookup[assess], + edgecolor=edgecolor, + **kwargs, + ) # Add test description to plot. ax.text(xdata.values[0], ii + 0.5, ' ' + flag_meanings[ii], va='center') # Change y ticks to test number - plt.yticks([ii + 0.5 for ii in range(0, len(test_nums))], - labels=['Test ' + str(ii[0]) for ii in test_nums]) + plt.yticks( + [ii + 0.5 for ii in range(0, len(test_nums))], + labels=['Test ' + str(ii[0]) for ii in test_nums], + ) # Set ylimit to number of tests plotted ax.set_ylim(0, len(flag_assessments)) @@ -1321,10 +1713,12 @@ def qc_flag_block_plot( else: # Set X Format if len(subplot_index) == 1: - days = (self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0]) + days = self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0] else: - days = (self.xrng[subplot_index[0], subplot_index[1], 1] - - self.xrng[subplot_index[0], subplot_index[1], 0]) + days = ( + self.xrng[subplot_index[0], subplot_index[1], 1] + - self.xrng[subplot_index[0], subplot_index[1], 0] + ) myFmt = common.get_date_format(days) ax.xaxis.set_major_formatter(myFmt) @@ -1332,8 +1726,14 @@ def qc_flag_block_plot( return self.axes[subplot_index] - def fill_between(self, field, dsname=None, subplot_index=(0, ), - set_title=None, secondary_y=False, **kwargs): + def fill_between( + self, + field, + dsname=None, + subplot_index=(0,), + set_title=None, + **kwargs, + ): """ Makes a fill_between plot, based on matplotlib @@ -1350,8 +1750,6 @@ def fill_between(self, field, dsname=None, subplot_index=(0, ), The index of the subplot to set the x range of. set_title : str The title for the plot. - secondary_y : boolean - Option to indicate if the data should be plotted on second y-axis. **kwargs : keyword arguments The keyword arguments for :func:`plt.plot` (1D timeseries) or :func:`plt.pcolormesh` (2D timeseries). @@ -1362,17 +1760,19 @@ def fill_between(self, field, dsname=None, subplot_index=(0, ), The matplotlib axis handle of the plot. """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] + dsname = list(self._ds.keys())[0] # Get data and dimensions - data = self._arm[dsname][field] - dim = list(self._arm[dsname][field].dims) - xdata = self._arm[dsname][dim[0]] + data = self._ds[dsname][field] + dim = list(self._ds[dsname][field].dims) + xdata = self._ds[dsname][dim[0]] if 'units' in data.attrs: ytitle = ''.join(['(', data.attrs['units'], ')']) @@ -1388,19 +1788,18 @@ def fill_between(self, field, dsname=None, subplot_index=(0, ), self.fig.add_axes(self.axes[0]) # Set ax to appropriate axis - if secondary_y is False: - ax = self.axes[subplot_index] - else: - ax = self.axes[subplot_index].twinx() + ax = self.axes[subplot_index] ax.fill_between(xdata.values, data, **kwargs) # Set X Format if len(subplot_index) == 1: - days = (self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0]) + days = self.xrng[subplot_index, 1] - self.xrng[subplot_index, 0] else: - days = (self.xrng[subplot_index[0], subplot_index[1], 1] - - self.xrng[subplot_index[0], subplot_index[1], 0]) + days = ( + self.xrng[subplot_index[0], subplot_index[1], 1] + - self.xrng[subplot_index[0], subplot_index[1], 0] + ) myFmt = common.get_date_format(days) ax.xaxis.set_major_formatter(myFmt) @@ -1411,17 +1810,21 @@ def fill_between(self, field, dsname=None, subplot_index=(0, ), # Put on an xlabel, but only if we are making the bottom-most plot if subplot_index[0] == self.axes.shape[0] - 1: - self.axes[subplot_index].set_xlabel('Time [UTC]') + ax.set_xlabel('Time [UTC]') # Set YTitle ax.set_ylabel(ytitle) # Set Title if set_title is None: - set_title = ' '.join([dsname, field, 'on', - dt_utils.numpy_to_arm_date( - self._arm[dsname].time.values[0])]) - if secondary_y is False: - ax.set_title(set_title) - + set_title = ' '.join( + [ + dsname, + field, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + ax.set_title(set_title) + self.axes[subplot_index] = ax return self.axes[subplot_index] diff --git a/act/plotting/windrosedisplay.py b/act/plotting/windrosedisplay.py new file mode 100644 index 0000000000..ef128c2ccc --- /dev/null +++ b/act/plotting/windrosedisplay.py @@ -0,0 +1,488 @@ +""" +Stores the class for WindRoseDisplay. + +""" + +import warnings + +import matplotlib +import matplotlib.pyplot as plt +import numpy as np + +# Import Local Libs +from ..utils import datetime_utils as dt_utils +from .plot import Display + + +class WindRoseDisplay(Display): + """ + A class for handing wind rose plots. + + This is inherited from the :func:`act.plotting.Display` + class and has therefore has the same attributes as that class. + See :func:`act.plotting.Display` + for more information. There are no additional attributes or parameters + to this class. + + Examples + -------- + To create a WindRoseDisplay object, simply do: + + .. code-block :: python + + sonde_ds = act.io.arm.read_arm_netcdf('sonde_data.nc') + WindDisplay = act.plotting.WindRoseDisplay(sonde_ds, figsize=(8,10)) + + """ + + def __init__(self, ds, subplot_shape=(1,), ds_name=None, **kwargs): + super().__init__(ds, subplot_shape, ds_name, subplot_kw=dict(projection='polar'), + **kwargs) + + def set_thetarng(self, trng=(0.0, 360.0), subplot_index=(0,)): + """ + Sets the theta range of the wind rose plot. + + Parameters + ---------- + trng : 2-tuple + The range (in degrees). + subplot_index : 2-tuple + The index of the subplot to set the degree range of. + + """ + if self.axes is not None: + self.axes[subplot_index].set_thetamin(trng[0]) + self.axes[subplot_index].set_thetamax(trng[1]) + self.trng = trng + else: + raise RuntimeError('Axes must be initialized before' + ' changing limits!') + + def set_rrng(self, rrng, subplot_index=(0,)): + """ + Sets the range of the radius of the wind rose plot. + + Parameters + ---------- + rrng : 2-tuple + The range for the plot radius (in %). + subplot_index : 2-tuple + The index of the subplot to set the radius range of. + + """ + if self.axes is not None: + self.axes[subplot_index].set_rmin(rrng[0]) + self.axes[subplot_index].set_rmax(rrng[1]) + self.rrng = rrng + else: + raise RuntimeError('Axes must be initialized before' + ' changing limits!') + + def plot( + self, + dir_field, + spd_field, + dsname=None, + subplot_index=(0,), + cmap=None, + set_title=None, + num_dirs=20, + spd_bins=None, + tick_interval=3, + legend_loc=0, + legend_bbox=None, + legend_title=None, + calm_threshold=1.0, + **kwargs, + ): + """ + Makes the wind rose plot from the given dataset. + + Parameters + ---------- + dir_field : str + The name of the field representing the wind direction (in degrees). + spd_field : str + The name of the field representing the wind speed. + dsname : str + The name of the datastream to plot from. Set to None to + let ACT automatically try to determine this. + subplot_index : 2-tuple + The index of the subplot to place the plot on. + cmap : str or matplotlib colormap + The name of the matplotlib colormap to use. + set_title : str + The title of the plot. + num_dirs : int + The number of directions to split the wind rose into. + spd_bins : 1D array-like + The bin boundaries to sort the wind speeds into. + tick_interval : int + The interval (in %) for the ticks on the radial axis. + legend_loc : int + Legend location using matplotlib legend code + legend_bbox : tuple + Legend bounding box coordinates + legend_title : string + Legend title + calm_threshold : float + Winds below this threshold are considered to be calm. + **kwargs : keyword arguments + Additional keyword arguments will be passed into :func:plt.bar + + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle corresponding to the plot. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + # Get data and dimensions + dir_data = self._ds[dsname][dir_field].values + spd_data = self._ds[dsname][spd_field].values + + # Get the current plotting axis, add day/night background and plot data + if self.fig is None: + self.fig = plt.figure() + + if self.axes is None: + self.axes = np.array([plt.axes(projection='polar')]) + self.fig.add_axes(self.axes[0]) + + if spd_bins is None: + spd_bins = np.linspace(0, np.nanmax(spd_data), 10) + + # Make the bins so that 0 degrees N is in the center of the first bin + # We need to wrap around + + deg_width = 360.0 / num_dirs + dir_bins_mid = np.linspace(0.0, 360.0 - 3 * deg_width / 2.0, num_dirs) + wind_hist = np.zeros((num_dirs, len(spd_bins) - 1)) + + for i in range(num_dirs): + if i == 0: + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', 'invalid value encountered in.*') + the_range = np.logical_or( + dir_data < deg_width / 2.0, dir_data > 360.0 - deg_width / 2.0 + ) + else: + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', 'invalid value encountered in.*') + the_range = np.logical_and( + dir_data >= dir_bins_mid[i] - deg_width / 2, + dir_data <= dir_bins_mid[i] + deg_width / 2, + ) + hist, bins = np.histogram(spd_data[the_range], spd_bins) + wind_hist[i] = hist + + wind_hist = wind_hist / np.sum(wind_hist) * 100 + mins = np.deg2rad(dir_bins_mid) + + # Do the first level + if 'units' in self._ds[dsname][spd_field].attrs.keys(): + units = self._ds[dsname][spd_field].attrs['units'] + else: + units = '' + the_label = '%3.1f' % spd_bins[0] + '-' + '%3.1f' % spd_bins[1] + ' ' + units + our_cmap = matplotlib.colormaps.get_cmap(cmap) + our_colors = our_cmap(np.linspace(0, 1, len(spd_bins))) + + ax = self.axes[subplot_index] + + bars = [ + ax.bar( + mins, + wind_hist[:, 0], + bottom=0, + label=the_label, + width=0.8 * np.deg2rad(deg_width), + color=our_colors[0], + **kwargs, + ) + ] + for i in range(1, len(spd_bins) - 1): + the_label = '%3.1f' % spd_bins[i] + '-' + '%3.1f' % spd_bins[i + 1] + ' ' + units + # Changing the bottom to be a sum of the previous speeds so that + # it positions it correctly - Adam Theisen + bars.append( + ax.bar( + mins, + wind_hist[:, i], + label=the_label, + bottom=np.sum(wind_hist[:, :i], axis=1), + width=0.8 * np.deg2rad(deg_width), + color=our_colors[i], + **kwargs, + ) + ) + ax.legend( + loc=legend_loc, bbox_to_anchor=legend_bbox, title=legend_title + ) + ax.set_theta_zero_location('N') + ax.set_theta_direction(-1) + + # Add an annulus with text stating % of time calm + pct_calm = np.sum(spd_data <= calm_threshold) / len(spd_data) * 100 + ax.set_rorigin(-2.5) + ax.annotate( + '%3.2f%%\n calm' % pct_calm, xy=(0, -2.5), ha='center', va='center' + ) + + # Set the ticks to be nice numbers + tick_max = tick_interval * round(np.nanmax(np.cumsum(wind_hist, axis=1)) / tick_interval) + rticks = np.arange(0, tick_max, tick_interval) + rticklabels = [('%d' % x + '%') for x in rticks] + ax.set_rticks(rticks) + ax.set_yticklabels(rticklabels) + + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + ax.set_title(set_title) + + self.axes[subplot_index] = ax + + return ax + + def plot_data( + self, + dir_field, + spd_field, + data_field, + dsname=None, + subplot_index=(0,), + plot_type='Line', + line_color=None, + set_title=None, + num_dirs=30, + num_data_bins=30, + calm_threshold=1.0, + line_plot_calc='mean', + clevels=30, + contour_type='count', + cmap=None, + **kwargs, + ): + """ + Makes a data rose plot in line or boxplot form from the given data. + + Parameters + ---------- + dir_field : str + The name of the field representing the wind direction (in degrees). + spd_field : str + The name of the field representing the wind speed. + data_field : str + Name of the field to plot. Default is to plot mean values. + dsname : str + The name of the datastream to plot from. Set to None to + let ACT automatically try to determine this. + subplot_index : 2-tuple + The index of the subplot to place the plot on. + plot_type : str + Type of plot to create. Defaults to a line plot but the full options include + 'line', 'contour', and 'boxplot' + line_color : str + Color to use for the line + set_title : str + The title of the plot. + num_dirs : int + The number of directions to split the wind rose into. + num_data_bins : int + The number of bins to use for data processing if doing a contour plot + calm_threshold : float + Winds below this threshold are considered to be calm. + line_plot_calc : str + What values to display for the line plot. Defaults to 'mean', + but other options are 'median' and 'stdev' + clevels : int + Number of contour levels to plot + contour_type : str + Type of contour plot to do. Default is 'count' which displays a + heatmap of where values are occuring most along with wind directions + The other option is 'mean' which will do a wind direction x wind speed + plot with the contours of the mean values for each wind dir/speed. + num_data_bins will be used for number of wind speed bins + cmap : str or matplotlib colormap + The name of the matplotlib colormap to use. + **kwargs : keyword arguments + Additional keyword arguments will be passed into :func:plt.bar + + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle corresponding to the plot. + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + # Get data and dimensions + # Throw out calm winds for the analysis + ds = self._ds[dsname] + ds = ds.where(ds[spd_field] >= calm_threshold) + dir_data = ds[dir_field].values + data = ds[data_field].values + + # Set the bins + dir_bins_mid = np.linspace(0.0, 360.0, num_dirs + 1) + + # Run through the data and bin based on the wind direction and plot type + arr = [] + bins = [] + for i, d in enumerate(dir_bins_mid): + if i < len(dir_bins_mid) - 1: + idx = np.where((dir_data > d) & (dir_data <= dir_bins_mid[i + 1]))[0] + bins.append(d + (dir_bins_mid[i + 1] - d) / 2.) + else: + idx = np.where((dir_data > d) & (dir_data <= 360.))[0] + bins.append(d + (360. - d) / 2.) + + if plot_type == 'line': + if line_plot_calc == 'mean': + arr.append(np.nanmean(data[idx])) + plot_type_str = 'Mean of' + elif line_plot_calc == 'median': + arr.append(np.nanmedian(data[idx])) + plot_type_str = 'Median of' + elif line_plot_calc == 'stdev': + plot_type_str = 'Standard Deviation of' + arr.append(np.nanstd(data[idx])) + else: + raise ValueError('Please pick an available option') + elif plot_type == 'boxplot': + arr.append(data[idx]) + + # Plot data for each plot type + if plot_type == 'line': + # Add the first values to the end of the array to have a + # complete circle + bins.append(bins[0]) + arr.append(arr[0]) + self.axes[subplot_index].plot(np.deg2rad(bins), arr, **kwargs) + elif plot_type == 'boxplot': + # Plot boxplot + self.axes[subplot_index].boxplot( + arr, positions=np.deg2rad(bins), showmeans=False, **kwargs + ) + if bins[-1] == 360: + bins[-1] = 0 + self.axes[subplot_index].xaxis.set_ticklabels(np.ceil(bins)) + plot_type_str = 'Boxplot of' + elif plot_type == 'contour': + # Calculate a histogram to plot out a contour for + if contour_type == 'count': + idx = np.where((~np.isnan(dir_data)) & (~np.isnan(data)))[0] + hist, xedges, yedges = np.histogram2d( + dir_data[idx], data[idx], bins=[num_dirs, num_data_bins] + ) + hist = np.insert(hist, -1, hist[0], axis=0) + cplot = self.axes[subplot_index].contourf( + np.deg2rad(xedges), yedges[0:-1], np.transpose(hist), + cmap=cmap, levels=clevels, **kwargs + ) + plot_type_str = 'Heatmap of' + cbar = self.fig.colorbar(cplot, ax=self.axes[subplot_index]) + cbar.ax.set_ylabel('Count') + elif contour_type == 'mean': + # Produce direction (x-axis) and speed (y-axis) plots displaying the mean + # as the contours. + spd_data = ds[spd_field].values + spd_bins = np.linspace(0, ds[spd_field].max(), num_data_bins + 1) + spd_bins = np.insert(spd_bins, 1, calm_threshold) + # Set up an array and cycle through the data, binning them by speed/direction + mean_data = np.zeros([len(bins), len(spd_bins)]) + for i in range(len(bins) - 1): + for j in range(len(spd_bins)): + if j < len(spd_bins) - 1: + idx = np.where( + (spd_data >= spd_bins[j]) + & (spd_data < spd_bins[j + 1]) + & (dir_data >= bins[i]) + & (dir_data < bins[i + 1]) + )[0] + else: + idx = np.where( + (spd_data >= spd_bins[j]) + & (dir_data >= bins[i]) + & (dir_data < bins[i + 1]) + )[0] + mean_data[i, j] = np.nanmean(data[idx]) + + # Necessary to produce the full polar contour without having gaps + mean_data = np.insert(mean_data, -1, mean_data[0, :], axis=0) + bins.append(bins[0]) + mean_data[-1, :] = mean_data[0, :] + + # In order to properly handle vmin/vmax in contours, need to adjust + # the levels plotted and remove the keywords to contourf + vmin = np.nanmin(mean_data) + vmax = np.nanmax(mean_data) + if 'vmin' in kwargs: + vmin = kwargs.get('vmin') + kwargs.pop('vmin', None) + if 'vmax' in kwargs: + vmax = kwargs.get('vmax') + kwargs.pop('vmax', None) + + clevels = np.linspace(vmin, vmax, clevels) + cplot = self.axes[subplot_index].contourf( + np.deg2rad(bins), spd_bins, np.transpose(mean_data), + cmap=cmap, levels=clevels, extend='both', **kwargs + ) + plot_type_str = 'Mean of' + cbar = self.fig.colorbar(cplot, ax=self.axes[subplot_index]) + cbar.ax.set_ylabel('Mean') + else: + raise ValueError('Please choose an available plot type') + + # Set axis parameters so that it's a standard wind rose style + self.axes[subplot_index].set_theta_zero_location('N') + self.axes[subplot_index].set_theta_direction(-1) + + # Set Title + sdate = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + edate = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[-1]), + + if sdate == edate: + date_str = 'on ' + sdate[0] + else: + date_str = 'from ' + sdate[0] + ' to ' + edate[0] + if 'units' in ds[data_field].attrs: + units = ds[data_field].attrs['units'] + else: + units = '' + if set_title is None: + set_title = ' '.join( + [ + plot_type_str, + data_field + ' (' + units + ')', + 'by\n', + dir_field, + date_str + ] + ) + self.axes[subplot_index].set_title(set_title) + plt.tight_layout(h_pad=1.05) + + return self.axes[subplot_index] diff --git a/act/plotting/XSectionDisplay.py b/act/plotting/xsectiondisplay.py similarity index 76% rename from act/plotting/XSectionDisplay.py rename to act/plotting/xsectiondisplay.py index b269ea18cd..d989594c0c 100644 --- a/act/plotting/XSectionDisplay.py +++ b/act/plotting/xsectiondisplay.py @@ -1,7 +1,4 @@ """ -act.plotting.XSectionDisplay ----------------------------- - Stores the class for XSectionDisplay. """ @@ -12,6 +9,7 @@ try: import cartopy.crs as ccrs + CARTOPY_AVAILABLE = True except ImportError: CARTOPY_AVAILABLE = False @@ -45,7 +43,7 @@ class and has therefore has the same attributes as that class. .. code-block:: python - time_slice = my_ds['ir_temperature'].isel(time=0) + time_slice = my_ds["ir_temperature"].isel(time=0) The methods of this class support passing in keyword arguments into xarray :func:`xarray.Dataset.sel` and :func:`xarray.Dataset.isel` commands @@ -57,19 +55,24 @@ class and has therefore has the same attributes as that class. xsection = XSectionDisplay(my_ds, figsize=(15, 8)) xsection.plot_xsection_map( - None, 'ir_temperature', vmin=220, vmax=300, - cmap='Greys', x='longitude', y='latitude', - isel_kwargs={'time': 0}) + None, + "ir_temperature", + vmin=220, + vmax=300, + cmap="Greys", + x="longitude", + y="latitude", + isel_kwargs={"time": 0}, + ) Here, the array is sliced by the first time period as specified in :code:`isel_kwargs`. The other keyword arguments are standard keyword arguments taken by :func:`matplotlib.pyplot.pcolormesh`. """ - def __init__(self, obj, subplot_shape=(1,), - ds_name=None, **kwargs): - super().__init__(obj, None, ds_name, **kwargs) - self.add_subplots(subplot_shape) + + def __init__(self, ds, subplot_shape=(1,), ds_name=None, **kwargs): + super().__init__(ds, subplot_shape, ds_name, **kwargs) def set_subplot_to_map(self, subplot_index): total_num_plots = self.axes.shape @@ -84,10 +87,13 @@ def set_subplot_to_map(self, subplot_index): third_number = second_number * subplot_index[0] + j + 1 self.axes[subplot_index] = plt.subplot( - total_num_plots[0], second_number, third_number, - projection=ccrs.PlateCarree()) + total_num_plots[0], + second_number, + third_number, + projection=ccrs.PlateCarree(), + ) - def set_xrng(self, xrng, subplot_index=(0, )): + def set_xrng(self, xrng, subplot_index=(0,)): """ Sets the x range of the plot. @@ -100,19 +106,17 @@ def set_xrng(self, xrng, subplot_index=(0, )): """ if self.axes is None: - raise RuntimeError("set_xrng requires the plot to be displayed.") + raise RuntimeError('set_xrng requires the plot to be displayed.') if not hasattr(self, 'xrng') and len(self.axes.shape) == 2: - self.xrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2), - dtype=xrng[0].dtype) + self.xrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2), dtype=xrng[0].dtype) elif not hasattr(self, 'xrng') and len(self.axes.shape) == 1: - self.xrng = np.zeros((self.axes.shape[0], 2), - dtype=xrng[0].dtype) + self.xrng = np.zeros((self.axes.shape[0], 2), dtype=xrng[0].dtype) self.axes[subplot_index].set_xlim(xrng) self.xrng[subplot_index, :] = np.array(xrng) - def set_yrng(self, yrng, subplot_index=(0, )): + def set_yrng(self, yrng, subplot_index=(0,)): """ Sets the y range of the plot. @@ -125,11 +129,10 @@ def set_yrng(self, yrng, subplot_index=(0, )): """ if self.axes is None: - raise RuntimeError("set_yrng requires the plot to be displayed.") + raise RuntimeError('set_yrng requires the plot to be displayed.') if not hasattr(self, 'yrng') and len(self.axes.shape) == 2: - self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2), - dtype=yrng[0].dtype) + self.yrng = np.zeros((self.axes.shape[0], self.axes.shape[1], 2), dtype=yrng[0].dtype) elif not hasattr(self, 'yrng') and len(self.axes.shape) == 1: self.yrng = np.zeros((self.axes.shape[0], 2), dtype=yrng[0].dtype) @@ -140,10 +143,17 @@ def set_yrng(self, yrng, subplot_index=(0, )): self.yrng[subplot_index, :] = yrng - def plot_xsection(self, dsname, varname, x=None, y=None, - subplot_index=(0, ), - sel_kwargs=None, isel_kwargs=None, - **kwargs): + def plot_xsection( + self, + dsname, + varname, + x=None, + y=None, + subplot_index=(0,), + sel_kwargs=None, + isel_kwargs=None, + **kwargs, + ): """ This function plots a cross section whose x and y coordinates are specified by the variable names either provided by the user or @@ -180,13 +190,15 @@ def plot_xsection(self, dsname, varname, x=None, y=None, The matplotlib axis handle corresponding to the plot. """ - if dsname is None and len(self._arm.keys()) > 1: - raise ValueError(("You must choose a datastream when there are 2 " - "or more datasets in the TimeSeriesDisplay " - "object.")) + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + 'or more datasets in the TimeSeriesDisplay ' + 'object.' + ) elif dsname is None: - dsname = list(self._arm.keys())[0] - temp_ds = self._arm[dsname].copy() + dsname = list(self._ds.keys())[0] + temp_ds = self._ds[dsname].copy() if sel_kwargs is not None: temp_ds = temp_ds.sel(**sel_kwargs, method='nearest') @@ -194,9 +206,11 @@ def plot_xsection(self, dsname, varname, x=None, y=None, if isel_kwargs is not None: temp_ds = temp_ds.isel(**isel_kwargs) - if((x is not None and y is None) or (y is None and x is not None)): - raise RuntimeError("Both x and y must be specified if we are" + - "not trying to automatically detect them!") + if (x is not None and y is None) or (y is None and x is not None): + raise RuntimeError( + 'Both x and y must be specified if we are' + + 'not trying to automatically detect them!' + ) if x is not None: coord_list = {} @@ -204,8 +218,7 @@ def plot_xsection(self, dsname, varname, x=None, y=None, coord_list[x] = x_coord_dim y_coord_dim = temp_ds[y].dims[0] coord_list[y] = y_coord_dim - new_ds = data_utils.assign_coordinates( - temp_ds, coord_list) + new_ds = data_utils.assign_coordinates(temp_ds, coord_list) my_dataarray = new_ds[varname] else: my_dataarray = temp_ds[varname] @@ -244,9 +257,9 @@ def plot_xsection(self, dsname, varname, x=None, y=None, del temp_ds return ax - def plot_xsection_map(self, dsname, varname, - subplot_index=(0, ), coastlines=True, - background=False, **kwargs): + def plot_xsection_map( + self, dsname, varname, subplot_index=(0,), coastlines=True, background=False, **kwargs + ): """ Plots a cross section of 2D data on a geographical map. @@ -274,17 +287,16 @@ def plot_xsection_map(self, dsname, varname, """ if not CARTOPY_AVAILABLE: - raise ImportError("Cartopy needs to be installed in order to plot " + - "cross sections on maps!") + raise ImportError( + 'Cartopy needs to be installed in order to plot ' + 'cross sections on maps!' + ) self.set_subplot_to_map(subplot_index) self.plot_xsection(dsname, varname, subplot_index=subplot_index, **kwargs) xlims = self.xrng[subplot_index].flatten() ylims = self.yrng[subplot_index].flatten() - self.axes[subplot_index].set_xticks( - np.linspace(round(xlims[0], 0), round(xlims[1], 0), 10)) - self.axes[subplot_index].set_yticks( - np.linspace(round(ylims[0], 0), round(ylims[1], 0), 10)) + self.axes[subplot_index].set_xticks(np.linspace(round(xlims[0], 0), round(xlims[1], 0), 10)) + self.axes[subplot_index].set_yticks(np.linspace(round(ylims[0], 0), round(ylims[1], 0), 10)) if coastlines: self.axes[subplot_index].coastlines(resolution='10m') diff --git a/act/qc/__init__.py b/act/qc/__init__.py index fe520a7581..df8a866305 100644 --- a/act/qc/__init__.py +++ b/act/qc/__init__.py @@ -1,52 +1,41 @@ """ -=========================== -act.qc (act.qc) -=========================== - -.. currentmodule:: act.qc - This module contains procedures for working with QC information -and for applying tests to data +and for applying tests to data. -.. autosummary:: - :toctree: generated/ - - arm.add_dqr_to_qc - clean.CleanDataset - qcfilter.QCFilter - qcfilter.parse_bit - qcfilter.set_bit - qcfilter.unset_bit - qcfilter.QCFilter.add_delta_test - qcfilter.QCFilter.add_difference_test - qcfilter.QCFilter.add_equal_to_test - qcfilter.QCFilter.add_greater_test - qcfilter.QCFilter.add_greater_equal_test - qcfilter.QCFilter.add_inside_test - qcfilter.QCFilter.add_less_test - qcfilter.QCFilter.add_less_equal_test - qcfilter.QCFilter.add_missing_value_test - qcfilter.QCFilter.add_not_equal_to_test - qcfilter.QCFilter.add_outside_test - qcfilter.QCFilter.add_persistence_test - qcfilter.QCFilter.add_test - qcfilter.QCFilter.available_bit - qcfilter.QCFilter.check_for_ancillary_qc - qcfilter.QCFilter.compare_time_series_trends - qcfilter.QCFilter.create_qc_variable - qcfilter.QCFilter.datafilter - qcfilter.QCFilter.get_qc_test_mask - qcfilter.QCFilter.get_masked_data - qcfilter.QCFilter.remove_test - qcfilter.QCFilter.set_test - qcfilter.QCFilter.unset_test - qcfilter.QCFilter.update_ancillary_variable - qctests.QCTests - radiometer_tests.fft_shading_test """ -from . import qcfilter -from . import qctests, comparison_tests -from . import clean -from . import arm -from . import radiometer_tests +import lazy_loader as lazy + +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=[ + 'add_supplemental_qc', + 'arm', + 'bsrn_tests', + 'comparison_tests', + 'qcfilter', + 'qctests', + 'radiometer_tests', + 'sp2', + ], + submod_attrs={ + 'arm': ['add_dqr_to_qc'], + 'qcfilter': [ + 'QCFilter', + 'parse_bit', + 'set_bit', + 'unset_bit', + ], + 'qctests': [ + 'QCTests', + ], + 'radiometer_tests': [ + 'fft_shading_test', + 'fft_shading_test_process', + ], + 'bsrn_tests': ['QCTests'], + 'comparison_tests': ['QCTests'], + 'add_supplemental_qc': ['read_yaml_supplemental_qc'], + 'sp2': ['SP2ParticleCriteria', 'get_waveform_statistics'], + }, +) diff --git a/act/qc/add_supplemental_qc.py b/act/qc/add_supplemental_qc.py new file mode 100644 index 0000000000..2d94f15a2d --- /dev/null +++ b/act/qc/add_supplemental_qc.py @@ -0,0 +1,350 @@ +import yaml +import numpy as np +from pathlib import Path +from dateutil import parser +from os import environ + +# Example of the YAML file and how to construct. +# The times are set as inclusive start to inclusive end time. +# Different formats are acceptable as displayed with temp_mean +# Good example below. +# +# The general format is to use the variable name as initial key +# followed by an assessment key, followed by a 'description' key which +# is a description of that test. Each test listed will insert a new test +# into the ancillary quality control variable. After the 'description' +# list all time ranges as a YAML array. +# If a test is to be applied to all variables list under the specail +# variable name '_all'. +# +# The file should be named same as datastream name with standard +# YAML file extension when only providing the directoy. +# For example the file below would be named sgpmetE13.b1.yaml +# +# +# _all: +# Bad: +# Values are bad for all: +# - 2020-01-21 01:01:02, 2020-01-21 01:03:13 +# - 2020-01-21 02:01:02, 2020-01-21 04:03:13 +# Suspect: +# Values are suspect for all: [] +# +# temp_mean: +# Bad: +# Values are bad: +# - 2020-01-01 00:01:02, 2020-01-01 00:03:44 +# - 2020-01-02 01:01:02, 2020-01-02 01:03:13 +# - 2020-02-01 00:01:02, 2020-02-01 00:03:44 +# - 2020-03-02 01:01:02, 2020-03-02 01:03:13 +# - 2020-01-21 01:01:02, 2020-01-21 01:03:13 +# Suspect: +# Values are suspect: +# - 2020-01-01 02:04:02, 2020-01-01 02:05:44 +# Good: +# Values are good: +# - 2020-01-01 00:08:02, 2020-01-01 00:09:44 +# - Jan 1, 2020 00:08:02 ; January 1, 2020 00:09:44 AM +# - 2020-01-01 00:08 | 2020-01-01 00:09 +# - 2020-01-01T00:08:02 ; 2020-01-01T00:09:44 +# +# rh_mean: +# Bad: +# Values are bad: +# - 2020-01-01 00:01:02, 2020-01-01 00:03:44 +# - 2020-01-02 00:01:02, 2020-01-02 00:03:44 +# Suspect: +# Values are suspect: +# - 2020-01-01 00:04:02, 2020-01-01 00:05:44 + + +def read_yaml_supplemental_qc( + ds, + fullpath, + variables=None, + assessments=None, + datetime64=True, + time_delim=(';', ',', '|', r'\t'), + none_if_empty=True, + quiet=False +): + + """ + Returns a dictionary converstion of YAML file for flagging data. The dictionary + will contain variable names as first key, assessents as second keys containing + test description as third key with time as last key. Multiple descriptions + are allowed. + + Parameters + ---------- + ds : xarray.Dataset + Xarray dataset containing data. + fullpath : str or `pathlib.Path` + Full path to file to read or directory containing YAML files to read. If providing + a directory a file with the datastream name ending in .yaml or .yml must exists. + variables : str, list of str or None + Optional, variable names to keep in dictionary. All others will be removed + before returning dictionary. If no variables are left will return None. + assessments : str, list of str or None + Optional, assessments categories to keep in dictionary. All others will be removed + before returning dictionary. + datetime64 : boolean + Convert the string value list to 2D numpy datetime64 array with first value + the start time and second value end time. If the time list in the YAML file + is empty, the 'time' numpy array will be a single value instead of 2D array + and set to numpy datetime64 NaT. + time_delim : str or list of str or tuple of str + Optional, character delimiter to use when parsing times. + none_if_empty : boolean + Return None instead of empty dictionary + quiet : boolean + Suppress information about not finding a YAML file to read. + + Returns + ------- + Dictionary of [variable names][assessments][description] and time values + or if the dictionary is empty after processing options and none_if_empty set + to True will return None. + + Examples + -------- + This example will load the example MET data used for unit testing. + + .. code-block:: python + + from act.tests import EXAPLE_MET_YAML, EXAMPLE_MET1 + from act.io.arm import read_arm_netcdf + from act.qc.add_supplemental_qc import read_yaml_supplemental_qc + ds = read_arm_netcdf(EXAMPLE_MET1, cleanup_qc=True) + result = read_yaml_supplemental_qc(ds, EXAPLE_MET_YAML, + variables=['rh_mean'], assessments='Bad') + print(result) + + {'rh_mean': {'Bad': {'description': 'Values are bad', + 'time': array([['2020-01-01T00:01:02.000', '2020-01-01T00:03:44.000'], + ['2020-01-02T00:01:02.000', '2020-01-02T00:03:44.000']], + dtype='datetime64[ms]')}}} + + """ + + flag_file = [] + if Path(fullpath).is_file(): + flag_file = [Path(fullpath)] + else: + try: + datastream = ds.attrs['_datastream'] + except KeyError: + raise RuntimeError( + 'Unable to determine datastream name from Dataset. Need to set global attribute ' + '_datastream in Dataset or provided full path to flag file.') + + flag_file = list(Path(fullpath).glob(f'{datastream}.yml')) + flag_file.extend(list(Path(fullpath).glob(f'{datastream}.yaml'))) + + if len(flag_file) > 0: + flag_file = flag_file[0] + else: + if not quiet: + print(f'Could not find supplemental QC file for {datastream} in {fullpath}') + + return None + + # Ensure keywords are lists + if isinstance(variables, str): + variables = [variables] + + if isinstance(assessments, str): + assessments = [assessments] + + if isinstance(time_delim, str): + time_delim = [time_delim] + + # Ensure the assessments are capitalized for matching + if assessments is not None: + assessments = [ii.capitalize() for ii in assessments] + + # Read YAML file + with open(flag_file, "r") as fp: + try: + data_dict = yaml.load(fp, Loader=yaml.FullLoader) + except AttributeError: + data_dict = yaml.load(fp) + + # If variable names are provided only keep those names. + if variables is not None: + variables.append('_all') + del_vars = set(data_dict.keys()) - set(variables) + for var_name in del_vars: + del data_dict[var_name] + + # If assessments are given only keep those assessments. + if assessments is not None: + for var_name in data_dict.keys(): + for asses_name in data_dict[var_name].keys(): + # Check if yaml file assessments are capitalized. If not fix. + if not asses_name == asses_name.capitalize(): + data_dict[var_name][asses_name.capitalize()] = data_dict[var_name][asses_name] + del data_dict[var_name][asses_name] + + # Delete assessments if not in provided list. + del_asses = set(data_dict[var_name].keys()) - set(assessments) + for asses_name in del_asses: + del data_dict[var_name][asses_name] + + # Convert from string to numpy datetime64 2D array + if datetime64: + for var_name in data_dict.keys(): + for asses_name in data_dict[var_name].keys(): + for description in data_dict[var_name][asses_name].keys(): + try: + num_times = len(data_dict[var_name][asses_name][description]) + new_times = np.empty((num_times, 2), dtype='datetime64[ms]') + except TypeError: + # Set to single value Not A Time numpy array if times + # from yaml file are empty list. + new_times = np.full([], np.datetime64('NaT'), dtype='datetime64[ms]') + + for ii, tm in enumerate(data_dict[var_name][asses_name][description]): + # Split the times on multiple different types of delimiters. + for delim in time_delim: + split_tm = tm.split(delim) + if len(split_tm) > 1: + break + + new_times[ii, 0] = np.datetime64(parser.parse(split_tm[0])) + new_times[ii, 1] = np.datetime64(parser.parse(split_tm[1])) + + data_dict[var_name][asses_name][description] = new_times + + # If the return dictinary is empty convert to None + if none_if_empty and len(data_dict) == 0: + data_dict = None + + return data_dict + + +def apply_supplemental_qc( + ds, + fullpath, + variables=None, + assessments=None, + apply_all=True, + exclude_all_variables=None, + quiet=False +): + + """ + Apply flagging from supplemental QC file by adding new QC tests. + + Parameters + ---------- + ds : xarray.Dataset + Xarray dataset containing data. QC variables should be converted to CF + format prior to adding new tests. + fullpath : str or `pathlib.Path` + Fullpath to file or directory with supplemental QC files. + variables : str, list of str or None + Variables to apply to the dataset from supplemental QC flag file. + If not set will apply all variables in the file. + assessments : str, list of str or None + Assessments to apply. If not not set will apply all assesments in the flag file. + apply_all : boolean + If a "_all" variable exists in the supplemental QC flag file will apply to all variables + in the Dataset. + exclude_all_variables : str, list of str or None + Variables to skip when applying "_all" variables. + quiet : boolean + Suppress information about not finding a supplemental QC file to read. + + Examples + -------- + This example will load the example sounding data used for unit testing. + + .. code-block:: python + + from act.tests import EXAPLE_MET_YAML, EXAMPLE_MET1 + from act.io.arm import read_arm_netcdf + from act.qc.add_supplemental_qc import apply_supplemental_qc + ds = read_arm_netcdf(EXAMPLE_MET1, cleanup_qc=True) + apply_supplemental_qc(ds, EXAPLE_MET_YAML, apply_all=False) + print(ds['qc_temp_mean'].attrs['flag_meanings']) + + ['Value is equal to missing_value.', 'Value is less than the fail_min.', + 'Value is greater than the fail_max.', + 'Difference between current and previous values exceeds fail_delta.', + 'Values are bad', 'Values are super bad', 'Values are suspect', 'Values are good'] + + """ + + exclude_vars = ['time', 'base_time', 'time_offset'] + if exclude_all_variables is not None: + if isinstance(exclude_all_variables, str): + exclude_all_variables = [exclude_all_variables] + + exclude_vars.extend(exclude_all_variables) + + flag_dict = read_yaml_supplemental_qc( + ds, fullpath, variables=variables, assessments=assessments, quiet=quiet) + + if flag_dict is None: + return + + for var_name in list(ds.variables): + if var_name in flag_dict.keys(): + for asses_name in flag_dict[var_name].keys(): + for description in flag_dict[var_name][asses_name]: + times = flag_dict[var_name][asses_name][description] + + if np.all(np.isnat(times)): + continue + + indexes = np.array([], dtype=np.int32) + for vals in times: + ind = np.argwhere( + (ds['time'].values >= vals[0]) & (ds['time'].values <= vals[1])) + + if len(ind) > 0: + indexes = np.append(indexes, ind) + + if indexes.size > 0: + ds.qcfilter.add_test( + var_name, + index=indexes, + test_meaning=description, + test_assessment=asses_name) + + var_name = '_all' + if apply_all and var_name in flag_dict.keys(): + for asses_name in flag_dict[var_name].keys(): + for description in flag_dict[var_name][asses_name]: + times = flag_dict[var_name][asses_name][description] + + if np.all(np.isnat(times)): + continue + + indexes = np.array([], dtype=np.int32) + for vals in times: + ind = np.argwhere( + (ds['time'].values >= vals[0]) & (ds['time'].values <= vals[1])) + if ind.size > 0: + indexes = np.append(indexes, np.ndarray.flatten(ind)) + + if indexes.size > 0: + for all_var_name in list(ds.data_vars): + if all_var_name in exclude_vars: + continue + + if 'time' not in ds[all_var_name].dims: + continue + + try: + if ds[all_var_name].attrs['standard_name'] == 'quality_flag': + continue + except KeyError: + pass + + ds.qcfilter.add_test( + all_var_name, + index=indexes, + test_meaning=description, + test_assessment=asses_name) diff --git a/act/qc/arm.py b/act/qc/arm.py index 7933200f0d..0fb84597d4 100644 --- a/act/qc/arm.py +++ b/act/qc/arm.py @@ -1,124 +1,202 @@ """ -act.qc.arm ------------------------------- - Functions specifically for working with QC/DQRs from -the Atmospheric Radiation Measurement Program (ARM) +the Atmospheric Radiation Measurement Program (ARM). """ -import requests import datetime as dt import numpy as np - - -def add_dqr_to_qc(obj, variable=None, assessment='incorrect,suspect', - exclude=None, include=None, normalize_assessment=True, - add_qc_variable=None): +import requests +import json + +from act.config import DEFAULT_DATASTREAM_NAME + + +def add_dqr_to_qc( + ds, + variable=None, + assessment='incorrect,suspect', + exclude=None, + include=None, + normalize_assessment=True, + cleanup_qc=True, + dqr_link=False, + skip_location_vars=False, +): """ Function to query the ARM DQR web service for reports and - add as a qc test. See online documentation from ARM Data - Quality Office on the use of the DQR web service + add as a new quality control test to ancillary quality control + variable. If no anicllary quality control variable exist a new + one will be created and lined to the data variable through + ancillary_variables attribure. + + See online documentation from ARM Data + Quality Office on the use of the DQR web service. https://code.arm.gov/docs/dqrws-examples/wikis/home + Information about the DQR web-service avaible at + https://adc.arm.gov/dqrws/ + Parameters ---------- - obj : xarray Dataset - Data object - variable : string or list - Variables to check DQR web service for + ds : xarray.Dataset + Xarray dataset + variable : string, or list of str, or None + Variables to check DQR web service. If set to None will + attempt to update all variables. assessment : string - assessment type to get DQRs for + assessment type to get DQRs. Current options include + 'missing', 'suspect', 'incorrect' or any combination separated + by a comma. exclude : list of strings - DQRs to exclude from adding into QC + DQR IDs to exclude from adding into QC include : list of strings - List of DQRs to use in flagging of data + List of DQR IDs to include in flagging of data. Any other DQR IDs + will be ignored. normalize_assessment : boolean The DQR assessment term is different than the embedded QC term. Embedded QC uses "Bad" and "Indeterminate" while DQRs use "Incorrect" and "Suspect". Setting this will ensure the same terms are used for both. - add_qc_varable : string or list - Variables to add QC information to + cleanup_qc : boolean + Call clean.cleanup() method to convert to standardized ancillary + quality control variables. Has a little bit of overhead so + if the Dataset has already been cleaned up, no need to run. + dqr_link : boolean + Prints out a link for each DQR to read the full DQR. Defaults to False + skip_location_vars : boolean + Does not apply DQRs to location variables. This can be useful in the event + the submitter has erroneously selected all variables. Returns ------- - obj : xarray Dataset - Data object + ds : xarray.Dataset + Xarray dataset containing new or updated quality control variables + + Examples + -------- + .. code-block:: python + + from act.qc.arm import add_dqr_to_qc + ds = add_dqr_to_qc(ds, variable=['temp_mean', 'atmos_pressure']) + """ - # DQR Webservice goes off datastreams, pull from object - if 'datastream' in obj.attrs: - datastream = obj.attrs['datastream'] - elif '_datastream' in obj.attrs: - datastream = obj.attrs['_datastream'] + # DQR Webservice goes off datastreams, pull from the dataset + if 'datastream' in ds.attrs: + datastream = ds.attrs['datastream'] + elif '_datastream' in ds.attrs: + datastream = ds.attrs['_datastream'] else: - raise ValueError('Object does not have datastream attribute') + raise ValueError('Dataset does not have datastream attribute') + + if datastream == DEFAULT_DATASTREAM_NAME: + raise ValueError("'datastream' name required for DQR service set to default value " + f"{datastream}. Unable to perform DQR service query.") # Clean up QC to conform to CF conventions - obj.clean.cleanup() + if cleanup_qc: + ds.clean.cleanup() + + start_date = ds['time'].values[0].astype('datetime64[s]').astype(dt.datetime).strftime('%Y%m%d') + end_date = ds['time'].values[-1].astype('datetime64[s]').astype(dt.datetime).strftime('%Y%m%d') + + # Clean up assessment to ensure it is a string with no spaces. + if isinstance(assessment, (list, tuple)): + assessment = ','.join(assessment) + + # Not strictly needed but should make things more better. + assessment = assessment.replace(' ', '') + assessment = assessment.lower() + + # Create URL + url = 'https://dqr-web-service.svcs.arm.gov/dqr_full' + url += f"/{datastream}" + url += f"/{start_date}/{end_date}" + url += f"/{assessment}" + + # Call web service + req = requests.get(url) + + # Check status values and raise error if not successful + status = req.status_code + if status == 400: + raise ValueError('Check parameters') + if status == 500: + raise ValueError('DQR Webservice Temporarily Down') + + # Convert from string to dictionary + docs = json.loads(req.text) + + # If no DQRs found will not have a key with datastream. + # The status will also be 404. + try: + docs = docs[datastream] + except KeyError: + return ds + + dqr_results = {} + for quality_category in docs: + for dqr_number in docs[quality_category]: + if exclude is not None and dqr_number in exclude: + continue + + if include is not None and dqr_number not in include: + continue - # In order to properly flag data, get all variables if None. Exclude QC variables. - if variable is None: - variable = list(set(obj.data_vars) - set(obj.clean.matched_qc_variables)) + index = np.array([], dtype=np.int32) + for time_range in docs[quality_category][dqr_number]['dates']: + starttime = np.datetime64(time_range['start_date']) + endtime = np.datetime64(time_range['end_date']) + ind = np.where((ds['time'].values >= starttime) & (ds['time'].values <= endtime)) + if ind[0].size > 0: + index = np.append(index, ind[0]) + + if index.size > 0: + dqr_results[dqr_number] = { + 'index': index, + 'test_assessment': quality_category.lower().capitalize(), + 'test_meaning': f"{dqr_number} : {docs[quality_category][dqr_number]['description']}", + 'variables': docs[quality_category][dqr_number]['variables'], + } + + if dqr_link: + print(f"{dqr_number} - {quality_category.lower().capitalize()}: " + f"https://adc.arm.gov/ArchiveServices/DQRService?dqrid={dqr_number}") # Check to ensure variable is list - if not isinstance(variable, (list, tuple)): + if variable and not isinstance(variable, (list, tuple)): variable = [variable] - # If add_qc_variable is none, set to variables list - if add_qc_variable is None: - add_qc_variable = variable - if not isinstance(add_qc_variable, (list, tuple)): - add_qc_variable = [add_qc_variable] - - # Loop through each variable and call web service for that variable - for i, var in enumerate(variable): - # Create URL - url = 'http://www.archive.arm.gov/dqrws/ARMDQR?datastream=' - url += datastream - url += '&varname=' + var - url += ''.join(['&searchmetric=', assessment, - '&dqrfields=dqrid,starttime,endtime,metric,subject']) - - # Call web service - req = requests.get(url) - - # Check status values and raise error if not successful - status = req.status_code - if status == 400: - raise ValueError('Check parameters') - if status == 500: - raise ValueError('DQR Webservice Temporarily Down') - - # Get data and run through each dqr - dqrs = req.text.splitlines() - time = obj['time'].values - for line in dqrs: - line = line.split('|') - # Exclude DQRs if in list - if exclude is not None and line[0] in exclude: + loc_vars = ['lat', 'lon', 'alt', 'latitude', 'longitude', 'altitude'] + for key, value in dqr_results.items(): + for var_name in value['variables']: + + # Do not process on location variables + if skip_location_vars and var_name in loc_vars: continue - # Only include if in include list - if include is not None and line[0] not in include: + # Only process provided variable names + if variable is not None and var_name not in variable: continue - line[1] = dt.datetime.utcfromtimestamp(int(line[1])) - line[2] = dt.datetime.utcfromtimestamp(int(line[2])) - ind = np.where((time >= np.datetime64(line[1])) & (time <= np.datetime64(line[2]))) - if len(ind[0]) == 0: + try: + ds.qcfilter.add_test( + var_name, + index=np.unique(value['index']), + test_meaning=value['test_meaning'], + test_assessment=value['test_assessment']) + + except KeyError: # Variable name not in Dataset continue - # Add flag to object - index = sorted(list(ind)) - name = ': '.join([line[0], line[-1]]) - assess = line[3] - obj.qcfilter.add_test(add_qc_variable[i], index=index, test_meaning=name, test_assessment=assess) + except IndexError: + print(f"Skipping '{var_name}' DQR application because of IndexError") + continue - if normalize_assessment: - obj.clean.normalize_assessment(variables=add_qc_variable[i]) + if normalize_assessment: + ds.clean.normalize_assessment(variables=var_name) - return obj + return ds diff --git a/act/qc/bsrn_tests.py b/act/qc/bsrn_tests.py new file mode 100644 index 0000000000..c585d01770 --- /dev/null +++ b/act/qc/bsrn_tests.py @@ -0,0 +1,594 @@ +""" +Functions and methods for performing solar radiation tests taken from +the BSRN Global Network recommended QC tests, V2.0 + +https://bsrn.awi.de + +""" + +import warnings +import numpy as np +import dask.array as da +from scipy.constants import Stefan_Boltzmann + +from act.utils.geo_utils import get_solar_azimuth_elevation +from act.utils.data_utils import convert_units + + +def _calculate_solar_parameters(ds, lat_name, lon_name, solar_constant): + """ + Function to calculate solar zenith angles and solar constant adjusted + to Earth Sun distance + + Parameters + ---------- + ds : xarray.Dataset + Dataset containing location variables + lat_name : str + Variable name for latitude + lon_name : str + Variable name for longitude + solar_constant : float + Solar constant in W/m^2 + + Returns + ------- + Tuple containing (solar zenith angle array, solar constant scalar) + + """ + latitude = ds[lat_name].values + if latitude.size > 1: + latitude = latitude[0] + longitude = ds[lon_name].values + if longitude.size > 1: + longitude = longitude[0] + + # Calculate solar parameters + elevation, _, solar_distance = get_solar_azimuth_elevation( + latitude=latitude, longitude=longitude, time=ds['time'].values) + solar_distance = np.nanmean(solar_distance) + Sa = solar_constant / solar_distance**2 + + sza = 90. - elevation + + return (sza, Sa) + + +def _find_indexes(ds, var_name, min_limit, max_limit, use_dask): + """ + Function to find array indexes where failing limit tests + + Parameters + ---------- + ds : xarray.Dataset + Dataset containing data to use in test + var_name : str + Variable name to inspect + min_limit : float or numpy array + Minimum limit to use for returning indexes + max_limit : float or numpy array + Maximum limit to use for returning indexes + use_dask : boolean + Option to use Dask operations instead of Numpy + + Returns + ------- + Tuple containing solar zenith angle array and solar constant scalar + + """ + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(ds[var_name].data, da.Array): + index_min = da.where(ds[var_name].data < min_limit, True, False).compute() + index_max = da.where(ds[var_name].data > max_limit, True, False).compute() + else: + index_min = np.less(ds[var_name].values, min_limit) + index_max = np.greater(ds[var_name].values, max_limit) + + return (index_min, index_max) + + +class QCTests: + """ + This is a Mixins class used to allow using qcfilter class that is already + registered to the Xarray dataset. All the methods in this class will be added + to the qcfilter class. Doing this to make the code spread across more files + so it is more manageable and readable. Additinal files of tests can be added + to qcfilter by creating a new class in the new file and adding to qcfilter + class declaration. + + """ + + def bsrn_limits_test( + self, + test='Physically Possible', + gbl_SW_dn_name=None, + glb_diffuse_SW_dn_name=None, + direct_normal_SW_dn_name=None, + direct_SW_dn_name=None, + glb_SW_up_name=None, + glb_LW_dn_name=None, + glb_LW_up_name=None, + sw_min_limit=None, + lw_min_dn_limit=None, + lw_min_up_limit=None, + lw_max_dn_limit=None, + lw_max_up_limit=None, + solar_constant=1366, + lat_name='lat', + lon_name='lon', + use_dask=False + ): + + """ + Method to apply BSRN limits test and add results to ancillary quality control variable. + Need to provide variable name for each measurement for the test to be performed. If no + limits provided will use default values. All data must be in W/m^2 units. Test will + provided exception if required variable name is missing. + + Parameters + ---------- + test : str + Type of tests to apply. Options include "Physically Possible" or "Extremely Rare" + gbl_SW_dn_name : str + Variable name in the Dataset for global shortwave downwelling radiation + measured by unshaded pyranometer + glb_diffuse_SW_dn_name : str + Variable name in the Dataset for global diffuse shortwave downwelling radiation + measured by shaded pyranometer + direct_normal_SW_dn_name : str + Variable name in the Dataset for direct normal shortwave downwelling radiation + direct_SW_dn_name : str + Variable name in the Dataset for direct shortwave downwelling radiation + glb_SW_up_name : str + Variable name in the Dataset for global shortwave upwelling radiation + glb_LW_dn_name : str + Variable name in the Dataset for global longwave downwelling radiation + glb_LW_up_name : str + Variable name in the Dataset for global longwave upwelling radiation + sw_min_limit : int or float + Lower limit for shortwave radiation test + lw_min_dn_limit : int or float + Lower limit for downwelling longwave radiation test measured by a pyrgeometer + lw_min_up_limit : int or float + Lower limit for upwelling longwave radiation test measured by a pyrgeometer + lw_max_dn_limit : int or float + Upper limit for downwelling longwave radiation test measured by a pyrgeometer + lw_max_up_limit : int or float + Upper limit for upwelling longwave radiation test measured by a pyrgeometer + solar_constant : int or float + Mean solar constant used in upper limit calculation. Earth sun distance will be + calculated and applied to this value. + lat_name : str + Variable name in the Dataset for latitude + lon_name : str + Variable name in the Dataset for longitude + use_dask : boolean + Option to use Dask for processing if data is stored in a Dask array + + References + ---------- + Long, Charles N., and Ellsworth G. Dutton. "BSRN Global Network recommended QC tests, V2. x." (2010). + + Examples + -------- + .. code-block:: python + + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_BRS, cleanup_qc=True) + ds.qcfilter.bsrn_limits_test( + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', + glb_SW_up_name='up_short_hemisp', + glb_LW_dn_name='down_long_hemisp_shaded', + glb_LW_up_name='up_long_hemisp') + """ + + test_names_org = ["Physically Possible", "Extremely Rare"] + test = test.lower() + test_names = [ii.lower() for ii in test_names_org] + if test not in test_names: + raise ValueError(f"Value of '{test}' in keyword 'test' not recognized. " + f"Must a single value in options {test_names_org}") + + sza, Sa = _calculate_solar_parameters(self._ds, lat_name, lon_name, solar_constant) + + if test == test_names[0]: + if sw_min_limit is None: + sw_min_limit = -4. + if lw_min_dn_limit is None: + lw_min_dn_limit = 40. + if lw_min_up_limit is None: + lw_min_up_limit = 40. + if lw_max_dn_limit is None: + lw_max_dn_limit = 700. + if lw_max_up_limit is None: + lw_max_up_limit = 900. + elif test == test_names[1]: + if sw_min_limit is None: + sw_min_limit = -2. + if lw_min_dn_limit is None: + lw_min_dn_limit = 60. + if lw_min_up_limit is None: + lw_min_up_limit = 60. + if lw_max_dn_limit is None: + lw_max_dn_limit = 500. + if lw_max_up_limit is None: + lw_max_up_limit = 700. + + # Global Shortwave downwelling min and max tests + if gbl_SW_dn_name is not None: + cos_sza = np.cos(np.radians(sza)) + cos_sza[sza > 90.] = 0. + if test == test_names[0]: + sw_max_limit = Sa * 1.5 * cos_sza**1.2 + 100. + elif test == test_names[1]: + sw_max_limit = Sa * 1.2 * cos_sza**1.2 + 50. + + index_min, index_max = _find_indexes(self._ds, gbl_SW_dn_name, sw_min_limit, sw_max_limit, use_dask) + + self._ds.qcfilter.add_test( + gbl_SW_dn_name, index=index_min, test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + + self._ds.qcfilter.add_test( + gbl_SW_dn_name, index=index_max, test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit") + + # Diffuse Shortwave downwelling min and max tests + if glb_diffuse_SW_dn_name is not None: + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if test == test_names[0]: + sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza))**1.2 + 50. + elif test == test_names[1]: + sw_max_limit = Sa * 0.75 * np.cos(np.radians(sza))**1.2 + 30. + + index_min, index_max = _find_indexes(self._ds, glb_diffuse_SW_dn_name, sw_min_limit, + sw_max_limit, use_dask) + self._ds.qcfilter.add_test( + glb_diffuse_SW_dn_name, index=index_min, test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + + self._ds.qcfilter.add_test( + glb_diffuse_SW_dn_name, index=index_max, test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit") + + # Direct Normal Shortwave downwelling min and max tests + if direct_normal_SW_dn_name is not None: + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if test == test_names[0]: + sw_max_limit = Sa + elif test == test_names[1]: + sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza))**0.2 + 10. + + index_min, index_max = _find_indexes(self._ds, direct_normal_SW_dn_name, + sw_min_limit, sw_max_limit, use_dask) + self._ds.qcfilter.add_test( + direct_normal_SW_dn_name, index=index_min, test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + + self._ds.qcfilter.add_test( + direct_normal_SW_dn_name, index=index_max, test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit") + + # Direct Shortwave downwelling min and max tests + if direct_SW_dn_name is not None: + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if test == test_names[0]: + sw_max_limit = Sa * np.cos(np.radians(sza)) + elif test == test_names[1]: + sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza))**1.2 + 10 + + index_min, index_max = _find_indexes(self._ds, direct_SW_dn_name, + sw_min_limit, sw_max_limit, use_dask) + + self._ds.qcfilter.add_test( + direct_SW_dn_name, index=index_min, test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + + self._ds.qcfilter.add_test( + direct_SW_dn_name, index=index_max, test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit") + + # Shortwave up welling min and max tests + if glb_SW_up_name is not None: + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if test == test_names[0]: + sw_max_limit = Sa * 1.2 * np.cos(np.radians(sza))**1.2 + 50 + elif test == test_names[1]: + sw_max_limit = Sa * np.cos(np.radians(sza))**1.2 + 50 + + index_min, index_max = _find_indexes(self._ds, glb_SW_up_name, + sw_min_limit, sw_max_limit, use_dask) + + self._ds.qcfilter.add_test( + glb_SW_up_name, index=index_min, test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + + self._ds.qcfilter.add_test( + glb_SW_up_name, index=index_max, test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit") + + # Longwave downwelling min and max tests + if glb_LW_dn_name is not None: + index_min, index_max = _find_indexes(self._ds, glb_LW_dn_name, + lw_min_dn_limit, lw_max_dn_limit, use_dask) + + self._ds.qcfilter.add_test( + glb_LW_dn_name, index=index_min, test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {lw_min_dn_limit} W/m^2") + + self._ds.qcfilter.add_test( + glb_LW_dn_name, index=index_max, test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit of {lw_max_dn_limit} W/m^2") + + # Longwave upwelling min and max tests + if glb_LW_up_name is not None: + index_min, index_max = _find_indexes(self._ds, glb_LW_up_name, + lw_min_up_limit, lw_max_up_limit, use_dask) + + self._ds.qcfilter.add_test( + glb_LW_up_name, index=index_min, test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {lw_min_up_limit} W/m^2") + + self._ds.qcfilter.add_test( + glb_LW_up_name, index=index_max, test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit of {lw_max_up_limit} W/m^2") + + def bsrn_comparison_tests( + self, + test, + gbl_SW_dn_name=None, + glb_diffuse_SW_dn_name=None, + direct_normal_SW_dn_name=None, + glb_SW_up_name=None, + glb_LW_dn_name=None, + glb_LW_up_name=None, + air_temp_name=None, + test_assessment='Indeterminate', + lat_name='lat', + lon_name='lon', + LWdn_lt_LWup_component=25., + LWdn_gt_LWup_component=300., + use_dask=False + ): + """ + Method to apply BSRN comparison tests and add results to ancillary quality control variable. + Need to provided variable name for each measurement for the test to be performed. All radiation + data must be in W/m^2 units. Test will provided exception if required variable name is missing. + + Parameters + ---------- + test : str + Type of tests to apply. Options include: 'Global over Sum SW Ratio', 'Diffuse Ratio', + 'SW up', 'LW down to air temp', 'LW up to air temp', 'LW down to LW up' + gbl_SW_dn_name : str + Variable name in Dataset for global shortwave downwelling radiation + measured by unshaded pyranometer + glb_diffuse_SW_dn_name : str + Variable name in Dataset for global diffuse shortwave downwelling radiation + measured by shaded pyranometer + direct_normal_SW_dn_name : str + Variable name in Dataset for direct normal shortwave downwelling radiation + glb_SW_up_name : str + Variable name in Dataset for global shortwave upwelling radiation + glb_LW_dn_name : str + Variable name in Dataset for global longwave downwelling radiation + glb_LW_up_name : str + Variable name in Dataset for global longwave upwelling radiation + air_temp_name : str + Variable name in Dataset for atmospheric air temperature. Variable used + in longwave tests. + test_assessment : str + Test assessment string value appended to flag_assessments attribute of QC variable. + lat_name : str + Variable name in the Dataset for latitude + lon_name : str + Variable name in the Dataset for longitude + LWdn_lt_LWup_component : int or float + Value used in longwave down less than longwave up test. + LWdn_gt_LWup_component : int or float + Value used in longwave down greater than longwave up test. + use_dask : boolean + Option to use Dask for processing if data is stored in a Dask array + + References + ---------- + Long, Charles N., and Ellsworth G. Dutton. "BSRN Global Network recommended QC tests, V2. x." (2010). + + Examples + -------- + .. code-block:: python + + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_BRS, cleanup_qc=True) + ds.qcfilter.bsrn_comparison_tests( + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', + glb_SW_up_name='up_short_hemisp', + glb_LW_dn_name='down_long_hemisp_shaded', + glb_LW_up_name='up_long_hemisp', + use_dask=True) + """ + + if isinstance(test, str): + test = [test] + + test_options = ['Global over Sum SW Ratio', 'Diffuse Ratio', 'SW up', 'LW down to air temp', + 'LW up to air temp', 'LW down to LW up'] + + solar_constant = 1360.8 + sza, Sa = _calculate_solar_parameters(self._ds, lat_name, lon_name, solar_constant) + + # Ratio of Global over Sum SW + if test_options[0] in test: + if gbl_SW_dn_name is None or glb_diffuse_SW_dn_name is None or direct_normal_SW_dn_name is None: + raise ValueError('Must set keywords gbl_SW_dn_name, glb_diffuse_SW_dn_name, ' + f'direct_normal_SW_dn_name for {test_options[0]} test.') + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[glb_diffuse_SW_dn_name].data, da.Array): + sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].data + + self._ds[direct_normal_SW_dn_name].data * np.cos(np.radians(sza))) + sum_sw_down[sum_sw_down < 50] = np.nan + ratio = self._ds[gbl_SW_dn_name].data / sum_sw_down + index_a = sza < 75 + index_1 = da.where((ratio > 1.08) & index_a, True, False) + index_2 = da.where((ratio < 0.92) & index_a, True, False) + index_b = (sza >= 75) & (sza < 93) + index_3 = da.where((ratio > 1.15) & index_b & index_b, True, False) + index_4 = da.where((ratio < 0.85) & index_b, True, False) + index = (index_1 | index_2 | index_3 | index_4).compute() + else: + sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].values + + self._ds[direct_normal_SW_dn_name].values * np.cos(np.radians(sza))) + sum_sw_down[sum_sw_down < 50] = np.nan + ratio = self._ds[gbl_SW_dn_name].values / sum_sw_down + index_a = sza < 75 + index_1 = (ratio > 1.08) & index_a + index_2 = (ratio < 0.92) & index_a + index_b = (sza >= 75) & (sza < 93) + index_3 = (ratio > 1.15) & index_b + index_4 = (ratio < 0.85) & index_b + index = index_1 | index_2 | index_3 | index_4 + + test_meaning = "Ratio of Global over Sum shortwave larger than expected" + self._ds.qcfilter.add_test(gbl_SW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + self._ds.qcfilter.add_test(glb_diffuse_SW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + self._ds.qcfilter.add_test(direct_normal_SW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + + # Diffuse Ratio + if test_options[1] in test: + if gbl_SW_dn_name is None or glb_diffuse_SW_dn_name is None: + raise ValueError('Must set keywords gbl_SW_dn_name, glb_diffuse_SW_dn_name ' + f'for {test_options[1]} test.') + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[glb_diffuse_SW_dn_name].data, da.Array): + ratio = self._ds[glb_diffuse_SW_dn_name].data / self._ds[gbl_SW_dn_name].data + ratio[self._ds[gbl_SW_dn_name].data < 50] = np.nan + index_a = sza < 75 + index_1 = da.where((ratio >= 1.05) & index_a, True, False) + index_b = (sza >= 75) & (sza < 93) + index_2 = da.where((ratio >= 1.10) & index_b, True, False) + index = (index_1 | index_2).compute() + else: + ratio = self._ds[glb_diffuse_SW_dn_name].values / self._ds[gbl_SW_dn_name].values + ratio[self._ds[gbl_SW_dn_name].values < 50] = np.nan + index_a = sza < 75 + index_1 = (ratio >= 1.05) & index_a + index_b = (sza >= 75) & (sza < 93) + index_2 = (ratio >= 1.10) & index_b + index = index_1 | index_2 + + test_meaning = "Ratio of Diffuse Shortwave over Global Shortwave larger than expected" + self._ds.qcfilter.add_test(gbl_SW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + self._ds.qcfilter.add_test(glb_diffuse_SW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + + # Shortwave up comparison + if test_options[2] in test: + if glb_SW_up_name is None or glb_diffuse_SW_dn_name is None or direct_normal_SW_dn_name is None: + raise ValueError('Must set keywords glb_SW_up_name, glb_diffuse_SW_dn_name, ' + f'direct_normal_SW_dn_name for {test_options[2]} test.') + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[glb_diffuse_SW_dn_name].data, da.Array): + sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].data + + self._ds[direct_normal_SW_dn_name].data * np.cos(np.radians(sza))) + + sum_sw_down[sum_sw_down < 50] = np.nan + index = da.where(self._ds[glb_SW_up_name].data > sum_sw_down, True, False).compute() + else: + sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].values + + self._ds[direct_normal_SW_dn_name].values * np.cos(np.radians(sza))) + sum_sw_down[sum_sw_down < 50] = np.nan + index = self._ds[glb_SW_up_name].values > sum_sw_down + + test_meaning = "Ratio of Shortwave Upwelling greater than Shortwave Sum" + self._ds.qcfilter.add_test(glb_SW_up_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + self._ds.qcfilter.add_test(glb_diffuse_SW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + self._ds.qcfilter.add_test(direct_normal_SW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + + # Longwave down to air temperature comparison + if test_options[3] in test: + if glb_LW_dn_name is None or air_temp_name is None: + raise ValueError('Must set keywords glb_LW_dn_name, air_temp_name ' + f' for {test_options[3]} test.') + + air_temp = convert_units(self._ds[air_temp_name].values, + self._ds[air_temp_name].attrs['units'], 'degK') + if use_dask and isinstance(self._ds[glb_LW_dn_name].data, da.Array): + air_temp = da.array(air_temp) + conversion = da.array(Stefan_Boltzmann * air_temp**4) + index_1 = (0.4 * conversion) > self._ds[glb_LW_dn_name].data + index_2 = (conversion + 25.) < self._ds[glb_LW_dn_name].data + index = (index_1 | index_2).compute() + else: + conversion = Stefan_Boltzmann * air_temp**4 + index_1 = (0.4 * conversion) > self._ds[glb_LW_dn_name].values + index_2 = (conversion + 25.) < self._ds[glb_LW_dn_name].values + index = index_1 | index_2 + + test_meaning = "Longwave downwelling comparison to air temperature out side of expected range" + self._ds.qcfilter.add_test(glb_LW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + + # Longwave up to air temperature comparison + if test_options[4] in test: + if glb_LW_up_name is None or air_temp_name is None: + raise ValueError('Must set keywords glb_LW_up_name, air_temp_name ' + f'for {test_options[3]} test.') + + air_temp = convert_units(self._ds[air_temp_name].values, + self._ds[air_temp_name].attrs['units'], 'degK') + if use_dask and isinstance(self._ds[glb_LW_up_name].data, da.Array): + air_temp = da.array(air_temp) + index_1 = (Stefan_Boltzmann * (air_temp - 15)**4) > self._ds[glb_LW_up_name].data + index_2 = (Stefan_Boltzmann * (air_temp + 25)**4) < self._ds[glb_LW_up_name].data + index = (index_1 | index_2).compute() + else: + index_1 = (Stefan_Boltzmann * (air_temp - 15)**4) > self._ds[glb_LW_up_name].values + index_2 = (Stefan_Boltzmann * (air_temp + 25)**4) < self._ds[glb_LW_up_name].values + index = index_1 | index_2 + + test_meaning = "Longwave upwelling comparison to air temperature out side of expected range" + self._ds.qcfilter.add_test(glb_LW_up_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + + # Lonwave down to longwave up comparison + if test_options[5] in test: + if glb_LW_dn_name is None or glb_LW_up_name is None: + raise ValueError('Must set keywords glb_LW_dn_name, glb_LW_up_name ' + f'for {test_options[3]} test.') + + if use_dask and isinstance(self._ds[glb_LW_dn_name].data, da.Array): + index_1 = da.where(self._ds[glb_LW_dn_name].data + > (self._ds[glb_LW_up_name].data + LWdn_lt_LWup_component), True, False) + index_2 = da.where(self._ds[glb_LW_dn_name].data + < (self._ds[glb_LW_up_name].data - LWdn_gt_LWup_component), True, False) + index = (index_1 | index_2).compute() + else: + index_1 = self._ds[glb_LW_dn_name].values > (self._ds[glb_LW_up_name].values + LWdn_lt_LWup_component) + index_2 = self._ds[glb_LW_dn_name].values < (self._ds[glb_LW_up_name].values - LWdn_gt_LWup_component) + index = index_1 | index_2 + + test_meaning = "Lonwave downwelling compared to longwave upwelling outside of expected range" + self._ds.qcfilter.add_test(glb_LW_dn_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) + self._ds.qcfilter.add_test(glb_LW_up_name, index=index, test_assessment=test_assessment, + test_meaning=test_meaning) diff --git a/act/qc/clean.py b/act/qc/clean.py index 3a5451da1d..c84a30efef 100644 --- a/act/qc/clean.py +++ b/act/qc/clean.py @@ -1,25 +1,26 @@ """ -act.qc.clean ------------------------------- - Class definitions for cleaning up QC variables to standard -cf-compliance +cf-compliance. """ -import xarray as xr +import copy import re + import numpy as np -import copy +import xarray as xr + +from act.qc.qcfilter import parse_bit @xr.register_dataset_accessor('clean') -class CleanDataset(object): +class CleanDataset: """ Class for cleaning up QC variables to standard cf-compliance """ - def __init__(self, xarray_obj): - self._obj = xarray_obj + + def __init__(self, ds): + self._ds = ds @property def matched_qc_variables(self, check_arm_syntax=True): @@ -41,56 +42,67 @@ def matched_qc_variables(self, check_arm_syntax=True): A list of strings containing the name of each variable. """ - variables = [] # Will need to find all historical cases and add to list - qc_dict = {'description': - ["See global attributes for individual.+bit descriptions.", - ("This field contains bit packed integer values, where each " - "bit represents a QC test on the data. Non-zero bits indicate " - "the QC condition given in the description for those bits; " - "a value of 0.+ indicates the data has not " - "failed any QC tests."), - (r"This field contains bit packed values which should be " - r"interpreted as listed..+") - ] - } + description_list = [ + 'See global attributes for individual.+bit descriptions.', + ( + 'This field contains bit packed integer values, where each ' + 'bit represents a QC test on the data. Non-zero bits indicate ' + 'the QC condition given in the description for those bits; ' + 'a value of 0.+ indicates the data has not ' + 'failed any QC tests.' + ), + (r'This field contains bit packed values which should be ' r'interpreted as listed..+'), + ] # Loop over each variable and look for a match to an attribute that - # would exist if the variable is a QC variable - for var in self._obj.data_vars: - attributes = self._obj[var].attrs - for att_name in attributes: - if att_name in qc_dict.keys(): - for value in qc_dict[att_name]: - if re.match(value, attributes[att_name]) is not None: - variables.append(var) - break + # would exist if the variable is a QC variable. + variables = [] + for var in self._ds.data_vars: + try: + if self._ds[var].attrs['standard_name'] == 'quality_flag': + variables.append(var) + continue + except KeyError: + pass + + if check_arm_syntax and var.startswith('qc_'): + variables.append(var) + continue + + try: + for desc in description_list: + if re.match(desc, self._ds[var].attrs['description']) is not None: + variables.append(var) + break + except KeyError: + pass - # Check the start of the variable name. If it begins with qc_ assume quality - # control variable from ARM. - if check_arm_syntax: - variables_qc = [var for var in self._obj.data_vars if var.startswith('qc_')] - variables = variables + variables_qc - variables = list(set(variables)) + variables = list(set(variables)) return variables - def cleanup(self, cleanup_arm_qc=True, clean_arm_state_vars=None, - handle_missing_value=True, link_qc_variables=True, - normalize_assessment=False, - **kwargs): + def cleanup( + self, + cleanup_arm_qc=True, + clean_arm_state_vars=None, + handle_missing_value=True, + link_qc_variables=True, + normalize_assessment=False, + cleanup_cf_qc=True, + **kwargs, + ): """ Wrapper method to automatically call all the standard methods - for obj cleanup. + for dataset cleanup. Parameters ---------- cleanup_arm_qc : bool - Option to clean xarray object from ARM QC to CF QC standards. - Default is True. + Option to clean Xarray dataset from ARM QC to CF QC standards. clean_arm_state_vars : list of str - Option to clean xarray object state variables from ARM to CF + Option to clean Xarray dataset state variables from ARM to CF standards. Pass in list of variable names. handle_missing_value : bool Go through variables and look for cases where a QC or state varible @@ -110,33 +122,45 @@ def cleanup(self, cleanup_arm_qc=True, clean_arm_state_vars=None, Keyword arguments passed through to clean.clean_arm_qc method. + Examples + -------- + .. code-block:: python + + files = act.tests.sample_files.EXAMPLE_MET1 + ds = act.io.arm.read_arm_netcdf(files) + ds.clean.cleanup() + """ # Convert ARM QC to be more like CF state fields if cleanup_arm_qc: - self._obj.clean.clean_arm_qc(**kwargs) + self._ds.clean.clean_arm_qc(**kwargs) # Convert ARM state fields to be more liek CF state fields if clean_arm_state_vars is not None: - self._obj.clean.clean_arm_state_variables(clean_arm_state_vars) + self._ds.clean.clean_arm_state_variables(clean_arm_state_vars) # Correctly convert data type because of missing value # indicators in state and QC variables. Needs to be run after # clean.clean_arm_qc to use CF attribute names. if handle_missing_value: - self._obj.clean.handle_missing_values() + self._ds.clean.handle_missing_values() # Add some ancillary_variables linkages # between data variable and QC variable if link_qc_variables: - self._obj.clean.link_variables() + self._ds.clean.link_variables() # Update the terminology used with flag_assessments to be consistent if normalize_assessment: - self._obj.clean.normalize_assessment() + self._ds.clean.normalize_assessment() + + # Update from CF to standard used in ACT + if cleanup_cf_qc: + self._ds.clean.clean_cf_qc(**kwargs) def handle_missing_values(self, default_missing_value=np.int32(-9999)): """ - Correctly handle missing_value and _FillValue in object. + Correctly handle missing_value and _FillValue in the dataset. xarray will automatically replace missing_value and _FillValue in the data with NaN. This is great for data set as type float but not great for int data. Can cause issues @@ -155,18 +179,25 @@ def handle_missing_values(self, default_missing_value=np.int32(-9999)): is not defined but one is needed. """ - state_att_names = ['flag_values', 'flag_meanings', - 'flag_masks', 'flag_attributes'] + state_att_names = [ + 'flag_values', + 'flag_meanings', + 'flag_masks', + 'flag_attributes', + ] # Look for variables that have 2 of the state_att_names defined # as attribures and is of type float. If so assume the variable # was incorreclty converted to float type. - for var in self._obj.data_vars: - var_att_names = self._obj[var].attrs.keys() - if (len(set(state_att_names) & set(var_att_names)) >= 2 and - self._obj[var].values.dtype in - [np.dtype('float16'), np.dtype('float32'), - np.dtype('float64')]): + for var in self._ds.data_vars: + var_att_names = self._ds[var].attrs.keys() + if len(set(state_att_names) & set(var_att_names)) >= 2 and self._ds[ + var + ].values.dtype in [ + np.dtype('float16'), + np.dtype('float32'), + np.dtype('float64'), + ]: # Look at units variable to see if this is the stupid way some # ARM products mix data and state variables. If the units are not @@ -175,15 +206,13 @@ def handle_missing_values(self, default_missing_value=np.int32(-9999)): # and skip. This is commented out for now since the units check # appears to be working. try: - if self._obj[var].attrs['units'] not in ['1', 'unitless', '', ' ']: + if self._ds[var].attrs['units'] not in ['1', 'unitless', '', ' ']: continue -# self._obj[var].attrs['valid_range'] -# continue except KeyError: pass # Change any np.nan values to missing value indicator - data = self._obj[var].values + data = self._ds[var].values data[np.isnan(data)] = default_missing_value.astype(data.dtype) # Convert data to match type of flag_mask or flag_values @@ -191,15 +220,21 @@ def handle_missing_values(self, default_missing_value=np.int32(-9999)): found_dtype = False for att_name in ['flag_masks', 'flag_values']: try: - att_value = self._obj[var].attrs[att_name] + att_value = self._ds[var].attrs[att_name] if isinstance(att_value, (list, tuple)): dtype = att_value[0].dtype + elif isinstance(att_value, str): + dtype = default_missing_value.dtype + att_value = att_value.replace(',', ' ').split() + att_value = np.array(att_value, dtype=dtype) + self._ds[var].attrs[att_name] = att_value + dtype = default_missing_value.dtype else: dtype = att_value.dtype data = data.astype(dtype) found_dtype = True break - except (KeyError, IndexError): + except (KeyError, IndexError, AttributeError): pass # If flag_mask or flag_values is not available choose an int type @@ -207,11 +242,10 @@ def handle_missing_values(self, default_missing_value=np.int32(-9999)): if found_dtype is False: data = data.astype(default_missing_value.dtype) - # Return data to object and add missing value indicator + # Return data to the dataset and add missing value indicator # attribute to variable. - self._obj[var].values = data - self._obj[var].attrs['missing_value'] = \ - default_missing_value.astype(data.dtype) + self._ds[var].values = data + self._ds[var].attrs['missing_value'] = default_missing_value.astype(data.dtype) def get_attr_info(self, variable=None, flag=False): """ @@ -245,7 +279,7 @@ def get_attr_info(self, variable=None, flag=False): else: found_string = False try: - if self._obj.attrs['qc_bit_comment']: + if self._ds.attrs['qc_bit_comment']: string = 'bit' found_string = True except KeyError: @@ -253,7 +287,7 @@ def get_attr_info(self, variable=None, flag=False): if found_string is False: try: - if self._obj.attrs['qc_flag_comment']: + if self._ds.attrs['qc_flag_comment']: string = 'flag' found_string = True except KeyError: @@ -263,30 +297,24 @@ def get_attr_info(self, variable=None, flag=False): var = self.matched_qc_variables if len(var) > 0: try: - if self._obj[variable].attrs['flag_method'] == 'integer': + if self._ds[variable].attrs['flag_method'] == 'integer': string = 'flag' found_string = True - del self._obj[variable].attrs['flag_method'] + del self._ds[variable].attrs['flag_method'] except KeyError: pass try: if variable: - attr_description_pattern = (r"(^" + string + - r")_([0-9]+)_(description$)") - attr_assessment_pattern = (r"(^" + string + - r")_([0-9]+)_(assessment$)") - attr_comment_pattern = (r"(^" + string + - r")_([0-9]+)_(comment$)") - attributes = self._obj[variable].attrs + attr_description_pattern = r'(^' + string + r')_([0-9]+)_(description$)' + attr_assessment_pattern = r'(^' + string + r')_([0-9]+)_(assessment$)' + attr_comment_pattern = r'(^' + string + r')_([0-9]+)_(comment$)' + attributes = self._ds[variable].attrs else: - attr_description_pattern = (r"(^qc_" + string + - r")_([0-9]+)_(description$)") - attr_assessment_pattern = (r"(^qc_" + string + - r")_([0-9]+)_(assessment$)") - attr_comment_pattern = (r"(^qc_" + string + - r")_([0-9]+)_(comment$)") - attributes = self._obj.attrs + attr_description_pattern = r'(^qc_' + string + r')_([0-9]+)_(description$)' + attr_assessment_pattern = r'(^qc_' + string + r')_([0-9]+)_(assessment$)' + attr_comment_pattern = r'(^qc_' + string + r')_([0-9]+)_(comment$)' + attributes = self._ds.attrs except KeyError: return None @@ -326,20 +354,17 @@ def get_attr_info(self, variable=None, flag=False): pass if variable is not None: - # Try and get the data type from the variable if it is an int + # Try and get the data type from the variable if it is an integer + # If not an integer make the flag values integers. try: - if (self._obj[variable].values.dtype in [ - np.dtype('int8'), np.dtype('int16'), - np.dtype('int32'), np.dtype('int64')]): - dtype = self._obj[variable].values.dtype + dtype = self._ds[variable].values.dtype + if np.issubdtype(dtype, np.integer): + pass + else: + dtype = np.int32 except AttributeError: pass - # If the data is type float check the largest value and make - # sure the type we set can handle it. - if np.nanmax(self._obj[variable].values) > 2**32 - 1: - dtype = np.int64 - # Sort on bit number to ensure correct description order index = np.argsort(description_bit_num) flag_meanings = np.array(flag_meanings) @@ -377,43 +402,69 @@ def get_attr_info(self, variable=None, flag=False): # build dictionary to return values if len(flag_masks) > 0 or len(description_bit_num) > 0: return_dict = dict() - return_dict['flag_meanings'] = list(np.array(flag_meanings, - dtype=str)) - if len(flag_masks) > 0 and max(flag_masks) > 2**32 - 1: - flag_mask_dtype = np.int64 + return_dict['flag_meanings'] = list(np.array(flag_meanings, dtype=str)) + + if len(flag_masks) > 0 and max(flag_masks) > np.iinfo(np.uint32).max: + flag_mask_dtype = np.uint64 else: - flag_mask_dtype = dtype + flag_mask_dtype = np.uint32 if flag: - return_dict['flag_values'] = list(np.array(description_bit_num, - dtype=dtype)) - return_dict['flag_masks'] = list(np.array([], - dtype=flag_mask_dtype)) + return_dict['flag_values'] = list(np.array(description_bit_num, dtype=dtype)) + return_dict['flag_masks'] = list(np.array([], dtype=flag_mask_dtype)) else: - return_dict['flag_values'] = list(np.array([], - dtype=dtype)) - return_dict['flag_masks'] = list(np.array(flag_masks, - dtype=flag_mask_dtype)) - - return_dict['flag_assessments'] = list(np.array(flag_assessments, - dtype=str)) - return_dict['flag_tests'] = list(np.array(description_bit_num, - dtype=dtype)) - return_dict['flag_comments'] = list(np.array(flag_comments, - dtype=str)) + return_dict['flag_values'] = list(np.array([], dtype=dtype)) + return_dict['flag_masks'] = list(np.array(flag_masks, dtype=flag_mask_dtype)) + + return_dict['flag_assessments'] = list(np.array(flag_assessments, dtype=str)) + return_dict['flag_tests'] = list(np.array(description_bit_num, dtype=dtype)) + return_dict['flag_comments'] = list(np.array(flag_comments, dtype=str)) return_dict['arm_attributes'] = arm_attributes else: # If nothing to return set to None return_dict = None + # If no QC is found but there's a Mentor_QC_Field_Information global attribute, + # hard code the information. This is for older ARM files that had QC information + # in this global attribute. For these cases, this should hold 100% + if return_dict is None and 'Mentor_QC_Field_Information' in self._ds.attrs: + qc_att = self._ds.attrs['Mentor_QC_Field_Information'] + if 'Basic mentor QC checks' in qc_att: + if len(qc_att) == 920 or len(qc_att) == 1562: + return_dict = dict() + return_dict['flag_meanings'] = [ + 'Value is equal to missing_value.', + 'Value is less than the valid_min.', + 'Value is greater than the valid_max.', + 'Difference between current and previous values exceeds valid_delta.' + ] + return_dict['flag_tests'] = [1, 2, 3, 4] + return_dict['flag_masks'] = [1, 2, 4, 8] + return_dict['flag_assessments'] = ['Bad', 'Bad', 'Bad', 'Indeterminate'] + return_dict['flag_values'] = [] + return_dict['flag_comments'] = [] + return_dict['arm_attributes'] = [ + 'bit_1_description', + 'bit_1_assessment', + 'bit_2_description', + 'bit_2_assessment', + 'bit_3_description', + 'bit_3_assessment', + 'bit_4_description', + 'bit_4_assessment' + ] + return return_dict - def clean_arm_state_variables(self, - variables, - override_cf_flag=True, - clean_units_string=True, - integer_flag=True): + def clean_arm_state_variables( + self, + variables, + override_cf_flag=True, + clean_units_string=True, + integer_flag=True, + replace_in_flag_meanings=None, + ): """ Function to clean up state variables to use more CF style. @@ -429,6 +480,11 @@ def clean_arm_state_variables(self, udunits compliant '1'. integer_flag : bool Pass through keyword of 'flag' for get_attr_info(). + replace_in_flag_meanings : None or string + Character string to search and replace in each flag meanings array value + to increase readability since the flag_meanings stored in netCDF file + is a single character array separated by space character. Alows for + replacing things like "_" with space character. """ if isinstance(variables, str): @@ -436,32 +492,47 @@ def clean_arm_state_variables(self, for var in variables: flag_info = self.get_attr_info(variable=var, flag=integer_flag) - if flag_info is None: - return + if flag_info is not None: - # Add new attributes to variable - for attr in ['flag_values', 'flag_meanings', 'flag_masks']: + # Add new attributes to variable + for attr in ['flag_values', 'flag_meanings', 'flag_masks']: - if len(flag_info[attr]) > 0: - # Only add if attribute does not exist. - if attr in self._obj[var].attrs.keys() is False: - self._obj[var].attrs[attr] = copy.copy(flag_info[attr]) - # If flag is set set attribure even if exists - elif override_cf_flag: - self._obj[var].attrs[attr] = copy.copy(flag_info[attr]) + if len(flag_info[attr]) > 0: + # Only add if attribute does not exist. + if attr in self._ds[var].attrs.keys() is False: + self._ds[var].attrs[attr] = copy.copy(flag_info[attr]) + # If flag is set, set attribure even if exists + elif override_cf_flag: + self._ds[var].attrs[attr] = copy.copy(flag_info[attr]) - # Remove replaced attributes - arm_attributes = flag_info['arm_attributes'] - for attr in arm_attributes: - try: - del self._obj[var].attrs[attr] - except KeyError: - pass + # Remove replaced attributes + arm_attributes = flag_info['arm_attributes'] + for attr in arm_attributes: + try: + del self._ds[var].attrs[attr] + except KeyError: + pass + + # Check if flag_meanings is string. If so convert to list. + try: + flag_meanings = copy.copy(self._ds[var].attrs['flag_meanings']) + if isinstance(flag_meanings, str): + flag_meanings = flag_meanings.split() + if replace_in_flag_meanings is not None: + for ii, flag_meaning in enumerate(flag_meanings): + flag_meaning = flag_meaning.replace(replace_in_flag_meanings, ' ') + flag_meanings[ii] = flag_meaning + + self._ds[var].attrs['flag_meanings'] = flag_meanings + except KeyError: + pass # Clean up units attribute from unitless to udunits '1' - if (clean_units_string and - self._obj[var].attrs['units'] == 'unitless'): - self._obj[var].attrs['units'] = '1' + try: + if clean_units_string and self._ds[var].attrs['units'] == 'unitless': + self._ds[var].attrs['units'] = '1' + except KeyError: + pass def correct_valid_minmax(self, qc_variable): """ @@ -471,14 +542,16 @@ def correct_valid_minmax(self, qc_variable): Parameters ---------- qc_variable : str - Name of quality control variable in xarray object to correct. + Name of quality control variable in the Xarray dataset to correct. """ - test_dict = {'valid_min': 'fail_min', - 'valid_max': 'fail_max', - 'valid_delta': 'fail_delta'} + test_dict = { + 'valid_min': 'fail_min', + 'valid_max': 'fail_max', + 'valid_delta': 'fail_delta', + } - aa = re.match(r"^qc_(.+)", qc_variable) + aa = re.match(r'^qc_(.+)', qc_variable) variable = None try: variable = aa.groups()[0] @@ -487,8 +560,7 @@ def correct_valid_minmax(self, qc_variable): made_change = False try: - flag_meanings = copy.copy( - self._obj[qc_variable].attrs['flag_meanings']) + flag_meanings = copy.copy(self._ds[qc_variable].attrs['flag_meanings']) except KeyError: return @@ -498,14 +570,15 @@ def correct_valid_minmax(self, qc_variable): flag_meanings[ii] = re.sub(attr, test_dict[attr], test) made_change = True try: - self._obj[qc_variable].attrs[test_dict[attr]] = \ - copy.copy(self._obj[variable].attrs[attr]) - del self._obj[variable].attrs[attr] + self._ds[qc_variable].attrs[test_dict[attr]] = copy.copy( + self._ds[variable].attrs[attr] + ) + del self._ds[variable].attrs[attr] except KeyError: pass if made_change: - self._obj[qc_variable].attrs['flag_meanings'] = flag_meanings + self._ds[qc_variable].attrs['flag_meanings'] = flag_meanings def link_variables(self): """ @@ -514,8 +587,8 @@ def link_variables(self): of quality_flag. Hopefully this will be added to the standard_name table in the future. """ - for var in self._obj.data_vars: - aa = re.match(r"^qc_(.+)", var) + for var in self._ds.data_vars: + aa = re.match(r'^qc_(.+)', var) try: variable = aa.groups()[0] qc_variable = var @@ -523,39 +596,40 @@ def link_variables(self): continue # Skip data quality fields. try: - if not ('Quality check results on field:' in - self._obj[var].attrs['long_name']): + if not ('Quality check results on field:' in self._ds[var].attrs['long_name']): continue except KeyError: pass # Get existing data variable ancillary_variables attribute try: - ancillary_variables = self._obj[variable].\ - attrs['ancillary_variables'] + ancillary_variables = self._ds[variable].attrs['ancillary_variables'] except KeyError: ancillary_variables = '' # If the QC variable is not in ancillary_variables add if qc_variable not in ancillary_variables: ancillary_variables = qc_variable - self._obj[variable].attrs['ancillary_variables']\ - = copy.copy(ancillary_variables) + self._ds[variable].attrs['ancillary_variables'] = copy.copy(ancillary_variables) # Check if QC variable has correct standard_name and iff not fix it. correct_standard_name = 'quality_flag' try: - if self._obj[qc_variable].attrs['standard_name'] != correct_standard_name: - self._obj[qc_variable].attrs['standard_name'] = correct_standard_name + if self._ds[qc_variable].attrs['standard_name'] != correct_standard_name: + self._ds[qc_variable].attrs['standard_name'] = correct_standard_name except KeyError: - self._obj[qc_variable].attrs['standard_name'] = correct_standard_name - - def clean_arm_qc(self, - override_cf_flag=True, - clean_units_string=True, - correct_valid_min_max=True): + self._ds[qc_variable].attrs['standard_name'] = correct_standard_name + + def clean_arm_qc( + self, + override_cf_flag=True, + clean_units_string=True, + correct_valid_min_max=True, + remove_unset_global_tests=True, + **kwargs + ): """ - Function to clean up xarray object QC variables. + Method to clean up Xarray dataset QC variables. Parameters ---------- @@ -571,6 +645,9 @@ def clean_arm_qc(self, fail_max and fail_detla if the valid_min, valid_max or valid_delta is listed in bit discription attribute. If not listed as used with QC will assume is being used correctly. + remove_unset_global_tests : bool + Option to look for globaly defined tests that are not set at the + variable level and remove from quality control variable. """ global_qc = self.get_attr_info() @@ -578,9 +655,8 @@ def clean_arm_qc(self, # Clean up units attribute from unitless to udunits '1' try: - if (clean_units_string and - self._obj[qc_var].attrs['units'] == 'unitless'): - self._obj[qc_var].attrs['units'] = '1' + if clean_units_string and self._ds[qc_var].attrs['units'] == 'unitless': + self._ds[qc_var].attrs['units'] = '1' except KeyError: pass @@ -590,16 +666,20 @@ def clean_arm_qc(self, qc_attributes = global_qc # Add new attributes to variable - for attr in ['flag_masks', 'flag_meanings', - 'flag_assessments', 'flag_values', 'flag_comments']: - + for attr in [ + 'flag_masks', + 'flag_meanings', + 'flag_assessments', + 'flag_values', + 'flag_comments', + ]: if qc_attributes is not None and len(qc_attributes[attr]) > 0: # Only add if attribute does not exists - if attr in self._obj[qc_var].attrs.keys() is False: - self._obj[qc_var].attrs[attr] = copy.copy(qc_attributes[attr]) + if attr in self._ds[qc_var].attrs.keys() is False: + self._ds[qc_var].attrs[attr] = copy.copy(qc_attributes[attr]) # If flag is set add attribure even if already exists elif override_cf_flag: - self._obj[qc_var].attrs[attr] = copy.copy(qc_attributes[attr]) + self._ds[qc_var].attrs[attr] = copy.copy(qc_attributes[attr]) # Remove replaced attributes if qc_attributes is not None: @@ -610,13 +690,13 @@ def clean_arm_qc(self, arm_attributes.append('flag_method') for attr in arm_attributes: try: - del self._obj[qc_var].attrs[attr] + del self._ds[qc_var].attrs[attr] except KeyError: pass # Check for use of valid_min and valid_max as QC limits and fix if correct_valid_min_max: - self._obj.clean.correct_valid_minmax(qc_var) + self._ds.clean.correct_valid_minmax(qc_var) # Clean up global attributes if global_qc is not None: @@ -624,12 +704,62 @@ def clean_arm_qc(self, global_attributes.extend(['qc_bit_comment']) for attr in global_attributes: try: - del self._obj.attrs[attr] + del self._ds.attrs[attr] except KeyError: pass - def normalize_assessment(self, variables=None, exclude_variables=None, - qc_lookup={"Incorrect": "Bad", "Suspect": "Indeterminate"}): + # If requested remove tests at variable level that were set from global level descriptions. + # This is assuming the test was only performed if the limit value is listed with the variable + # even if the global level describes the test. + if remove_unset_global_tests and global_qc is not None: + limit_name_list = ['fail_min', 'fail_max', 'fail_delta'] + + for qc_var_name in self.matched_qc_variables: + flag_meanings = self._ds[qc_var_name].attrs['flag_meanings'] + flag_masks = self._ds[qc_var_name].attrs['flag_masks'] + tests_to_remove = [] + for ii, flag_meaning in enumerate(flag_meanings): + + # Loop over usual test attribute names looking to see if they + # are listed in test description. If so use that name for look up. + test_attribute_limit_name = None + for name in limit_name_list: + if name in flag_meaning: + test_attribute_limit_name = name + break + + if test_attribute_limit_name is None: + continue + + remove_test = True + test_number = parse_bit(flag_masks[ii])[0] + for attr_name in self._ds[qc_var_name].attrs: + if test_attribute_limit_name == attr_name: + remove_test = False + break + + index = self._ds.qcfilter.get_qc_test_mask( + qc_var_name=qc_var_name, test_number=test_number + ) + if np.any(index): + remove_test = False + break + + if remove_test: + tests_to_remove.append(test_number) + + if len(tests_to_remove) > 0: + for test_to_remove in tests_to_remove: + self._ds.qcfilter.remove_test( + qc_var_name=qc_var_name, test_number=test_to_remove + ) + + def normalize_assessment( + self, + variables=None, + exclude_variables=None, + qc_lookup={'Incorrect': 'Bad', 'Suspect': 'Indeterminate'}, + ): """ Method to clean up assessment terms used to be consistent between @@ -645,11 +775,23 @@ def normalize_assessment(self, variables=None, exclude_variables=None, qc_lookup : dict Optional dictionary used to convert between terms. + Examples + -------- + .. code-block:: python + + ds = act.io.arm.read_arm_netcdf(files) + ds.clean.normalize_assessment(variables='temp_mean') + + .. code-block:: python + + ds = act.io.arm.read_arm_netcdf(files, cleanup_qc=True) + ds.clean.normalize_assessment(qc_lookup={'Bad': 'Incorrect', 'Indeterminate': 'Suspect'}) + """ # Get list of variables if not provided if variables is None: - variables = list(self._obj.data_vars) + variables = list(self._ds.data_vars) # Ensure variables is a list if not isinstance(variables, (list, tuple)): @@ -665,11 +807,12 @@ def normalize_assessment(self, variables=None, exclude_variables=None, # Loop over variables checking if a QC variable exits and use the # lookup dictionary to convert the assessment terms. for var_name in variables: - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc( - var_name, add_if_missing=False, cleanup=False) + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc( + var_name, add_if_missing=False, cleanup=False + ) if qc_var_name is not None: try: - flag_assessments = self._obj[qc_var_name].attrs['flag_assessments'] + flag_assessments = self._ds[qc_var_name].attrs['flag_assessments'] except KeyError: continue @@ -678,3 +821,84 @@ def normalize_assessment(self, variables=None, exclude_variables=None, flag_assessments[ii] = qc_lookup[assess] except KeyError: continue + + def clean_cf_qc(self, variables=None, sep='__', **kwargs): + """ + Method to convert the CF standard for QC attributes to match internal + format expected in the Dataset. CF does not allow string attribute + arrays, even though netCDF4 does allow string attribute arrays. The quality + control variables uses and expects lists for flag_meaning, flag_assessments. + + Parameters + ---------- + variables : str or list of str or None + Data variable names to convert. If set to None will check all variables. + sep : str or None + Separater to use for splitting individual test meanings. Since the CF + attribute in the netCDF file must be a string and is separated by a + space character, individual test meanings are connected with a character. + Default for ACT writing to file is double underscore to preserve underscores + in variable or attribute names. + kwargs : dict + Additional keyword argumnts not used. This is to allow calling multiple + methods from one method without causing unexpected keyword errors. + + Examples + -------- + .. code-block:: python + + ds = act.io.arm.read_arm_netcdf(files) + ds.clean.clean_cf_qc(variables='temp_mean') + + .. code-block:: python + + ds = act.io.arm.read_arm_netcdf(files, cleanup_qc=True) + + """ + + # Convert string in to list of string for itteration + if isinstance(variables, str): + variables = [variables] + + # If no variables provided, get list of all variables in Dataset + if variables is None: + variables = list(self._ds.data_vars) + + for var_name in variables: + # Check flag_meanings type. If string separate on space character + # into list. If sep is not None split string on separater to make + # better looking list of strings. + try: + flag_meanings = self._ds[var_name].attrs['flag_meanings'] + if isinstance(flag_meanings, str): + flag_meanings = flag_meanings.split() + if sep is not None: + flag_meanings = [ii.replace(sep, ' ') for ii in flag_meanings] + self._ds[var_name].attrs['flag_meanings'] = flag_meanings + except KeyError: + pass + + # Check if flag_assessments is a string, split on space character + # to make list. + try: + flag_assessments = self._ds[var_name].attrs['flag_assessments'] + if isinstance(flag_assessments, str): + flag_assessments = flag_assessments.split() + self._ds[var_name].attrs['flag_assessments'] = flag_assessments + except KeyError: + pass + + # Check if flag_masks is a numpy scalar instead of array. If so convert + # to numpy array. If value is not numpy scalar, turn single value into + # list. + try: + flag_masks = self._ds[var_name].attrs['flag_masks'] + if type(flag_masks).__module__ == 'numpy': + if flag_masks.shape == (): + self._ds[var_name].attrs['flag_masks'] = np.atleast_1d(flag_masks) + + elif not isinstance(flag_masks, (list, tuple)): + self._ds[var_name].attrs['flag_masks'] = [flag_masks] + + except KeyError: + pass diff --git a/act/qc/comparison_tests.py b/act/qc/comparison_tests.py index b38091b37d..731eae0230 100644 --- a/act/qc/comparison_tests.py +++ b/act/qc/comparison_tests.py @@ -1,16 +1,28 @@ -import numpy as np +""" +Functions and methods for performing comparison tests. + +""" +import copy import warnings + +import numpy as np +import xarray as xr + from act.utils.data_utils import convert_units from act.utils.datetime_utils import determine_time_delta -import copy -import xarray as xr class QCTests: - def compare_time_series_trends(self, var_name=None, comp_dataset=None, - comp_var_name=None, time_match_threshhold=60, - time_shift=60 * 60, time_step=None, - time_qc_threshold=60 * 15): + def compare_time_series_trends( + self, + var_name=None, + comp_dataset=None, + comp_var_name=None, + time_match_threshhold=60, + time_shift=60 * 60, + time_step=None, + time_qc_threshold=60 * 15, + ): """ Method to perform a time series comparison test between two Xarray Datasets to detect a shift in time based on two similar variables. This test will @@ -59,28 +71,31 @@ def compare_time_series_trends(self, var_name=None, comp_dataset=None, comp_dataset = self # Extract copy of DataArray for work below - self_da = copy.deepcopy(self._obj[var_name]) + self_da = copy.deepcopy(self._ds[var_name]) comp_da = copy.deepcopy(comp_dataset[comp_var_name]) # Convert comp data units to match - comp_da.values = convert_units(comp_da.values, comp_da.attrs['units'], - self_da.attrs['units']) + comp_da.values = convert_units( + comp_da.values, comp_da.attrs['units'], self_da.attrs['units'] + ) comp_da.attrs['units'] = self_da.attrs['units'] # Match comparison data to time of data if time_step is None: - time_step = determine_time_delta(self._obj['time'].values) + time_step = determine_time_delta(self._ds['time'].values) sum_diff = np.array([], dtype=float) time_diff = np.array([], dtype=np.int32) - for tm_shift in range(-1 * time_shift, time_shift + int(time_step), - int(time_step)): + for tm_shift in range(-1 * time_shift, time_shift + int(time_step), int(time_step)): self_da_shifted = self_da.assign_coords( - time=self_da.time.values.astype('datetime64[s]') + tm_shift) + time=self_da.time.values.astype('datetime64[s]') + tm_shift + ) data_matched, comp_data_matched = xr.align(self_da, comp_da) self_da_shifted = self_da_shifted.reindex( - time=comp_da.time.values, method='nearest', - tolerance=np.timedelta64(time_match_threshhold, 's')) + time=comp_da.time.values, + method='nearest', + tolerance=np.timedelta64(time_match_threshhold, 's'), + ) diff = np.abs(self_da_shifted.values - comp_da.values) sum_diff = np.append(sum_diff, np.nansum(diff)) time_diff = np.append(time_diff, tm_shift) @@ -91,11 +106,13 @@ def compare_time_series_trends(self, var_name=None, comp_dataset=None, index = None if np.abs(time_diff) > time_qc_threshold: index = np.arange(0, self_da.size) - meaning = (f"Time shift detected with Minimum Difference test. Comparison of " - f"{var_name} with {comp_var_name} off by {time_diff} seconds " - f"exceeding absolute threshold of {time_qc_threshold} seconds.") - result = self._obj.qcfilter.add_test(var_name, index=index, - test_meaning=meaning, - test_assessment='Indeterminate') + meaning = ( + f'Time shift detected with Minimum Difference test. Comparison of ' + f'{var_name} with {comp_var_name} off by {time_diff} seconds ' + f'exceeding absolute threshold of {time_qc_threshold} seconds.' + ) + result = self._ds.qcfilter.add_test( + var_name, index=index, test_meaning=meaning, test_assessment='Indeterminate' + ) return result diff --git a/act/qc/qcfilter.py b/act/qc/qcfilter.py index 2f175b6d65..6137db9f92 100644 --- a/act/qc/qcfilter.py +++ b/act/qc/qcfilter.py @@ -1,21 +1,19 @@ """ -act.qc.qcfilter ------------------------------- - Functions and methods for creating ancillary quality control variables and filters (masks) which can be used with various corrections routines in ACT. """ +import dask import numpy as np import xarray as xr -from act.qc import qctests, comparison_tests +from act.qc import comparison_tests, qctests, bsrn_tests @xr.register_dataset_accessor('qcfilter') -class QCFilter(qctests.QCTests, comparison_tests.QCTests, object): +class QCFilter(qctests.QCTests, comparison_tests.QCTests, bsrn_tests.QCTests): """ A class for building quality control variables containing arrays for filtering data based on a set of test condition typically based on the @@ -23,12 +21,18 @@ class QCFilter(qctests.QCTests, comparison_tests.QCTests, object): algorithms and calculations within ACT. """ - def __init__(self, xarray_obj): - """ initialize """ - self._obj = xarray_obj - def check_for_ancillary_qc(self, var_name, add_if_missing=True, - cleanup=True, flag_type=False): + def __init__(self, ds): + """initialize""" + self._ds = ds + + def check_for_ancillary_qc( + self, + var_name, + add_if_missing=True, + cleanup=False, + flag_type=False + ): """ Method to check if a quality control variable exist in the dataset and return the quality control varible name. @@ -43,10 +47,12 @@ def check_for_ancillary_qc(self, var_name, add_if_missing=True, var_name : str Data variable name. add_if_missing : boolean - Add quality control variable if missing from object. + Add quality control variable if missing from teh dataset. Will raise + and exception if the var_name does not exist in Dataset. Set to False + to not raise exception. cleanup : boolean - Option to run qc.clean.cleanup() method on the object - to ensure the object was updated from ARM QC to the + Option to run qc.clean.cleanup() method on the dataset + to ensure the dataset was updated from ARM QC to the correct standardized QC. flag_type : boolean Indicating the QC variable uses flag_values instead of @@ -59,22 +65,33 @@ def check_for_ancillary_qc(self, var_name, add_if_missing=True, None if no existing quality control variable is found and add_if_missing is set to False. + Examples + -------- + .. code-block:: python + + from act.tests import EXAMPLE_METE40 + from act.io.arm import read_arm_netcdf + ds = read_arm_netcdf(EXAMPLE_METE40, cleanup_qc=True) + qc_var_name = ds.qcfilter.check_for_ancillary_qc('atmos_pressure') + print(f'qc_var_name: {qc_var_name}') + qc_var_name = ds.qcfilter.check_for_ancillary_qc('the_greatest_variable_ever', + add_if_missing=False) + print(f'qc_var_name: {qc_var_name}') + """ qc_var_name = None try: - ancillary_variables = \ - self._obj[var_name].attrs['ancillary_variables'] + ancillary_variables = self._ds[var_name].attrs['ancillary_variables'] if isinstance(ancillary_variables, str): ancillary_variables = ancillary_variables.split() for var in ancillary_variables: - for attr, value in self._obj[var].attrs.items(): + for attr, value in self._ds[var].attrs.items(): if attr == 'standard_name' and 'quality_flag' in value: qc_var_name = var if add_if_missing and qc_var_name is None: - qc_var_name = self._obj.qcfilter.create_qc_variable( - var_name, flag_type=flag_type) + qc_var_name = self._ds.qcfilter.create_qc_variable(var_name, flag_type=flag_type) except KeyError: # Since no ancillary_variables exist look for ARM style of QC @@ -82,29 +99,31 @@ def check_for_ancillary_qc(self, var_name, add_if_missing=True, # QC varaible. if add_if_missing: try: - self._obj['qc_' + var_name] + self._ds['qc_' + var_name] qc_var_name = 'qc_' + var_name except KeyError: - qc_var_name = self._obj.qcfilter.create_qc_variable( - var_name, flag_type=flag_type) + qc_var_name = self._ds.qcfilter.create_qc_variable( + var_name, flag_type=flag_type + ) # Make sure data varaible has a variable attribute linking # data variable to QC variable. if add_if_missing: - self._obj.qcfilter.update_ancillary_variable(var_name, qc_var_name) + self._ds.qcfilter.update_ancillary_variable(var_name, qc_var_name) # Clean up quality control variables to the requried standard in the - # xarray object. If the quality control variables are already cleaned - # the extra work is small since it's just checking. + # xarray dataset. if cleanup: - self._obj.clean.cleanup(handle_missing_value=True, - link_qc_variables=False) + self._ds.clean.cleanup(handle_missing_value=True, link_qc_variables=False) return qc_var_name - def create_qc_variable(self, var_name, flag_type=False, - flag_values_set_value=0, - qc_var_name=None): + def create_qc_variable( + self, var_name, + flag_type=False, + flag_values_set_value=0, + qc_var_name=None + ): """ Method to create a quality control variable in the dataset. Will try not to destroy the qc variable by appending numbers @@ -131,13 +150,25 @@ def create_qc_variable(self, var_name, flag_type=False, qc_var_name : str Name of new quality control variable created. + Examples + -------- + .. code-block:: python + + from act.tests import EXAMPLE_AOSMET + from act.io.arm import read_arm_netcdf + ds = read_arm_netcdf(EXAMPLE_AOSMET) + qc_var_name = ds.qcfilter.create_qc_variable('temperature_ambient') + print(qc_var_name) + print(ds[qc_var_name]) + """ # Make QC variable long name. The variable long_name attribute # may not exist so catch that error and set to default. try: - qc_variable_long_name = ('Quality check results on field: ' + - self._obj[var_name].attrs['long_name']) + qc_variable_long_name = ( + 'Quality check results on field: ' + self._ds[var_name].attrs['long_name'] + ) except KeyError: qc_variable_long_name = 'Quality check results for ' + var_name @@ -147,7 +178,7 @@ def create_qc_variable(self, var_name, flag_type=False, if qc_var_name is None: qc_var_name = 'qc_' + var_name - variable_names = list(self._obj.data_vars) + variable_names = list(self._ds.data_vars) if qc_var_name in variable_names: for ii in range(1, 100): temp_qc_var_name = '_'.join([qc_var_name, str(ii)]) @@ -157,28 +188,36 @@ def create_qc_variable(self, var_name, flag_type=False, # Create the QC variable filled with 0 values matching the # shape of data variable. - self._obj[qc_var_name] = xr.zeros_like(self._obj[var_name], dtype=np.int32) - self._obj[qc_var_name].attrs = {} - # This is the way to update the DataArrays in the Dataset to be Dask arrays - # instead of Numpy arrays but it's messing things up in a strange way. Maybe - # a bug in Xarray? Leave commented out for now. -# self._obj = self._obj.chunk() + try: + qc_data = dask.array.from_array( + np.zeros_like(self._ds[var_name].values, dtype=np.int32), + chunks=self._ds[var_name].data.chunksize, + ) + except AttributeError: + qc_data = np.zeros_like(self._ds[var_name].values, dtype=np.int32) + + # Updating to use coords instead of dim, which caused a loss of + # attribuets as noted in Issue 347 + self._ds[qc_var_name] = xr.DataArray( + data=qc_data, + coords=self._ds[var_name].coords, + attrs={'long_name': qc_variable_long_name, 'units': '1'}, + ) # Update if using flag_values and don't want 0 to be default value. if flag_type and flag_values_set_value != 0: - self._obj[qc_var_name].values = \ - self._obj[qc_var_name].values + int(flag_values_set_value) + self._ds[qc_var_name].values = self._ds[qc_var_name].values + int( + flag_values_set_value + ) # Add requried variable attributes. - self._obj[qc_var_name].attrs['long_name'] = qc_variable_long_name - self._obj[qc_var_name].attrs['units'] = '1' if flag_type: - self._obj[qc_var_name].attrs['flag_values'] = [] + self._ds[qc_var_name].attrs['flag_values'] = [] else: - self._obj[qc_var_name].attrs['flag_masks'] = [] - self._obj[qc_var_name].attrs['flag_meanings'] = [] - self._obj[qc_var_name].attrs['flag_assessments'] = [] - self._obj[qc_var_name].attrs['standard_name'] = 'quality_flag' + self._ds[qc_var_name].attrs['flag_masks'] = [] + self._ds[qc_var_name].attrs['flag_meanings'] = [] + self._ds[qc_var_name].attrs['flag_assessments'] = [] + self._ds[qc_var_name].attrs['standard_name'] = 'quality_flag' self.update_ancillary_variable(var_name, qc_var_name=qc_var_name) @@ -198,29 +237,46 @@ def update_ancillary_variable(self, var_name, qc_var_name=None): to get the name from data variable ancillary_variables attribute. + Examples + -------- + .. code-block:: python + + from act.tests import EXAMPLE_AOSMET + from act.io.arm import read_arm_netcdf + ds = read_arm_netcdf(EXAMPLE_AOSMET) + var_name = 'temperature_ambient' + qc_var_name = ds.qcfilter.create_qc_variable(var_name) + del ds[var_name].attrs['ancillary_variables'] + ds.qcfilter.update_ancillary_variable(var_name, qc_var_name) + print(ds[var_name].attrs['ancillary_variables']) + """ if qc_var_name is None: - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc( - var_name, add_if_missing=False) + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc(var_name, add_if_missing=False) if qc_var_name is None: return try: - ancillary_variables = \ - self._obj[var_name].attrs['ancillary_variables'] + ancillary_variables = self._ds[var_name].attrs['ancillary_variables'] if qc_var_name not in ancillary_variables: - ancillary_variables = ' '.join([ancillary_variables, - qc_var_name]) + ancillary_variables = ' '.join([ancillary_variables, qc_var_name]) except KeyError: ancillary_variables = qc_var_name - self._obj[var_name].attrs['ancillary_variables'] = ancillary_variables - - def add_test(self, var_name, index=None, test_number=None, - test_meaning=None, test_assessment='Bad', - flag_value=False): + self._ds[var_name].attrs['ancillary_variables'] = ancillary_variables + + def add_test( + self, + var_name, + index=None, + test_number=None, + test_meaning=None, + test_assessment='Bad', + flag_value=False, + recycle=False, + ): """ Method to add a new test/filter to a quality control variable. @@ -228,7 +284,7 @@ def add_test(self, var_name, index=None, test_number=None, ---------- var_name : str data variable name - index : int, bool, list of int or bool, numpy array, tuple of numpy arrays + index : int, bool, list of int or bool, numpy array, tuple of numpy arrays, None Indexes into quality control array to set the test bit. If not set or set to None will not set the test on any element of the quality control variable but will still @@ -243,9 +299,13 @@ def add_test(self, var_name, index=None, test_number=None, test_assessment : str String describing the test assessment. If not set will use "Bad" as the string to append to flag_assessments. Will - update to be lower case and then capitalized. + update to be capitalized. flag_value : boolean Switch to use flag_values integer quality control. + recyle : boolean + Option to use number less than next highest test if available. For example + tests 1, 2, 4, 5 are set. Set to true the next test chosen will be 3, else + will be 6. Returns ------- @@ -255,57 +315,71 @@ def add_test(self, var_name, index=None, test_number=None, Examples -------- - > result = ds_object.qcfilter.add_test( - var_name, test_meaning='Birds!') + .. code-block:: python + + result = ds.qcfilter.add_test(var_name, test_meaning='Birds!') """ test_dict = {} if test_meaning is None: - raise ValueError('You need to provide a value for test_meaning ' - 'keyword when calling the add_test method') + raise ValueError( + 'You need to provide a value for test_meaning ' + 'keyword when calling the add_test method' + ) # This ensures the indexing will work even if given float values. # Preserves tuples from np.where() or boolean arrays for standard # python indexing. if index is not None and not isinstance(index, (np.ndarray, tuple)): index = np.array(index) - if index.dtype.kind == 'f': + if index.dtype.kind not in np.typecodes['AllInteger']: index = index.astype(int) - # Ensure assessment is lowercase and capitalized to be consistent - test_assessment = test_assessment.lower().capitalize() + # Ensure assessment is capitalized to be consistent + test_assessment = test_assessment.capitalize() - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc( - var_name, flag_type=flag_value) + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc(var_name, flag_type=flag_value) if test_number is None: - test_number = self._obj.qcfilter.available_bit( - qc_var_name) + test_number = self._ds.qcfilter.available_bit(qc_var_name, recycle=recycle) - self._obj.qcfilter.set_test(var_name, index, test_number, flag_value) + self._ds.qcfilter.set_test(var_name, index, test_number, flag_value) if flag_value: try: - self._obj[qc_var_name].attrs['flag_values'].append(test_number) + self._ds[qc_var_name].attrs['flag_values'].append(test_number) except KeyError: - self._obj[qc_var_name].attrs['flag_values'] = [test_number] + self._ds[qc_var_name].attrs['flag_values'] = [test_number] else: - try: - self._obj[qc_var_name].attrs['flag_masks'].append( - set_bit(0, test_number)) - except KeyError: - self._obj[qc_var_name].attrs['flag_masks'] = [set_bit(0, test_number)] + # Determine if flag_masks test number is too large for current data type. + # If so up convert data type. + flag_masks = np.array(self._ds[qc_var_name].attrs['flag_masks']) + mask_dtype = flag_masks.dtype + if not np.issubdtype(mask_dtype, np.integer): + mask_dtype = np.uint32 + + if np.iinfo(mask_dtype).max - set_bit(0, test_number) <= -1: + if mask_dtype == np.int8 or mask_dtype == np.uint8: + mask_dtype = np.uint16 + elif mask_dtype == np.int16 or mask_dtype == np.uint16: + mask_dtype = np.uint32 + elif mask_dtype == np.int32 or mask_dtype == np.uint32: + mask_dtype = np.uint64 + + flag_masks = flag_masks.astype(mask_dtype) + flag_masks = np.append(flag_masks, np.array(set_bit(0, test_number), dtype=mask_dtype)) + self._ds[qc_var_name].attrs['flag_masks'] = list(flag_masks) try: - self._obj[qc_var_name].attrs['flag_meanings'].append(test_meaning) + self._ds[qc_var_name].attrs['flag_meanings'].append(test_meaning) except KeyError: - self._obj[qc_var_name].attrs['flag_meanings'] = [test_meaning] + self._ds[qc_var_name].attrs['flag_meanings'] = [test_meaning] try: - self._obj[qc_var_name].attrs['flag_assessments'].append(test_assessment) + self._ds[qc_var_name].attrs['flag_assessments'].append(test_assessment) except KeyError: - self._obj[qc_var_name].attrs['flag_assessments'] = [test_assessment] + self._ds[qc_var_name].attrs['flag_assessments'] = [test_assessment] test_dict['test_number'] = test_number test_dict['test_meaning'] = test_meaning @@ -315,17 +389,26 @@ def add_test(self, var_name, index=None, test_number=None, return test_dict - def remove_test(self, var_name, test_number=None, flag_value=False, - flag_values_reset_value=0): + def remove_test( + self, + var_name=None, + test_number=None, + qc_var_name=None, + flag_value=False, + flag_values_reset_value=0, + ): """ - Method to remove a test/filter from a quality control variable. + Method to remove a test/filter from a quality control variable. Must set + var_name or qc_var_name. Parameters ---------- - var_name : str + var_name : str or None Data variable name. test_number : int Test number to remove. + qc_var_name : str or None + Quality control variable name. Ignored if var_name is set. flag_value : boolean Switch to use flag_values integer quality control. flag_values_reset_value : int @@ -333,26 +416,36 @@ def remove_test(self, var_name, test_number=None, flag_value=False, Examples -------- - > ds_object.qcfilter.remove_test( - var_name, test_number=3) + .. code-block:: python + + ds.qcfilter.remove_test(var_name, test_number=3) """ if test_number is None: - raise ValueError('You need to provide a value for test_number ' - 'keyword when calling the add_test method') + raise ValueError( + 'You need to provide a value for test_number ' + 'keyword when calling the remove_test() method' + ) + + if var_name is None and qc_var_name is None: + raise ValueError( + 'You need to provide a value for var_name or qc_var_name ' + 'keyword when calling the remove_test() method' + ) - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc(var_name) + if var_name is not None: + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc(var_name) # Determine which index is using the test number index = None if flag_value: - flag_values = self._obj[qc_var_name].attrs['flag_values'] + flag_values = self._ds[qc_var_name].attrs['flag_values'] for ii, flag_num in enumerate(flag_values): if flag_num == test_number: index = ii break else: - flag_masks = self._obj[qc_var_name].attrs['flag_masks'] + flag_masks = self._ds[qc_var_name].attrs['flag_masks'] for ii, bit_num in enumerate(flag_masks): if parse_bit(bit_num)[0] == test_number: index = ii @@ -363,30 +456,53 @@ def remove_test(self, var_name, test_number=None, flag_value=False, return if flag_value: - remove_index = self._obj.qcfilter.get_qc_test_mask( - var_name, test_number, return_index=True, flag_value=True) - self._obj.qcfilter.unset_test(var_name, remove_index, test_number, - flag_value, flag_values_reset_value) + remove_index = self._ds.qcfilter.get_qc_test_mask( + var_name=var_name, + qc_var_name=qc_var_name, + test_number=test_number, + return_index=True, + flag_value=True, + ) + self._ds.qcfilter.unset_test( + var_name=var_name, + qc_var_name=qc_var_name, + index=remove_index, + test_number=test_number, + flag_value=flag_value, + flag_values_reset_value=flag_values_reset_value, + ) del flag_values[index] - self._obj[qc_var_name].attrs['flag_values'] = flag_values + self._ds[qc_var_name].attrs['flag_values'] = flag_values + else: - remove_index = self._obj.qcfilter.get_qc_test_mask( - var_name, test_number, return_index=True) - self._obj.qcfilter.unset_test(var_name, remove_index, test_number, - flag_value, flag_values_reset_value) - del flag_masks[index] - self._obj[qc_var_name].attrs['flag_masks'] = flag_masks - - flag_meanings = self._obj[qc_var_name].attrs['flag_meanings'] + remove_index = self._ds.qcfilter.get_qc_test_mask( + var_name=var_name, + qc_var_name=qc_var_name, + test_number=test_number, + return_index=True, + ) + self._ds.qcfilter.unset_test( + var_name=var_name, + qc_var_name=qc_var_name, + index=remove_index, + test_number=test_number, + flag_value=flag_value, + ) + if isinstance(flag_masks, list): + del flag_masks[index] + else: + flag_masks = np.delete(flag_masks, index) + self._ds[qc_var_name].attrs['flag_masks'] = flag_masks + + flag_meanings = self._ds[qc_var_name].attrs['flag_meanings'] del flag_meanings[index] - self._obj[qc_var_name].attrs['flag_meanings'] = flag_meanings + self._ds[qc_var_name].attrs['flag_meanings'] = flag_meanings - flag_assessments = self._obj[qc_var_name].attrs['flag_assessments'] + flag_assessments = self._ds[qc_var_name].attrs['flag_assessments'] del flag_assessments[index] - self._obj[qc_var_name].attrs['flag_assessments'] = flag_assessments + self._ds[qc_var_name].attrs['flag_assessments'] = flag_assessments - def set_test(self, var_name, index=None, test_number=None, - flag_value=False): + def set_test(self, var_name, index=None, test_number=None, flag_value=False): """ Method to set a test/filter in a quality control variable. @@ -407,34 +523,61 @@ def set_test(self, var_name, index=None, test_number=None, .. code-block:: python index = [0, 1, 2, 30] - ds_object.qcfilter.set_test( - var_name, index=index, test_number=2) + ds.qcfilter.set_test(var_name, index=index, test_number=2) """ - if index is None: - return - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc(var_name) + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc(var_name) + + qc_variable = np.array(self._ds[qc_var_name].values) + + # Ensure the qc_variable data type is integer. This ensures bitwise comparison + # will not cause an error. + if qc_variable.dtype.kind not in np.typecodes['AllInteger']: + qc_variable = qc_variable.astype(int) + + # Determine if test number is too large for current data type. If so + # up convert data type. + dtype = qc_variable.dtype + if np.iinfo(dtype).max - set_bit(0, test_number) < -1: + if dtype == np.int8: + dtype = np.int16 + elif dtype == np.int16: + dtype = np.int32 + elif dtype == np.int32: + dtype = np.int64 - qc_variable = np.array(self._obj[qc_var_name].values) + qc_variable = qc_variable.astype(dtype) if index is not None: if flag_value: qc_variable[index] = test_number else: - qc_variable[index] = set_bit(qc_variable[index], test_number) - - self._obj[qc_var_name].values = qc_variable - - def unset_test(self, var_name, index=None, test_number=None, - flag_value=False, flag_values_reset_value=0): + if bool(np.shape(index)): + qc_variable[index] = set_bit(qc_variable[index], test_number) + elif index == 0: + qc_variable = set_bit(qc_variable, test_number) + + self._ds[qc_var_name].values = qc_variable + + def unset_test( + self, + var_name=None, + qc_var_name=None, + index=None, + test_number=None, + flag_value=False, + flag_values_reset_value=0, + ): """ Method to unset a test/filter from a quality control variable. Parameters ---------- - var_name : str + var_name : str or None Data variable name. + qc_var_name : str or None + Quality control variable name. Ignored if var_name is set. index : int or list or numpy array Index to unset test in quality control array. If want to unset all values will need to pass in index of all values. @@ -449,22 +592,35 @@ def unset_test(self, var_name, index=None, test_number=None, -------- .. code-block:: python - ds_object.qcfilter.unset_test( - var_name, index=0, test_number=2) + ds.qcfilter.unset_test(var_name, index=range(10, 100), test_number=2) """ if index is None: return - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc(var_name) + if var_name is None and qc_var_name is None: + raise ValueError( + 'You need to provide a value for var_name or qc_var_name ' + 'keyword when calling the unset_test() method' + ) + + if var_name is not None: + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc(var_name) + + # Get QC variable + qc_variable = self._ds[qc_var_name].values + + # Ensure the qc_variable data type is integer. This ensures bitwise comparison + # will not cause an error. + if qc_variable.dtype.kind not in np.typecodes['AllInteger']: + qc_variable = qc_variable.astype(int) - qc_variable = self._obj[qc_var_name].values if flag_value: qc_variable[index] = flag_values_reset_value else: qc_variable[index] = unset_bit(qc_variable[index], test_number) - self._obj[qc_var_name].values = qc_variable + self._ds[qc_var_name].values = qc_variable def available_bit(self, qc_var_name, recycle=False): """ @@ -486,23 +642,36 @@ def available_bit(self, qc_var_name, recycle=False): test_num : int Next available test number. + Examples + -------- + .. code-block:: python + + from act.tests import EXAMPLE_METE40 + from act.io.arm import read_arm_netcdf + ds = read_arm_netcdf(EXAMPLE_METE40, cleanup_qc=True) + test_number = ds.qcfilter.available_bit('qc_atmos_pressure') + print(test_number) + + """ try: - flag_masks = self._obj[qc_var_name].attrs['flag_masks'] + flag_masks = self._ds[qc_var_name].attrs['flag_masks'] flag_value = False except KeyError: try: - flag_masks = self._obj[qc_var_name].attrs['flag_values'] + flag_masks = self._ds[qc_var_name].attrs['flag_values'] flag_value = True except KeyError: try: - self._obj[qc_var_name].attrs['flag_values'] - flag_masks = self._obj[qc_var_name].attrs['flag_masks'] + self._ds[qc_var_name].attrs['flag_values'] + flag_masks = self._ds[qc_var_name].attrs['flag_masks'] flag_value = False except KeyError: - raise ValueError('Problem getting next value from ' - 'available_bit(). flag_values and ' - 'flag_masks not set as expected') + raise ValueError( + 'Problem getting next value from ' + 'available_bit(). flag_values and ' + 'flag_masks not set as expected' + ) if flag_masks == []: next_bit = 1 @@ -521,77 +690,105 @@ def available_bit(self, qc_var_name, recycle=False): return int(next_bit) - def get_qc_test_mask(self, var_name, test_number, flag_value=False, - return_index=False): + def get_qc_test_mask( + self, + var_name=None, + test_number=None, + qc_var_name=None, + flag_value=False, + return_index=False, + ): """ Returns a numpy array of False or True where a particular - flag or bit is set in a numpy array. + flag or bit is set in a numpy array. Must set var_name or qc_var_name + when calling. Parameters ---------- - var_name : str + var_name : str or None Data variable name. test_number : int Test number to return array where test is set. + qc_var_name : str or None + Quality control variable name. Ignored if var_name is set. flag_value : boolean Switch to use flag_values integer quality control. return_index : boolean Return a numpy array of index numbers into QC array where the - test is set instead of 0 or 1 mask. + test is set instead of False or True mask. Returns ------- - test_mask : bool array + test_mask : numpy bool array or numpy integer array A numpy boolean array with False or True where the test number or - bit was set. + bit was set, or numpy integer array of indexes where test is True. Examples -------- .. code-block:: python - from act.io.armfiles import read_netcdf + from act.io.arm import read_arm_netcdf from act.tests import EXAMPLE_IRT25m20s - ds_object = read_netcdf(EXAMPLE_IRT25m20s) - var_name = 'inst_up_long_dome_resist' - result = ds_object.qcfilter.add_test( - var_name, index=[0, 1, 2], test_meaning='Birds!') - qc_var_name = result['qc_variable_name'] - mask = ds_object.qcfilter.get_qc_test_mask( - var_name, result['test_number'], return_index=True) + + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + var_name = "inst_up_long_dome_resist" + result = ds.qcfilter.add_test( + var_name, index=[0, 1, 2], test_meaning="Birds!" + ) + qc_var_name = result["qc_variable_name"] + mask = ds.qcfilter.get_qc_test_mask( + var_name, result["test_number"], return_index=True + ) print(mask) - array([0, 1, 2]) + array([0, 1, 2]) - mask = ds_object.qcfilter.get_qc_test_mask( - var_name, result['test_number']) + mask = ds.qcfilter.get_qc_test_mask(var_name, result["test_number"]) print(mask) - array([ True, True, True, ..., False, False, False]) + array([True, True, True, ..., False, False, False]) - data = ds_object[var_name].values + data = ds[var_name].values print(data[mask]) - array([7.84 , 7.8777, 7.8965], dtype=float32) + array([7.84, 7.8777, 7.8965], dtype=float32) import numpy as np + data[mask] = np.nan print(data) - array([ nan, nan, nan, ..., 7.6705, 7.6892, 7.6892], - dtype=float32) + array([nan, nan, nan, ..., 7.6705, 7.6892, 7.6892], dtype=float32) """ - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc(var_name) + if var_name is None and qc_var_name is None: + raise ValueError( + 'You need to provide a value for var_name or qc_var_name ' + 'keyword when calling the get_qc_test_mask() method' + ) + + if test_number is None: + raise ValueError( + 'You need to provide a value for test_number ' + 'keyword when calling the get_qc_test_mask() method' + ) + + if var_name is not None: + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc(var_name) - qc_variable = self._obj[qc_var_name].values + qc_variable = self._ds[qc_var_name].values + # Ensure the qc_variable data type is integer. This ensures bitwise comparison + # will not cause an error. + if qc_variable.dtype.kind not in np.typecodes['AllInteger']: + qc_variable = qc_variable.astype(int) if flag_value: - tripped = np.where(qc_variable == test_number) + tripped = qc_variable == test_number else: check_bit = set_bit(0, test_number) & qc_variable - tripped = np.where(check_bit > 0) + tripped = check_bit > 0 - test_mask = np.zeros(qc_variable.shape, dtype='int') + test_mask = np.full(qc_variable.shape, False, dtype='bool') # Make sure test_mask is an array. If qc_variable is scalar will # be retuned from np.zeros as scalar. test_mask = np.atleast_1d(test_mask) - test_mask[tripped] = 1 + test_mask[tripped] = True test_mask = np.ma.make_mask(test_mask, shrink=False) if return_index: @@ -599,9 +796,15 @@ def get_qc_test_mask(self, var_name, test_number, flag_value=False, return test_mask - def get_masked_data(self, var_name, rm_assessments=None, - rm_tests=None, return_nan_array=False, - ma_fill_value=None, return_inverse=False): + def get_masked_data( + self, + var_name, + rm_assessments=None, + rm_tests=None, + return_nan_array=False, + ma_fill_value=None, + return_inverse=False, + ): """ Returns a numpy masked array containing data and mask or @@ -643,36 +846,40 @@ def get_masked_data(self, var_name, rm_assessments=None, -------- .. code-block:: python - from act.io.armfiles import read_netcdf + from act.io.arm import read_arm_netcdf from act.tests import EXAMPLE_IRT25m20s - ds_object = read_netcdf(EXAMPLE_IRT25m20s) - var_name = 'inst_up_long_dome_resist' - result = ds_object.qcfilter.add_test( - var_name, index=[0, 1, 2], test_meaning='Birds!') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_assessments=['Bad', 'Indeterminate']) + + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + var_name = "inst_up_long_dome_resist" + result = ds.qcfilter.add_test( + var_name, index=[0, 1, 2], test_meaning="Birds!" + ) + data = ds.qcfilter.get_masked_data( + var_name, rm_assessments=["Bad", "Indeterminate"] + ) print(data) - masked_array(data=[--, --, --, ..., 7.670499801635742, - 7.689199924468994, 7.689199924468994], - mask=[ True, True, True, ..., False, False, False], - fill_value=1e+20, dtype=float32) + masked_array( + data=[..., 7.670499801635742, 7.689199924468994, 7.689199924468994], + mask=[..., False, False, False], + fill_value=1e20, + dtype=float32, + ) """ - qc_var_name = self._obj.qcfilter.check_for_ancillary_qc( - var_name, add_if_missing=False) + qc_var_name = self._ds.qcfilter.check_for_ancillary_qc(var_name, add_if_missing=False) flag_value = False flag_values = None flag_masks = None flag_assessments = None try: - flag_assessments = self._obj[qc_var_name].attrs['flag_assessments'] - flag_masks = self._obj[qc_var_name].attrs['flag_masks'] + flag_assessments = self._ds[qc_var_name].attrs['flag_assessments'] + flag_masks = self._ds[qc_var_name].attrs['flag_masks'] except KeyError: pass try: - flag_values = self._obj[qc_var_name].attrs['flag_values'] + flag_values = self._ds[qc_var_name].attrs['flag_values'] flag_value = True except KeyError: pass @@ -703,20 +910,25 @@ def get_masked_data(self, var_name, rm_assessments=None, test_numbers = list(set(test_numbers)) # Create mask of indexes by looking where each test is set - variable = self._obj[var_name].values - mask = np.zeros(variable.shape, dtype=np.bool) + variable = self._ds[var_name].values + nan_dtype = np.float32 + if variable.dtype in (np.float64, np.int64): + nan_dtype = np.float64 + + mask = np.zeros(variable.shape, dtype=bool) for test in test_numbers: - mask = mask | self._obj.qcfilter.get_qc_test_mask( - var_name, test, flag_value=flag_value) + mask = mask | self._ds.qcfilter.get_qc_test_mask(var_name, test, flag_value=flag_value) # Convert data numpy array into masked array try: - variable = np.ma.array(variable, mask=mask, - fill_value=ma_fill_value) + variable = np.ma.array(variable, mask=mask, fill_value=ma_fill_value) except TypeError: - variable = np.ma.array(variable, mask=mask, - fill_value=ma_fill_value, - dtype=np.array(ma_fill_value).dtype) + variable = np.ma.array( + variable, + mask=mask, + fill_value=ma_fill_value, + dtype=np.array(ma_fill_value).dtype, + ) # If requested switch array from where data is not failing tests # to where data is failing tests. This can be used when over plotting @@ -728,18 +940,23 @@ def get_masked_data(self, var_name, rm_assessments=None, # If asked to return numpy array with values set to NaN if return_nan_array: - variable = variable.astype(np.float) + variable = variable.astype(nan_dtype) variable = variable.filled(fill_value=np.nan) return variable - def datafilter(self, variables=None, rm_assessments=None, rm_tests=None, - np_ma=True, verbose=False, del_qc_var=True): + def datafilter( + self, + variables=None, + rm_assessments=None, + rm_tests=None, + verbose=False, + del_qc_var=False, + ): """ Method to apply quality control variables to data variables by changing the data values in the dataset using quality control variables. - The data variable is changed to to a numpy masked array with failing - data masked or, if requested, to numpy array with failing data set to + The data is updated with failing data set to NaN. This can be used to update the data variable in the xarray dataset for use with xarray methods to perform analysis on the data since those methods don't read the quality control variables. @@ -747,7 +964,8 @@ def datafilter(self, variables=None, rm_assessments=None, rm_tests=None, Parameters ---------- variables : None or str or list of str - Data variable names to process + Data variable names to process. If set to None will update all + data variables. rm_assessments : str or list of str Assessment names listed under quality control varible flag_assessments to exclude from returned data. Examples include @@ -756,81 +974,141 @@ def datafilter(self, variables=None, rm_assessments=None, rm_tests=None, Test numbers listed under quality control variable to exclude from returned data. This is the test number (or bit position number) not the mask number. - np_ma : boolean - Shoudl the data in the xarray DataArray be set to numpy masked - arrays. This shoudl work with most xarray methods. If the xarray - processing method does not work with numpy masked array set to - False to use NaN. verbose : boolean Print processing information. del_qc_var : boolean - Opttion to delete quality control variable after processing. Since + Option to delete quality control variable after processing. Since the data values can not be determined after they are set to NaN and xarray method processing would also process the quality control variables, the default is to remove the quality control data - variables. If numpy masked arrays are used the data are not lost - but would need to be extracted and set to DataArray to return the - dataset back to original state. + variables. Defaults to False. Examples -------- .. code-block:: python - from act.io.armfiles import read_netcdf + from act.io.arm import read_arm_netcdf from act.tests import EXAMPLE_MET1 - ds = read_netcdf(EXAMPLE_MET1) + ds = read_arm_netcdf(EXAMPLE_MET1) ds.clean.cleanup() - var_name = 'atmos_pressure' + var_name = "atmos_pressure" + + ds_1 = ds.nanmean() - ds_1 = ds.mean() + ds.qcfilter.add_less_test(var_name, 99, test_assessment="Bad") + ds.qcfilter.datafilter(rm_assessments="Bad") + ds_2 = ds.nanmean() - ds.qcfilter.add_less_test(var_name, 99, test_assessment='Bad') - ds.qcfilter.datafilter(rm_assessments='Bad') - ds_2 = ds.mean() - print(f'All data: {ds_1[var_name].values}, Bad Removed: {ds_2[var_name].values}') - All data: 98.86097717285156, Bad Removed: 99.15148162841797 + print("All_data =", ds_1[var_name].values) + All_data = 98.86098 + print("Bad_Removed =", ds_2[var_name].values) + Bad_Removed = 99.15148 """ + + if rm_assessments is None and rm_tests is None: + raise ValueError('Need to set rm_assessments or rm_tests option') + if variables is not None and isinstance(variables, str): variables = [variables] if variables is None: - variables = list(self._obj.data_vars) + variables = list(self._ds.data_vars) for var_name in variables: - qc_var_name = self.check_for_ancillary_qc(var_name, - add_if_missing=False, - cleanup=False) + qc_var_name = self.check_for_ancillary_qc(var_name, add_if_missing=False, cleanup=False) if qc_var_name is None: if verbose: + if var_name in ['base_time', 'time_offset']: + continue + + try: + if self._ds[var_name].attrs['standard_name'] == 'quality_flag': + continue + except KeyError: + pass + print(f'No quality control variable for {var_name} found ' f'in call to .qcfilter.datafilter()') + continue - data = self.get_masked_data(var_name, rm_assessments=rm_assessments, - rm_tests=rm_tests, ma_fill_value=np_ma) + # Need to return data as Numpy array with NaN values. Setting the Dask array + # to Numpy masked array does not work with other tools. + data = self.get_masked_data( + var_name, + rm_assessments=rm_assessments, + rm_tests=rm_tests, + return_nan_array=True + ) + + # If data was orginally stored as Dask array return values to Dataset as Dask array + # else set as Numpy array. + try: + self._ds[var_name].data = dask.array.from_array( + data, chunks=self._ds[var_name].data.chunksize) + + except AttributeError: + self._ds[var_name].values = data - self._obj[var_name].values = data + # Adding information on filtering to history attribute + flag_masks = None + flag_assessments = None + flag_meanings = None + try: + flag_assessments = list(self._ds[qc_var_name].attrs['flag_assessments']) + flag_masks = list(self._ds[qc_var_name].attrs['flag_masks']) + flag_meanings = list(self._ds[qc_var_name].attrs['flag_meanings']) + except KeyError: + pass + + # Add comment to history for each test that's filtered out + if isinstance(rm_tests, int): + rm_tests = [rm_tests] + if rm_tests is not None: + for test in list(rm_tests): + test = 2 ** (test - 1) + if test in flag_masks: + index = flag_masks.index(test) + comment = ''.join(['act.qc.datafilter: ', flag_meanings[index]]) + if 'history' in self._ds[var_name].attrs.keys(): + self._ds[var_name].attrs['history'] += '\n' + comment + else: + self._ds[var_name].attrs['history'] = comment + if isinstance(rm_assessments, str): + rm_assessments = [rm_assessments] + if rm_assessments is not None: + for assessment in rm_assessments: + if assessment in flag_assessments: + index = [i for i, e in enumerate(flag_assessments) if e == assessment] + for ind in index: + comment = ''.join(['act.qc.datafilter: ', flag_meanings[ind]]) + if 'history' in self._ds[var_name].attrs.keys(): + self._ds[var_name].attrs['history'] += '\n' + comment + else: + self._ds[var_name].attrs['history'] = comment + + # If requested delete quality control variable if del_qc_var: - del self._obj[qc_var_name] + del self._ds[qc_var_name] if verbose: print(f'Deleting {qc_var_name} from dataset') def set_bit(array, bit_number): """ - Function to set a quality control bit given an a scalar or + Function to set a quality control bit given a scalar or array of values and a bit number. Parameters ---------- - array : int or numpy array + array : int list of int or numpy array of int The bitpacked array to set the bit number. bit_number : int - The bit (or test) number to set. + The bit (or test) number to set starting at 1. Returns ------- @@ -844,10 +1122,11 @@ def set_bit(array, bit_number): .. code-block:: python + from act.qc.qcfilter import set_bit data = np.array(range(0, 7)) data = set_bit(data, 2) print(data) - array([2, 3, 2, 3, 6, 7, 6]) + array([2, 3, 2, 3, 6, 7, 6]) """ was_list = False @@ -861,7 +1140,7 @@ def set_bit(array, bit_number): was_tuple = True if bit_number > 0: - array |= (1 << bit_number - 1) + array |= 1 << bit_number - 1 if was_list: array = list(array) @@ -879,10 +1158,10 @@ def unset_bit(array, bit_number): Parameters ---------- - array : int or numpy array + array : int list of int or numpy array Array of integers containing bit packed numbers. bit_number : int - Bit number to remove. + Bit number to remove starting at 1. Returns ------- @@ -892,16 +1171,17 @@ def unset_bit(array, bit_number): Examples -------- - Example use removing bit 2 from an array called data: + .. code-block:: python - > data = set_bit(0,2) - > data = set_bit(data,3) - > data - 6 + from act.qc.qcfilter import set_bit, unset_bit + data = set_bit([0, 1, 2, 3, 4], 2) + data = set_bit(data, 3) + print(data) + [6, 7, 6, 7, 6] - > data = unset_bit(data,2) - > data - 4 + data = unset_bit(data, 2) + print(data) + [4, 5, 4, 5, 4] """ was_list = False @@ -915,7 +1195,7 @@ def unset_bit(array, bit_number): was_tuple = True if bit_number > 0: - array = array & ~ (1 << bit_number - 1) + array &= ~(1 << bit_number - 1) if was_list: array = list(array) @@ -943,30 +1223,50 @@ def parse_bit(qc_bit): Examples -------- - > parse_bit(7) - array([1, 2, 3]) + .. code-block:: python + + from act.qc.qcfilter import parse_bit + parse_bit(7) + array([1, 2, 3], dtype=int32) """ if isinstance(qc_bit, (list, tuple, np.ndarray)): if len(qc_bit) > 1: - raise ValueError("Must be a single value.") + raise ValueError('Must be a single value.') qc_bit = qc_bit[0] if qc_bit < 0: - raise ValueError("Must be a positive integer.") + raise ValueError('Must be a positive integer.') + + # Convert integer value to single element numpy array of type unsigned integer 64 + value = np.array([qc_bit]).astype(">u8") + + # Convert value to view containing only unsigned integer 8 data type. This + # is required for the numpy unpackbits function which only works with + # unsigned integer 8 bit data type. + value = value.view("u1") + + # Unpack bits using numpy into array of 1 where bit is set and convert into boolean array + index = np.unpackbits(value).astype(bool) + + # Create range of numbers from 64 to 1 and subset where unpackbits found a bit set. + bit_number = np.arange(index.size, 0, -1)[index] + + # Flip the array to increasing numbers to match historical method + bit_number = np.flip(bit_number) - bit_number = [] -# if qc_bit == 0: -# bit_number.append(0) + # bit_number = [] + # qc_bit = int(qc_bit) - counter = 0 - while qc_bit > 0: - temp_value = qc_bit % 2 - qc_bit = qc_bit >> 1 - counter += 1 - if temp_value == 1: - bit_number.append(counter) + # counter = 0 + # while qc_bit > 0: + # temp_value = qc_bit % 2 + # qc_bit = qc_bit >> 1 + # counter += 1 + # if temp_value == 1: + # bit_number.append(counter) + # Convert data type into expected type bit_number = np.asarray(bit_number, dtype=np.int32) return bit_number diff --git a/act/qc/qctests.py b/act/qc/qctests.py index f76baeaa06..45bfb7d179 100644 --- a/act/qc/qctests.py +++ b/act/qc/qctests.py @@ -1,7 +1,4 @@ """ -act.qc.qctests ------------------------------- - Here we define the methods for performing the tests and putting the results in the ancillary quality control varible. If you add a test to this file you will need to add a method reference in the main @@ -9,15 +6,20 @@ """ +import warnings + +import dask.array as da +from metpy.units import units +from metpy.calc import add_height_to_pressure import numpy as np import pandas as pd import xarray as xr -import warnings -from act.utils import get_missing_value, convert_units + +from act.utils.data_utils import convert_units, get_missing_value # This is a Mixins class used to allow using qcfilter class that is already -# registered to the xarray object. All the methods in this class will be added +# registered to the Xarray dataset. All the methods in this class will be added # to the qcfilter class. Doing this to make the code spread across more files # so it is more manageable and readable. Additinal files of tests can be added # to qcfilter by creating a new class in the new file and adding to qcfilter @@ -25,21 +27,29 @@ class QCTests: """ This is a Mixins class used to allow using qcfilter class that is already - registered to the xarray object. All the methods in this class will be added + registered to the Xarray dataset. All the methods in this class will be added to the qcfilter class. Doing this to make the code spread across more files so it is more manageable and readable. Additinal files of tests can be added to qcfilter by creating a new class in the new file and adding to qcfilter class declaration. """ - def __init__(self, obj, **kwargs): - self._obj = obj - - def add_missing_value_test(self, var_name, missing_value=None, - missing_value_att_name='missing_value', - test_number=None, test_assessment='Bad', - test_meaning=None, flag_value=False, - prepend_text=None): + + def __init__(self, ds, **kwargs): + self._ds = ds + + def add_missing_value_test( + self, + var_name, + missing_value=None, + missing_value_att_name='missing_value', + test_number=None, + test_assessment='Bad', + test_meaning=None, + flag_value=False, + prepend_text=None, + use_dask=False, + ): """ Method to add indication in quality control variable where data value is set to missing value. @@ -68,6 +78,8 @@ def add_missing_value_test(self, var_name, missing_value=None, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -83,43 +95,63 @@ def add_missing_value_test(self, var_name, missing_value=None, test_meaning = ': '.join((prepend_text, test_meaning)) if missing_value is None: - missing_value = get_missing_value(self._obj, var_name, nodefault=True) - if (missing_value is None and - self._obj[var_name].values.dtype.type in - (type(0.0), np.float16, np.float32, np.float64)): + missing_value = get_missing_value(self._ds, var_name, nodefault=True) + if missing_value is None and self._ds[var_name].values.dtype.type in ( + float, + np.float16, + np.float32, + np.float64, + ): missing_value = float('nan') else: missing_value = -9999 # Ensure missing_value attribute is matching data type - missing_value = np.array(missing_value, dtype=self._obj[var_name].values.dtype.type) + missing_value = np.array(missing_value, dtype=self._ds[var_name].values.dtype.type) - # New method using straight numpy instead of masked array with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - if np.isnan(missing_value) is False: - index = np.equal(self._obj[var_name].values, missing_value) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + if np.isnan(missing_value) is False: + index = da.where( + self._ds[var_name].data == missing_value, True, False + ).compute() + else: + index = da.isnan(self._ds[var_name].data).compute() else: - index = np.isnan(self._obj[var_name].values) + if np.isnan(missing_value) is False: + index = np.equal(self._ds[var_name].values, missing_value) + else: + index = np.isnan(self._ds[var_name].values) - test_dict = self._obj.qcfilter.add_test( - var_name, index=index, + test_dict = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) try: - self._obj[var_name].attrs[missing_value_att_name] + self._ds[var_name].attrs[missing_value_att_name] except KeyError: - self._obj[var_name].attrs[missing_value_att_name] = missing_value + self._ds[var_name].attrs[missing_value_att_name] = missing_value return test_dict - def add_less_test(self, var_name, limit_value, test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, limit_attr_name=None, - prepend_text=None): + def add_less_test( + self, + var_name, + limit_value, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_name=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform a less than test (i.e. minimum value) and add result to ancillary quality control variable. If ancillary @@ -151,6 +183,8 @@ def add_less_test(self, var_name, limit_value, test_meaning=None, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -176,30 +210,42 @@ def add_less_test(self, var_name, limit_value, test_meaning=None, if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) - # New method with straight numpy with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - index = np.less(self._obj[var_name].values, limit_value) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index = da.where(self._ds[var_name].data < limit_value, True, False).compute() + else: + index = np.less(self._ds[var_name].values, limit_value) - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value = np.array(limit_value, dtype=self._obj[var_name].values.dtype.type) + limit_value = np.array(limit_value, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name] = limit_value + self._ds[qc_var_name].attrs[attr_name] = limit_value return result - def add_greater_test(self, var_name, limit_value, test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, limit_attr_name=None, - prepend_text=None): + def add_greater_test( + self, + var_name, + limit_value, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_name=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform a greater than test (i.e. maximum value) and add result to ancillary quality control variable. If ancillary @@ -231,6 +277,8 @@ def add_greater_test(self, var_name, limit_value, test_meaning=None, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -257,28 +305,41 @@ def add_greater_test(self, var_name, limit_value, test_meaning=None, test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - index = np.greater(self._obj[var_name].values, limit_value) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index = da.where(self._ds[var_name].data > limit_value, True, False).compute() + else: + index = np.greater(self._ds[var_name].values, limit_value) - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value = np.array(limit_value, dtype=self._obj[var_name].values.dtype.type) + limit_value = np.array(limit_value, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name] = limit_value + self._ds[qc_var_name].attrs[attr_name] = limit_value return result - def add_less_equal_test(self, var_name, limit_value, test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, limit_attr_name=None, - prepend_text=None): + def add_less_equal_test( + self, + var_name, + limit_value, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_name=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform a less than or equal to test (i.e. minimum value) and add result to ancillary quality control @@ -311,6 +372,8 @@ def add_less_equal_test(self, var_name, limit_value, test_meaning=None, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -331,35 +394,51 @@ def add_less_equal_test(self, var_name, limit_value, test_meaning=None, attr_name = limit_attr_name if test_meaning is None: - test_meaning = ('Data value less than ' - 'or equal to {}.').format(attr_name) + test_meaning = ('Data value less than ' 'or equal to {}.').format(attr_name) if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - index = np.less_equal(self._obj[var_name].values, limit_value) + warnings.filterwarnings('ignore', category=RuntimeWarning) + index = np.less_equal(self._ds[var_name].values, limit_value) - result = self._obj.qcfilter.add_test( - var_name, index=index, + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index = da.where(self._ds[var_name].data <= limit_value, True, False).compute() + else: + index = np.less_equal(self._ds[var_name].values, limit_value) + + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value = np.array(limit_value, dtype=self._obj[var_name].values.dtype.type) + limit_value = np.array(limit_value, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name] = limit_value + self._ds[qc_var_name].attrs[attr_name] = limit_value return result - def add_greater_equal_test(self, var_name, limit_value, test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, limit_attr_name=None, - prepend_text=None): + def add_greater_equal_test( + self, + var_name, + limit_value, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_name=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform a greater than or equal to test (i.e. maximum value) and add result to ancillary quality control @@ -392,6 +471,8 @@ def add_greater_equal_test(self, var_name, limit_value, test_meaning=None, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -412,35 +493,47 @@ def add_greater_equal_test(self, var_name, limit_value, test_meaning=None, attr_name = limit_attr_name if test_meaning is None: - test_meaning = ('Data value greater than ' - 'or equal to {}.').format(attr_name) + test_meaning = ('Data value greater than ' 'or equal to {}.').format(attr_name) if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - index = np.greater_equal(self._obj[var_name].values, limit_value) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index = da.where(self._ds[var_name].data >= limit_value, True, False).compute() + else: + index = np.greater_equal(self._ds[var_name].values, limit_value) - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value = np.array(limit_value, dtype=self._obj[var_name].values.dtype.type) + limit_value = np.array(limit_value, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name] = limit_value + self._ds[qc_var_name].attrs[attr_name] = limit_value return result - def add_equal_to_test(self, var_name, limit_value, test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, limit_attr_name=None, - prepend_text=None): + def add_equal_to_test( + self, + var_name, + limit_value, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_name=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform an equal test and add result to ancillary quality control variable. If ancillary quality control variable does not @@ -472,6 +565,8 @@ def add_equal_to_test(self, var_name, limit_value, test_meaning=None, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -492,34 +587,47 @@ def add_equal_to_test(self, var_name, limit_value, test_meaning=None, attr_name = limit_attr_name if test_meaning is None: - test_meaning = 'Data value equal to {}.'.format(attr_name) + test_meaning = f'Data value equal to {attr_name}.' if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - index = np.equal(self._obj[var_name].values, limit_value) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index = da.where(self._ds[var_name].data == limit_value, True, False).compute() + else: + index = np.equal(self._ds[var_name].values, limit_value) - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value = np.array(limit_value, dtype=self._obj[var_name].values.dtype.type) + limit_value = np.array(limit_value, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name] = limit_value + self._ds[qc_var_name].attrs[attr_name] = limit_value return result - def add_not_equal_to_test(self, var_name, limit_value, test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, limit_attr_name=None, - prepend_text=None): + def add_not_equal_to_test( + self, + var_name, + limit_value, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_name=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform a not equal to test and add result to ancillary quality control variable. If ancillary quality control variable does @@ -551,6 +659,8 @@ def add_not_equal_to_test(self, var_name, limit_value, test_meaning=None, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -571,35 +681,48 @@ def add_not_equal_to_test(self, var_name, limit_value, test_meaning=None, attr_name = limit_attr_name if test_meaning is None: - test_meaning = 'Data value not equal to {}.'.format(attr_name) + test_meaning = f'Data value not equal to {attr_name}.' if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - index = np.not_equal(self._obj[var_name].values, limit_value) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index = da.where(self._ds[var_name].data != limit_value, True, False).compute() + else: + index = np.not_equal(self._ds[var_name].values, limit_value) - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value = np.array(limit_value, dtype=self._obj[var_name].values.dtype.type) + limit_value = np.array(limit_value, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name] = limit_value + self._ds[qc_var_name].attrs[attr_name] = limit_value return result - def add_outside_test(self, var_name, limit_value_lower, limit_value_upper, - test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, limit_attr_names=None, - prepend_text=None): + def add_outside_test( + self, + var_name, + limit_value_lower, + limit_value_upper, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_names=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform a less than or greater than test (i.e. outide minimum and maximum value) and add @@ -636,6 +759,8 @@ def add_outside_test(self, var_name, limit_value_lower, limit_value_upper, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -657,44 +782,60 @@ def add_outside_test(self, var_name, limit_value_lower, limit_value_upper, attr_name_upper = limit_attr_names[1] if test_meaning is None: - test_meaning = ('Data value less than {} ' - 'or greater than {}.').format(attr_name_lower, - attr_name_upper) + test_meaning = ('Data value less than {} ' 'or greater than {}.').format( + attr_name_lower, attr_name_upper + ) if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - data = np.ma.masked_outside(self._obj[var_name].values, - limit_value_lower, limit_value_upper) - if data.mask.size == 1: - data.mask = np.full(data.data.shape, data.mask, dtype=bool) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index1 = da.where(self._ds[var_name].data < limit_value_lower, True, False) + index2 = da.where(self._ds[var_name].data > limit_value_upper, True, False) + index = (index1 | index2).compute() + else: + data = np.ma.masked_outside( + self._ds[var_name].values, limit_value_lower, limit_value_upper + ) + if data.mask.size == 1: + data.mask = np.full(data.data.shape, data.mask, dtype=bool) - index = data.mask + index = data.mask - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value_lower = np.array(limit_value_lower, dtype=self._obj[var_name].values.dtype.type) - limit_value_upper = np.array(limit_value_upper, dtype=self._obj[var_name].values.dtype.type) + limit_value_lower = np.array(limit_value_lower, dtype=self._ds[var_name].values.dtype.type) + limit_value_upper = np.array(limit_value_upper, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name_lower] = limit_value_lower - self._obj[qc_var_name].attrs[attr_name_upper] = limit_value_upper + self._ds[qc_var_name].attrs[attr_name_lower] = limit_value_lower + self._ds[qc_var_name].attrs[attr_name_upper] = limit_value_upper return result - def add_inside_test(self, var_name, limit_value_lower, limit_value_upper, - test_meaning=None, test_assessment='Bad', - test_number=None, flag_value=False, - limit_attr_names=None, - prepend_text=None): + def add_inside_test( + self, + var_name, + limit_value_lower, + limit_value_upper, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + limit_attr_names=None, + prepend_text=None, + use_dask=False, + ): """ Method to perform a greater than or less than test (i.e. between minimum and maximum value) and add @@ -731,6 +872,8 @@ def add_inside_test(self, var_name, limit_value_lower, limit_value_upper, prepend_text : str Optional text to prepend to the test meaning. Example is indicate what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array Returns ------- @@ -752,43 +895,60 @@ def add_inside_test(self, var_name, limit_value_lower, limit_value_upper, attr_name_upper = limit_attr_names[1] if test_meaning is None: - test_meaning = ('Data value greater than {} ' - 'or less than {}.').format(attr_name_lower, - attr_name_upper) + test_meaning = ('Data value greater than {} ' 'or less than {}.').format( + attr_name_lower, attr_name_upper + ) if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - data = np.ma.masked_inside(self._obj[var_name].values, - limit_value_lower, limit_value_upper) - if data.mask.size == 1: - data.mask = np.full(data.data.shape, data.mask, dtype=bool) + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index1 = da.where(self._ds[var_name].data > limit_value_lower, True, False) + index2 = da.where(self._ds[var_name].data < limit_value_upper, True, False) + index = (index1 & index2).compute() + else: + data = np.ma.masked_inside( + self._ds[var_name].values, limit_value_lower, limit_value_upper + ) + if data.mask.size == 1: + data.mask = np.full(data.data.shape, data.mask, dtype=bool) - index = data.mask + index = data.mask - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) # Ensure limit_value attribute is matching data type - limit_value_lower = np.array(limit_value_lower, dtype=self._obj[var_name].values.dtype.type) - limit_value_upper = np.array(limit_value_upper, dtype=self._obj[var_name].values.dtype.type) + limit_value_lower = np.array(limit_value_lower, dtype=self._ds[var_name].values.dtype.type) + limit_value_upper = np.array(limit_value_upper, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name_lower] = limit_value_lower - self._obj[qc_var_name].attrs[attr_name_upper] = limit_value_upper + self._ds[qc_var_name].attrs[attr_name_lower] = limit_value_lower + self._ds[qc_var_name].attrs[attr_name_upper] = limit_value_upper return result - def add_persistence_test(self, var_name, window=10, test_limit=0.0001, - min_periods=1, center=True, test_meaning=None, - test_assessment='Bad', test_number=None, - flag_value=False, prepend_text=None): + def add_persistence_test( + self, + var_name, + window=10, + test_limit=0.0001, + min_periods=1, + center=True, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + prepend_text=None, + ): """ Method to perform a persistence test over 1-D data.. @@ -831,40 +991,52 @@ def add_persistence_test(self, var_name, window=10, test_limit=0.0001, test_number, test_meaning, test_assessment """ - data = self._obj[var_name] + data = self._ds[var_name] if window > data.size: window = data.size if test_meaning is None: - test_meaning = ('Data failing persistence test. ' - 'Standard Deviation over a window of {} values ' - 'less than {}.').format(window, test_limit) + test_meaning = ( + 'Data failing persistence test. ' + 'Standard Deviation over a window of {} values ' + 'less than {}.' + ).format(window, test_limit) if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) + warnings.filterwarnings('ignore', category=RuntimeWarning) stddev = data.rolling(time=window, min_periods=min_periods, center=True).std() index = stddev < test_limit - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) return result - def add_difference_test(self, var_name, dataset2_dict=None, ds2_var_name=None, - diff_limit=None, tolerance="1m", - set_test_regardless=True, - apply_assessment_to_dataset2=None, - apply_tests_to_dataset2=None, - test_meaning=None, test_assessment='Bad', - test_number=None, flag_value=False, - prepend_text=None): + def add_difference_test( + self, + var_name, + dataset2_dict=None, + ds2_var_name=None, + diff_limit=None, + tolerance='1m', + set_test_regardless=True, + apply_assessment_to_dataset2=None, + apply_tests_to_dataset2=None, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + prepend_text=None, + ): """ Method to perform a comparison test on time series data. Tested on 1-D data only. Will check if units and long_name indicate a direction and @@ -921,31 +1093,37 @@ def add_difference_test(self, var_name, dataset2_dict=None, ds2_var_name=None, test_number, test_meaning, test_assessment """ + + if set_test_regardless is False and dataset2_dict is None: + return + if dataset2_dict is None: - dataset2_dict = {'second_dataset': self._obj} + dataset2_dict = {'second_dataset': self._ds} - if not isinstance(dataset2_dict, dict): - raise ValueError('You did not provide a dictionary containing the ' - 'datastream name as the key and xarray dataset as ' - 'the value for dataset2_dict for add_difference_test().') + else: + if not isinstance(dataset2_dict, dict): + raise ValueError( + 'You did not provide a dictionary containing the ' + 'datastream name as the key and xarray dataset as ' + 'the value for dataset2_dict for add_difference_test().' + ) - if diff_limit is None: - raise ValueError('You did not provide a test limit for add_difference_test().') + if diff_limit is None: + raise ValueError('You did not provide a test limit for add_difference_test().') datastream2 = list(dataset2_dict.keys())[0] dataset2 = dataset2_dict[datastream2] - if set_test_regardless is False and type(dataset2) != xr.core.dataset.Dataset: - return - if test_meaning is None: - if dataset2 is self._obj: + if dataset2 is self._ds: var_name2 = f'{ds2_var_name}' else: var_name2 = f'{datastream2}:{ds2_var_name}' - test_meaning = (f'Difference between {var_name} and {var_name2} ' - f'greater than {diff_limit} {self._obj[var_name].attrs["units"]}') + test_meaning = ( + f'Difference between {var_name} and {var_name2} ' + f'greater than {diff_limit} {self._ds[var_name].attrs["units"]}' + ) if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) @@ -954,41 +1132,51 @@ def add_difference_test(self, var_name, dataset2_dict=None, ds2_var_name=None, tolerance = pd.Timedelta(tolerance) index = [] - if type(dataset2) == xr.core.dataset.Dataset: + if isinstance(dataset2, xr.core.dataset.Dataset): if apply_assessment_to_dataset2 is not None or apply_tests_to_dataset2 is not None: dataset2[ds2_var_name].values = dataset2.qcfilter.get_masked_data( - ds2_var_name, rm_assessments=apply_assessment_to_dataset2, - rm_tests=apply_tests_to_dataset2, return_nan_array=True) - - df_a = pd.DataFrame({'time': self._obj['time'].values, - var_name: self._obj[var_name].values}) - data_b = convert_units(dataset2[ds2_var_name].values, - dataset2[ds2_var_name].attrs['units'], - self._obj[var_name].attrs['units']) + ds2_var_name, + rm_assessments=apply_assessment_to_dataset2, + rm_tests=apply_tests_to_dataset2, + return_nan_array=True, + ) + + df_a = pd.DataFrame( + {'time': self._ds['time'].values, var_name: self._ds[var_name].values} + ) + data_b = convert_units( + dataset2[ds2_var_name].values, + dataset2[ds2_var_name].attrs['units'], + self._ds[var_name].attrs['units'], + ) ds2_var_name = ds2_var_name + '_newname' - df_b = pd.DataFrame({'time': dataset2['time'].values, - ds2_var_name: data_b}) + df_b = pd.DataFrame({'time': dataset2['time'].values, ds2_var_name: data_b}) if tolerance is not None: tolerance = pd.Timedelta(tolerance) - pd_c = pd.merge_asof(df_a, df_b, on='time', tolerance=tolerance, - direction="nearest") + pd_c = pd.merge_asof(df_a, df_b, on='time', tolerance=tolerance, direction='nearest') with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) + warnings.filterwarnings('ignore', category=RuntimeWarning) # Check if variable is for wind direction comparisons. Fix # for 0 - 360 degrees transition. This is done by adding 360 degrees to # all wind values and using modulus to get the minimum difference number. # This is done for both a-b and b-a and then choosing the minimum number # to compensate for large differences. wdir_units = ['deg', 'degree', 'degrees', 'degs'] - if (self._obj[var_name].attrs['units'] in wdir_units and - 'direction' in self._obj[var_name].attrs['long_name'].lower()): - diff1 = np.mod(np.absolute((pd_c[var_name] + 360.) - - (pd_c[ds2_var_name] + 360.)), 360) - diff2 = np.mod(np.absolute((pd_c[ds2_var_name] + 360.) - - (pd_c[var_name] + 360.)), 360) + if ( + self._ds[var_name].attrs['units'] in wdir_units + and 'direction' in self._ds[var_name].attrs['long_name'].lower() + ): + diff1 = np.mod( + np.absolute((pd_c[var_name] + 360.0) - (pd_c[ds2_var_name] + 360.0)), + 360, + ) + diff2 = np.mod( + np.absolute((pd_c[ds2_var_name] + 360.0) - (pd_c[var_name] + 360.0)), + 360, + ) diff = np.array([diff1, diff2]) diff = np.nanmin(diff, axis=0) @@ -997,19 +1185,28 @@ def add_difference_test(self, var_name, dataset2_dict=None, ds2_var_name=None, index = diff > diff_limit - result = self._obj.qcfilter.add_test( - var_name, index=index, + result = self._ds.qcfilter.add_test( + var_name, + index=index, test_number=test_number, test_meaning=test_meaning, test_assessment=test_assessment, - flag_value=flag_value) + flag_value=flag_value, + ) return result - def add_delta_test(self, var_name, diff_limit=1, test_meaning=None, - limit_attr_name=None, - test_assessment='Indeterminate', test_number=None, - flag_value=False, prepend_text=None): + def add_delta_test( + self, + var_name, + diff_limit=1, + test_meaning=None, + limit_attr_name=None, + test_assessment='Indeterminate', + test_number=None, + flag_value=False, + prepend_text=None, + ): """ Method to perform a difference test on adjacent values in time series. Will flag both values where a difference is greater @@ -1064,32 +1261,359 @@ def add_delta_test(self, var_name, diff_limit=1, test_meaning=None, test_meaning = ': '.join((prepend_text, test_meaning)) with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) + warnings.filterwarnings('ignore', category=RuntimeWarning) # Check if variable is for wind direction comparisons by units. Fix # for 0 - 360 degrees transition. This is done by adding 360 degrees to # all wind values and using modulus to get the minimum difference number. wdir_units = ['deg', 'degree', 'degrees', 'degs'] - if (self._obj[var_name].attrs['units'] in wdir_units and - 'direction' in self._obj[var_name].attrs['long_name'].lower()): - abs_diff = np.mod(np.abs(np.diff(self._obj[var_name].values)), 360) + if ( + self._ds[var_name].attrs['units'] in wdir_units + and 'direction' in self._ds[var_name].attrs['long_name'].lower() + ): + abs_diff = np.mod(np.abs(np.diff(self._ds[var_name].values)), 360) else: - abs_diff = np.abs(np.diff(self._obj[var_name].values)) + abs_diff = np.abs(np.diff(self._ds[var_name].values)) index = np.where(abs_diff >= diff_limit)[0] if index.size > 0: index = np.append(index, index + 1) index = np.unique(index) - result = self._obj.qcfilter.add_test(var_name, index=index, - test_number=test_number, - test_meaning=test_meaning, - test_assessment=test_assessment, - flag_value=flag_value) + result = self._ds.qcfilter.add_test( + var_name, + index=index, + test_number=test_number, + test_meaning=test_meaning, + test_assessment=test_assessment, + flag_value=flag_value, + ) # Ensure min value attribute is matching data type - diff_limit = np.array(diff_limit, dtype=self._obj[var_name].values.dtype.type) + diff_limit = np.array(diff_limit, dtype=self._ds[var_name].values.dtype.type) qc_var_name = result['qc_variable_name'] - self._obj[qc_var_name].attrs[attr_name] = diff_limit + self._ds[qc_var_name].attrs[attr_name] = diff_limit + + return result + + def add_iqr_test( + self, + var_name, + coef=1.5, + test_meaning=None, + test_assessment='Indeterminate', + test_number=None, + flag_value=False, + prepend_text=None, + ): + """ + Method to perform an interquartile range outliers test on 1D data. + Data that lie within the lower and upper limits are considered + non-outliers. The lower limit is the number that lies coef IQRs below + the first quartile; the upper limit is the number that lies coef IQRs + above the third quartile. This method will flag data + failing the test in the corresponding quality control variable. + + The library used to perform test does not accept NaN values. The NaN + values will be filtered out prior to testing and outlier values will + be matched after. This can cause the test to run slower on large data + sets. + + Parameters + ---------- + var_name : str + Data variable name. + coef : float + Coefficient by which interquartile range is multiplied. + test_meaning : str + Optional text description to add to flag_meanings + describing the test. Will use a default if not set. + test_assessment : str + Optional single word describing the assessment of the test. + Will use a default if not set. + test_number : int + Optional test number to use. If not set will use next available + test number. + flag_value : boolean + Indicates that the tests are stored as integers + not bit packed values in quality control variable. + prepend_text : str + Optional text to prepend to the test meaning. + Example is indicate what institution added the test. + + Returns + ------- + test_info : tuple + A tuple containing test information including var_name, qc + variable name, test_number, test_meaning, test_assessment + + """ + + try: + from scikit_posthocs import outliers_iqr + except ImportError: + raise ImportError( + 'scikit_posthocs needs to be installed on your system to ' + 'run add_iqr_test.' + ) + + if test_meaning is None: + test_meaning = ( + 'Value outside of interquartile range test range with ' f'a coefficient of {coef}' + ) + + if prepend_text is not None: + test_meaning = ': '.join((prepend_text, test_meaning)) + + data = self._ds[var_name].values + data = data[np.isfinite(data)] + + fail_data = outliers_iqr(data, ret='outliers') + + index = [] + if fail_data.size > 0: + index = np.array([], dtype=int) + for ii in np.unique(fail_data): + ind = np.atleast_1d(self._ds[var_name].values == ii).nonzero() + index = np.append(index, ind) + + result = self._ds.qcfilter.add_test( + var_name, + index=index, + test_number=test_number, + test_meaning=test_meaning, + test_assessment=test_assessment, + flag_value=flag_value, + ) + + return result + + def add_gesd_test( + self, + var_name, + outliers=5, + alpha=0.05, + test_meaning=None, + test_assessment='Indeterminate', + test_number=None, + flag_value=False, + prepend_text=None, + ): + """ + Method to perform generalized Extreme Studentized Deviate test to + detect one or more outliers in a univariate data set that follows an + approximately normal distribution. Default is to find 5 outliers but + can overestimate number of outliers and will only flag values + determined to be outliers. If set to find one outlier is the Grubbs + test. + + The library used to perform test does not accept NaN values. The NaN + values will be filtered out prior to testing and outlier values will + be matched after. This can cause the test to run slower on large data + sets. + + Parameters + ---------- + var_name : str + Data variable name. + outliers : int or float + Number of outliers to test for. If set to 1 is the Grubbs test. + If set to float values less than one will calcualte the number of + outliers to test for. Float value from 0 to 0.9 will be multiplied + by the number of data values to determine number of outliers to + check. If set to value larger than 0.9 will use 0.9. + alpha : float + Significance level for a hypothesis test + test_meaning : str + Optional text description to add to flag_meanings + describing the test. Will use a default if not set. + test_assessment : str + Optional single word describing the assessment of the test. + Will use a default if not set. + test_number : int + Optional test number to use. If not set will use next available + test number. + flag_value : boolean + Indicates that the tests are stored as integers + not bit packed values in quality control variable. + prepend_text : str + Optional text to prepend to the test meaning. + Example is indicate what institution added the test. + + Returns + ------- + test_info : tuple + A tuple containing test information including var_name, qc + variable name, test_number, test_meaning, test_assessment + + """ + + try: + from scikit_posthocs import outliers_gesd + except ImportError: + raise ImportError( + 'scikit_posthocs needs to be installed on your system to ' + 'run add_gesd_test.' + ) + + if test_meaning is None: + test_meaning = ( + 'Value failed generalized Extreme Studentized Deviate test ' + f'with an alpha of {alpha}' + ) + + if prepend_text is not None: + test_meaning = ': '.join((prepend_text, test_meaning)) + + data = self._ds[var_name].values + + if outliers < 1: + if outliers > 0.9: + outliers = 0.9 + outliers = int(np.ceil(outliers * data.size)) + else: + outliers = int(outliers) + + data = data[np.isfinite(data)] + + index = outliers_gesd(data, outliers=outliers, hypo=True, alpha=alpha) + + if index.dtype == np.bool_: + fail_data = data[index] + index = np.array([], dtype=int) + for ii in np.unique(fail_data): + ind = (self._ds[var_name].values == ii).nonzero() + index = np.append(index, ind) + else: + index = [] + + result = self._ds.qcfilter.add_test( + var_name, + index=index, + test_number=test_number, + test_meaning=test_meaning, + test_assessment=test_assessment, + flag_value=flag_value, + ) + + return result + + def add_atmospheric_pressure_test( + self, + var_name, + alt_name='alt', + test_limit=3.5, + sea_level_pressure=101.325, + bias=0.35, + test_meaning=None, + test_assessment='Bad', + test_number=None, + flag_value=False, + prepend_text=None, + use_dask=False + ): + """ + Method to perform a limit test on atmospheric pressure data using + pressure derived from altitude value. Will use the derived pressure as + a mean and apply upper and lower limit test on the data, flagging + where outside the limit range. + + Parameters + ---------- + var_name : str + Data variable name within the Dataset + alt_name : str + Altitude data variable name within the Dataset + test_limit : int or float + Test range value to add/subtract from derived pressure value to + set range limits. + sea_level_pressure : float + Sea level pressure in kPa used for deriving pressure at altitude. + bias : float + The derived pressure value in has a slight bias from typically + measured values. This allows adjusting the limits. This value in + units of kPa is added to the derived pressure value. + test_meaning : str + Optional text description to add to flag_meanings describing the + test. Will use a default if not set. + test_assessment : str + Optional single word describing the assessment of the test. + Will use a default if not set. + test_number : int + Optional test number to use. If not set will use next available + test number. + flag_value : boolean + Indicates that the tests are stored as integers not bit packed + values in quality control variable. + prepend_text : str + Optional text to prepend to the test meaning. Example is indicate + what institution added the test. + use_dask : boolean + Option to use Dask for searching if data is stored in a Dask array. + + Returns + ------- + test_info : tuple + A tuple containing test information including var_name, qc + variable name, test_number, test_meaning, test_assessment. + + Examples + -------- + .. code-block:: python + + result = ds.qcfilter.add_atmospheric_pressure_test('atmos_pressure', use_dask=True) + print(result) + + {'test_number': 1, 'test_meaning': 'Value outside of atmospheric pressure range test range: 94.41 to 101.41 kPa', + 'test_assessment': 'Bad', 'qc_variable_name': 'qc_atmos_pressure', 'variable_name': 'atmos_pressure'} + + + """ + data_units = self._ds[var_name].attrs['units'] + working_units = 'kPa' + test_limit = test_limit * units(working_units) + test_limit = test_limit.to(data_units) + altitude = self._ds[alt_name].values + if altitude.size > 1: + altitude = np.nanmean(altitude) + + altitude = altitude * units(self._ds[alt_name].attrs['units']) + + sea_level_pressure = sea_level_pressure * units(working_units) + bias = bias * units(working_units) + bias = bias.to(data_units) + pressure = add_height_to_pressure(sea_level_pressure, altitude) + pressure = pressure.to(data_units) + pressure += bias + + lower_limit = pressure - test_limit + upper_limit = pressure + test_limit + lower_limit = lower_limit.magnitude + upper_limit = upper_limit.magnitude + + if test_meaning is None: + test_meaning = ('Value outside of atmospheric pressure range test range: ' + f'{round(lower_limit, 2)} to {round(upper_limit, 2)} {data_units}') + + if prepend_text is not None: + test_meaning = ': '.join((prepend_text, test_meaning)) + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + if use_dask and isinstance(self._ds[var_name].data, da.Array): + index1 = da.where(self._ds[var_name].data < lower_limit, True, False) + index2 = da.where(self._ds[var_name].data > upper_limit, True, False) + index = (index1 | index2).compute() + else: + index = (self._ds[var_name].values > upper_limit) | (self._ds[var_name].values < lower_limit) + + result = self._ds.qcfilter.add_test( + var_name, + index=index, + test_number=test_number, + test_meaning=test_meaning, + test_assessment=test_assessment, + flag_value=flag_value, + ) return result diff --git a/act/qc/radiometer_tests.py b/act/qc/radiometer_tests.py index 1833aa72d8..34ba7687c2 100644 --- a/act/qc/radiometer_tests.py +++ b/act/qc/radiometer_tests.py @@ -1,28 +1,32 @@ """ -act.qc.radiometer_tests ------------------------------- +Tests specific to radiometers. -Tests specific to radiometers """ -from scipy.fftpack import rfft, rfftfreq -import numpy as np -import xarray as xr -import pandas as pd import datetime -import dask import warnings +import dask +import numpy as np +import pandas as pd +import xarray as xr +from scipy.fftpack import rfft, rfftfreq + from act.utils.datetime_utils import determine_time_delta from act.utils.geo_utils import get_sunrise_sunset_noon, is_sun_visible -def fft_shading_test(obj, variable='diffuse_hemisp_narrowband_filter4', - fft_window=30, - shad_freq_lower=[0.008, 0.017], - shad_freq_upper=[0.0105, 0.0195], - ratio_thresh=[3.15, 1.2], - time_interval=None, smooth_window=5, shading_thresh=0.4): +def fft_shading_test( + ds, + variable='diffuse_hemisp_narrowband_filter4', + fft_window=30, + shad_freq_lower=[0.008, 0.017], + shad_freq_upper=[0.0105, 0.0195], + ratio_thresh=[3.15, 1.2], + time_interval=None, + smooth_window=5, + shading_thresh=0.4, +): """ Function to test shadowband radiometer (MFRSR, RSS, etc) instruments for shading related problems. Program was adapted by Adam Theisen @@ -36,13 +40,13 @@ def fft_shading_test(obj, variable='diffuse_hemisp_narrowband_filter4', Function has been tested and is in use by the ARM DQ Office for problem detection. It is know to have some false positives at times. - Need to run obj.clean.cleanup() ahead of time to ensure proper addition + Need to run ds.clean.cleanup() ahead of time to ensure proper addition to QC variable Parameters ---------- - obj : xarray Dataset - Data object + ds : xarray.Dataset + Xarray dataset variable : string Name of variable to process fft_window : int @@ -64,8 +68,8 @@ def fft_shading_test(obj, variable='diffuse_hemisp_narrowband_filter4', Returns ------- - obj : xarray Dataset - Data object + ds : xarray.Dataset + Xarray dataset tested for shading problems References ---------- @@ -77,12 +81,12 @@ def fft_shading_test(obj, variable='diffuse_hemisp_narrowband_filter4', """ # Get time and data from variable - time = obj['time'].values - data = obj[variable].values - if 'missing_value' in obj[variable].attrs: - missing = obj[variable].attrs['missing_value'] + time = ds['time'].values + data = ds[variable].values + if 'missing_value' in ds[variable].attrs: + missing = ds[variable].attrs['missing_value'] else: - missing = -9999. + missing = -9999.0 # Get time interval between measurements if time_interval is None: @@ -92,7 +96,7 @@ def fft_shading_test(obj, variable='diffuse_hemisp_narrowband_filter4', # Compute the FFT for each point +- window samples task = [] - sun_up = is_sun_visible(latitude=obj['lat'].values, longitude=obj['lon'].values, date_time=time) + sun_up = is_sun_visible(latitude=ds['lat'].values, longitude=ds['lon'].values, date_time=time) for t in range(len(time)): sind = t - fft_window eind = t + fft_window @@ -103,18 +107,22 @@ def fft_shading_test(obj, variable='diffuse_hemisp_narrowband_filter4', # Get data and remove all nan/missing values d = data[sind:eind] - idx = ((d != missing) & (np.isnan(d) is not True)) + idx = (d != missing) & (np.isnan(d) is not True) index = np.where(idx) d = d[index] # Add to task for dask processing - task.append(dask.delayed(fft_shading_test_process)( - time[t], d, - shad_freq_lower=shad_freq_lower, - shad_freq_upper=shad_freq_upper, - ratio_thresh=ratio_thresh, - time_interval=dt, - is_sunny=sun_up[t])) + task.append( + dask.delayed(fft_shading_test_process)( + time[t], + d, + shad_freq_lower=shad_freq_lower, + shad_freq_upper=shad_freq_upper, + ratio_thresh=ratio_thresh, + time_interval=dt, + is_sunny=sun_up[t], + ) + ) # Process using dask result = dask.compute(*task) @@ -125,40 +133,57 @@ def fft_shading_test(obj, variable='diffuse_hemisp_narrowband_filter4', shading = pd.Series(shading).rolling(window=smooth_window, min_periods=1).median() # Find indices where shading is indicated - idx = (np.asarray(shading) > shading_thresh) + idx = np.asarray(shading) > shading_thresh index = np.where(idx) # Add test to QC Variable desc = 'FFT Shading Test' - obj.qcfilter.add_test(variable, index=index, test_meaning=desc) + ds.qcfilter.add_test(variable, index=index, test_meaning=desc) - # Prepare frequency and fft variables for adding to object + # Prepare frequency and fft variables for adding to the dataset fft = np.empty([len(time), fft_window * 2]) fft[:] = np.nan freq = np.empty([len(time), fft_window * 2]) freq[:] = np.nan for i, r in enumerate(result): dummy = r['fft'] - fft[i, 0:len(dummy)] = dummy + fft[i, 0 : len(dummy)] = dummy dummy = r['freq'] - freq[i, 0:len(dummy)] = dummy - - attrs = {'units': '', 'long_name': 'FFT Results for Shading Test', 'upper_freq': shad_freq_upper, - 'lower_freq': shad_freq_lower} - fft_window = xr.DataArray(range(fft_window * 2), dims=['fft_window'], - attrs={'long_name': 'FFT Window', 'units': '1'}) - da = xr.DataArray(fft, dims=['time', 'fft_window'], attrs=attrs, coords=[obj['time'], fft_window]) - obj['fft'] = da + freq[i, 0 : len(dummy)] = dummy + + attrs = { + 'units': '', + 'long_name': 'FFT Results for Shading Test', + 'upper_freq': shad_freq_upper, + 'lower_freq': shad_freq_lower, + } + fft_window = xr.DataArray( + range(fft_window * 2), + dims=['fft_window'], + attrs={'long_name': 'FFT Window', 'units': '1'}, + ) + da = xr.DataArray( + fft, dims=['time', 'fft_window'], attrs=attrs, coords=[ds['time'], fft_window] + ) + ds['fft'] = da attrs = {'units': '', 'long_name': 'FFT Frequency Values for Shading Test'} - da = xr.DataArray(freq, dims=['time', 'fft_window'], attrs=attrs, coords=[obj['time'], fft_window]) - obj['fft_freq'] = da - - return obj - - -def fft_shading_test_process(time, data, shad_freq_lower=None, - shad_freq_upper=None, ratio_thresh=None, - time_interval=None, is_sunny=None): + da = xr.DataArray( + freq, dims=['time', 'fft_window'], attrs=attrs, coords=[ds['time'], fft_window] + ) + ds['fft_freq'] = da + + return ds + + +def fft_shading_test_process( + time, + data, + shad_freq_lower=None, + shad_freq_upper=None, + ratio_thresh=None, + time_interval=None, + is_sunny=None, +): """ Processing function to do the FFT calculations/thresholding @@ -193,8 +218,8 @@ def fft_shading_test_process(time, data, shad_freq_lower=None, # Get FFT data under threshold with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - idx = (fftv > 1.) + warnings.filterwarnings('ignore', category=RuntimeWarning) + idx = fftv > 1.0 index = np.where(idx) fftv[index] = np.nan freq[index] = np.nan @@ -215,9 +240,8 @@ def fft_shading_test_process(time, data, shad_freq_lower=None, # Calculate threshold of peak value to surrounding values for i in range(len(shad_freq_lower)): with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - idx = np.logical_and(freq > shad_freq_lower[i], - freq < shad_freq_upper[i]) + warnings.filterwarnings('ignore', category=RuntimeWarning) + idx = np.logical_and(freq > shad_freq_lower[i], freq < shad_freq_upper[i]) index = np.where(idx) if len(index[0]) == 0: @@ -238,7 +262,11 @@ def fft_shading_test_process(time, data, shad_freq_lower=None, # Calculates to the left/right of each peak peak_l = max(fftv[range(sind, index[0])]) peak_r = max(fftv[range(index[-1], eind)]) - ratio.append(peak / np.mean([peak_l, peak_r])) + mean_value = np.mean([peak_l, peak_r]) + if mean_value == 0.0: + ratio.append(np.nan) + else: + ratio.append(peak / mean_value) # Checks ratios against thresholds for each freq range shading = 0 diff --git a/act/qc/sp2.py b/act/qc/sp2.py new file mode 100644 index 0000000000..9a67123e32 --- /dev/null +++ b/act/qc/sp2.py @@ -0,0 +1,152 @@ +import warnings + +import numpy as np +import pandas as pd + +try: + import pysp2 + + PYSP2_AVAILABLE = True +except ImportError: + PYSP2_AVAILABLE = False + +if PYSP2_AVAILABLE: + + class SP2ParticleCriteria: + """ + This class stores the particle crtiteria for filtering out bad particles in the SP2. + In addition, this class stores the calibration statistics for the mass calculations. + + Parameters + ---------- + cal_file_name: str or None + Path to the SP2 calibration file. Set to None to use default values. + + Attributes + ---------- + ScatMaxPeakHt1: int + The maximum peak value for scattering channel 0. + ScatMinPeakHt1: int + The minimum peak value for scattering channel 0 + ScatMaxPeakHt2: int + The maximum peak value for scattering channel 4. + ScatMinPeakHt2: int + The minimum peak value for scattering channel 4 + ScatMinWidth: int + The minimum peak width for the scattering channels + ScatMaxWidth: int + The maximum peak width for the scattering channels + IncanMinPeakHt1: int + The minimum peak height for channel 1 + IncanMinPeakHt2: int + The minimum peak height for channel 5 + IncanMidWidth: int + The minimum width for the incandescence channels + IncanMaxWidth: int + The maximum width for the incandescence channels + IncanMinPeakPos: int + The minimum peak position for the incandescence channels. + IncanMaxPeakPos: int + The maximum peak position for the incandescence channels. + IncanMinPeakRatio: float + The minimum peak ch5/ch6 peak ratio. + IncanMaxPeakRatio: float + The maximum peak ch5/ch6 peak ratio. + c0Mass1, c1Mass1, c2Mass1: floats + Calibration mass coefficients for ch1 + c0Mass2, c1Mass2, c2Mass2: floats + Calibration mass coefficients for ch2 + c0Scat1, c1Scat1, c2Scat1: floats + Calibration scattering coefficients for ch0 + c0Scat2, c1Scat2, c2Scat2: floats + Calibration scattering coefficients for ch4 + densitySO4, BC: float + Density of SO4, BC + tempSTP, presSTP: float + Temperature [Kelvin] and pressure [hPa] at STP. + + """ + + def __init__(self, cal_file_name=None): + self.ScatMaxPeakHt1 = 60000 + self.ScatMinPeakHt1 = 250 + self.ScatMaxPeakHt2 = 60000 + self.ScatMinPeakHt2 = 250 + self.ScatMinWidth = 10 + self.ScatMaxWidth = 90 + self.ScatMinPeakPos = 20 + self.ScatMaxPeakPos = 90 + self.IncanMinPeakHt1 = 200 + self.IncanMinPeakHt2 = 200 + self.IncanMaxPeakHt1 = 60000 + self.IncanMaxPeakHt2 = 60000 + self.IncanMinWidth = 5 + self.IncanMaxWidth = np.inf + self.IncanMinPeakPos = 20 + self.IncanMaxPeakPos = 90 + self.IncanMinPeakRatio = 0.1 + self.IncanMaxPeakRatio = 25 + self.IncanMaxPeakOffset = 11 + self.c0Mass1 = 0 + self.c1Mass1 = 0.0001896 + self.c2Mass1 = 0 + self.c3Mass1 = 0 + self.c0Mass2 = 0 + self.c1Mass2 = 0.0016815 + self.c2Mass2 = 0 + self.c3Mass2 = 0 + self.c0Scat1 = 0 + self.c1Scat1 = 78.141 + self.c2Scat1 = 0 + self.c0Scat2 = 0 + self.c1Scat2 = 752.53 + self.c2Scat2 = 0 + self.densitySO4 = 1.8 + self.densityBC = 1.8 + self.TempSTP = 273.15 + self.PressSTP = 1013.25 + if cal_file_name is not None: + df = pd.read_csv(cal_file_name, sep='\t') + for i in range(len(df['CalName'].values)): + setattr(self, df['CalName'].values[i], df['CalValue'].values[i]) + del df + +else: + + class SP2ParticleCriteria: + def __init__(self): + warnings.warn( + 'Attempting to use SP2ParticleCriteria without' + 'PySP2 installed. SP2ParticleCriteria will' + 'not have any functionality besides this' + 'warning message.', RuntimeWarning + ) + + +def get_waveform_statistics(ds, config_file, parallel=False, num_records=None): + """ + Generates waveform statistics for each particle in the dataset + This will do the fitting for channel 0 only. + + Parameters + ---------- + ds : xarray.Dataset + Raw SP2 binary dataset + config_file: ConfigParser object + The configuration INI file path. + parallel: bool + If true, use dask to enable parallelism + num_records: int or None + Only process first num_records datapoints. Set to + None to process all records. + + Returns + ------- + wave_ds: xarray.Dataset + Dataset with gaussian fits + """ + if PYSP2_AVAILABLE: + config = pysp2.io.read_config(config_file) + return pysp2.util.gaussian_fit(ds, config, parallel, num_records) + else: + raise ModuleNotFoundError('PySP2 must be installed in order to process SP2 data.') diff --git a/act/retrievals/__init__.py b/act/retrievals/__init__.py index 7578c5bdbf..a1849d92c6 100644 --- a/act/retrievals/__init__.py +++ b/act/retrievals/__init__.py @@ -1,36 +1,30 @@ """ -=============================== -act.retrievals (act.retrievals) -=============================== +This module contains various retrievals for datasets. -.. currentmodule:: act.retrievals - -This module contains various retrievals for datsets. - -.. autosummary:: - :toctree: generated/ - - aeri2irt - calculate_dsh_from_dsdh_sdn - calculate_irradiance_stats - calculate_net_radiation - calculate_longwave_radiation - calculate_precipitable_water - calculate_stability_indicies - compute_winds_from_ppi - generic_sobel_cbh - sst_from_irt - sum_function_irt """ -from .stability_indices import calculate_stability_indicies -from .cbh import generic_sobel_cbh -from .pwv_calc import calculate_precipitable_water -from .doppler_lidar import compute_winds_from_ppi -from .aeri import aeri2irt -from .irt import sst_from_irt -from .irt import sum_function_irt -from .radiation import calculate_dsh_from_dsdh_sdn -from .radiation import calculate_irradiance_stats -from .radiation import calculate_net_radiation -from .radiation import calculate_longwave_radiation +import lazy_loader as lazy + +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=['aeri', 'cbh', 'doppler_lidar', 'irt', 'radiation', 'sonde', 'sp2'], + submod_attrs={ + 'aeri': ['aeri2irt'], + 'cbh': ['generic_sobel_cbh'], + 'doppler_lidar': ['compute_winds_from_ppi'], + 'irt': ['sst_from_irt', 'sum_function_irt'], + 'radiation': [ + 'calculate_dsh_from_dsdh_sdn', + 'calculate_irradiance_stats', + 'calculate_longwave_radiation', + 'calculate_net_radiation', + ], + 'sonde': [ + 'calculate_pbl_liu_liang', + 'calculate_precipitable_water', + 'calculate_stability_indicies', + 'calculate_pbl_heffter', + ], + 'sp2': ['calc_sp2_diams_masses', 'process_sp2_psds'], + }, +) diff --git a/act/retrievals/aeri.py b/act/retrievals/aeri.py index 2768daf441..68a7e1c572 100644 --- a/act/retrievals/aeri.py +++ b/act/retrievals/aeri.py @@ -1,18 +1,24 @@ """ -act.retrievals.aeri ------------------- - -Modules for converting aeri radiance to ir temp +Functions for aeri retrievals. """ import numpy as np from scipy.optimize import brentq + from act.retrievals.irt import irt_response_function, sum_function_irt -def aeri2irt(aeri_ds, wnum_name='wnum', rad_name='mean_rad', hatch_name='hatchOpen', - tolerance=0.1, temp_low=150.0, temp_high=320.0, maxiter=200): +def aeri2irt( + aeri_ds, + wnum_name='wnum', + rad_name='mean_rad', + hatch_name='hatchOpen', + tolerance=0.1, + temp_low=150.0, + temp_high=320.0, + maxiter=200, +): """ This function will integrate over the correct wavenumber values to produce the effective IRT temperature. @@ -35,8 +41,8 @@ def aeri2irt(aeri_ds, wnum_name='wnum', rad_name='mean_rad', hatch_name='hatchOp Parameters ---------- - aeri_ds : Xarray Dataset Object - The Dataset object containing AERI data. + aeri_ds : xarray.Dataset + The xarray dataset containing AERI data. wnum_name : str The variable name for coordinate dimention of wave number Xarray Dataset. hatch_name : str or None @@ -56,7 +62,7 @@ def aeri2irt(aeri_ds, wnum_name='wnum', rad_name='mean_rad', hatch_name='hatchOp Returns ------- - obj : Xarray Dataset Object or None + ds : xarray.Dataset or None The aeri_ds Dataset with new DataArray of temperatures added under variable name 'aeri_irt_equiv_temperature'. @@ -115,15 +121,22 @@ def aeri2irt(aeri_ds, wnum_name='wnum', rad_name='mean_rad', hatch_name='hatchOp continue else: try: - aeri_irt_vals[ii] = brentq(sum_function_irt, temp_low, temp_high, - args=(mean_rad[ii], ), xtol=tolerance, maxiter=maxiter) + aeri_irt_vals[ii] = brentq( + sum_function_irt, + temp_low, + temp_high, + args=(mean_rad[ii],), + xtol=tolerance, + maxiter=maxiter, + ) except ValueError: pass # Add new values to Xarray Dataset aeri_ds['aeri_irt_equiv_temperature'] = ( - 'time', aeri_irt_vals, - {'long_name': 'Derived IRT equivalent temperatrues from AERI', - 'units': 'K'}) + 'time', + aeri_irt_vals, + {'long_name': 'Derived IRT equivalent temperatrues from AERI', 'units': 'K'}, + ) return aeri_ds diff --git a/act/retrievals/cbh.py b/act/retrievals/cbh.py index fbd3444711..dd7aa0c04f 100644 --- a/act/retrievals/cbh.py +++ b/act/retrievals/cbh.py @@ -1,8 +1,5 @@ """ -act.retrievals.cbh ------------------- - -Module that calculates cloud base heights in various ways. +Functions for calculated cloud base height that are instrument agnostic. """ @@ -11,9 +8,16 @@ from scipy import ndimage -def generic_sobel_cbh(obj, variable=None, height_dim=None, - var_thresh=None, fill_na=None, - return_thresh=False): +def generic_sobel_cbh( + ds, + variable=None, + height_dim=None, + var_thresh=None, + fill_na=None, + return_thresh=False, + filter_type='uniform', + edge_thresh=5., +): """ Function for calculating cloud base height from lidar/radar data using a basic sobel filter and thresholding. Note, this was not @@ -21,10 +25,13 @@ def generic_sobel_cbh(obj, variable=None, height_dim=None, that there have been similar methods employed to detect boundary layer heights. + NOTE: The returned variable now appends the field name of the + data used to generate the CBH as part of the variable name. cbh_sobel_[varname] + Parameters ---------- - obj : ACT Object - ACT object where data are stored. + ds : ACT xarray.Dataset + ACT xarray dataset where data are stored. variable : string Variable on which to process. height_dim : string @@ -32,12 +39,19 @@ def generic_sobel_cbh(obj, variable=None, height_dim=None, var_thresh : float Thresholding for variable if needed. fill_na : float - What to fill nans with in DataArray if any. + Value to fill nans with in DataArray if any. + filter_type : string + Currently the only option is for uniform filtering. + uniform: Apply uniform filtering after the sobel filter? Applies a standard area of 3x3 filtering + None: Excludes the filtering + edge_thresh : float + Threshold value for finding the edge after the sobel filtering. + If the signal is not strong, this may need to be lowered Returns ------- - new_obj : ACT Object - ACT Object with cbh values included as variable. + new_ds : ACT xarray.Dataset + ACT xarray dataset with cbh values included as variable. Examples -------- @@ -46,20 +60,29 @@ def generic_sobel_cbh(obj, variable=None, height_dim=None, .. code-block:: python - kazr = act.retrievals.cbh.generic_sobel_cbh(kazr,variable='reflectivity_copol', - height_dim='range', var_thresh=-10.) + kazr = act.retrievals.cbh.generic_sobel_cbh( + kazr, variable="reflectivity_copol", height_dim="range", var_thresh=-10.0 + ) mpl = act.corrections.mpl.correct_mpl(mpl) - mpl.range_bins.values = mpl.height.values[0,:]*1000. - mpl.range_bins.attrs['units'] = 'm' - mpl['signal_return_co_pol'].values[:,0:10] = 0. - mpl = act.retrievals.cbh.generic_sobel_cbh(mpl,variable='signal_return_co_pol', - height_dim='range_bins',var_thresh=10., - fill_na=0.) - - ceil = act.retrievals.cbh.generic_sobel_cbh(ceil,variable='backscatter', - height_dim='range', var_thresh=1000., - fill_na=0) + mpl.range_bins.values = mpl.height.values[0, :] * 1000.0 + mpl.range_bins.attrs["units"] = "m" + mpl["signal_return_co_pol"].values[:, 0:10] = 0.0 + mpl = act.retrievals.cbh.generic_sobel_cbh( + mpl, + variable="signal_return_co_pol", + height_dim="range_bins", + var_thresh=10.0, + fill_na=0.0, + ) + + ceil = act.retrievals.cbh.generic_sobel_cbh( + ceil, + variable="backscatter", + height_dim="range", + var_thresh=1000.0, + fill_na=0, + ) """ if variable is None: @@ -68,42 +91,46 @@ def generic_sobel_cbh(obj, variable=None, height_dim=None, fill_na = var_thresh # Pull data into Standalone DataArray - data = obj[variable] + da = ds[variable] # Apply thresholds if set if var_thresh is not None: - data = data.where(data.values > var_thresh) + da = da.where(da.values > var_thresh) # Fill with fill_na values - data = data.fillna(fill_na) + da = da.fillna(fill_na) # If return_thresh is True, replace variable data with # thresholded data if return_thresh is True: - obj[variable].values = data.values + ds[variable].values = da.values # Apply Sobel filter to data and smooth the results - data = data.values + data = da.values.tolist() edge = ndimage.sobel(data) - edge = ndimage.uniform_filter(edge, size=3, mode='nearest') + if filter_type == 'uniform': + edge = ndimage.uniform_filter(edge, size=3, mode='nearest') # Create Data Array - edge_obj = xr.DataArray(edge, dims=obj[variable].dims) + edge_da = xr.DataArray(edge, dims=ds[variable].dims) # Filter some of the resulting edge data to get defined edges - edge_obj = edge_obj.where(edge_obj > 5.) - edge_obj = edge_obj.fillna(fill_na) + edge_da = edge_da.where(edge_da > edge_thresh) + edge_da = edge_da.fillna(fill_na) # Do a diff along the height dimension to define edge - diff = edge_obj.diff(dim=1) + diff = edge_da.diff(dim=1).values # Get height variable to use for cbh - height = obj[height_dim].values + height = ds[height_dim].values # Run through times and find the height cbh = [] for i in range(np.shape(diff)[0]): - index = np.where(diff[i, :] > 5.)[0] + try: + index = np.where(diff[i, :] > edge_thresh)[0] + except ValueError(): + index = [] if len(np.shape(height)) > 1: ht = height[i, :] else: @@ -114,11 +141,13 @@ def generic_sobel_cbh(obj, variable=None, height_dim=None, else: cbh.append(np.nan) - # Create DataArray to add to Object - da = xr.DataArray(cbh, dims=['time'], coords=[obj['time'].values]) - obj['cbh_sobel'] = da - obj['cbh_sobel'].attrs['long_name'] = ' '.join(['CBH calculated from', - variable, 'using sobel filter']) - obj['cbh_sobel'].attrs['units'] = obj[height_dim].attrs['units'] + # Create DataArray to add to the dataset + var_name = 'cbh_sobel_' + variable + da = xr.DataArray(cbh, dims=['time'], coords=[ds['time'].values]) + ds[var_name] = da + ds[var_name].attrs['long_name'] = ' '.join( + ['CBH calculated from', variable, 'using sobel filter'] + ) + ds[var_name].attrs['units'] = ds[height_dim].attrs['units'] - return obj + return ds diff --git a/act/retrievals/doppler_lidar.py b/act/retrievals/doppler_lidar.py index d3b669d128..0e5dd85154 100644 --- a/act/retrievals/doppler_lidar.py +++ b/act/retrievals/doppler_lidar.py @@ -1,17 +1,25 @@ -""" Retrieval Functions for doppler lidar. """ +""" +Functions for doppler lidar specific retrievals -import numpy as np +""" import warnings +import dask +import numpy as np import xarray as xr -def compute_winds_from_ppi(obj, elevation_name='elevation', - azimuth_name='azimuth', - radial_velocity_name='radial_velocity', - snr_name='signal_to_noise_ratio', - intensity_name=None, - snr_threshold=0.008, remove_all_missing=False, - condition_limit=1.0e4, return_obj=None): +def compute_winds_from_ppi( + ds, + elevation_name='elevation', + azimuth_name='azimuth', + radial_velocity_name='radial_velocity', + snr_name='signal_to_noise_ratio', + intensity_name=None, + snr_threshold=0.008, + remove_all_missing=False, + condition_limit=1.0e4, + return_ds=None, +): """ This function will convert a Doppler Lidar PPI scan into vertical distribution of horizontal wind direction and speed. @@ -21,37 +29,37 @@ def compute_winds_from_ppi(obj, elevation_name='elevation', Parameters ---------- - obj : Xarray Dataset Object - The Dataset object containing PPI scan to be converte into winds. + ds : xarray.Dataset + The xarray dataset containing PPI scan to be converte into winds. elevation_name : str - The name of the elevation variable in the Dataset object. + The name of the elevation variable in the dataset. azimuth_name : str - The name of the azimuth variable in the Dataset object. + The name of the azimuth variable in the dataset. radial_velocity_name : str - The name of the radial velocity variable in the Dataset object. + The name of the radial velocity variable in the dataset. snr_name : str - The name of the signal to noise variable in the Dataset object. + The name of the signal to noise variable in the dataset. intensity_name : str - The name of the intensity variable in the Dataset object. If this + The name of the intensity variable in the dataset. If this is set will use intensity instead of signal to noise ratio. variable. snr_threshold : float The signal to noise lower threshold used to decide which values to use. remove_all_missing : boolean - Option to not add a time step in the returned object where all values + Option to not add a time step in the returned dataset where all values are set to NaN condition_limit : float Upper limit used with Normalized data to check if data should be converted from scan signal to noise ration to wind speeds and directions. - return_obj : None or Xarray Dataset Object - If set to a Xarray Dataset Object the calculated winds object will - be concatinated onto this object. This is to allow looping over - this function for many scans and returning a single object. + return_ds : None or xarray.Dataset + If set to a Xarray Dataset the calculated winds dataset will + be concatinated onto this dataset. This is to allow looping over + this function for many scans and returning a single dataset. Returns ------- - obj : Xarray Dataset Object or None + ds : xarray.Dataset or None The winds converted from PPI scan to horizontal wind speeds and wind directions along with wind speed error and wind direction error. If there is a problem determining the breaks between PPI scans, will @@ -65,174 +73,241 @@ def compute_winds_from_ppi(obj, elevation_name='elevation', Techniques Discussions 2016, 10, 1-30 """ - azimuth = obj[azimuth_name].values + + new_ds = None + azimuth = ds[azimuth_name].values azimuth_rounded = np.round(azimuth).astype(int) # Determine where the azimuth scans repeate to get range for each PPI index = np.where(azimuth_rounded == azimuth_rounded[0])[0] if index.size == 0: - print('\nERROR: Having trouble determining the PPI scan breaks ' - 'in compute_winds_from_ppi().\n') - return return_obj + print( + '\nERROR: Having trouble determining the PPI scan breaks ' + 'in compute_winds_from_ppi().\n' + ) + return return_ds if index.size == 1: num_scans = azimuth.size else: num_scans = index[1] - index[0] + elevation = np.radians(ds[elevation_name].values) + azimuth = np.radians(ds[azimuth_name].values) + doppler = ds[radial_velocity_name].values + if intensity_name is not None: + intensity = ds[intensity_name].values + snr = intensity - 1 + del intensity + var_name = intensity_name + else: + try: + snr = ds[snr_name].values + except KeyError: + intensity = ds['intensity'].values + snr = intensity - 1 + del intensity + var_name = 'intensity' + + height_name = list(set(ds[var_name].dims) - {'time'})[0] + rng = ds[height_name].values + try: + height_units = ds[height_name].attrs['units'] + except KeyError: + if rng[0] > 0: + height_units = 'm' + else: + height_units = 'km' + time = ds['time'].values + # Loop over each PPI scan + task = [] for start_index in index: scan_index = range(start_index, start_index + num_scans) # Since this can run while instrument is making measurements # the number of PPI scans may not match exactly. This will # adjust the number of scans in case there is an issue. - if scan_index[-1] > obj[elevation_name].values.size: - scan_index = range(start_index, obj[elevation_name].values.size) - - elevation = np.radians(obj[elevation_name].values[scan_index]) - azimuth = np.radians(obj[azimuth_name].values[scan_index]) - doppler = obj[radial_velocity_name].values[scan_index] - if intensity_name is not None: - intensity = obj[intensity_name].values[scan_index, :] - snr = intensity - 1 - del intensity - snr_name = intensity_name - else: - try: - snr = obj[snr_name].values[scan_index, :] - except KeyError: - intensity = obj['intensity'].values[scan_index, :] - snr = intensity - 1 - del intensity - snr_name = 'intensity' - - height_name = list(set(obj[snr_name].dims) - set(['time']))[0] - rng = obj[height_name].values - try: - height_units = obj[height_name].attrs['units'] - except KeyError: - if rng[0] > 0: - height_units = 'm' - else: - height_units = 'km' - time = obj['time'].values[scan_index] - - height = rng * np.median(np.sin(elevation)) - xhat = np.sin(azimuth) * np.cos(elevation) - yhat = np.cos(azimuth) * np.cos(elevation) - zhat = np.sin(elevation) - - dims = snr.shape - - # mean_snr = np.nanmean(snr, axis=1) - u_wind = np.full(dims[1], np.nan) - v_wind = np.full(dims[1], np.nan) - w_wind = np.full(dims[1], np.nan) - u_err = np.full(dims[1], np.nan) - v_err = np.full(dims[1], np.nan) - w_err = np.full(dims[1], np.nan) - residual = np.full(dims[1], np.nan) - chisq = np.full(dims[1], np.nan) - corr = np.full(dims[1], np.nan) - - # Loop over each level - for ii in range(dims[1]): - ur1 = doppler[:, ii] - snr1 = snr[:, ii] - with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - index = np.where((snr1 >= snr_threshold) & np.isfinite(ur1))[0] - count = index.size - if count >= 4: - ur1 = ur1[index] - xhat1 = xhat[index] - yhat1 = yhat[index] - zhat1 = zhat[index] - - a = np.full((3, 3), np.nan) - b = np.full(3, np.nan) - - a[0, 0] = np.sum(xhat1**2) - a[1, 0] = np.sum(xhat1 * yhat1) - a[2, 0] = np.sum(xhat1 * zhat1) - - a[0, 1] = a[1, 0] - a[1, 1] = np.sum(yhat1**2) - a[2, 1] = np.sum(yhat1 * zhat1) - - a[0, 2] = a[2, 0] - a[1, 2] = a[2, 1] - a[2, 2] = np.sum(zhat1**2) - - b[0] = np.sum(ur1 * xhat1) - b[1] = np.sum(ur1 * yhat1) - b[2] = np.sum(ur1 * zhat1) - - ainv = np.linalg.inv(a) - condition = np.linalg.norm(a) * np.linalg.norm(ainv) # Condition Number ? - if condition < condition_limit: - c = b @ ainv - u_wind[ii] = c[0] - v_wind[ii] = c[1] - w_wind[ii] = c[2] - ur_fit = xhat1 * u_wind[ii] + yhat1 * v_wind[ii] + zhat1 * w_wind[ii] - chisq[ii] = np.sum((ur_fit - ur1)**2) - residual[ii] = np.sqrt(chisq[ii] / count) - with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - corr[ii] = np.corrcoef(ur_fit, ur1)[0, 1] - u_err[ii] = np.sqrt((chisq[ii] / (count - 3)) * ainv[0, 0]) - v_err[ii] = np.sqrt((chisq[ii] / (count - 3)) * ainv[1, 1]) - w_err[ii] = np.sqrt((chisq[ii] / (count - 3)) * ainv[2, 2]) - - # Compute windspeed and direction - with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - wspd = np.sqrt(u_wind**2 + v_wind**2) - wdir = np.degrees(np.arctan2(u_wind, v_wind) + np.pi) - - wspd_err = np.sqrt((u_wind * u_err)**2 + (v_wind * v_err)**2) / wspd - wdir_err = np.degrees(np.sqrt((u_wind * v_err)**2 + (v_wind * u_err)**2) / wspd**2) - - if remove_all_missing and np.isnan(wspd).all(): - continue - - time = time[0] + (time[-1] - time[0]) / 2 - time = time.reshape(1,) - wspd = wspd.reshape(1, rng.size) - wdir = wdir.reshape(1, rng.size) - wspd_err = wspd_err.reshape(1, rng.size) - wdir_err = wdir_err.reshape(1, rng.size) - corr = corr.reshape(1, rng.size) - residual = residual.reshape(1, rng.size) + if scan_index[-1] > np.size(elevation): + scan_index = range(start_index, np.size(elevation)) + + task.append( + dask.delayed(process_ppi_winds)( + time[scan_index], elevation[scan_index], azimuth[scan_index], snr[scan_index, :], + doppler[scan_index, :], rng, condition_limit, snr_threshold, remove_all_missing, + height_units + ) + ) + + results = dask.compute(*task) + is_Dataset = [isinstance(ii, xr.core.dataset.Dataset) for ii in results] + if any(is_Dataset): + results = [results[ii] for ii, value in enumerate(is_Dataset) if value is True] + new_ds = xr.concat(results, 'time') + + if isinstance(return_ds, xr.core.dataset.Dataset) and isinstance(new_ds, xr.core.dataset.Dataset): + return_ds = xr.concat([return_ds, new_ds], dim='time') + else: + return_ds = new_ds + + return return_ds + + +def process_ppi_winds(time, elevation, azimuth, snr, doppler, rng, condition_limit, + snr_threshold, remove_all_missing, height_units): + """ + This function is for processing the winds using dask from the compute_winds_from_ppi + function. This should not be used standalone. + + """ + + height = rng * np.median(np.sin(elevation)) + xhat = np.sin(azimuth) * np.cos(elevation) + yhat = np.cos(azimuth) * np.cos(elevation) + zhat = np.sin(elevation) + + dims = np.shape(snr) + + # mean_snr = np.nanmean(snr, axis=1) + u_wind = np.full(dims[1], np.nan) + v_wind = np.full(dims[1], np.nan) + w_wind = np.full(dims[1], np.nan) + u_err = np.full(dims[1], np.nan) + v_err = np.full(dims[1], np.nan) + w_err = np.full(dims[1], np.nan) + residual = np.full(dims[1], np.nan) + chisq = np.full(dims[1], np.nan) + corr = np.full(dims[1], np.nan) + + # Loop over each level + for ii in range(dims[1]): + ur1 = doppler[:, ii] + snr1 = snr[:, ii] with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) - snr_mean = np.nanmean(snr, axis=0) - snr_mean = snr_mean.reshape(1, rng.size) - new_object = xr.Dataset( - {'wind_speed': (('time', 'height'), wspd, {'long_name': 'Wind speed', 'units': 'm/s'}), - 'wind_direction': (('time', 'height'), wdir, - {'long_name': 'Wind direction', 'units': 'degree'}), - 'wind_speed_error': (('time', 'height'), wspd_err, - {'long_name': 'Wind direction error', 'units': 'm/s'}), - 'wind_direction_error': (('time', 'height'), wdir_err, - {'long_name': 'Wind direction error', 'units': 'degree'}), - 'signal_to_noise_ratio': (('time', 'height'), snr_mean, - {'long_name': 'Signal to noise ratio mean over PPI scan', - 'units': '1'}), - 'residual': (('time', 'height'), residual, - {'long_name': 'Residual values (Square Root of Chi Square)', - 'units': 'm/s'}), - 'correlation': (('time', 'height'), corr, - {'long_name': 'Correlation coefficient', 'units': '1'})}, - {'time': ('time', time, {'long_name': 'Time in UTC'}), - 'height': ('height', height, {'long_name': 'Height to center of bin', - 'units': height_units})}, + warnings.filterwarnings('ignore', category=RuntimeWarning) + index = np.where((snr1 >= snr_threshold) & np.isfinite(ur1))[0] + count = index.size + if count >= 4: + ur1 = ur1[index] + xhat1 = xhat[index] + yhat1 = yhat[index] + zhat1 = zhat[index] + + a = np.full((3, 3), np.nan) + b = np.full(3, np.nan) + + a[0, 0] = np.sum(xhat1**2) + a[1, 0] = np.sum(xhat1 * yhat1) + a[2, 0] = np.sum(xhat1 * zhat1) + + a[0, 1] = a[1, 0] + a[1, 1] = np.sum(yhat1**2) + a[2, 1] = np.sum(yhat1 * zhat1) + + a[0, 2] = a[2, 0] + a[1, 2] = a[2, 1] + a[2, 2] = np.sum(zhat1**2) + + b[0] = np.sum(ur1 * xhat1) + b[1] = np.sum(ur1 * yhat1) + b[2] = np.sum(ur1 * zhat1) + + ainv = np.linalg.inv(a) + condition = np.linalg.norm(a) * np.linalg.norm(ainv) # Condition Number ? + if condition < condition_limit: + c = b @ ainv + u_wind[ii] = c[0] + v_wind[ii] = c[1] + w_wind[ii] = c[2] + ur_fit = xhat1 * u_wind[ii] + yhat1 * v_wind[ii] + zhat1 * w_wind[ii] + chisq[ii] = np.sum((ur_fit - ur1) ** 2) + residual[ii] = np.sqrt(chisq[ii] / count) + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + corr[ii] = np.corrcoef(ur_fit, ur1)[0, 1] + u_err[ii] = np.sqrt((chisq[ii] / (count - 3)) * ainv[0, 0]) + v_err[ii] = np.sqrt((chisq[ii] / (count - 3)) * ainv[1, 1]) + w_err[ii] = np.sqrt((chisq[ii] / (count - 3)) * ainv[2, 2]) + + # Compute windspeed and direction + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + wspd = np.sqrt(u_wind**2 + v_wind**2) + wdir = np.degrees(np.arctan2(u_wind, v_wind) + np.pi) + + wspd_err = np.sqrt((u_wind * u_err) ** 2 + (v_wind * v_err) ** 2) / wspd + wdir_err = np.degrees( + np.sqrt((u_wind * v_err) ** 2 + (v_wind * u_err) ** 2) / wspd**2 ) - if isinstance(return_obj, xr.core.dataset.Dataset): - return_obj = xr.concat([return_obj, new_object], dim='time') - else: - return_obj = new_object + if remove_all_missing and np.isnan(wspd).all(): + return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan + + time = time[0] + (time[-1] - time[0]) / 2 + time = time.reshape( + 1, + ) + wspd = wspd.reshape(1, rng.size) + wdir = wdir.reshape(1, rng.size) + wspd_err = wspd_err.reshape(1, rng.size) + wdir_err = wdir_err.reshape(1, rng.size) + corr = corr.reshape(1, rng.size) + residual = residual.reshape(1, rng.size) + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + snr_mean = np.nanmean(snr, axis=0) + snr_mean = snr_mean.reshape(1, rng.size) - return return_obj + new_ds = xr.Dataset( + { + 'wind_speed': ( + ('time', 'height'), + wspd, + {'long_name': 'Wind speed', 'units': 'm/s'}, + ), + 'wind_direction': ( + ('time', 'height'), + wdir, + {'long_name': 'Wind direction', 'units': 'degree'}, + ), + 'wind_speed_error': ( + ('time', 'height'), + wspd_err, + {'long_name': 'Wind direction error', 'units': 'm/s'}, + ), + 'wind_direction_error': ( + ('time', 'height'), + wdir_err, + {'long_name': 'Wind direction error', 'units': 'degree'}, + ), + 'signal_to_noise_ratio': ( + ('time', 'height'), + snr_mean, + { + 'long_name': 'Signal to noise ratio mean over PPI scan', + 'units': '1', + }, + ), + 'residual': ( + ('time', 'height'), + residual, + { + 'long_name': 'Residual values (Square Root of Chi Square)', + 'units': 'm/s', + }, + ), + 'correlation': ( + ('time', 'height'), + corr, + {'long_name': 'Correlation coefficient', 'units': '1'}, + ), + }, + { + 'time': ('time', time, {'long_name': 'Time in UTC'}), + 'height': ( + 'height', + height, + {'long_name': 'Height to center of bin', 'units': height_units}, + ), + }, + ) + return new_ds diff --git a/act/retrievals/irt.py b/act/retrievals/irt.py index 5de6404e3c..55468e55be 100644 --- a/act/retrievals/irt.py +++ b/act/retrievals/irt.py @@ -1,15 +1,13 @@ """ -act.retrievals.irt ------------------- - -Modules for converting irt temperatures and radiances +Functions for IRT retrievals and calculations. """ import dask -import xarray as xr import numpy as np +import xarray as xr from scipy.optimize import brentq + from act.utils.radiance_utils import planck_converter @@ -26,127 +24,918 @@ def irt_response_function(): """ # Fill response function values. First wavenumbers then response fraction. --; wnum = np.array( - [847.133, 847.615, 848.097, 848.579, 849.061, 849.543, 850.026, 850.508, - 850.990, 851.472, 851.954, 852.436, 852.918, 853.401, 853.883, 854.365, 854.847, - 855.329, 855.811, 856.293, 856.776, 857.258, 857.740, 858.222, 858.704, 859.186, - 859.668, 860.151, 860.633, 861.115, 861.597, 862.079, 862.561, 863.043, 863.526, - 864.008, 864.490, 864.972, 865.454, 865.936, 866.419, 866.901, 867.383, 867.865, - 868.347, 868.829, 869.311, 869.794, 870.276, 870.758, 871.240, 871.722, 872.204, - 872.686, 873.169, 873.651, 874.133, 874.615, 875.097, 875.579, 876.061, 876.544, - 877.026, 877.508, 877.990, 878.472, 878.954, 879.437, 879.919, 880.401, 880.883, - 881.365, 881.847, 882.329, 882.812, 883.294, 883.776, 884.258, 884.740, 885.222, - 885.704, 886.187, 886.669, 887.151, 887.633, 888.115, 888.597, 889.079, 889.562, - 890.044, 890.526, 891.008, 891.490, 891.972, 892.454, 892.937, 893.419, 893.901, - 894.383, 894.865, 895.347, 895.829, 896.312, 896.794, 897.276, 897.758, 898.240, - 898.722, 899.205, 899.687, 900.169, 900.651, 901.133, 901.615, 902.097, 902.580, - 903.062, 903.544, 904.026, 904.508, 904.990, 905.472, 905.955, 906.437, 906.919, - 907.401, 907.883, 908.365, 908.847, 909.330, 909.812, 910.294, 910.776, 911.258, - 911.740, 912.223, 912.705, 913.187, 913.669, 914.151, 914.633, 915.115, 915.598, - 916.080, 916.562, 917.044, 917.526, 918.008, 918.490, 918.973, 919.455, 919.937, - 920.419, 920.901, 921.383, 921.865, 922.348, 922.830, 923.312, 923.794, 924.276, - 924.758, 925.240, 925.723, 926.205, 926.687, 927.169, 927.651, 928.133, 928.615, - 929.098, 929.580, 930.062, 930.544, 931.026, 931.508, 931.991, 932.473, 932.955, - 933.437, 933.919, 934.401, 934.883, 935.366, 935.848, 936.330, 936.812, 937.294, - 937.776, 938.258, 938.741, 939.223, 939.705, 940.187, 940.669, 941.151, 941.633, - 942.116, 942.598, 943.080, 943.562, 944.044, 944.526, 945.009, 945.491, 945.973, - 946.455, 946.937, 947.419, 947.901, 948.384, 948.866, 949.348, 949.830, 950.312, - 950.794, 951.276, 951.759, 952.241, 952.723, 953.205, 953.687, 954.169, 954.651, - 955.134, 955.616, 956.098, 956.580, 957.062, 957.544, 958.026, 958.509, 958.991, - 959.473, 959.955, 960.437, 960.919, 961.401, 961.884, 962.366, 962.848, 963.330, - 963.812, 964.294, 964.777, 965.259, 965.741, 966.223, 966.705, 967.187, 967.669, - 968.152, 968.634, 969.116, 969.598, 970.080, 970.562, 971.044, 971.527, 972.009, - 972.491, 972.973, 973.455, 973.937, 974.419, 974.902, 975.384, 975.866, 976.348, - 976.830, 977.312, 977.795, 978.277, 978.759, 979.241, 979.723, 980.205, 980.687, - 981.170, 981.652, 982.134, 982.616, 983.098, 983.580, 984.062, 984.545, 985.027, - 985.509, 985.991, 986.473, 986.955, 987.438, 987.920, 988.402, 988.884, 989.366, - 989.848, 990.330, 990.812, 991.295, 991.777, 992.259, 992.741, 993.223, 993.705, - 994.188, 994.670, 995.152, 995.634, 996.116, 996.598, 997.080, 997.563, 998.045, - 998.527, 999.009, 999.491, 999.973, 1000.455, 1000.938, 1001.420, 1001.902, 1002.384, - 1002.866, 1003.348, 1003.830, 1004.313, 1004.795, 1005.277, 1005.759, 1006.241, - 1006.720, 1007.210, 1007.690, 1008.170, 1008.650, 1009.130, 1009.620, 1010.100, - 1010.580, 1011.060, 1011.540, 1012.030, 1012.510, 1012.990, 1013.470, 1013.960, - 1014.440, 1014.920, 1015.400, 1015.880, 1016.370, 1016.850, 1017.330, 1017.810, - 1018.290, 1018.780, 1019.260, 1019.740, 1020.220, 1020.710, 1021.190, 1021.670, - 1022.150, 1022.630, 1023.120, 1023.600, 1024.080, 1024.560, 1025.040, 1025.530, - 1026.010, 1026.490, 1026.970, 1027.460, 1027.940, 1028.420, 1028.900, 1029.380, - 1029.870, 1030.350, 1030.830, 1031.310, 1031.800, 1032.280, 1032.760, 1033.240, - 1033.720, 1034.210, 1034.690, 1035.170, 1035.650, 1036.130, 1036.620, 1037.100, - 1037.580, 1038.060, 1038.550, 1039.030, 1039.510, 1039.990, 1040.470, 1040.960, - 1041.440, 1041.920, 1042.400, 1042.880, 1043.370, 1043.850, 1044.330, 1044.810, - 1045.300, 1045.780, 1046.260, 1046.740, 1047.220, 1047.710, 1048.190, 1048.670, - 1049.150, 1049.630, 1050.120, 1050.600, 1051.080, 1051.560, 1052.050, 1052.530, - 1053.010, 1053.490, 1053.970, 1054.460, 1054.940, 1055.420, 1055.900, 1056.380, - 1056.870, 1057.350, 1057.830, 1058.310, 1058.800, 1059.280, 1059.760, 1060.240, - 1060.720, 1061.210, 1061.690, 1062.170, 1062.650, 1063.130, 1063.620, 1064.100], - dtype=np.float32) + [ + 847.133, + 847.615, + 848.097, + 848.579, + 849.061, + 849.543, + 850.026, + 850.508, + 850.990, + 851.472, + 851.954, + 852.436, + 852.918, + 853.401, + 853.883, + 854.365, + 854.847, + 855.329, + 855.811, + 856.293, + 856.776, + 857.258, + 857.740, + 858.222, + 858.704, + 859.186, + 859.668, + 860.151, + 860.633, + 861.115, + 861.597, + 862.079, + 862.561, + 863.043, + 863.526, + 864.008, + 864.490, + 864.972, + 865.454, + 865.936, + 866.419, + 866.901, + 867.383, + 867.865, + 868.347, + 868.829, + 869.311, + 869.794, + 870.276, + 870.758, + 871.240, + 871.722, + 872.204, + 872.686, + 873.169, + 873.651, + 874.133, + 874.615, + 875.097, + 875.579, + 876.061, + 876.544, + 877.026, + 877.508, + 877.990, + 878.472, + 878.954, + 879.437, + 879.919, + 880.401, + 880.883, + 881.365, + 881.847, + 882.329, + 882.812, + 883.294, + 883.776, + 884.258, + 884.740, + 885.222, + 885.704, + 886.187, + 886.669, + 887.151, + 887.633, + 888.115, + 888.597, + 889.079, + 889.562, + 890.044, + 890.526, + 891.008, + 891.490, + 891.972, + 892.454, + 892.937, + 893.419, + 893.901, + 894.383, + 894.865, + 895.347, + 895.829, + 896.312, + 896.794, + 897.276, + 897.758, + 898.240, + 898.722, + 899.205, + 899.687, + 900.169, + 900.651, + 901.133, + 901.615, + 902.097, + 902.580, + 903.062, + 903.544, + 904.026, + 904.508, + 904.990, + 905.472, + 905.955, + 906.437, + 906.919, + 907.401, + 907.883, + 908.365, + 908.847, + 909.330, + 909.812, + 910.294, + 910.776, + 911.258, + 911.740, + 912.223, + 912.705, + 913.187, + 913.669, + 914.151, + 914.633, + 915.115, + 915.598, + 916.080, + 916.562, + 917.044, + 917.526, + 918.008, + 918.490, + 918.973, + 919.455, + 919.937, + 920.419, + 920.901, + 921.383, + 921.865, + 922.348, + 922.830, + 923.312, + 923.794, + 924.276, + 924.758, + 925.240, + 925.723, + 926.205, + 926.687, + 927.169, + 927.651, + 928.133, + 928.615, + 929.098, + 929.580, + 930.062, + 930.544, + 931.026, + 931.508, + 931.991, + 932.473, + 932.955, + 933.437, + 933.919, + 934.401, + 934.883, + 935.366, + 935.848, + 936.330, + 936.812, + 937.294, + 937.776, + 938.258, + 938.741, + 939.223, + 939.705, + 940.187, + 940.669, + 941.151, + 941.633, + 942.116, + 942.598, + 943.080, + 943.562, + 944.044, + 944.526, + 945.009, + 945.491, + 945.973, + 946.455, + 946.937, + 947.419, + 947.901, + 948.384, + 948.866, + 949.348, + 949.830, + 950.312, + 950.794, + 951.276, + 951.759, + 952.241, + 952.723, + 953.205, + 953.687, + 954.169, + 954.651, + 955.134, + 955.616, + 956.098, + 956.580, + 957.062, + 957.544, + 958.026, + 958.509, + 958.991, + 959.473, + 959.955, + 960.437, + 960.919, + 961.401, + 961.884, + 962.366, + 962.848, + 963.330, + 963.812, + 964.294, + 964.777, + 965.259, + 965.741, + 966.223, + 966.705, + 967.187, + 967.669, + 968.152, + 968.634, + 969.116, + 969.598, + 970.080, + 970.562, + 971.044, + 971.527, + 972.009, + 972.491, + 972.973, + 973.455, + 973.937, + 974.419, + 974.902, + 975.384, + 975.866, + 976.348, + 976.830, + 977.312, + 977.795, + 978.277, + 978.759, + 979.241, + 979.723, + 980.205, + 980.687, + 981.170, + 981.652, + 982.134, + 982.616, + 983.098, + 983.580, + 984.062, + 984.545, + 985.027, + 985.509, + 985.991, + 986.473, + 986.955, + 987.438, + 987.920, + 988.402, + 988.884, + 989.366, + 989.848, + 990.330, + 990.812, + 991.295, + 991.777, + 992.259, + 992.741, + 993.223, + 993.705, + 994.188, + 994.670, + 995.152, + 995.634, + 996.116, + 996.598, + 997.080, + 997.563, + 998.045, + 998.527, + 999.009, + 999.491, + 999.973, + 1000.455, + 1000.938, + 1001.420, + 1001.902, + 1002.384, + 1002.866, + 1003.348, + 1003.830, + 1004.313, + 1004.795, + 1005.277, + 1005.759, + 1006.241, + 1006.720, + 1007.210, + 1007.690, + 1008.170, + 1008.650, + 1009.130, + 1009.620, + 1010.100, + 1010.580, + 1011.060, + 1011.540, + 1012.030, + 1012.510, + 1012.990, + 1013.470, + 1013.960, + 1014.440, + 1014.920, + 1015.400, + 1015.880, + 1016.370, + 1016.850, + 1017.330, + 1017.810, + 1018.290, + 1018.780, + 1019.260, + 1019.740, + 1020.220, + 1020.710, + 1021.190, + 1021.670, + 1022.150, + 1022.630, + 1023.120, + 1023.600, + 1024.080, + 1024.560, + 1025.040, + 1025.530, + 1026.010, + 1026.490, + 1026.970, + 1027.460, + 1027.940, + 1028.420, + 1028.900, + 1029.380, + 1029.870, + 1030.350, + 1030.830, + 1031.310, + 1031.800, + 1032.280, + 1032.760, + 1033.240, + 1033.720, + 1034.210, + 1034.690, + 1035.170, + 1035.650, + 1036.130, + 1036.620, + 1037.100, + 1037.580, + 1038.060, + 1038.550, + 1039.030, + 1039.510, + 1039.990, + 1040.470, + 1040.960, + 1041.440, + 1041.920, + 1042.400, + 1042.880, + 1043.370, + 1043.850, + 1044.330, + 1044.810, + 1045.300, + 1045.780, + 1046.260, + 1046.740, + 1047.220, + 1047.710, + 1048.190, + 1048.670, + 1049.150, + 1049.630, + 1050.120, + 1050.600, + 1051.080, + 1051.560, + 1052.050, + 1052.530, + 1053.010, + 1053.490, + 1053.970, + 1054.460, + 1054.940, + 1055.420, + 1055.900, + 1056.380, + 1056.870, + 1057.350, + 1057.830, + 1058.310, + 1058.800, + 1059.280, + 1059.760, + 1060.240, + 1060.720, + 1061.210, + 1061.690, + 1062.170, + 1062.650, + 1063.130, + 1063.620, + 1064.100, + ], + dtype=np.float32, + ) rf = np.array( - [0.00000000, 0.00174289, 0.00710459, 0.01246630, 0.01782730, 0.02318830, - 0.02855000, 0.03391170, 0.03927280, 0.04463380, 0.04996460, 0.05523600, 0.06050680, - 0.06577760, 0.07104910, 0.07632050, 0.08159130, 0.08686210, 0.09213360, 0.09740500, - 0.10267600, 0.10794700, 0.11321800, 0.11849000, 0.12376000, 0.12903100, 0.13430300, - 0.13957400, 0.14582200, 0.16096000, 0.17610100, 0.19124100, 0.20638000, 0.22151900, - 0.23665900, 0.25180000, 0.26693800, 0.28207700, 0.29721700, 0.31235800, 0.32749600, - 0.34263500, 0.35777600, 0.37291600, 0.38805500, 0.40319300, 0.41833400, 0.43254500, - 0.44572400, 0.45890300, 0.47208400, 0.48526500, 0.49844400, 0.51162300, 0.52480400, - 0.53798400, 0.55116300, 0.56434300, 0.57752300, 0.59070400, 0.60388300, 0.61706200, - 0.63024300, 0.64342400, 0.65660300, 0.66978200, 0.67679500, 0.67641800, 0.67604100, - 0.67566500, 0.67528800, 0.67491100, 0.67453400, 0.67415800, 0.67378100, 0.67340400, - 0.67302800, 0.67265100, 0.67227400, 0.67189800, 0.67152100, 0.67114400, 0.67076700, - 0.67039100, 0.67001400, 0.66962700, 0.66894000, 0.66825200, 0.66756500, 0.66687800, - 0.66619000, 0.66550300, 0.66481600, 0.66412900, 0.66344100, 0.66275400, 0.66206700, - 0.66137900, 0.66069200, 0.66000500, 0.65931700, 0.65863000, 0.65794300, 0.65725500, - 0.65656800, 0.65601000, 0.65599700, 0.65598400, 0.65597200, 0.65595900, 0.65594700, - 0.65593400, 0.65592200, 0.65590900, 0.65589600, 0.65588400, 0.65587100, 0.65585900, - 0.65584600, 0.65583400, 0.65582100, 0.65580800, 0.65579600, 0.65578300, 0.65577100, - 0.65575800, 0.65619900, 0.65668200, 0.65716400, 0.65764600, 0.65812900, 0.65861100, - 0.65909300, 0.65957600, 0.66005800, 0.66054000, 0.66102300, 0.66150500, 0.66198700, - 0.66247000, 0.66295200, 0.66343400, 0.66391700, 0.66439900, 0.66488100, 0.66536400, - 0.66581700, 0.66615300, 0.66648900, 0.66682400, 0.66716000, 0.66749600, 0.66783200, - 0.66816700, 0.66850300, 0.66883900, 0.66917500, 0.66951000, 0.66984600, 0.67018200, - 0.67051800, 0.67085300, 0.67118900, 0.67152500, 0.67186100, 0.67219700, 0.67253200, - 0.67285600, 0.67236500, 0.67187500, 0.67138400, 0.67089400, 0.67040300, 0.66991300, - 0.66942200, 0.66893200, 0.66844100, 0.66795100, 0.66746000, 0.66697000, 0.66647900, - 0.66598900, 0.66549800, 0.66500800, 0.66451700, 0.66402700, 0.66353600, 0.66304600, - 0.66255500, 0.66200900, 0.66136400, 0.66071900, 0.66007400, 0.65942800, 0.65878300, - 0.65813800, 0.65749300, 0.65684700, 0.65620200, 0.65555700, 0.65491200, 0.65426600, - 0.65362100, 0.65297600, 0.65233100, 0.65168500, 0.65104000, 0.65039500, 0.64975000, - 0.64910400, 0.64845900, 0.64779500, 0.64705600, 0.64631700, 0.64557900, 0.64484000, - 0.64410100, 0.64336200, 0.64262400, 0.64188500, 0.64114600, 0.64040700, 0.63966900, - 0.63893000, 0.63819100, 0.63745200, 0.63671400, 0.63597500, 0.63523600, 0.63449700, - 0.63375800, 0.63302000, 0.63228100, 0.63154200, 0.63074100, 0.62988800, 0.62903400, - 0.62818100, 0.62732700, 0.62647400, 0.62562000, 0.62476700, 0.62391300, 0.62306000, - 0.62220600, 0.62135300, 0.62049900, 0.61964600, 0.61879300, 0.61793900, 0.61708600, - 0.61623200, 0.61537900, 0.61452500, 0.61367200, 0.61281800, 0.61196500, 0.61118100, - 0.61052400, 0.60986700, 0.60921100, 0.60855400, 0.60789700, 0.60724100, 0.60658400, - 0.60592700, 0.60527100, 0.60461400, 0.60395700, 0.60330100, 0.60264400, 0.60198700, - 0.60133000, 0.60067400, 0.60001700, 0.59936000, 0.59870400, 0.59804700, 0.59739000, - 0.59673400, 0.59607700, 0.59582900, 0.59583300, 0.59583700, 0.59584100, 0.59584500, - 0.59585000, 0.59585400, 0.59585800, 0.59586200, 0.59586600, 0.59587100, 0.59587500, - 0.59587900, 0.59588300, 0.59588700, 0.59589200, 0.59589600, 0.59590000, 0.59590400, - 0.59590800, 0.59591300, 0.59591700, 0.59592100, 0.59592500, 0.59547600, 0.59403900, - 0.59260100, 0.59116400, 0.58972700, 0.58828900, 0.58685200, 0.58541400, 0.58397700, - 0.58254000, 0.58110200, 0.57966500, 0.57822800, 0.57679000, 0.57535300, 0.57391500, - 0.57247800, 0.57104000, 0.56960300, 0.56816600, 0.56672800, 0.56529100, 0.56385300, - 0.56241600, 0.56097900, 0.55884500, 0.55577200, 0.55270000, 0.54962700, 0.54655400, - 0.54348100, 0.54040900, 0.53733600, 0.53426300, 0.53119000, 0.52811700, 0.52504500, - 0.52197200, 0.51889900, 0.51582600, 0.51275400, 0.50968100, 0.50660800, 0.50353500, - 0.50046300, 0.49739000, 0.49431700, 0.49124400, 0.48817200, 0.48509900, 0.48202600, - 0.47522600, 0.46813400, 0.46104100, 0.45394800, 0.44685600, 0.43976400, 0.43267100, - 0.42557800, 0.41848600, 0.41139400, 0.40430100, 0.39720800, 0.39011600, 0.38302300, - 0.37593000, 0.36883700, 0.36174400, 0.35465300, 0.34756000, 0.34046700, 0.33337600, - 0.32628300, 0.31919000, 0.31209700, 0.30500400, 0.29791300, 0.29130000, 0.28481200, - 0.27832500, 0.27183700, 0.26534900, 0.25886000, 0.25237200, 0.24588600, 0.23939700, - 0.23290900, 0.22642200, 0.21993400, 0.21344600, 0.20695800, 0.20047000, 0.19398300, - 0.18749500, 0.18100700, 0.17452000, 0.16803200, 0.16154300, 0.15505500, 0.14856700, - 0.14208000, 0.13559200, 0.12910400, 0.12268400, 0.11988200, 0.11708000, 0.11427900, - 0.11147700, 0.10867600, 0.10587400, 0.10307200, 0.10027100, 0.09746960, 0.09466790, - 0.09186620, 0.08906450, 0.08626350, 0.08346180, 0.08066010, 0.07785910, 0.07505740, - 0.07225560, 0.06945390, 0.06665220, 0.06385120, 0.06104950, 0.05824780, 0.05544680, - 0.05264510, 0.04984330, 0.04704160, 0.04397770, 0.04070670, 0.03743490, 0.03416300, - 0.03089200, 0.02762020, 0.02434830, 0.02107650, 0.01780460, 0.01453360, 0.01126180, - 0.00798992, 0.00471891, 0.00144707, 0.00000000], - dtype=np.float32) + [ + 0.00000000, + 0.00174289, + 0.00710459, + 0.01246630, + 0.01782730, + 0.02318830, + 0.02855000, + 0.03391170, + 0.03927280, + 0.04463380, + 0.04996460, + 0.05523600, + 0.06050680, + 0.06577760, + 0.07104910, + 0.07632050, + 0.08159130, + 0.08686210, + 0.09213360, + 0.09740500, + 0.10267600, + 0.10794700, + 0.11321800, + 0.11849000, + 0.12376000, + 0.12903100, + 0.13430300, + 0.13957400, + 0.14582200, + 0.16096000, + 0.17610100, + 0.19124100, + 0.20638000, + 0.22151900, + 0.23665900, + 0.25180000, + 0.26693800, + 0.28207700, + 0.29721700, + 0.31235800, + 0.32749600, + 0.34263500, + 0.35777600, + 0.37291600, + 0.38805500, + 0.40319300, + 0.41833400, + 0.43254500, + 0.44572400, + 0.45890300, + 0.47208400, + 0.48526500, + 0.49844400, + 0.51162300, + 0.52480400, + 0.53798400, + 0.55116300, + 0.56434300, + 0.57752300, + 0.59070400, + 0.60388300, + 0.61706200, + 0.63024300, + 0.64342400, + 0.65660300, + 0.66978200, + 0.67679500, + 0.67641800, + 0.67604100, + 0.67566500, + 0.67528800, + 0.67491100, + 0.67453400, + 0.67415800, + 0.67378100, + 0.67340400, + 0.67302800, + 0.67265100, + 0.67227400, + 0.67189800, + 0.67152100, + 0.67114400, + 0.67076700, + 0.67039100, + 0.67001400, + 0.66962700, + 0.66894000, + 0.66825200, + 0.66756500, + 0.66687800, + 0.66619000, + 0.66550300, + 0.66481600, + 0.66412900, + 0.66344100, + 0.66275400, + 0.66206700, + 0.66137900, + 0.66069200, + 0.66000500, + 0.65931700, + 0.65863000, + 0.65794300, + 0.65725500, + 0.65656800, + 0.65601000, + 0.65599700, + 0.65598400, + 0.65597200, + 0.65595900, + 0.65594700, + 0.65593400, + 0.65592200, + 0.65590900, + 0.65589600, + 0.65588400, + 0.65587100, + 0.65585900, + 0.65584600, + 0.65583400, + 0.65582100, + 0.65580800, + 0.65579600, + 0.65578300, + 0.65577100, + 0.65575800, + 0.65619900, + 0.65668200, + 0.65716400, + 0.65764600, + 0.65812900, + 0.65861100, + 0.65909300, + 0.65957600, + 0.66005800, + 0.66054000, + 0.66102300, + 0.66150500, + 0.66198700, + 0.66247000, + 0.66295200, + 0.66343400, + 0.66391700, + 0.66439900, + 0.66488100, + 0.66536400, + 0.66581700, + 0.66615300, + 0.66648900, + 0.66682400, + 0.66716000, + 0.66749600, + 0.66783200, + 0.66816700, + 0.66850300, + 0.66883900, + 0.66917500, + 0.66951000, + 0.66984600, + 0.67018200, + 0.67051800, + 0.67085300, + 0.67118900, + 0.67152500, + 0.67186100, + 0.67219700, + 0.67253200, + 0.67285600, + 0.67236500, + 0.67187500, + 0.67138400, + 0.67089400, + 0.67040300, + 0.66991300, + 0.66942200, + 0.66893200, + 0.66844100, + 0.66795100, + 0.66746000, + 0.66697000, + 0.66647900, + 0.66598900, + 0.66549800, + 0.66500800, + 0.66451700, + 0.66402700, + 0.66353600, + 0.66304600, + 0.66255500, + 0.66200900, + 0.66136400, + 0.66071900, + 0.66007400, + 0.65942800, + 0.65878300, + 0.65813800, + 0.65749300, + 0.65684700, + 0.65620200, + 0.65555700, + 0.65491200, + 0.65426600, + 0.65362100, + 0.65297600, + 0.65233100, + 0.65168500, + 0.65104000, + 0.65039500, + 0.64975000, + 0.64910400, + 0.64845900, + 0.64779500, + 0.64705600, + 0.64631700, + 0.64557900, + 0.64484000, + 0.64410100, + 0.64336200, + 0.64262400, + 0.64188500, + 0.64114600, + 0.64040700, + 0.63966900, + 0.63893000, + 0.63819100, + 0.63745200, + 0.63671400, + 0.63597500, + 0.63523600, + 0.63449700, + 0.63375800, + 0.63302000, + 0.63228100, + 0.63154200, + 0.63074100, + 0.62988800, + 0.62903400, + 0.62818100, + 0.62732700, + 0.62647400, + 0.62562000, + 0.62476700, + 0.62391300, + 0.62306000, + 0.62220600, + 0.62135300, + 0.62049900, + 0.61964600, + 0.61879300, + 0.61793900, + 0.61708600, + 0.61623200, + 0.61537900, + 0.61452500, + 0.61367200, + 0.61281800, + 0.61196500, + 0.61118100, + 0.61052400, + 0.60986700, + 0.60921100, + 0.60855400, + 0.60789700, + 0.60724100, + 0.60658400, + 0.60592700, + 0.60527100, + 0.60461400, + 0.60395700, + 0.60330100, + 0.60264400, + 0.60198700, + 0.60133000, + 0.60067400, + 0.60001700, + 0.59936000, + 0.59870400, + 0.59804700, + 0.59739000, + 0.59673400, + 0.59607700, + 0.59582900, + 0.59583300, + 0.59583700, + 0.59584100, + 0.59584500, + 0.59585000, + 0.59585400, + 0.59585800, + 0.59586200, + 0.59586600, + 0.59587100, + 0.59587500, + 0.59587900, + 0.59588300, + 0.59588700, + 0.59589200, + 0.59589600, + 0.59590000, + 0.59590400, + 0.59590800, + 0.59591300, + 0.59591700, + 0.59592100, + 0.59592500, + 0.59547600, + 0.59403900, + 0.59260100, + 0.59116400, + 0.58972700, + 0.58828900, + 0.58685200, + 0.58541400, + 0.58397700, + 0.58254000, + 0.58110200, + 0.57966500, + 0.57822800, + 0.57679000, + 0.57535300, + 0.57391500, + 0.57247800, + 0.57104000, + 0.56960300, + 0.56816600, + 0.56672800, + 0.56529100, + 0.56385300, + 0.56241600, + 0.56097900, + 0.55884500, + 0.55577200, + 0.55270000, + 0.54962700, + 0.54655400, + 0.54348100, + 0.54040900, + 0.53733600, + 0.53426300, + 0.53119000, + 0.52811700, + 0.52504500, + 0.52197200, + 0.51889900, + 0.51582600, + 0.51275400, + 0.50968100, + 0.50660800, + 0.50353500, + 0.50046300, + 0.49739000, + 0.49431700, + 0.49124400, + 0.48817200, + 0.48509900, + 0.48202600, + 0.47522600, + 0.46813400, + 0.46104100, + 0.45394800, + 0.44685600, + 0.43976400, + 0.43267100, + 0.42557800, + 0.41848600, + 0.41139400, + 0.40430100, + 0.39720800, + 0.39011600, + 0.38302300, + 0.37593000, + 0.36883700, + 0.36174400, + 0.35465300, + 0.34756000, + 0.34046700, + 0.33337600, + 0.32628300, + 0.31919000, + 0.31209700, + 0.30500400, + 0.29791300, + 0.29130000, + 0.28481200, + 0.27832500, + 0.27183700, + 0.26534900, + 0.25886000, + 0.25237200, + 0.24588600, + 0.23939700, + 0.23290900, + 0.22642200, + 0.21993400, + 0.21344600, + 0.20695800, + 0.20047000, + 0.19398300, + 0.18749500, + 0.18100700, + 0.17452000, + 0.16803200, + 0.16154300, + 0.15505500, + 0.14856700, + 0.14208000, + 0.13559200, + 0.12910400, + 0.12268400, + 0.11988200, + 0.11708000, + 0.11427900, + 0.11147700, + 0.10867600, + 0.10587400, + 0.10307200, + 0.10027100, + 0.09746960, + 0.09466790, + 0.09186620, + 0.08906450, + 0.08626350, + 0.08346180, + 0.08066010, + 0.07785910, + 0.07505740, + 0.07225560, + 0.06945390, + 0.06665220, + 0.06385120, + 0.06104950, + 0.05824780, + 0.05544680, + 0.05264510, + 0.04984330, + 0.04704160, + 0.04397770, + 0.04070670, + 0.03743490, + 0.03416300, + 0.03089200, + 0.02762020, + 0.02434830, + 0.02107650, + 0.01780460, + 0.01453360, + 0.01126180, + 0.00798992, + 0.00471891, + 0.00144707, + 0.00000000, + ], + dtype=np.float32, + ) return wnum, rf @@ -173,7 +962,7 @@ def sum_function_irt(temperature, inTotal, units='cm', rf=None, rf_wnum=None): if rf is None or rf_wnum is None: rf_wnum, rf = irt_response_function() if units == 'm': - rf_wnum *= 100. + rf_wnum *= 100.0 rad = planck_converter(rf_wnum, temperature=temperature, units=units) * rf return np.nansum(rad) - inTotal @@ -257,9 +1046,17 @@ def process_sst_data(sfc_t, sky_t, emis, maxit, tempLow, tempHigh, tol): return sst -def sst_from_irt(obj, sky_irt='sky_ir_temp', sfc_irt='sfc_ir_temp', emis=0.986, - maxit=500, tempLow=250., tempHigh=350., tol=0.1, - sst_variable='sea_surface_temperature'): +def sst_from_irt( + ds, + sky_irt='sky_ir_temp', + sfc_irt='sfc_ir_temp', + emis=0.986, + maxit=500, + tempLow=250.0, + tempHigh=350.0, + tol=0.1, + sst_variable='sea_surface_temperature', +): """ Base function to calculate sea surface temperatures from Sky and Surface IRT values. This is meant to take advantage of dask and multiprocessing @@ -269,8 +1066,8 @@ def sst_from_irt(obj, sky_irt='sky_ir_temp', sfc_irt='sfc_ir_temp', emis=0.986, Parameters ---------- - obj : xarray Dataset - Data object + ds : xarray.Dataset + Xarray dataset sky_irt : string Sky ir temperature variable name sfc_irt : string @@ -290,8 +1087,8 @@ def sst_from_irt(obj, sky_irt='sky_ir_temp', sfc_irt='sfc_ir_temp', emis=0.986, Returns ------- - obj : xarray Dataset - Data object with Sea surface temperature array inserted + ds : xarray.Dataset + Xarray dataset with Sea surface temperature array inserted References --------- @@ -303,21 +1100,24 @@ def sst_from_irt(obj, sky_irt='sky_ir_temp', sfc_irt='sfc_ir_temp', emis=0.986, """ # Get Data for surface and sky ir temperatures - sfc_temp = obj[sfc_irt].values - sky_temp = obj[sky_irt].values + sfc_temp = ds[sfc_irt].values + sky_temp = ds[sky_irt].values # Get response function values once instead of calling function each time task = [] for i in range(len(sfc_temp)): - task.append(dask.delayed(process_sst_data)(sfc_temp[i], sky_temp[i], emis, - maxit, tempLow, tempHigh, tol)) + task.append( + dask.delayed(process_sst_data)( + sfc_temp[i], sky_temp[i], emis, maxit, tempLow, tempHigh, tol + ) + ) results = dask.compute(*task) - # Add data back to the object + # Add data back to the dataset long_name = 'Calculated sea surface temperature' attrs = {'long_name': long_name, 'units': 'K'} - da = xr.DataArray(list(results), dims=['time'], coords=[obj['time'].values], attrs=attrs) - obj[sst_variable] = da + da = xr.DataArray(list(results), dims=['time'], coords=[ds['time'].values], attrs=attrs) + ds[sst_variable] = da - return obj + return ds diff --git a/act/retrievals/pwv_calc.py b/act/retrievals/pwv_calc.py deleted file mode 100644 index ccc1c6d706..0000000000 --- a/act/retrievals/pwv_calc.py +++ /dev/null @@ -1,85 +0,0 @@ -""" Retrievals for precipitable water vapor. """ - -import numpy as np - - -def calculate_precipitable_water(ds, temp_name='tdry', rh_name='rh', - pres_name='pres'): - """ - - Function to calculate precipitable water vapor from ARM sondewnpn b1 data. - Will first calculate saturation vapor pressure of all data using Arden-Buck - equations, then calculate specific humidity and integrate over all pressure - levels to give us a precipitable water value in centimeters. - - ds : ACT object - Object as read in by the ACT netCDF reader. - temp_name : str - Name of temperature field to use. Defaults to 'tdry' for sondewnpn b1 - level data. - rh_name : str - Name of relative humidity field to use. Defaults to 'rh' for sondewnpn - b1 level data. - pres_name : str - Name of atmospheric pressure field to use. Defaults to 'pres' for - sondewnpn b1 level data. - - """ - temp = ds[temp_name].values - rh = ds[rh_name].values - pres = ds[pres_name].values - - # Get list of temperature values for saturation vapor pressure calc - temperature = [] - for t in np.nditer(temp): - temperature.append(t) - - # Apply Arden-Buck equation to get saturation vapor pressure - sat_vap_pres = [] - for t in temperature: - # Over liquid water, above freezing - if t >= 0: - sat_vap_pres.append(0.61121 * np.exp((18.678 - (t / 234.5)) * - (t / (257.14 + t)))) - # Over ice, below freezing - else: - sat_vap_pres.append(0.61115 * np.exp((23.036 - (t / 333.7)) * - (t / (279.82 + t)))) - - # convert rh from % to decimal - rel_hum = [] - for r in np.nditer(rh): - rel_hum.append(r / 100.) - - # get vapor pressure from rh and saturation vapor pressure - vap_pres = [] - for i in range(0, len(sat_vap_pres)): - es = rel_hum[i] * sat_vap_pres[i] - vap_pres.append(es) - - # Get list of pressure values for mixing ratio calc - pressure = [] - for p in np.nditer(pres): - pressure.append(p) - - # Mixing ratio calc - - mix_rat = [] - for i in range(0, len(vap_pres)): - mix_rat.append(0.622 * vap_pres[i] / (pressure[i] - vap_pres[i])) - - # Specific humidity - - spec_hum = [] - for rat in mix_rat: - spec_hum.append(rat / (1 + rat)) - - # Integrate specific humidity - - pwv = 0.0 - for i in range(1, len(pressure) - 1): - pwv = pwv + 0.5 * (spec_hum[i] + spec_hum[i - 1]) * (pressure[i - 1] - - pressure[i]) - - pwv = pwv / 0.098 - return pwv diff --git a/act/retrievals/radiation.py b/act/retrievals/radiation.py index 79e34c0ac6..4d1964ebdd 100644 --- a/act/retrievals/radiation.py +++ b/act/retrievals/radiation.py @@ -1,21 +1,23 @@ """ -act.retrievals.radiation ------------------------- - -Module for solar radiation related calculations and retrievals +Functions for solar radiation related calculations and retrievals. """ import numpy as np import xarray as xr from scipy.constants import Stefan_Boltzmann + from act.utils.datetime_utils import datetime64_to_datetime from act.utils.geo_utils import get_solar_azimuth_elevation -def calculate_dsh_from_dsdh_sdn(obj, dsdh='down_short_diffuse_hemisp', - sdn='short_direct_normal', lat='lat', - lon='lon'): +def calculate_dsh_from_dsdh_sdn( + ds, + dsdh='down_short_diffuse_hemisp', + sdn='short_direct_normal', + lat='lat', + lon='lon', +): """ Function to derive the downwelling shortwave hemispheric irradiance from the @@ -24,8 +26,8 @@ def calculate_dsh_from_dsdh_sdn(obj, dsdh='down_short_diffuse_hemisp', Parameters ---------- - obj : Xarray dataset - Object where variables for these calculations are stored + ds : xarray.Dataset + Xarray dataset where variables for these calculations are stored dsdh : str Name of the downwelling shortwave diffuse hemispheric irradiance field to use. Defaults to downwelling_sw_diffuse_hemisp_irradiance. @@ -40,35 +42,45 @@ def calculate_dsh_from_dsdh_sdn(obj, dsdh='down_short_diffuse_hemisp', Returns ------- - obj: Xarray dataset - ACT Xarray dataset oject with calculations included as new variables. + ds: xarray.Dataset + ACT Xarray Dataset with calculations included as new variables. """ # Calculating Derived Down Short Hemisp - tt = datetime64_to_datetime(obj['time'].values) - elevation, _, _ = get_solar_azimuth_elevation(obj[lat].values, obj[lon].values, tt) - solar_zenith = np.cos(np.radians(90. - elevation)) - dsh = (obj[dsdh].values + (solar_zenith * obj[sdn].values)) - - # Add data back to object - atts = {'long_name': 'Derived Downwelling Shortwave Hemispheric Irradiance', 'units': 'W/m^2'} - da = xr.DataArray(dsh, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj['derived_down_short_hemisp'] = da - - return obj - - -def calculate_irradiance_stats(obj, variable=None, variable2=None, diff_output_variable=None, - ratio_output_variable=None, threshold=None): + elevation, _, _ = get_solar_azimuth_elevation(ds[lat].values, ds[lon].values, ds['time'].values) + solar_zenith = np.cos(np.radians(90.0 - elevation)) + dsh = ds[dsdh].values + (solar_zenith * ds[sdn].values) + + # Add data back to DataArray + ds['derived_down_short_hemisp'] = xr.DataArray( + dsh, + dims=['time'], + attrs={ + 'long_name': 'Derived Downwelling Shortwave Hemispheric Irradiance', + 'units': 'W/m^2', + } + ) + + return ds + + +def calculate_irradiance_stats( + ds, + variable=None, + variable2=None, + diff_output_variable=None, + ratio_output_variable=None, + threshold=None, +): """ Function to calculate the difference and ratio between two irradiance. Parameters ---------- - obj : ACT object - Object where variables for these calculations are stored + ds : xarray.Dataset + Xarray dataset where variables for these calculations are stored variable : str Name of the first irradiance variable variable2 : str @@ -83,13 +95,13 @@ def calculate_irradiance_stats(obj, variable=None, variable2=None, diff_output_v Returns ------- - obj: ACT Object - Object with calculations included as new variables. + ds : xarray.Dataset + Xarray dataset with calculations included as new variables. """ if variable is None or variable2 is None: - return obj + return ds if diff_output_variable is None: diff_output_variable = 'diff_' + variable if ratio_output_variable is None: @@ -98,28 +110,40 @@ def calculate_irradiance_stats(obj, variable=None, variable2=None, diff_output_v # --------------------------------- # Calculating Difference # --------------------------------- - diff = obj[variable] - obj[variable2] - atts = {'long_name': ' '.join(['Difference between', variable, 'and', variable2]), 'units': 'W/m^2'} - da = xr.DataArray(diff, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj[diff_output_variable] = da + diff = ds[variable] - ds[variable2] + atts = { + 'long_name': ' '.join(['Difference between', variable, 'and', variable2]), + 'units': 'W/m^2', + } + da = xr.DataArray(diff, coords={'time': ds['time'].values}, dims=['time'], attrs=atts) + ds[diff_output_variable] = da # --------------------------------- # Calculating Irradiance Ratio # --------------------------------- - ratio = obj[variable].values / obj[variable2].values + ratio = ds[variable].values / ds[variable2].values if threshold is not None: - index = np.where((obj[variable].values < threshold) & (obj[variable2].values < threshold)) + index = np.where((ds[variable].values < threshold) & (ds[variable2].values < threshold)) ratio[index] = np.nan - atts = {'long_name': ' '.join(['Ratio between', variable, 'and', variable2]), 'units': ''} - da = xr.DataArray(ratio, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj[ratio_output_variable] = da + atts = { + 'long_name': ' '.join(['Ratio between', variable, 'and', variable2]), + 'units': '', + } + da = xr.DataArray(ratio, coords={'time': ds['time'].values}, dims=['time'], attrs=atts) + ds[ratio_output_variable] = da - return obj + return ds -def calculate_net_radiation(obj, ush='up_short_hemisp', ulh='up_long_hemisp', dsh='down_short_hemisp', - dlhs='down_long_hemisp_shaded', smooth=None): +def calculate_net_radiation( + ds, + ush='up_short_hemisp', + ulh='up_long_hemisp', + dsh='down_short_hemisp', + dlhs='down_long_hemisp_shaded', + smooth=None, +): """ @@ -128,8 +152,8 @@ def calculate_net_radiation(obj, ush='up_short_hemisp', ulh='up_long_hemisp', ds Parameters ---------- - obj : ACT object - Object where variables for these calculations are stored + ds : xarray.Dataset + Xarray dataset where variables for these calculations are stored ush : str Name of the upwelling shortwave hemispheric variable ulh : str @@ -144,34 +168,45 @@ def calculate_net_radiation(obj, ush='up_short_hemisp', ulh='up_long_hemisp', ds Returns ------- - obj: ACT Object - Object with calculations included as new variables. + ds : xarray.Dataset + Xarray dataset with calculations included as new variables. """ # Calculate Net Radiation - ush_da = obj[ush] - ulh_da = obj[ulh] - dsh_da = obj[dsh] - dlhs_da = obj[dlhs] + ush_da = ds[ush] + ulh_da = ds[ulh] + dsh_da = ds[dsh] + dlhs_da = ds[dlhs] net = -ush_da + dsh_da - ulh_da + dlhs_da atts = {'long_name': 'Calculated Net Radiation', 'units': 'W/m^2'} - da = xr.DataArray(net, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj['net_radiation'] = da + da = xr.DataArray(net, coords={'time': ds['time'].values}, dims=['time'], attrs=atts) + ds['net_radiation'] = da if smooth is not None: net_smoothed = net.rolling(time=smooth).mean() - atts = {'long_name': 'Net Radiation Smoothed by ' + str(smooth), 'units': 'W/m^2'} - da = xr.DataArray(net_smoothed, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj['net_radiation_smoothed'] = da - - return obj - - -def calculate_longwave_radiation(obj, temperature_var=None, vapor_pressure_var=None, met_obj=None, - emiss_a=0.61, emiss_b=0.06): + atts = { + 'long_name': 'Net Radiation Smoothed by ' + str(smooth), + 'units': 'W/m^2', + } + da = xr.DataArray( + net_smoothed, coords={'time': ds['time'].values}, dims=['time'], attrs=atts + ) + ds['net_radiation_smoothed'] = da + + return ds + + +def calculate_longwave_radiation( + ds, + temperature_var=None, + vapor_pressure_var=None, + met_ds=None, + emiss_a=0.61, + emiss_b=0.06, +): """ @@ -181,15 +216,15 @@ def calculate_longwave_radiation(obj, temperature_var=None, vapor_pressure_var=N Parameters ---------- - obj : ACT object - Object where variables for these calculations are stored + ds : xarray.Dataset + Xarray dataset where variables for these calculations are stored temperature_var : str Name of the temperature variable to use vapor_pressure_var : str Name of the vapor pressure variable to use - met_obj : ACT object - Object where surface meteorological variables for these calculations are stored - if not given, will assume they are in the main object passed in + met_ds : xarray.Dataset + Xarray dataset where surface meteorological variables for these calculations are + stored if not given, will assume they are in the main dataset passed in emiss_a : float a coefficient for the emissivity calculation of e = a + bT emiss_b : float @@ -197,8 +232,8 @@ def calculate_longwave_radiation(obj, temperature_var=None, vapor_pressure_var=N Returns ------- - obj : ACT object - ACT object with 3 new variables; monteith_clear, monteith_cloudy, prata_clear + ds : xarray.Dataset + Xarray dataset with 3 new variables; monteith_clear, monteith_cloudy, prata_clear References --------- @@ -213,13 +248,13 @@ def calculate_longwave_radiation(obj, temperature_var=None, vapor_pressure_var=N San Antonio, Texas, March 22-26 """ - if met_obj is not None: + if met_ds is not None: - T = met_obj[temperature_var] + 273.15 # C to K - e = met_obj[vapor_pressure_var] * 10. # kpa to hpa + T = met_ds[temperature_var] + 273.15 # C to K + e = met_ds[vapor_pressure_var] * 10.0 # kpa to hpa else: - T = obj[temperature_var] + 273.15 # C to K - e = obj[vapor_pressure_var] * 10. # kpa to hpa + T = ds[temperature_var] + 273.15 # C to K + e = ds[vapor_pressure_var] * 10.0 # kpa to hpa if len(T) == 0 or len(e) == 0: raise ValueError('Temperature and Vapor Pressure are Needed') @@ -235,21 +270,26 @@ def calculate_longwave_radiation(obj, temperature_var=None, vapor_pressure_var=N # Prata 1996 Calculation xi = 46.5 * (e / T) - lw_calc_clear_prata = (1.0 - (1.0 + xi) * np.exp(-(1.2 + 3.0 * xi)**.5)) * stefan * T**4 + lw_calc_clear_prata = (1.0 - (1.0 + xi) * np.exp(-((1.2 + 3.0 * xi) ** 0.5))) * stefan * T**4 # Monteith Cloudy Calcuation as indicated by Splitt and Bahrmann 1999 - lw_calc_cldy = esky * (1.0 + (0.178 - 0.00957 * (T - 290.))) * stefan * T**4 + lw_calc_cldy = esky * (1.0 + (0.178 - 0.00957 * (T - 290.0))) * stefan * T**4 atts = {'long_name': 'Clear Sky Estimate-(Monteith, 1973)', 'units': 'W/m^2'} - da = xr.DataArray(lw_calc_clear, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj['monteith_clear'] = da + da = xr.DataArray(lw_calc_clear, coords={'time': ds['time'].values}, dims=['time'], attrs=atts) + ds['monteith_clear'] = da atts = {'long_name': 'Overcast Sky Estimate-(Monteith, 1973)', 'units': 'W/m^2'} - da = xr.DataArray(lw_calc_cldy, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj['monteith_cloudy'] = da + da = xr.DataArray(lw_calc_cldy, coords={'time': ds['time'].values}, dims=['time'], attrs=atts) + ds['monteith_cloudy'] = da atts = {'long_name': 'Clear Sky Estimate-(Prata, 1996)', 'units': 'W/m^2'} - da = xr.DataArray(lw_calc_clear_prata, coords={'time': obj['time'].values}, dims=['time'], attrs=atts) - obj['prata_clear'] = da - - return obj + da = xr.DataArray( + lw_calc_clear_prata, + coords={'time': ds['time'].values}, + dims=['time'], + attrs=atts, + ) + ds['prata_clear'] = da + + return ds diff --git a/act/retrievals/sonde.py b/act/retrievals/sonde.py new file mode 100644 index 0000000000..242b7f9abb --- /dev/null +++ b/act/retrievals/sonde.py @@ -0,0 +1,666 @@ +""" +Functions for radiosonde related calculations. + +""" + +import warnings +import numpy as np +import pandas as pd +import xarray as xr +from operator import itemgetter +from itertools import groupby +import metpy.calc as mpcalc +from metpy.units import units + +from act.utils.data_utils import convert_to_potential_temp + + +def calculate_precipitable_water(ds, temp_name='tdry', rh_name='rh', pres_name='pres'): + """ + + Function to calculate precipitable water vapor from ARM sondewnpn b1 data. + Will first calculate saturation vapor pressure of all data using Arden-Buck + equations, then calculate specific humidity and integrate over all pressure + levels to give us a precipitable water value in centimeters. + + ds : xarray.Dataset + Xarray dataset as read in by the ACT netCDF reader. + temp_name : str + Name of temperature field to use. Defaults to 'tdry' for sondewnpn b1 + level data. + rh_name : str + Name of relative humidity field to use. Defaults to 'rh' for sondewnpn + b1 level data. + pres_name : str + Name of atmospheric pressure field to use. Defaults to 'pres' for + sondewnpn b1 level data. + + """ + temp = ds[temp_name].values + rh = ds[rh_name].values + pres = ds[pres_name].values + + # Get list of temperature values for saturation vapor pressure calc + temperature = [] + for t in np.nditer(temp): + temperature.append(t) + + # Apply Arden-Buck equation to get saturation vapor pressure + sat_vap_pres = [] + for t in temperature: + # Over liquid water, above freezing + if t >= 0: + sat_vap_pres.append(0.61121 * np.exp((18.678 - (t / 234.5)) * (t / (257.14 + t)))) + # Over ice, below freezing + else: + sat_vap_pres.append(0.61115 * np.exp((23.036 - (t / 333.7)) * (t / (279.82 + t)))) + + # convert rh from % to decimal + rel_hum = [] + for r in np.nditer(rh): + rel_hum.append(r / 100.0) + + # get vapor pressure from rh and saturation vapor pressure + vap_pres = [] + for i in range(0, len(sat_vap_pres)): + es = rel_hum[i] * sat_vap_pres[i] + vap_pres.append(es) + + # Get list of pressure values for mixing ratio calc + pressure = [] + for p in np.nditer(pres): + pressure.append(p) + + # Mixing ratio calc + + mix_rat = [] + for i in range(0, len(vap_pres)): + mix_rat.append(0.622 * vap_pres[i] / (pressure[i] - vap_pres[i])) + + # Specific humidity + + spec_hum = [] + for rat in mix_rat: + spec_hum.append(rat / (1 + rat)) + + # Integrate specific humidity + + pwv = 0.0 + for i in range(1, len(pressure) - 1): + pwv = pwv + 0.5 * (spec_hum[i] + spec_hum[i - 1]) * (pressure[i - 1] - pressure[i]) + + pwv = pwv / 0.098 + return pwv + + +def calculate_stability_indicies( + ds, + temp_name='temperature', + td_name='dewpoint_temperature', + p_name='pressure', + moving_ave_window=0, +): + """ + Function for calculating stability indices from sounding data. + + Parameters + ---------- + ds : ACT dataset + The dataset to compute the stability indicies of. Must have + temperature, dewpoint, and pressure in vertical coordinates. + temp_name : str + The name of the temperature field. + td_name : str + The name of the dewpoint field. + p_name : str + The name of the pressure field. + moving_ave_window : int + Number of points to do a moving average on sounding data to reduce + noise. This is useful if noise in the sounding is preventing parcel + ascent. + + Returns + ------- + ds : ACT dataset + An ACT dataset with additional stability indicies added. + + """ + t = ds[temp_name] + td = ds[td_name] + p = ds[p_name] + + if not hasattr(t, 'units'): + raise AttributeError('Temperature field must have units' + ' for ACT to discern!') + + if not hasattr(td, 'units'): + raise AttributeError('Dewpoint field must have units' + ' for ACT to discern!') + + if not hasattr(p, 'units'): + raise AttributeError('Pressure field must have units' + ' for ACT to discern!') + if t.units == 'C': + t_units = units.degC + else: + t_units = getattr(units, t.units) + + if td.units == 'C': + td_units = units.degC + else: + td_units = getattr(units, td.units) + + p_units = getattr(units, p.units) + + # Sort all values by decreasing pressure + t_sorted = np.array(t.values) + td_sorted = np.array(td.values) + p_sorted = np.array(p.values) + ind_sort = np.argsort(p_sorted) + t_sorted = t_sorted[ind_sort[-1:0:-1]] + td_sorted = td_sorted[ind_sort[-1:0:-1]] + p_sorted = p_sorted[ind_sort[-1:0:-1]] + + if moving_ave_window > 0: + t_sorted = np.convolve(t_sorted, np.ones((moving_ave_window,)) / moving_ave_window) + td_sorted = np.convolve(td_sorted, np.ones((moving_ave_window,)) / moving_ave_window) + p_sorted = np.convolve(p_sorted, np.ones((moving_ave_window,)) / moving_ave_window) + + t_sorted = t_sorted * t_units + td_sorted = td_sorted * td_units + p_sorted = p_sorted * p_units + + t_profile = mpcalc.parcel_profile(p_sorted, t_sorted[0], td_sorted[0]) + + # Calculate parcel trajectory + ds['parcel_temperature'] = t_profile.magnitude + ds['parcel_temperature'].attrs['units'] = t_profile.units + + # Calculate CAPE, CIN, LCL + sbcape, sbcin = mpcalc.surface_based_cape_cin(p_sorted, + t_sorted, + td_sorted) + + lcl = mpcalc.lcl(p_sorted[0], t_sorted[0], td_sorted[0]) + try: + lfc = mpcalc.lfc(p_sorted[0], t_sorted[0], td_sorted[0]) + except IndexError: + lfc = np.nan * p_sorted.units + + mucape, mucin = mpcalc.most_unstable_cape_cin(p_sorted, t_sorted, td_sorted) + + where_500 = np.argmin(np.abs(p_sorted - 500 * units.hPa)) + li = t_sorted[where_500] - t_profile[where_500] + + ds['surface_based_cape'] = sbcape.magnitude + ds['surface_based_cape'].attrs['units'] = 'J/kg' + ds['surface_based_cape'].attrs['long_name'] = 'Surface-based CAPE' + ds['surface_based_cin'] = sbcin.magnitude + ds['surface_based_cin'].attrs['units'] = 'J/kg' + ds['surface_based_cin'].attrs['long_name'] = 'Surface-based CIN' + ds['most_unstable_cape'] = mucape.magnitude + ds['most_unstable_cape'].attrs['units'] = 'J/kg' + ds['most_unstable_cape'].attrs['long_name'] = 'Most unstable CAPE' + ds['most_unstable_cin'] = mucin.magnitude + ds['most_unstable_cin'].attrs['units'] = 'J/kg' + ds['most_unstable_cin'].attrs['long_name'] = 'Most unstable CIN' + ds['lifted_index'] = li.magnitude + ds['lifted_index'].attrs['units'] = t_profile.units + ds['lifted_index'].attrs['long_name'] = 'Lifted index' + ds['level_of_free_convection'] = lfc.magnitude + ds['level_of_free_convection'].attrs['units'] = lfc.units + ds['level_of_free_convection'].attrs['long_name'] = 'Level of free convection' + ds['lifted_condensation_level_temperature'] = lcl[1].magnitude + ds['lifted_condensation_level_temperature'].attrs['units'] = lcl[1].units + ds['lifted_condensation_level_temperature'].attrs[ + 'long_name' + ] = 'Lifted condensation level temperature' + ds['lifted_condensation_level_pressure'] = lcl[0].magnitude + ds['lifted_condensation_level_pressure'].attrs['units'] = lcl[0].units + ds['lifted_condensation_level_pressure'].attrs[ + 'long_name' + ] = 'Lifted condensation level pressure' + return ds + + +def calculate_pbl_liu_liang( + ds, + temperature='tdry', + pressure='pres', + windspeed='wspd', + height='alt', + smooth_height=3, + land_parameter=True, + llj_max_alt=1500.0, + llj_max_wspd=2.0, +): + """ + Function for calculating the PBL height from a radiosonde profile + using the Liu-Liang 2010 technique. There are some slight descrepencies + in the function from the ARM implementation 1.) it imposes a 1500m (keyword) + height on the definition of the LLJ and 2.) the interpolation is slightly different + using python functions + + Parameters + ---------- + ds : xarray Dataset + Dataset housing radiosonde profile for calculations + temperature : str + The name of the temperature field. + pressure : str + The name of the pressure field. + windspeed : str + The name of the wind speed field. + height : str + The name of the height field + smooth_height : int + Number of points to do a moving average on sounding height data to reduce noise + land_parameter : boolean + Set to True if retrievals over land or false to retrievals over water + llj_max_alt : float + Maximum altitude the LLJ 2 m/s difference should be checked against + llj_max_wspd : float + Maximum wind speed threshold to use to define LLJ + + Returns + ------- + ds : xarray Dataset + xarray dataset with results stored in pblht_liu_liang variable + + References + ---------- + Liu, Shuyan, and Xin-Zhong Liang. "Observed diurnal cycle climatology of planetary + boundary layer height." Journal of Climate 23, no. 21 (2010): 5790-5809. + + Sivaraman, C., S. McFarlane, E. Chapman, M. Jensen, T. Toto, S. Liu, and M. Fischer. + "Planetary boundary layer (PBL) height value added product (VAP): Radiosonde retrievals." + Department of Energy Office of Science Atmospheric Radiation Measurement (ARM) Program + (United States) (2013). + + """ + + # Preprocess the sonde data to ensure the same methods across all retrievals + ds2 = preprocess_sonde_data(ds, temperature=temperature, pressure=pressure, + height=height, smooth_height=smooth_height, base=5.) + + pres = ds2[pressure].values + wspd = ds2[windspeed].values + alt = ds2[height].values + + theta = ds2['potential_temperature'].values + + # Calculate the lapse rate + theta_gradient = np.diff(theta) / np.diff(alt) + + # Calculate AGL + if np.isnan(alt[0]): + idx = np.where(~np.isnan(alt))[0] + agl = alt - alt[idx[0]] + else: + agl = alt - alt[0] + + theta_diff = theta[4] - theta[1] + theta_gradient = np.diff(theta) / np.diff(alt / 1000.0) + + # Set up threshold values + if land_parameter: + stability_thresh = 1.0 # K + inst_thresh = 0.5 # K + overshoot_thresh = 4.0 # K/km + else: + stability_thresh = 0.2 # K + inst_thresh = 0.1 # K + overshoot_thresh = 0.5 # K/km + + # Check Regimes + if theta_diff < 0 - stability_thresh: + regime = 'CBL' + if theta_diff > abs(stability_thresh): + regime = 'SBL' + if (0 - stability_thresh) <= theta_diff <= abs(stability_thresh): + regime = 'NRL' + + # Calculate for CBL/NRL regimes + pbl_stable = np.nan + pbl_shear = np.nan + + if regime == 'CBL' or regime == 'NRL': + # Calculate gradient from first level + theta_gradient_0 = theta - theta[0] + + # Only process data above 150m ARM + idx = np.where(agl > 150)[0][0] + theta_gradient_0[0:idx] = np.nan + + # Scan upward to find lowest level that meets condition + idx = np.where(theta_gradient_0 >= inst_thresh)[0] + theta_gradient[0 : idx[0]] = np.nan + + # Scan upward from previous level to search for overlying inversion layer + idx = np.where(theta_gradient >= overshoot_thresh)[0] + pbl = alt[idx[0]] + else: + idx = np.array( + [ + i + for i, t in enumerate(theta_gradient[1:-1]) + if theta_gradient[i] < theta_gradient[i - 1] + and theta_gradient[i] < theta_gradient[i + 1] + ] + ) + + for i in idx: + cond1 = (theta_gradient[i] - theta_gradient[i - 1]) < -40.0 + cond2 = (theta_gradient[i + 1] < overshoot_thresh) or ( + theta_gradient[i + 2] < overshoot_thresh + ) + if cond1 or cond2: + # This gets the ARM answer + pbl_stable = (alt[i + 1] + alt[i]) / 2.0 + # pbl_stable = alt[i] + break + + # Check for low-level jet + # Find the height of the maximum windspeed and look up to find layer 2m/s lower + # Stull 1988 indicates LLJ is defined as where there is a relative wind speed + # maximum that is more than 2 m/s faster than the wind speeds above it within + # the lowest 1500m of the atmosphere. Keywords to adjust are provided + idh = np.where(alt <= llj_max_alt)[0] + max_wspd_ind = [i for i, w in enumerate(wspd[:-1]) if wspd[i] > wspd[i + 1]][0] + diff = wspd[max_wspd_ind] - wspd[max_wspd_ind : idh[-1]] + idx = np.where(diff > llj_max_wspd)[0] + if len(idx) > 0: + wspd_to_surf = np.diff(np.flip(wspd[0:max_wspd_ind])) + wspd_monotonic = np.all(wspd_to_surf <= 0.0) + if wspd_monotonic: + pbl_shear = alt[max_wspd_ind] + + if ~np.all(np.isnan([pbl_stable, pbl_shear])): + pbl = np.nanmin([pbl_stable, pbl_shear]) + else: + pbl = -9999.0 + + atts = {'units': 'm', 'long_name': 'Planteary Boundary Layer Height Liu-Liang'} + da = xr.DataArray(pbl, attrs=atts) + ds['pblht_liu_liang'] = da + + atts = { + 'units': '', + 'long_name': 'Planteary Boundary Layer Regime Classification Liu-Liang', + } + da = xr.DataArray(regime, attrs=atts) + ds['pblht_regime_liu_liang'] = da + + atts = {'units': 'mb', 'long_name': 'Gridded pressure'} + da = xr.DataArray(pres, coords={'atm_pres_ss': pres}, dims=['atm_pres_ss'], attrs=atts) + ds['atm_pres_ss'] = da + + atts = {'units': 'K', 'long_name': 'Gridded potential temperature'} + da = xr.DataArray(theta, coords={'atm_pres_ss': pres}, dims=['atm_pres_ss'], attrs=atts) + ds['potential_temperature_ss'] = da + + atts = {'units': 'm', 'long_name': 'Gridded altitude'} + da = xr.DataArray(alt, coords={'atm_pres_ss': pres}, dims=['atm_pres_ss'], attrs=atts) + ds['alt_ss'] = da + + atts = {'units': 'm', 'long_name': 'PBL Stable Condition 1'} + da = xr.DataArray(pbl_stable, attrs=atts) + ds['pblht_liu_liang_stable_cond'] = da + + atts = {'units': 'm', 'long_name': 'PBL Shear Condition 2'} + da = xr.DataArray(pbl_shear, attrs=atts) + ds['pblht_liu_liang_shear_cond'] = da + + return ds + + +def calculate_pbl_heffter( + ds, + temperature='tdry', + pressure='pres', + height='alt', + smooth_height=3, + base=5., +): + """ + Function for calculating the PBL height from a radiosonde profile + using the Heffter technique. There are differences from the ARM + VAP at times due to different averaging schemes. Larger differences + do occur at times and are unknown as to the cause but it is being + investigated and is potential a code issue with the VAP. + + Parameters + ---------- + ds : xarray Dataset + Dataset housing radiosonde profile for calculations + temperature : str + The name of the temperature field. + pressure : str + The name of the pressure field. + height : str + The name of the height field + smooth_height : int + Number of points to do a moving average on sounding height data to reduce noise + base : int + Interval for pressure gridding. In testing, 5 mb was found to produce results with + the lowest RMS + + Returns + ------- + ds : xarray Dataset + xarray dataset with results stored in pblht_liu_liang variable + + References + ---------- + Heffter JL. 1980. “Transport Layer Depth Calculations.” Second Joint Conference on + Applications of Air Pollution Meteorology, New Orleans, Louisiana. + + Sivaraman, C., S. McFarlane, E. Chapman, M. Jensen, T. Toto, S. Liu, and M. Fischer. + "Planetary boundary layer (PBL) height value added product (VAP): Radiosonde retrievals." + Department of Energy Office of Science Atmospheric Radiation Measurement (ARM) Program + (United States) (2013). + + """ + + # Preprocess the sonde data to ensure the same methods across all retrievals + ds2 = preprocess_sonde_data(ds, temperature=temperature, pressure=pressure, + height=height, smooth_height=smooth_height, base=base) + + # Get data + pres = ds2[pressure].values + alt = ds2[height].values + theta = ds2['potential_temperature'].values + + # Calculate the lapse rate + theta_gradient = np.diff(theta) / np.diff(alt) + + # Calculate AGL + if np.isnan(alt[0]): + idx = np.where(~np.isnan(alt))[0] + agl = alt - alt[idx[0]] + else: + agl = alt - alt[0] + + # Find where the lapse rate is greater than 0.005 K/m + idx = np.where(theta_gradient >= 0.005)[0] + + # Find the consistent layers by grouping the indices together + # Does not include a single height as a layer + ranges = [] + for key, group in groupby(enumerate(idx), lambda i: i[0] - i[1]): + group = list(map(itemgetter(1), group)) + if group[-1] - group[0] > 0: + ranges.append((group[0], group[-1])) + + # Subset ranges to lowest 5 + if len(ranges) > 5: + ranges = ranges[0:5] + + # For each layer, calculate the difference in theta from + # top and bottom of the layer. The lowest layer where the + # difference is > 2 K is set as the PBL. + pbl = 0. + theta_diff_layer = [] + bottom_inversion = [] + top_inversion = [] + for r in ranges: + if agl[r[1]] > 4000.: + continue + theta_diff = theta[r[1]] - theta[r[0]] + theta_diff_layer.append(theta_diff) + bottom_inversion.append(alt[r[0]]) + top_inversion.append(alt[r[1]]) + if pbl == 0. and theta_diff > 2.0: + pbl = alt[r[0]] + + if len(theta_diff_layer) == 0: + pbl = -9999. + + # If PBL is not set, set it to the layer with the max theta diff + if pbl == 0.: + idx = np.argmax(theta_diff_layer) + pbl = bottom_inversion[idx] + + # Add variables to the dataset + atts = {'units': 'm', 'long_name': 'Planteary Boundary Layer Height Heffter'} + da = xr.DataArray(pbl, attrs=atts) + ds['pblht_heffter'] = da + + atts = {'units': 'mb', 'long_name': 'Gridded pressure'} + da = xr.DataArray(pres, coords={'atm_pres_ss': pres}, dims=['atm_pres_ss'], attrs=atts) + ds['atm_pres_ss'] = da + + atts = {'units': 'K', 'long_name': 'Gridded potential temperature'} + da = xr.DataArray(theta, coords={'atm_pres_ss': pres}, dims=['atm_pres_ss'], attrs=atts) + ds['potential_temperature_ss'] = da + + atts = {'units': 'm', 'long_name': 'Gridded altitude'} + da = xr.DataArray(alt, coords={'atm_pres_ss': pres}, dims=['atm_pres_ss'], attrs=atts) + ds['alt_ss'] = da + + atts = {'units': 'm', 'long_name': 'Bottom height of inversion layers'} + da = xr.DataArray(bottom_inversion, coords={'layers': list(range(len(bottom_inversion)))}, dims=['layers'], attrs=atts) + ds['bottom_inversion'] = da + + atts = {'units': 'm', 'long_name': 'Top height of inversion layers'} + da = xr.DataArray(top_inversion, coords={'layers': list(range(len(top_inversion)))}, dims=['layers'], attrs=atts) + ds['top_inversion'] = da + + return ds + + +def preprocess_sonde_data( + ds, + temperature='tdry', + pressure='pres', + height='alt', + smooth_height=3, + base=5., +): + """ + Function for processing the SONDE data for the PBL calculations. + This is to ensure consistency and also applies some QC to the + processing. + + Parameters + ---------- + ds : xarray Dataset + Dataset housing radiosonde profile for calculations + temperature : str + The name of the temperature field. + pressure : str + The name of the pressure field. + height : str + The name of the height field + smooth_height : int + Number of points to do a moving average on sounding height data to reduce noise + base : int + Interval for pressure gridding. In testing, 5 mb was found to produce results with + the lowest RMS + + Returns + ------- + ds : xarray.Dataset + Xarray dataset containing processed sonde data. + + References + ---------- + Sivaraman, C., S. McFarlane, E. Chapman, M. Jensen, T. Toto, S. Liu, and M. Fischer. + "Planetary boundary layer (PBL) height value added product (VAP): Radiosonde retrievals." + Department of Energy Office of Science Atmospheric Radiation Measurement (ARM) Program + (United States) (2013). + + """ + + # Get the initial time and temp values + time_0 = ds['time'].values + temp_0 = ds[temperature].values + + # Apply a rolling average to smooth the pressure out + ds[pressure] = ds[pressure].rolling(time=smooth_height, min_periods=1, center=True).mean() + + # Swap time and pressure for doing the appropriate gridding + ds2 = ds.swap_dims(dims_dict={'time': pressure}) + for var in ds2: + ds2[var].attrs = ds2[var].attrs + + # Set up the pressure grid + starting_pres = base * np.ceil(float(ds2[pressure].values[2]) / base) + p_grid = np.flip(np.arange(100.0, starting_pres + base, base)) + + # Pull out the data that's nearest to the pressure grid. If it errors + # it will smooth the data more. This tends to happen if there are multiple + # values of pressure that are the same + try: + ds2 = ds2.sel({pressure: p_grid}, method='nearest') + except Exception: + ds[pressure] = ( + ds[pressure].rolling(time=smooth_height + 4, min_periods=2, center=True).mean() + ) + ds2 = ds.swap_dims(dims_dict={'time': pressure}) + for var in ds2: + ds2[var].attrs = ds[var].attrs + try: + ds2 = ds2.sel({pressure: p_grid}, method='nearest') + except Exception: + raise ValueError('Sonde profile does not have unique pressures after smoothing') + + # Get data + alt = ds2[height].values + pres = ds2[pressure].values + temp = ds2[temperature].values + + # Perform Pre-processing checks + if len(temp) == 0.: + raise ValueError('No data in profile') + + if np.nanmax(alt) < 1000.0: + raise ValueError('Max altitude < 1000m') + + if np.nanmax(pres) <= 200.0: + raise ValueError('Max pressure <= 200 hPa') + + # Check temperature delta + t1 = time_0[0] + t2 = t1 + np.timedelta64(10, 's') + idx = np.where((time_0 >= t1) & (time_0 <= t2))[0] + t_delta = abs(temp_0[idx[-1]] - temp_0[idx[0]]) + if t_delta > 30.0: + raise ValueError('Temperature changes by >30Âē in first 10 seconds') + + # Check min/max + if np.nanmax(temp) > 50.0 or np.nanmin(temp) < -90: + raise ValueError('Temperature outside acceptable range (-90, 50)') + + if np.isnan(pres[0]) or np.isnan(pres[1]): + raise ValueError('First two pressure values bad') + + # Calculate potential temperature and subsequent gradients + theta = ( + convert_to_potential_temp(ds=ds2, temp_var_name=temperature, press_var_name=pressure) + + 273.15 + ) + + # Set variables to return + atts = {'units': 'K', 'long_name': 'Potential temperature'} + da = xr.DataArray(theta, coords=ds2['tdry'].coords, dims=ds2[temperature].dims, attrs=atts) + ds2['potential_temperature'] = da + + return ds2 diff --git a/act/retrievals/sp2.py b/act/retrievals/sp2.py new file mode 100644 index 0000000000..89461d8f34 --- /dev/null +++ b/act/retrievals/sp2.py @@ -0,0 +1,70 @@ +try: + import pysp2 + + PYSP2_AVAILABLE = True +except ImportError: + PYSP2_AVAILABLE = False + + +def calc_sp2_diams_masses(ds, debug=True, factor=1.0, Globals=None): + """ + Calculates the scattering and incandescence diameters/BC masses for each particle. + + Parameters + ---------- + ds : xarray.Dataset + The ACT xarray dataset containing the processed SP2 data. + debug : boolean + If true, print out particle rejection statistics + factor : float + Multiply soot masses by this factor for AquaDag calibation. Use + 1.3 for NSA. + Globals : act.qc.SP2ParticleCriteria structure or None + DMTGlobals structure containing calibration coefficients. Set to + None to use default values for MOSAiC. + + Returns + ------- + diam_ds : xarray.Dataset + The ACT xarray dataset containing the scattering/incadescence diameters. + """ + if PYSP2_AVAILABLE: + return pysp2.util.calc_diams_masses(ds, debug, factor, Globals) + else: + raise ModuleNotFoundError('PySP2 needs to be installed to use this feature.') + + +def process_sp2_psds( + particle_ds, hk_ds, config_file, deltaSize=0.005, num_bins=199, avg_interval=10 +): + """ + Processes the Scattering and BC mass size distributions. + + Parameters + ---------- + particle_ds : xarray.Dataset + The xarray Dataset containing the particle statistics generated by + act.retrievals.calc_sp2_diams_masses. + hk_ds : xarray.Dataset + The xarray Dataset containing the housekeeping variables + config_file : file_name + Path to the .INI file. + deltaSize : float + The size distribution bin width in microns. + num_bins : int + The number of size bins + avg_interval : int + The time in seconds to average the concentrations into. + + Returns + ------- + psd_ds: xarray.Dataset + The xarray Dataset containing the time-averaged particle statistics. + """ + if PYSP2_AVAILABLE: + config = pysp2.io.read_config(config_file) + return pysp2.util.process_psds( + particle_ds, hk_ds, config, deltaSize, num_bins, avg_interval + ) + else: + raise ModuleNotFoundError('PySP2 needs to be installed to use this feature.') diff --git a/act/retrievals/stability_indices.py b/act/retrievals/stability_indices.py deleted file mode 100644 index 6afc57d5fe..0000000000 --- a/act/retrievals/stability_indices.py +++ /dev/null @@ -1,156 +0,0 @@ -""" -act.retrievals.stability_indices --------------------------------- - -Module that adds stability indicies to a dataset. - -""" -import warnings -import numpy as np - -try: - from pkg_resources import DistributionNotFound - import metpy.calc as mpcalc - METPY_AVAILABLE = True -except ImportError: - METPY_AVAILABLE = False -except (ModuleNotFoundError, DistributionNotFound): - warnings.warn("MetPy is installed but could not be imported. " + - "Please check your MetPy installation. Some features " + - "will be disabled.", ImportWarning) - METPY_AVAILABLE = False - -if METPY_AVAILABLE: - from metpy.units import units - - -def calculate_stability_indicies(ds, temp_name="temperature", - td_name="dewpoint_temperature", - p_name="pressure", - moving_ave_window=0): - """ - Function for calculating stability indices from sounding data. - - Parameters - ---------- - ds : ACT dataset - The dataset to compute the stability indicies of. Must have - temperature, dewpoint, and pressure in vertical coordinates. - temp_name : str - The name of the temperature field. - td_name : str - The name of the dewpoint field. - p_name : str - The name of the pressure field. - moving_ave_window : int - Number of points to do a moving average on sounding data to reduce - noise. This is useful if noise in the sounding is preventing parcel - ascent. - - Returns - ------- - ds : ACT dataset - An ACT dataset with additional stability indicies added. - - """ - if not METPY_AVAILABLE: - raise ImportError("MetPy need to be installed on your system to " + - "calculate stability indices") - - t = ds[temp_name] - td = ds[td_name] - p = ds[p_name] - - if not hasattr(t, "units"): - raise AttributeError("Temperature field must have units" + - " for ACT to discern!") - - if not hasattr(td, "units"): - raise AttributeError("Dewpoint field must have units" + - " for ACT to discern!") - - if not hasattr(p, "units"): - raise AttributeError("Pressure field must have units" + - " for ACT to discern!") - if t.units == "C": - t_units = units.degC - else: - t_units = getattr(units, t.units) - - if td.units == "C": - td_units = units.degC - else: - td_units = getattr(units, td.units) - - p_units = getattr(units, p.units) - - # Sort all values by decreasing pressure - t_sorted = np.array(t.values) - td_sorted = np.array(td.values) - p_sorted = np.array(p.values) - ind_sort = np.argsort(p_sorted) - t_sorted = t_sorted[ind_sort[-1:0:-1]] - td_sorted = td_sorted[ind_sort[-1:0:-1]] - p_sorted = p_sorted[ind_sort[-1:0:-1]] - - if moving_ave_window > 0: - t_sorted = np.convolve( - t_sorted, np.ones((moving_ave_window,)) / moving_ave_window) - td_sorted = np.convolve( - td_sorted, np.ones((moving_ave_window,)) / moving_ave_window) - p_sorted = np.convolve( - p_sorted, np.ones((moving_ave_window,)) / moving_ave_window) - - t_sorted = t_sorted * t_units - td_sorted = td_sorted * td_units - p_sorted = p_sorted * p_units - - t_profile = mpcalc.parcel_profile( - p_sorted, t_sorted[0], td_sorted[0]) - - # Calculate parcel trajectory - ds["parcel_temperature"] = t_profile.magnitude - ds["parcel_temperature"].attrs['units'] = t_profile.units - - # Calculate CAPE, CIN, LCL - sbcape, sbcin = mpcalc.surface_based_cape_cin( - p_sorted, t_sorted, td_sorted) - lcl = mpcalc.lcl( - p_sorted[0], t_sorted[0], td_sorted[0]) - try: - lfc = mpcalc.lfc( - p_sorted[0], t_sorted[0], td_sorted[0]) - except IndexError: - lfc = np.nan * p_sorted.units - - mucape, mucin = mpcalc.most_unstable_cape_cin( - p_sorted, t_sorted, td_sorted) - - where_500 = np.argmin(np.abs(p_sorted - 500 * units.hPa)) - li = t_sorted[where_500] - t_profile[where_500] - - ds["surface_based_cape"] = sbcape.magnitude - ds["surface_based_cape"].attrs['units'] = "J/kg" - ds["surface_based_cape"].attrs['long_name'] = "Surface-based CAPE" - ds["surface_based_cin"] = sbcin.magnitude - ds["surface_based_cin"].attrs['units'] = "J/kg" - ds["surface_based_cin"].attrs['long_name'] = "Surface-based CIN" - ds["most_unstable_cape"] = mucape.magnitude - ds["most_unstable_cape"].attrs['units'] = "J/kg" - ds["most_unstable_cape"].attrs['long_name'] = "Most unstable CAPE" - ds["most_unstable_cin"] = mucin.magnitude - ds["most_unstable_cin"].attrs['units'] = "J/kg" - ds["most_unstable_cin"].attrs['long_name'] = "Most unstable CIN" - ds["lifted_index"] = li.magnitude - ds["lifted_index"].attrs['units'] = t_profile.units - ds["lifted_index"].attrs['long_name'] = "Lifted index" - ds["level_of_free_convection"] = lfc.magnitude - ds["level_of_free_convection"].attrs['units'] = lfc.units - ds["level_of_free_convection"].attrs['long_name'] = "Level of free convection" - ds["lifted_condensation_level_temperature"] = lcl[1].magnitude - ds["lifted_condensation_level_temperature"].attrs['units'] = lcl[1].units - ds["lifted_condensation_level_temperature"].attrs['long_name'] = "Lifted condensation level temperature" - ds["lifted_condensation_level_pressure"] = lcl[0].magnitude - ds["lifted_condensation_level_pressure"].attrs['units'] = lcl[0].units - ds["lifted_condensation_level_pressure"].attrs['long_name'] = "Lifted condensation level pressure" - return ds diff --git a/act/tests/__init__.py b/act/tests/__init__.py index ba510fae3f..9ae16bd6a3 100644 --- a/act/tests/__init__.py +++ b/act/tests/__init__.py @@ -1,32 +1,66 @@ """ -===================== -act.tests (act.tests) -===================== - -.. currentmodule:: act.tests - This module contains sample files used for testing the ARM Community Toolkit. Files in this module should only be used for testing, not production. -.. autosummary:: - :toctree: generated/ - - EXAMPLE_SONDE1 - EXAMPLE_LCL1 - EXAMPLE_SONDE_WILDCARD """ +import lazy_loader as lazy -from .sample_files import (EXAMPLE_SONDE1, EXAMPLE_LCL1, EXAMPLE_MET_CSV, - EXAMPLE_SONDE_WILDCARD, EXAMPLE_MET1, - EXAMPLE_METE40, EXAMPLE_TWP_SONDE_20060121, - EXAMPLE_MET_WILDCARD, EXAMPLE_CEIL1, - EXAMPLE_CEIL_WILDCARD, EXAMPLE_ANL_CSV, - EXAMPLE_MPL_1SAMPLE, EXAMPLE_IRT25m20s, - EXAMPLE_MET_CONTOUR, EXAMPLE_NAV, - EXAMPLE_AOSMET, EXAMPLE_DLPPI, EXAMPLE_EBBR1, - EXAMPLE_EBBR2, EXAMPLE_BRS, EXAMPLE_AERI, - EXAMPLE_MFRSR, EXAMPLE_SURFSPECALB1MLAWER, - EXAMPLE_SIGMA_MPLV5, EXAMPLE_RL1, - EXAMPLE_CO2FLX4M, EXAMPLE_SIRS, EXAMPLE_IRTSST, - EXAMPLE_MET_TEST1, EXAMPLE_MET_TEST2, - EXAMPLE_STAMP_WILDCARD) +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=['sample_files'], + submod_attrs={ + 'sample_files': [ + 'EXAMPLE_AERI', + 'EXAMPLE_AAF_ICARTT', + 'EXAMPLE_ANL_CSV', + 'EXAMPLE_AOSMET', + 'EXAMPLE_BRS', + 'EXAMPLE_CEIL1', + 'EXAMPLE_CEIL_WILDCARD', + 'EXAMPLE_CO2FLX4M', + 'EXAMPLE_DLPPI', + 'EXAMPLE_EBBR1', + 'EXAMPLE_EBBR2', + 'EXAMPLE_EBBR3', + 'EXAMPLE_IRTSST', + 'EXAMPLE_LCL1', + 'EXAMPLE_MET1', + 'EXAMPLE_MET_CONTOUR', + 'EXAMPLE_MET_CSV', + 'EXAMPLE_MET_TEST1', + 'EXAMPLE_MET_TEST2', + 'EXAMPLE_MET_WILDCARD', + 'EXAMPLE_MET_SAIL', + 'EXAMPLE_METE40', + 'EXAMPLE_MFRSR', + 'EXAMPLE_MMCR', + 'EXAMPLE_MPL_1SAMPLE', + 'EXAMPLE_NAV', + 'EXAMPLE_NEON', + 'EXAMPLE_NEON_VARIABLE', + 'EXAMPLE_NEON_POSITION', + 'EXAMPLE_NOAA_PSL', + 'EXAMPLE_NOAA_PSL_TEMPERATURE', + 'EXAMPLE_RL1', + 'EXAMPLE_SIGMA_MPLV5', + 'EXAMPLE_SIRS', + 'EXAMPLE_MFAS_SODAR', + 'EXAMPLE_SONDE1', + 'EXAMPLE_SONDE_WILDCARD', + 'EXAMPLE_STAMP_WILDCARD', + 'EXAMPLE_SURFSPECALB1MLAWER', + 'EXAMPLE_TWP_SONDE_20060121', + 'EXAMPLE_IRT25m20s', + 'EXAMPLE_HK', + 'EXAMPLE_INI', + 'EXAMPLE_SP2B', + 'EXAMPLE_MET_YAML', + 'EXAMPLE_CLOUDPHASE' + 'EXAMPLE_ECOR', + 'EXAMPLE_SEBS', + 'EXAMPLE_ENA_MET', + 'EXAMPLE_CCN', + 'EXAMPLE_OLD_QC', + ] + }, +) diff --git a/act/tests/baseline/test_2D_timeseries_plot.png b/act/tests/baseline/test_2D_timeseries_plot.png deleted file mode 100644 index 9cd2e5c8dd..0000000000 Binary files a/act/tests/baseline/test_2D_timeseries_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_2d_as_1d.png b/act/tests/baseline/test_2d_as_1d.png deleted file mode 100644 index 974430a033..0000000000 Binary files a/act/tests/baseline/test_2d_as_1d.png and /dev/null differ diff --git a/act/tests/baseline/test_assessment_overplot.png b/act/tests/baseline/test_assessment_overplot.png deleted file mode 100644 index fb67f04ae6..0000000000 Binary files a/act/tests/baseline/test_assessment_overplot.png and /dev/null differ diff --git a/act/tests/baseline/test_assessment_overplot_multi.png b/act/tests/baseline/test_assessment_overplot_multi.png deleted file mode 100644 index dfcb33c658..0000000000 Binary files a/act/tests/baseline/test_assessment_overplot_multi.png and /dev/null differ diff --git a/act/tests/baseline/test_barb_sounding_plot.png b/act/tests/baseline/test_barb_sounding_plot.png deleted file mode 100644 index c79288b69b..0000000000 Binary files a/act/tests/baseline/test_barb_sounding_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_fill_between.png b/act/tests/baseline/test_fill_between.png deleted file mode 100644 index 5708721531..0000000000 Binary files a/act/tests/baseline/test_fill_between.png and /dev/null differ diff --git a/act/tests/baseline/test_geoplot.png b/act/tests/baseline/test_geoplot.png deleted file mode 100644 index 6d42bc13e0..0000000000 Binary files a/act/tests/baseline/test_geoplot.png and /dev/null differ diff --git a/act/tests/baseline/test_heatmap.png b/act/tests/baseline/test_heatmap.png deleted file mode 100644 index f7a7a251aa..0000000000 Binary files a/act/tests/baseline/test_heatmap.png and /dev/null differ diff --git a/act/tests/baseline/test_multi_skewt_plot.png b/act/tests/baseline/test_multi_skewt_plot.png deleted file mode 100644 index 4f222a56b8..0000000000 Binary files a/act/tests/baseline/test_multi_skewt_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_multidataset_plot_dict.png b/act/tests/baseline/test_multidataset_plot_dict.png deleted file mode 100644 index f7856a5fa1..0000000000 Binary files a/act/tests/baseline/test_multidataset_plot_dict.png and /dev/null differ diff --git a/act/tests/baseline/test_multidataset_plot_tuple.png b/act/tests/baseline/test_multidataset_plot_tuple.png deleted file mode 100644 index 0be93f1a15..0000000000 Binary files a/act/tests/baseline/test_multidataset_plot_tuple.png and /dev/null differ diff --git a/act/tests/baseline/test_plot.png b/act/tests/baseline/test_plot.png deleted file mode 100644 index 4ab502ff5a..0000000000 Binary files a/act/tests/baseline/test_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_plot_barbs_from_u_v.png b/act/tests/baseline/test_plot_barbs_from_u_v.png deleted file mode 100644 index 0ac3c275a4..0000000000 Binary files a/act/tests/baseline/test_plot_barbs_from_u_v.png and /dev/null differ diff --git a/act/tests/baseline/test_plot_barbs_from_u_v2.png b/act/tests/baseline/test_plot_barbs_from_u_v2.png deleted file mode 100644 index 35feaa0f4a..0000000000 Binary files a/act/tests/baseline/test_plot_barbs_from_u_v2.png and /dev/null differ diff --git a/act/tests/baseline/test_qc_bar_plot.png b/act/tests/baseline/test_qc_bar_plot.png deleted file mode 100644 index 9aa36b8d0a..0000000000 Binary files a/act/tests/baseline/test_qc_bar_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_qc_flag_block_plot.png b/act/tests/baseline/test_qc_flag_block_plot.png deleted file mode 100644 index fa3e328303..0000000000 Binary files a/act/tests/baseline/test_qc_flag_block_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_skewt_plot.png b/act/tests/baseline/test_skewt_plot.png deleted file mode 100644 index 3fc8d67b0f..0000000000 Binary files a/act/tests/baseline/test_skewt_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_skewt_plot_spd_dir.png b/act/tests/baseline/test_skewt_plot_spd_dir.png deleted file mode 100644 index 3fc8d67b0f..0000000000 Binary files a/act/tests/baseline/test_skewt_plot_spd_dir.png and /dev/null differ diff --git a/act/tests/baseline/test_time_height_scatter.png b/act/tests/baseline/test_time_height_scatter.png deleted file mode 100644 index f115adadb0..0000000000 Binary files a/act/tests/baseline/test_time_height_scatter.png and /dev/null differ diff --git a/act/tests/baseline/test_xsection_plot.png b/act/tests/baseline/test_xsection_plot.png deleted file mode 100644 index 167de71687..0000000000 Binary files a/act/tests/baseline/test_xsection_plot.png and /dev/null differ diff --git a/act/tests/baseline/test_xsection_plot_map.png b/act/tests/baseline/test_xsection_plot_map.png deleted file mode 100644 index 76413c84e7..0000000000 Binary files a/act/tests/baseline/test_xsection_plot_map.png and /dev/null differ diff --git a/act/tests/data/201509021500.bi b/act/tests/data/201509021500.bi deleted file mode 100644 index 74fd4c5b5a..0000000000 Binary files a/act/tests/data/201509021500.bi and /dev/null differ diff --git a/act/tests/data/anltwr_mar19met.data b/act/tests/data/anltwr_mar19met.data deleted file mode 100644 index b079b7c02c..0000000000 --- a/act/tests/data/anltwr_mar19met.data +++ /dev/null @@ -1,50 +0,0 @@ - 1 3 19 0030 E 28.6 1.9 17.1 -5.0 16.9 1.4 16.3 -4.8 -8.1 80.2 -0.3 0.0 0.00 -10.70 99.80 0.33 -0.6 3.1 7.1 - 1 3 19 0130 E 36.0 1.8 7.3 -4.9 22.7 1.4 16.4 -4.7 -8.2 78.9 -0.3 0.0 0.00 -15.30 99.78 0.33 -0.6 3.1 7.1 - 1 3 19 0230 E 24.1 2.8 8.0 -4.8 19.1 1.9 14.8 -4.6 -8.2 78.2 -0.5 0.0 0.00 -7.70 99.77 0.33 -0.6 3.1 7.1 - 1 3 19 0330 E 26.4 2.6 13.7 -4.8 29.8 1.9 16.0 -4.5 -8.4 76.0 -0.7 0.0 0.00 -10.30 99.77 0.32 -0.6 3.1 7.1 - 1 3 19 0430 E 39.7 2.2 10.7 -4.7 40.3 1.7 15.0 -4.3 -8.9 72.8 -0.6 0.0 0.00 -9.10 99.78 0.31 -0.6 3.1 7.1 - 1 3 19 0530 E 40.5 2.5 8.9 -4.5 36.6 2.0 13.3 -4.2 -8.9 71.3 -0.6 0.0 0.00 -8.20 99.79 0.31 -0.6 3.1 7.1 - 1 3 19 0630 D 32.0 2.2 10.8 -4.4 22.0 1.6 20.1 -4.1 -8.7 72.1 -0.6 0.0 3.10 -5.90 99.82 0.32 -0.6 3.1 7.1 - 1 3 19 0730 D 39.7 2.6 14.8 -4.2 41.0 2.2 17.3 -3.7 -8.4 71.5 -0.9 0.0 36.70 16.70 99.82 0.33 -0.6 3.1 7.1 - 1 3 19 0830 C 83.2 2.5 12.4 -3.6 91.4 2.3 14.7 -3.0 -7.5 72.5 -1.1 0.0 95.20 52.80 99.87 0.35 -0.6 3.1 7.1 - 1 3 19 0930 C 81.6 2.4 15.6 -2.8 87.8 2.1 21.0 -2.2 -6.4 73.8 -1.2 0.0 188.60 110.40 99.88 0.38 -0.6 3.1 7.1 - 1 3 19 1030 C 103.4 2.5 21.2 -1.7 107.2 2.6 24.3 -1.0 -5.4 72.2 -1.3 0.0 333.60 201.60 99.91 0.41 -0.6 3.1 7.1 - 1 3 19 1130 B 79.5 2.4 22.0 -0.9 78.8 2.3 28.3 -0.2 -5.1 69.1 -1.4 0.0 362.60 220.10 99.94 0.42 -0.6 3.2 7.1 - 1 3 19 1230 B 68.5 2.7 21.0 -0.2 77.0 2.6 23.2 0.5 -4.7 67.1 -1.5 0.0 394.80 239.80 99.90 0.43 -0.6 3.2 7.1 - 1 3 19 1330 B 70.4 3.2 15.6 0.3 72.1 2.9 21.7 1.0 -4.3 66.8 -1.5 0.0 422.60 253.70 99.82 0.45 -0.6 3.2 7.1 - 1 3 19 1430 B 73.5 3.7 15.8 0.6 77.7 3.2 18.4 1.3 -4.3 65.3 -1.5 0.0 403.70 229.90 99.76 0.45 -0.5 3.2 7.1 - 1 3 19 1530 C 76.8 3.1 15.6 0.6 87.2 2.9 17.5 1.3 -4.7 63.3 -1.4 0.0 299.20 151.80 99.76 0.43 -0.6 3.2 7.1 - 1 3 19 1630 C 77.2 3.1 14.6 0.5 81.2 2.8 16.0 1.1 -5.0 63.3 -1.2 0.0 187.70 68.70 99.76 0.42 -0.6 3.2 7.1 - 1 3 19 1730 D 59.7 3.2 8.4 -0.3 66.1 2.4 13.1 0.0 -5.3 66.5 -0.7 0.0 25.40 -36.50 99.73 0.41 -0.6 3.2 7.1 - 1 3 19 1830 D 63.9 4.1 6.7 -1.1 70.3 2.5 11.0 -0.9 -5.3 71.6 -0.3 0.0 0.00 -56.20 99.70 0.41 -0.6 3.2 7.1 - 1 3 19 1930 D 71.8 4.1 6.3 -1.6 79.7 2.8 8.5 -1.4 -5.2 75.2 -0.6 0.0 0.00 -19.20 99.68 0.42 -0.6 3.2 7.1 - 1 3 19 2030 D 84.2 3.5 8.7 -1.9 94.9 2.5 9.7 -1.6 -5.0 77.4 -0.7 0.0 0.00 -11.70 99.66 0.42 -0.6 3.1 7.1 - 1 3 19 2130 E 79.5 2.7 15.6 -1.9 80.6 2.1 15.0 -1.4 -4.9 77.4 -0.8 0.0 0.00 -7.30 99.66 0.43 -0.6 3.2 7.1 - 1 3 19 2230 E 63.3 1.7 12.4 -1.7 69.9 1.6 16.7 -1.4 -5.0 76.4 -0.8 0.0 0.00 -8.00 99.67 0.42 -0.6 3.2 7.1 - 1 3 19 2330 E 71.4 2.4 11.1 -1.6 80.6 1.9 14.7 -1.4 -4.7 78.1 -0.6 0.0 0.00 -8.90 99.63 0.43 -0.6 3.2 7.1 - 1 3 19 2400 X 63.2 2.7 11.5 -2.3 68.4 2.2 17.4 -1.8 -6.3 72.4 -0.9 0.0 114.70 55.40 99.78 0.39 -0.6 3.1 7.1 - 2 3 19 0030 D 85.9 2.7 5.2 -1.7 92.4 1.8 9.9 -1.4 -4.4 80.6 -0.5 0.0 0.00 -7.50 99.61 0.44 -0.6 3.2 7.1 - 2 3 19 0130 F 57.3 2.0 12.3 -1.5 51.0 1.4 22.9 -1.3 -4.2 80.3 -0.5 0.0 0.00 -9.40 99.63 0.45 -0.6 3.2 7.1 - 2 3 19 0230 F 10.9 2.5 15.2 -1.6 1.5 1.5 20.1 -1.3 -4.1 80.9 -0.5 0.0 0.00 -9.80 99.60 0.45 -0.6 3.2 7.1 - 2 3 19 0330 F 3.4 2.5 10.5 -2.0 3.2 1.6 18.0 -1.6 -4.1 82.5 -0.8 0.0 0.00 -9.60 99.56 0.45 -0.6 3.2 7.1 - 2 3 19 0430 F 348.8 2.6 14.1 -2.3 348.6 1.8 19.2 -1.9 -4.3 84.0 -0.9 0.0 0.00 -9.10 99.61 0.45 -0.6 3.1 7.1 - 2 3 19 0530 D 336.7 4.4 8.3 -2.7 333.7 3.0 15.0 -2.2 -4.2 86.5 -1.0 0.0 0.00 -8.40 99.70 0.45 -0.6 3.1 7.0 - 2 3 19 0630 D 333.9 4.3 10.3 -3.1 333.3 3.0 15.4 -2.6 -4.0 91.4 -1.0 0.0 2.30 -5.10 99.77 0.46 -0.6 3.1 7.1 - 2 3 19 0730 D 325.8 5.1 9.3 -3.0 322.4 3.7 14.3 -2.5 -4.3 88.2 -0.9 0.0 38.40 16.70 99.86 0.44 -0.6 3.2 7.1 - 2 3 19 0830 C 327.9 5.5 9.9 -2.9 327.7 4.1 16.8 -2.3 -5.1 81.9 -1.1 0.0 145.30 80.20 99.92 0.42 -0.6 3.2 7.1 - 2 3 19 0930 C 352.0 5.3 13.8 -2.6 352.4 3.7 20.6 -1.9 -6.1 73.6 -1.4 0.0 263.20 153.90 99.96 0.39 -0.6 3.2 7.1 - 2 3 19 1030 B 348.0 4.2 16.3 -2.3 350.3 3.2 24.0 -1.5 -6.2 70.4 -1.6 0.0 358.10 210.10 100.06 0.39 -0.6 3.2 7.1 - 2 3 19 1130 B 351.3 3.7 24.0 -1.9 355.9 3.1 30.0 -1.1 -6.4 67.2 -1.6 0.0 471.00 277.90 100.12 0.38 -0.5 3.2 7.1 - 2 3 19 1230 B 335.6 4.0 17.0 -1.3 332.9 3.5 22.1 -0.4 -6.7 62.0 -1.7 0.0 449.80 269.10 100.19 0.37 -0.5 3.2 7.1 - 2 3 19 1330 B 338.7 4.0 20.7 -1.0 344.5 3.5 29.1 -0.3 -7.3 58.5 -1.4 0.0 443.20 255.90 100.18 0.35 -0.5 3.2 7.1 - 2 3 19 1430 C 352.3 3.7 19.9 -1.0 352.4 3.1 24.9 -0.2 -8.0 55.0 -1.6 0.0 320.60 178.60 100.17 0.34 -0.5 3.2 7.1 - 2 3 19 1530 C 9.2 3.6 17.9 -1.0 17.3 2.8 25.8 -0.2 -8.1 54.8 -1.4 0.0 223.30 113.60 100.14 0.33 -0.5 3.2 7.1 - 2 3 19 1630 C 18.9 3.1 21.4 -1.2 30.6 2.7 21.9 -0.6 -8.0 56.8 -1.1 0.0 99.20 36.00 100.12 0.34 -0.6 3.2 7.1 - 2 3 19 1730 D 38.6 3.7 12.2 -2.0 44.2 3.1 15.5 -1.6 -7.4 64.7 -0.9 0.0 13.70 -20.60 100.09 0.35 -0.6 3.2 7.1 - 2 3 19 1830 D 41.1 3.7 8.7 -2.6 42.0 3.0 14.3 -2.2 -6.8 71.2 -0.8 0.0 0.00 -34.50 100.05 0.37 -0.6 3.2 7.0 - 2 3 19 1930 D 42.0 3.4 10.5 -3.0 45.6 2.6 14.6 -2.6 -6.3 76.3 -0.8 0.0 0.00 -37.00 100.06 0.38 -0.6 3.2 7.0 - 2 3 19 2030 E 35.6 3.1 9.9 -3.2 38.8 2.1 15.7 -2.9 -7.2 73.0 -0.5 0.0 0.00 -47.30 100.04 0.36 -0.6 3.2 7.0 - 2 3 19 2130 F 14.9 2.7 9.4 -3.3 5.3 1.4 21.4 -3.0 -7.3 73.3 -0.4 0.0 0.00 -25.70 100.05 0.35 -0.6 3.2 7.0 - 2 3 19 2230 D 351.5 2.9 12.1 -3.3 339.4 1.6 12.5 -3.2 -7.4 73.5 -0.2 0.0 0.00 -31.00 100.04 0.35 -0.6 3.1 7.0 - 2 3 19 2330 D 329.4 2.9 5.8 -3.5 319.7 1.7 12.1 -3.3 -7.2 75.3 -0.4 0.0 0.00 -18.60 100.01 0.36 -0.6 3.1 7.0 - 2 3 19 2400 X 358.8 3.6 12.0 -2.2 359.5 2.6 19.7 -1.8 -6.1 73.4 -1.0 0.0 117.80 54.90 99.94 0.39 -0.6 3.2 7.1 diff --git a/act/tests/data/brw21001.dat b/act/tests/data/brw21001.dat deleted file mode 100644 index 4ac35acc84..0000000000 --- a/act/tests/data/brw21001.dat +++ /dev/null @@ -1,20 +0,0 @@ - Barrow - 71.316 -156.600 11 m - 2021 1 1 1 0 0 0.000 95.60 -1.5 0 -0.7 0 0.4 0 0.0 0 139.8 0 246.15 0 245.91 0 209.5 0 246.15 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -69.6 0 -69.6 0 -28.2 0 78.6 0 6.8 0 78.1 0 1020.1 0 - 2021 1 1 1 0 1 0.017 95.62 -1.5 0 -0.7 0 0.4 0 0.0 0 139.8 0 246.15 0 245.91 0 209.5 0 246.15 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -69.7 0 -69.7 0 -28.2 0 78.6 0 6.5 0 77.8 0 1020.1 0 - 2021 1 1 1 0 2 0.033 95.65 -1.5 0 -0.8 0 0.3 0 0.0 0 139.4 0 246.15 0 245.91 0 209.8 0 246.18 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -70.5 0 -70.4 0 -28.3 0 78.8 0 6.8 0 77.2 0 1020.1 0 - 2021 1 1 1 0 3 0.050 95.68 -1.5 0 -0.8 0 0.3 0 0.0 0 139.6 0 246.15 0 245.88 0 210.0 0 246.19 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -70.4 0 -70.4 0 -28.3 0 79.2 0 6.2 0 76.1 0 1020.1 0 - 2021 1 1 1 0 4 0.067 95.71 -1.5 0 -0.8 0 0.4 0 0.0 0 139.5 0 246.15 0 245.84 0 210.0 0 246.19 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -70.5 0 -70.4 0 -28.4 0 79.2 0 6.1 0 75.3 0 1020.0 0 - 2021 1 1 1 0 5 0.083 95.74 -1.5 0 -0.9 0 0.3 0 0.0 0 139.4 0 246.14 0 245.81 0 210.0 0 246.19 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -70.6 0 -70.6 0 -28.4 0 79.1 0 6.3 0 74.7 0 1019.9 0 - 2021 1 1 1 0 6 0.100 95.77 -1.5 0 -0.9 0 0.1 0 -0.1 0 139.3 0 246.11 0 245.77 0 210.3 0 246.21 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -71.0 0 -71.0 0 -28.5 0 79.0 0 6.9 0 74.7 0 1019.9 0 - 2021 1 1 1 0 7 0.117 95.80 -1.5 0 -0.9 0 0.2 0 -0.1 0 139.6 0 246.10 0 245.75 0 210.3 0 246.22 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -70.7 0 -70.7 0 -28.5 0 79.3 0 7.1 0 74.5 0 1019.8 0 - 2021 1 1 1 0 8 0.133 95.83 -1.5 0 -0.9 0 0.4 0 -0.1 0 142.4 0 246.07 0 245.75 0 210.4 0 246.22 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -68.0 0 -68.0 0 -28.4 0 78.4 0 6.6 0 74.3 0 1019.8 0 - 2021 1 1 1 0 9 0.150 95.86 -1.5 0 -0.9 0 0.4 0 -0.1 0 146.6 0 246.07 0 245.75 0 210.5 0 246.22 0 246.03 0 -9999.9 2 -9999.9 1 0.0 0 -63.9 0 -63.9 0 -28.4 0 77.7 0 6.8 0 74.2 0 1019.8 0 - 2021 1 1 1 0 10 0.167 95.89 -1.5 0 -0.9 0 0.4 0 -0.1 0 146.6 0 246.04 0 245.75 0 210.2 0 246.22 0 246.05 0 -9999.9 2 -9999.9 1 0.0 0 -63.6 0 -63.6 0 -28.3 0 77.9 0 6.7 0 74.2 0 1019.8 0 - 2021 1 1 1 0 11 0.183 95.92 -1.5 0 -0.9 0 0.4 0 -0.1 0 146.7 0 246.03 0 245.75 0 210.1 0 246.23 0 246.07 0 -9999.9 2 -9999.9 1 0.0 0 -63.4 0 -63.4 0 -28.3 0 77.7 0 6.8 0 74.1 0 1019.8 0 - 2021 1 1 1 0 12 0.200 95.95 -1.5 0 -0.9 0 0.4 0 0.0 0 148.8 0 246.03 0 245.78 0 210.1 0 246.23 0 246.07 0 -9999.9 2 -9999.9 1 0.0 0 -61.3 0 -61.3 0 -28.2 0 77.8 0 7.2 0 74.7 0 1019.8 0 - 2021 1 1 1 0 13 0.217 95.99 -1.5 0 -0.8 0 0.4 0 0.0 0 149.1 0 246.03 0 245.82 0 209.9 0 246.23 0 246.09 0 -9999.9 2 -9999.9 1 0.0 0 -60.8 0 -60.8 0 -28.1 0 77.2 0 6.5 0 75.0 0 1019.8 0 - 2021 1 1 1 0 14 0.233 96.02 -1.5 0 -0.8 0 1.0 0 0.0 0 151.8 0 246.03 0 245.87 0 209.6 0 246.23 0 246.13 0 -9999.9 2 -9999.9 1 0.0 0 -57.7 0 -57.7 0 -28.0 0 76.7 0 7.5 0 75.4 0 1019.8 0 - 2021 1 1 1 0 15 0.250 96.05 -1.5 0 -0.8 0 1.1 0 0.1 0 155.4 0 246.03 0 245.94 0 209.5 0 246.25 0 246.15 0 -9999.9 2 -9999.9 1 0.0 0 -54.1 0 -54.1 0 -27.9 0 76.6 0 6.7 0 76.3 0 1019.8 0 - 2021 1 1 1 0 16 0.267 96.08 -1.5 0 -0.7 0 1.1 0 0.2 0 157.6 0 246.07 0 246.00 0 209.4 0 246.27 0 246.19 0 -9999.9 2 -9999.9 1 0.0 0 -51.8 0 -51.8 0 -27.8 0 76.6 0 7.2 0 76.6 0 1019.8 0 - 2021 1 1 1 0 17 0.283 96.12 -1.2 0 -0.7 0 1.1 0 0.2 0 161.5 0 246.10 0 246.05 0 209.5 0 246.30 0 246.22 0 -9999.9 2 -9999.9 1 0.0 0 -48.0 0 -48.0 0 -27.7 0 76.7 0 6.6 0 76.9 0 1019.8 0 diff --git a/act/tests/data/brw_12_2020_hour.dat b/act/tests/data/brw_12_2020_hour.dat deleted file mode 100644 index a56ced2c56..0000000000 --- a/act/tests/data/brw_12_2020_hour.dat +++ /dev/null @@ -1,34 +0,0 @@ -These data are made available to the scientific community and public with the understanding that authors of publications -and presentations will contact the PI to obtain up-to-date information on the latest version of the data during the early stages of their analysis. -Manuscripts that employ these data should be reviewed by the PI before submission to ensure the quality and limitations of the data are represented. - -Data Disclaimer: Data has undergone extensive quality checks and is available from NOAA-GMD and WDCGG. -However, there still exists the potential for these data to be modified at the discretion of NOAA/ESRL Global Monitoring Division. - -If you have questions regarding the data in this file, please contact: -Irina Petropavlovskikh: Irina.Petro@noaa.gov (303-497-6279) -Audra McClure-Begley: Audra.mcclure@noaa.gov - -Please use the following citation for data use: -McClure-Begley, A., Petropavlovskikh, I., Oltmans, S., (2014) NOAA Global Monitoring Surface Ozone Network. - Station name, Time start-Time end. National Oceanic and Atmospheric Administration, Earth Systems Research Laboratory Global Monitoring Division. - Boulder, CO. DATE ACCESSED http://dx.doi.org/10.7289/V57P8WBF - -STN YEAR MON DAY HR O3(PPB) -BRW 2020 12 01 00 32.15 -BRW 2020 12 01 01 33.07 -BRW 2020 12 01 02 34.06 -BRW 2020 12 01 03 35.18 -BRW 2020 12 01 04 35.41 -BRW 2020 12 01 05 35.40 -BRW 2020 12 01 06 35.23 -BRW 2020 12 01 07 35.38 -BRW 2020 12 01 08 35.57 -BRW 2020 12 01 09 36.04 -BRW 2020 12 01 10 36.13 -BRW 2020 12 01 11 35.37 -BRW 2020 12 01 12 33.13 -BRW 2020 12 01 13 32.62 -BRW 2020 12 01 14 32.53 -BRW 2020 12 01 15 32.51 -BRW 2020 12 01 16 32.98 diff --git a/act/tests/data/brw_CCl4_Day.dat b/act/tests/data/brw_CCl4_Day.dat deleted file mode 100644 index 4fd2044e44..0000000000 --- a/act/tests/data/brw_CCl4_Day.dat +++ /dev/null @@ -1,68 +0,0 @@ -# file: brw_CCl4_Day.dat -# date: Mon, Mar 8, 2021 2:35:30 PM -# -# Carbon tetrachloride (CCl4) data from hourly in situ samples analyzed on a gas chromatograph located -# at Pt. Barrow (BRW), Alaska (71.3 N, 156.6 W, elevation: 8 m). -# -# Atmospheric Measurements from the NOAA/ESRL Chromatograph for Atmospheric Trace Species -# (CATS) Program. This GC replaces the RITS GCs operated during the period of 1986 through 2000. -# This work was funded in part by the Atmospheric Chemistry Project of NOAA's Climate and -# Global Change Program. -# -# (PIs) Geoffrey S. Dutton, Dr. James W. Elkins, Dr. Bradley D. Hall -# -# National Oceanic and Atmospheric Administration (NOAA) -# Earth System Research Laboratory (ESRL) -# 325 Broadway, R/GML -# Boulder, CO 80305-3328 -# -# Email: Geoff.Dutton@noaa.gov; James.W.Elkins@noaa.gov; Bradley.Hall@noaa.gov -# Phone: (303) 497-6086 (303) 497-6224 (303) 497-7011 -# Fax: (303) 497-6290 -# -# See (http://www.esrl.noaa.gov/gmd/obop/) for station statistics and personnel. -# -# Data use policy: -# If you use this data in a publication or report, we would appreciate that you contact the principal -# investigators (PIs) first and discuss your interests. We are trying to encourage scientific discussion. -# The PIs can discuss the quality of the data and any potential problems with its analysis. Recent data (less -# than 1.5 years) are considered preliminary. Please contact the PIs for more information. -# -# The data should be cited in presentations or publications as the flowing: Carbon tetrachloride data from -# the NOAA/ESRL halocarbons in situ program. -# -# DOI: http://doi.org/10.7289/V5X0659V -# -# Calibration scale used: NOAA 2008 -# -# More information about the calibration scale can be found at: -# http://www.esrl.noaa.gov/gmd/ccl/ -# -# The CATS GCs sample air once an hour. Daily median data are provided in parts-per-trillion, ppt. -# Abbreviations used: -# yr=year, mon=month, m=monthly data; gc=type of sample--in situ GC data, sd=standard deviation of samples, -# n=number of samples, brw=Pt. Barrow, Alaska, sum=Summit, Greenland, nwr= Niwot Ridge, Colorado -# mlo=Mauna Loa, Hawaii, smo = American Samoa, spo=South Pole, Antarctica -# NAN=not a number or no data, and space(s) is the delimiter. -# -# The standard deviation (unc) reported is the estimate of insturmental precision. -# The standard deviation (sd) reported is the estimate of atmospheric variability. -# -# year, month, day, daily median CCl4 in ppt, std. dev. -# -CCl4catsBRWyr CCl4catsBRWmon CCl4catsBRWday CCl4catsBRWm CCl4catsBRWmsd CCl4catsBRWn -1998 6 16 nan nan 0 -1998 6 17 103.76 0.66 21 -1998 6 18 103.44 0.59 24 -1998 6 19 103.27 0.45 17 -1998 6 20 103.37 0.41 20 -1998 6 21 103.20 0.43 19 -1998 6 22 103.11 0.39 18 -1998 6 23 103.20 0.40 24 -1998 6 24 103.11 0.52 22 -1998 6 25 103.07 0.50 17 -1998 6 26 103.35 0.51 15 -1998 6 27 103.09 0.60 24 -1998 6 28 103.09 0.66 14 -1998 6 29 nan nan 0 -1998 6 30 103.59 0.56 12 diff --git a/act/tests/data/co2_brw_surface-insitu_1_ccgg_MonthlyData.txt b/act/tests/data/co2_brw_surface-insitu_1_ccgg_MonthlyData.txt deleted file mode 100644 index 09112800a2..0000000000 --- a/act/tests/data/co2_brw_surface-insitu_1_ccgg_MonthlyData.txt +++ /dev/null @@ -1,164 +0,0 @@ -# header_lines : 151 -# -# ------------------------------------------------------------->>>> -# DATA SET NAME -# -# dataset_name: co2_brw_surface-insitu_1_ccgg_MonthlyData -# -# ------------------------------------------------------------->>>> -# DESCRIPTION -# -# dataset_description: Atmospheric Carbon Dioxide Dry Air Mole Fractions from quasi-continuous measurements at Barrow, Alaska. -# -# ------------------------------------------------------------->>>> -# CITATION -# -# dataset_citation: K.W. Thoning, A.M. Crotwell, and J.W. Mund (2021), Atmospheric Carbon Dioxide Dry Air Mole Fractions from continuous measurements at Mauna Loa, Hawaii, Barrow, Alaska, American Samoa and South Pole. 1973-2019, Version 2021-02 National Oceanic and Atmospheric Administration (NOAA), Global Monitoring Laboratory (GML), Boulder, Colorado, USA https://doi.org/10.15138/yaf1-bk21 FTP path: ftp://aftp.cmdl.noaa.gov/data/greenhouse_gases/co2/in-situ/surface/ -# -# ------------------------------------------------------------->>>> -# FAIR USE POLICY -# -# dataset_fair_use: These data are made freely available to the public and the scientific community in the belief that their wide dissemination will lead to greater understanding and new scientific insights. The availability of these data does not constitute publication of the data. NOAA relies on the ethics and integrity of the user to ensure that ESRL receives fair credit for their work. If the data are obtained for potential use in a publication or presentation, ESRL should be informed at the outset of the nature of this work. If the ESRL data are essential to the work, or if an important result or conclusion depends on the ESRL data, co-authorship may be appropriate. This should be discussed at an early stage in the work. Manuscripts using the ESRL data should be sent to ESRL for review before they are submitted for publication so we can ensure that the quality and limitations of the data are accurately represented. -# -# ------------------------------------------------------------->>>> -# WARNING -# -# dataset_warning: Every effort is made to produce the most accurate and precise measurements possible. However, we reserve the right to make corrections to the data based on recalibration of standard gases or for other reasons deemed scientifically justified. We are not responsible for results and conclusions based on use of these data without regard to this warning. -# -# ------------------------------------------------------------->>>> -# GLOBAL ATTRIBUTES -# -# site_code : BRW -# site_name : Barrow Atmospheric Baseline Observatory -# site_country : United States -# site_country_flag : http://www.esrl.noaa.gov/gmd/webdata/ccgg/ObsPack/images/flags/UNST0001.GIF -# site_latitude : 71.323 -# site_longitude : -156.6114 -# site_elevation : 11.0 -# site_elevation_unit : masl -# site_position_comment : This is the nominal location of the site. The sampling location at many sites has changed over time, and we report here the most recent nominal location. The actual sampling location for each observation is not necessarily the site location. The sampling locations for each observation are reported in the latitude, longitude, and altitude variables. -# site_utc2lst : -9.0 -# site_utc2lst_comment : Add 'site_utc2lst' hours to convert a time stamp in UTC (Coordinated Universal Time) to LST (Local Standard Time). -# site_url : http://www.esrl.noaa.gov/gmd/obop/brw/index.html -# dataset_creation_date : 2021-03-05T12:36:08.450229 -# dataset_num : 3 -# dataset_name : co2_brw_surface-insitu_1_ccgg_MonthlyData -# dataset_parameter : co2 -# dataset_project : surface-insitu -# dataset_platform : fixed -# dataset_selection : Monthly values derived from hourly data representative of baseline conditions -# dataset_selection_tag : MonthlyData -# dataset_calibration_scale : WMO CO2 X2019 -# dataset_start_date : 1973-01-01T00:00:00Z -# dataset_stop_date : 2019-12-01T00:00:00Z -# dataset_data_frequency : 1 -# dataset_data_frequency_unit : month -# dataset_reciprocity : Use of these data implies an agreement to reciprocate. Laboratories making similar measurements agree to make their own data available to the general public and to the scientific community in an equally complete and easily accessible form. Modelers are encouraged to make available to the community, upon request, their own tools used in the interpretation of the ESRL data, namely well documented model code, transport fields, and additional information necessary for other scientists to repeat the work and to run modified versions. Model availability includes collaborative support for new users of the models. -# dataset_usage_url : https://www.esrl.noaa.gov/gmd/ccgg/obspack/citation.php?product=obspack_co2_1_CCGGObsInsitu_v1.0_2021-03-05 -# dataset_usage_description : Please cite the product's citation when using data from this dataset. Relevant literature references for this dataset are listed below for convenience. -# dataset_reference_total_listed : 2 -# dataset_reference_1_name : Peterson, J.T., W.D. Komhyr, L.S. Waterman, R.H. Gammon, K.W. Thoning, and T.J. Conway, Atmospheric CO2 variations at Barrow, Alaska, 1973 1982, J. Atmos. Chem., 4, 491 510, 1986. -# dataset_reference_2_name : Halter, B. and J. M. Harris (1983), On the variability of atmospheric carbon dioxide concentration at Barrow, Alaska, during winter, Journal of Geophysical Research, 88(C11), 6858-6864. -# dataset_contribution : These data are provided by NOAA. Principal investigators include Kirk Thoning (NOAA) AND Pieter Tans (NOAA). -# lab_total_listed : 1 -# lab_1_number : 1 -# lab_1_abbr : NOAA -# lab_1_name : NOAA Global Monitoring Laboratory -# lab_1_address1 : 325 Broadway -# lab_1_address2 : NOAA R/GML-1 -# lab_1_address3 : Boulder, CO 80305-3328 -# lab_1_country : United States -# lab_1_url : http://www.esrl.noaa.gov/gmd/ccgg/ -# lab_1_parameter : Lab has contributed measurements for: co2 -# lab_1_country_flag : http://www.esrl.noaa.gov/gmd/webdata/ccgg/ObsPack/images/flags/UNST0001.GIF -# lab_1_logo : http://www.esrl.noaa.gov/gmd/webdata/ccgg/ObsPack/images/logos/noaa_medium.png -# lab_1_ongoing_atmospheric_air_comparison : T -# lab_1_comparison_activity : Ongoing comparison with co-located measurements including NOAA surface flask data and independent measurement laboratories. -# provider_total_listed : 2 -# provider_1_name : Kirk Thoning -# provider_1_address1 : NOAA ESRL GML -# provider_1_address2 : 325 Broadway R/GML-1 -# provider_1_address3 : Boulder, CO 80305-3328 -# provider_1_country : United States -# provider_1_affiliation : National Oceanic and Atmospheric Administration -# provider_1_email : kirk.w.thoning@noaa.gov -# provider_1_tel : 303-497-6078 -# provider_1_parameter : Provider has contributed measurements for: co2 -# provider_2_name : Pieter Tans -# provider_2_address1 : NOAA ESRL GML -# provider_2_address2 : 325 Broadway R/GML-1 -# provider_2_address3 : Boulder, CO 80305-3328 -# provider_2_country : United States -# provider_2_affiliation : National Oceanic and Atmospheric Administration -# provider_2_email : pieter.tans@noaa.gov -# provider_2_tel : 303-497-6678 -# provider_2_parameter : Provider has contributed measurements for: co2 -# ------------------------------------------------------------->>>> -# VARIABLE ATTRIBUTES -# -# site_code:long_name : site_name_abbreviation. -# site_code:comment : Site code is an abbreviation for the sampling site name. -# time_components:_FillValue : -9 -# time_components:long_name : integer_components_of_UTC_date/time -# time_components:order : year, month, day, hour, minute, second -# time_components:comment : Calendar time components as integers. Times and dates are UTC. Time-averaged values are reported at the beginning of the averaging interval. -# time_decimal:_FillValue : -999.999 -# time_decimal:long_name : sample_decimal_year_in_UTC -# time_decimal:comment : decimal year in UTC. Time-averaged values are reported at the beginning of the averaging interval. -# value:_FillValue : -999.999 -# value:long_name : measured_mole_fraction_of_trace_gas_in_dry_air -# value:units : micromol mol-1 -# value:comment : Mole fraction reported in units of micromol mol-1 (10-6 mol per mol of dry air); abbreviated as ppm (parts per million). -# value_std_dev:_FillValue : -99.99 -# value_std_dev:long_name : standard_deviation_in_reported_value -# value_std_dev:units : micromol mol-1 -# value_std_dev:comment : This is the standard deviation of the reported mean value when nvalue is greater than 1. See provider_comment if available. -# nvalue:_FillValue : -9 -# nvalue:long_name : number_of_measurements_contributing_to_reported_value -# nvalue:comment : Number of individual measurements used to compute reported value. See provider_comment if available. -# latitude:_FillValue : -999.999 -# latitude:standard_name : latitude -# latitude:long_name : sample_latitude_in_decimal_degrees -# latitude:units : degrees_north -# latitude:comment : Latitude at which air sample was collected. -# longitude:_FillValue : -999.999 -# longitude:standard_name : longitude -# longitude:long_name : sample_longitude_in_decimal_degrees -# longitude:units : degrees_east -# longitude:comment : Longitude at which air sample was collected using a range of -180 degrees to +180 degrees. -# altitude:_FillValue : -999.999 -# altitude:standard_name : altitude -# altitude:long_name : sample_altitude_in_meters_above_sea_level -# altitude:units : m -# altitude:comment : Altitude (in meters above sea level). See provider_comment if available. -# altitude:provider_comment : Altitude for this dataset is the sum of surface elevation (masl) and sample intake height (magl). -# elevation:_FillValue : -999.999 -# elevation:standard_name : elevation -# elevation:long_name : surface_elevation_in_meters_above_sea_level -# elevation:units : m -# elevation:comment : Surface elevation in meters above sea level. See provider_comment if available. -# intake_height:_FillValue : -999.999 -# intake_height:long_name : sample_intake_height_in_meters_above_ground_level -# intake_height:units : m -# intake_height:comment : Sample intake height in meters above ground level (magl). See provider_comment if available. -# qcflag:missing_value : NA -# qcflag:long_name : quality_control_flag -# qcflag:comment : This quality control flag is provided by the contributing PIs. See provider_comment if available. -# qcflag:provider_comment : This is the NOAA 3-character quality control flag. Column 1 is the REJECTION flag. An alphanumeric other than a period (.) in the FIRST column indicates a sample with obvious problems during collection or analysis. This measurement should not be interpreted. Column 2 is the SELECTION flag. An alphanumeric other than a period (.) in the SECOND column indicates a sample that is likely valid but does not meet selection criteria determined by the goals of a particular investigation. Column 3 is the INFORMATION flag. An alphanumeric other than a period (.) in the THIRD column provides additional information about the collection or analysis of the sample. -# -# VARIABLE ORDER -# -site_code year month day hour minute second time_decimal value value_std_dev nvalue latitude longitude altitude elevation intake_height qcflag -BRW 1973 1 1 0 0 0 1973.0 -999.99 -99.99 0 71.323 -156.611 27.0 11.0 16.0 *.. -BRW 1973 2 1 0 0 0 1973.0849315068492 -999.99 -99.99 0 71.323 -156.611 27.0 11.0 16.0 *.. -BRW 1973 3 1 0 0 0 1973.1616438356164 -999.99 -99.99 0 71.323 -156.611 27.0 11.0 16.0 *.. -BRW 1973 4 1 0 0 0 1973.2465753424658 -999.99 -99.99 0 71.323 -156.611 27.0 11.0 16.0 *.. -BRW 1973 5 1 0 0 0 1973.3287671232877 -999.99 -99.99 0 71.323 -156.611 27.0 11.0 16.0 *.. -BRW 1973 6 1 0 0 0 1973.4136986301369 -999.99 -99.99 0 71.323 -156.611 27.0 11.0 16.0 *.. -BRW 1973 7 1 0 0 0 1973.495890410959 324.53 0.39 5 71.323 -156.611 27.0 11.0 16.0 ... -BRW 1973 8 1 0 0 0 1973.5808219178082 322.73 0.84 23 71.323 -156.611 27.0 11.0 16.0 ... -BRW 1973 9 1 0 0 0 1973.6657534246576 324.79 1.81 29 71.323 -156.611 27.0 11.0 16.0 ... -BRW 1973 10 1 0 0 0 1973.7479452054795 329.86 2.78 29 71.323 -156.611 27.0 11.0 16.0 ... -BRW 1973 11 1 0 0 0 1973.8328767123287 333.61 0.77 27 71.323 -156.611 27.0 11.0 16.0 ... -BRW 1973 12 1 0 0 0 1973.9150684931508 334.6 1.6 30 71.323 -156.611 27.0 11.0 16.0 ... -BRW 1974 1 1 0 0 0 1974.0 337.51 1.35 20 71.323 -156.611 27.0 11.0 16.0 ... diff --git a/act/tests/data/maraosmetM1.a1.20180201.000000.nc b/act/tests/data/maraosmetM1.a1.20180201.000000.nc deleted file mode 100644 index 24e57de3ff..0000000000 Binary files a/act/tests/data/maraosmetM1.a1.20180201.000000.nc and /dev/null differ diff --git a/act/tests/data/marirtsstM1.b1.20190320.000000.nc b/act/tests/data/marirtsstM1.b1.20190320.000000.nc deleted file mode 100644 index 45219fe1f5..0000000000 Binary files a/act/tests/data/marirtsstM1.b1.20190320.000000.nc and /dev/null differ diff --git a/act/tests/data/marnavM1.a1.20180201.000000.nc b/act/tests/data/marnavM1.a1.20180201.000000.nc deleted file mode 100644 index 0cce4ef9c5..0000000000 Binary files a/act/tests/data/marnavM1.a1.20180201.000000.nc and /dev/null differ diff --git a/act/tests/data/met_brw_insitu_1_obop_hour_2020.txt b/act/tests/data/met_brw_insitu_1_obop_hour_2020.txt deleted file mode 100644 index e6b17550f0..0000000000 --- a/act/tests/data/met_brw_insitu_1_obop_hour_2020.txt +++ /dev/null @@ -1,20 +0,0 @@ -BRW 2020 01 01 00 5 7.1 100 1004.73 -25.5 -25.0 -999.9 77 -99 -BRW 2020 01 01 01 0 7.0 100 1005.16 -25.8 -25.2 -999.9 77 -99 -BRW 2020 01 01 02 3 7.6 99 1005.48 -25.3 -25.0 -999.9 77 -99 -BRW 2020 01 01 03 4 7.6 99 1006.04 -25.2 -24.7 -999.9 77 -99 -BRW 2020 01 01 04 15 7.5 100 1006.61 -25.1 -24.6 -999.9 77 -99 -BRW 2020 01 01 05 18 7.2 100 1007.19 -24.9 -24.5 -999.9 77 -99 -BRW 2020 01 01 06 17 7.7 100 1007.56 -24.8 -24.5 -999.9 77 -99 -BRW 2020 01 01 07 23 7.0 100 1008.24 -25.4 -25.0 -999.9 77 -99 -BRW 2020 01 01 08 21 7.4 100 1008.89 -25.7 -25.3 -999.9 77 -99 -BRW 2020 01 01 09 16 6.9 100 1009.78 -25.8 -25.2 -999.9 76 -99 -BRW 2020 01 01 10 17 7.0 100 1010.39 -25.3 -24.9 -999.9 77 -99 -BRW 2020 01 01 11 13 7.0 100 1010.57 -25.4 -25.0 -999.9 77 -99 -BRW 2020 01 01 12 28 7.5 100 1010.80 -24.9 -24.7 -999.9 77 -99 -BRW 2020 01 01 13 18 7.5 100 1011.54 -24.7 -24.5 -999.9 77 -99 -BRW 2020 01 01 14 17 7.6 100 1012.06 -24.3 -24.2 -999.9 77 -99 -BRW 2020 01 01 15 16 7.8 100 1012.52 -24.4 -24.1 -999.9 77 -99 -BRW 2020 01 01 16 44 6.9 100 1013.36 -24.7 -24.4 -999.9 77 -99 -BRW 2020 01 01 17 36 7.6 100 1014.02 -24.8 -24.5 -999.9 77 -99 -BRW 2020 01 01 18 28 7.8 100 1014.64 -24.3 -24.1 -999.9 78 -99 -BRW 2020 01 01 19 25 8.4 100 1015.17 -24.4 -24.2 -999.9 78 -99 diff --git a/act/tests/data/met_lcl.nc b/act/tests/data/met_lcl.nc deleted file mode 100644 index 2874a2eec4..0000000000 Binary files a/act/tests/data/met_lcl.nc and /dev/null differ diff --git a/act/tests/data/nsasurfspecalb1mlawerC1.c1.20160609.080000.nc b/act/tests/data/nsasurfspecalb1mlawerC1.c1.20160609.080000.nc deleted file mode 100644 index 579dd1b40e..0000000000 Binary files a/act/tests/data/nsasurfspecalb1mlawerC1.c1.20160609.080000.nc and /dev/null differ diff --git a/act/tests/data/sgp30ebbrE32.b1.20191125.000000.nc b/act/tests/data/sgp30ebbrE32.b1.20191125.000000.nc deleted file mode 100644 index d6ee80f1c6..0000000000 Binary files a/act/tests/data/sgp30ebbrE32.b1.20191125.000000.nc and /dev/null differ diff --git a/act/tests/data/sgp30ebbrE32.b1.20191130.000000.nc b/act/tests/data/sgp30ebbrE32.b1.20191130.000000.nc deleted file mode 100644 index ce76df50e5..0000000000 Binary files a/act/tests/data/sgp30ebbrE32.b1.20191130.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpaerich1C1.b1.20190501.000342.nc b/act/tests/data/sgpaerich1C1.b1.20190501.000342.nc deleted file mode 100644 index 14af48ff19..0000000000 Binary files a/act/tests/data/sgpaerich1C1.b1.20190501.000342.nc and /dev/null differ diff --git a/act/tests/data/sgpbrsC1.b1.20190705.000000.cdf b/act/tests/data/sgpbrsC1.b1.20190705.000000.cdf deleted file mode 100644 index f3db7cee4d..0000000000 Binary files a/act/tests/data/sgpbrsC1.b1.20190705.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpceilC1.b1.20190101.000000.nc b/act/tests/data/sgpceilC1.b1.20190101.000000.nc deleted file mode 100644 index 4936c57f6d..0000000000 Binary files a/act/tests/data/sgpceilC1.b1.20190101.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpco2flx4mC1.b1.20201007.001500.nc b/act/tests/data/sgpco2flx4mC1.b1.20201007.001500.nc deleted file mode 100644 index 17b7ab79d2..0000000000 Binary files a/act/tests/data/sgpco2flx4mC1.b1.20201007.001500.nc and /dev/null differ diff --git a/act/tests/data/sgpdlppiC1.b1.20191015.120023.cdf b/act/tests/data/sgpdlppiC1.b1.20191015.120023.cdf deleted file mode 100644 index 3b205bd16e..0000000000 Binary files a/act/tests/data/sgpdlppiC1.b1.20191015.120023.cdf and /dev/null differ diff --git a/act/tests/data/sgpdlppiC1.b1.20191015.121506.cdf b/act/tests/data/sgpdlppiC1.b1.20191015.121506.cdf deleted file mode 100644 index e36bd1dd51..0000000000 Binary files a/act/tests/data/sgpdlppiC1.b1.20191015.121506.cdf and /dev/null differ diff --git a/act/tests/data/sgpirt25m20sC1.a0.20190601.000000.cdf b/act/tests/data/sgpirt25m20sC1.a0.20190601.000000.cdf deleted file mode 100644 index f0889b1e52..0000000000 Binary files a/act/tests/data/sgpirt25m20sC1.a0.20190601.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190101.000000.cdf b/act/tests/data/sgpmetE13.b1.20190101.000000.cdf deleted file mode 100644 index 6799c25eb1..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190101.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190102.000000.cdf b/act/tests/data/sgpmetE13.b1.20190102.000000.cdf deleted file mode 100644 index 74297afee0..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190102.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190103.000000.cdf b/act/tests/data/sgpmetE13.b1.20190103.000000.cdf deleted file mode 100644 index 9bcab76295..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190103.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190104.000000.cdf b/act/tests/data/sgpmetE13.b1.20190104.000000.cdf deleted file mode 100644 index 1d529af99c..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190104.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190105.000000.cdf b/act/tests/data/sgpmetE13.b1.20190105.000000.cdf deleted file mode 100644 index ac03ca4b5b..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190105.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190106.000000.cdf b/act/tests/data/sgpmetE13.b1.20190106.000000.cdf deleted file mode 100644 index 79baf2393a..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190106.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190107.000000.cdf b/act/tests/data/sgpmetE13.b1.20190107.000000.cdf deleted file mode 100644 index 9b5d60084e..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190107.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20190508.000000.cdf b/act/tests/data/sgpmetE13.b1.20190508.000000.cdf deleted file mode 100644 index 8315ba6cda..0000000000 Binary files a/act/tests/data/sgpmetE13.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE13.b1.20210401.000000.csv b/act/tests/data/sgpmetE13.b1.20210401.000000.csv deleted file mode 100644 index 9fc8eff6ab..0000000000 --- a/act/tests/data/sgpmetE13.b1.20210401.000000.csv +++ /dev/null @@ -1,4 +0,0 @@ -time,date_time,time_offset,atmos_pressure,qc_atmos_pressure,temp_mean,qc_temp_mean,temp_std,rh_mean,qc_rh_mean,rh_std,vapor_pressure_mean,qc_vapor_pressure_mean,vapor_pressure_std,wspd_arith_mean,qc_wspd_arith_mean,wspd_vec_mean,qc_wspd_vec_mean,wdir_vec_mean,qc_wdir_vec_mean,wdir_vec_std,tbrg_precip_total,qc_tbrg_precip_total,tbrg_precip_total_corr,qc_tbrg_precip_total_corr,org_precip_rate_mean,qc_org_precip_rate_mean,pwd_err_code,pwd_mean_vis_1min,qc_pwd_mean_vis_1min,pwd_mean_vis_10min,qc_pwd_mean_vis_10min,pwd_pw_code_inst,qc_pwd_pw_code_inst,pwd_pw_code_15min,qc_pwd_pw_code_15min,pwd_pw_code_1hr,qc_pwd_pw_code_1hr,pwd_precip_rate_mean_1min,qc_pwd_precip_rate_mean_1min,pwd_cumul_rain,qc_pwd_cumul_rain,pwd_cumul_snow,qc_pwd_cumul_snow,logger_volt,qc_logger_volt,logger_temp,qc_logger_temp,lat,lon,alt -2021-04-01 00:00:00,2021-04-01 00:00:00,2021-04-01 00:00:00,99.14,0,13.9,0,0.019,36.49,0,0.231,0.579,0,0.003,2.744,0,2.742,0,113.1,0,2.301,0.0,0,0.0,0,0.0,0,0.0,20000.0,0,20000.0,0,0.0,0,0.0,0,0.0,0,0.0,0,26.98,0,457.0,0,12.83,0,20.4,0,36.605,-97.485,318.0 -2021-04-01 00:01:00,2021-04-01 00:00:00,2021-04-01 00:01:00,99.14,0,13.86,0,0.026,37.29,0,0.163,0.59,0,0.002,2.553,0,2.549,0,110.2,0,3.345,0.0,0,0.0,0,0.0,0,0.0,20000.0,0,20000.0,0,0.0,0,0.0,0,0.0,0,0.0,0,26.98,0,457.0,0,12.84,0,20.37,0,36.605,-97.485,318.0 -2021-04-01 00:02:00,2021-04-01 00:00:00,2021-04-01 00:02:00,99.14,0,13.76,0,0.034,38.36,0,0.524,0.603,0,0.007,2.661,0,2.66,0,103.6,0,1.518,0.0,0,0.0,0,0.0,0,0.0,20000.0,0,20000.0,0,0.0,0,0.0,0,0.0,0,0.0,0,26.98,0,457.0,0,12.83,0,20.31,0,36.605,-97.485,318.0 diff --git a/act/tests/data/sgpmetE15.b1.20190508.000000.cdf b/act/tests/data/sgpmetE15.b1.20190508.000000.cdf deleted file mode 100644 index 5c78b3767b..0000000000 Binary files a/act/tests/data/sgpmetE15.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE31.b1.20190508.000000.cdf b/act/tests/data/sgpmetE31.b1.20190508.000000.cdf deleted file mode 100644 index 7ce923759f..0000000000 Binary files a/act/tests/data/sgpmetE31.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE32.b1.20190508.000000.cdf b/act/tests/data/sgpmetE32.b1.20190508.000000.cdf deleted file mode 100644 index 7ec28d28b3..0000000000 Binary files a/act/tests/data/sgpmetE32.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE33.b1.20190508.000000.cdf b/act/tests/data/sgpmetE33.b1.20190508.000000.cdf deleted file mode 100644 index 0bafa1af4e..0000000000 Binary files a/act/tests/data/sgpmetE33.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE34.b1.20190508.000000.cdf b/act/tests/data/sgpmetE34.b1.20190508.000000.cdf deleted file mode 100644 index af6f5d3a3c..0000000000 Binary files a/act/tests/data/sgpmetE34.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE35.b1.20190508.000000.cdf b/act/tests/data/sgpmetE35.b1.20190508.000000.cdf deleted file mode 100644 index 54fbc3108a..0000000000 Binary files a/act/tests/data/sgpmetE35.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE36.b1.20190508.000000.cdf b/act/tests/data/sgpmetE36.b1.20190508.000000.cdf deleted file mode 100644 index dc3eb5b311..0000000000 Binary files a/act/tests/data/sgpmetE36.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE37.b1.20190508.000000.cdf b/act/tests/data/sgpmetE37.b1.20190508.000000.cdf deleted file mode 100644 index 792b595b67..0000000000 Binary files a/act/tests/data/sgpmetE37.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE38.b1.20190508.000000.cdf b/act/tests/data/sgpmetE38.b1.20190508.000000.cdf deleted file mode 100644 index ee7e058350..0000000000 Binary files a/act/tests/data/sgpmetE38.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE39.b1.20190508.000000.cdf b/act/tests/data/sgpmetE39.b1.20190508.000000.cdf deleted file mode 100644 index f408c47902..0000000000 Binary files a/act/tests/data/sgpmetE39.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE40.b1.20190508.000000.cdf b/act/tests/data/sgpmetE40.b1.20190508.000000.cdf deleted file mode 100644 index 82e3cb9dc6..0000000000 Binary files a/act/tests/data/sgpmetE40.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmetE9.b1.20190508.000000.cdf b/act/tests/data/sgpmetE9.b1.20190508.000000.cdf deleted file mode 100644 index 90b885e642..0000000000 Binary files a/act/tests/data/sgpmetE9.b1.20190508.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpmet_no_time.nc b/act/tests/data/sgpmet_no_time.nc deleted file mode 100644 index cf32a36d83..0000000000 Binary files a/act/tests/data/sgpmet_no_time.nc and /dev/null differ diff --git a/act/tests/data/sgpmet_test_time.nc b/act/tests/data/sgpmet_test_time.nc deleted file mode 100644 index 3f067ea715..0000000000 Binary files a/act/tests/data/sgpmet_test_time.nc and /dev/null differ diff --git a/act/tests/data/sgpmfrsr7nchE38.b1.20190514.180000.nc b/act/tests/data/sgpmfrsr7nchE38.b1.20190514.180000.nc deleted file mode 100644 index 4aff405208..0000000000 Binary files a/act/tests/data/sgpmfrsr7nchE38.b1.20190514.180000.nc and /dev/null differ diff --git a/act/tests/data/sgpmplpolfsC1.b1.20190502.000000.cdf b/act/tests/data/sgpmplpolfsC1.b1.20190502.000000.cdf deleted file mode 100644 index 2267f27c68..0000000000 Binary files a/act/tests/data/sgpmplpolfsC1.b1.20190502.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgprlC1.a0.20160131.000000.nc b/act/tests/data/sgprlC1.a0.20160131.000000.nc deleted file mode 100644 index 7c4f12a57c..0000000000 Binary files a/act/tests/data/sgprlC1.a0.20160131.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpsirsE13.b1.20190101.000000.cdf b/act/tests/data/sgpsirsE13.b1.20190101.000000.cdf deleted file mode 100644 index af16485ad6..0000000000 Binary files a/act/tests/data/sgpsirsE13.b1.20190101.000000.cdf and /dev/null differ diff --git a/act/tests/data/sgpsondewnpnC1.b1.20190101.053200.cdf b/act/tests/data/sgpsondewnpnC1.b1.20190101.053200.cdf deleted file mode 100644 index d1f2cf9e0b..0000000000 Binary files a/act/tests/data/sgpsondewnpnC1.b1.20190101.053200.cdf and /dev/null differ diff --git a/act/tests/data/sgpstampE13.b1.20200101.000000.nc b/act/tests/data/sgpstampE13.b1.20200101.000000.nc deleted file mode 100644 index 2bb4d93df3..0000000000 Binary files a/act/tests/data/sgpstampE13.b1.20200101.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpstampE31.b1.20200101.000000.nc b/act/tests/data/sgpstampE31.b1.20200101.000000.nc deleted file mode 100644 index 863f10def7..0000000000 Binary files a/act/tests/data/sgpstampE31.b1.20200101.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpstampE32.b1.20200101.000000.nc b/act/tests/data/sgpstampE32.b1.20200101.000000.nc deleted file mode 100644 index a4619d15ad..0000000000 Binary files a/act/tests/data/sgpstampE32.b1.20200101.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpstampE33.b1.20200101.000000.nc b/act/tests/data/sgpstampE33.b1.20200101.000000.nc deleted file mode 100644 index 3db75441af..0000000000 Binary files a/act/tests/data/sgpstampE33.b1.20200101.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpstampE34.b1.20200101.000000.nc b/act/tests/data/sgpstampE34.b1.20200101.000000.nc deleted file mode 100644 index 84aa0cf4f4..0000000000 Binary files a/act/tests/data/sgpstampE34.b1.20200101.000000.nc and /dev/null differ diff --git a/act/tests/data/sgpstampE9.b1.20200101.000000.nc b/act/tests/data/sgpstampE9.b1.20200101.000000.nc deleted file mode 100644 index 8180d4031f..0000000000 Binary files a/act/tests/data/sgpstampE9.b1.20200101.000000.nc and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060119.050300.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060119.050300.custom.cdf deleted file mode 100644 index 7e9f09e470..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060119.050300.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060119.112000.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060119.112000.custom.cdf deleted file mode 100644 index 7297d40d01..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060119.112000.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060119.163300.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060119.163300.custom.cdf deleted file mode 100644 index b6da8c41d6..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060119.163300.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060119.231600.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060119.231600.custom.cdf deleted file mode 100644 index ec35969c06..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060119.231600.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060120.043800.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060120.043800.custom.cdf deleted file mode 100644 index c6040eb0f2..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060120.043800.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060120.111900.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060120.111900.custom.cdf deleted file mode 100644 index 83e2c36914..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060120.111900.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060120.170800.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060120.170800.custom.cdf deleted file mode 100644 index c8cbfb166f..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060120.170800.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060120.231500.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060120.231500.custom.cdf deleted file mode 100644 index 839e0f05f6..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060120.231500.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060121.051500.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060121.051500.custom.cdf deleted file mode 100644 index 997b58ed9f..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060121.051500.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060121.111600.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060121.111600.custom.cdf deleted file mode 100644 index 27020666b3..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060121.111600.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060121.171600.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060121.171600.custom.cdf deleted file mode 100644 index b800d67295..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060121.171600.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060121.231600.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060121.231600.custom.cdf deleted file mode 100644 index d6db498514..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060121.231600.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060122.052600.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060122.052600.custom.cdf deleted file mode 100644 index 3199dff333..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060122.052600.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060122.111500.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060122.111500.custom.cdf deleted file mode 100644 index 8fea5c3bcf..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060122.111500.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060122.171800.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060122.171800.custom.cdf deleted file mode 100644 index c67a527430..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060122.171800.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060122.232600.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060122.232600.custom.cdf deleted file mode 100644 index 8b5481bca7..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060122.232600.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060123.052500.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060123.052500.custom.cdf deleted file mode 100644 index af7d63dd70..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060123.052500.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060123.111700.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060123.111700.custom.cdf deleted file mode 100644 index a1044eeb3d..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060123.111700.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060123.171600.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060123.171600.custom.cdf deleted file mode 100644 index 31ad61bc2a..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060123.171600.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060123.231500.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060123.231500.custom.cdf deleted file mode 100644 index e069fe4939..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060123.231500.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060124.051500.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060124.051500.custom.cdf deleted file mode 100644 index c56430184b..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060124.051500.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060124.111800.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060124.111800.custom.cdf deleted file mode 100644 index 63ed909168..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060124.111800.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060124.171700.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060124.171700.custom.cdf deleted file mode 100644 index c7847143b0..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060124.171700.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpsondewnpnC3.b1.20060124.231500.custom.cdf b/act/tests/data/twpsondewnpnC3.b1.20060124.231500.custom.cdf deleted file mode 100644 index 4f4bc691c9..0000000000 Binary files a/act/tests/data/twpsondewnpnC3.b1.20060124.231500.custom.cdf and /dev/null differ diff --git a/act/tests/data/twpvisstgridirtemp.c1.20050705.002500.nc b/act/tests/data/twpvisstgridirtemp.c1.20050705.002500.nc deleted file mode 100644 index cfc62a6617..0000000000 Binary files a/act/tests/data/twpvisstgridirtemp.c1.20050705.002500.nc and /dev/null differ diff --git a/act/tests/sample_files.py b/act/tests/sample_files.py index 7432d99411..d1e1194cc5 100644 --- a/act/tests/sample_files.py +++ b/act/tests/sample_files.py @@ -1,94 +1,137 @@ """ -act.tests.sample_files -====================== - Sample data file for use in testing. These files should only be used for testing ACT. --- autosummary:: - :toctree: generated/ - - EXAMPLE_MET1 - EXAMPLE_METE40 - EXAMPLE_CEIL1 - EXAMPLE_SONDE1 - EXAMPLE_LCL1 - EXAMPLE_SONDE_WILDCARD - EXAMPLE_MET_WILDCARD - EXAMPLE_MET_CONTOUR - EXAMPLE_MET_CSV - EXAMPLE_CEIL_WILDCARD - EXAMPLE_TWP_SONDE_WILDCARD - EXAMPLE_TWP_SONDE_20060121 - EXAMPLE_ANL_CSV - EXAMPLE_VISST - EXAMPLE_DLPPI - EXAMPLE_DLPPI_MULTI - EXAMPLE_EBBR1 - EXAMPLE_EBBR2 - EXAMPLE_BRS - EXAMPLE_IRTSST - EXAMPLE_MFRSR - EXAMPLE_SURFSPECALB1MLAWER - EXAMPLE_SIGMA_MPLV5 - EXAMPLE_CO2FLX4M - EXAMPLE_SIRS - EXAMPLE_GML_RADIATION - EXAMPLE_GML_MET - EXAMPLE_GML_OZONE - EXAMPLE_GML_CO2 - EXAMPLE_GML_HALO - EXAMPLE_MET_TEST1 - EXAMPLE_MET_TEST2 - EXAMPLE_STAMP_WILDCARD """ + import os -DATA_PATH = os.path.join(os.path.dirname(__file__), 'data') +from arm_test_data import DATASETS + +# Single files +EXAMPLE_MET1 = DATASETS.fetch('sgpmetE13.b1.20190101.000000.cdf') +EXAMPLE_MET_SAIL = DATASETS.fetch('gucmetM1.b1.20230301.000000.cdf') +EXAMPLE_MET_CSV = DATASETS.fetch('sgpmetE13.b1.20210401.000000.csv') +EXAMPLE_METE40 = DATASETS.fetch('sgpmetE40.b1.20190508.000000.cdf') +EXAMPLE_CEIL1 = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') +EXAMPLE_SONDE1 = DATASETS.fetch('sgpsondewnpnC1.b1.20190101.053200.cdf') +EXAMPLE_LCL1 = DATASETS.fetch('met_lcl.nc') +EXAMPLE_ANL_CSV = DATASETS.fetch('anltwr_mar19met.data') +EXAMPLE_VISST = DATASETS.fetch('twpvisstgridirtemp.c1.20050705.002500.nc') +EXAMPLE_MPL_1SAMPLE = DATASETS.fetch('sgpmplpolfsC1.b1.20190502.000000.cdf') +EXAMPLE_IRT25m20s = DATASETS.fetch('sgpirt25m20sC1.a0.20190601.000000.cdf') +EXAMPLE_NAV = DATASETS.fetch('marnavM1.a1.20180201.000000.nc') +EXAMPLE_AOSMET = DATASETS.fetch('maraosmetM1.a1.20180201.000000.nc') +EXAMPLE_DLPPI = DATASETS.fetch('sgpdlppiC1.b1.20191015.120023.cdf') +EXAMPLE_BRS = DATASETS.fetch('sgpbrsC1.b1.20190705.000000.cdf') +EXAMPLE_AERI = DATASETS.fetch('sgpaerich1C1.b1.20190501.000342.nc') +EXAMPLE_IRTSST = DATASETS.fetch('marirtsstM1.b1.20190320.000000.nc') +EXAMPLE_MFRSR = DATASETS.fetch('sgpmfrsr7nchE11.b1.20210329.070000.nc') +EXAMPLE_SURFSPECALB1MLAWER = DATASETS.fetch( + 'nsasurfspecalb1mlawerC1.c1.20160609.080000.nc' +) +EXAMPLE_SIGMA_MPLV5 = DATASETS.fetch('201509021500.bi') +EXAMPLE_RL1 = DATASETS.fetch('sgprlC1.a0.20160131.000000.nc') +EXAMPLE_CO2FLX4M = DATASETS.fetch('sgpco2flx4mC1.b1.20201007.001500.nc') +EXAMPLE_SIRS = DATASETS.fetch('sgpsirsE13.b1.20190101.000000.cdf') +EXAMPLE_GML_RADIATION = DATASETS.fetch('brw21001.dat') +EXAMPLE_GML_MET = DATASETS.fetch('met_brw_insitu_1_obop_hour_2020.txt') +EXAMPLE_GML_OZONE = DATASETS.fetch('brw_12_2020_hour.dat') +EXAMPLE_GML_CO2 = DATASETS.fetch('co2_brw_surface-insitu_1_ccgg_MonthlyData.txt') +EXAMPLE_GML_HALO = DATASETS.fetch('brw_CCl4_Day.dat') +EXAMPLE_MET_TEST1 = DATASETS.fetch('sgpmet_no_time.nc') +EXAMPLE_MET_TEST2 = DATASETS.fetch('sgpmet_test_time.nc') +EXAMPLE_NOAA_PSL = DATASETS.fetch('ctd21125.15w') +EXAMPLE_NOAA_PSL_TEMPERATURE = DATASETS.fetch('ctd22187.00t.txt') +EXAMPLE_SP2B = DATASETS.fetch('mosaossp2M1.00.20191216.130601.raw.20191216x193.sp2b') +EXAMPLE_INI = DATASETS.fetch('mosaossp2M1.00.20191216.000601.raw.20191216000000.ini') +EXAMPLE_HK = DATASETS.fetch('mosaossp2auxM1.00.20191217.010801.raw.20191216000000.hk') +EXAMPLE_MET_YAML = DATASETS.fetch('sgpmetE13.b1.yaml') +EXAMPLE_CLOUDPHASE = DATASETS.fetch('nsacloudphaseC1.c1.20180601.000000.nc') +EXAMPLE_AAF_ICARTT = DATASETS.fetch('AAFNAV_COR_20181104_R0.ict') +EXAMPLE_NEON = DATASETS.fetch('NEON.D18.BARR.DP1.00002.001.000.010.001.SAAT_1min.2022-10.expanded.20221107T205629Z.csv') +EXAMPLE_NEON_VARIABLE = DATASETS.fetch('NEON.D18.BARR.DP1.00002.001.variables.20221201T110553Z.csv') +EXAMPLE_NEON_POSITION = DATASETS.fetch('NEON.D18.BARR.DP1.00002.001.sensor_positions.20221107T205629Z.csv') +EXAMPLE_DOD = DATASETS.fetch('vdis.b1') +EXAMPLE_EBBR1 = DATASETS.fetch('sgp30ebbrE32.b1.20191125.000000.nc') +EXAMPLE_EBBR2 = DATASETS.fetch('sgp30ebbrE32.b1.20191130.000000.nc') +EXAMPLE_EBBR3 = DATASETS.fetch('sgp30ebbrE13.b1.20190601.000000.nc') +EXAMPLE_ECOR = DATASETS.fetch('sgp30ecorE14.b1.20190601.000000.cdf') +EXAMPLE_SEBS = DATASETS.fetch('sgpsebsE14.b1.20190601.000000.cdf') +EXAMPLE_MFAS_SODAR = DATASETS.fetch('sodar.20230404.mnd') +EXAMPLE_ENA_MET = DATASETS.fetch('enametC1.b1.20221109.000000.cdf') +EXAMPLE_CCN = DATASETS.fetch('sgpaosccn2colaE13.b1.20170903.000000.nc') +EXAMPLE_OLD_QC = DATASETS.fetch('sgp30ecorE6.b1.20040705.000000.cdf') +EXAMPLE_SONDE_WILDCARD = DATASETS.fetch('sgpsondewnpnC1.b1.20190101.053200.cdf') +EXAMPLE_CEIL_WILDCARD = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') +EXAMPLE_HYSPLIT = DATASETS.fetch('houstonaug300.0summer2010080100') -EXAMPLE_MET1 = os.path.join(DATA_PATH, 'sgpmetE13.b1.20190101.000000.cdf') -EXAMPLE_MET_CSV = os.path.join(DATA_PATH, 'sgpmetE13.*csv') -EXAMPLE_METE40 = os.path.join(DATA_PATH, 'sgpmetE40.b1.20190508.000000.cdf') -EXAMPLE_CEIL1 = os.path.join(DATA_PATH, 'sgpceilC1.b1.20190101.000000.nc') -EXAMPLE_SONDE1 = os.path.join(DATA_PATH, - 'sgpsondewnpnC1.b1.20190101.053200.cdf') -EXAMPLE_LCL1 = os.path.join(DATA_PATH, 'met_lcl.nc') -EXAMPLE_SONDE_WILDCARD = os.path.join(DATA_PATH, 'sgpsondewnpn*.cdf') -EXAMPLE_MET_WILDCARD = os.path.join(DATA_PATH, 'sgpmet*201901*.cdf') -EXAMPLE_MET_CONTOUR = os.path.join(DATA_PATH, 'sgpmet*20190508*.cdf') -EXAMPLE_CEIL_WILDCARD = os.path.join(DATA_PATH, 'sgpceil*.cdf') -EXAMPLE_TWP_SONDE_WILDCARD = os.path.join(DATA_PATH, 'twpsondewnpn*.cdf') -EXAMPLE_TWP_SONDE_20060121 = os.path.join(DATA_PATH, 'twpsondewnpn*20060121*.cdf') -EXAMPLE_ANL_CSV = os.path.join(DATA_PATH, 'anltwr_mar19met.data') -EXAMPLE_VISST = os.path.join( - DATA_PATH, 'twpvisstgridirtemp.c1.20050705.002500.nc') -EXAMPLE_MPL_1SAMPLE = os.path.join(DATA_PATH, - 'sgpmplpolfsC1.b1.20190502.000000.cdf') -EXAMPLE_IRT25m20s = os.path.join(DATA_PATH, - 'sgpirt25m20sC1.a0.20190601.000000.cdf') -EXAMPLE_NAV = os.path.join(DATA_PATH, - 'marnavM1.a1.20180201.000000.nc') -EXAMPLE_AOSMET = os.path.join(DATA_PATH, - 'maraosmetM1.a1.20180201.000000.nc') -EXAMPLE_DLPPI = os.path.join(DATA_PATH, 'sgpdlppiC1.b1.20191015.120023.cdf') -EXAMPLE_DLPPI_MULTI = os.path.join(DATA_PATH, 'sgpdlppiC1.b1.20191015.*.cdf') -EXAMPLE_EBBR1 = os.path.join(DATA_PATH, 'sgp30ebbrE32.b1.20191125.000000.nc') -EXAMPLE_EBBR2 = os.path.join(DATA_PATH, 'sgp30ebbrE32.b1.20191130.000000.nc') -EXAMPLE_BRS = os.path.join(DATA_PATH, 'sgpbrsC1.b1.20190705.000000.cdf') -EXAMPLE_AERI = os.path.join(DATA_PATH, 'sgpaerich1C1.b1.20190501.000342.nc') -EXAMPLE_IRTSST = os.path.join(DATA_PATH, 'marirtsstM1.b1.20190320.000000.nc') -EXAMPLE_MFRSR = os.path.join(DATA_PATH, 'sgpmfrsr7nchE38.b1.20190514.180000.nc') -EXAMPLE_SURFSPECALB1MLAWER = os.path.join( - DATA_PATH, 'nsasurfspecalb1mlawerC1.c1.20160609.080000.nc') -EXAMPLE_SIGMA_MPLV5 = os.path.join(DATA_PATH, '201509021500.bi') -EXAMPLE_RL1 = os.path.join(DATA_PATH, 'sgprlC1.a0.20160131.000000.nc') -EXAMPLE_CO2FLX4M = os.path.join(DATA_PATH, 'sgpco2flx4mC1.b1.20201007.001500.nc') -EXAMPLE_SIRS = os.path.join(DATA_PATH, 'sgpsirsE13.b1.20190101.000000.cdf') -EXAMPLE_GML_RADIATION = os.path.join(DATA_PATH, 'brw21001.dat') -EXAMPLE_GML_MET = os.path.join(DATA_PATH, 'met_brw_insitu_1_obop_hour_2020.txt') -EXAMPLE_GML_OZONE = os.path.join(DATA_PATH, 'brw_12_2020_hour.dat') -EXAMPLE_GML_CO2 = os.path.join(DATA_PATH, 'co2_brw_surface-insitu_1_ccgg_MonthlyData.txt') -EXAMPLE_GML_HALO = os.path.join(DATA_PATH, 'brw_CCl4_Day.dat') -EXAMPLE_MET_TEST1 = os.path.join(DATA_PATH, 'sgpmet_no_time.nc') -EXAMPLE_MET_TEST2 = os.path.join(DATA_PATH, 'sgpmet_test_time.nc') -EXAMPLE_STAMP_WILDCARD = os.path.join(DATA_PATH, 'sgpstamp*202001*.nc') +# Multiple files in a list +dlppi_multi_list = ['sgpdlppiC1.b1.20191015.120023.cdf', + 'sgpdlppiC1.b1.20191015.121506.cdf'] +EXAMPLE_DLPPI_MULTI = [DATASETS.fetch(file) for file in dlppi_multi_list] +noaa_psl_list = ['ayp22199.21m', + 'ayp22200.00m'] +EXAMPLE_NOAA_PSL_SURFACEMET = [DATASETS.fetch(file) for file in noaa_psl_list] +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] +EXAMPLE_MET_WILDCARD = [DATASETS.fetch(file) for file in met_wildcard_list] +met_contour_list = ['sgpmetE15.b1.20190508.000000.cdf', + 'sgpmetE31.b1.20190508.000000.cdf', + 'sgpmetE32.b1.20190508.000000.cdf', + 'sgpmetE33.b1.20190508.000000.cdf', + 'sgpmetE34.b1.20190508.000000.cdf', + 'sgpmetE35.b1.20190508.000000.cdf', + 'sgpmetE36.b1.20190508.000000.cdf', + 'sgpmetE37.b1.20190508.000000.cdf', + 'sgpmetE38.b1.20190508.000000.cdf', + 'sgpmetE39.b1.20190508.000000.cdf', + 'sgpmetE40.b1.20190508.000000.cdf', + 'sgpmetE9.b1.20190508.000000.cdf', + 'sgpmetE13.b1.20190508.000000.cdf'] +EXAMPLE_MET_CONTOUR = [DATASETS.fetch(file) for file in met_contour_list] +twp_sonde_wildcard_list = ['twpsondewnpnC3.b1.20060119.050300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', + 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', + 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', + 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', + 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', + 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', + 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', + 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', + 'twpsondewnpnC3.b1.20060124.231500.custom.cdf'] +EXAMPLE_TWP_SONDE_WILDCARD = [DATASETS.fetch(file) for file in twp_sonde_wildcard_list] +twp_sonde_20060121_list = ['twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf'] +EXAMPLE_TWP_SONDE_20060121 = [DATASETS.fetch(file) for file in twp_sonde_20060121_list] +stamp_wildcard_list = ['sgpstampE13.b1.20200101.000000.nc', + 'sgpstampE31.b1.20200101.000000.nc', + 'sgpstampE32.b1.20200101.000000.nc', + 'sgpstampE33.b1.20200101.000000.nc', + 'sgpstampE34.b1.20200101.000000.nc', + 'sgpstampE9.b1.20200101.000000.nc'] +EXAMPLE_STAMP_WILDCARD = [DATASETS.fetch(file) for file in stamp_wildcard_list] +mmcr_list = ['sgpmmcrC1.b1.1.cdf', + 'sgpmmcrC1.b1.2.cdf'] +EXAMPLE_MMCR = [DATASETS.fetch(file) for file in mmcr_list] diff --git a/act/tests/test_correct.py b/act/tests/test_correct.py deleted file mode 100644 index 979203d99d..0000000000 --- a/act/tests/test_correct.py +++ /dev/null @@ -1,107 +0,0 @@ -import act -import numpy as np -import xarray as xr - - -def test_correct_ceil(): - # Make a fake ARM dataset to test with, just an array with 1e-7 for half - # of it - fake_data = 10 * np.ones((300, 20)) - fake_data[:, 10:] = -1 - arm_obj = {} - arm_obj['backscatter'] = xr.DataArray(fake_data) - arm_obj = act.corrections.ceil.correct_ceil(arm_obj) - assert np.all(arm_obj['backscatter'].data[:, 10:] == -7) - assert np.all(arm_obj['backscatter'].data[:, 1:10] == 1) - - -def test_correct_mpl(): - # Make a fake ARM dataset to test with, just an array with 1e-7 for half - # of it - test_data = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_MPL_1SAMPLE) - obj = act.corrections.mpl.correct_mpl(test_data) - sig_cross_pol = obj['signal_return_cross_pol'].values[1, 10:15] - sig_co_pol = obj['signal_return_co_pol'].values[1, 10:15] - height = obj['height'].values[0:10] - overlap0 = obj['overlap_correction'].values[1, 0, 0:5] - overlap1 = obj['overlap_correction'].values[1, 1, 0:5] - overlap2 = obj['overlap_correction'].values[1, 2, 0:5] - np.testing.assert_allclose( - overlap0, [0., 0., 0., 0., 0.]) - np.testing.assert_allclose( - overlap1, [754.338, 754.338, 754.338, 754.338, 754.338]) - np.testing.assert_allclose( - overlap2, [181.9355, 181.9355, 181.9355, 181.9355, - 181.9355]) - np.testing.assert_allclose( - sig_cross_pol, [-0.5823283, -1.6066532, -1.7153032, - -2.520143, -2.275405], rtol=4e-07) - np.testing.assert_allclose( - sig_co_pol, [12.5631485, 11.035495, 11.999875, - 11.09393, 11.388968]) - np.testing.assert_allclose( - height, [0.00749012, 0.02247084, 0.03745109, - 0.05243181, 0.06741206, 0.08239277, 0.09737302, - 0.11235374, 0.12733398, 0.14231472], rtol=1e-6) - assert obj['signal_return_co_pol'].attrs['units'] == '10 * log10(count/us)' - assert obj['signal_return_cross_pol'].attrs['units'] == '10 * log10(count/us)' - assert obj['cross_co_ratio'].attrs['long_name'] == 'Cross-pol / Co-pol ratio * 100' - assert obj['cross_co_ratio'].attrs['units'] == 'LDR' - assert 'description' not in obj['cross_co_ratio'].attrs.keys() - assert 'ancillary_variables' not in obj['cross_co_ratio'].attrs.keys() - assert np.all(np.round(obj['cross_co_ratio'].data[0, 500]) == 34.) - assert np.all(np.round(obj['signal_return_co_pol'].data[0, 11]) == 11) - assert np.all(np.round(obj['signal_return_co_pol'].data[0, 500]) == -6) - test_data.close() - obj.close() - - -def test_correct_wind(): - nav = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_NAV) - nav = act.utils.ship_utils.calc_cog_sog(nav) - - aosmet = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_AOSMET) - - obj = xr.merge([nav, aosmet], compat='override') - obj = act.corrections.ship.correct_wind(obj) - - assert round(obj['wind_speed_corrected'].values[800]) == 5.0 - assert round(obj['wind_direction_corrected'].values[800]) == 92.0 - - -def test_correct_dl(): - # Test the DL correction script on a PPI dataset eventhough it will - # mostlikely be used on FPT scans. Doing this to save space with only - # one datafile in the repo. - files = act.tests.sample_files.EXAMPLE_DLPPI - obj = act.io.armfiles.read_netcdf(files) - - new_obj = act.corrections.doppler_lidar.correct_dl(obj, fill_value=np.nan) - data = new_obj['attenuated_backscatter'].data - data[np.isnan(data)] = 0. - data = data * 100. - data = data.astype(np.int64) - assert np.sum(data) == -18633551 - - new_obj = act.corrections.doppler_lidar.correct_dl(obj, range_normalize=False) - data = new_obj['attenuated_backscatter'].data - data[np.isnan(data)] = 0. - data = data.astype(np.int64) - assert np.sum(data) == -224000 - - -def test_correct_rl(): - # Using ceil data in RL place to save memory - files = act.tests.sample_files.EXAMPLE_RL1 - obj = act.io.armfiles.read_netcdf(files) - - obj = act.corrections.raman_lidar.correct_rl(obj, - range_normalize_log_values=True) - np.testing.assert_almost_equal(np.max(obj['depolarization_counts_high'].values), - 9.91, decimal=2) - np.testing.assert_almost_equal(np.min(obj['depolarization_counts_high'].values), - -7.00, decimal=2) - np.testing.assert_almost_equal(np.mean(obj['depolarization_counts_high'].values), - -1.45, decimal=2) diff --git a/act/tests/test_discovery.py b/act/tests/test_discovery.py deleted file mode 100644 index 7f93b55ed1..0000000000 --- a/act/tests/test_discovery.py +++ /dev/null @@ -1,79 +0,0 @@ -import act -import requests -import numpy as np -import os -import glob -from datetime import datetime -from act.discovery import get_asos -from requests.packages.urllib3.exceptions import InsecureRequestWarning -requests.packages.urllib3.disable_warnings(InsecureRequestWarning) - - -def test_cropType(): - year = 2018 - lat = 37.1509 - lon = -98.362 - try: - crop = act.discovery.get_CropScape.croptype(lat, lon, year) - crop2 = act.discovery.get_CropScape.croptype(lat, lon) - except Exception: - return - - if crop is not None: - assert crop == 'Grass/Pasture' - if crop2 is not None: - assert crop2 == 'Soybeans' - - -def test_get_ord(): - time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 12, 10, 0)] - my_asoses = get_asos(time_window, station="ORD") - assert "ORD" in my_asoses.keys() - assert np.all( - np.equal(my_asoses["ORD"]["sknt"].values[:10], - np.array([13., 11., 14., 14., 13., 11., 14., 13., 13., 13.]))) - - -def test_get_region(): - my_keys = ['MDW', 'IGQ', 'ORD', '06C', 'PWK', 'LOT', 'GYY'] - time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 12, 10, 0)] - lat_window = (41.8781 - 0.5, 41.8781 + 0.5) - lon_window = (-87.6298 - 0.5, -87.6298 + 0.5) - my_asoses = get_asos(time_window, lat_range=lat_window, lon_range=lon_window) - asos_keys = [x for x in my_asoses.keys()] - assert asos_keys == my_keys - - -def test_get_armfile(): - if not os.path.isdir((os.getcwd() + '/data/')): - os.makedirs((os.getcwd() + '/data/')) - - uname = os.getenv('ARM_USERNAME') - token = os.getenv('ARM_PASSWORD') - - if uname is not None: - datastream = 'sgpmetE13.b1' - startdate = '2020-01-01' - enddate = startdate - outdir = os.getcwd() + '/data/' - - results = act.discovery.get_armfiles.download_data(uname, token, - datastream, - startdate, enddate, - output=outdir) - files = glob.glob(outdir + datastream + '*20200101*cdf') - if len(results) > 0: - assert files is not None - assert 'sgpmetE13' in files[0] - - if files is not None: - if len(files) > 0: - os.remove(files[0]) - - datastream = 'sgpmeetE13.b1' - act.discovery.get_armfiles.download_data(uname, token, - datastream, - startdate, enddate, - output=outdir) - files = glob.glob(outdir + datastream + '*20200101*cdf') - assert len(files) == 0 diff --git a/act/tests/test_io.py b/act/tests/test_io.py deleted file mode 100644 index 9555d6fd35..0000000000 --- a/act/tests/test_io.py +++ /dev/null @@ -1,269 +0,0 @@ -import act -from act.io.noaagml import read_gml -import act.tests.sample_files as sample_files -from pathlib import Path -import tempfile -import numpy as np -import glob - - -def test_io(): - sonde_ds = act.io.armfiles.read_netcdf([act.tests.EXAMPLE_MET1]) - assert 'temp_mean' in sonde_ds.variables.keys() - assert 'rh_mean' in sonde_ds.variables.keys() - assert sonde_ds.attrs['_arm_standards_flag'] == (1 << 0) - - with np.testing.assert_raises(OSError): - act.io.armfiles.read_netcdf([]) - - result = act.io.armfiles.read_netcdf([], return_None=True) - assert result is None - result = act.io.armfiles.read_netcdf(['./randomfile.nc'], return_None=True) - assert result is None - - obj = act.io.armfiles.read_netcdf([act.tests.EXAMPLE_MET_TEST1]) - assert 'time' in obj - - obj = act.io.armfiles.read_netcdf([act.tests.EXAMPLE_MET_TEST2]) - assert obj['time'].values[10] == np.datetime64('2019-01-01T00:10:00') - sonde_ds.close() - - -def test_io_mfdataset(): - sonde_ds = act.io.armfiles.read_netcdf( - act.tests.EXAMPLE_MET_WILDCARD) - assert 'temp_mean' in sonde_ds.variables.keys() - assert 'rh_mean' in sonde_ds.variables.keys() - assert len(sonde_ds.attrs['_file_times']) == 7 - assert sonde_ds.attrs['_arm_standards_flag'] == (1 << 0) - sonde_ds.close() - - -def test_io_csv(): - headers = ['day', 'month', 'year', 'time', 'pasquill', - 'wdir_60m', 'wspd_60m', 'wdir_60m_std', - 'temp_60m', 'wdir_10m', 'wspd_10m', - 'wdir_10m_std', 'temp_10m', 'temp_dp', - 'rh', 'avg_temp_diff', 'total_precip', - 'solar_rad', 'net_rad', 'atmos_press', - 'wv_pressure', 'temp_soil_10cm', - 'temp_soil_100cm', 'temp_soil_10ft'] - anl_ds = act.io.csvfiles.read_csv( - act.tests.EXAMPLE_ANL_CSV, sep='\s+', column_names=headers) - assert 'temp_60m' in anl_ds.variables.keys() - assert 'rh' in anl_ds.variables.keys() - assert anl_ds['temp_60m'].values[10] == -1.7 - anl_ds.close() - - files = glob.glob(act.tests.EXAMPLE_MET_CSV) - obj = act.io.csvfiles.read_csv(files[0]) - assert 'date_time' in obj - assert '_datastream' in obj.attrs - - -def test_io_dod(): - dims = {'time': 1440, 'drop_diameter': 50} - - try: - obj = act.io.armfiles.create_obj_from_arm_dod('vdis.b1', dims, version='1.2', - scalar_fill_dim='time') - assert 'moment1' in obj - assert len(obj['base_time'].values) == 1440 - assert len(obj['drop_diameter'].values) == 50 - with np.testing.assert_warns(UserWarning): - obj2 = act.io.armfiles.create_obj_from_arm_dod('vdis.b1', dims, - scalar_fill_dim='time') - assert 'moment1' in obj2 - assert len(obj2['base_time'].values) == 1440 - assert len(obj2['drop_diameter'].values) == 50 - with np.testing.assert_raises(ValueError): - obj = act.io.armfiles.create_obj_from_arm_dod('vdis.b1', {}, version='1.2') - - except Exception: - return - obj.close() - obj2.close() - - -def test_io_write(): - sonde_ds = act.io.armfiles.read_netcdf(sample_files.EXAMPLE_SONDE1) - sonde_ds.clean.cleanup() - - with tempfile.TemporaryDirectory() as tmpdirname: - write_file = Path(tmpdirname, Path(sample_files.EXAMPLE_SONDE1).name) - keep_vars = ['tdry', 'qc_tdry', 'dp', 'qc_dp'] - for var_name in list(sonde_ds.data_vars): - if var_name not in keep_vars: - del sonde_ds[var_name] - sonde_ds.write.write_netcdf(path=write_file, FillValue=-9999) - - sonde_ds_read = act.io.armfiles.read_netcdf(str(write_file)) - assert list(sonde_ds_read.data_vars) == keep_vars - assert isinstance(sonde_ds_read['qc_tdry'].attrs['flag_meanings'], str) - assert sonde_ds_read['qc_tdry'].attrs['flag_meanings'].count('__') == 21 - for attr in ['qc_standards_version', 'qc_method', 'qc_comment']: - assert attr not in list(sonde_ds_read.attrs) - sonde_ds_read.close() - del sonde_ds_read - - sonde_ds.close() - - sonde_ds = act.io.armfiles.read_netcdf(sample_files.EXAMPLE_EBBR1) - sonde_ds.clean.cleanup() - assert 'fail_min' in sonde_ds['qc_home_signal_15'].attrs - assert 'standard_name' in sonde_ds['qc_home_signal_15'].attrs - assert 'flag_masks' in sonde_ds['qc_home_signal_15'].attrs - - with tempfile.TemporaryDirectory() as tmpdirname: - cf_convention = 'CF-1.8' - write_file = Path(tmpdirname, Path(sample_files.EXAMPLE_EBBR1).name) - sonde_ds.write.write_netcdf(path=write_file, make_copy=False, join_char='_', - cf_compliant=True, cf_convention=cf_convention) - - sonde_ds_read = act.io.armfiles.read_netcdf(str(write_file)) - - assert cf_convention in sonde_ds_read.attrs['Conventions'].split() - assert sonde_ds_read.attrs['FeatureType'] == 'timeSeries' - global_att_keys = [ii for ii in sonde_ds_read.attrs.keys() if not ii.startswith('_')] - assert global_att_keys[-1] == 'history' - assert sonde_ds_read['alt'].attrs['axis'] == 'Z' - assert sonde_ds_read['alt'].attrs['positive'] == 'up' - - sonde_ds_read.close() - del sonde_ds_read - - sonde_ds.close() - - obj = act.io.armfiles.read_netcdf(sample_files.EXAMPLE_CEIL1) - with tempfile.TemporaryDirectory() as tmpdirname: - cf_convention = 'CF-1.8' - write_file = Path(tmpdirname, Path(sample_files.EXAMPLE_CEIL1).name) - obj.write.write_netcdf(path=write_file, make_copy=False, join_char='_', - cf_compliant=True, cf_convention=cf_convention) - - obj_read = act.io.armfiles.read_netcdf(str(write_file)) - - assert cf_convention in obj_read.attrs['Conventions'].split() - assert obj_read.attrs['FeatureType'] == 'timeSeriesProfile' - assert len(obj_read.dims) > 1 - - obj_read.close() - del obj_read - - -def test_io_mpldataset(): - try: - mpl_ds = act.io.mpl.read_sigma_mplv5( - act.tests.EXAMPLE_SIGMA_MPLV5) - except Exception: - return - - # Tests fields - assert 'channel_1' in mpl_ds.variables.keys() - assert 'temp_0' in mpl_ds.variables.keys() - assert mpl_ds.channel_1.values.shape == (102, 1000) - - # Tests coordinates - assert 'time' in mpl_ds.coords.keys() - assert 'range' in mpl_ds.coords.keys() - assert mpl_ds.coords['time'].values.shape == (102, ) - assert mpl_ds.coords['range'].values.shape == (1000, ) - assert '_arm_standards_flag' in mpl_ds.attrs.keys() - - # Tests attributes - assert '_datastream' in mpl_ds.attrs.keys() - mpl_ds.close() - - -def test_read_gml(): - # Test Radiation - ds = read_gml(sample_files.EXAMPLE_GML_RADIATION, datatype='RADIATION') - assert np.isclose(np.nansum(ds['solar_zenith_angle']), 1629.68) - assert np.isclose(np.nansum(ds['upwelling_infrared_case_temp']), 4185.73) - assert (ds['upwelling_infrared_case_temp'].attrs['ancillary_variables'] == - 'qc_upwelling_infrared_case_temp') - assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_values'] == [0, 1, 2] - assert (ds['qc_upwelling_infrared_case_temp'].attrs['flag_meanings'] == - ['Not failing any tests', 'Knowingly bad value', 'Should be used with scrutiny']) - assert (ds['qc_upwelling_infrared_case_temp'].attrs['flag_assessments'] == - ['Good', 'Bad', 'Indeterminate']) - assert ds['time'].values[-1] == np.datetime64('2021-01-01T00:17:00') - - ds = read_gml(sample_files.EXAMPLE_GML_RADIATION, convert_missing=False) - assert np.isclose(np.nansum(ds['solar_zenith_angle']), 1629.68) - assert np.isclose(np.nansum(ds['upwelling_infrared_case_temp']), 4185.73) - assert (ds['upwelling_infrared_case_temp'].attrs['ancillary_variables'] == - 'qc_upwelling_infrared_case_temp') - assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_values'] == [0, 1, 2] - assert (ds['qc_upwelling_infrared_case_temp'].attrs['flag_meanings'] == - ['Not failing any tests', 'Knowingly bad value', 'Should be used with scrutiny']) - assert (ds['qc_upwelling_infrared_case_temp'].attrs['flag_assessments'] == - ['Good', 'Bad', 'Indeterminate']) - assert ds['time'].values[-1] == np.datetime64('2021-01-01T00:17:00') - - # Test MET - ds = read_gml(sample_files.EXAMPLE_GML_MET, datatype='MET') - assert np.isclose(np.nansum(ds['wind_speed'].values), 140.999) - assert ds['wind_speed'].attrs['units'] == 'm/s' - assert np.isnan(ds['wind_speed'].attrs['_FillValue']) - assert np.sum(np.isnan(ds['preciptation_intensity'].values)) == 19 - assert ds['preciptation_intensity'].attrs['units'] == 'mm/hour' - assert ds['time'].values[0] == np.datetime64('2020-01-01T01:00:00') - - ds = read_gml(sample_files.EXAMPLE_GML_MET, convert_missing=False) - assert np.isclose(np.nansum(ds['wind_speed'].values), 140.999) - assert ds['wind_speed'].attrs['units'] == 'm/s' - assert np.isclose(ds['wind_speed'].attrs['_FillValue'], -999.9) - assert np.sum(ds['preciptation_intensity'].values) == -1881 - assert ds['preciptation_intensity'].attrs['units'] == 'mm/hour' - assert ds['time'].values[0] == np.datetime64('2020-01-01T01:00:00') - - # Test Ozone - ds = read_gml(sample_files.EXAMPLE_GML_OZONE, datatype='OZONE') - assert np.isclose(np.nansum(ds['ozone'].values), 582.76) - assert ds['ozone'].attrs['long_name'] == 'Ozone' - assert ds['ozone'].attrs['units'] == 'ppb' - assert np.isnan(ds['ozone'].attrs['_FillValue']) - assert ds['time'].values[0] == np.datetime64('2020-12-01T00:00:00') - - ds = read_gml(sample_files.EXAMPLE_GML_OZONE) - assert np.isclose(np.nansum(ds['ozone'].values), 582.76) - assert ds['ozone'].attrs['long_name'] == 'Ozone' - assert ds['ozone'].attrs['units'] == 'ppb' - assert np.isnan(ds['ozone'].attrs['_FillValue']) - assert ds['time'].values[0] == np.datetime64('2020-12-01T00:00:00') - - # Test Carbon Dioxide - ds = read_gml(sample_files.EXAMPLE_GML_CO2, datatype='co2') - assert np.isclose(np.nansum(ds['co2'].values), 2307.630) - assert (ds['qc_co2'].values == - np.array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], dtype=int)).all() - assert ds['co2'].attrs['units'] == 'ppm' - assert np.isnan(ds['co2'].attrs['_FillValue']) - assert ds['qc_co2'].attrs['flag_assessments'] == ['Bad', 'Indeterminate'] - assert ds['latitude'].attrs['standard_name'] == 'latitude' - - ds = read_gml(sample_files.EXAMPLE_GML_CO2, convert_missing=False) - assert np.isclose(np.nansum(ds['co2'].values), -3692.3098) - assert ds['co2'].attrs['_FillValue'] == -999.99 - assert (ds['qc_co2'].values == - np.array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], dtype=int)).all() - assert ds['co2'].attrs['units'] == 'ppm' - assert np.isclose(ds['co2'].attrs['_FillValue'], -999.99) - assert ds['qc_co2'].attrs['flag_assessments'] == ['Bad', 'Indeterminate'] - assert ds['latitude'].attrs['standard_name'] == 'latitude' - - # Test Halocarbon - ds = read_gml(sample_files.EXAMPLE_GML_HALO, datatype='HALO') - assert np.isclose(np.nansum(ds['CCl4'].values), 1342.6499) - assert ds['CCl4'].attrs['units'] == 'ppt' - assert ds['CCl4'].attrs['long_name'] == 'Carbon Tetrachloride (CCl4) daily median' - assert np.isnan(ds['CCl4'].attrs['_FillValue']) - assert ds['time'].values[0] == np.datetime64('1998-06-16T00:00:00') - - ds = read_gml(sample_files.EXAMPLE_GML_HALO) - assert np.isclose(np.nansum(ds['CCl4'].values), 1342.6499) - assert ds['CCl4'].attrs['units'] == 'ppt' - assert ds['CCl4'].attrs['long_name'] == 'Carbon Tetrachloride (CCl4) daily median' - assert np.isnan(ds['CCl4'].attrs['_FillValue']) - assert ds['time'].values[0] == np.datetime64('1998-06-16T00:00:00') diff --git a/act/tests/test_plotting.py b/act/tests/test_plotting.py deleted file mode 100644 index f1a20f0b4e..0000000000 --- a/act/tests/test_plotting.py +++ /dev/null @@ -1,746 +0,0 @@ -import pytest -import numpy as np -import glob -import xarray as xr -import pandas as pd -import os -import act -import act.io.armfiles as arm -import act.tests.sample_files as sample_files -from act.plotting import TimeSeriesDisplay, WindRoseDisplay -from act.plotting import SkewTDisplay, XSectionDisplay -from act.plotting import GeographicPlotDisplay, HistogramDisplay -from act.plotting import ContourDisplay -from act.utils.data_utils import accumulate_precip -import matplotlib -matplotlib.use('Agg') -try: - import metpy.calc as mpcalc - METPY = True -except ImportError: - METPY = False - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_plot(): - # Process MET data to get simple LCL - files = sample_files.EXAMPLE_MET_WILDCARD - met = arm.read_netcdf(files) - met_temp = met.temp_mean - met_rh = met.rh_mean - met_lcl = (20. + met_temp / 5.) * (100. - met_rh) / 1000. - met['met_lcl'] = met_lcl * 1000. - met['met_lcl'].attrs['units'] = 'm' - met['met_lcl'].attrs['long_name'] = 'LCL Calculated from SGP MET E13' - - # Plot data - display = TimeSeriesDisplay(met) - display.add_subplots((2, 2), figsize=(15, 10)) - display.plot('wspd_vec_mean', subplot_index=(0, 0)) - display.plot('temp_mean', subplot_index=(1, 0)) - display.plot('rh_mean', subplot_index=(0, 1)) - - windrose = WindRoseDisplay(met) - display.put_display_in_subplot(windrose, subplot_index=(1, 1)) - windrose.plot('wdir_vec_mean', 'wspd_vec_mean', - spd_bins=np.linspace(0, 10, 4)) - windrose.axes[0].legend(loc='best') - met.close() - return display.fig - - -def test_errors(): - files = sample_files.EXAMPLE_MET_WILDCARD - obj = arm.read_netcdf(files) - - display = TimeSeriesDisplay(obj) - display.axes = None - with np.testing.assert_raises(RuntimeError): - display.day_night_background() - - display = TimeSeriesDisplay({'met': obj, 'met2': obj}) - with np.testing.assert_raises(ValueError): - display.plot('temp_mean') - with np.testing.assert_raises(ValueError): - display.qc_flag_block_plot('qc_temp_mean') - with np.testing.assert_raises(ValueError): - display.plot_barbs_from_spd_dir('wdir_vec_mean', 'wspd_vec_mean') - with np.testing.assert_raises(ValueError): - display.plot_barbs_from_u_v('wdir_vec_mean', 'wspd_vec_mean') - - del obj.attrs['_file_dates'] - - data = np.empty(len(obj['time'])) * np.nan - lat = obj['lat'].values - lon = obj['lon'].values - obj['lat'].values = data - obj['lon'].values = data - - display = TimeSeriesDisplay(obj) - display.plot('temp_mean') - display.set_yrng([0, 0]) - with np.testing.assert_warns(RuntimeWarning): - display.day_night_background() - obj['lat'].values = lat - with np.testing.assert_warns(RuntimeWarning): - display.day_night_background() - obj['lon'].values = lon * 100. - with np.testing.assert_warns(RuntimeWarning): - display.day_night_background() - obj['lat'].values = lat * 100. - with np.testing.assert_warns(RuntimeWarning): - display.day_night_background() - - obj.close() - - # Test some of the other errors - obj = arm.read_netcdf(files) - del obj['temp_mean'].attrs['units'] - display = TimeSeriesDisplay(obj) - display.axes = None - with np.testing.assert_raises(RuntimeError): - display.set_yrng([0, 10]) - with np.testing.assert_raises(RuntimeError): - display.set_xrng([0, 10]) - display.fig = None - display.plot('temp_mean', add_nan=True) - - assert display.fig is not None - assert display.axes is not None - - with np.testing.assert_raises(AttributeError): - display = TimeSeriesDisplay([]) - - fig, ax = matplotlib.pyplot.subplots() - display = TimeSeriesDisplay(obj) - display.add_subplots((2, 2), figsize=(15, 10)) - display.assign_to_figure_axis(fig, ax) - assert display.fig is not None - assert display.axes is not None - - obj = arm.read_netcdf(files) - display = TimeSeriesDisplay(obj) - obj.clean.cleanup() - display.axes = None - display.fig = None - display.qc_flag_block_plot('atmos_pressure') - assert display.fig is not None - assert display.axes is not None - - -def test_histogram_errors(): - files = sample_files.EXAMPLE_MET1 - obj = arm.read_netcdf(files) - - histdisplay = HistogramDisplay(obj) - histdisplay.axes = None - with np.testing.assert_raises(RuntimeError): - histdisplay.set_yrng([0, 10]) - with np.testing.assert_raises(RuntimeError): - histdisplay.set_xrng([-40, 40]) - histdisplay.fig = None - histdisplay.plot_stacked_bar_graph('temp_mean', bins=np.arange(-40, 40, 5)) - histdisplay.set_yrng([0, 0]) - assert histdisplay.yrng[0][1] == 1. - assert histdisplay.fig is not None - assert histdisplay.axes is not None - - with np.testing.assert_raises(AttributeError): - HistogramDisplay([]) - - histdisplay.axes = None - histdisplay.fig = None - histdisplay.plot_stairstep_graph('temp_mean', bins=np.arange(-40, 40, 5)) - assert histdisplay.fig is not None - assert histdisplay.axes is not None - - sigma = 10 - mu = 50 - bins = np.linspace(0, 100, 50) - ydata = 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-(bins - mu)**2 / (2 * sigma**2)) - y_array = xr.DataArray(ydata, dims={'bins': bins}) - bins = xr.DataArray(bins, dims={'bins': bins}) - my_fake_ds = xr.Dataset({'bins': bins, 'ydata': y_array}) - histdisplay = HistogramDisplay(my_fake_ds) - histdisplay.axes = None - histdisplay.fig = None - histdisplay.plot_size_distribution('ydata', 'bins', set_title='Fake distribution.') - assert histdisplay.fig is not None - assert histdisplay.axes is not None - - sonde_ds = arm.read_netcdf(sample_files.EXAMPLE_SONDE1) - histdisplay = HistogramDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - histdisplay.axes = None - histdisplay.fig = None - histdisplay.plot_heatmap('tdry', 'alt', x_bins=np.arange(-60, 10, 1), - y_bins=np.linspace(0, 10000., 50), cmap='coolwarm') - assert histdisplay.fig is not None - assert histdisplay.axes is not None - - -def test_xsection_errors(): - obj = arm.read_netcdf(sample_files.EXAMPLE_CEIL1) - - display = XSectionDisplay(obj, figsize=(10, 8), subplot_shape=(2,)) - display.axes = None - with np.testing.assert_raises(RuntimeError): - display.set_yrng([0, 10]) - with np.testing.assert_raises(RuntimeError): - display.set_xrng([-40, 40]) - - display = XSectionDisplay(obj, figsize=(10, 8), subplot_shape=(1,)) - with np.testing.assert_raises(RuntimeError): - display.plot_xsection(None, 'backscatter', x='time') - - obj.close() - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_multidataset_plot_tuple(): - obj = arm.read_netcdf(sample_files.EXAMPLE_MET1) - obj2 = arm.read_netcdf(sample_files.EXAMPLE_SIRS) - obj = obj.rename({'lat': 'fun_time'}) - obj['fun_time'].attrs['standard_name'] = 'latitude' - obj = obj.rename({'lon': 'not_so_fun_time'}) - obj['not_so_fun_time'].attrs['standard_name'] = 'longitude' - - # You can use tuples if the datasets in the tuple contain a - # datastream attribute. This is required in all ARM datasets. - display = TimeSeriesDisplay( - (obj, obj2), subplot_shape=(2,), figsize=(15, 10)) - display.plot('short_direct_normal', 'sgpsirsE13.b1', subplot_index=(0,)) - display.day_night_background('sgpsirsE13.b1', subplot_index=(0,)) - display.plot('temp_mean', 'sgpmetE13.b1', subplot_index=(1,)) - display.day_night_background('sgpmetE13.b1', subplot_index=(1,)) - - ax = act.plotting.common.parse_ax(ax=None) - ax, fig = act.plotting.common.parse_ax_fig(ax=None, fig=None) - obj.close() - obj2.close() - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_multidataset_plot_dict(): - - obj = arm.read_netcdf(sample_files.EXAMPLE_MET1) - obj2 = arm.read_netcdf(sample_files.EXAMPLE_SIRS) - - # You can use tuples if the datasets in the tuple contain a - # datastream attribute. This is required in all ARM datasets. - display = TimeSeriesDisplay( - {'sirs': obj2, 'met': obj}, - subplot_shape=(2,), figsize=(15, 10)) - display.plot('short_direct_normal', 'sirs', subplot_index=(0,)) - display.day_night_background('sirs', subplot_index=(0,)) - display.plot('temp_mean', 'met', subplot_index=(1,)) - display.day_night_background('met', subplot_index=(1,)) - obj.close() - obj2.close() - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_wind_rose(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_TWP_SONDE_WILDCARD) - - WindDisplay = WindRoseDisplay(sonde_ds, figsize=(10, 10)) - WindDisplay.plot('deg', 'wspd', - spd_bins=np.linspace(0, 20, 10), num_dirs=30, - tick_interval=2, cmap='viridis') - WindDisplay.set_thetarng(trng=(0., 360.)) - WindDisplay.set_rrng((0., 14)) - - sonde_ds.close() - return WindDisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_barb_sounding_plot(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_TWP_SONDE_WILDCARD) - BarbDisplay = TimeSeriesDisplay({'sonde_darwin': sonde_ds}) - BarbDisplay.plot_time_height_xsection_from_1d_data('rh', 'pres', - cmap='coolwarm_r', - vmin=0, vmax=100, - num_time_periods=25) - BarbDisplay.plot_barbs_from_spd_dir('deg', 'wspd', 'pres', - num_barbs_x=20) - sonde_ds.close() - return BarbDisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_skewt_plot(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - if METPY: - skewt = SkewTDisplay(sonde_ds) - skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp') - sonde_ds.close() - return skewt.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_skewt_plot_spd_dir(): - sonde_ds = arm.read_netcdf(sample_files.EXAMPLE_SONDE1) - - if METPY: - skewt = SkewTDisplay(sonde_ds, ds_name='act_datastream') - skewt.plot_from_spd_and_dir('wspd', 'deg', 'pres', 'tdry', 'dp') - sonde_ds.close() - return skewt.fig - - -@pytest.mark.mpl_image_compare(tolerance=67) -def test_multi_skewt_plot(): - - files = glob.glob(sample_files.EXAMPLE_TWP_SONDE_20060121) - test = {} - for f in files: - time = f.split('.')[-3] - sonde_ds = arm.read_netcdf(f) - test.update({time: sonde_ds}) - - if METPY: - skewt = SkewTDisplay(test, subplot_shape=(2, 2)) - i = 0 - j = 0 - for f in files: - time = f.split('.')[-3] - skewt.plot_from_spd_and_dir('wspd', 'deg', 'pres', 'tdry', 'dp', - subplot_index=(j, i), dsname=time, - p_levels_to_plot=np.arange(10., 1000., 25)) - if j == 1: - i += 1 - j = 0 - elif j == 0: - j += 1 - return skewt.fig - - -@pytest.mark.mpl_image_compare(tolerance=31) -def test_xsection_plot(): - visst_ds = arm.read_netcdf( - sample_files.EXAMPLE_CEIL1) - - xsection = XSectionDisplay(visst_ds, figsize=(10, 8)) - xsection.plot_xsection(None, 'backscatter', x='time', y='range', - cmap='coolwarm', vmin=0, vmax=320) - visst_ds.close() - return xsection.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_xsection_plot_map(): - radar_ds = arm.read_netcdf( - sample_files.EXAMPLE_VISST, combine='nested') - try: - xsection = XSectionDisplay(radar_ds, figsize=(15, 8)) - xsection.plot_xsection_map(None, 'ir_temperature', vmin=220, vmax=300, cmap='Greys', - x='longitude', y='latitude', isel_kwargs={'time': 0}) - radar_ds.close() - return xsection.fig - except Exception: - pass - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_geoplot(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - try: - geodisplay = GeographicPlotDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - geodisplay.geoplot('tdry', marker='.', cartopy_feature=['STATES', 'LAND', 'OCEAN', 'COASTLINE', - 'BORDERS', 'LAKES', 'RIVERS'], - text={'Ponca City': [-97.0725, 36.7125]}) - return geodisplay.fig - except Exception: - pass - sonde_ds.close() - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_stair_graph(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - histdisplay = HistogramDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - histdisplay.plot_stairstep_graph('tdry', bins=np.arange(-60, 10, 1)) - sonde_ds.close() - - return histdisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_stair_graph_sorted(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - histdisplay = HistogramDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - histdisplay.plot_stairstep_graph( - 'tdry', bins=np.arange(-60, 10, 1), sortby_field="alt", - sortby_bins=np.linspace(0, 10000., 6)) - sonde_ds.close() - - return histdisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_stacked_bar_graph(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - histdisplay = HistogramDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - histdisplay.plot_stacked_bar_graph('tdry', bins=np.arange(-60, 10, 1)) - sonde_ds.close() - - return histdisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_stacked_bar_graph2(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - histdisplay = HistogramDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - histdisplay.plot_stacked_bar_graph('tdry') - histdisplay.set_yrng([0, 400]) - histdisplay.set_xrng([-70, 0]) - sonde_ds.close() - - return histdisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_stacked_bar_graph_sorted(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - histdisplay = HistogramDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - histdisplay.plot_stacked_bar_graph( - 'tdry', bins=np.arange(-60, 10, 1), sortby_field="alt", - sortby_bins=np.linspace(0, 10000., 6)) - sonde_ds.close() - - return histdisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_heatmap(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - histdisplay = HistogramDisplay({'sgpsondewnpnC1.b1': sonde_ds}) - histdisplay.plot_heatmap( - 'tdry', 'alt', x_bins=np.arange(-60, 10, 1), - y_bins=np.linspace(0, 10000., 50), cmap='coolwarm') - sonde_ds.close() - - return histdisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_size_distribution(): - sigma = 10 - mu = 50 - bins = np.linspace(0, 100, 50) - ydata = 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-(bins - mu)**2 / (2 * sigma**2)) - y_array = xr.DataArray(ydata, dims={'bins': bins}) - bins = xr.DataArray(bins, dims={'bins': bins}) - my_fake_ds = xr.Dataset({'bins': bins, 'ydata': y_array}) - histdisplay = HistogramDisplay(my_fake_ds) - histdisplay.plot_size_distribution('ydata', 'bins', set_title='Fake distribution.') - return histdisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_contour(): - files = glob.glob(sample_files.EXAMPLE_MET_CONTOUR) - time = '2019-05-08T04:00:00.000000000' - data = {} - fields = {} - wind_fields = {} - station_fields = {} - for f in files: - obj = arm.read_netcdf(f) - data.update({f: obj}) - fields.update({f: ['lon', 'lat', 'temp_mean']}) - wind_fields.update({f: ['lon', 'lat', 'wspd_vec_mean', 'wdir_vec_mean']}) - station_fields.update({f: ['lon', 'lat', 'atmos_pressure']}) - - display = ContourDisplay(data, figsize=(8, 8)) - display.create_contour(fields=fields, time=time, levels=50, - contour='contour', cmap='viridis') - display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, mesh=True, grid_delta=(0.1, 0.1)) - display.plot_station(fields=station_fields, time=time, markersize=7, color='red') - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_contour_stamp(): - files = glob.glob(sample_files.EXAMPLE_STAMP_WILDCARD) - test = {} - stamp_fields = {} - time = '2020-01-01T00:00:00.000000000' - for f in files: - ds = f.split('/')[-1] - obj = act.io.armfiles.read_netcdf(f) - test.update({ds: obj}) - stamp_fields.update({ds: ['lon', 'lat', 'plant_water_availability_east']}) - obj.close() - - display = act.plotting.ContourDisplay(test, figsize=(8, 8)) - display.create_contour(fields=stamp_fields, time=time, levels=50, - alpha=0.5, twod_dim_value=5) - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_contour2(): - files = glob.glob(sample_files.EXAMPLE_MET_CONTOUR) - time = '2019-05-08T04:00:00.000000000' - data = {} - fields = {} - wind_fields = {} - station_fields = {} - for f in files: - obj = arm.read_netcdf(f) - data.update({f: obj}) - fields.update({f: ['lon', 'lat', 'temp_mean']}) - wind_fields.update({f: ['lon', 'lat', 'wspd_vec_mean', 'wdir_vec_mean']}) - station_fields.update({f: ['lon', 'lat', 'atmos_pressure']}) - - display = ContourDisplay(data, figsize=(8, 8)) - display.create_contour(fields=fields, time=time, levels=50, - contour='contour', cmap='viridis') - display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, mesh=False, grid_delta=(0.1, 0.1)) - display.plot_station(fields=station_fields, time=time, markersize=7, color='pink') - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_contourf(): - files = glob.glob(sample_files.EXAMPLE_MET_CONTOUR) - time = '2019-05-08T04:00:00.000000000' - data = {} - fields = {} - wind_fields = {} - station_fields = {} - for f in files: - obj = arm.read_netcdf(f) - data.update({f: obj}) - fields.update({f: ['lon', 'lat', 'temp_mean']}) - wind_fields.update({f: ['lon', 'lat', 'wspd_vec_mean', 'wdir_vec_mean']}) - station_fields.update({f: ['lon', 'lat', 'atmos_pressure', 'temp_mean', 'rh_mean', - 'vapor_pressure_mean', 'temp_std']}) - - display = ContourDisplay(data, figsize=(8, 8)) - display.create_contour(fields=fields, time=time, levels=50, - contour='contourf', cmap='viridis') - display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, mesh=True, grid_delta=(0.1, 0.1)) - display.plot_station(fields=station_fields, time=time, markersize=7, color='red') - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_contourf2(): - files = glob.glob(sample_files.EXAMPLE_MET_CONTOUR) - time = '2019-05-08T04:00:00.000000000' - data = {} - fields = {} - wind_fields = {} - station_fields = {} - for f in files: - obj = arm.read_netcdf(f) - data.update({f: obj}) - fields.update({f: ['lon', 'lat', 'temp_mean']}) - wind_fields.update({f: ['lon', 'lat', 'wspd_vec_mean', 'wdir_vec_mean']}) - station_fields.update({f: ['lon', 'lat', 'atmos_pressure', 'temp_mean', 'rh_mean', - 'vapor_pressure_mean', 'temp_std']}) - - display = ContourDisplay(data, figsize=(8, 8)) - display.create_contour(fields=fields, time=time, levels=50, - contour='contourf', cmap='viridis') - display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, mesh=False, grid_delta=(0.1, 0.1)) - display.plot_station(fields=station_fields, time=time, markersize=7, color='pink') - - return display.fig - - -# Due to issues with pytest-mpl, for now we just test to see if it runs -def test_time_height_scatter(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_SONDE1) - - display = TimeSeriesDisplay({'sgpsondewnpnC1.b1': sonde_ds}, - figsize=(7, 3)) - display.time_height_scatter('tdry', day_night_background=False) - - sonde_ds.close() - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_qc_bar_plot(): - ds_object = arm.read_netcdf(sample_files.EXAMPLE_MET1) - ds_object.clean.cleanup() - var_name = 'temp_mean' - ds_object.qcfilter.set_test(var_name, index=range(100, 600), test_number=2) - - # Testing out when the assessment is not listed - ds_object.qcfilter.set_test(var_name, index=range(500, 800), test_number=4) - ds_object['qc_' + var_name].attrs['flag_assessments'][3] = 'Wonky' - - display = TimeSeriesDisplay({'sgpmetE13.b1': ds_object}, - subplot_shape=(2, ), figsize=(7, 4)) - display.plot(var_name, subplot_index=(0, ), assessment_overplot=True) - display.day_night_background('sgpmetE13.b1', subplot_index=(0, )) - color_lookup = {'Bad': 'red', 'Incorrect': 'red', - 'Indeterminate': 'orange', 'Suspect': 'orange', - 'Missing': 'darkgray', 'Not Failing': 'green', - 'Acceptable': 'green'} - display.qc_flag_block_plot(var_name, subplot_index=(1, ), - assessment_color=color_lookup) - - ds_object.close() - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_2d_as_1d(): - obj = arm.read_netcdf(sample_files.EXAMPLE_CEIL1) - - display = TimeSeriesDisplay(obj) - display.plot('backscatter', force_line_plot=True) - - obj.close() - del obj - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_fill_between(): - obj = arm.read_netcdf(sample_files.EXAMPLE_MET_WILDCARD) - - accumulate_precip(obj, 'tbrg_precip_total') - - display = TimeSeriesDisplay(obj) - display.fill_between('tbrg_precip_total_accumulated', color='gray', alpha=0.2) - - obj.close() - del obj - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_qc_flag_block_plot(): - obj = arm.read_netcdf(sample_files.EXAMPLE_SURFSPECALB1MLAWER) - - display = TimeSeriesDisplay(obj, subplot_shape=(2, ), figsize=(8, 2 * 4)) - - display.plot('surface_albedo_mfr_narrowband_10m', force_line_plot=True, labels=True) - - display.qc_flag_block_plot('surface_albedo_mfr_narrowband_10m', subplot_index=(1, )) - - obj.close() - del obj - - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_assessment_overplot(): - var_name = 'temp_mean' - files = sample_files.EXAMPLE_MET1 - ds = arm.read_netcdf(files) - ds.load() - ds.clean.cleanup() - - ds.qcfilter.set_test(var_name, index=np.arange(100, 300, dtype=int), test_number=2) - ds.qcfilter.set_test(var_name, index=np.arange(420, 422, dtype=int), test_number=3) - ds.qcfilter.set_test(var_name, index=np.arange(500, 800, dtype=int), test_number=4) - ds.qcfilter.set_test(var_name, index=np.arange(900, 901, dtype=int), test_number=4) - - # Plot data - display = TimeSeriesDisplay(ds, subplot_shape=(1, ), figsize=(10, 6)) - display.plot(var_name, day_night_background=True, assessment_overplot=True) - - ds.close() - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_assessment_overplot_multi(): - var_name1, var_name2 = 'wspd_arith_mean', 'wspd_vec_mean' - files = sample_files.EXAMPLE_MET1 - ds = arm.read_netcdf(files) - ds.load() - ds.clean.cleanup() - - ds.qcfilter.set_test(var_name1, index=np.arange(100, 200, dtype=int), test_number=2) - ds.qcfilter.set_test(var_name1, index=np.arange(500, 600, dtype=int), test_number=4) - ds.qcfilter.set_test(var_name2, index=np.arange(300, 400, dtype=int), test_number=4) - - # Plot data - display = TimeSeriesDisplay(ds, subplot_shape=(1, ), figsize=(10, 6)) - display.plot(var_name1, label=var_name1, - assessment_overplot=True, overplot_behind=True) - display.plot(var_name2, day_night_background=True, color='green', - label=var_name2, assessment_overplot=True) - - ds.close() - return display.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_plot_barbs_from_u_v(): - sonde_ds = arm.read_netcdf( - sample_files.EXAMPLE_TWP_SONDE_WILDCARD) - BarbDisplay = TimeSeriesDisplay({'sonde_darwin': sonde_ds}) - BarbDisplay.plot_barbs_from_u_v('u_wind', 'v_wind', 'pres', - num_barbs_x=20) - sonde_ds.close() - return BarbDisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_plot_barbs_from_u_v2(): - bins = list(np.linspace(0, 1, 10)) - xbins = list(pd.date_range(pd.to_datetime('2020-01-01'), - pd.to_datetime('2020-01-02'), 12)) - y_data = np.full([len(xbins), len(bins)], 1.) - x_data = np.full([len(xbins), len(bins)], 2.) - y_array = xr.DataArray(y_data, dims={'xbins': xbins, 'ybins': bins}, - attrs={'units': 'm/s'}) - x_array = xr.DataArray(x_data, dims={'xbins': xbins, 'ybins': bins}, - attrs={'units': 'm/s'}) - xbins = xr.DataArray(xbins, dims={'xbins': xbins}) - ybins = xr.DataArray(bins, dims={'ybins': bins}) - fake_obj = xr.Dataset({'xbins': xbins, 'ybins': ybins, - 'ydata': y_array, 'xdata': x_array}) - BarbDisplay = TimeSeriesDisplay(fake_obj) - BarbDisplay.plot_barbs_from_u_v('xdata', 'ydata', None, num_barbs_x=20, - num_barbs_y=20, set_title='test plot', cmap='jet') - fake_obj.close() - return BarbDisplay.fig - - -@pytest.mark.mpl_image_compare(tolerance=30) -def test_2D_timeseries_plot(): - obj = arm.read_netcdf(sample_files.EXAMPLE_CEIL1) - display = TimeSeriesDisplay(obj) - display.plot('backscatter', y_rng=[0, 5000], use_var_for_y='range') - matplotlib.pyplot.show() - return display.fig diff --git a/act/tests/test_qc.py b/act/tests/test_qc.py deleted file mode 100644 index 6ab2ad20c3..0000000000 --- a/act/tests/test_qc.py +++ /dev/null @@ -1,599 +0,0 @@ -from act.io.armfiles import read_netcdf -from act.tests import (EXAMPLE_IRT25m20s, EXAMPLE_METE40, EXAMPLE_CEIL1, - EXAMPLE_MFRSR, EXAMPLE_MET1, EXAMPLE_CO2FLX4M) -from act.qc.arm import add_dqr_to_qc -from act.qc.radiometer_tests import fft_shading_test -from act.qc.qcfilter import parse_bit, set_bit, unset_bit -import numpy as np -import pytest -import copy - - -def test_fft_shading_test(): - obj = read_netcdf(EXAMPLE_MFRSR) - obj.clean.cleanup() - obj = fft_shading_test(obj) - qc_data = obj['qc_diffuse_hemisp_narrowband_filter4'] - assert np.nansum(qc_data.values) == 456 - - -def test_qc_test_errors(): - ds_object = read_netcdf(EXAMPLE_MET1) - var_name = 'temp_mean' - - assert ds_object.qcfilter.add_less_test(var_name, None) is None - assert ds_object.qcfilter.add_greater_test(var_name, None) is None - assert ds_object.qcfilter.add_less_equal_test(var_name, None) is None - assert ds_object.qcfilter.add_equal_to_test(var_name, None) is None - assert ds_object.qcfilter.add_not_equal_to_test(var_name, None) is None - - -def test_arm_qc(): - # Test DQR Webservice using known DQR - variable = 'wspd_vec_mean' - qc_variable = 'qc_' + variable - obj = read_netcdf(EXAMPLE_METE40) - - # DQR webservice does go down, so ensure it - # properly runs first before testing - try: - obj = add_dqr_to_qc(obj, variable=variable) - ran = True - obj.attrs['_datastream'] = obj.attrs['datastream'] - del obj.attrs['datastream'] - obj2 = add_dqr_to_qc(obj, variable=variable) - with np.testing.assert_raises(ValueError): - del obj.attrs['_datastream'] - add_dqr_to_qc(obj, variable=variable) - - obj4 = add_dqr_to_qc(obj) - except ValueError: - ran = False - - if ran: - assert qc_variable in obj - dqr = [True for d in obj[qc_variable].attrs['flag_meanings'] if 'D190529.4' in d] - assert dqr[0] is True - assert 'Suspect' not in obj[qc_variable].attrs['flag_assessments'] - assert 'Incorrect' not in obj[qc_variable].attrs['flag_assessments'] - - assert qc_variable in obj2 - dqr = [True for d in obj2[qc_variable].attrs['flag_meanings'] if 'D190529.4' in d] - assert dqr[0] is True - assert 'Suspect' not in obj2[qc_variable].attrs['flag_assessments'] - assert 'Incorrect' not in obj2[qc_variable].attrs['flag_assessments'] - - assert qc_variable in obj4 - dqr = [True for d in obj4[qc_variable].attrs['flag_meanings'] if 'D190529.4' in d] - assert dqr[0] is True - assert 'Suspect' not in obj4[qc_variable].attrs['flag_assessments'] - assert 'Incorrect' not in obj4[qc_variable].attrs['flag_assessments'] - - -def test_qcfilter(): - ds_object = read_netcdf(EXAMPLE_IRT25m20s) - var_name = 'inst_up_long_dome_resist' - expected_qc_var_name = 'qc_' + var_name - - # Perform adding of quality control variables to object - result = ds_object.qcfilter.add_test(var_name, test_meaning='Birds!') - assert isinstance(result, dict) - qc_var_name = result['qc_variable_name'] - assert qc_var_name == expected_qc_var_name - - # Check that new linking and describing attributes are set - assert ds_object[qc_var_name].attrs['standard_name'] == 'quality_flag' - assert ds_object[var_name].attrs['ancillary_variables'] == qc_var_name - - # Check that CF attributes are set including new flag_assessments - assert 'flag_masks' in ds_object[qc_var_name].attrs.keys() - assert 'flag_meanings' in ds_object[qc_var_name].attrs.keys() - assert 'flag_assessments' in ds_object[qc_var_name].attrs.keys() - - # Check that the values of the attributes are set correctly - assert ds_object[qc_var_name].attrs['flag_assessments'][0] == 'Bad' - assert ds_object[qc_var_name].attrs['flag_meanings'][0] == 'Birds!' - assert ds_object[qc_var_name].attrs['flag_masks'][0] == 1 - - # Set some test values - index = [0, 1, 2, 30] - ds_object.qcfilter.set_test(var_name, index=index, - test_number=result['test_number']) - - # Add a new test and set values - index2 = [6, 7, 8, 50] - ds_object.qcfilter.add_test(var_name, index=index2, - test_number=9, - test_meaning='testing high number', - test_assessment='Suspect') - - # Retrieve data from object as numpy masked array. Count number of masked - # elements and ensure equal to size of index array. - data = ds_object.qcfilter.get_masked_data(var_name, rm_assessments='Bad') - assert np.ma.count_masked(data) == len(index) - - data = ds_object.qcfilter.get_masked_data( - var_name, rm_assessments='Suspect', return_nan_array=True) - assert np.sum(np.isnan(data)) == len(index2) - - data = ds_object.qcfilter.get_masked_data( - var_name, rm_assessments=['Bad', 'Suspect'], ma_fill_value=np.nan) - assert np.ma.count_masked(data) == len(index + index2) - - # Test internal function for returning the index array of where the - # tests are set. - assert np.sum(ds_object.qcfilter.get_qc_test_mask( - var_name, result['test_number'], return_index=True) - - np.array(index, dtype=np.int)) == 0 - - # Unset a test - ds_object.qcfilter.unset_test(var_name, index=0, - test_number=result['test_number']) - # Remove the test - ds_object.qcfilter.remove_test(var_name, - test_number=result['test_number']) - pytest.raises(ValueError, ds_object.qcfilter.add_test, var_name) - pytest.raises(ValueError, ds_object.qcfilter.remove_test, var_name) - - ds_object.close() - - pytest.raises(ValueError, parse_bit, [1, 2]) - pytest.raises(ValueError, parse_bit, -1) - - assert set_bit(0, 16) == 32768 - data = range(0, 4) - assert isinstance(set_bit(list(data), 2), list) - assert isinstance(set_bit(tuple(data), 2), tuple) - assert isinstance(unset_bit(list(data), 2), list) - assert isinstance(unset_bit(tuple(data), 2), tuple) - - # Fill in missing tests - ds_object = read_netcdf(EXAMPLE_IRT25m20s) - del ds_object[var_name].attrs['long_name'] - # Test creating a qc variable - ds_object.qcfilter.create_qc_variable(var_name) - # Test creating a second qc variable and of flag type - ds_object.qcfilter.create_qc_variable(var_name, flag_type=True) - result = ds_object.qcfilter.add_test(var_name, index=[1, 2, 3], - test_number=9, - test_meaning='testing high number', - flag_value=True) - ds_object.qcfilter.set_test(var_name, index=5, test_number=9, flag_value=True) - data = ds_object.qcfilter.get_masked_data(var_name) - assert np.isclose(np.sum(data), 42674.766, 0.01) - data = ds_object.qcfilter.get_masked_data(var_name, rm_assessments='Bad') - assert np.isclose(np.sum(data), 42643.195, 0.01) - - ds_object.qcfilter.unset_test(var_name, test_number=9, flag_value=True) - ds_object.qcfilter.unset_test(var_name, index=1, test_number=9, flag_value=True) - assert ds_object.qcfilter.available_bit(result['qc_variable_name']) == 10 - assert ds_object.qcfilter.available_bit(result['qc_variable_name'], recycle=True) == 1 - ds_object.qcfilter.remove_test(var_name, test_number=9, flag_value=True) - - ds_object.qcfilter.update_ancillary_variable(var_name) - # Test updating ancillary variable if does not exist - ds_object.qcfilter.update_ancillary_variable('not_a_variable_name') - # Change ancillary_variables attribute to test if add correct qc variable correctly - ds_object[var_name].attrs['ancillary_variables'] = 'a_different_name' - ds_object.qcfilter.update_ancillary_variable(var_name, - qc_var_name=expected_qc_var_name) - assert (expected_qc_var_name in - ds_object[var_name].attrs['ancillary_variables']) - - # Test flag QC - var_name = 'inst_sfc_ir_temp' - qc_var_name = 'qc_' + var_name - ds_object.qcfilter.create_qc_variable(var_name, flag_type=True) - assert qc_var_name in list(ds_object.data_vars) - assert 'flag_values' in ds_object[qc_var_name].attrs.keys() - assert 'flag_masks' not in ds_object[qc_var_name].attrs.keys() - del ds_object[qc_var_name] - - qc_var_name = ds_object.qcfilter.check_for_ancillary_qc( - var_name, add_if_missing=True, cleanup=False, flag_type=True) - assert qc_var_name in list(ds_object.data_vars) - assert 'flag_values' in ds_object[qc_var_name].attrs.keys() - assert 'flag_masks' not in ds_object[qc_var_name].attrs.keys() - del ds_object[qc_var_name] - - ds_object.qcfilter.add_missing_value_test(var_name, flag_value=True, prepend_text='arm') - ds_object.qcfilter.add_test(var_name, index=list(range(0, 20)), test_number=2, - test_meaning='Testing flag', flag_value=True, - test_assessment='Suspect') - assert qc_var_name in list(ds_object.data_vars) - assert 'flag_values' in ds_object[qc_var_name].attrs.keys() - assert 'flag_masks' not in ds_object[qc_var_name].attrs.keys() - assert 'standard_name' in ds_object[qc_var_name].attrs.keys() - assert ds_object[qc_var_name].attrs['flag_values'] == [1, 2] - assert ds_object[qc_var_name].attrs['flag_assessments'] == ['Bad', 'Suspect'] - - ds_object.close() - - -def test_qctests(): - ds_object = read_netcdf(EXAMPLE_IRT25m20s) - var_name = 'inst_up_long_dome_resist' - - # Add in one missing value and test for that missing value - data = ds_object[var_name].values - data[0] = np.nan - ds_object[var_name].values = data - result = ds_object.qcfilter.add_missing_value_test(var_name) - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert data.mask[0] - - # less than min test - limit_value = 6.8 - result = ds_object.qcfilter.add_less_test(var_name, limit_value, prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 54 - assert 'fail_min' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['fail_min'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['fail_min'], limit_value) - - result = ds_object.qcfilter.add_less_test(var_name, limit_value, test_assessment='Suspect') - assert 'warn_min' in ds_object[result['qc_variable_name']].attrs.keys() - - # greator than max test - limit_value = 12.7 - result = ds_object.qcfilter.add_greater_test(var_name, limit_value, prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 61 - assert 'fail_max' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['fail_max'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['fail_max'], limit_value) - - result = ds_object.qcfilter.add_greater_test(var_name, limit_value, test_assessment='Suspect') - assert 'warn_max' in ds_object[result['qc_variable_name']].attrs.keys() - - # less than or equal test - limit_value = 6.9 - result = ds_object.qcfilter.add_less_equal_test(var_name, limit_value, - test_assessment='Suspect', - prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 149 - assert 'warn_min' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['warn_min'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['warn_min'], limit_value) - - result = ds_object.qcfilter.add_less_equal_test(var_name, limit_value) - assert 'fail_min' in ds_object[result['qc_variable_name']].attrs.keys() - - # greater than or equal test - limit_value = 12 - result = ds_object.qcfilter.add_greater_equal_test(var_name, limit_value, - test_assessment='Suspect', - prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 606 - assert 'warn_max' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['warn_max'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['warn_max'], limit_value) - - result = ds_object.qcfilter.add_greater_equal_test(var_name, limit_value) - assert 'fail_max' in ds_object[result['qc_variable_name']].attrs.keys() - - # equal to test - limit_value = 7.6705 - result = ds_object.qcfilter.add_equal_to_test(var_name, limit_value, prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 2 - assert 'fail_equal_to' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['fail_equal_to'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['fail_equal_to'], limit_value) - - result = ds_object.qcfilter.add_equal_to_test(var_name, limit_value, - test_assessment='Indeterminate') - assert 'warn_equal_to' in ds_object[result['qc_variable_name']].attrs.keys() - - # not equal to test - limit_value = 7.6705 - result = ds_object.qcfilter.add_not_equal_to_test(var_name, limit_value, - test_assessment='Indeterminate', - prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 4318 - assert 'warn_not_equal_to' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['warn_not_equal_to'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['warn_not_equal_to'], limit_value) - - result = ds_object.qcfilter.add_not_equal_to_test(var_name, limit_value) - assert 'fail_not_equal_to' in ds_object[result['qc_variable_name']].attrs.keys() - - # outside range test - limit_value1 = 6.8 - limit_value2 = 12.7 - result = ds_object.qcfilter.add_outside_test(var_name, limit_value1, limit_value2, - prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 115 - assert 'fail_lower_range' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['fail_lower_range'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['fail_lower_range'], limit_value1) - assert 'fail_upper_range' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['fail_upper_range'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['fail_upper_range'], limit_value2) - - result = ds_object.qcfilter.add_outside_test(var_name, limit_value1, limit_value2, - test_assessment='Indeterminate') - assert 'warn_lower_range' in ds_object[result['qc_variable_name']].attrs.keys() - assert 'warn_upper_range' in ds_object[result['qc_variable_name']].attrs.keys() - - # inside range test - limit_value1 = 7 - limit_value2 = 8 - result = ds_object.qcfilter.add_inside_test(var_name, limit_value1, limit_value2, - prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 479 - assert 'fail_lower_range_inner' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['fail_lower_range_inner'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['fail_lower_range_inner'], - limit_value1) - assert 'fail_upper_range_inner' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['fail_upper_range_inner'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['fail_upper_range_inner'], - limit_value2) - - result = ds_object.qcfilter.add_inside_test(var_name, limit_value1, limit_value2, - test_assessment='Indeterminate') - assert 'warn_lower_range_inner' in ds_object[result['qc_variable_name']].attrs.keys() - assert 'warn_upper_range_inner' in ds_object[result['qc_variable_name']].attrs.keys() - - # delta test - test_limit = 0.05 - result = ds_object.qcfilter.add_delta_test(var_name, test_limit, prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert np.ma.count_masked(data) == 175 - assert 'warn_delta' in ds_object[result['qc_variable_name']].attrs.keys() - assert (ds_object[result['qc_variable_name']].attrs['warn_delta'].dtype == - ds_object[result['variable_name']].values.dtype) - assert np.isclose(ds_object[result['qc_variable_name']].attrs['warn_delta'], test_limit) - - data = ds_object.qcfilter.get_masked_data(var_name, - rm_assessments=['Suspect', 'Bad']) - assert np.ma.count_masked(data) == 4320 - - result = ds_object.qcfilter.add_delta_test(var_name, test_limit, test_assessment='Bad') - assert 'fail_delta' in ds_object[result['qc_variable_name']].attrs.keys() - - comp_object = read_netcdf(EXAMPLE_IRT25m20s) - result = ds_object.qcfilter.add_difference_test( - var_name, {comp_object.attrs['datastream']: comp_object}, - var_name, diff_limit=1, prepend_text='arm') - data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) - assert 'arm' in result['test_meaning'] - assert not (data.mask).all() - - comp_object.close() - ds_object.close() - - -def test_qctests_dos(): - ds_object = read_netcdf(EXAMPLE_IRT25m20s) - var_name = 'inst_up_long_dome_resist' - - # persistence test - data = ds_object[var_name].values - data[1000:2500] = data[1000] - ds_object[var_name].values = data - ds_object.qcfilter.add_persistence_test(var_name) - qc_var_name = ds_object.qcfilter.check_for_ancillary_qc( - var_name, add_if_missing=False, cleanup=False, flag_type=False) - test_meaning = ('Data failing persistence test. Standard Deviation over a ' - 'window of 10 values less than 0.0001.') - assert ds_object[qc_var_name].attrs['flag_meanings'][-1] == test_meaning - assert np.sum(ds_object[qc_var_name].values) == 1500 - - ds_object.qcfilter.add_persistence_test(var_name, window=10000, prepend_text='DQO') - test_meaning = ('DQO: Data failing persistence test. Standard Deviation over a window of ' - '4320 values less than 0.0001.') - assert ds_object[qc_var_name].attrs['flag_meanings'][-1] == test_meaning - - -def test_datafilter(): - ds = read_netcdf(EXAMPLE_MET1) - ds.clean.cleanup() - - var_name = 'atmos_pressure' - - ds_1 = ds.mean() - - ds.qcfilter.add_less_test(var_name, 99, test_assessment='Bad') - ds.qcfilter.datafilter(rm_assessments='Bad') - ds_2 = ds.mean() - - assert np.isclose(ds_1[var_name].values, 98.86, atol=0.01) - assert np.isclose(ds_2[var_name].values, 99.15, atol=0.01) - - ds.close() - - -def test_qc_remainder(): - ds = read_netcdf(EXAMPLE_MET1) - assert ds.clean.get_attr_info(variable='bad_name') is None - del ds.attrs['qc_bit_comment'] - assert isinstance(ds.clean.get_attr_info(), dict) - ds.attrs['qc_flag_comment'] = 'testing' - ds.close() - - ds = read_netcdf(EXAMPLE_MET1) - ds.clean.cleanup(normalize_assessment=True) - ds['qc_atmos_pressure'].attrs['units'] = 'testing' - del ds['qc_temp_mean'].attrs['units'] - del ds['qc_temp_mean'].attrs['flag_masks'] - ds.clean.handle_missing_values() - ds.close() - - ds = read_netcdf(EXAMPLE_MET1) - ds.attrs['qc_bit_1_comment'] = 'tesing' - data = ds['qc_atmos_pressure'].values.astype(np.int64) - data[0] = 2**32 - ds['qc_atmos_pressure'].values = data - ds.clean.get_attr_info(variable='qc_atmos_pressure') - ds.clean.clean_arm_state_variables('testname') - ds.clean.cleanup() - ds['qc_atmos_pressure'].attrs['standard_name'] = 'wrong_name' - ds.clean.link_variables() - assert ds['qc_atmos_pressure'].attrs['standard_name'] == 'quality_flag' - ds.close() - - -def test_qc_flag_description(): - """ - This will check if the cleanup() method will correctly convert convert - flag_#_description to CF flag_masks and flag_meanings. - - """ - - ds = read_netcdf(EXAMPLE_CO2FLX4M) - ds.clean.cleanup() - qc_var_name = ds.qcfilter.check_for_ancillary_qc('momentum_flux', add_if_missing=False, - cleanup=False) - - assert isinstance(ds[qc_var_name].attrs['flag_masks'], list) - assert isinstance(ds[qc_var_name].attrs['flag_meanings'], list) - assert isinstance(ds[qc_var_name].attrs['flag_assessments'], list) - assert ds[qc_var_name].attrs['standard_name'] == 'quality_flag' - - assert len(ds[qc_var_name].attrs['flag_masks']) == 9 - unique_flag_assessments = list(set(['Acceptable', 'Indeterminate', 'Bad'])) - assert list(set(ds[qc_var_name].attrs['flag_assessments'])) == unique_flag_assessments - - -def test_clean(): - # Read test data - ceil_ds = read_netcdf([EXAMPLE_CEIL1]) - # Cleanup QC data - ceil_ds.clean.cleanup(clean_arm_state_vars=['detection_status']) - - # Check that global attribures are removed - global_attributes = ['qc_bit_comment', - 'qc_bit_1_description', - 'qc_bit_1_assessment', - 'qc_bit_2_description', - 'qc_bit_2_assessment' - 'qc_bit_3_description', - 'qc_bit_3_assessment' - ] - - for glb_att in global_attributes: - assert glb_att not in ceil_ds.attrs.keys() - - # Check that CF attributes are set including new flag_assessments - var_name = 'qc_first_cbh' - for attr_name in ['flag_masks', 'flag_meanings', 'flag_assessments']: - assert attr_name in ceil_ds[var_name].attrs.keys() - assert isinstance(ceil_ds[var_name].attrs[attr_name], list) - - # Check that the flag_mask values are set correctly - assert ceil_ds['qc_first_cbh'].attrs['flag_masks'] == [1, 2, 4] - - # Check that the flag_meanings values are set correctly - assert (ceil_ds['qc_first_cbh'].attrs['flag_meanings'] == - ['Value is equal to missing_value.', - 'Value is less than the fail_min.', - 'Value is greater than the fail_max.']) - - # Check the value of flag_assessments is as expected - assert ceil_ds['qc_first_cbh'].attrs['flag_assessments'] == ['Bad', 'Bad', 'Bad'] - - # Check that ancillary varibles is being added - assert 'qc_first_cbh' in ceil_ds['first_cbh'].attrs['ancillary_variables'].split() - - # Check that state field is updated to CF - assert 'flag_values' in ceil_ds['detection_status'].attrs.keys() - assert isinstance(ceil_ds['detection_status'].attrs['flag_values'], list) - assert ceil_ds['detection_status'].attrs['flag_values'] == [0, 1, 2, 3, 4, 5] - - assert 'flag_meanings' in ceil_ds['detection_status'].attrs.keys() - assert isinstance(ceil_ds['detection_status'].attrs['flag_meanings'], list) - assert (ceil_ds['detection_status'].attrs['flag_meanings'] == - ['No significant backscatter', - 'One cloud base detected', - 'Two cloud bases detected', - 'Three cloud bases detected', - 'Full obscuration determined but no cloud base detected', - 'Some obscuration detected but determined to be transparent']) - - assert 'flag_0_description' not in ceil_ds['detection_status'].attrs.keys() - assert ('detection_status' in - ceil_ds['first_cbh'].attrs['ancillary_variables'].split()) - - ceil_ds.close() - - -def test_compare_time_series_trends(): - - drop_vars = ['base_time', 'time_offset', 'atmos_pressure', 'qc_atmos_pressure', - 'temp_std', 'rh_mean', 'qc_rh_mean', 'rh_std', 'vapor_pressure_mean', - 'qc_vapor_pressure_mean', 'vapor_pressure_std', 'wspd_arith_mean', - 'qc_wspd_arith_mean', 'wspd_vec_mean', 'qc_wspd_vec_mean', 'wdir_vec_mean', - 'qc_wdir_vec_mean', 'wdir_vec_std', 'tbrg_precip_total', 'qc_tbrg_precip_total', - 'tbrg_precip_total_corr', 'qc_tbrg_precip_total_corr', 'org_precip_rate_mean', - 'qc_org_precip_rate_mean', 'pwd_err_code', 'pwd_mean_vis_1min', 'qc_pwd_mean_vis_1min', - 'pwd_mean_vis_10min', 'qc_pwd_mean_vis_10min', 'pwd_pw_code_inst', - 'qc_pwd_pw_code_inst', 'pwd_pw_code_15min', 'qc_pwd_pw_code_15min', - 'pwd_pw_code_1hr', 'qc_pwd_pw_code_1hr', 'pwd_precip_rate_mean_1min', - 'qc_pwd_precip_rate_mean_1min', 'pwd_cumul_rain', 'qc_pwd_cumul_rain', - 'pwd_cumul_snow', 'qc_pwd_cumul_snow', 'logger_volt', 'qc_logger_volt', - 'logger_temp', 'qc_logger_temp', 'lat', 'lon', 'alt'] - ds = read_netcdf(EXAMPLE_MET1, drop_variables=drop_vars) - ds.clean.cleanup() - ds2 = copy.deepcopy(ds) - - var_name = 'temp_mean' - qc_var_name = ds.qcfilter.check_for_ancillary_qc(var_name, add_if_missing=False, - cleanup=False, flag_type=False) - ds.qcfilter.compare_time_series_trends(var_name=var_name, time_shift=60, - comp_var_name=var_name, comp_dataset=ds2, - time_qc_threshold=60 * 10) - - test_description = ('Time shift detected with Minimum Difference test. Comparison of ' - 'temp_mean with temp_mean off by 0 seconds exceeding absolute ' - 'threshold of 600 seconds.') - assert ds[qc_var_name].attrs['flag_meanings'][-1] == test_description - - time = ds2['time'].values + np.timedelta64(1, 'h') - time_attrs = ds2['time'].attrs - ds2 = ds2.assign_coords({'time': time}) - ds2['time'].attrs = time_attrs - - ds.qcfilter.compare_time_series_trends(var_name=var_name, comp_dataset=ds2, time_step=60, - time_match_threshhold=50) - - test_description = ('Time shift detected with Minimum Difference test. Comparison of ' - 'temp_mean with temp_mean off by 3600 seconds exceeding absolute ' - 'threshold of 900 seconds.') - assert ds[qc_var_name].attrs['flag_meanings'][-1] == test_description diff --git a/act/tests/test_retrievals.py b/act/tests/test_retrievals.py deleted file mode 100644 index a7b0748083..0000000000 --- a/act/tests/test_retrievals.py +++ /dev/null @@ -1,191 +0,0 @@ -" Unit tests for the ACT retrievals module. """ - -import act -import numpy as np -import xarray as xr - - -def test_get_stability_indices(): - sonde_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE1) - - try: - sonde_ds = act.retrievals.calculate_stability_indicies( - sonde_ds, temp_name="tdry", td_name="dp", p_name="pres") - metpy = True - except ImportError: - metpy = False - - if metpy is True: - np.testing.assert_allclose( - sonde_ds["parcel_temperature"].values[0:5], - [269.85000005, 269.74530704, 269.67805708, - 269.62251119, 269.57241322], rtol=1e-5) - assert sonde_ds["parcel_temperature"].attrs["units"] == "kelvin" - np.testing.assert_almost_equal( - sonde_ds["surface_based_cape"], 1.62, decimal=2) - assert sonde_ds["surface_based_cape"].attrs["units"] == "J/kg" - assert sonde_ds[ - "surface_based_cape"].attrs["long_name"] == "Surface-based CAPE" - np.testing.assert_almost_equal( - sonde_ds["surface_based_cin"], 0.000, decimal=3) - assert sonde_ds["surface_based_cin"].attrs["units"] == "J/kg" - assert sonde_ds[ - "surface_based_cin"].attrs["long_name"] == "Surface-based CIN" - np.testing.assert_almost_equal( - sonde_ds["most_unstable_cape"], 0.000, decimal=3) - assert sonde_ds["most_unstable_cape"].attrs["units"] == "J/kg" - assert sonde_ds[ - "most_unstable_cape"].attrs["long_name"] == "Most unstable CAPE" - np.testing.assert_almost_equal( - sonde_ds["most_unstable_cin"], 0.000, decimal=3) - assert sonde_ds["most_unstable_cin"].attrs["units"] == "J/kg" - assert sonde_ds[ - "most_unstable_cin"].attrs["long_name"] == "Most unstable CIN" - - np.testing.assert_almost_equal( - sonde_ds["lifted_index"], 28.4, decimal=1) - assert sonde_ds["lifted_index"].attrs["units"] == "kelvin" - assert sonde_ds["lifted_index"].attrs["long_name"] == "Lifted index" - np.testing.assert_equal( - sonde_ds["level_of_free_convection"], np.array(np.nan)) - assert sonde_ds[ - "level_of_free_convection"].attrs["units"] == "hectopascal" - assert sonde_ds[ - "level_of_free_convection"].attrs[ - "long_name"] == "Level of free convection" - np.testing.assert_almost_equal( - sonde_ds["lifted_condensation_level_temperature"], - -8.07, decimal=2) - assert sonde_ds[ - "lifted_condensation_level_temperature"].attrs[ - "units"] == "degree_Celsius" - assert sonde_ds[ - "lifted_condensation_level_temperature"].attrs[ - "long_name"] == "Lifted condensation level temperature" - np.testing.assert_almost_equal( - sonde_ds["lifted_condensation_level_pressure"], 927.1, decimal=1) - assert sonde_ds[ - "lifted_condensation_level_pressure"].attrs[ - "units"] == "hectopascal" - assert sonde_ds[ - "lifted_condensation_level_pressure"].attrs[ - "long_name"] == "Lifted condensation level pressure" - sonde_ds.close() - - -def test_generic_sobel_cbh(): - ceil = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_CEIL1) - - ceil = ceil.resample(time='1min').nearest() - ceil = act.retrievals.cbh.generic_sobel_cbh( - ceil, variable='backscatter', height_dim='range', - var_thresh=1000., fill_na=0) - cbh = ceil['cbh_sobel'].values - assert cbh[500] == 615. - assert cbh[1000] == 555. - ceil.close() - - -def test_calculate_precipitable_water(): - sonde_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE1) - assert sonde_ds["tdry"].units == "C", "Temperature must be in Celsius" - assert sonde_ds["rh"].units == "%", "Relative Humidity must be a percentage" - assert sonde_ds["pres"].units == "hPa", "Pressure must be in hPa" - pwv_data = act.retrievals.pwv_calc.calculate_precipitable_water( - sonde_ds, temp_name='tdry', rh_name='rh', pres_name='pres') - np.testing.assert_almost_equal(pwv_data, 0.8028, decimal=3) - sonde_ds.close() - - -def test_doppler_lidar_winds(): - # Process a single file - dl_ds = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_DLPPI) - result = act.retrievals.doppler_lidar.compute_winds_from_ppi( - dl_ds, intensity_name='intensity') - assert np.round( - np.nansum(result['wind_speed'].values)).astype(int) == 1570 - assert np.round( - np.nansum(result['wind_direction'].values)).astype(int) == 32635 - assert result['wind_speed'].attrs['units'] == 'm/s' - assert result['wind_direction'].attrs['units'] == 'degree' - assert result['height'].attrs['units'] == 'm' - dl_ds.close() - - # Process multiple files - dl_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_DLPPI_MULTI) - del dl_ds['range'].attrs['units'] - result = act.retrievals.doppler_lidar.compute_winds_from_ppi(dl_ds) - assert np.round( - np.nansum(result['wind_speed'].values)).astype(int) == 64419 - assert np.round( - np.nansum(result['wind_direction'].values)).astype(int) == 733627 - dl_ds.close() - - -def test_aeri2irt(): - aeri_ds = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_AERI) - aeri_ds = act.retrievals.aeri.aeri2irt(aeri_ds) - assert np.round( - np.nansum( - aeri_ds['aeri_irt_equiv_temperature'].values)).astype(int) == 17372 - np.testing.assert_almost_equal( - aeri_ds['aeri_irt_equiv_temperature'].values[7], 286.081, decimal=3) - np.testing.assert_almost_equal( - aeri_ds['aeri_irt_equiv_temperature'].values[-10], 285.366, decimal=3) - aeri_ds.close() - del aeri_ds - - -def test_sst(): - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_IRTSST) - obj = act.retrievals.irt.sst_from_irt(obj) - np.testing.assert_almost_equal( - obj['sea_surface_temperature'].values[0], 278.901, decimal=3) - np.testing.assert_almost_equal( - obj['sea_surface_temperature'].values[-1], 279.291, decimal=3) - assert np.round( - np.nansum(obj['sea_surface_temperature'].values)).astype(int) == 6699 - obj.close() - - -def test_calculate_sirs_variable(): - sirs_object = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SIRS) - met_object = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_MET1) - - obj = act.retrievals.radiation.calculate_dsh_from_dsdh_sdn(sirs_object) - assert np.isclose(np.nansum(obj['derived_down_short_hemisp'].values), 60350, atol=1) - - obj = act.retrievals.radiation.calculate_irradiance_stats( - obj, variable='derived_down_short_hemisp', - variable2='down_short_hemisp', threshold=60) - assert np.isclose(np.nansum(obj['diff_derived_down_short_hemisp'].values), 527, atol=1) - assert np.isclose(np.nansum(obj['ratio_derived_down_short_hemisp'].values), 392, atol=1) - - obj = act.retrievals.radiation.calculate_net_radiation(obj, smooth=30) - assert np.ceil(np.nansum(obj['net_radiation'].values)) == 21915 - assert np.ceil(np.nansum(obj['net_radiation_smoothed'].values)) == 22316 - - obj = act.retrievals.radiation.calculate_longwave_radiation( - obj, temperature_var='temp_mean', - vapor_pressure_var='vapor_pressure_mean', - met_obj=met_object) - assert np.ceil(obj['monteith_clear'].values[25]) == 239 - assert np.ceil(obj['monteith_cloudy'].values[30]) == 318 - assert np.ceil(obj['prata_clear'].values[35]) == 234 - - new_obj = xr.merge([sirs_object, met_object], compat='override') - obj = act.retrievals.radiation.calculate_longwave_radiation( - new_obj, temperature_var='temp_mean', - vapor_pressure_var='vapor_pressure_mean') - assert np.ceil(obj['monteith_clear'].values[25]) == 239 - assert np.ceil(obj['monteith_cloudy'].values[30]) == 318 - assert np.ceil(obj['prata_clear'].values[35]) == 234 - - sirs_object.close() - met_object.close() diff --git a/act/tests/test_utils.py b/act/tests/test_utils.py deleted file mode 100644 index 3c24f4757c..0000000000 --- a/act/tests/test_utils.py +++ /dev/null @@ -1,453 +0,0 @@ -""" Unit tests for ACT utils module. """ - -from datetime import datetime -import pytz - -import act -import numpy as np -import pandas as pd -import pytest -import xarray as xr -import tempfile -from pathlib import Path - - -def test_dates_between(): - start_date = '20190101' - end_date = '20190110' - date_list = act.utils.dates_between(start_date, end_date) - answer = [datetime(2019, 1, 1), - datetime(2019, 1, 2), - datetime(2019, 1, 3), - datetime(2019, 1, 4), - datetime(2019, 1, 5), - datetime(2019, 1, 6), - datetime(2019, 1, 7), - datetime(2019, 1, 8), - datetime(2019, 1, 9), - datetime(2019, 1, 10)] - assert date_list == answer - - -def test_add_in_nan(): - # Make a 1D array with a 4 day gap in the data - time_list = [np.datetime64(datetime(2019, 1, 1, 1, 0)), - np.datetime64(datetime(2019, 1, 1, 1, 1)), - np.datetime64(datetime(2019, 1, 1, 1, 2)), - np.datetime64(datetime(2019, 1, 1, 1, 8)), - np.datetime64(datetime(2019, 1, 1, 1, 9))] - data = np.linspace(0., 8., 5) - - time_list = xr.DataArray(time_list) - data = xr.DataArray(data) - time_filled, data_filled = act.utils.add_in_nan( - time_list, data) - - assert(data_filled.data[8] == 6.) - - time_answer = [np.datetime64(datetime(2019, 1, 1, 1, 0)), - np.datetime64(datetime(2019, 1, 1, 1, 1)), - np.datetime64(datetime(2019, 1, 1, 1, 2)), - np.datetime64(datetime(2019, 1, 1, 1, 3)), - np.datetime64(datetime(2019, 1, 1, 1, 4)), - np.datetime64(datetime(2019, 1, 1, 1, 5)), - np.datetime64(datetime(2019, 1, 1, 1, 6)), - np.datetime64(datetime(2019, 1, 1, 1, 7)), - np.datetime64(datetime(2019, 1, 1, 1, 8)), - np.datetime64(datetime(2019, 1, 1, 1, 9))] - - assert(time_filled[8].values == time_answer[8]) - assert(time_filled[5].values == time_answer[5]) - - time_filled, data_filled = act.utils.add_in_nan( - time_list[0], data[0]) - assert time_filled.values == time_list[0] - assert data_filled.values == data[0] - - -def test_get_missing_value(): - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) - missing = act.utils.data_utils.get_missing_value( - obj, 'latent_heat_flux', use_FillValue=True, add_if_missing_in_obj=True) - assert missing == -9999 - - obj['latent_heat_flux'].attrs['missing_value'] = -9998 - missing = act.utils.data_utils.get_missing_value(obj, 'latent_heat_flux') - assert missing == -9998 - - -def test_convert_units(): - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) - data = obj['soil_temp_1'].values - in_units = obj['soil_temp_1'].attrs['units'] - r_data = act.utils.data_utils.convert_units(data, in_units, 'K') - assert np.ceil(r_data[0]) == 285 - - data = act.utils.data_utils.convert_units(r_data, 'K', 'C') - assert np.ceil(data[0]) == 12 - - try: - obj.utils.change_units() - except ValueError as error: - assert str(error) == "Need to provide 'desired_unit' keyword for .change_units() method" - - desired_unit = 'degF' - skip_vars = [ii for ii in obj.data_vars if ii.startswith('qc_')] - obj.utils.change_units(variables=None, desired_unit=desired_unit, - skip_variables=skip_vars, skip_standard=True) - units = [] - for var_name in obj.data_vars: - try: - units.append(obj[var_name].attrs['units']) - except KeyError: - pass - indices = [i for i, x in enumerate(units) if x == desired_unit] - assert indices == [0, 2, 4, 6, 8, 32, 34, 36, 38, 40] - - var_name = 'home_signal_15' - desired_unit = 'V' - obj.utils.change_units(var_name, desired_unit, skip_variables='lat') - assert obj[var_name].attrs['units'] == desired_unit - - var_names = ['home_signal_15', 'home_signal_30'] - obj.utils.change_units(var_names, desired_unit) - for var_name in var_names: - assert obj[var_name].attrs['units'] == desired_unit - - obj.close() - del obj - - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_CEIL1) - var_name = 'range' - desired_unit = 'km' - obj = obj.utils.change_units(var_name, desired_unit) - assert obj[var_name].attrs['units'] == desired_unit - assert np.isclose(np.sum(obj[var_name].values), 952.56, atol=0.01) - - obj.close() - del obj - - -def test_ts_weighted_average(): - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_MET_WILDCARD) - cf_ds = {'sgpmetE13.b1': {'variable': ['tbrg_precip_total', 'org_precip_rate_mean', - 'pwd_precip_rate_mean_1min'], - 'weight': [0.8, 0.15, 0.05], 'object': obj}} - data = act.utils.data_utils.ts_weighted_average(cf_ds) - - np.testing.assert_almost_equal(np.sum(data), 84.9, decimal=1) - - -def test_accum_precip(): - obj = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_MET_WILDCARD) - - obj = act.utils.accumulate_precip(obj, 'tbrg_precip_total') - dmax = round(np.nanmax(obj['tbrg_precip_total_accumulated'])) - assert dmax == 13.0 - - obj = act.utils.accumulate_precip(obj, 'tbrg_precip_total', time_delta=60) - dmax = round(np.nanmax(obj['tbrg_precip_total_accumulated'])) - assert dmax == 13.0 - - obj['tbrg_precip_total'].attrs['units'] = 'mm/hr' - obj = act.utils.accumulate_precip(obj, 'tbrg_precip_total') - dmax = np.round(np.nanmax(obj['tbrg_precip_total_accumulated']), 2) - assert dmax == 0.22 - - -def test_calc_cog_sog(): - obj = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_NAV) - - obj = act.utils.calc_cog_sog(obj) - - cog = obj['course_over_ground'].values - sog = obj['speed_over_ground'].values - - np.testing.assert_almost_equal(cog[10], 170.987, decimal=3) - np.testing.assert_almost_equal(sog[15], 0.448, decimal=3) - - obj = obj.rename({'lat': 'latitude', 'lon': 'longitude'}) - obj = act.utils.calc_cog_sog(obj) - np.testing.assert_almost_equal(cog[10], 170.987, decimal=3) - np.testing.assert_almost_equal(sog[15], 0.448, decimal=3) - - -def test_destination_azimuth_distance(): - lat = 37.1509 - lon = -98.362 - lat2, lon2 = act.utils.destination_azimuth_distance(lat, lon, 180., 100) - - np.testing.assert_almost_equal(lat2, 37.150, decimal=3) - np.testing.assert_almost_equal(lon2, -98.361, decimal=3) - - -def test_calculate_dqr_times(): - ebbr1_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_EBBR1) - ebbr2_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_EBBR2) - brs_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_BRS) - ebbr1_result = act.utils.calculate_dqr_times( - ebbr1_ds, variable=['soil_temp_1'], threshold=2) - ebbr2_result = act.utils.calculate_dqr_times( - ebbr2_ds, variable=['rh_bottom_fraction'], - qc_bit=3, threshold=2) - ebbr3_result = act.utils.calculate_dqr_times( - ebbr2_ds, variable=['rh_bottom_fraction'], - qc_bit=3) - brs_result = act.utils.calculate_dqr_times( - brs_ds, variable='down_short_hemisp_min', qc_bit=2, threshold=30) - assert ebbr1_result == [('2019-11-25 02:00:00', '2019-11-25 04:30:00')] - assert ebbr2_result == [('2019-11-30 00:00:00', '2019-11-30 11:00:00')] - assert brs_result == [('2019-07-05 01:57:00', '2019-07-05 11:07:00')] - assert ebbr3_result is None - with tempfile.TemporaryDirectory() as tmpdirname: - write_file = Path(tmpdirname) - brs_result = act.utils.calculate_dqr_times(brs_ds, variable='down_short_hemisp_min', - qc_bit=2, threshold=30, txt_path=str(write_file)) - - brs_result = act.utils.calculate_dqr_times(brs_ds, variable='down_short_hemisp_min', - qc_bit=2, threshold=30, return_missing=False) - assert len(brs_result[0]) == 2 - - ebbr1_ds.close() - ebbr2_ds.close() - brs_ds.close() - - -def test_decode_present_weather(): - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_MET1) - obj = act.utils.decode_present_weather(obj, variable='pwd_pw_code_inst') - - data = obj['pwd_pw_code_inst_decoded'].values - result = 'No significant weather observed' - assert data[0] == result - assert data[100] == result - assert data[600] == result - - np.testing.assert_raises(ValueError, act.utils.inst_utils.decode_present_weather, obj) - np.testing.assert_raises(ValueError, act.utils.inst_utils.decode_present_weather, - obj, variable='temp_temp') - - -def test_datetime64_to_datetime(): - time_datetime = [datetime(2019, 1, 1, 1, 0), - datetime(2019, 1, 1, 1, 1), - datetime(2019, 1, 1, 1, 2), - datetime(2019, 1, 1, 1, 3), - datetime(2019, 1, 1, 1, 4)] - - time_datetime64 = [np.datetime64(datetime(2019, 1, 1, 1, 0)), - np.datetime64(datetime(2019, 1, 1, 1, 1)), - np.datetime64(datetime(2019, 1, 1, 1, 2)), - np.datetime64(datetime(2019, 1, 1, 1, 3)), - np.datetime64(datetime(2019, 1, 1, 1, 4))] - - time_datetime64_to_datetime = act.utils.datetime_utils.datetime64_to_datetime(time_datetime64) - assert time_datetime == time_datetime64_to_datetime - - -def test_create_pyart_obj(): - try: - obj = act.io.mpl.read_sigma_mplv5(act.tests.EXAMPLE_SIGMA_MPLV5) - except Exception: - return - - radar = act.utils.create_pyart_obj(obj, range_var='range') - variables = list(radar.fields) - assert 'nrb_copol' in variables - assert 'nrb_crosspol' in variables - assert radar.sweep_start_ray_index['data'][-1] == 67 - assert radar.sweep_end_ray_index['data'][-1] == 101 - assert radar.fixed_angle['data'] == 2.0 - assert radar.scan_type == 'ppi' - assert radar.sweep_mode['data'] == 'ppi' - np.testing.assert_allclose( - radar.sweep_number['data'][-3:], - [1., 1., 1.]) - np.testing.assert_allclose( - radar.sweep_number['data'][0:3], - [0., 0., 0.]) - - # coordinates - np.testing.assert_allclose( - radar.azimuth['data'][0:5], - [-95., -92.5, -90., -87.5, -85.]) - np.testing.assert_allclose( - radar.elevation['data'][0:5], - [2., 2., 2., 2., 2.]) - np.testing.assert_allclose( - radar.range['data'][0:5], - [14.98962308, 44.96886923, 74.94811538, - 104.92736153, 134.90660768]) - gate_lat = radar.gate_latitude['data'][0, 0:5] - gate_lon = radar.gate_longitude['data'][0, 0:5] - gate_alt = radar.gate_altitude['data'][0, 0:5] - np.testing.assert_allclose( - gate_lat, [38.95293483, 38.95291135, 38.95288786, - 38.95286437, 38.95284089]) - np.testing.assert_allclose( - gate_lon, [-76.8363515, -76.83669666, -76.83704182, - -76.83738699, -76.83773215]) - np.testing.assert_allclose( - gate_alt, [62.84009906, 63.8864653, 64.93293721, - 65.9795148, 67.02619806]) - obj.close() - del radar - - -def test_add_solar_variable(): - obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_NAV) - new_obj = act.utils.geo_utils.add_solar_variable(obj) - - assert 'sun_variable' in list(new_obj.keys()) - assert new_obj['sun_variable'].values[10] == 1 - assert np.sum(new_obj['sun_variable'].values) >= 598 - - new_obj = act.utils.geo_utils.add_solar_variable(obj, dawn_dusk=True) - assert 'sun_variable' in list(new_obj.keys()) - assert new_obj['sun_variable'].values[10] == 1 - assert np.sum(new_obj['sun_variable'].values) >= 1234 - - obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_MET1) - new_obj = act.utils.geo_utils.add_solar_variable(obj, dawn_dusk=True) - assert np.sum(new_obj['sun_variable'].values) >= 1046 - - obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_IRTSST) - obj = obj.fillna(0) - new_obj = act.utils.geo_utils.add_solar_variable(obj) - assert np.sum(new_obj['sun_variable'].values) >= 12 - - obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_IRTSST) - obj.drop_vars('lat') - pytest.raises( - ValueError, act.utils.geo_utils.add_solar_variable, obj) - - obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_IRTSST) - obj.drop_vars('lon') - pytest.raises( - ValueError, act.utils.geo_utils.add_solar_variable, obj) - obj.close() - new_obj.close() - - -def test_reduce_time_ranges(): - time = pd.date_range(start='2020-01-01T00:00:00', freq='1min', periods=100) - time = time.to_list() - time = time[0:50] + time[60:] - result = act.utils.datetime_utils.reduce_time_ranges(time) - assert len(result) == 2 - assert result[1][1].minute == 39 - - result = act.utils.datetime_utils.reduce_time_ranges(time, broken_barh=True) - assert len(result) == 2 - - -def test_planck_converter(): - wnum = 1100 - temp = 300 - radiance = 81.5 - result = act.utils.radiance_utils.planck_converter(wnum=wnum, temperature=temp) - np.testing.assert_almost_equal(result, radiance, decimal=1) - result = act.utils.radiance_utils.planck_converter(wnum=wnum, radiance=radiance) - assert np.ceil(result) == temp - np.testing.assert_raises(ValueError, act.utils.radiance_utils.planck_converter) - - -def test_solar_azimuth_elevation(): - - obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_NAV) - - elevation, azimuth, distance = act.utils.geo_utils.get_solar_azimuth_elevation( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], time=obj['time'].values, - library='skyfield', temperature_C='standard', pressure_mbar='standard') - assert np.isclose(np.nanmean(elevation), 26.408, atol=0.001) - assert np.isclose(np.nanmean(azimuth), 179.732, atol=0.001) - assert np.isclose(np.nanmean(distance), 0.985, atol=0.001) - - -def test_get_sunrise_sunset_noon(): - - obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_NAV) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], - date=obj['time'].values[0], library='skyfield') - assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) - assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) - assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], - date=obj['time'].values[0], library='skyfield', timezone=True) - assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32, tzinfo=pytz.UTC) - assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4, tzinfo=pytz.UTC) - assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10, tzinfo=pytz.UTC) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], - date='20180201', library='skyfield') - assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) - assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) - assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], - date=['20180201'], library='skyfield') - assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) - assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) - assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], - date=datetime(2018, 2, 1), library='skyfield') - assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) - assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) - assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], - date=datetime(2018, 2, 1, tzinfo=pytz.UTC), library='skyfield') - assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) - assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) - assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=obj['lat'].values[0], longitude=obj['lon'].values[0], - date=[datetime(2018, 2, 1)], library='skyfield') - assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) - assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) - assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) - - sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( - latitude=85.0, longitude=-140., date=[datetime(2018, 6, 1)], library='skyfield') - assert sunrise[0].replace(microsecond=0) == datetime(2018, 3, 30, 10, 48, 48) - assert sunset[0].replace(microsecond=0) == datetime(2018, 9, 12, 8, 50, 14) - assert noon[0].replace(microsecond=0) == datetime(2018, 6, 1, 21, 17, 52) - - -def test_is_sun_visible(): - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) - result = act.utils.geo_utils.is_sun_visible( - latitude=obj['lat'].values, longitude=obj['lon'].values, - date_time=obj['time'].values) - assert len(result) == 48 - assert sum(result) == 20 - - result = act.utils.geo_utils.is_sun_visible( - latitude=obj['lat'].values, longitude=obj['lon'].values, - date_time=obj['time'].values[0]) - assert result == [False] - - result = act.utils.geo_utils.is_sun_visible( - latitude=obj['lat'].values, longitude=obj['lon'].values, - date_time=[datetime(2019, 11, 25, 13, 30, 00)]) - assert result == [True] - - result = act.utils.geo_utils.is_sun_visible( - latitude=obj['lat'].values, longitude=obj['lon'].values, - date_time=datetime(2019, 11, 25, 13, 30, 00)) - assert result == [True] diff --git a/act/utils/__init__.py b/act/utils/__init__.py index 02a0f20e8e..035bf99de3 100644 --- a/act/utils/__init__.py +++ b/act/utils/__init__.py @@ -1,52 +1,56 @@ """ -===================== -act.utils (act.utils) -===================== - -.. currentmodule:: act.utils - This module contains the common procedures used by all modules of the ARM Community Toolkit. -.. autosummary:: - :toctree: generated/ - - accumulate_precip - add_in_nan - add_solar_variable - assign_coordinates - calc_cog_sog - calculate_dqr_times - convert_units - create_pyart_obj - dates_between - datetime64_to_datetime - decode_present_weather - destination_azimuth_distance - determine_time_delta - get_missing_value - numpy_to_arm_date - planck_converter - reduce_time_ranges - ts_weighted_average """ +import lazy_loader as lazy -from .data_utils import add_in_nan -from .data_utils import get_missing_value -from .data_utils import convert_units -from .data_utils import assign_coordinates -from .data_utils import accumulate_precip -from .data_utils import ts_weighted_average -from .data_utils import create_pyart_obj -from .datetime_utils import dates_between -from .datetime_utils import numpy_to_arm_date -from .datetime_utils import reduce_time_ranges -from .datetime_utils import determine_time_delta -from .datetime_utils import datetime64_to_datetime -from .qc_utils import calculate_dqr_times -from .ship_utils import calc_cog_sog -from .geo_utils import destination_azimuth_distance -from .geo_utils import add_solar_variable -from .inst_utils import decode_present_weather -from .radiance_utils import planck_converter -from .data_utils import ChangeUnits +__getattr__, __dir__, __all__ = lazy.attach( + __name__, + submodules=['data_utils', 'datetime_utils', 'geo_utils', 'inst_utils', 'io_utils', 'qc_utils', 'radiance_utils', 'ship_utils'], + submod_attrs={ + 'data_utils': [ + 'ChangeUnits', + 'accumulate_precip', + 'add_in_nan', + 'assign_coordinates', + 'convert_units', + 'create_pyart_obj', + 'get_missing_value', + 'ts_weighted_average', + 'height_adjusted_pressure', + 'height_adjusted_temperature', + 'convert_to_potential_temp', + 'arm_site_location_search', + 'DatastreamParserARM', + ], + 'datetime_utils': [ + 'dates_between', + 'datetime64_to_datetime', + 'determine_time_delta', + 'numpy_to_arm_date', + 'reduce_time_ranges', + 'date_parser', + 'adjust_timestamp' + ], + 'geo_utils': [ + 'add_solar_variable', + 'destination_azimuth_distance', + 'get_solar_azimuth_elevation', + 'get_sunrise_sunset_noon', + 'is_sun_visible', + ], + 'inst_utils': ['decode_present_weather'], + 'qc_utils': ['calculate_dqr_times'], + 'radiance_utils': ['planck_converter'], + 'ship_utils': ['calc_cog_sog', 'proc_scog'], + 'io_utils': ['pack_tar', + 'unpack_tar', + 'cleanup_files', + 'is_gunzip_file', + 'pack_gzip', + 'unpack_gzip', + 'generate_movie' + ], + }, +) diff --git a/act/utils/data_utils.py b/act/utils/data_utils.py index 1eb457f48e..5d499338dc 100644 --- a/act/utils/data_utils.py +++ b/act/utils/data_utils.py @@ -1,17 +1,20 @@ """ -act.utils.data_utils --------------------- - Module containing utilities for the data. """ import importlib +import warnings +import json +import metpy import numpy as np +import pint import scipy.stats as stats import xarray as xr -import pint +from pathlib import Path +import re +import requests spec = importlib.util.find_spec('pyart') if spec is not None: @@ -21,36 +24,40 @@ @xr.register_dataset_accessor('utils') -class ChangeUnits(object): +class ChangeUnits: """ - Class for updating units in the object. Data values and units attribute + Class for updating units in the dataset. Data values and units attribute are updated in place. Coordinate variables can not be updated in place. Must use new returned dataset when updating coordinage varibles. """ - def __init__(self, xarray_obj): - self._obj = xarray_obj - def change_units(self, variables=None, desired_unit=None, - skip_variables=None, skip_standard=True): + def __init__(self, ds): + self._ds = ds + + def change_units( + self, variables=None, desired_unit=None, skip_variables=None, skip_standard=True + ): """ Parameters ---------- variables : None, str or list of str - Variable names to attempt to change units + Variable names to attempt to change units. desired_unit : str - Desired udunits unit string + Desired udunits unit string. skip_variables : None, str or list of str - Varible names to skip. Works well when not providing a variables keyword + Variable names to skip. Works well when not providing a variables + keyword. skip_standard : boolean - Flag indicating the QC variables that will not need changing are skipped. - Makes the processing faster when processing all variables in dataset. + Flag indicating the QC variables that will not need changing are + skipped. Makes the processing faster when processing all variables + in dataset. Returns ------- dataset : xarray.dataset - A new dataset if the coordinate variables are updated. Required to use - returned dataset if coordinage variabels are updated, otherwise the - dataset is updated in place. + A new dataset if the coordinate variables are updated. Required to + use returned dataset if coordinage variabels are updated, + otherwise the dataset is updated in place. """ if variables is not None and isinstance(variables, str): @@ -63,34 +70,268 @@ def change_units(self, variables=None, desired_unit=None, raise ValueError("Need to provide 'desired_unit' keyword for .change_units() method") if variables is None: - variables = list(self._obj.data_vars) + variables = list(self._ds.data_vars) if skip_variables is not None: variables = list(set(variables) - set(skip_variables)) for var_name in variables: try: - if self._obj[var_name].attrs['standard_name'] == 'quality_flag': + if self._ds[var_name].attrs['standard_name'] == 'quality_flag': continue except KeyError: pass try: - data = convert_units(self._obj[var_name].values, - self._obj[var_name].attrs['units'], desired_unit) + data = convert_units( + self._ds[var_name].values, + self._ds[var_name].attrs['units'], + desired_unit, + ) try: - self._obj[var_name].values = data - self._obj[var_name].attrs['units'] = desired_unit + self._ds[var_name].values = data + self._ds[var_name].attrs['units'] = desired_unit except ValueError: - attrs = self._obj[var_name].attrs - self._obj = self._obj.assign_coords({var_name: data}) + attrs = self._ds[var_name].attrs + self._ds = self._ds.assign_coords({var_name: data}) attrs['units'] = desired_unit - self._obj[var_name].attrs = attrs - except (KeyError, pint.errors.DimensionalityError, pint.errors.UndefinedUnitError, - np.core._exceptions.UFuncTypeError): + self._ds[var_name].attrs = attrs + except ( + KeyError, + pint.errors.DimensionalityError, + pint.errors.UndefinedUnitError, + np.core._exceptions.UFuncTypeError, + ): continue - return self._obj + return self._ds + + +# @xr.register_dataset_accessor('utils') +class DatastreamParserARM(object): + ''' + Class to parse ARM datastream names or filenames into its components. + Will return None for each attribute if not extracted from the filename. + + Attributes + ---------- + site : str or None + The site code extracted from the filename. + datastream_class : str + The datastream class extracted from the filename. + facility : str or None + The datastream facility code extracted from the filename. + level : str or None + The datastream level code extracted from the filename. + datastream : str or None + The datastram extracted from the filename. + date : str or None + The date extracted from the filename. + time : str or None + The time extracted from the filename. + ext : str or None + The file extension extracted from the filename. + + Example + ------- + >>> from act.utils.data_utils import DatastreamParserARM + >>> file = 'sgpmetE13.b1.20190501.024254.nc' + >>> fn_obj = DatastreamParserARM(file) + >>> fn_obj.site + 'sgp' + >>> fn_obj.datastream_class + 'met' + + + ''' + def __init__(self, ds=''): + ''' + Constructor that initializes datastream data member and runs + parse_datastream class method. Also converts datastream name to + lower case before parsing. + + ds : str + The datastream or filename to parse + + ''' + + if isinstance(ds, str): + self.__datastream = Path(ds).name + else: + raise ValueError('Datastream or filename name must be a string') + + try: + self.__parse_datastream() + except ValueError: + self.__site = None + self.__class = None + self.__facility = None + self.__datastream = None + self.__level = None + self.__date = None + self.__time = None + self.__ext = None + + def __parse_datastream(self): + ''' + Private method to parse datastream name into its various components + (site, class, facility, and data level. Is called automatically by + constructor when object of class is instantiated and when the + set_datastream method is called to reset the object. + + ''' + # Import the built-in match function from regular expression library + # self.__datastream = self.__datastream + tempstring = self.__datastream.split('.') + + # Check to see if ARM-standard filename was passed + self.__ext = None + self.__time = None + self.__date = None + self.__level = None + self.__site = None + self.__class = None + self.__facility = None + if len(tempstring) >= 5: + self.__ext = tempstring[4] + + if len(tempstring) >= 4: + self.__time = tempstring[3] + + if len(tempstring) >= 3: + self.__date = tempstring[2] + + if len(tempstring) >= 2: + m = re.match('[abcs0][0123456789]', tempstring[1]) + if m is not None: + self.__level = m.group() + + match = False + m = re.search(r'(^[a-z]{3})(\w+)([A-Z]{1}\d{1,2})$', tempstring[0]) + if m is not None: + self.__site = m.group(1) + self.__class = m.group(2) + self.__facility = m.group(3) + match = True + + if not match: + m = re.search(r'(^[a-z]{3})(\w+)$', tempstring[0]) + if m is not None: + self.__site = m.group(1) + self.__class = m.group(2) + match = True + + if not match and len(tempstring[0]) == 3: + self.__site = tempstring[0] + match = True + + if not match: + raise ValueError(self.__datastream) + + def set_datastream(self, ds): + ''' + Method used to set or reset object by passing a new datastream name. + + ''' + + self.__init__(ds) + + @property + def datastream(self): + ''' + Property returning current datastream name stored in object in + standard lower case. Will return the datastrem with no level if + unavailable. + + ''' + + try: + return ''.join((self.__site, self.__class, self.__facility, '.', + self.__level)) + except TypeError: + return None + + @property + def site(self): + ''' + Property returning current site name stored in object in standard + lower case. + + ''' + + return self.__site + + @property + def datastream_class(self): + ''' + Property returning current datastream class name stored in object in + standard lower case. Could not use class as attribute name since it + is a reserved word in Python + + ''' + + return self.__class + + @property + def facility(self): + ''' + Property returning current facility name stored in object in + standard upper case. + + ''' + + try: + return self.__facility.upper() + except AttributeError: + return self.__facility + + @property + def level(self): + ''' + Property returning current data level stored in object in standard + lower case. + ''' + + return self.__level + + @property + def datastream_standard(self): + ''' + Property returning datastream name in ARM-standard format with + facility in caps. Will return the datastream name with no level if + unavailable. + ''' + + try: + return ''.join((self.site, self.datastream_class, self.facility, + '.', self.level)) + + except TypeError: + return None + + @property + def date(self): + ''' + Property returning date from filename. + ''' + + return self.__date + + @property + def time(self): + ''' + Property returning time from filename. + ''' + + return self.__time + + @property + def ext(self): + ''' + Property returning file extension from filename. + ''' + + return self.__ext def assign_coordinates(ds, coord_list): @@ -118,12 +359,12 @@ def assign_coordinates(ds, coord_list): for coord in coord_list.keys(): if coord not in ds.variables.keys(): - raise KeyError(coord + " is not a variable in the Dataset.") + raise KeyError(coord + ' is not a variable in the Dataset.') if ds.dims[coord_list[coord]] != len(ds.variables[coord]): - raise IndexError((coord + " must have the same " + - "value as length of " + - coord_list[coord])) + raise IndexError( + coord + ' must have the same ' + 'value as length of ' + coord_list[coord] + ) new_ds_dict = {} for variable in ds.variables.keys(): @@ -135,8 +376,7 @@ def assign_coordinates(ds, coord_list): my_coord_dict[coord_list[coord]] = ds[coord] if variable not in my_coord_dict.keys() and variable not in ds.dims: - the_dataarray = xr.DataArray(dataarray.data, coords=my_coord_dict, - dims=dataarray.dims) + the_dataarray = xr.DataArray(dataarray.data, coords=my_coord_dict, dims=dataarray.dims) new_ds_dict[variable] = the_dataarray new_ds = xr.Dataset(new_ds_dict, coords=my_coord_dict) @@ -146,81 +386,112 @@ def assign_coordinates(ds, coord_list): def add_in_nan(time, data): """ - This procedure adds in NaNs for given time periods in time when there is no - corresponding data available. This is useful for timeseries that have - irregular gaps in data. + This procedure adds in NaNs when there is a larger than expected time step. + This is useful for timeseries where there is a gap in data and need a + NaN value to stop plotting from connecting data over the large data gap. Parameters ---------- - time : 1D array of np.datetime64 - List of times in the timeseries. - data : 1 or 2D array + time : 1D array of numpy datetime64 or Xarray DataArray of datetime64 + Times in the timeseries. + data : 1D or 2D numpy array or Xarray DataArray Array containing the data. The 0 axis corresponds to time. Returns ------- - d_time : xarray DataArray - The xarray DataArray containing the new times at regular intervals. + time : numpy array or Xarray DataArray + The array containing the new times including a NaN filled + sampe or slice if multi-dimensional. The intervals are determined by the mode of the timestep in *time*. - d_data : xarray DataArray - The xarray DataArray containing the NaN-filled data. + data : numpy array or Xarray DataArray + The array containing the NaN-indserted data. """ - # Return if time dimension is only size one since we can't do differences. - if time.size < 2: - return time, data - - diff = np.diff(time, 1) / np.timedelta64(1, 's') - mode = stats.mode(diff).mode[0] - index = np.where(diff > 2. * mode) - d_data = np.asarray(data) - d_time = np.asarray(time) - - offset = 0 - for i in index[0]: - n_obs = np.floor( - (time[i + 1] - time[i]) / mode / np.timedelta64(1, 's')) - time_arr = [ - d_time[i + offset] + np.timedelta64(int((n + 1) * mode), 's') - for n in range(int(n_obs) - 1)] - S = d_data.shape - if len(S) == 2: - data_arr = np.empty([len(time_arr), S[1]]) - else: - data_arr = np.empty([len(time_arr)]) - data_arr[:] = np.nan - - d_time = np.insert(d_time, i + 1 + offset, time_arr) - d_data = np.insert(d_data, i + 1 + offset, data_arr, axis=0) - offset += len(time_arr) - - d_time = xr.DataArray(d_time) - d_data = xr.DataArray(d_data) - return d_time, d_data + time_is_DataArray = False + data_is_DataArray = False + if isinstance(time, xr.core.dataarray.DataArray): + time_is_DataArray = True + time_attributes = time.attrs + time_dims = time.dims + if isinstance(data, xr.core.dataarray.DataArray): + data_is_DataArray = True + data_attributes = data.attrs + data_dims = data.dims - -def get_missing_value(data_object, variable, default=-9999, - add_if_missing_in_obj=False, - use_FillValue=False, nodefault=False): + # Return if time dimension is only size one since we can't do differences. + if time.size > 2: + data = np.asarray(data) + time = np.asarray(time) + # Not sure if we need to set to second data type to make it work better. + # Leaving code in here in case we need to update. + # diff = np.diff(time.astype('datetime64[s]'), 1) + diff = np.diff(time, 1) + + # Wrapping in a try to catch error while switching between numpy 1.10 to 1.11 + try: + mode = stats.mode(diff, keepdims=True).mode[0] + except TypeError: + mode = stats.mode(diff).mode[0] + index = np.where(diff > (2.0 * mode)) + + offset = 0 + for i in index[0]: + corr_i = i + offset + + if len(data.shape) == 1: + # For line plotting adding a NaN will stop the connection of the line + # between points. So we just need to add a NaN anywhere between the points. + corr_i = i + offset + time_added = time[corr_i] + (time[corr_i + 1] - time[corr_i]) / 2.0 + time = np.insert(time, corr_i + 1, time_added) + data = np.insert(data, corr_i + 1, np.nan, axis=0) + offset += 1 + else: + # For 2D plots need to add a NaN right after and right before the data + # to correctly mitigate streaking with pcolormesh. + time_added_1 = time[corr_i] + 1 # One time step after + time_added_2 = time[corr_i + 1] - 1 # One time step before + time = np.insert(time, corr_i + 1, [time_added_1, time_added_2]) + data = np.insert(data, corr_i + 1, np.nan, axis=0) + data = np.insert(data, corr_i + 2, np.nan, axis=0) + offset += 2 + + if time_is_DataArray: + time = xr.DataArray(time, attrs=time_attributes, dims=time_dims) + + if data_is_DataArray: + data = xr.DataArray(data, attrs=data_attributes, dims=data_dims) + + return time, data + + +def get_missing_value( + ds, + variable, + default=-9999, + add_if_missing_in_ds=False, + use_FillValue=False, + nodefault=False, +): """ Function to get missing value from missing_value or _FillValue attribute. Works well with catching errors and allows for a default value when a - missing value is not listed in the object. You may get strange results + missing value is not listed in the dataset. You may get strange results becaus xarray will automatically convert all missing_value or _FillValue to NaN and then remove the missing_value and _FillValue variable attribute when reading data with default settings. Parameters ---------- - data_object : xarray dataset + ds : xarray.Dataset Xarray dataset containing data variable. variable : str Variable name to use for getting missing value. default : int or float - Default value to use if missing value attribute is not in data object. - add_if_missing_in_obj : bool - Boolean to add to object if does not exist. Default is False. + Default value to use if missing value attribute is not in dataset. + add_if_missing_in_ds : bool + Boolean to add to the dataset if does not exist. Default is False. use_FillValue : bool Boolean to use _FillValue instead of missing_value. If missing_value does exist and _FillValue does not will add _FillValue @@ -241,12 +512,13 @@ def get_missing_value(data_object, variable, default=-9999, .. code-block:: python from act.utils import get_missing_value - missing = get_missing_value(dq_object, 'temp_mean') + + missing = get_missing_value(dq_ds, "temp_mean") print(missing) -9999.0 """ - in_object = False + in_ds = False if use_FillValue: missing_atts = ['_FillValue', 'missing_value'] else: @@ -254,34 +526,40 @@ def get_missing_value(data_object, variable, default=-9999, for att in missing_atts: try: - missing = data_object[variable].attrs[att] - in_object = True + missing = ds[variable].attrs[att] + in_ds = True break except (AttributeError, KeyError): missing = default # Check if do not want a default value retured and a value # was not fund. - if nodefault is True and in_object is False: + if nodefault is True and in_ds is False: missing = None return missing # Check data type and try to match missing_value to the data type of data try: - missing = data_object[variable].data.dtype.type(missing) + missing = ds[variable].data.dtype.type(missing) except KeyError: pass except AttributeError: - print(('--- AttributeError: Issue trying to get data type ' + - 'from "{}" data ---').format(variable)) - - # If requested add missing value to object - if add_if_missing_in_obj and not in_object: + print( + ('--- AttributeError: Issue trying to get data type ' + 'from "{}" data ---').format( + variable + ) + ) + + # If requested add missing value to the dataset + if add_if_missing_in_ds and not in_ds: try: - data_object[variable].attrs[missing_atts[0]] = missing + ds[variable].attrs[missing_atts[0]] = missing except KeyError: - print(('--- KeyError: Issue trying to add "{}" ' + - 'attribute to "{}" ---').format(missing_atts[0], variable)) + print( + ('--- KeyError: Issue trying to add "{}" ' + 'attribute to "{}" ---').format( + missing_atts[0], variable + ) + ) return missing @@ -320,8 +598,8 @@ def convert_units(data, in_units, out_units): convert_dict = { 'C': 'degC', 'F': 'degF', - '%': 'percent', # seems like pint does not like this symbol? - '1': 'unitless', # seems like pint does not like this number? + '%': 'percent', # Pint does not like this symbol with .to('%') + '1': 'unitless', # Pint does not like a number } if in_units in convert_dict: @@ -336,9 +614,9 @@ def convert_units(data, in_units, out_units): # Instantiate the registry ureg = pint.UnitRegistry(autoconvert_offset_to_baseunit=True) - # Add missing units - ureg.define('percent = 0.01*count = %') - ureg.define('unitless = count = 1') + # Add missing units and conversions + ureg.define('fraction = []') + ureg.define('unitless = []') if not isinstance(data, np.ndarray): data = np.array(data) @@ -355,10 +633,12 @@ def convert_units(data, in_units, out_units): # need float precision. If so leave, if not change back to orginal # precision after checking if the precsion is not lost with the orginal # data type. - if (data_type_kind == 'i' and - np.nanmin(data) >= np.iinfo(data_type).min and - np.nanmax(data) <= np.iinfo(data_type).max and - np.all(np.mod(data, 1) == 0)): + if ( + data_type_kind == 'i' + and np.nanmin(data) >= np.iinfo(data_type).min + and np.nanmax(data) <= np.iinfo(data_type).max + and np.all(np.mod(data, 1) == 0) + ): data = data.astype(data_type) return data @@ -375,16 +655,25 @@ def ts_weighted_average(ts_dict): Parameters ---------- ts_dict : dict - Dictionary containing datastream, variable, weight, and objects + Dictionary containing datastream, variable, weight, and datasets .. code-block:: python - t_dict = {'sgpvdisC1.b1': {'variable': 'rain_rate', 'weight': 0.05, - 'object': act_obj} - 'sgpmetE13.b1': {'variable': ['tbrg_precip_total', - 'org_precip_rate_mean', - 'pwd_precip_rate_mean_1min'], - 'weight': [0.25, 0.05, 0.0125]}} + t_dict = { + "sgpvdisC1.b1": { + "variable": "rain_rate", + "weight": 0.05, + "ds": ds, + }, + "sgpmetE13.b1": { + "variable": [ + "tbrg_precip_total", + "org_precip_rate_mean", + "pwd_precip_rate_mean_1min", + ], + "weight": [0.25, 0.05, 0.0125], + }, + } Returns ------- @@ -395,12 +684,12 @@ def ts_weighted_average(ts_dict): # Run through each datastream/variable and get data da_array = [] - data = 0. + data = 0.0 for d in ts_dict: for i, v in enumerate(ts_dict[d]['variable']): new_name = '_'.join([d, v]) # Since many variables may have same name, rename with datastream - da = ts_dict[d]['object'][v].rename(new_name) + da = ts_dict[d]['ds'][v].rename(new_name) # Apply Weights to Data da.values = da.values * ts_dict[d]['weight'][i] @@ -420,164 +709,216 @@ def ts_weighted_average(ts_dict): data = np.nansum(data, 0) # Add data to data array and return - dims = ts_dict[list(ts_dict.keys())[0]]['object'].dims - da_xr = xr.DataArray(data, dims=dims, - coords={'time': ts_dict[list(ts_dict.keys())[0]]['object']['time']}) + dims = ts_dict[list(ts_dict.keys())[0]]['ds'].dims + da_xr = xr.DataArray( + data, + dims=dims, + coords={'time': ts_dict[list(ts_dict.keys())[0]]['ds']['time']}, + ) da_xr.attrs['long_name'] = 'Weighted average of ' + ', '.join(list(ts_dict.keys())) return da_xr -def accumulate_precip(act_obj, variable, time_delta=None): +def accumulate_precip(ds, variable, time_delta=None): """ - Program to accumulate rain rates from an act object and insert variable back - into act object with "_accumulated" appended to the variable name. Please - verify that your units are accurately described in the data. + Program to accumulate rain rates from an act xarray dataset and insert + variable back into an act xarray dataset with "_accumulated" appended to + the variable name. Please verify that your units are accurately described + in the data. Parameters ---------- - act_obj : xarray DataSet - ACT Object. + ds : xarray.DataSet + ACT Xarray dataset. variable : string - Variable name + Variable name. time_delta : float Time delta to caculate precip accumulations over. - Useful if full time series is not passed in + Useful if full time series is not passed in. Returns ------- - act_obj : xarray DataSet - ACT object with variable_accumulated. + ds : xarray.DataSet + ACT Xarray dataset with variable_accumulated. """ # Get Data, time, and metadat - data = act_obj[variable] - time = act_obj.coords['time'] - units = act_obj[variable].attrs['units'] + data = ds[variable] + time = ds.coords['time'] + units = ds[variable].attrs['units'] # Calculate mode of the time samples(i.e. 1 min vs 1 sec) if time_delta is None: diff = np.diff(time.values, 1) / np.timedelta64(1, 's') - t_delta = stats.mode(diff).mode + try: + t_delta = stats.mode(diff, keepdims=False).mode + except TypeError: + t_delta = stats.mode(diff).mode else: t_delta = time_delta # Calculate the accumulation based on the units - t_factor = t_delta / 60. + t_factor = t_delta / 60.0 if units == 'mm/hr': - data = data * (t_factor / 60.) + data = data * (t_factor / 60.0) accum = np.nancumsum(data.values) - # Add accumulated variable back to ACT object + # Add accumulated variable back to the dataset long_name = 'Accumulated precipitation' attrs = {'long_name': long_name, 'units': 'mm'} - act_obj['_'.join([variable, 'accumulated'])] = xr.DataArray(accum, coords=act_obj[variable].coords, - attrs=attrs) - - return act_obj - - -def create_pyart_obj(obj, variables=None, sweep=None, azimuth=None, elevation=None, - range_var=None, sweep_start=None, sweep_end=None, lat=None, lon=None, - alt=None, sweep_mode='ppi'): + ds['_'.join([variable, 'accumulated'])] = xr.DataArray( + accum, coords=ds[variable].coords, attrs=attrs + ) + + return ds + + +def create_pyart_obj( + ds, + variables=None, + sweep=None, + azimuth=None, + elevation=None, + range_var=None, + sweep_start=None, + sweep_end=None, + lat=None, + lon=None, + alt=None, + sweep_mode='ppi', + sweep_az_thresh=10.0, + sweep_el_thresh=0.5, +): """ - Produces a PyART radar object based on data in the ACT object + Produces a Py-ART radar object based on data in the ACT Xarray dataset. Parameters ---------- - obj : xarray DataSet - ACT Object. + ds : xarray.DataSet + ACT Xarray dataset. variables : list - List of variables to add to the radar object, will default to all variables + List of variables to add to the radar object, will default to all + variables. sweep : string - Name of variable that has sweep information. If none, will try and calculate - from the azimuth and elevation + Name of variable that has sweep information. If none, will try and + calculate from the azimuth and elevation. azimuth : string - Name of azimuth variable. Will try and find one if none given + Name of azimuth variable. Will try and find one if none given. elevation : string - Name of elevation variable. Will try and find one if none given + Name of elevation variable. Will try and find one if none given. range_var : string - Name of the range variable. Will try and find one if none given + Name of the range variable. Will try and find one if none given. sweep_start : string - Name of variable with sweep start indices + Name of variable with sweep start indices. sweep_end : string - Name of variable with sweep end indices + Name of variable with sweep end indices. lat : string - Name of latitude variable. Will try and find one if none given + Name of latitude variable. Will try and find one if none given. lon : string - Name of longitude variable. Will try and find one if none given + Name of longitude variable. Will try and find one if none given. alt : string - Name of altitude variable. Will try and find one if none given + Name of altitude variable. Will try and find one if none given. sweep_mode : string - Type of scan. Defaults to PPI + Type of scan. Defaults to PPI. + sweep_az_thresh : float + If calculating sweep numbers, the maximum change in azimuth before new + sweep. + sweep_el_thresh : float + If calculating sweep numbers, the maximum change in elevation before + new sweep. Returns ------- - radar : PyART Object - PyART Radar Object + radar : radar.Radar + Py-ART Radar Object. """ if not PYART_AVAILABLE: - raise ImportError("PyART needs to be installed on your system to convert to PyART Object") + raise ImportError( + 'Py-ART needs to be installed on your system to convert to ' 'Py-ART Object.' + ) else: import pyart # Get list of variables if none provided if variables is None: - variables = list(obj.keys()) + variables = list(ds.keys()) # Determine the sweeps if not already in a variable$a if sweep is None: - swp = np.zeros(obj.sizes['time']) + swp = np.zeros(ds.sizes['time']) + for key in ds.variables.keys(): + if len(ds.variables[key].shape) == 2: + total_rays = ds.variables[key].shape[0] + break + nsweeps = int(total_rays / ds.variables['time'].shape[0]) else: - swp = obj[sweep].values + swp = ds[sweep].values + nsweeps = ds[sweep].values # Get coordinate variables if lat is None: - lat = [s for s in variables if "latitude" in s][0] + lat = [s for s in variables if 'latitude' in s] if len(lat) == 0: - lat = [s for s in variables if "lat" in s][0] + lat = [s for s in variables if 'lat' in s] if len(lat) == 0: - raise ValueError("Latitude variable not set and could not be discerned from the data") + raise ValueError( + 'Latitude variable not set and could not be ' 'discerned from the data.' + ) + else: + lat = lat[0] if lon is None: - lon = [s for s in variables if "longitude" in s][0] + lon = [s for s in variables if 'longitude' in s] if len(lon) == 0: - lon = [s for s in variables if "lon" in s][0] + lon = [s for s in variables if 'lon' in s] if len(lon) == 0: - raise ValueError("Longitude variable not set and could not be discerned from the data") + raise ValueError( + 'Longitude variable not set and could not be ' 'discerned from the data.' + ) + else: + lon = lon[0] if alt is None: - alt = [s for s in variables if "altitude" in s][0] + alt = [s for s in variables if 'altitude' in s] if len(alt) == 0: - alt = [s for s in variables if "alt" in s][0] + alt = [s for s in variables if 'alt' in s] if len(alt) == 0: - raise ValueError("Altitude variable not set and could not be discerned from the data") + raise ValueError( + 'Altitude variable not set and could not be ' 'discerned from the data.' + ) + else: + alt = alt[0] # Get additional variable names if none provided if azimuth is None: - azimuth = [s for s in sorted(variables) if "azimuth" in s][0] + azimuth = [s for s in sorted(variables) if 'azimuth' in s][0] if len(azimuth) == 0: - raise ValueError("Azimuth variable not set and could not be discerned from the data") + raise ValueError( + 'Azimuth variable not set and could not be ' 'discerned from the data.' + ) if elevation is None: - elevation = [s for s in sorted(variables) if "elevation" in s][0] + elevation = [s for s in sorted(variables) if 'elevation' in s][0] if len(elevation) == 0: - raise ValueError("Elevation variable not set and could not be discerned from the data") + raise ValueError( + 'Elevation variable not set and could not be ' 'discerned from the data.' + ) if range_var is None: - range_var = [s for s in sorted(variables) if "range" in s][0] + range_var = [s for s in sorted(variables) if 'range' in s][0] if len(range_var) == 0: - raise ValueError("Range variable not set and could not be discerned from the data") + raise ValueError('Range variable not set and could not be ' 'discerned from the data.') # Calculate the sweep indices if not passed in if sweep_start is None and sweep_end is None: - az_diff = np.abs(np.diff(obj[azimuth].values)) - az_idx = (az_diff > 10.) + az_diff = np.abs(np.diff(ds[azimuth].values)) + az_idx = az_diff > sweep_az_thresh - el_diff = np.abs(np.diff(obj[elevation].values)) - el_idx = (el_diff > 0.5) + el_diff = np.abs(np.diff(ds[elevation].values)) + el_idx = el_diff > sweep_el_thresh # Create index list az_index = list(np.where(az_idx)[0] + 1) @@ -585,29 +926,29 @@ def create_pyart_obj(obj, variables=None, sweep=None, azimuth=None, elevation=No index = sorted(az_index + el_index) index.insert(0, 0) - index += [obj.sizes['time']] + index += [ds.sizes['time']] sweep_start_index = [] sweep_end_index = [] for i in range(len(index) - 1): sweep_start_index.append(index[i]) sweep_end_index.append(index[i + 1] - 1) - swp[index[i]:index[i + 1]] = i + swp[index[i] : index[i + 1]] = i else: - sweep_start_index = obj[sweep_start].values - sweep_end_index = obj[sweep_end].values + sweep_start_index = ds[sweep_start].values + sweep_end_index = ds[sweep_end].values if sweep is None: for i in range(len(sweep_start_index)): - swp[sweep_start_index[i]:sweep_end_index[i]] = i + swp[sweep_start_index[i] : sweep_end_index[i]] = i - radar = pyart.testing.make_empty_ppi_radar(obj.sizes[range_var], obj.sizes['time'], len(np.unique(swp))) + radar = pyart.testing.make_empty_ppi_radar(ds.sizes[range_var], ds.sizes['time'], nsweeps) - radar.time['data'] = np.array(obj['time'].values) + radar.time['data'] = np.array(ds['time'].values) - # Add lat, lon, alt - radar.latitude['data'] = np.array(obj[lat].values) - radar.longitude['data'] = np.array(obj[lon].values) - radar.altitude['data'] = np.array(obj[alt]) + # Add lat, lon, and alt + radar.latitude['data'] = np.array(ds[lat].values) + radar.longitude['data'] = np.array(ds[lon].values) + radar.altitude['data'] = np.array(ds[alt].values) # Add sweep information radar.sweep_number['data'] = swp @@ -617,10 +958,10 @@ def create_pyart_obj(obj, variables=None, sweep=None, azimuth=None, elevation=No radar.scan_type = sweep_mode # Add elevation, azimuth, etc... - radar.azimuth['data'] = np.array(obj[azimuth]) - radar.elevation['data'] = np.array(obj[elevation]) - radar.fixed_angle['data'] = np.array(obj[elevation].values[0]) - radar.range['data'] = np.array(obj[range_var].values) + radar.azimuth['data'] = np.array(ds[azimuth]) + radar.elevation['data'] = np.array(ds[elevation]) + radar.fixed_angle['data'] = np.array(ds[elevation].values[0]) + radar.range['data'] = np.array(ds[range_var].values) # Calculate radar points in lat/lon radar.init_gate_altitude() @@ -630,8 +971,342 @@ def create_pyart_obj(obj, variables=None, sweep=None, azimuth=None, elevation=No fields = {} for v in variables: ref_dict = pyart.config.get_metadata(v) - ref_dict['data'] = np.array(obj[v].values) + ref_dict['data'] = np.array(ds[v].values) fields[v] = ref_dict radar.fields = fields return radar + + +def convert_to_potential_temp( + ds=None, + temp_var_name=None, + press_var_name=None, + temperature=None, + pressure=None, + temp_var_units=None, + press_var_units=None, +): + + """ + Converts temperature to potential temperature. + + Parameters + ---------- + ds : xarray.DataSet + ACT Xarray dataset + temp_var_name : str + Temperature variable name in the ACT Xarray dataset containing + temperature data to convert. + press_var_name : str + Pressure variable name in the ACT Xarray dataset containing the + pressure data to use in conversion. If not set or set to None will + use values from pressure keyword. + pressure : int, float, numpy array + Optional pressure values to use instead of using values from xarray + dataset. If set must also set press_var_units keyword. + temp_var_units : string + Pint recognized units string for temperature data. If set to None will + use the units attribute under temperature variable in ds. + press_var_units : string + Pint recognized units string for pressure data. If set to None will + use the units attribute under pressure variable in the dataset. If using + the pressure keyword this must be set. + + Returns + ------- + potential_temperature : None, int, float, numpy array + The converted temperature to potential temperature or None if something + goes wrong. + + References + ---------- + May, R. M., Arms, S. C., Marsh, P., Bruning, E., Leeman, J. R., Goebbert, + K., Thielen, J. E., and Bruick, Z., 2021: MetPy: A Python Package for + Meteorological Data. Unidata, https://github.com/Unidata/MetPy, + doi:10.5065/D6WW7G29. + + """ + potential_temp = None + if temp_var_units is None and temp_var_name is not None: + temp_var_units = ds[temp_var_name].attrs['units'] + if press_var_units is None and press_var_name is not None: + press_var_units = ds[press_var_name].attrs['units'] + + if press_var_units is None: + raise ValueError( + "Need to provide 'press_var_units' keyword " "when using 'pressure' keyword" + ) + if temp_var_units is None: + raise ValueError( + "Need to provide 'temp_var_units' keyword " "when using 'temperature' keyword" + ) + + if temperature is not None: + temperature = metpy.units.units.Quantity(temperature, temp_var_units) + else: + temperature = metpy.units.units.Quantity(ds[temp_var_name].values, temp_var_units) + + if pressure is not None: + pressure = metpy.units.units.Quantity(pressure, press_var_units) + else: + pressure = metpy.units.units.Quantity(ds[press_var_name].values, press_var_units) + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + potential_temp = metpy.calc.potential_temperature(pressure, temperature) + potential_temp = potential_temp.to(temp_var_units).magnitude + + return potential_temp + + +def height_adjusted_temperature( + ds=None, + temp_var_name=None, + height_difference=0, + height_units='m', + press_var_name=None, + temperature=None, + temp_var_units=None, + pressure=101.325, + press_var_units='kPa', +): + """ + Converts temperature for change in height. + + Parameters + ---------- + ds : xarray.DataSet, None + Optional Xarray dataset for retrieving pressure and temperature values. + Not needed if using temperature keyword. + temp_var_name : str, None + Optional temperature variable name in the Xarray dataset containing the + temperature data to use in conversion. If not set or set to None will + use values from temperature keyword. + height_difference : int, float + Required difference in height to adjust pressure values. Positive + values to increase height negative values to decrease height. + height_units : str + Units of height value. + press_var_name : str, None + Optional pressure variable name in the Xarray dataset containing the + pressure data to use in conversion. If not set or set to None will + use values from pressure keyword. + temperature : int, float, numpy array, None + Optional temperature values to use instead of values in the dataset. + temp_var_units : str, None + Pint recognized units string for temperature data. If set to None will + use the units attribute under temperature variable in the dataset. + If using the temperature keyword this must be set. + pressure : int, float, numpy array, None + Optional pressure values to use instead of values in the dataset. + Default value of sea level pressure is set for ease of use. + press_var_units : str, None + Pint recognized units string for pressure data. If set to None will + use the units attribute under pressure variable in the dataset. + If using the pressure keyword this must be set. Default value of + sea level pressure is set for ease of use. + + Returns + ------- + adjusted_temperature : None, int, float, numpy array + The height adjusted temperature or None if something goes wrong. + + References + ---------- + May, R. M., Arms, S. C., Marsh, P., Bruning, E., Leeman, J. R., Goebbert, + K., Thielen, J. E., and Bruick, Z., 2021: MetPy: A Python Package for + Meteorological Data. Unidata, https://github.com/Unidata/MetPy, + doi:10.5065/D6WW7G29. + + """ + adjusted_temperature = None + if temp_var_units is None and temperature is None: + temp_var_units = ds[temp_var_name].attrs['units'] + if temp_var_units is None: + raise ValueError( + "Need to provide 'temp_var_units' keyword when " 'providing temperature keyword values.' + ) + + if temperature is not None: + temperature = metpy.units.units.Quantity(temperature, temp_var_units) + else: + temperature = metpy.units.units.Quantity(ds[temp_var_name].values, temp_var_units) + + if press_var_name is not None: + pressure = metpy.units.units.Quantity(ds[press_var_name].values, press_var_units) + else: + pressure = metpy.units.units.Quantity(pressure, press_var_units) + + adjusted_pressure = height_adjusted_pressure( + height_difference=height_difference, + height_units=height_units, + pressure=pressure.magnitude, + press_var_units=press_var_units, + ) + adjusted_pressure = metpy.units.units.Quantity(adjusted_pressure, press_var_units) + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + adjusted_temperature = metpy.calc.dry_lapse(adjusted_pressure, temperature, pressure) + adjusted_temperature = adjusted_temperature.to(temp_var_units).magnitude + + return adjusted_temperature + + +def height_adjusted_pressure( + ds=None, + press_var_name=None, + height_difference=0, + height_units='m', + pressure=None, + press_var_units=None, +): + """ + Converts pressure for change in height. + + Parameters + ---------- + ds : xarray.DataSet, None + Optional Xarray dataset for retrieving pressure values. Not needed if + using pressure keyword. + press_var_name : str, None + Optional pressure variable name in the Xarray dataset containing the + pressure data to use in conversion. If not set or set to None will + use values from pressure keyword. + height_difference : int, float + Required difference in height to adjust pressure values. Positive + values to increase height negative values to decrease height. + height_units : str + Units of height value. + pressure : int, float, numpy array, None + Optional pressure values to use instead of values in the dataset. + press_var_units : str, None + Pint recognized units string for pressure data. If set to None will + use the units attribute under pressure variable in the dataset. + If using the pressure keyword this must be set. + + Returns + ------- + adjusted_pressure : None, int, float, numpy array + The height adjusted pressure or None if something goes wrong. + + References + ---------- + May, R. M., Arms, S. C., Marsh, P., Bruning, E., Leeman, J. R., Goebbert, + K., Thielen, J. E., and Bruick, Z., 2021: MetPy: A Python Package for + Meteorological Data. Unidata, https://github.com/Unidata/MetPy, + doi:10.5065/D6WW7G29. + + """ + adjusted_pressure = None + if press_var_units is None and pressure is None: + press_var_units = ds[press_var_name].attrs['units'] + + if press_var_units is None: + raise ValueError( + "Need to provide 'press_var_units' keyword when " 'providing pressure keyword values.' + ) + + if pressure is not None: + pressure = metpy.units.units.Quantity(pressure, press_var_units) + else: + pressure = metpy.units.units.Quantity(ds[press_var_name].values, press_var_units) + + height_difference = metpy.units.units.Quantity(height_difference, height_units) + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=RuntimeWarning) + adjusted_pressure = metpy.calc.add_height_to_pressure(pressure, height_difference) + adjusted_pressure = adjusted_pressure.to(press_var_units).magnitude + + return adjusted_pressure + + +def arm_site_location_search(site_code='sgp', facility_code=None): + """ + Parameters + ---------- + site_code : str + ARM site code to retrieve facilities and coordinate information. Example and default + is 'sgp'. + facility_code : str or None + Facility code or codes for the ARM site provided. If None is provided, all facilities are returned. + Example string for multiple facilities is 'A4,I5'. + + Returns + ------- + coord_dict : dict + A dictionary containing the facility chosen coordinate information or all facilities + if None for facility_code and their respective coordinates. + + """ + headers = { + 'Content-Type': 'application/json', + } + # Return all facilities if facility_code is None else set the query to include + # facility search + if facility_code is None: + query = "site_code:" + site_code + else: + query = "site_code:" + site_code + " AND facility_code:" + facility_code + + # Search aggregation for elastic search + json_data = { + "aggs": { + "distinct_facility_code": { + "terms": { + "field": "facility_code.keyword", + "order": { + "_key": "asc" + }, + "size": 7000, + }, + "aggs": { + "hits": { + "top_hits": { + "_source": [ + "site_type", + "site_code", + "facility_code", + "location", + ], + "size": 1 + }, + }, + }, + }, + }, + "size": 0, + "query": { + "query_string": { + "query": query, + }, + }, + } + + # Uses requests to grab metadata from arm.gov. + response = requests.get('https://adc.arm.gov/elastic/metadata/_search', headers=headers, json=json_data) + # Loads the text to a dictionary + response_dict = json.loads(response.text) + + # Searches dictionary for the site, facility and coordinate information. + coord_dict = {} + # Loop through each facility. + for i in range(len(response_dict['aggregations']['distinct_facility_code']['buckets'])): + site_info = response_dict['aggregations']['distinct_facility_code']['buckets'][i]['hits']['hits']['hits'][0]['_source'] + site = site_info['site_code'] + facility = site_info['facility_code'] + # Some sites do not contain coordinate information, return None if that is the case. + if site_info['location'] is None: + coords = {'latitude': None, + 'longitude': None} + else: + lat, lon = site_info['location'].split(',') + lat = float(lat) + lon = float(lon) + coords = {'latitude': lat, + 'longitude': lon} + coord_dict.setdefault(site + ' ' + facility, coords) + + return coord_dict diff --git a/act/utils/datetime_utils.py b/act/utils/datetime_utils.py index 7c56c8fc93..e2e890bf9e 100644 --- a/act/utils/datetime_utils.py +++ b/act/utils/datetime_utils.py @@ -1,16 +1,14 @@ """ -act.utils.datetime_utils ------------------------- - Module that containing utilities involving datetimes. """ import datetime as dt -import pandas as pd +import warnings + import numpy as np +import pandas as pd from scipy import stats -import warnings def dates_between(sdate, edate): @@ -32,10 +30,10 @@ def dates_between(sdate, edate): The array containing the dates between *sdate* and *edate*. """ - days = dt.datetime.strptime(edate, '%Y%m%d') - \ - dt.datetime.strptime(sdate, '%Y%m%d') - all_dates = [dt.datetime.strptime(sdate, '%Y%m%d') + dt.timedelta(days=d) - for d in range(days.days + 1)] + days = dt.datetime.strptime(edate, '%Y%m%d') - dt.datetime.strptime(sdate, '%Y%m%d') + all_dates = [ + dt.datetime.strptime(sdate, '%Y%m%d') + dt.timedelta(days=d) for d in range(days.days + 1) + ] return all_dates @@ -52,15 +50,19 @@ def numpy_to_arm_date(_date, returnTime=False): Returns ------- - arm_date : string + arm_date : string or None Returns an arm date. """ - date = pd.to_datetime(str(_date)) - if returnTime is False: - date = date.strftime('%Y%m%d') - else: - date = date.strftime('%H%M%S') + from dateutil.parser._parser import ParserError + try: + date = pd.to_datetime(str(_date)) + if returnTime is False: + date = date.strftime('%Y%m%d') + else: + date = date.strftime('%H%M%S') + except ParserError: + date = None return date @@ -102,16 +104,17 @@ def reduce_time_ranges(time, time_delta=60, broken_barh=False): # Create a list of tuples containg time ranges or start time with duration if broken_barh: - return [(time[dd[ii] + 1], time[dd[ii + 1]] - time[dd[ii] + 1]) - for ii in range(len(dd) - 1)] + return [ + (time[dd[ii] + 1], time[dd[ii + 1]] - time[dd[ii] + 1]) for ii in range(len(dd) - 1) + ] else: return [(time[dd[ii] + 1], time[dd[ii + 1]]) for ii in range(len(dd) - 1)] def determine_time_delta(time, default=60): """ - Returns the most likely time step in seconds by analyzing the difference in - time steps. + Returns the most likely time step in seconds by analyzing the difference + in time steps. Parameters ---------- @@ -128,9 +131,12 @@ def determine_time_delta(time, default=60): """ with warnings.catch_warnings(): - warnings.filterwarnings("ignore", category=RuntimeWarning) + warnings.filterwarnings('ignore', category=RuntimeWarning) if time.size > 1: - mode = stats.mode(np.diff(time)) + try: + mode = stats.mode(np.diff(time), keepdims=True) + except TypeError: + mode = stats.mode(np.diff(time)) time_delta = mode.mode[0] time_delta = time_delta.astype('timedelta64[s]').astype(float) else: @@ -141,23 +147,130 @@ def determine_time_delta(time, default=60): def datetime64_to_datetime(time): """ - Given a numpy datetime64 array time series, return datetime (y, m, d, h, m, s) + Given a numpy datetime64 array time series, return datetime + (y, m, d, h, m, s) Parameters ---------- - time: numpy datetime64 array, list of numpy datetime64 values or scalar numpy datetime64 - The numpy array of date time values. + time : numpy datetime64 array, list of numpy datetime64 values or + scalar numpy datetime64. The numpy array of date time values. Returns ------- - datetime: list + datetime : list Returns a list of datetimes (y, m, d, h, m, s) from a time series. + YYYY-MM-DD, DD.MM.YYYY, DD/MM/YYYY or YYYYMMDD. """ if isinstance(time, (tuple, list)): time = np.array(time) if len(time.shape) == 0: time = np.array([time]) - datetime_array = [dt.datetime.fromtimestamp(tm.astype('datetime64[ms]').astype('float') / 1000., - tz=dt.timezone.utc).replace(tzinfo=None) for tm in time] + datetime_array = [ + dt.datetime.fromtimestamp( + tm.astype('datetime64[ms]').astype('float') / 1000.0, tz=dt.timezone.utc + ).replace(tzinfo=None) + for tm in time + ] return datetime_array + + +def date_parser(date_string, output_format='%Y%m%d', return_datetime=False): + """Converts one datetime string to another or to + a datetime object. + + Parameters + ---------- + date_string : str + datetime string to be parsed. Accepted formats are + YYYY-MM-DD, DD.MM.YYYY, DD/MM/YYYY or YYYYMMDD. + output_format : str + Format for datetime.strftime to output datetime string. + return_datetime : bool + If true, returns str as a datetime object. + Default is False. + + returns + ------- + datetime_str : str + A valid datetime string. + datetime_obj : datetime.datetime + A datetime object. + + """ + date_fmts = [ + '%Y-%m-%d', + '%d.%m.%Y', + '%d/%m/%Y', + '%Y%m%d', + '%Y/%m/%d', + '%Y-%m-%dT%H:%M:%S', + '%d.%m.%YT%H:%M:%S', + '%d/%m/%YT%H:%M:%S', + '%Y%m%dT%%H:%M:%S', + '%Y/%m/%dT%H:%M:%S', + ] + for fmt in date_fmts: + try: + datetime_obj = dt.datetime.strptime(date_string, fmt) + if return_datetime: + return datetime_obj + else: + return datetime_obj.strftime(output_format) + except ValueError: + pass + fmt_strings = ', '.join(date_fmts) + raise ValueError('Invalid Date format, please use one of these formats ' + fmt_strings) + + +def adjust_timestamp(ds, time_bounds='time_bounds', align='left', offset=None): + """ + Will adjust the timestamp based on the time_bounds or other information + so that the timestamp aligns with user preference. + + Will work to adjust the times based on the time_bounds variable + but if it's not available will rely on the user supplied input + + Parameters + ---------- + ds : Xarray Dataset + Dataset to adjust + time_bounds : str + Name of the time_bounds variable + align : str + Alignment of the time when using time_bounds. + left: Sets timestamp to start of sample interval + right: Sets timestamp to end of sample interval + center: Sets timestamp to middle of sample interval + offset : int + Time in seconds to offset the timestamp. This overrides + the time_bounds variable and can be positive or negative. + Required to be in seconds + + Returns + ------- + ds : Xarray DataSet + Adjusted DataSet + + """ + + if time_bounds in ds and offset is None: + time_bounds = ds[time_bounds].values + if align == 'left': + time_start = [np.datetime64(t[0]) for t in time_bounds] + elif align == 'right': + time_start = [np.datetime64(t[1]) for t in time_bounds] + elif align == 'center': + time_start = [np.datetime64(t[0]) + (np.datetime64(t[0]) - np.datetime64(t[1])) / 2. for t in time_bounds] + else: + raise ValueError('Align should be set to one of [left, right, middle]') + + elif offset is not None: + time = ds['time'].values + time_start = [t + np.timedelta64(offset, 's') for t in time] + else: + raise ValueError('time_bounds variable is not available') + + ds = ds.assign_coords({'time': time_start}) + + return ds diff --git a/act/utils/geo_utils.py b/act/utils/geo_utils.py index 33ebf0bf77..27c2dac85c 100644 --- a/act/utils/geo_utils.py +++ b/act/utils/geo_utils.py @@ -1,25 +1,24 @@ """ -act.utils.geo_utils --------------------- - Module containing utilities for geographic calculations, including solar calculations """ -import numpy as np -import pandas as pd -from datetime import datetime, timezone, timedelta -from skyfield.api import wgs84, N, W, load_file, load -from skyfield import almanac import re +from datetime import datetime, timedelta, timezone +from pathlib import Path + import dateutil.parser +import numpy as np +import pandas as pd import pytz -from pathlib import Path -from act.utils.datetime_utils import datetime64_to_datetime +from skyfield import almanac +from skyfield.api import load, load_file, wgs84 + from act.utils.data_utils import convert_units +from act.utils.datetime_utils import datetime64_to_datetime -skyfield_bsp_file = str(Path(Path(__file__).parent, "conf", "de421.bsp")) +skyfield_bsp_file = str(Path(Path(__file__).parent, 'conf', 'de421.bsp')) def destination_azimuth_distance(lat, lon, az, dist, dist_units='m'): @@ -49,7 +48,7 @@ def destination_azimuth_distance(lat, lon, az, dist, dist_units='m'): """ # Volumetric Mean Radius of Earth in km - R = 6378. + R = 6378.0 # Convert az to radian brng = np.radians(az) @@ -62,28 +61,31 @@ def destination_azimuth_distance(lat, lon, az, dist, dist_units='m'): lon = np.radians(lon) # Using great circle equations - lat2 = np.arcsin(np.sin(lat) * np.cos(d / R) + - np.cos(lat) * np.sin(d / R) * np.cos(brng)) - lon2 = lon + np.arctan2(np.sin(brng) * np.sin(d / R) * np.cos(lat), - np.cos(d / R) - np.sin(lat) * np.sin(lat2)) + lat2 = np.arcsin(np.sin(lat) * np.cos(d / R) + np.cos(lat) * np.sin(d / R) * np.cos(brng)) + lon2 = lon + np.arctan2( + np.sin(brng) * np.sin(d / R) * np.cos(lat), + np.cos(d / R) - np.sin(lat) * np.sin(lat2), + ) return np.degrees(lat2), np.degrees(lon2) -def add_solar_variable(obj, latitude=None, longitude=None, solar_angle=0., dawn_dusk=False): +def add_solar_variable(ds, latitude=None, longitude=None, solar_angle=0.0, dawn_dusk=False): """ - Add variable to the object to denote night (0) or sun (1). If dawk_dusk is True - will also return dawn (2) and dusk (3). If at a high latitude and there's sun, will + Add variable to the dataset to denote night (0) or sun (1). If dawk_dusk is True + will also return dawn (2) and dusk (3). If at a high latitude and there's sun, will label twilight as dawn; if dark{2}, will label twilight as dusk(3). Parameters ---------- - obj : xarray dataset - ACT object + ds : xarray.Dataset + ACT Xarray dataset latitude : str - Latitude variable name, default will look for matching variables in object + Latitude variable name, default will look for matching variables in + the dataset. longitude : str - Longitude variable name, default will look for matching variables in object + Longitude variable name, default will look for matching variables in + the dataset. solar_angle : float Number of degress to use for dawn/dusk calculations dawn_dusk : boolean @@ -91,35 +93,35 @@ def add_solar_variable(obj, latitude=None, longitude=None, solar_angle=0., dawn_ Returns ------- - obj : xarray dataset - Xarray object + ds : xarray.Dataset + Xarray dataset containing sun and night flag. """ - - variables = list(obj.keys()) + variables = list(ds.keys()) # Get coordinate variables if latitude is None: - latitude = [s for s in variables if "latitude" in s] + latitude = [s for s in variables if 'latitude' in s] if len(latitude) == 0: - latitude = [s for s in variables if "lat" in s] + latitude = [s for s in variables if 'lat' in s] if len(latitude) == 0: - raise ValueError("Latitude variable not set and could not be discerned from the data") + raise ValueError('Latitude variable not set and could not be discerned from the data') if longitude is None: - longitude = [s for s in variables if "longitude" in s] + longitude = [s for s in variables if 'longitude' in s] if len(longitude) == 0: - longitude = [s for s in variables if "lon" in s] + longitude = [s for s in variables if 'lon' in s] if len(longitude) == 0: - raise ValueError("Longitude variable not set and could not be discerned from the data") + raise ValueError('Longitude variable not set and could not be discerned from the data') # Get lat/lon variables - lat = obj[latitude[0]].values - lon = obj[longitude[0]].values + lat = ds[latitude[0]].values + lon = ds[longitude[0]].values # Loop through each time to ensure that the sunrise/set calcuations # are correct for each time and lat/lon if multiple - results = is_sun_visible(latitude=lat, longitude=lon, date_time=obj['time'].values, - dawn_dusk=dawn_dusk) + results = is_sun_visible( + latitude=lat, longitude=lon, date_time=ds['time'].values, dawn_dusk=dawn_dusk + ) # Set longname longname = 'Daylight indicator; 0-Night; 1-Sun' @@ -129,9 +131,9 @@ def add_solar_variable(obj, latitude=None, longitude=None, solar_angle=0., dawn_ else: # If dawn_dusk is True, add 2 more indicators longname += '; 2-Dawn; 3-Dusk; 4-Twilight' - dark_ind = np.where((results == 0))[0] + dark_ind = np.where(results == 0)[0] twil_ind = np.where((results > 0) & (results < 4))[0] - sun_ind = np.where((results == 4))[0] + sun_ind = np.where(results == 4)[0] if len(sun_ind) == 0: results[twil_ind] = 3 @@ -154,15 +156,24 @@ def add_solar_variable(obj, latitude=None, longitude=None, solar_angle=0., dawn_ results[dusk_ind] = 3 results[sun_ind] = 1 - # Add results to object and return - obj['sun_variable'] = ('time', np.array(results), - {'long_name': longname, 'units': ' '}) + # Add results to the dataset and return + ds['sun_variable'] = ( + 'time', + np.array(results), + {'long_name': longname, 'units': ' '}, + ) - return obj + return ds -def get_solar_azimuth_elevation(latitude=None, longitude=None, time=None, library='skyfield', - temperature_C='standard', pressure_mbar='standard'): +def get_solar_azimuth_elevation( + latitude=None, + longitude=None, + time=None, + library='skyfield', + temperature_C='standard', + pressure_mbar='standard', +): """ Calculate solar azimuth, elevation and solar distance. @@ -194,7 +205,8 @@ def get_solar_azimuth_elevation(latitude=None, longitude=None, time=None, librar """ - result = {'elevation': None, 'azimuth': None, 'distance': None} + # result = {'elevation': None, 'azimuth': None, 'distance': None} + result = (None, None, None) if library == 'skyfield': planets = load_file(skyfield_bsp_file) @@ -218,18 +230,20 @@ def get_solar_azimuth_elevation(latitude=None, longitude=None, time=None, librar ts = load.timescale() t = ts.from_datetimes(time) - location = earth + wgs84.latlon(latitude * N, longitude * W) + location = earth + wgs84.latlon(latitude, longitude) astrometric = location.at(t).observe(sun) - alt, az, distance = astrometric.apparent().altaz(temperature_C=temperature_C, - pressure_mbar=pressure_mbar) + alt, az, distance = astrometric.apparent().altaz( + temperature_C=temperature_C, pressure_mbar=pressure_mbar + ) result = (alt.degrees, az.degrees, distance.au) planets.close() return result -def get_sunrise_sunset_noon(latitude=None, longitude=None, date=None, library='skyfield', - timezone=False): +def get_sunrise_sunset_noon( + latitude=None, longitude=None, date=None, library='skyfield', timezone=False +): """ Calculate sunrise, sunset and local solar noon times. @@ -257,7 +271,6 @@ def get_sunrise_sunset_noon(latitude=None, longitude=None, date=None, library='s polar night will return empty lists. If spans the transition to polar day will return previous sunrise or next sunset outside of date range provided. """ - sunrise, sunset, noon = np.array([]), np.array([]), np.array([]) if library == 'skyfield': @@ -361,8 +374,8 @@ def get_sunrise_sunset_noon(latitude=None, longitude=None, date=None, library='s # since we are in polar day. diff = max(noon) - temp_sunset sunset_index = np.min(np.where(diff < timedelta(seconds=1))) + 1 - sunrise = temp_sunrise[sunrise_index: sunset_index] - sunset = temp_sunset[sunrise_index: sunset_index] + sunrise = temp_sunrise[sunrise_index:sunset_index] + sunset = temp_sunset[sunrise_index:sunset_index] eph.close() @@ -403,7 +416,6 @@ def is_sun_visible(latitude=None, longitude=None, date_time=None, dawn_dusk=Fals result : list List matching size of date_time containing True/False if sun is above horizon. """ - sf_dates = None # Check if datetime object is scalar and if has no timezone. @@ -426,8 +438,9 @@ def is_sun_visible(latitude=None, longitude=None, date_time=None, dawn_dusk=Fals sf_dates = [ii.replace(tzinfo=pytz.UTC) for ii in sf_dates] if sf_dates is None: - raise ValueError('The date_time values entered into is_sun_visible() ' - 'do not match input types.') + raise ValueError( + 'The date_time values entered into is_sun_visible() ' 'do not match input types.' + ) ts = load.timescale() eph = load_file(skyfield_bsp_file) diff --git a/act/utils/inst_utils.py b/act/utils/inst_utils.py index fdf9c7cf0a..e48f95af0e 100644 --- a/act/utils/inst_utils.py +++ b/act/utils/inst_utils.py @@ -1,21 +1,18 @@ """ -act.utils.inst_utils --------------------- - -Module containing utilities for instruments +Functions containing utilities for instruments. """ -def decode_present_weather(obj, variable=None, decoded_name=None): +def decode_present_weather(ds, variable=None, decoded_name=None): """ - This function is to decode codes reported from automatic weather stations suchas the PWD22. - This is based on WMO Table 4680. + This function is to decode codes reported from automatic weather stations such as the PWD22. + This is based on WMO Table 4680 as well as a supplement table for WMO table 4677. Parameters ---------- - obj : ACT Dataset - ACT or xarray dataset from which to convert codes + ds : xarray.Dataset + ACT or Xarray dataset from which to convert codes variable : string Variable to decode decoded_name : string @@ -23,25 +20,25 @@ def decode_present_weather(obj, variable=None, decoded_name=None): Returns ------- - obj : ACT Dataset - Returns object with new decoded data + ds : xarray.Dataset + Returns dataset with new decoded data References ---------- - WMO Manual on Code Volume I.1 - https://www.wmo.int/pages/prog/www/WMOCodes/WMO306_vI1/Publications/2017update/Sel9.pdf + WMO Manual on Code Volume I.1 A-360. + https://library.wmo.int/doc_num.php?explnum_id=10235 """ # Check to ensure that a variable name is passed if variable is None: - raise ValueError(("You Must Specify A Variable")) + raise ValueError('You must specify a variable') - if variable not in obj: - raise ValueError(("Variable Not In Object")) + if variable not in ds: + raise ValueError('Variable not in the dataset') - # Define the weather hash - weather = { + # Define the weather hash for WMO table 4680. + weather_4680 = { 0: 'No significant weather observed', 1: 'Clouds generally dissolving or becoming less developed during the past hour', 2: 'State of the sky on the whole unchanged during the past hour', @@ -121,15 +118,27 @@ def decode_present_weather(obj, variable=None, decoded_name=None): 95: 'Thunderstorm, heavy, with rain showers and/or snow showers', 96: 'Thunderstorm, heavy, with hail', 99: 'Tornado', - -9999: 'Missing' + -9999: 'Missing', + } + + # Define the weather hash for WMO table 4677. + weather_4677 = { + 88: 'Shower(s) of snow pellets or small hail, with or without rain or rain and snow mixed, moderate or heavy', } + # Join weather tables + weather_combined = dict(weather_4680) + weather_combined.update(weather_4677) + + # Sort keys to be in order + weather = dict(sorted(weather_combined.items())) + # If a decoded name is not passed, make one if decoded_name is None: decoded_name = variable + '_decoded' # Get data and fill nans with -9999 - data = obj[variable] + data = ds[variable] data = data.fillna(-9999) # Get the weather type for each code @@ -137,10 +146,15 @@ def decode_present_weather(obj, variable=None, decoded_name=None): # Massage the data array to set back in the dataset data.values = wx_type - data.attrs['long_name'] = data.attrs['long_name'] + ' Decoded' - del(data.attrs['valid_min']) - del(data.attrs['valid_max']) - - obj[decoded_name] = data - - return obj + if 'long_name' in data.attrs: + data.attrs['long_name'] = data.attrs['long_name'] + ' Decoded' + else: + data.attrs['long_name'] = 'Decoded present weather values' + if 'valid_min' in data.attrs: + del data.attrs['valid_min'] + if 'valid_max' in data.attrs: + del data.attrs['valid_max'] + + ds[decoded_name] = data + + return ds diff --git a/act/utils/io_utils.py b/act/utils/io_utils.py new file mode 100644 index 0000000000..839b7b8ae9 --- /dev/null +++ b/act/utils/io_utils.py @@ -0,0 +1,352 @@ +from pathlib import Path +import tarfile +from os import PathLike +from shutil import rmtree +import random +import string +import gzip +import shutil +import tempfile +import numpy as np +import types + +try: + import moviepy.video.io.ImageSequenceClip + from moviepy.video.io.VideoFileClip import VideoFileClip + MOVIEPY_AVAILABLE = True +except ImportError: + MOVIEPY_AVAILABLE = False + + +def pack_tar(filenames, write_filename=None, write_directory=None, remove=False): + """ + Creates TAR file from list of filenames provided. Currently only works with + all files existing in the same directory. + + ... + + Parameters + ---------- + filenames : str or list + Filenames to be placed in TAR file + write_filename : str, pathlib.Path, None + TAR output filename. If not provided will use file name 'created_tarfile.tar' + write_directory : str, pathlib.Path, None + Path to directory to write TAR file. If the directory does not exist will + be created. + remove : boolean + Delete provided filenames after making TAR file + + Returns + ------- + list + List of files extracted from the TAR file or full path to created direcotry + containing extracted files. + + """ + + if write_filename is None: + write_filename = 'created_tarfile.tar' + + if isinstance(filenames, (str, PathLike)): + filenames = [filenames] + + if write_directory is not None: + write_directory = Path(write_directory) + write_directory.mkdir(parents=True, exist_ok=True) + write_filename = Path(write_filename).name + elif Path(write_filename).parent != Path('.'): + write_directory = Path(write_filename).parent + else: + write_directory = Path('.') + + if not str(write_filename).endswith('.tar'): + write_filename = str(write_filename) + '.tar' + + write_filename = Path(write_directory, write_filename) + tar_file_handle = tarfile.open(write_filename, "w") + for filename in filenames: + tar_file_handle.add(filename, arcname=Path(filename).name) + + tar_file_handle.close() + + if remove: + for filename in filenames: + Path(filename).unlink() + + return str(write_filename) + + +def unpack_tar(tar_files, write_directory=None, temp_dir=False, randomize=True, + return_files=True, remove=False): + """ + Unpacks TAR file contents into provided base directory + + ... + + Parameters + ---------- + tar_files : str or list + path to TAR file to be unpacked + write_directory : str or pathlib.Path + base path to extract contents of TAR files or create a new randomized directory + to extract contents of TAR file. + temp_dir : boolean + Should a temporary directory be created and TAR files extracted to the new directory. + write_directory and randomize are ignored if this option is used. + randomize : boolean + Create a new randomized directory to extract TAR files into. + return_files : boolean + When set will return a list of full path filenames to the extracted files. + When set to False will return full path to directory containing extracted files. + remove : boolean + Delete provided TAR files after extracting files. + + Returns + ------- + files : list or str + List of full path files extracted from the TAR file or full path to direcotry + containing extracted files. + + """ + + files = [] + + if isinstance(tar_files, (str, PathLike)): + tar_files = [tar_files] + + out_dir = Path.cwd() + if temp_dir is True: + out_dir = Path(tempfile.TemporaryDirectory().name) + else: + if write_directory is not None: + out_dir = Path(write_directory) + else: + out_dir = Path(Path(tar_files[0]).parent) + + if out_dir.is_dir() is False: + out_dir.mkdir(parents=True, exist_ok=True) + + if randomize: + out_dir = Path(tempfile.mkdtemp(dir=out_dir)) + + for tar_file in tar_files: + try: + tar = tarfile.open(tar_file) + tar.extractall(path=out_dir) + result = [str(Path(out_dir, ii.name)) for ii in tar.getmembers()] + files.extend(result) + tar.close() + except tarfile.ReadError: + print(f"\nCould not extract files from {tar_file}") + + if return_files is False: + files = str(out_dir) + else: + files.sort() + + if remove: + for tar_file in tar_files: + Path(tar_file).unlink() + + return files + + +def cleanup_files(dirname=None, files=None): + """ + Cleans up files and directory possibly created from unpacking TAR files with unpack_tar() + + ... + + Parameters + ---------- + dirname : str, pathlib.Path, None + Path to directory of extracted files which will be removed. + files : str, pahtlib.Path, list, None + Full path file name(s) from extracted TAR file. + Assumes the directory this file exists in should be removed. + + """ + + if isinstance(files, (str, PathLike)): + files = [str(files)] + + try: + if dirname is not None: + rmtree(dirname) + + if files is not None and len(files) > 0 and Path(files[0]).is_file(): + out_dir = Path(files[0]).parent + rmtree(out_dir) + + except Exception as error: + print("\nError removing files:", error) + + +def is_gunzip_file(filepath): + """ + Function to test if file is a gunzip file. + + Parameters + ---------- + + filepath : str or pathlib.Path to file to test + + Returns + ------- + test : boolean + Result from testing if file is a gunzip file + + """ + + try: + with open(str(filepath), 'rb') as test_f: + return test_f.read(2) == b'\x1f\x8b' + except Exception: + return False + + +def pack_gzip(filename, write_directory=None, remove=False): + """ + Creates a gunzip file from a filename path + + ... + + Parameters + ---------- + filename : str, pathlib.Path + Filename to use in creation of gunzip version. + write_directory : str, pahtlib.Path, list, None + Path to directory to place newly created gunzip file. + remove : boolean + Remove provided filename after creating gunzip file + + Returns + ------- + write_filename : str + Full path name of created gunzip file + + """ + + write_filename = Path(filename).name + '.gz' + + if write_directory is not None: + write_filename = Path(write_directory, write_filename) + Path(write_directory).mkdir(parents=True, exist_ok=True) + else: + write_filename = Path(Path(filename).parent, write_filename) + + with open(filename, 'rb') as f_in: + with gzip.open(write_filename, 'wb') as f_out: + shutil.copyfileobj(f_in, f_out) + + if remove: + Path(filename).unlink() + + return str(write_filename) + + +def unpack_gzip(filename, write_directory=None, remove=False): + """ + Extracts file from a gunzip file. + + ... + + Parameters + ---------- + filename : str, pathlib.Path + Filename to use in extraction of gunzip file. + write_directory : str, pahtlib.Path, list, None + Path to directory to place newly created gunzip file. + remove : boolean + Remove provided filename after creating gunzip file + + Returns + ------- + write_filename : str + Full path name of created gunzip file + + """ + + if write_directory is None: + write_directory = Path(filename).parent + + write_filename = Path(filename).name + if write_filename.endswith('.gz'): + write_filename = write_filename.replace(".gz", "") + + write_filename = Path(write_directory, write_filename) + + with gzip.open(filename, "rb") as f_in: + with open(write_filename, "wb") as f_out: + shutil.copyfileobj(f_in, f_out) + + if remove: + Path(filename).unlink() + + return str(write_filename) + + +def generate_movie(images, write_filename=None, fps=10, **kwargs): + """ + Creates a movie from a list of images or convert movie to different type + + ... + + Parameters + ---------- + images : list, PosixPath generator, path to a directory, single string/PosixPath to movie + List of images in the correct order to make into a movie or a generator from + a pathlib.Path.glob() search. If a path to directory will create movie from all files + in that directory in alpanumeric order. If a single file to a movie will allow for converting + to new format defined by file extension of write_filename. + write_filename : str, pathlib.Path, None + Movie output filename. Default is 'movie.mp4' in current directory. If a path to a directory + that does not exist, will create the directory path. + fps: int + Frames per second. Passed into moviepy->ImageSequenceClip() method + **kwargs: dict + Optional keywords passed into moviepy->write_videofile() method + + + Returns + ------- + write_filename : str + Full path name of created movie file + + """ + if not MOVIEPY_AVAILABLE: + raise ImportError( + 'MoviePy needs to be installed on your system to make movies.' + ) + + # Set default movie name + if write_filename is None: + write_filename = Path(Path().cwd(), 'movie.mp4') + + # Check if images is pointing to a directory. If so ensure is a string not PosixPath + IS_MOVIE = False + if isinstance(images, (types.GeneratorType, list, tuple)): + images = [str(image) for image in images] + images.sort() + elif isinstance(images, (PathLike, str)) and Path(images).is_file(): + IS_MOVIE = True + images = str(images) + elif isinstance(images, (PathLike, str)) and Path(images).is_dir(): + images = str(images) + + # Ensure full path to filename exists + write_directory = Path(write_filename).parent + write_directory.mkdir(parents=True, exist_ok=True) + + if IS_MOVIE: + with VideoFileClip(images) as clip: + # Not sure why but need to set the duration of the clip with subclip() to write + # the full file out. + clip = clip.subclip(t_start=clip.start, t_end=clip.end * clip.fps) + clip.write_videofile(str(write_filename), fps=fps, **kwargs) + else: + clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(images, fps=fps) + clip.write_videofile(str(write_filename), **kwargs) + + return str(write_filename) diff --git a/act/utils/qc_utils.py b/act/utils/qc_utils.py index cfc3c2e55c..af6298dee9 100644 --- a/act/utils/qc_utils.py +++ b/act/utils/qc_utils.py @@ -1,4 +1,8 @@ -""" Utility functions for quality control . """ +""" +Functions containing utilities for quality control which +may or may not be program dependent + +""" import os @@ -7,8 +11,8 @@ def calculate_dqr_times( - obj, variable=None, txt_path=None, threshold=None, - qc_bit=None, return_missing=True): + ds, variable=None, txt_path=None, threshold=None, qc_bit=None, return_missing=True +): """ Function to retrieve start and end times of missing or bad data. Function will retrieve start and end time strings in a format that the DQR @@ -17,10 +21,10 @@ def calculate_dqr_times( Parameters ---------- - obj : ACT Object - Xarray Dataset as read by ACT where data are stored. + ds : xarray.Dataset + Xarray dataset as read by ACT where data are stored. variable : str or list of str - Data variable(s) in the object to check. Can check multiple variables. + Data variable(s) in the dataset to check. Can check multiple variables. txt_path : str Full path to directory in which to save .txt files with start and end times. If directory doesn't exist the program will create it. If set @@ -60,11 +64,9 @@ def calculate_dqr_times( return_missing = False # Clean files. Converts from ARM to CF standards - obj.clean.cleanup(cleanup_arm_qc=True, - handle_missing_value=True, - link_qc_variables=True) - date = obj.attrs['_file_dates'][0] - datastream = obj.attrs['_datastream'] + ds.clean.cleanup(cleanup_arm_qc=True, handle_missing_value=True, link_qc_variables=True) + date = ds.attrs['_file_dates'][0] + datastream = ds.attrs['_datastream'] # Make variable instance a list always if variable is not None: @@ -79,8 +81,7 @@ def calculate_dqr_times( if not isinstance(threshold, int): int(round(threshold)) else: - print('You must specify a threshold for separating ranges of' + - ' flagged data') + print('You must specify a threshold for separating ranges of' + ' flagged data') return # If return_missing then search for indices where data is equal to @@ -88,7 +89,7 @@ def calculate_dqr_times( if return_missing: for var in variable: # Get indices where data is being flagged as missing - idx = np.where(np.isnan(obj[var].values))[0] + idx = np.where(np.isnan(ds[var].values))[0] # Find where there are gaps in flagged data time_diff = np.diff(idx) @@ -99,7 +100,7 @@ def calculate_dqr_times( # If no bad indices then exit if len(idx) == 0: - print('No missing data for {} on '.format(var) + date) + print(f'No missing data for {var} on ' + date) continue else: idx = np.split(idx, splits) @@ -112,23 +113,18 @@ def calculate_dqr_times( if len(time) < 2: pass else: - dt_times.append((obj['time'].values[time[0]], - obj['time'].values[time[-1]])) + dt_times.append((ds['time'].values[time[0]], ds['time'].values[time[-1]])) # Convert the datetimes to strings time_strings = [] for st, et in dt_times: - start_time = pd.to_datetime(str(st)).strftime( - '%Y-%m-%d %H:%M:%S') - end_time = pd.to_datetime(str(et)).strftime( - '%Y-%m-%d %H:%M:%S') + start_time = pd.to_datetime(str(st)).strftime('%Y-%m-%d %H:%M:%S') + end_time = pd.to_datetime(str(et)).strftime('%Y-%m-%d %H:%M:%S') time_strings.append((start_time, end_time)) # Print times to screen - print('Missing Data for {} begins at: '.format(var) + - start_time) - print('Missing Data for {} ends at: '.format(var) + end_time) + print(f'Missing Data for {var} begins at: ' + start_time) + print(f'Missing Data for {var} ends at: ' + end_time) if txt_path: - _write_dqr_times_to_txt(datastream, date, txt_path, var, - time_strings) + _write_dqr_times_to_txt(datastream, date, txt_path, var, time_strings) return time_strings # If return_bad then search for times in the corresponding qc variable @@ -136,13 +132,13 @@ def calculate_dqr_times( if return_bad: for var in variable: # If a1 level data, return. - if 'a1' in obj.attrs['data_level']: + if 'a1' in ds.attrs['data_level']: print('No QC is present in a1 level.') return # Get QC data from corresponding QC variable qc_var = 'qc_' + var try: - qc_data = obj[qc_var].values + qc_data = ds[qc_var].values except KeyError: print('Unable to calculate start and end times for bad data') continue @@ -161,8 +157,7 @@ def calculate_dqr_times( # If no bad indices then exit if len(idx) == 0: - print('No bad data on ' + date + ' for selected QC bit for' + - ' variable ' + var) + print('No bad data on ' + date + ' for selected QC bit for' + ' variable ' + var) continue else: idx = np.split(idx, splits) @@ -175,27 +170,22 @@ def calculate_dqr_times( if len(time) < 2: pass else: - dt_times.append((obj['time'].values[time[0]], - obj['time'].values[time[-1]])) + dt_times.append((ds['time'].values[time[0]], ds['time'].values[time[-1]])) # Convert the datetimes to strings time_strings = [] for st, et in dt_times: - start_time = pd.to_datetime(str(st)).strftime( - '%Y-%m-%d %H:%M:%S') - end_time = pd.to_datetime(str(et)).strftime( - '%Y-%m-%d %H:%M:%S') + start_time = pd.to_datetime(str(st)).strftime('%Y-%m-%d %H:%M:%S') + end_time = pd.to_datetime(str(et)).strftime('%Y-%m-%d %H:%M:%S') time_strings.append((start_time, end_time)) # Print times to screen - print('Bad Data for {} Begins at: '.format(var) + start_time) - print('Bad Data for {} Ends at: '.format(var) + end_time) + print(f'Bad Data for {var} Begins at: ' + start_time) + print(f'Bad Data for {var} Ends at: ' + end_time) if txt_path: - _write_dqr_times_to_txt(datastream, date, txt_path, var, - time_strings) + _write_dqr_times_to_txt(datastream, date, txt_path, var, time_strings) return time_strings -def _write_dqr_times_to_txt(datastream, date, txt_path, variable, - time_strings): +def _write_dqr_times_to_txt(datastream, date, txt_path, variable, time_strings): """ Writes flagged data time range(s) to a .txt file. The naming convention is dqrtimes_datastream.date.txt. @@ -214,13 +204,25 @@ def _write_dqr_times_to_txt(datastream, date, txt_path, variable, List of every start and end time to be written. """ - print('Writing data to text file for ' + datastream + ' ' + variable + - ' on ' + date + ' at ' + txt_path + '...', flush=True) + print( + 'Writing data to text file for ' + + datastream + + ' ' + + variable + + ' on ' + + date + + ' at ' + + txt_path + + '...', + flush=True, + ) full_path = txt_path + '/' + datastream if os.path.exists(full_path) is False: os.mkdir(full_path) - with open(full_path + '/dqrtimes_' + datastream + '.' + date + '.' + - variable + '.txt', 'w') as text_file: + with open( + full_path + '/dqrtimes_' + datastream + '.' + date + '.' + variable + '.txt', + 'w', + ) as text_file: for st, et in time_strings: text_file.write('%s, ' % st) text_file.write('%s \n' % et) diff --git a/act/utils/radiance_utils.py b/act/utils/radiance_utils.py index ca4a698c80..248a3a47e3 100644 --- a/act/utils/radiance_utils.py +++ b/act/utils/radiance_utils.py @@ -1,18 +1,14 @@ """ -act.utils.radiance_utils --------------------- - Module containing utilities for radiance calculations """ +import inspect import numpy as np -import inspect -def planck_converter(wnum=None, radiance=None, temperature=None, - units='cm'): +def planck_converter(wnum=None, radiance=None, temperature=None, units='cm'): """ Planck function to convert radiance to temperature or temperature to radiance given a corresponding wavenumber value. @@ -62,10 +58,12 @@ def planck_converter(wnum=None, radiance=None, temperature=None, func_name = inspect.stack()[0][3] if wnum is None: - raise ValueError(f"No wnum values provided for {func_name}() function.\n") + raise ValueError(f'No wnum values provided for {func_name}() function.\n') if radiance is None and temperature is None: - raise ValueError(f"No radiance or temperature values provided for {func_name}() function.\n") + raise ValueError( + f'No radiance or temperature values provided for {func_name}() function.\n' + ) if radiance is not None: radiance = np.array(radiance, dtype=np.float64) diff --git a/act/utils/ship_utils.py b/act/utils/ship_utils.py index cf4115a885..8d28522d69 100644 --- a/act/utils/ship_utils.py +++ b/act/utils/ship_utils.py @@ -1,18 +1,15 @@ """ -act.utils.ship_utils --------------------- - Module containing utilities for ship data """ -import pyproj import dask -import xarray as xr import numpy as np +import pyproj +import xarray as xr -def calc_cog_sog(obj): +def calc_cog_sog(ds): """ This function calculates the course and speed over ground of a moving platform using the lat/lon. Note,data are resampled to 1 minute in @@ -26,44 +23,46 @@ def calc_cog_sog(obj): Parameters ---------- - obj : ACT Dataset - ACT Dataset to calculate COG/SOG from. Assumes lat/lon are variables and + ds : xarray.Dataset + ACT xarray dataset to calculate COG/SOG from. Assumes lat/lon are variables and that it's 1-second data. Returns ------- - obj : ACT Dataset - Returns object with course_over_ground and speed_over_ground variables. + ds : xarray.Dataset + Returns dataset with course_over_ground and speed_over_ground variables. """ # Convert data to 1 minute in order to get proper values - new_obj = obj.resample(time='1min').nearest() + new_ds = ds.resample(time='1min').nearest() # Get lat and lon data - if 'lat' in new_obj: - lat = new_obj['lat'] - elif 'latitude' in new_obj: - lat = new_obj['latitude'] + if 'lat' in new_ds: + lat = new_ds['lat'] + elif 'latitude' in new_ds: + lat = new_ds['latitude'] else: - return new_obj + return new_ds - if 'lon' in new_obj: - lon = new_obj['lon'] - elif 'longitude' in new_obj: - lon = new_obj['longitude'] + if 'lon' in new_ds: + lon = new_ds['lon'] + elif 'longitude' in new_ds: + lon = new_ds['longitude'] else: - return new_obj + return new_ds # Set pyproj Geod _GEOD = pyproj.Geod(ellps='WGS84') # Set up delayed tasks for dask task = [] - time = new_obj['time'].values + time = new_ds['time'].values for i in range(len(lat) - 1): - task.append(dask.delayed(proc_scog) - (_GEOD, lon[i + 1], lat[i + 1], lon[i], lat[i], - time[i], time[i + 1])) + task.append( + dask.delayed(proc_scog)( + _GEOD, lon[i + 1], lat[i + 1], lon[i], lat[i], time[i], time[i + 1] + ) + ) # Compute and process results Adding 2 values # to the end to make up for the missing times @@ -84,10 +83,10 @@ def calc_cog_sog(obj): cog_da = xr.DataArray(cog, coords={'time': time}, dims=['time'], attrs=atts) cog_da = cog_da.resample(time='1s').nearest() - obj['course_over_ground'] = cog_da - obj['speed_over_ground'] = sog_da + ds['course_over_ground'] = cog_da + ds['speed_over_ground'] = sog_da - return obj + return ds def proc_scog(_GEOD, lon2, lat2, lon1, lat1, time1, time2): @@ -100,7 +99,7 @@ def proc_scog(_GEOD, lon2, lat2, lon1, lat1, time1, time2): tdiff = (time2 - time1) / np.timedelta64(1, 's') sog = dist / tdiff if cog < 0: - cog = 360. + cog + cog = 360.0 + cog if sog < 0.5: cog = np.nan diff --git a/codecov.yml b/codecov.yml new file mode 100644 index 0000000000..0263db0054 --- /dev/null +++ b/codecov.yml @@ -0,0 +1,23 @@ +codecov: + require_ci_to_pass: no + max_report_age: off + +comment: false + +ignore: + - 'tests/**/*.py' + - 'act/*version*py' + - 'setup.py' + - 'versioneer.py' + +coverage: + precision: 2 + round: down + status: + project: + default: + target: 95 + threshold: 2% + informational: true + patch: off + changes: off diff --git a/continuous_integration/build_docs.sh b/continuous_integration/build_docs.sh deleted file mode 100644 index a7fbdef9fe..0000000000 --- a/continuous_integration/build_docs.sh +++ /dev/null @@ -1,14 +0,0 @@ -set -e - -echo "Building Docs" -conda install -c conda-forge -q sphinx doctr -pip install sphinx_gallery -pip install sphinx-copybutton -cd docs -make clean -make html -cd .. -doctr deploy . - - - diff --git a/continuous_integration/environment-3.7.yml b/continuous_integration/environment-3.7.yml deleted file mode 100644 index 710779a3a8..0000000000 --- a/continuous_integration/environment-3.7.yml +++ /dev/null @@ -1,25 +0,0 @@ -name: testenv -channels: - - conda-forge - - defaults -dependencies: - - python=3.7 - - cartopy - - pyproj - - numpy - - scipy - - matplotlib - - netcdf4 - - pytest - - pytest-mpl - - pytest-cov - - dask - - xarray - - flake8 - - ipython - - pint=0.8.1 - - skyfield - - pip - - pip: - - mpl2nc - - arm-pyart diff --git a/continuous_integration/environment-3.8.yml b/continuous_integration/environment-3.8.yml deleted file mode 100644 index aa85455918..0000000000 --- a/continuous_integration/environment-3.8.yml +++ /dev/null @@ -1,25 +0,0 @@ -name: testenv -channels: - - conda-forge - - defaults -dependencies: - - python=3.8 - - cartopy - - pyproj - - numpy - - scipy - - matplotlib - - netcdf4 - - pytest - - pytest-mpl - - pytest-cov - - dask - - xarray - - flake8 - - ipython - - pint=0.8.1 - - skyfield - - pip - - pip: - - mpl2nc - - arm-pyart diff --git a/continuous_integration/environment_actions.yml b/continuous_integration/environment_actions.yml new file mode 100644 index 0000000000..0443eb0502 --- /dev/null +++ b/continuous_integration/environment_actions.yml @@ -0,0 +1,38 @@ +# Basic environment for ACT. +name: act_env +channels: + - conda-forge + - defaults +dependencies: + - cartopy + - pyproj + - matplotlib>=3.7 + - numpy + - scipy + - netcdf4 + - dask + - xarray + - ipython + - pint=0.8.1 + - skyfield + - lxml + - scikit-posthocs + - flake8 + - pytest + - pytest-cov + - pytest-mpl + - coveralls + - pandas + - shapely + - pip + - lazy_loader + - cmweather + - arm-test-data + - moviepy + - pip: + - mpl2nc + - metpy + - pysp2 + - arm_pyart + - icartt + - aiohttp>=3.9.0b1 diff --git a/continuous_integration/install.sh b/continuous_integration/install.sh deleted file mode 100644 index 4fc61a1768..0000000000 --- a/continuous_integration/install.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/bash - -set -e -# use next line to debug this script -set -x - -# Install Miniconda -wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh \ - -O miniconda.sh -chmod +x miniconda.sh -./miniconda.sh -b -export PATH=/home/travis/miniconda3/bin:$PATH -conda config --set always_yes yes -conda config --set show_channel_urls true -conda install -c anaconda setuptools -conda install -c conda-forge proj -conda update -q conda -conda info -a - -## Create a testenv with the correct Python version -conda env create -f continuous_integration/environment-$PYTHON_VERSION.yml -source activate testenv -pip install -e . -pip install sphinx sphinx_rtd_theme diff --git a/docs/Makefile b/docs/Makefile index b4a5893b3d..694c988535 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -1,20 +1,154 @@ -# Minimal makefile for Sphinx documentation + +# Makefile for Sphinx documentation # # You can set these variables from the command line. -SPHINXOPTS = "-W" # This flag turns warnings into errors. +SPHINXOPTS = SPHINXBUILD = sphinx-build -SPHINXPROJ = PackagingScientificPython -SOURCEDIR = source +PAPER = BUILDDIR = build -# Put it first so that "make" without argument is like "make help". +# Internal variables. +PAPEROPT_a4 = -D latex_paper_size=a4 +PAPEROPT_letter = -D latex_paper_size=letter +ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source +# the i18n builder cannot share the environment and doctrees with the others +I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source + +.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext + help: - @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + @echo "Please use \`make ' where is one of" + @echo " html to make standalone HTML files" + @echo " dirhtml to make HTML files named index.html in directories" + @echo " singlehtml to make a single large HTML file" + @echo " pickle to make pickle files" + @echo " json to make JSON files" + @echo " htmlhelp to make HTML files and a HTML help project" + @echo " qthelp to make HTML files and a qthelp project" + @echo " devhelp to make HTML files and a Devhelp project" + @echo " epub to make an epub" + @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" + @echo " latexpdf to make LaTeX files and run them through pdflatex" + @echo " text to make text files" + @echo " man to make manual pages" + @echo " texinfo to make Texinfo files" + @echo " info to make Texinfo files and run them through makeinfo" + @echo " gettext to make PO message catalogs" + @echo " changes to make an overview of all changed/added/deprecated items" + @echo " linkcheck to check all external links for integrity" + @echo " doctest to run all doctests embedded in the documentation (if enabled)" + +clean: + -rm -rf $(BUILDDIR)/* + +html: + $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." + +dirhtml: + $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." + +singlehtml: + $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml + @echo + @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." + +pickle: + $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle + @echo + @echo "Build finished; now you can process the pickle files." + +json: + $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json + @echo + @echo "Build finished; now you can process the JSON files." + +htmlhelp: + $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp + @echo + @echo "Build finished; now you can run HTML Help Workshop with the" \ + ".hhp project file in $(BUILDDIR)/htmlhelp." + +qthelp: + $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp + @echo + @echo "Build finished; now you can run "qcollectiongenerator" with the" \ + ".qhcp project file in $(BUILDDIR)/qthelp, like this:" + @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Py-ART.qhcp" + @echo "To view the help file:" + @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Py-ART.qhc" + +devhelp: + $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp + @echo + @echo "Build finished." + @echo "To view the help file:" + @echo "# mkdir -p $$HOME/.local/share/devhelp/Py-ART" + @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Py-ART" + @echo "# devhelp" + +epub: + $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub + @echo + @echo "Build finished. The epub file is in $(BUILDDIR)/epub." + +latex: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo + @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." + @echo "Run \`make' in that directory to run these through (pdf)latex" \ + "(use \`make latexpdf' here to do that automatically)." + +latexpdf: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo "Running LaTeX files through pdflatex..." + $(MAKE) -C $(BUILDDIR)/latex all-pdf + @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." + +text: + $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text + @echo + @echo "Build finished. The text files are in $(BUILDDIR)/text." + +man: + $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man + @echo + @echo "Build finished. The manual pages are in $(BUILDDIR)/man." + +texinfo: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo + @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." + @echo "Run \`make' in that directory to run these through makeinfo" \ + "(use \`make info' here to do that automatically)." + +info: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo "Running Texinfo files through makeinfo..." + make -C $(BUILDDIR)/texinfo info + @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." + +gettext: + $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale + @echo + @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." + +changes: + $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes + @echo + @echo "The overview file is in $(BUILDDIR)/changes." -.PHONY: help Makefile +linkcheck: + $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck + @echo + @echo "Link check complete; look for any errors in the above output " \ + "or in $(BUILDDIR)/linkcheck/output.txt." -# 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) +doctest: + $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest + @echo "Testing of doctests in the sources finished, look at the " \ + "results in $(BUILDDIR)/doctest/output.txt." diff --git a/docs/environment_docs.yml b/docs/environment_docs.yml new file mode 100644 index 0000000000..74d4b3248c --- /dev/null +++ b/docs/environment_docs.yml @@ -0,0 +1,42 @@ +name: act-docs +channels: + - conda-forge + - defaults +dependencies: + - cartopy + - pyproj + - numpy + - scipy + - matplotlib>=3.5.1 + - netcdf4 + - dask + - xarray + - ipython + - notebook + - pint=0.8.1 + - skyfield + - scikit-posthocs + - pip + - shapely<1.8.3 + - arm-test-data + - moviepy + - pip: + - mpl2nc + - lazy_loader + - metpy>=1.2 + - arm-pyart + - sphinx<7.2 + - sphinx_gallery + - sphinx-copybutton + - pydata-sphinx-theme<0.9.0 + - myst_nb + - ablog + - sphinx_design + - nbsphinx + - pooch + - icartt + - cmweather + - sphinxcontrib-devhelp==1.0.5 + - sphinxcontrib-htmlhelp==2.0.4 + - sphinxcontrib-qthelp==1.0.6 + - sphinxcontrib-serializinghtml==1.1.9 diff --git a/docs/make.bat b/docs/make.bat index 2be830693f..66b2f89149 100644 --- a/docs/make.bat +++ b/docs/make.bat @@ -1,36 +1,190 @@ @ECHO OFF -pushd %~dp0 - REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) -set SOURCEDIR=source set BUILDDIR=build -set SPHINXPROJ=PackagingScientificPython +set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source +set I18NSPHINXOPTS=%SPHINXOPTS% source +if NOT "%PAPER%" == "" ( + set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% + set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% +) if "%1" == "" goto help -%SPHINXBUILD% >NUL 2>NUL -if errorlevel 9009 ( +if "%1" == "help" ( + :help + echo.Please use `make ^` where ^ is one of + echo. html to make standalone HTML files + echo. dirhtml to make HTML files named index.html in directories + echo. singlehtml to make a single large HTML file + echo. pickle to make pickle files + echo. json to make JSON files + echo. htmlhelp to make HTML files and a HTML help project + echo. qthelp to make HTML files and a qthelp project + echo. devhelp to make HTML files and a Devhelp project + echo. epub to make an epub + echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter + echo. text to make text files + echo. man to make manual pages + echo. texinfo to make Texinfo files + echo. gettext to make PO message catalogs + echo. changes to make an overview over all changed/added/deprecated items + echo. linkcheck to check all external links for integrity + echo. doctest to run all doctests embedded in the documentation if enabled + goto end +) + +if "%1" == "clean" ( + for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i + del /q /s %BUILDDIR%\* + goto end +) + +if "%1" == "html" ( + %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The HTML pages are in %BUILDDIR%/html. + goto end +) + +if "%1" == "dirhtml" ( + %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. + goto end +) + +if "%1" == "singlehtml" ( + %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. + goto end +) + +if "%1" == "pickle" ( + %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle + if errorlevel 1 exit /b 1 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.Build finished; now you can process the pickle files. + goto end +) + +if "%1" == "json" ( + %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json + if errorlevel 1 exit /b 1 echo. - echo.If you don't have Sphinx installed, grab it from - echo.http://sphinx-doc.org/ - exit /b 1 + echo.Build finished; now you can process the JSON files. + goto end ) -%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% -goto end +if "%1" == "htmlhelp" ( + %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp + if errorlevel 1 exit /b 1 + echo. + echo.Build finished; now you can run HTML Help Workshop with the ^ +.hhp project file in %BUILDDIR%/htmlhelp. + goto end +) -:help -%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% +if "%1" == "qthelp" ( + %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp + if errorlevel 1 exit /b 1 + echo. + echo.Build finished; now you can run "qcollectiongenerator" with the ^ +.qhcp project file in %BUILDDIR%/qthelp, like this: + echo.^> qcollectiongenerator %BUILDDIR%\qthelp\Py-ART.qhcp + echo.To view the help file: + echo.^> assistant -collectionFile %BUILDDIR%\qthelp\Py-ART.ghc + goto end +) + +if "%1" == "devhelp" ( + %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. + goto end +) + +if "%1" == "epub" ( + %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The epub file is in %BUILDDIR%/epub. + goto end +) + +if "%1" == "latex" ( + %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex + if errorlevel 1 exit /b 1 + echo. + echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. + goto end +) + +if "%1" == "text" ( + %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The text files are in %BUILDDIR%/text. + goto end +) + +if "%1" == "man" ( + %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The manual pages are in %BUILDDIR%/man. + goto end +) + +if "%1" == "texinfo" ( + %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. + goto end +) + +if "%1" == "gettext" ( + %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale + if errorlevel 1 exit /b 1 + echo. + echo.Build finished. The message catalogs are in %BUILDDIR%/locale. + goto end +) + +if "%1" == "changes" ( + %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes + if errorlevel 1 exit /b 1 + echo. + echo.The overview file is in %BUILDDIR%/changes. + goto end +) + +if "%1" == "linkcheck" ( + %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck + if errorlevel 1 exit /b 1 + echo. + echo.Link check complete; look for any errors in the above output ^ +or in %BUILDDIR%/linkcheck/output.txt. + goto end +) + +if "%1" == "doctest" ( + %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest + if errorlevel 1 exit /b 1 + echo. + echo.Testing of doctests in the sources finished, look at the ^ +results in %BUILDDIR%/doctest/output.txt. + goto end +) :end -popd diff --git a/docs/source/API/corrections.rst b/docs/source/API/corrections.rst deleted file mode 100644 index 226b6db926..0000000000 --- a/docs/source/API/corrections.rst +++ /dev/null @@ -1,2 +0,0 @@ -.. automodule:: act.corrections - :members: diff --git a/docs/source/API/discovery.rst b/docs/source/API/discovery.rst deleted file mode 100644 index 9fee2e1322..0000000000 --- a/docs/source/API/discovery.rst +++ /dev/null @@ -1,4 +0,0 @@ -.. automodule:: act.discovery - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/API/index.rst b/docs/source/API/index.rst index 449d14c804..d5213d2fec 100644 --- a/docs/source/API/index.rst +++ b/docs/source/API/index.rst @@ -1,15 +1,19 @@ -============= -API Reference -============= +.. _API: + +#################### +API Reference Manual +#################### :Release: |version| :Date: |today| -This shows the details of the API of the Atmospheric data Community Toolkit. Documentation -of each procedure in each module is provided as a reference. +This shows the details of the API of the Atmospheric data Community Toolkit. +Documentation of each procedure in each module is provided as a reference. + +.. currentmodule:: act -.. toctree:: - :maxdepth: 3 +.. autosummary:: + :toctree: generated/ corrections discovery @@ -18,4 +22,3 @@ of each procedure in each module is provided as a reference. qc retrievals utils - diff --git a/docs/source/API/io.rst b/docs/source/API/io.rst deleted file mode 100644 index 8ea9604f88..0000000000 --- a/docs/source/API/io.rst +++ /dev/null @@ -1,9 +0,0 @@ -.. automodule:: act.io - :members: - :undoc-members: - :show-inheritance: - - -.. toctree:: - :maxdepth: 2 - diff --git a/docs/source/API/plotting.rst b/docs/source/API/plotting.rst deleted file mode 100644 index 9d7747abd3..0000000000 --- a/docs/source/API/plotting.rst +++ /dev/null @@ -1,7 +0,0 @@ -.. automodule:: act.plotting - :members: - :undoc-members: - :show-inheritance: - -.. toctree:: - :maxdepth: 2 diff --git a/docs/source/API/qc.rst b/docs/source/API/qc.rst deleted file mode 100644 index ef3a79e088..0000000000 --- a/docs/source/API/qc.rst +++ /dev/null @@ -1,7 +0,0 @@ -.. automodule:: act.qc - :members: - :undoc-members: - :show-inheritance: - -.. toctree:: - :maxdepth: 2 diff --git a/docs/source/API/retrievals.rst b/docs/source/API/retrievals.rst deleted file mode 100644 index 98c312db2d..0000000000 --- a/docs/source/API/retrievals.rst +++ /dev/null @@ -1,4 +0,0 @@ -.. automodule:: act.retrievals - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/API/utils.rst b/docs/source/API/utils.rst deleted file mode 100644 index 737515b711..0000000000 --- a/docs/source/API/utils.rst +++ /dev/null @@ -1,4 +0,0 @@ -.. automodule:: act.utils - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/CONTRIBUTING.rst b/docs/source/CONTRIBUTING.rst deleted file mode 100644 index 4392834494..0000000000 --- a/docs/source/CONTRIBUTING.rst +++ /dev/null @@ -1,424 +0,0 @@ -============ -Contributing -============ - -Contributions are welcome, and they are greatly appreciated! Every -little bit helps, and credit will always be given. - -You can contribute in many ways: - -Types of Contributions ----------------------- - -Report Bugs -~~~~~~~~~~~ - -Report bugs at https://github.com/ARM-DOE/ACT/issues - -If you are reporting a bug, please include: - -* Any details about your local setup that might be helpful in troubleshooting. -* Detailed steps to reproduce the bug. - -Fix Bugs -~~~~~~~~ - -Look through the GitHub issues for bugs. Anything tagged with "bug" -is open to whoever wants to implement it. - -Implement Features -~~~~~~~~~~~~~~~~~~ - -Look through the GitHub issues for features. Anything tagged with "feature" -is open to whoever wants to implement it. - -Write Documentation -~~~~~~~~~~~~~~~~~~~ - -Atmospheric data Community Toolkit could always use more documentation, whether -as part of the official Atmospheric data Community Toolkit docs, in docstrings, -or even on the web in blog posts, articles, and such. - -Submit Feedback -~~~~~~~~~~~~~~~ - -The best way to send feedback is to file an issue at https://github.com/ARM-DOE/ACT/issues - -If you are proposing a feature: - -* Explain in detail how it would work. -* Keep the scope as narrow as possible, to make it easier to implement. -* Remember that this is a volunteer-driven project, and that contributions - are welcome :) - -Get Started! ------------- - -Ready to contribute? Here's are a few steps we will go over for contributing -to `act`. - -1. Fork the `ACT` repo on GitHub and clone your fork locally. - -2. Install your local copy into an Anaconda environment. Assuming you have - anaconda installed. - -3. Create a branch for local development. - -4. Create or modified code so that it produces doc string and follows standards. - -5. PEP8 check using flake8. - -6. Local unit testing using Pytest. - -7. Commit your changes and push your branch to GitHub and submit a pull - request through the GitHub website. - -Fork and Cloning the ACT Repository ------------------------------------ -To start, you will first fork the `ACT` repo on GitHub by -clicking the fork icon button found on the main page here: - -- https://github.com/ARM-DOE/ACT - -After your fork is created, git clone your fork. I would not clone the main -repository link unless your just using the package as an install and not -development. The main master is used as a remote for upstream for grabbing -changes as others contribute. - -To clone and set up an upstream, use:: - - git clone https://github.com/yourusername/ACT.git - -or if you have ssh key setup:: - - git clone git@github.com:yourusername/ACT.git - -After that, from within the ACT directory, do:: - - git remote add upstream https://github.com/ARM-DOE/ACT.git - -Install -------- - -The easiest method for using ACT and its dependencies is by using: -`Anaconda `_ or -`Miniconda `_. -From within the ACT directory, you can use:: - - pip install -e . - -This downloads ACT in development mode. Do this preferably in a conda -environment. For more on Anaconda and environments: - -- https://ARM-DOE.github.io/ACT/CREATING_ENVIRONMENTS.html - -Working with Git Branches -------------------------- - -When contributing to ACT, the changes created should be in a new branch -under your forked repository. Let's say the user is adding a new plot display. -Instead of creating that new function in your master branch. Create a new -branch called ‘wind_rose_plot’. If everything checks out and the admin -accepts the pull request, you can then merge the master branch and -wind_rose_plot branch. - -To delete a branch both locally and remotely, if done with it:: - - git push origin --delete - git branch -d - -or in this case:: - - git push origin --delete wind_rose_plot - git branch -d wind_rose_plot - - -To create a new branch:: - - git checkout -b - -If you have a branch with changes that have not been added to a pull request -but you would like to start a new branch with a different task in mind. It -is recommended that your new branch is based on your master. First:: - - git checkout master - -Then:: - - git checkout -b - -This way, your new branch is not a combination of your other task branch and -the new task branch, but is based on the original master branch. - -Typing `git status` will not only inform the user of what files have been -modified and untracked, it will also inform the user of which branch they -are currently on. - -To switch between branches, simply type:: - - git checkout - -Python File Setup ------------------ - -When adding a new function to ACT, add the function in the __init__.py -for the submodule so it can be included in the documentation. - -Following the introduction code, modules are then added. To follow pep8 -standards, modules should be added in the order of: - - 1. Standard library imports. - 2. Related third party imports. - 3. Local application/library specific imports. - -For example: - -.. code-block:: python - - import glob - import os - - import numpy as np - import numpy.ma as ma - - from .dataset import ACTAccessor - -Following the main function def line, but before the code within it, a doc -string is needed to explain arguments, returns, references if needed, and -other helpful information. These documentation standards follow the NumPy -documentation style. - -For more on the NumPy documentation style: - -- https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard - -An example: - -.. code-block:: python - - def read_netcdf(filenames, variables=None): - - """ - Returns `xarray.Dataset` with stored data and metadata from a - user-defined query of standard netCDF files from a single - datastream. - - Parameters - ---------- - filenames : str or list - Name of file(s) to read - variables : list, optional - List of variable name(s) to read - - Returns - ------- - act_obj : Object - ACT dataset - - Examples - -------- - This example will load the example sounding data used for unit - testing. - - .. code-block:: python - - import act - - the_ds, the_flag = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE_WILDCARD) - print(the_ds.act.datastream) - """ - -As seen, each argument has what type of object it is, an explanation of -what it is, mention of units, and if an argument has a default value, a -statement of what that default value is and why. - -Private or smaller functions and classes can have a single line explanation. - -An example: - -.. code-block:: python - - def _get_value(self): - """ Gets a value that is used in a public function. """ - -Code Style ----------- - -ACT follows PEP8 coding standards. To make sure your code follows the -PEP8 style, you can use a variety of tools that can check for you. Two -popular PEP8 check modules are flake8 and pylint. (Note: ACT's continuous -integration uses flake8). - -For more on pep8 style: - -- https://www.python.org/dev/peps/pep-0008/ - -To install flake8:: - - conda install -c conda-forge flake8 - -To use flake8:: - - flake8 path/to/code/to/check.py - -To install pylint:: - - conda install pylint - -To use pylint:: - - pylint path/to/code/to/check.py - -Both of these tools are highly configurable to suit a user's taste. Refer to -the tools documentation for details on this process. - -- https://flake8.pycqa.org/en/latest/ -- https://www.pylint.org/ - -Unit Testing ------------- - -When adding a new function to ACT it is important to add your function to -the __init__.py file under the corresponding ACT folder. - -Create a test for your function and have assert from numpy testing test the -known values to the calculated values. If changes are made in the future to -ACT, pytest will use the test created to see if the function is still valid -and produces the same values. It works that, it takes known values that are -obtained from the function, and when pytest is ran, it takes the test -function and reruns the function and compares the results to the original. - -An example: - -.. code-block:: python - - import act - import numpy as np - import xarray as xr - - - def test_correct_ceil(): - # Make a fake dataset to test with, just an array with 1e-7 - # for half of it. - fake_data = 10 * np.ones((300, 20)) - fake_data[:, 10:] = -1 - arm_obj = {} - arm_obj['backscatter'] = xr.DataArray(fake_data) - arm_obj = act.corrections.ceil.correct_ceil(arm_obj) - assert np.all(arm_obj['backscatter'].data[:, 10:] == -7) - assert np.all(arm_obj['backscatter'].data[:, 1:10] == 1) - -Pytest is used to run unit tests in ACT. - -It is recommended to install ACT in “editable” mode for pytest testing. -From within the main ACT directory:: - - pip install -e . - -This lets you change your source code and rerun tests at will. - -To install pytest:: - - conda install -c conda-forge pytest - -To run all tests in pyart with pytest from outside the pyart directory:: - - pytest --pyargs act - -All test with increase verbosity:: - - pytest -v - -Just one file:: - - pytest filename - -Note: When an example shows filename as such:: - - pytest filename - -filename is the filename and location, such as:: - - pytest /home/user/act/act/tests/test_correct.py - -Relative paths can also be used:: - - cd ACT - pytest ./act/tests/test_correct.py - -For more on pytest: - -- https://docs.pytest.org/en/latest/ - - -Adding Changes to GitHub ------------------------- - -Once your done updating a file, and want the changes on your remote branch. -Simply add it by using:: - - git add - -When commiting to GitHub, start the statement with a acronym such as -‘ADD:’ depending on what your commiting, could be ‘MAINT:’ or -‘BUG:’ or more. Then following should be a short statement such as -“ADD: Adding new wind rose display.”, but after the short statement, before -finishing the quotations, hit enter and in your terminal you can then type -a more in depth description on what your commiting. - -A set of recommended acronymns can be found at: - -- https://docs.scipy.org/doc/numpy-1.15.1/dev/gitwash/development_workflow.html#writing-the-commit-message - -If you would like to type your commit in the terminal and skip the default -editor:: - - git commit -m "STY: Removing whitespace from plot.py pep8." - -To use the default editor(in Linux, usually VIM), simply type:: - - git commit - -One thing to keep in mind is before doing a pull request, update your -branches with the original upstream repository. - -This could be done by:: - - git fetch upstream - -After fetching, a git merge is needed to pull in the changes. - -This is done by:: - - git merge upstream/master - -To prevent a merge commit:: - - git merge --ff-only upstream/master - -or a rebase can be done with:: - - git pull --rebase upsteam master - -Rebase will take commits you missed and stack your changes on top of them. - -Before you submit a pull request, check that it meets these guidelines: - -1. The pull request should include tests. -2. If the pull request adds functionality, the docs should be updated. Put - your new functionality into a function with a docstring, and add the - feature to the list in README.rst. -3. The pull request should work for Python 2.7, 3.6, 3.7 for PyPy. Check - https://travis-ci.org/ARM-DOE/ACT - and make sure that the tests pass for all supported Python versions. - -After creating a pull request through GitHub, and outside checker TravisCI -will determine if the code past all checks. If the code fails the tests, as -the pull request sits, make changes to fix the code and when pushed to GitHub, -the pull request will automatically update and TravisCI will automatically -rerun. - -For more on Git: - -- https://git-scm.com/book/en/v2 diff --git a/docs/source/_static/act-theme.css b/docs/source/_static/act-theme.css new file mode 100644 index 0000000000..229041c598 --- /dev/null +++ b/docs/source/_static/act-theme.css @@ -0,0 +1,146 @@ +/* ACT style heading towards use of Poppins font */ +.header-style, h1, h2, h3, h4, h5, h6 { + font-family: Poppins, sans-serif; + } + + /* ARM header color */ + .bg-arm { + background-color: #182b55; + } + + :root { + --pst-color-navbar-link: 255, 255, 255; + --pst-color-text-base: 24, 43, 85; + --pst-color-h3: var(--pst-color-text-base); + --pst-color-h4: var(--pst-color-text-base); + --pst-color-h5: var(--pst-color-text-base); + --pst-color-h6: var(--pst-color-text-base); + --pst-color-paragraph: var(--pst-color-text-base); + } + +/* Override the default color set in the original theme for title */ +.navbar-brand>.title { + color: rgba(255, 255, 255) !important; + font-weight: 400 !important; + font-style: bold; +} + + /* Override the default color set in the original theme */ + .navbar-nav>.active>.nav-link { + color: rgba(255, 255, 255) !important; + font-weight: 400 !important; + font-style: italic; + } + + .fa-github-square:before { + color: rgba(255, 255, 255) !important; + font-weight: 400 !important; + } + + .fa-twitter-square:before { + color: rgba(255, 255, 255) !important; + font-weight: 400 !important; + } + + /* Override the default logo height */ + .navbar-brand { + height: 50px; + } + + /* Enhance the links to function docs in the gallery examples */ + div[class^="highlight"] a { + background-color: #EEEEEE; + } + + /* Control the appearance of the version alert banner */ + #banner .alert-version, .alert-news { + margin: 1em; + padding: 0.5em; + font-family: "Work Sans", sans-serif; + font-weight: 600; font-size: 16px; + } + + .intro-card { + background: #d8e5e8; + border: none; + border-radius: 0; + padding: 30px 10px 10px 10px; + margin: 10px 0px; + } + + .intro-card .card-text { + margin: 20px 0px; + } + + .card-button { + background-color: #fafafa; + border: none; + color: #484848; + text-align: center; + text-decoration: none; + display: inline-block; + font-size: 0.9rem; + border-radius: 0.5rem; + max-width: 220px; + padding: 0.5rem 0rem; + margin-top: auto; + } + + .card-button a { + color: #484848; + } + + .card-button p { + margin-top: 0; + margin-bottom: 0rem; + color: #484848; + } + + /* Tweaks to the appearance of the sidebars */ + .bd-sidebar { + flex: 0 0 20%; + border-right: none; + } + + .bd-toc .tocsection { + border-left: none; + } + + .bd-toc .section-nav { + border-left: none; + } + + /* Can remove once theme releases new version */ + /* xarray output display in bootstrap */ + .xr-wrap[hidden] { + display: block !important; + } + + .xr-var-data pre { + border: none; + box-shadow: none; + } + + + /* Styling the API Changes Table */ + .api-table tr:nth-child(3n + 1){ + background: #EEF5F5; + } + + .api-table tr:nth-child(3n + 2){ + opacity: 0.65; + } + + code.literal:not(.xref) span.pre { + color: #000; + } + + .api-table tr:nth-child(3n + 2)>td span:first-child::before{ + content: url(old.png); + zoom: 0.25; + } + + .api-table tr:nth-child(3n + 3)>td span:first-child::before{ + content: url(new.png); + zoom: 0.21; + } diff --git a/docs/source/_static/doc_shared.js b/docs/source/_static/doc_shared.js new file mode 100644 index 0000000000..9d59448efc --- /dev/null +++ b/docs/source/_static/doc_shared.js @@ -0,0 +1,12 @@ +const project = "ACT"; + +// Borrowed from Bokeh docs to look for a banner.html at the base of the docs repo and add that +// to the banner if present. +$(document).ready(function () { + $.get('/' + project + '/banner.html', function (data) { + if (data.length > 0) { + console.log(data); + $('#banner').prepend(data); + } + }) + }) diff --git a/docs/source/_templates/autosummary/base.rst b/docs/source/_templates/autosummary/base.rst new file mode 100644 index 0000000000..b7556ebf7b --- /dev/null +++ b/docs/source/_templates/autosummary/base.rst @@ -0,0 +1,5 @@ +{{ fullname | escape | underline}} + +.. currentmodule:: {{ module }} + +.. auto{{ objtype }}:: {{ objname }} diff --git a/docs/source/_templates/autosummary/class.rst b/docs/source/_templates/autosummary/class.rst new file mode 100644 index 0000000000..536acfe122 --- /dev/null +++ b/docs/source/_templates/autosummary/class.rst @@ -0,0 +1,33 @@ +{% extends "!autosummary/class.rst" %} + +{% block methods %} +{% if methods %} +.. HACK -- the point here is that we don't want this to appear in the output, but the autosummary should still generate the pages. + +.. autosummary:: + :toctree: + +{% for item in all_methods %} +{%- if not item.startswith('_') or item in ['__call__'] %} + ~{{ name }}.{{ item }} +{%- endif -%} +{%- endfor %} + +{% endif %} +{% endblock %} + +{% block attributes %} +{% if attributes %} +.. HACK -- the point here is that we don't want this to appear in the output, but the autosummary should still generate the pages. + +.. autosummary:: + :toctree: + +{% for item in all_attributes %} +{%- if not item.startswith('_') %} + ~{{ name }}.{{ item }} +{%- endif -%} + +{%- endfor %} +{% endif %} +{% endblock %} diff --git a/docs/source/_templates/autosummary/module.rst b/docs/source/_templates/autosummary/module.rst new file mode 100644 index 0000000000..0957773d08 --- /dev/null +++ b/docs/source/_templates/autosummary/module.rst @@ -0,0 +1,29 @@ +{{ fullname | escape | underline }} + +.. rubric:: Description + +.. automodule:: {{ fullname }} + +.. currentmodule:: {{ fullname }} + +{% if classes %} +.. rubric:: Classes + +.. autosummary:: + :toctree: . + {% for class in classes %} + {{ class }} + {% endfor %} + +{% endif %} + +{% if functions %} +.. rubric:: Functions + +.. autosummary:: + :toctree: . + {% for function in functions %} + {{ function }} + {% endfor %} + +{% endif %} diff --git a/docs/source/_templates/dev_template.rst b/docs/source/_templates/dev_template.rst new file mode 100644 index 0000000000..2e76f1bc5c --- /dev/null +++ b/docs/source/_templates/dev_template.rst @@ -0,0 +1,32 @@ +{% extends "!autosummary/class.rst" %} +{% block methods %} +{% if methods %} + .. HACK -- the point here is that we don't want this to appear in the output, but the autosummary should still generate the pages. + .. autosummary:: + :toctree: + {% for item in all_methods %} + {%- if not item.startswith('_') or item in ['__call__'] %} + {{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + + | + + **Private methods** + + .. autosummary:: + :toctree: + + {% for item in all_methods %} + {%- if item.startswith('_') %} + ~{{ name }}.{{ item }} + {%- endif -%} + {%- endfor %} + + {% endif %} +{% endblock %} + +{% block attributes %} +{% if attributes %} +{% endif %} +{% endblock %} diff --git a/docs/source/_templates/layout.html b/docs/source/_templates/layout.html new file mode 100644 index 0000000000..a5e99e6b02 --- /dev/null +++ b/docs/source/_templates/layout.html @@ -0,0 +1,17 @@ +{% extends "!layout.html" %} + +{% block fonts %} + + {{ super() }} +{% endblock %} + +{% block docs_navbar %} + + +{# Added to support a banner with an alert #} + +{% endblock %} diff --git a/docs/source/blog.md b/docs/source/blog.md new file mode 100644 index 0000000000..cc24c25458 --- /dev/null +++ b/docs/source/blog.md @@ -0,0 +1,2 @@ +# Blog +This file will be replaced as the blog page is built diff --git a/docs/source/blog_posts/2022/first-post.md b/docs/source/blog_posts/2022/first-post.md new file mode 100644 index 0000000000..d4ba8c714f --- /dev/null +++ b/docs/source/blog_posts/2022/first-post.md @@ -0,0 +1,16 @@ +--- +author: Max Grover +date: 2022-04-01 +tags: annoucement +--- + +# New Docs + +Hello All! + +Welcome to our new documentation page! This is a **new section** within the docs meant for: +* General updates +* Release overviews +* More narrative-oriented examples + +If you have any feedback on this new site, feel free to let us know using that Github button in the top right corner! diff --git a/docs/source/blog_posts/2022/sail_campaign_arm_and_noaa.ipynb b/docs/source/blog_posts/2022/sail_campaign_arm_and_noaa.ipynb new file mode 100644 index 0000000000..ac8baad20b --- /dev/null +++ b/docs/source/blog_posts/2022/sail_campaign_arm_and_noaa.ipynb @@ -0,0 +1,394 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c48d197b", + "metadata": {}, + "source": [ + "# Visualize and bring together data from the SAIL campaign and NOAA" + ] + }, + { + "cell_type": "markdown", + "id": "7f8be08e", + "metadata": {}, + "source": [ + "When reading and analyzing data, its is useful to bring together data from different organizations. This not only expands the data available for scientists and their research, but is also useful for quality controls checks. In this notebook, we look at both the datasets produce by ARM instruments in the SAIL campaign as well as instruments provided by NOAA at their KPS site near the SAIL campaign location." + ] + }, + { + "cell_type": "markdown", + "id": "0c189c1f", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0df7f915", + "metadata": {}, + "outputs": [], + "source": [ + "# Import our modules\n", + "import datetime as dt\n", + "import glob\n", + "\n", + "\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "import act" + ] + }, + { + "cell_type": "markdown", + "id": "bf4b9c75", + "metadata": {}, + "source": [ + "## Download and visualize our data using ACT" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ff73b52c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading dkps2221322a.mom\n", + "Downloading hkps2221322a.mom\n", + "Downloading kps2221322.raw\n", + "Downloading dkps2221323a.mom\n", + "Downloading hkps2221323a.mom\n", + "Downloading kps2221323.raw\n" + ] + } + ], + "source": [ + "# Download the NOAA KPS site files from 22:00 and 23:00\n", + "result_22_kps = act.discovery.download_noaa_psl_data(\n", + " site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='22')\n", + "result_23_kps = act.discovery.download_noaa_psl_data(\n", + " site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='23')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4fbbcf41", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Read in the .raw file. Spectra data are also downloaded\n", + "ds1_kps = act.io.noaapsl.read_psl_radar_fmcw_moment([result_22_kps[-1], result_23_kps[-1]])\n", + "\n", + "# Read in the parsivel files from NOAA's webpage.\n", + "url = ['https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221322_stats.txt',\n", + " 'https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221323_stats.txt']\n", + "ds2_kps = act.io.noaapsl.read_psl_parsivel(url)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ab3d9e66", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First we plot the NOAA FMCW and parsivel from the KPS site\n", + "\n", + "# Create display object with both datasets\n", + "display = act.plotting.TimeSeriesDisplay(\n", + " {\"NOAA Site KPS PSL Radar FMCW\": kps_ds1, \"NOAA Site KPS Parsivel\": kps_ds2},\n", + " subplot_shape=(2,), figsize=(10, 10))\n", + "\n", + "# Plot the subplots\n", + "display.plot('reflectivity_uncalibrated', dsname='NOAA Site KPS PSL Radar FMCW',\n", + " cmap='act_HomeyerRainbow', subplot_index=(0,))\n", + "display.plot('number_density_drops', dsname='NOAA Site KPS Parsivel',\n", + " cmap='act_HomeyerRainbow', subplot_index=(1,))\n", + "# Set limits\n", + "display.axes[1].set_ylim([0, 10])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c3cb7b25", + "metadata": {}, + "source": [ + "## Create a Multipanel Plot to Compare the KAZR and Parsivel" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6ee2d0ac", + "metadata": {}, + "outputs": [], + "source": [ + "# Use arm username and token to retrieve files.\n", + "# This is commented out as the files have already been downloaded.\n", + "\n", + "#token = 'arm_token'\n", + "#username = 'arm_username'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "aba3d2ea", + "metadata": {}, + "outputs": [], + "source": [ + "#Specify datastream and date range for KAZR data\n", + "ds_kazr = 'guckazrcfrgeM1.a1'\n", + "startdate = '2022-08-01'\n", + "enddate = '2022-08-01'\n", + "\n", + "# Data already retrieved, but showing code below on how to download the files.\n", + "#act.discovery.download_data(username, token, ds_kazr, startdate, enddate)\n", + "\n", + "# Index last 2 files for the 22:00 and 23:00 timeframe.\n", + "kazr_files = glob.glob(''.join(['./',ds_kazr,'/*nc']))\n", + "kazr_files[-2:]\n", + "kazr_ds = act.io.arm.read_arm_netcdf(kazr_files[-2:])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2d0eff7f", + "metadata": {}, + "outputs": [], + "source": [ + "#Specify datastream and date range for KAZR data\n", + "ds_ld = 'gucldM1.b1'\n", + "startdate = '2022-08-01'\n", + "enddate = '2022-08-01'\n", + "\n", + "# Data already retrieved, but showing code below on how to download the files.\n", + "#act.discovery.download_data(username, token, ds_ld, startdate, enddate)\n", + "\n", + "# Index last 2 files for the 22:00 and 23:00 timeframe.\n", + "ld_files = glob.glob(''.join(['./',ds_ld,'/*cdf']))\n", + "ld_ds = act.io.arm.read_arm_netcdf(ld_files[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e625bb29", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sherm\\AppData\\Local\\Temp\\ipykernel_10268\\1307396719.py:29: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " display.axes[0, 0].set_yticklabels(['0', '2', '4','6', '8', '10'])\n", + "C:\\Users\\sherm\\AppData\\Local\\Temp\\ipykernel_10268\\1307396719.py:33: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " display.axes[0, 1].set_yticklabels(['0', '2', '4','6', '8', '10'])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We now want to plot and compare ARM and NOAA's instruments.\n", + "\n", + "# Create a series display with all 4 datasets\n", + "display = act.plotting.TimeSeriesDisplay(\n", + " {\"NOAA KPS PSL Radar FMCW\": kps_ds1, \"NOAA KPS Parsivel\": kps_ds2,\n", + " \"guckazrcfrgeM1.a1\": kazr_ds, 'gucldM1.b1': ld_ds},\n", + " subplot_shape=(2, 2), figsize=(22, 12))\n", + "\n", + "# Set custom 2 line title for space\n", + "title = \"NOAA KPS PSL Radar FMCW\\n reflectivity_uncalibrated on 20220801\"\n", + "\n", + "# Plot the four subplots\n", + "display.plot('reflectivity_uncalibrated', dsname='NOAA KPS PSL Radar FMCW',\n", + " cmap='act_HomeyerRainbow', set_title=title, subplot_index=(0, 1))\n", + "display.plot('number_density_drops', dsname='NOAA KPS Parsivel',\n", + " cmap='act_HomeyerRainbow', subplot_index=(1, 1))\n", + "display.plot('reflectivity', dsname='guckazrcfrgeM1.a1',\n", + " cmap='act_HomeyerRainbow', subplot_index=(0, 0))\n", + "display.plot('number_density_drops', dsname='gucldM1.b1',\n", + " cmap='act_HomeyerRainbow', subplot_index=(1, 0))\n", + "\n", + "# Update limits\n", + "display.axes[1, 0].set_ylim([0, 10])\n", + "\n", + "display.axes[1, 1].set_ylim([0, 10])\n", + "\n", + "\n", + "display.axes[0, 0].set_ylim([0, 10000])\n", + "display.axes[0, 0].set_yticklabels(['0', '2', '4','6', '8', '10'])\n", + "display.axes[0, 0].set_ylabel('km')\n", + "\n", + "display.axes[0, 1].set_ylim([0, 10000])\n", + "display.axes[0, 1].set_yticklabels(['0', '2', '4','6', '8', '10'])\n", + "display.axes[0, 1].set_ylabel('km')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5db80cf7", + "metadata": {}, + "source": [ + "## Add Doppler Lidar Retrieved Winds" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8b1b4956", + "metadata": {}, + "outputs": [], + "source": [ + "#Specify datastream and date range for KAZR data\n", + "ds_dl = 'gucdlppiM1.b1'\n", + "startdate = '2022-08-01'\n", + "enddate = '2022-08-01'\n", + "\n", + "#act.discovery.download_data(username, token, ds_dl, startdate, enddate)\n", + "dl_ppi_files = glob.glob(''.join(['./',ds_dl,'/*cdf']))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "02f73beb", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "multi_ds = []\n", + "# Index last 9 files for the 22:00 and 23:00 timeframe and loop through.\n", + "for file in sorted(dl_ppi_files[-9:]):\n", + " ds = act.io.arm.read_arm_netcdf(file)\n", + " # Calculate the winds for each gucdlppi dataset.\n", + " wind_ds = act.retrievals.compute_winds_from_ppi(\n", + " ds, remove_all_missing=True, snr_threshold=0.008)\n", + " multi_ds.append(wind_ds)\n", + "\n", + "wind_ds = xr.merge(multi_ds)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5b567953", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a display object.\n", + "display = act.plotting.TimeSeriesDisplay(\n", + " {\"GUC DLPPI Computed Winds over KAZR\": wind_ds,\n", + " \"guckazrcfrgeM1.a1\": kazr_ds,}, figsize=(20, 10))\n", + "\n", + "# Plot the wind barbs overlayed on the KAZR reflectivity\n", + "display.plot('reflectivity', dsname='guckazrcfrgeM1.a1',\n", + " cmap='act_HomeyerRainbow', vmin=-20, vmax=30)\n", + "display.plot_barbs_from_spd_dir('wind_speed', 'wind_direction',\n", + " dsname='GUC DLPPI Computed Winds over KAZR',\n", + " invert_y_axis=False)\n", + "\n", + "# Update the x-limits to make sure both wind profiles are shown\n", + "# Update the y-limits to show plotted winds\n", + "display.axes[0].set_xlim([np.datetime64('2022-08-01T22:10'), np.datetime64('2022-08-01T23:50')])\n", + "display.axes[0].set_ylim([kazr.range.min(), 2500])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "be2b8212", + "metadata": {}, + "source": [ + "## Conclusion" + ] + }, + { + "cell_type": "markdown", + "id": "07bc7447", + "metadata": {}, + "source": [ + "By comparing these datasets, we can see similar and differences between the two datasets, but overall the structure is comparable. We can see the usefulness of ACT to not only read ARM datasets, but datasets outside of ARM. These workflows allow for scientists to have many different tools to use different datasets for their research, as well as quality control checks which increases the confidence in the quality and calibration of the instrumentation." + ] + } + ], + "metadata": { + "author": "Zach Sherman", + "date": "2022-10-07", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "tags": "SAIL,visualization,NOAA,parsivel,KAZR,winds,FMCW", + "title": "Visualize and compare data from the SAIL campaign and NOAA" + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/conf.py b/docs/source/conf.py index 146be8c307..a906959a32 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,5 +1,4 @@ #!/usr/bin/env python3 -# -*- coding: utf-8 -*- # # Atmospheric data Community Toolkit documentation build configuration file, created by # sphinx-quickstart on Thu Jun 28 12:35:56 2018. @@ -42,13 +41,17 @@ 'IPython.sphinxext.ipython_console_highlighting', 'matplotlib.sphinxext.plot_directive', 'sphinx_copybutton', + 'sphinx_design', + 'ablog', + 'myst_nb', 'sphinx_gallery.gen_gallery', - 'sphinx.ext.napoleon' + 'sphinx.ext.napoleon', ] +exclude_patterns = ['_build', '**.ipynb_checkpoints'] sphinx_gallery_conf = { 'examples_dirs': '../../examples', - 'gallery_dirs': 'source/auto_examples' + 'gallery_dirs': 'source/auto_examples', } # Configuration options for plot_directive. See: @@ -57,13 +60,16 @@ plot_html_show_formats = False # Generate the API documentation when building +autoclass_content = 'both' autosummary_generate = True -autoclass_content = "class" +autosummary_imported_members = True + +# Otherwise, the Return parameter list looks different from the Parameter list +napoleon_use_rtype = False napoleon_use_ivar = True napoleon_include_init_with_doc = False napoleon_use_param = False - # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] @@ -71,21 +77,22 @@ # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] -source_suffix = '.rst' +source_suffix = ['.rst', '.md', '.ipynb'] # The master toctree document. master_doc = 'index' # General information about the project. project = 'Atmospheric data Community Toolkit' -copyright = '2018, Adam Theisen' -author = 'Adam Theisen' +copyright = '2018-2022, ACT Developers' +author = 'ACT Developers' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # import act + # The short X.Y version. version = act.__version__ # The full version, including alpha/beta/rc tags. @@ -96,12 +103,11 @@ # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. -language = None +language = 'en' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path -exclude_patterns = [] # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' @@ -109,61 +115,94 @@ # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This patterns also effect to html_static_path and html_extra_path +exclude_patterns = ['*.ipynb'] + # -- 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' -import sphinx_rtd_theme -html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] +html_theme = 'pydata_sphinx_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # -# html_theme_options = {} + +html_theme_options = { + 'google_analytics_id': 'G-8YN80YZDD8', + 'github_url': 'https://github.com/ARM-DOE/ACT', +} # 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'] +html_css_files = ['act-theme.css'] + +html_js_files = ['doc_shared.js'] + # Custom sidebar templates, must be a dictionary that maps document names # to template names. # # This is required for the alabaster theme # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars html_sidebars = { - '**': [ - 'relations.html', # needs 'show_related': True theme option to display - 'searchbox.html', - ] + 'userguide': ['searchbox.html', 'sidebar-nav-bs.html'], + 'API': ['searchbox.html', 'sidebar-nav-bs.html'], + 'examples': ['searchbox.html', 'sidebar-nav-bs.html'], + 'notebook-gallery': ['searchbox.html', 'sidebar-nav-bs.html'], + 'blog': [ + 'search-field.html', + 'sidebar-nav-bs.html', + 'ablog/postcard.html', + 'ablog/recentposts.html', + 'ablog/archives.html', + ], + 'blog_posts/*/*': [ + 'search-field.html', + 'sidebar-nav-bs.html', + 'ablog/postcard.html', + 'ablog/recentposts.html', + 'ablog/archives.html', + ], } +# Setup the blog portion +blog_baseurl = 'arm-doe.github.io/ACT/' +blog_title = 'ACT Blog' +blog_path = 'blog' +fontawesome_included = True +blog_post_pattern = 'blog_posts/*/*' +post_redirect_refresh = 1 +post_auto_image = 1 +post_auto_excerpt = 2 + +# Don't execute the jupyter notebooks +nb_execution_mode = 'off' # -- Options for HTMLHelp output ------------------------------------------ # Output file base name for HTML help builder. htmlhelp_basename = 'act' - # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', - # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', - # Additional stuff for the LaTeX preamble. # # 'preamble': '', - # Latex figure (float) alignment # # 'figure_align': 'htbp', @@ -173,8 +212,13 @@ # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ - (master_doc, 'act.tex', 'Atmospheric data Community Toolkit Documentation', - 'Contributors', 'manual'), + ( + master_doc, + 'act.tex', + 'Atmospheric data Community Toolkit Documentation', + 'Contributors', + 'manual', + ), ] @@ -182,10 +226,7 @@ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [ - (master_doc, 'act', 'Atmospheric data Community Toolkit Documentation', - [author], 1) -] +man_pages = [(master_doc, 'act', 'Atmospheric data Community Toolkit Documentation', [author], 1)] # -- Options for Texinfo output ------------------------------------------- @@ -194,14 +235,18 @@ # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ - (master_doc, 'act', 'Atmospheric data Community Toolkit Documentation', - author, 'act', 'Package for connecting users to the data', - 'Miscellaneous'), + ( + master_doc, + 'act', + 'Atmospheric data Community Toolkit Documentation', + author, + 'act', + 'Package for connecting users to the data', + 'Miscellaneous', + ), ] - - # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = { 'python': ('https://docs.python.org/3/', None), diff --git a/docs/source/index.rst b/docs/source/index.rst index f621d7ecaa..11f59d4e11 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,32 +1,41 @@ -.. Packaging Scientific Python documentation master file, created by - sphinx-quickstart on Thu Jun 28 12:35:56 2018. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. - +================================================ Atmospheric data Community Toolkit Documentation ================================================ .. toctree:: - :maxdepth: 4 + :maxdepth: 2 :hidden: - :caption: Documentation + :caption: Version 2 Release Guide + + userguide/GUIDE_V2.rst + +.. toctree:: + :maxdepth: 2 + :hidden: + :caption: User Guide + + userguide/index.rst + +.. toctree:: + :maxdepth: 2 + :hidden: + :caption: Reference Guide - installation - CREATING_ENVIRONMENTS.rst - CONTRIBUTING.rst - usage - source/auto_examples/index.rst - release-history API/index.rst +.. toctree:: + :maxdepth: 2 + :hidden: + :caption: Example Gallery + + source/auto_examples/index.rst + .. toctree:: :maxdepth: 1 :hidden: - :caption: Downloads + :caption: Blog - Anaconda Cloud - GitHub Repository - Zip File of Repository + blog.md .. toctree:: :maxdepth: 1 @@ -44,28 +53,41 @@ The Atmospheric data Community Toolkit (ACT) is an open source Python toolkit fo .. |act| image:: act_plots.png +Please report any issues or feature requests by submitting an `Issue `_. Additionally, our `discussions boards `_ are open for ideas, general discussions or questions, and show and tell! + +Version 2.0 +=========== + +ACT will soon have a version 2.0 release. This release will contain many function +naming changes such as IO and Discovery module function naming changes. To +prepare for this release, a `v2.0 `_ +has been provided that explains the changes and how to work with the new syntax. + Dependencies ============ -* `xarray `_ -* `NumPy `_ -* `SciPy `_ -* `matplotlib `_ -* `skyfield `_ -* `pandas `_ -* `dask `_ -* `Pint `_ -* `PyProj `_ -* `Proj `_ -* `Six `_ -* `Requests `_ +| `xarray `_ +| `NumPy `_ +| `SciPy `_ +| `matplotlib `_ +| `skyfield `_ +| `pandas `_ +| `dask `_ +| `Pint `_ +| `PyProj `_ +| `Proj `_ +| `Six `_ +| `Requests `_ +| `MetPy `_ Optional Dependencies ===================== -* `MPL2NC `_ Reading binary MPL data. -* `Cartopy `_ Mapping and geoplots -* `MetPy `_ >= V1.0 Skew-T plotting and some stabilities indices calculations +| `MPL2NC `_ Reading binary MPL data. +| `Cartopy `_ Mapping and geoplots +| `Py-ART `_ Reading radar files, plotting and corrections +| `scikit-posthocs `_ Using interquartile range or generalized Extreme Studentized Deviate quality control tests +| `icartt `_ icartt is an ICARTT file format reader and writer for Python Contributing diff --git a/docs/source/installation.rst b/docs/source/installation.rst deleted file mode 100644 index 2f2773f56d..0000000000 --- a/docs/source/installation.rst +++ /dev/null @@ -1,25 +0,0 @@ -============ -Installation -============ - -In order to use ACT, you must have Python 3.6+ installed. We do not plan on -having support for Python 2.x as it will be deprecated very soon. - -In addition, in order to make Skew-T plots, metpy is needed. In order to install -MetPy, simply do:: - - $ pip install metpy - -Or, if you have Anaconda:: - - $ conda install -c conda-forge metpy - -You can build the Atmospheric data Community Toolkit from source and install it doing:: - - - $ git clone https://github.com/ARM-DOE/ACT - $ cd ACT - $ python setup.py install - -We soon plan to implement pip install and conda install features. - diff --git a/docs/source/multi_ds_plot1.png b/docs/source/multi_ds_plot1.png deleted file mode 100644 index 9af17d3678..0000000000 Binary files a/docs/source/multi_ds_plot1.png and /dev/null differ diff --git a/docs/source/plot_ceil_example.png b/docs/source/plot_ceil_example.png deleted file mode 100644 index 2d58744a73..0000000000 Binary files a/docs/source/plot_ceil_example.png and /dev/null differ diff --git a/docs/source/plot_contour_example.png b/docs/source/plot_contour_example.png deleted file mode 100644 index 77878135c9..0000000000 Binary files a/docs/source/plot_contour_example.png and /dev/null differ diff --git a/docs/source/release-history.rst b/docs/source/release-history.rst deleted file mode 100644 index a655bf92bf..0000000000 --- a/docs/source/release-history.rst +++ /dev/null @@ -1,81 +0,0 @@ -=============== -Release History -=============== - -0.1.6 (Released 2019-12-02) ---------------------------- - -Numerous updates have been made since the last release. - -* The ACT object has been updated to remove the "act" attributes - and instead store that information in xarrays attrs. - Code has also been updated to not need additional information - that is adding in during the reading so that pure xarray datasets can be used. - -* Corrections to the doppler lidar correction, wind barb plotting, sonde stability calculations. - -* Adding doppler lidar wind retrievals, code to calculate destination lat/lon - from starting lat/lon and heading/distance - - -0.1.6 (Released 2019-10-10) ---------------------------- - -* Corrections for Doppler Lidar, Raman Lidar added as well as updates to MPL correction code -* New plotting capability for plotting size spectra -* Added capability to calculate course and speed over ground from lat/lon data -* Added capability to correct wind speed and direction for ship motion -* Removing ACT rolling_window function - -0.1.5 (Released 2019-09-20) ---------------------------- - -The recent update to xarray caused some issues with the tests. -These have been updated to accommodate - -0.1.4 (Released 2019-09-20) ---------------------------- - -Version includes new plotting functions for visualizing -bit-packed QC as used by the ARM program. A new function -for calculating precipitable water vapor from a sounding -was also created and including. Other updates include bug -fixes and the inclusion of a roadmap. - -0.1.3 (Released 2019-09-06) ---------------------------- - -Merge pull request #116 from AdamTheisen/master - -Missing requirements and data files for tests - -0.1.2 (Released 2019-09-06) ---------------------------- - -Some .txt files were missing from the pip installs. - -0.1.1 (Released 2019-09-03) ---------------------------- - -This release is to support the anaconda distribution. - -0.1 (Released 2019-09-03) -------------------------- - -Additional documentation for the QC functions have been added. -New functions for weighted averaging of time-series data, precipitation -accumulation, and cloud base height detection using a sobel edge -detection method have also been added. - -0.0.2 (Released 2019-08-14) ---------------------------- - -Secondary release to work with pypi - -0.0.1 (Released 2019-08-14) ---------------------------- - -This is the initial release of the ACT toolkit for use in working with -atmospheric time-series data. Library includes scripts for accessing -data through APIs, I/O scripts, data visualization, quality control -algorithms, corrections, and retrievals. \ No newline at end of file diff --git a/docs/source/userguide/CONTRIBUTING.rst b/docs/source/userguide/CONTRIBUTING.rst new file mode 100644 index 0000000000..b1cd2f37dc --- /dev/null +++ b/docs/source/userguide/CONTRIBUTING.rst @@ -0,0 +1 @@ +.. include:: ../../../CONTRIBUTING.rst diff --git a/docs/source/CREATING_ENVIRONMENTS.rst b/docs/source/userguide/CREATING_ENVIRONMENTS.rst similarity index 100% rename from docs/source/CREATING_ENVIRONMENTS.rst rename to docs/source/userguide/CREATING_ENVIRONMENTS.rst diff --git a/docs/source/userguide/GUIDE_V2.rst b/docs/source/userguide/GUIDE_V2.rst new file mode 100644 index 0000000000..7b29b7e204 --- /dev/null +++ b/docs/source/userguide/GUIDE_V2.rst @@ -0,0 +1 @@ +.. include:: ../../../guides/GUIDE_V2.rst diff --git a/docs/source/userguide/index.rst b/docs/source/userguide/index.rst new file mode 100644 index 0000000000..4be41c90ff --- /dev/null +++ b/docs/source/userguide/index.rst @@ -0,0 +1,12 @@ +========== +User Guide +========== + +.. toctree:: + :maxdepth: 1 + + installation + CREATING_ENVIRONMENTS + usage + CONTRIBUTING + GUIDE_V2 diff --git a/docs/source/userguide/installation.rst b/docs/source/userguide/installation.rst new file mode 100644 index 0000000000..1f0268eaa6 --- /dev/null +++ b/docs/source/userguide/installation.rst @@ -0,0 +1,20 @@ +============ +Installation +============ + +In order to use ACT, you must have Python 3.6+ installed. + +You can build the Atmospheric data Community Toolkit from source and install it doing:: + + + $ git clone https://github.com/ARM-DOE/ACT + $ cd ACT + $ python setup.py install + +ACT is also available on Anaconda and PyPI. To install from PyPI: + + $ pip install act-atmos + +To install from Anaconda conda-forge:: + + $ conda install -c conda-forge act-atmos diff --git a/docs/source/usage.rst b/docs/source/userguide/usage.rst similarity index 73% rename from docs/source/usage.rst rename to docs/source/userguide/usage.rst index e24c536d64..202cc22a18 100644 --- a/docs/source/usage.rst +++ b/docs/source/userguide/usage.rst @@ -9,58 +9,56 @@ Start by importing Atmospheric data Community Toolkit. import act The Atmospheric data Community Toolkit comes with modules for loading ARM datasets. -The main dataset object that is used in ACT is based off of an extension of +The main dataset object that is used in ACT is based off of an extension of the `xarray.Dataset` object. In particular ACT adds a DatasetAccessor that stores the additional properties required by act in the .act property of a Dataset. For example, if we want to access the name of the datastream, we simply do: .. code-block:: python - + import act - - the_ds = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_SONDE_WILDCARD) + + the_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_SONDE_WILDCARD) print(the_ds.act.datastream) -To load ARM-standard files into, the ``arm.io.armfiles.read_netcdf`` routine is used. -This takes in a string with wildcards allowed or a list of files for ACT to read. -Currently, there is support for ACT to concatenate multiple netCDF files along a ``time`` +To load ARM-standard files into, the ``arm.io.arm.read_arm_netcdf`` routine is used. +This takes in a string with wildcards allowed or a list of files for ACT to read. +Currently, there is support for ACT to concatenate multiple netCDF files along a ``time`` dimension if all of the files follow the same format. This allows for the easy -reading of multi-file datasets, such as the examples provided in the +reading of multi-file datasets, such as the examples provided in the :ref:`sphx_glr_source_auto_examples_plot_sonde.py`. In addition, ACT has a TimeSeriesDisplay object that makes plotting the data in a timeseries easy. The TimeSeriesDisplay object supports multipanel plots with ease. The following code will plot a 3 panel time series plot from -the dataset in the code snippet above. +the dataset in the code snippet above. .. code-block:: python display = act.plotting.TimeSeriesDisplay(met) display.add_subplots((3,), figsize=(15, 10)) - display.plot('alt', subplot_index=(0,) ) - display.plot('temp_mean', subplot_index=(1,) ) - display.plot('rh_mean', subplot_index=(2,) ) + display.plot("alt", subplot_index=(0,)) + display.plot("temp_mean", subplot_index=(1,)) + display.plot("rh_mean", subplot_index=(2,)) plt.show() In addition, the figure and axes handles of each subplot are stored in the -`TimeSeriesDisplay` object as `TimeSeriesDisplay.fig` and +`TimeSeriesDisplay` object as `TimeSeriesDisplay.fig` and `TimeSeriesDisplay.ax`. Therefore, standard matplotlib routines can then be used to modify the properties of each plot if the user desires further customization. -Finally, ACT is able to download data from the ARM archive given that a -user's username and token are provided. +Finally, ACT is able to download data from the ARM archive given that a +user's username and token are provided. .. code-block:: python - act.discovery.get_data('userName','XXXXXXXXXXXXXXXX', 'sgpmetE13.b1', - '2017-01-14', '2017-01-20') + act.discovery.get_data( + "userName", "XXXXXXXXXXXXXXXX", "sgpmetE13.b1", "2017-01-14", "2017-01-20" + ) The preceding example will download the sgpmetE13.b1 dataset in netCDF format from 2017-01-14 to 2017-01-20 and store the dataset in an output folder named 'sgpmetE13.b1.' This output folder can also be specified by the user. - - - diff --git a/docs/source/weighted_average_example.png b/docs/source/weighted_average_example.png deleted file mode 100644 index 9135602042..0000000000 Binary files a/docs/source/weighted_average_example.png and /dev/null differ diff --git a/environment.yml b/environment.yml index 29256d8537..9c0e11f0a8 100644 --- a/environment.yml +++ b/environment.yml @@ -1,19 +1,22 @@ -# Basic environment for ACT. -name: act_env -channels: - - conda-forge -dependencies: - - python=3.7 - - numpy - - scipy - - xarray - - matplotlib - - dask - - distributed - - pandas - - pint - - requests - - pyproj>=2.0.0 - - cartopy - - skyfield - +# Basic environment for ACT. +name: act_env +channels: + - conda-forge +dependencies: + - python + - numpy + - scipy + - xarray + - matplotlib + - dask + - distributed + - pandas + - pint + - requests + - pre-commit + - pyproj>=2.0.0 + - cartopy + - skyfield + - lazy_loader + - lxml + - cmweather diff --git a/examples/README.rst b/examples/README.rst new file mode 100644 index 0000000000..eca624531b --- /dev/null +++ b/examples/README.rst @@ -0,0 +1,12 @@ +ACT Example Gallery +=================== + +This gallery houses examples on different use cases for act including +downloading data from web APIs, visualization various types of data, +and more. If there are specific use cases you would like to see examples +of, please head on over to the `ACT discussion page `_ on GitHub. + +If your looking to contribute, the templates directory found `here `_ +provides templates for the examples gallery python files. For a template for +creating Jupyter notebooks for ACT tutorials, blog posts and more, that +template can be found `here `_ diff --git a/examples/README.txt b/examples/README.txt deleted file mode 100644 index 76449d57f7..0000000000 --- a/examples/README.txt +++ /dev/null @@ -1,6 +0,0 @@ -ACT Example Gallery -=================== - -Different examples on how to read and visualize data using ACT are provided -here. - diff --git a/examples/ceil_example.py b/examples/ceil_example.py deleted file mode 100644 index 4d97bb98bf..0000000000 --- a/examples/ceil_example.py +++ /dev/null @@ -1,29 +0,0 @@ -""" -====================================== -Example for looking at ceilometer data -====================================== - -This is an example of how to download and -plot ceiliometer data from the SGP site -over Oklahoma. - -.. image:: ../../plot_ceil_example.png -""" - -import act -import matplotlib.pyplot as plt - -# Place your username and token here -username = '' -token = '' - -act.discovery.download_data(username, token, 'sgpceilC1.b1', - '2017-01-14', '2017-01-19') - -ceil_ds = act.io.armfiles.read_netcdf('sgpceilC1.b1/*') -print(ceil_ds) -ceil_ds = act.corrections.ceil.correct_ceil(ceil_ds, -9999.) -display = act.plotting.TimeSeriesDisplay( - ceil_ds, subplot_shape=(1, ), figsize=(15, 5)) -display.plot('backscatter', subplot_index=(0, )) -plt.show() diff --git a/examples/correct_ship_wind_data.py b/examples/corrections/plot_correct_ship_wind_data.py similarity index 55% rename from examples/correct_ship_wind_data.py rename to examples/corrections/plot_correct_ship_wind_data.py index 18a28d4513..d6f9071ce8 100644 --- a/examples/correct_ship_wind_data.py +++ b/examples/corrections/plot_correct_ship_wind_data.py @@ -1,34 +1,36 @@ """ -Example on how to correct wind data for ship motion +Correct wind data for ship motion --------------------------------------------------- This example shows how to calculate course and speed over ground of the ship and use it to correct the wind speed and direction data. """ -import act +from arm_test_data import DATASETS import xarray as xr +import act + # Read in the navigation data, mainly for the lat/lon -nav = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_NAV) +filename_nav = DATASETS.fetch('marnavM1.a1.20180201.000000.nc') +nav_ds = act.io.arm.read_arm_netcdf(filename_nav) # Calculate course and speed over ground from the NAV # lat and lon data -nav = act.utils.ship_utils.calc_cog_sog(nav) +nav_ds = act.utils.ship_utils.calc_cog_sog(nav_ds) # Read in the data containing the wind speed and direction -aosmet = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_AOSMET) +filename_aosmet = DATASETS.fetch('maraosmetM1.a1.20180201.000000.nc') +aosmet_ds = act.io.arm.read_arm_netcdf(filename_aosmet) # Merge the navigation and wind data together # This have been previously resampled to 1-minute data -obj = xr.merge([nav, aosmet], compat='override') +ds = xr.merge([nav_ds, aosmet_ds], compat='override') # Call the correction for the winds. Note, that this only # corrects for ship course and speed, not roll and pitch. -obj = act.corrections.ship.correct_wind(obj) +ds = act.corrections.ship.correct_wind(ds) -nav.close() -aosmet.close() -obj.close() +nav_ds.close() +aosmet_ds.close() +ds.close() diff --git a/examples/corrections/readme.txt b/examples/corrections/readme.txt new file mode 100644 index 0000000000..c0965b56ab --- /dev/null +++ b/examples/corrections/readme.txt @@ -0,0 +1,6 @@ +.. _correction_examples: + +Correction examples +-------------------------- + +Examples showing different meteorology corrections. diff --git a/examples/discovery/plot_airnow.py b/examples/discovery/plot_airnow.py new file mode 100644 index 0000000000..24ded44078 --- /dev/null +++ b/examples/discovery/plot_airnow.py @@ -0,0 +1,53 @@ +""" +Airnow Data +----------- + +This example shows the different ways to pull +air quality information from EPA's AirNow API for +a station near to SGP + +""" + +import os +import matplotlib.pyplot as plt +import act + +# You need an account and token from https://docs.airnowapi.org/ first +token = os.getenv('AIRNOW_API') + +if token is not None and len(token) > 0: + # This first example will get the forcasted values for the date passed + # at stations within 100 miles of the Zipcode. Can also use latlon instead as + # results = act.discovery.get_airnow_forecast(token, '2022-05-01', distance=100, + # latlon=[41.958, -88.12]) + # If the username and token are not set, use the existing sample file + results = act.discovery.get_airnow_forecast(token, '2022-05-01', zipcode=74630, distance=100) + + # The results show a dataset with air quality information from Oklahoma City + # The data is not indexed by time and just a rudimentary xarray object from + # converted from a pandas DataFrame. Note that the AirNow API labels the data + # returned as AQI. + print(results) + + # This call gives the daily average for Ozone, PM2.5 and PM10 + results = act.discovery.get_airnow_obs(token, date='2022-05-01', zipcode=74630, distance=100) + print(results) + + # This call will get all the station data for a time period within + # the bounding box provided. This will return the object with time + # as a coordinate and can be used with ACT Plotting to plot after + # squeezing the dimensions. It can be a 2D time series + lat_lon = '-98.172,35.879,-96.76,37.069' + results = act.discovery.get_airnow_bounded_obs( + token, '2022-05-01T00', '2022-05-01T12', lat_lon, 'OZONE,PM25', data_type='B' + ) + # Reduce to 1D timeseries + results = results.squeeze(dim='sites', drop=False) + print(results) + + # Plot out data but note that Ozone was not return in the results + display = act.plotting.TimeSeriesDisplay(results) + display.plot('PM2.5', label='PM2.5') + display.plot('AQI', label='AQI') + plt.legend() + plt.show() diff --git a/examples/discovery/plot_asos_temp.py b/examples/discovery/plot_asos_temp.py new file mode 100644 index 0000000000..8e592ef54e --- /dev/null +++ b/examples/discovery/plot_asos_temp.py @@ -0,0 +1,21 @@ +""" +Query and plot ASOS data +=========================================== + +This example shows how to plot timeseries of ASOS data from +Chicago O'Hare airport. + +""" +from datetime import datetime +import matplotlib.pyplot as plt +import act + +time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 10, 10, 0)] +station = 'KORD' +my_asoses = act.discovery.get_asos_data(time_window, station='ORD') + +display = act.plotting.TimeSeriesDisplay(my_asoses['ORD'], subplot_shape=(2,), figsize=(15, 10)) +display.plot('temp', subplot_index=(0,)) +display.plot_barbs_from_u_v(u_field='u', v_field='v', subplot_index=(1,)) +display.axes[1].set_ylim([0, 2]) +plt.show() diff --git a/examples/discovery/plot_neon.py b/examples/discovery/plot_neon.py new file mode 100644 index 0000000000..038fa62778 --- /dev/null +++ b/examples/discovery/plot_neon.py @@ -0,0 +1,58 @@ +""" +NEON Data +--------- + +This example shows how to download data from +NEON and ARM 2m surface meteorology stations +on the North Slope and plot them + +""" + +import os +import glob +import matplotlib.pyplot as plt +import numpy as np + +import act + +# Place your username and token here +username = os.getenv('ARM_USERNAME') +token = os.getenv('ARM_PASSWORD') + +if token is not None and len(token) > 0: + # Download ARM data if a username/token are set + files = act.discovery.download_arm_data(username, token, 'nsametC1.b1', '2022-10-01', '2022-10-07') + ds = act.io.arm.read_arm_netcdf(files) + + # Download NEON Data + # NEON sites can be found through the NEON website + # https://www.neonscience.org/field-sites/explore-field-sites + site_code = 'BARR' + product_code = 'DP1.00002.001' + result = act.discovery.neon.download_neon_data(site_code, product_code, '2022-10') + + # A number of files are downloaded and further explained in the readme file that's downloaded. + # These are the files we will need for reading 1 minute NEON data + file = glob.glob(os.path.join( + '.', + 'BARR_DP1.00002.001', + 'NEON.D18.BARR.DP1.00002.001.000.010.001.SAAT_1min.2022-10.expanded.*.csv', + )) + variable_file = glob.glob(os.path.join( + '.', 'BARR_DP1.00002.001', 'NEON.D18.BARR.DP1.00002.001.variables.*.csv' + )) + position_file = glob.glob(os.path.join( + '.', + 'BARR_DP1.00002.001', + 'NEON.D18.BARR.DP1.00002.001.sensor_positions.*.csv', + )) + # Read in the data using the ACT reader, passing with it the variable and position files + # for added information in the dataset + ds2 = act.io.read_neon_csv(file, variable_files=variable_file, position_files=position_file) + + # Plot up the two datasets + display = act.plotting.TimeSeriesDisplay({'ARM': ds, 'NEON': ds2}) + display.plot('temp_mean', 'ARM', marker=None, label='ARM') + display.plot('tempSingleMean', 'NEON', marker=None, label='NEON') + display.day_night_background('ARM') + plt.show() diff --git a/examples/discovery/plot_noaa_fmcw_moment.py b/examples/discovery/plot_noaa_fmcw_moment.py new file mode 100644 index 0000000000..50bad32ead --- /dev/null +++ b/examples/discovery/plot_noaa_fmcw_moment.py @@ -0,0 +1,59 @@ +""" +NOAA FMCW and parsivel plot +--------------------------- +ARM and NOAA have campaigns going on in the Crested Butte, CO region +and as part of that campaign NOAA has FMCW radars deployed that could +benefit the broader ARM and NOAA communities. This is an example of +how to plot both a NOAA FMCW PSL and NOAA parsivel two panel plot +observing the same event. + +Author: Zach Sherman, Adam Theisen +""" + + +import matplotlib.pyplot as plt + +import act + +# Use the ACT downloader to download a file from the +# Kettle Ponds site on 8/01/2022 between 2200 and 2300 UTC. +result_22 = act.discovery.download_noaa_psl_data( + site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='22' +) +result_23 = act.discovery.download_noaa_psl_data( + site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='23' +) + +# Read in the .raw files from both hours. Spectra data are also downloaded. +ds1 = act.io.noaapsl.read_psl_radar_fmcw_moment([result_22[-1], result_23[-1]]) + +# Read in the parsivel text files. +url = [ + 'https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221322_stats.txt', + 'https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221323_stats.txt', +] +ds2 = act.io.noaapsl.read_psl_parsivel(url) + +# Create a TimeSeriesDisplay object using both datasets. +display = act.plotting.TimeSeriesDisplay( + {'NOAA Site KPS PSL Radar FMCW': ds1, 'NOAA Site KPS Parsivel': ds2}, + subplot_shape=(2,), + figsize=(10, 10), +) + +# Plot PSL Radar followed by the parsivel data. +display.plot( + 'reflectivity_uncalibrated', + dsname='NOAA Site KPS PSL Radar FMCW', + cmap='HomeyerRainbow', + subplot_index=(0,), +) +display.plot( + 'number_density_drops', + dsname='NOAA Site KPS Parsivel', + cmap='HomeyerRainbow', + subplot_index=(1,), +) +# Adjust ylims of parsivel plot. +display.axes[1].set_ylim([0, 10]) +plt.show() diff --git a/examples/discovery/readme.txt b/examples/discovery/readme.txt new file mode 100644 index 0000000000..f8c0b32c21 --- /dev/null +++ b/examples/discovery/readme.txt @@ -0,0 +1,6 @@ +.. _discovery_examples: + +Discovery examples +-------------------------- + +Examples showing different ways to discover data. diff --git a/examples/get_stability_indices_example.py b/examples/get_stability_indices_example.py deleted file mode 100644 index 6748111a71..0000000000 --- a/examples/get_stability_indices_example.py +++ /dev/null @@ -1,42 +0,0 @@ -""" -Example on how to retrieve stability indicies from a sounding -------------------------------------------------------------- - -This example shows how to retrieve CAPE, CIN, and lifted index -from a sounding. -""" -import act - -sonde_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE1) - -sonde_ds = act.retrievals.calculate_stability_indicies( - sonde_ds, temp_name="tdry", td_name="dp", p_name="pres") -print("Lifted index = " + - str(sonde_ds["lifted_index"].values) + - " " + str(sonde_ds["lifted_index"].units)) -print("Surface based CAPE = " + - str(sonde_ds["surface_based_cape"].values) + - " " + - str(sonde_ds["surface_based_cape"].units)) -print("Surface based CIN = " + - str(sonde_ds["surface_based_cin"].values) + - " " + - str(sonde_ds["surface_based_cin"].units)) -print("Most unstable CAPE = " + - str(sonde_ds["most_unstable_cape"].values) + - " " + - str(sonde_ds["most_unstable_cape"].units)) -print("Most unstable CIN = " + - str(sonde_ds["most_unstable_cin"].values) + - " " + - str(sonde_ds["most_unstable_cin"].units)) -print("LCL temperature = " + - str(sonde_ds["lifted_condensation_level_temperature"].values) + - " " + - str(sonde_ds["lifted_condensation_level_temperature"].units)) -print("LCL pressure = " + - str(sonde_ds["lifted_condensation_level_pressure"].values) + - " " + - str(sonde_ds["lifted_condensation_level_pressure"].units)) -sonde_ds.close() diff --git a/examples/io/plot_create_arm_ds.py b/examples/io/plot_create_arm_ds.py new file mode 100644 index 0000000000..9840680405 --- /dev/null +++ b/examples/io/plot_create_arm_ds.py @@ -0,0 +1,55 @@ +""" +Create a dataset to mimic ARM file formats +------------------------------------------ +Example shows how to create a dataset from an ARM DOD. +This will enable users to create files that mimic ARM +files, making for easier use across the community. + +Author: Adam Theisen + +""" + +import act + +# Create an empty dataset using an ARM DOD +ds = act.io.arm.create_ds_from_arm_dod('vdis.b1', {'time': 1440}, scalar_fill_dim='time') + +# Print out the xarray dataset to see that it's empty +print(ds) + +# The user could populate this through a number of ways +# and that's best left up to the user on how to do it. +# If one has an existing dataset, a mapping of variable +# names is sometimes the easiest way + +# Let's look at some variable attributes +# These can be updated and it would be up to the +# user to ensure these tests are being applied +# and are appropriately set in the cooresponding QC variable +print(ds['num_drops'].attrs) + +# Next, let's print out the global attribuets +print(ds.attrs) + +# Add additional attributes or append to existing +# if they are needed using a dictionary +atts = { + 'command_line': 'python plot_create_arm_ds.py', + 'process_version': '1.2.3', + 'history': 'Processed with Jupyter Workbench', + 'random': '1234253sdgfadf' +} +for a in atts: + if a in ds.attrs: + ds.attrs[a] += atts[a] + else: + ds.attrs[a] = atts[a] + # Print out the attribute + print(a, ds.attrs[a]) + +# Write data out to netcdf +ds.to_netcdf('./sgpvdisX1.b1.20230101.000000.nc') + +# If one wants to clean up the dataset to better match CF standards +# the following can be done as well +ds.write.write_netcdf(cf_compliant=True, path='./sgpvdisX1.b1.20230101.000000.cf') diff --git a/examples/io/plot_hysplit.py b/examples/io/plot_hysplit.py new file mode 100644 index 0000000000..6e53009311 --- /dev/null +++ b/examples/io/plot_hysplit.py @@ -0,0 +1,23 @@ +""" +Read and plot a HYSPLIT trajectory file from a HYSPlIT run. +----------------------------------------------------------- + +This example shows how to read and plot a backtrajectory calculated by the NOAA +HYSPLIT model over Houston. + +Author: Robert Jackson +""" + +import act +import matplotlib.pyplot as plt + +from arm_test_data import DATASETS + +# Load the data +filename = DATASETS.fetch('houstonaug300.0summer2010080100') +ds = act.io.read_hysplit(filename) + +# Use the GeographicPlotDisplay object to make the plot +disp = act.plotting.GeographicPlotDisplay(ds) +disp.geoplot('PRESSURE', cartopy_feature=['STATES', 'OCEAN', 'LAND']) +plt.show() diff --git a/examples/io/plot_icartt.py b/examples/io/plot_icartt.py new file mode 100644 index 0000000000..4e7bc22bc9 --- /dev/null +++ b/examples/io/plot_icartt.py @@ -0,0 +1,44 @@ +""" +Plot ICARTT Formatted Files +--------------------------- + +This example shows how to read and display International Consortium for Atmospheric +Research on Transport and Transformation (ICARTT) file format standards V2.0 + +Author: Joe O'Brien + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import numpy as np + +import act +from act.io.icartt import read_icartt + +# Call the read_icartt function, which supports input +# for ICARTT (v2.0) formatted files. +# Example file is ARM Aerial Facility Navigation Data +filename_icartt = DATASETS.fetch('AAFNAV_COR_20181104_R0.ict') +ds = read_icartt(filename_icartt) + +# Create an ACT TimeSeriesDisplay. +display = act.plotting.TimeSeriesDisplay( + ds, ds_name=ds.attrs['_datastream'], subplot_shape=(2,), figsize=(15, 5) +) +# Display the AAF Ambient Temperature +display.plot('ambient_temp', subplot_index=(0,), label='Ambient') +# Display the AAF Dewpoint Temperature +display.plot('dewpoint_temperature', subplot_index=(0,), label='Dewpoint') +# Display the AAF Total Temperature +# (i.e Temperature not corrected for heating due to atmospheric compression) +# Note: Total Temperature >= Ambient (Static) Temperature +display.plot('total_temp', subplot_index=(0,), label='Total') + +# Display the AAF Static Air Pressure on the second subplot +display.plot('static_pressure', subplot_index=(1,)) +# Include legend to identify AAF Temperatures +plt.legend(loc='lower left') +# Adjust vertical space between subplots +plt.subplots_adjust(hspace=0.4) +plt.show() diff --git a/examples/plot_raw_minimpl.py b/examples/io/plot_raw_minimpl.py similarity index 58% rename from examples/plot_raw_minimpl.py rename to examples/io/plot_raw_minimpl.py index 436b11359e..2922216c6b 100644 --- a/examples/plot_raw_minimpl.py +++ b/examples/io/plot_raw_minimpl.py @@ -1,6 +1,6 @@ """ -Example on how to read and plot a PPI from mini-MPL ---------------------------------------------------- +Read and plot a PPI from raw mini-MPL data +------------------------------------------ Example of how to read in raw data from the mini-MPL and plot out the PPI by converting it to PyART @@ -8,26 +8,29 @@ Author: Adam Theisen """ +from arm_test_data import DATASETS +from matplotlib import pyplot as plt import act -from matplotlib import pyplot as plt try: import pyart + PYART_AVAILABLE = True except ImportError: PYART_AVAILABLE = False # Read in sample mini-MPL data -files = act.tests.sample_files.EXAMPLE_SIGMA_MPLV5 -obj = act.io.mpl.read_sigma_mplv5(files) +filename_mpl = DATASETS.fetch('201509021500.bi') +ds = act.io.mpl.read_sigma_mplv5(filename_mpl) # Create a PyART Radar Object -radar = act.utils.create_pyart_obj(obj, azimuth='azimuth_angle', elevation='elevation_angle', - range_var='range') +radar = act.utils.create_pyart_obj( + ds, azimuth='azimuth_angle', elevation='elevation_angle', range_var='range' +) # Creat Plot Display if PYART_AVAILABLE: display = pyart.graph.RadarDisplay(radar) - display.plot('nrb_copol', sweep=0, title_flag=False, vmin=0, vmax=1., cmap='jet') + display.plot('nrb_copol', sweep=0, title_flag=False, vmin=0, vmax=1.0, cmap='jet') plt.show() diff --git a/examples/io/plot_sodar.py b/examples/io/plot_sodar.py new file mode 100644 index 0000000000..0b6e0898fd --- /dev/null +++ b/examples/io/plot_sodar.py @@ -0,0 +1,33 @@ +""" +Read and plot a Sodar file +-------------------------- + +This example shows how to read and display Sodar data from the Argonne +National Laboratory (ANL) ATMOS site. + +Author: Zachary Sherman + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +# Call the read_sodar function. +# Example file is a MFAS Sodar at the ATMOS site. More information +# on the sodar can be found here: +# https://www.scintec.com/products/flat-array-sodar-mfas/ +filename_sodar = DATASETS.fetch('sodar.20230404.mnd') +ds = act.io.read_mfas_sodar(filename_sodar) + +# Create an ACT TimeSeriesDisplay. +display = act.plotting.TimeSeriesDisplay( + {'Shear, Wind Direction, and Speed at ANL ATMOS': ds}, + subplot_shape=(1,), figsize=(15, 5)) + +# Plot shear with a wind barb overlay, while using a color vision +# deficiency (CVD) colormap. +display.plot('shear', subplot_index=(0,), cb_friendly=True) +display.plot_barbs_from_spd_dir('speed', 'dir') +plt.show() diff --git a/examples/io/plot_surfrad.py b/examples/io/plot_surfrad.py new file mode 100644 index 0000000000..473185f24d --- /dev/null +++ b/examples/io/plot_surfrad.py @@ -0,0 +1,39 @@ +""" +Plot SurfRad Data +----------------- + +This data shows how to read in SurfRad data from the urls and plot +the data up in a time series + +Author: Adam Theisen + +""" + +import act +import matplotlib.pyplot as plt + +# Easily download data from SURFRAD +results = act.discovery.download_surfrad_data('tbl', startdate='20230601', enddate='20230602') +print(results) + +# But it's easy enough to read form the URLs as well +url = [ + 'https://gml.noaa.gov/aftp/data/radiation/surfrad/Boulder_CO/2023/tbl23008.dat', + 'https://gml.noaa.gov/aftp/data/radiation/surfrad/Boulder_CO/2023/tbl23009.dat' +] +ds = act.io.read_surfrad(url) + +# Create an ACT TimeSeriesDisplay. +display = act.plotting.TimeSeriesDisplay(ds, subplot_shape=(2,), figsize=(15, 10)) + +# Plot different variables from the SURFRAD data +display.plot('upwelling_global', subplot_index=(0,), label='Upwelling') +display.plot('downwelling_global', subplot_index=(0,), label='Downwelling') +plt.legend() + +display.plot('net_radiation', subplot_index=(1,), label='Net Radiation') +display.plot('net_ir', subplot_index=(1,), label='Net IR') +display.plot('total_net', subplot_index=(1,), label='Total Net') +plt.legend() + +plt.show() diff --git a/examples/io/readme.txt b/examples/io/readme.txt new file mode 100644 index 0000000000..5c77f405fb --- /dev/null +++ b/examples/io/readme.txt @@ -0,0 +1,6 @@ +.. _io_examples: + +Input/Output Examples +-------------------------- + +Examples showing different ways to read and save data. diff --git a/examples/multidata_example.py b/examples/multidata_example.py deleted file mode 100644 index 814b91426d..0000000000 --- a/examples/multidata_example.py +++ /dev/null @@ -1,50 +0,0 @@ -""" -================================================== -Example on how to plot multiple datasets at a time -================================================== - -This is an example of how to download and -plot multiple datasets at a time. - -.. image:: ../../multi_ds_plot1.png - -""" - -import act -import matplotlib.pyplot as plt - -# Place your username and token here -username = '' -token = '' - -act.discovery.download_data(username, token, 'sgpceilC1.b1', '2019-01-01', '2019-01-07') - -# Read in CEIL data and correct it -ceil_ds = act.io.armfiles.read_netcdf('sgpceilC1.b1/sgpceilC1.b1.201901*.nc') -ceil_ds = act.corrections.ceil.correct_ceil(ceil_ds, -9999.) - -# Read in the MET data -met_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_MET_WILDCARD) - -# You can use tuples if the datasets in the tuple contain a -# datastream attribute. This is required in all ARM datasets. -display = act.plotting.TimeSeriesDisplay( - (ceil_ds, met_ds), subplot_shape=(2, ), figsize=(15, 10)) -display.plot('backscatter', 'sgpceilC1.b1', subplot_index=(0, )) -display.plot('temp_mean', 'sgpmetE13.b1', subplot_index=(1, )) -display.day_night_background('sgpmetE13.b1', subplot_index=(1, )) -plt.show() - -# You can also use a dictionary so that you can customize -# your datastream names to something that may be more useful. -display = act.plotting.TimeSeriesDisplay( - {'ceiliometer': ceil_ds, 'met': met_ds}, - subplot_shape=(2, ), figsize=(15, 10)) -display.plot('backscatter', 'ceiliometer', subplot_index=(0, )) -display.plot('temp_mean', 'met', subplot_index=(1, )) -display.day_night_background('met', subplot_index=(1, )) -plt.show() - -ceil_ds.close() -met_ds.close() diff --git a/examples/plot_asos_temp.py b/examples/plot_asos_temp.py deleted file mode 100644 index 99e07980f5..0000000000 --- a/examples/plot_asos_temp.py +++ /dev/null @@ -1,23 +0,0 @@ -""" -=========================================== -Example on plotting timeseries of ASOS data -=========================================== - -This example shows how to plot timeseries of ASOS data from -Chicago O'Hare airport. - -""" -import act -import matplotlib.pyplot as plt - -from datetime import datetime -time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 10, 10, 0)] -station = "KORD" -my_asoses = act.discovery.get_asos(time_window, station="ORD") - -my_disp = act.plotting.TimeSeriesDisplay( - my_asoses['ORD'], subplot_shape=(2, ), figsize=(15, 10)) -my_disp.plot('temp', subplot_index=(0, )) -my_disp.plot_barbs_from_u_v(u_field='u', v_field='v', subplot_index=(1, )) -my_disp.axes[1].set_ylim([0, 2]) -plt.show() diff --git a/examples/plot_contour.py b/examples/plot_contour.py deleted file mode 100644 index eadc08435e..0000000000 --- a/examples/plot_contour.py +++ /dev/null @@ -1,36 +0,0 @@ -""" -======================================= -Example for plotting up a contour plot -======================================= - -This is an example of how to prepare -and plot data for a contour plot - -""" - -import act -import glob -import matplotlib.pyplot as plt - -files = glob.glob(act.tests.sample_files.EXAMPLE_MET_CONTOUR) -time = '2019-05-08T04:00:00.000000000' -data = {} -fields = {} -wind_fields = {} -station_fields = {} -for f in files: - obj = act.io.armfiles.read_netcdf(f) - data.update({f: obj}) - fields.update({f: ['lon', 'lat', 'temp_mean']}) - wind_fields.update({f: ['lon', 'lat', - 'wspd_vec_mean', 'wdir_vec_mean']}) - station_fields.update({f: ['lon', 'lat', 'temp_mean', - 'atmos_pressure', 'vapor_pressure_mean', - 'rh_mean']}) - -display = act.plotting.ContourDisplay(data, figsize=(8, 8)) -display.create_contour(fields=fields, time=time, levels=50) -display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, mesh=True, - grid_delta=(0.1, 0.1)) -display.plot_station(fields=station_fields, time=time, markersize=7, color='red') -plt.show() diff --git a/examples/plot_daytime_averages.py b/examples/plot_daytime_averages.py deleted file mode 100644 index 3b73cfd413..0000000000 --- a/examples/plot_daytime_averages.py +++ /dev/null @@ -1,32 +0,0 @@ -""" -Example on how to plot up daily daytime temperature averages ------------------------------------------------------------- - -Example of how to read in MET data and plot up daytime -temperature averages using the add_solar_variable function - -Author: Adam Theisen -""" - -import act -import matplotlib.pyplot as plt - -# Read in the sample MET data -obj = act.io.armfiles.read_netcdf(act.tests.EXAMPLE_MET_WILDCARD) - -# Add the solar variable, including dawn/dusk to variable -obj = act.utils.geo_utils.add_solar_variable(obj) - -# Using the sun variable, only analyze daytime data -obj = obj.where(obj['sun_variable'] == 1) - -# Take daily mean using xarray features -obj = obj.resample(time='1d', skipna=True, keep_attrs=True).mean() - -# Creat Plot Display -display = act.plotting.TimeSeriesDisplay(obj, figsize=(15, 10)) -display.plot('temp_mean', linestyle='solid') -display.day_night_background() -plt.show() - -obj.close() diff --git a/examples/plot_qc.py b/examples/plot_qc.py deleted file mode 100644 index e51a1c02ea..0000000000 --- a/examples/plot_qc.py +++ /dev/null @@ -1,32 +0,0 @@ -""" -Example on how to query the ARM DQR webservice ----------------------------------------------------- - -Simple example for querying the ARM DQR webservice -and plotting up the results - -Author: Adam Theisen -""" - - -import act -from matplotlib import pyplot as plt - -# Read in sample AOSMET data -files = act.tests.sample_files.EXAMPLE_AOSMET -obj = act.io.armfiles.read_netcdf(files) - -# Query DQR webservice for a specific variable -variable = 'temperature_ambient' -obj = act.qc.arm.add_dqr_to_qc(obj, variable=variable) - -# Plot data -# Creat Plot Display -display = act.plotting.TimeSeriesDisplay(obj, figsize=(15, 10), subplot_shape=(2,)) - -# Plot temperature data in top plot -display.plot(variable, subplot_index=(0,)) - -# Plot QC data -display.qc_flag_block_plot(variable, subplot_index=(1,)) -plt.show() diff --git a/examples/plot_rh_timeseries.py b/examples/plot_rh_timeseries.py deleted file mode 100644 index 480e9abbad..0000000000 --- a/examples/plot_rh_timeseries.py +++ /dev/null @@ -1,27 +0,0 @@ -""" -===================================================================== -Example on how to plot winds and relative humidity from sounding data -===================================================================== - -This is an example of how to display wind rose and barb timeseries -from multiple days worth of sounding data. - -""" - -import act -import numpy as np - -from matplotlib import pyplot as plt - -sonde_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_TWP_SONDE_WILDCARD) - -BarbDisplay = act.plotting.TimeSeriesDisplay( - {'sonde_darwin': sonde_ds}, figsize=(10, 5)) -BarbDisplay.plot_time_height_xsection_from_1d_data('rh', 'pres', - cmap='YlGn', - vmin=0, vmax=100, - num_time_periods=25) -BarbDisplay.plot_barbs_from_spd_dir('deg', 'wspd', 'pres', - num_barbs_x=20) -plt.show() diff --git a/examples/plot_skewt.py b/examples/plot_skewt.py deleted file mode 100644 index d15ae8690d..0000000000 --- a/examples/plot_skewt.py +++ /dev/null @@ -1,37 +0,0 @@ -""" -Example on how to plot a Skew-T plot of a sounding --------------------------------------------------- - -This example shows how to make a Skew-T plot from a sounding -and calculate stability indicies. METPy needs to be installed -in order to run this example - -""" - - -import act -from matplotlib import pyplot as plt - -try: - import metpy - METPY = True -except ImportError: - METPY = False - -if METPY: - # Read data - sonde_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_SONDE1) - - # Calculate stability indicies - sonde_ds = act.retrievals.calculate_stability_indicies( - sonde_ds, temp_name="tdry", td_name="dp", p_name="pres") - print(sonde_ds["lifted_index"]) - - # Set up plot - skewt = act.plotting.SkewTDisplay(sonde_ds, figsize=(15, 10)) - - # Add data - skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp') - sonde_ds.close() - plt.show() diff --git a/examples/plot_sonde.py b/examples/plot_sonde.py deleted file mode 100644 index 1d41d2936a..0000000000 --- a/examples/plot_sonde.py +++ /dev/null @@ -1,30 +0,0 @@ -""" -Example on how to plot a timeseries of sounding data ----------------------------------------------------- - -This is a simple example for how to plot a timeseries of sounding -data from the ARM SGP site. - -Author: Robert Jackson -""" - -import act -from matplotlib import pyplot as plt - -files = act.tests.sample_files.EXAMPLE_MET_WILDCARD -met = act.io.armfiles.read_netcdf(files) -print(met) -met_temp = met.temp_mean -met_rh = met.rh_mean -met_lcl = (20. + met_temp / 5.) * (100. - met_rh) / 1000. -met['met_lcl'] = met_lcl * 1000. -met['met_lcl'].attrs['units'] = 'm' -met['met_lcl'].attrs['long_name'] = 'LCL Calculated from SGP MET E13' - -# Plot data -display = act.plotting.TimeSeriesDisplay(met) -display.add_subplots((3,), figsize=(15, 10)) -display.plot('wspd_vec_mean', subplot_index=(0, )) -display.plot('temp_mean', subplot_index=(1, )) -display.plot('rh_mean', subplot_index=(2, )) -plt.show() diff --git a/examples/plot_wind_rose.py b/examples/plot_wind_rose.py deleted file mode 100644 index 5f13bfb1e4..0000000000 --- a/examples/plot_wind_rose.py +++ /dev/null @@ -1,34 +0,0 @@ -""" -===================================================================== -Example on how to plot winds and relative humidity from sounding data -===================================================================== - -This is an example of how to display wind rose and barb timeseries -from multiple days worth of sounding data. - -""" - -import act -import numpy as np - -from matplotlib import pyplot as plt - -sonde_ds = act.io.armfiles.read_netcdf( - act.tests.sample_files.EXAMPLE_TWP_SONDE_WILDCARD) - -WindDisplay = act.plotting.WindRoseDisplay(sonde_ds, figsize=(8, 10), subplot_shape=(2,)) -WindDisplay.plot('deg', 'wspd', - spd_bins=np.linspace(0, 25, 5), num_dirs=30, - tick_interval=2, subplot_index=(0,)) - - -BarbDisplay = act.plotting.TimeSeriesDisplay( - {'sonde_darwin': sonde_ds}, figsize=(10, 5)) -WindDisplay.put_display_in_subplot(BarbDisplay, subplot_index=(1,)) -BarbDisplay.plot_time_height_xsection_from_1d_data('rh', 'pres', - cmap='coolwarm_r', - vmin=0, vmax=100, - num_time_periods=25) -BarbDisplay.plot_barbs_from_spd_dir('deg', 'wspd', 'pres', - num_barbs_x=20) -plt.show() diff --git a/examples/plotting/plot_aaf_track.py b/examples/plotting/plot_aaf_track.py new file mode 100644 index 0000000000..2f42997582 --- /dev/null +++ b/examples/plotting/plot_aaf_track.py @@ -0,0 +1,30 @@ +""" +Plot ARM AAF Flight Path +-------------------------------- + +Plot the ARM AAF flight path using the GeographicPlotDisplay + +Author: Joe O'Brien + +""" +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act +from act.io.icartt import read_icartt + +# Call the read_icartt function, which supports input +# for ICARTT (v2.0) formatted files. +# Example file is ARM Aerial Facility Navigation Data +filename_icartt = DATASETS.fetch('AAFNAV_COR_20181104_R0.ict') +ds = read_icartt(filename_icartt) + +# Use GeographicPlotDisplay for referencing. +# NOTE: Cartopy is needed! +display = act.plotting.GeographicPlotDisplay(ds, figsize=(12, 10)) + +# Plot the ARM AAF flight track with respect to Pressure Altitude +display.geoplot('press_alt', lat_field='lat', lon_field='lon') + +# Display the plot +plt.show() diff --git a/examples/plotting/plot_ceil.py b/examples/plotting/plot_ceil.py new file mode 100644 index 0000000000..b24f810203 --- /dev/null +++ b/examples/plotting/plot_ceil.py @@ -0,0 +1,38 @@ +""" +Simple plot of 2D data +---------------------- + +This is an example of how to download and +plot ceiliometer data from the SGP site +over Oklahoma. + +""" + +import os + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +# Place your username and token here +username = os.getenv('ARM_USERNAME') +token = os.getenv('ARM_PASSWORD') + +# If the username and token are not set, use the existing sample file +if username is None or token is None or len(username) == 0 or len(token) == 0: + filename_ceil = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') + ceil_ds = act.io.arm.read_arm_netcdf(filename_ceil, engine='netcdf4') +else: + # Example to show how easy it is to download ARM data if a username/token are set + results = act.discovery.download_arm_data(username, token, 'sgpceilC1.b1', '2022-01-14', '2022-01-19') + ceil_ds = act.io.arm.read_arm_netcdf(results) + +# Adjust ceilometer data for plotting +ceil_ds = act.corrections.ceil.correct_ceil(ceil_ds, -9999.0) + +# Plot up ceilometer backscatter using HomeyerRainbow cb friendly colormap +# The same could be done with keyword 'cmap='HomeyerRainbow' +display = act.plotting.TimeSeriesDisplay(ceil_ds, subplot_shape=(1,), figsize=(15, 5)) +display.plot('backscatter', subplot_index=(0,), cb_friendly=True) +plt.show() diff --git a/examples/plotting/plot_contour.py b/examples/plotting/plot_contour.py new file mode 100644 index 0000000000..fba82cecfd --- /dev/null +++ b/examples/plotting/plot_contour.py @@ -0,0 +1,62 @@ +""" +Spatial contour plot +-------------------- + +This is an example of how to prepare +and plot data for a contour plot + +Author: Adam Theisen + +""" + +import glob + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +met_contour_list = ['sgpmetE15.b1.20190508.000000.cdf', + 'sgpmetE31.b1.20190508.000000.cdf', + 'sgpmetE32.b1.20190508.000000.cdf', + 'sgpmetE33.b1.20190508.000000.cdf', + 'sgpmetE34.b1.20190508.000000.cdf', + 'sgpmetE35.b1.20190508.000000.cdf', + 'sgpmetE36.b1.20190508.000000.cdf', + 'sgpmetE37.b1.20190508.000000.cdf', + 'sgpmetE38.b1.20190508.000000.cdf', + 'sgpmetE39.b1.20190508.000000.cdf', + 'sgpmetE40.b1.20190508.000000.cdf', + 'sgpmetE9.b1.20190508.000000.cdf', + 'sgpmetE13.b1.20190508.000000.cdf'] + +met_contour_filenames = [DATASETS.fetch(file) for file in met_contour_list] + +time = '2019-05-08T04:00:00.000000000' +data = {} +fields = {} +wind_fields = {} +station_fields = {} +for f in met_contour_filenames: + ds = act.io.arm.read_arm_netcdf(f) + data.update({f: ds}) + fields.update({f: ['lon', 'lat', 'temp_mean']}) + wind_fields.update({f: ['lon', 'lat', 'wspd_vec_mean', 'wdir_vec_mean']}) + station_fields.update( + { + f: [ + 'lon', + 'lat', + 'temp_mean', + 'atmos_pressure', + 'vapor_pressure_mean', + 'rh_mean', + ] + } + ) + +display = act.plotting.ContourDisplay(data, figsize=(8, 8)) +display.create_contour(fields=fields, time=time, levels=50) +display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, mesh=True, grid_delta=(0.1, 0.1)) +display.plot_station(fields=station_fields, time=time, markersize=7, color='red') +plt.show() diff --git a/examples/plotting/plot_data_rose.py b/examples/plotting/plot_data_rose.py new file mode 100644 index 0000000000..16166d83ee --- /dev/null +++ b/examples/plotting/plot_data_rose.py @@ -0,0 +1,104 @@ +""" +Data rose plot +-------------- + +This is an example of how to display a data rose. +As can be seen in the final plot, there are two major +bullseyes of data, one around 0ÂēC to the Northeast and +another around 15ÂēC to the South. This tells us that we +get lower temperatures when winds are out of the N/NE as +would be expected at this location. This can be extended +to easily review other types of data as well like aerosols +and fluxes. + +""" + +from arm_test_data import DATASETS +import numpy as np +from matplotlib import pyplot as plt + +import act + +# Read in some data with wind speed/direction in the file +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] +met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] +ds = act.io.arm.read_arm_netcdf(met_filenames) + +# Set up wind rose display object +display = act.plotting.WindRoseDisplay(ds, subplot_shape=(2, 3), figsize=(16, 10)) + +# Plot mean temperature based on wind direction +display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='line', + subplot_index=(0, 0), +) + +# Plot median temperature based on wind direction +display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='line', + subplot_index=(0, 1), + line_plot_calc='median', +) + +# Plot standard deviation of temperature based on wind direction +display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='line', + subplot_index=(0, 2), + line_plot_calc='stdev', +) + +# Plot a contour of counts of temperature based on wind direction +display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='contour', + subplot_index=(1, 0), +) + +# Plot a contour of mean temperature based on wind direction and wind speed +display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='contour', + contour_type='mean', + num_data_bins=10, + clevels=21, + cmap='rainbow', + vmin=-5, + vmax=20, + subplot_index=(1, 1), +) + +# Plot a boxplot of temperature based on wind direction +display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='boxplot', + subplot_index=(1, 2), +) + +plt.show() diff --git a/examples/plotting/plot_days.py b/examples/plotting/plot_days.py new file mode 100644 index 0000000000..70af4b7c1f --- /dev/null +++ b/examples/plotting/plot_days.py @@ -0,0 +1,39 @@ +""" +Calculate and plot wind rose plots separated by day. +----------------------------------------------------- + +Example of how to read in MET data and plot histograms +of wind speed and temperature grouped by day. + +Author: Bobby Jackson +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import numpy as np + +import act + +# Read in the sample MET data +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] +met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] +ds = act.io.arm.read_arm_netcdf(met_filenames) + +# Create Plot Display +display = act.plotting.WindRoseDisplay(ds, figsize=(15, 15), subplot_shape=(3, 3)) +groupby = display.group_by('day') +groupby.plot_group('plot_data', None, dir_field='wdir_vec_mean', spd_field='wspd_vec_mean', + data_field='temp_mean', num_dirs=12, plot_type='line') + +# Set theta tick markers for each axis inside display to be inside the polar axes +for i in range(3): + for j in range(3): + display.axes[i, j].tick_params(pad=-20) +plt.show() +ds.close() diff --git a/examples/plotting/plot_daytime_averages.py b/examples/plotting/plot_daytime_averages.py new file mode 100644 index 0000000000..117bf29a5e --- /dev/null +++ b/examples/plotting/plot_daytime_averages.py @@ -0,0 +1,42 @@ +""" +Calculate and plot daily daytime temperature averages +----------------------------------------------------- + +Example of how to read in MET data and plot up daytime +temperature averages using the add_solar_variable function + +Author: Adam Theisen +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +# Read in the sample MET data +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] +met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] +ds = act.io.arm.read_arm_netcdf(met_filenames) + +# Add the solar variable, including dawn/dusk to variable +ds = act.utils.geo_utils.add_solar_variable(ds) + +# Using the sun variable, only analyze daytime data +ds = ds.where(ds['sun_variable'] == 1) + +# Take daily mean using xarray features +ds = ds.resample(time='1d', skipna=True, keep_attrs=True).mean() + +# Creat Plot Display +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10)) +display.plot('temp_mean', linestyle='solid') +display.day_night_background() +plt.show() + +ds.close() diff --git a/examples/plotting/plot_enhanced_skewt.py b/examples/plotting/plot_enhanced_skewt.py new file mode 100644 index 0000000000..5223c6c3e4 --- /dev/null +++ b/examples/plotting/plot_enhanced_skewt.py @@ -0,0 +1,31 @@ +""" +Enhanced plot of a sounding +--------------------------- + +This example shows how to make an enhance plot for sounding data +which includes a Skew-T plot, hodograph, and stability indicies. + +Author: Adam Theisen + +""" + +import glob + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt +import metpy +import numpy as np +import xarray as xr + +import act + +# Read data +filename_sonde = DATASETS.fetch('sgpsondewnpnC1.b1.20190101.053200.cdf') +ds = act.io.arm.read_arm_netcdf(filename_sonde) + +# Plot enhanced Skew-T plot +display = act.plotting.SkewTDisplay(ds) +display.plot_enhanced_skewt(color_field='alt') + +ds.close() +plt.show() diff --git a/examples/plotting/plot_examples.py b/examples/plotting/plot_examples.py new file mode 100644 index 0000000000..96a8fe21e6 --- /dev/null +++ b/examples/plotting/plot_examples.py @@ -0,0 +1,43 @@ +""" +Xarray Plotting Examples +------------------------ + +This is an example of how to use some different aspects +of ACT's plotting tools as well as Xarray's tools. + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import xarray as xr + +import act + +# Set up plot space ahead of time +fig, ax = plt.subplots(3, figsize=(10, 7)) + +# Plotting up high-temporal resolution 2D data can be very slow at times. +# In order to increase the speed, the data can be resampled to a courser +# resolution prior to plotting. Using Xarray's resample and selecting +# the nearest neighbor will greatly increase the speed. +filename_ceil = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') +ds = act.io.arm.read_arm_netcdf(filename_ceil) +ds = ds.resample(time='1min').nearest() + +# These data can be plotted up using the existing xarray functionality +# which is quick and easy +ds['backscatter'].plot(x='time', ax=ax[0]) + +# or using ACT +display = act.plotting.TimeSeriesDisplay(ds) +display.assign_to_figure_axis(fig, ax[1]) +display.plot('backscatter') + +# When using ACT, the axis object can also be manipulated using normal +# matplotlib calls for more personalized customizations +display = act.plotting.TimeSeriesDisplay(ds) +display.assign_to_figure_axis(fig, ax[2]) +display.plot('backscatter') +display.axes[-1].set_ylim([0, 1500]) + +plt.show() diff --git a/examples/plotting/plot_heatmap.py b/examples/plotting/plot_heatmap.py new file mode 100644 index 0000000000..86238424c8 --- /dev/null +++ b/examples/plotting/plot_heatmap.py @@ -0,0 +1,41 @@ +""" +Example plot using heat maps +---------------------------- + +Compare MET temperature and RH using a heatmap +and scatter plot. + +Author: Adam Theisen + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +# Read MET data in from the test data area +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] +met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] +ds = act.io.arm.read_arm_netcdf(met_filenames) + +# Create a DistributionDisplay object to compare fields +display = act.plotting.DistributionDisplay(ds, subplot_shape=(1, 2), figsize=(12, 5)) + +# Plot a heatmap and scatter plot up of RH vs Temperature +# Set the number of bins for the x-axis to 25 and y to 20 +title = 'Heatmap of MET RH vs Temp' +display.plot_heatmap('temp_mean', 'rh_mean', x_bins=25, y_bins=20, + threshold=0, subplot_index=(0, 0), set_title=title) + +# Plot the scatter plot and shade by wind_speed +title = 'Scatter plot of MET RH vs Temp' +display.plot_scatter('temp_mean', 'rh_mean', subplot_index=(0, 1), set_title=title, m_field='time') + +plt.show() diff --git a/examples/plotting/plot_hist_kwargs.py b/examples/plotting/plot_hist_kwargs.py new file mode 100644 index 0000000000..063e19d280 --- /dev/null +++ b/examples/plotting/plot_hist_kwargs.py @@ -0,0 +1,25 @@ +""" +Plot a histogram of Met data. +---------------------------------------------------- + +This is a simple example for how to plot a histogram +of Meteorological data, while using hist_kwargs parameter. + +Author: Zachary Sherman +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt +import numpy as np + +import act + +filename_met = DATASETS.fetch('sgpmetE13.b1.20190101.000000.cdf') +met_ds = act.io.arm.read_arm_netcdf(filename_met) + +# Plot data +hist_kwargs = {'range': (-10, 10)} +histdisplay = act.plotting.DistributionDisplay(met_ds) +histdisplay.plot_stacked_bar('temp_mean', bins=np.arange(-40, 40, 5), + hist_kwargs=hist_kwargs) +plt.show() diff --git a/examples/plotting/plot_multiple_column.py b/examples/plotting/plot_multiple_column.py new file mode 100644 index 0000000000..1836277b3e --- /dev/null +++ b/examples/plotting/plot_multiple_column.py @@ -0,0 +1,37 @@ +""" +Plot a timeseries of sounding data +---------------------------------------------------- + +This is a simple example for how to plot multiple columns +in a TimeseriesDisplay. + +Author: Maxwell Grover +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt + +import act + +# Read in MET files. +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] +met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] +met_ds = act.io.arm.read_arm_netcdf(met_filenames) + + +# Plot data +display = act.plotting.TimeSeriesDisplay(met_ds) +display.add_subplots((3, 2), figsize=(15, 10)) +display.plot('temp_mean', color='tab:red', subplot_index=(0, 0)) +display.plot('rh_mean', color='tab:green', subplot_index=(1, 0)) +display.plot('wdir_vec_mean', subplot_index=(2, 0)) +display.plot('temp_std', color='tab:red', subplot_index=(0, 1)) +display.plot('rh_std', color='tab:green', subplot_index=(1, 1)) +display.plot('wdir_vec_std', subplot_index=(2, 1)) +plt.show() diff --git a/examples/plotting/plot_presentweathercode.py b/examples/plotting/plot_presentweathercode.py new file mode 100644 index 0000000000..dbec1e23d2 --- /dev/null +++ b/examples/plotting/plot_presentweathercode.py @@ -0,0 +1,88 @@ +""" +Plot Present Weather Code +-------------------------- + +Plot the Present Weather Code on Precipitation Accumulation + +Author: Joe O'Brien + +""" + +from arm_test_data import DATASETS +import numpy as np +from matplotlib.dates import DateFormatter +from matplotlib.dates import num2date +import matplotlib.pyplot as plt + +import act + +# Read the MET data into an xarray dataset +filename_met = DATASETS.fetch('gucmetM1.b1.20230301.000000.cdf') +ds = act.io.read_arm_netcdf(filename_met) + +# Decode the Present Weather Codes +# Pass it to the function to decode it along with the variable name +ds = act.utils.inst_utils.decode_present_weather(ds, + variable='pwd_pw_code_inst') + +# Calculate Precipitation Accumulation +pre_accum = act.utils.accumulate_precip(ds.where(ds.qc_tbrg_precip_total == 0), + "tbrg_precip_total").tbrg_precip_total_accumulated.compute() + +# Add the Precipitation Accum to the MET DataSet +ds['tbrg_accum'] = pre_accum + +# Create a matplotlib figure +fig, ax = plt.subplots(1, 1, figsize=(10, 10)) +# Adjust subplot width +fig.subplots_adjust(hspace=0.09) + +# Create ACT display +display = act.plotting.TimeSeriesDisplay(ds) + +# Define the Date/Time Format +date_form = DateFormatter("%H%M UTC") + +# Assign the ACT display object to the matplotlib figure subplot +display.assign_to_figure_axis(fig, ax) +# Datastream Names are needed for plotting! +display.plot('tbrg_accum', + label='TBRG Accumualated Precip') + +# Add a day/night background +display.day_night_background() + +# Update axe information and formatting! +ax.set_ylabel('Precipitation Accumulation [mm]') +# Add a title +ax.set_title('MET Tipping Bucket Rain Gauge - Crested Butte, CO') +# Define the x-axis format +ax.xaxis.set_major_formatter(date_form) +# Define the x-axis label +ax.set_xlabel('Time [UTC]') +# Gridlines are helpful +ax.grid(True) + +# Grab the X-ticks (and convert to datetime objects) to plot location of PWD codes +xticks = display.axes[0].get_xticks() +ndates = [num2date(x) for x in xticks] + +# Grab the PWD codes associated with those ticks +ncode = [ds['pwd_pw_code_inst_decoded'].sel(time=x.replace(tzinfo=None), method='nearest').data.tolist() for x in ndates] +pwd_code = ['\n'.join(x.split(' ')) if len(x) > 20 else x for x in ncode] + +# Display these select PWD codes as vertical texts along the x-axis +# Define the minimum y-axis tick mark for plotting +ymin = display.axes[0].get_yticks()[0] + +# Plot the PWD code +for i, key in enumerate(xticks): + ax.text(key, + ymin, + pwd_code[i], + rotation=90, + va='center') + +plt.subplots_adjust(bottom=0.20) + +plt.show() diff --git a/examples/plotting/plot_qc.py b/examples/plotting/plot_qc.py new file mode 100644 index 0000000000..34d0caae4b --- /dev/null +++ b/examples/plotting/plot_qc.py @@ -0,0 +1,35 @@ +""" +Plotting QC Flags +----------------- + +Simple example for cleaning up a dataset and +plotting the data and its QC flags + +Author: Adam Theisen +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt + +import act + +# Read in sample MET data +filename_met = DATASETS.fetch('sgpmetE13.b1.20190101.000000.cdf') +ds = act.io.arm.read_arm_netcdf(filename_met) + +# In order to utilize all the ACT QC modules and plot the QC, +# we need to clean up the dataset to follow CF standards +ds.clean.cleanup() + + +# Plot data +# Creat Plot Display +variable = 'temp_mean' +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot temperature data in top plot +display.plot(variable, subplot_index=(0,)) + +# Plot QC data +display.qc_flag_block_plot(variable, subplot_index=(1,)) +plt.show() diff --git a/examples/plotting/plot_rh_timeseries.py b/examples/plotting/plot_rh_timeseries.py new file mode 100644 index 0000000000..b4c7d65a2d --- /dev/null +++ b/examples/plotting/plot_rh_timeseries.py @@ -0,0 +1,48 @@ +""" +Plot winds and relative humidity from sounding data +--------------------------------------------------- + +This is an example of how to display wind rose and barb timeseries +from multiple days worth of sounding data. + +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt + +import act + +# Read in sonde files +twp_sonde_wildcard_list = ['twpsondewnpnC3.b1.20060119.050300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', + 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', + 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', + 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', + 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', + 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', + 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', + 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', + 'twpsondewnpnC3.b1.20060124.231500.custom.cdf'] +sonde_filenames = [DATASETS.fetch(file) for file in twp_sonde_wildcard_list] +sonde_ds = act.io.arm.read_arm_netcdf(sonde_filenames) + +BarbDisplay = act.plotting.TimeSeriesDisplay({'sonde_darwin': sonde_ds}, figsize=(10, 5)) +BarbDisplay.plot_time_height_xsection_from_1d_data( + 'rh', 'pres', cmap='YlGn', vmin=0, vmax=100, num_time_periods=25 +) +BarbDisplay.plot_barbs_from_spd_dir('wspd', 'deg', 'pres', num_barbs_x=20) +plt.show() diff --git a/examples/plotting/plot_scatter.py b/examples/plotting/plot_scatter.py new file mode 100644 index 0000000000..dd9202f05d --- /dev/null +++ b/examples/plotting/plot_scatter.py @@ -0,0 +1,84 @@ +""" +Compare Aircraft Airspeeds +-------------------------- + +Compare Aircraft Airspeeds via the DistributionDisplay +Scatter Plot + +Written: Joe O'Brien + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import numpy as np +from scipy.stats.mstats import pearsonr + +import act +from act.io.icartt import read_icartt + +# Call the read_icartt function, which supports input +# for ICARTT (v2.0) formatted files. +# Example file is ARM Aerial Facility Navigation Data +filename_icartt = DATASETS.fetch('AAFNAV_COR_20181104_R0.ict') +ds = read_icartt(filename_icartt) + +# Create a DistributionDisplay object to compare fields +display = act.plotting.DistributionDisplay(ds) + +# Compare aircraft ground speed with indicated airspeed +display.plot_scatter('true_airspeed', + 'ground_speed', + m_field='ambient_temp', + marker='x', + cbar_label='Ambient Temperature ($^\circ$C)' + ) + +# Set the range of the field on the x-axis +display.set_xrng((40, 140)) +display.set_yrng((40, 140)) + +# Determine the best fit line +z = np.ma.polyfit(ds['true_airspeed'], + ds['ground_speed'], + 1 + ) +p = np.poly1d(z) + +# Plot the best fit line +display.axes[0].plot(ds['true_airspeed'], + p(ds['true_airspeed']), + 'r', + linewidth=2 + ) + +# Display the line equation +display.axes[0].text(45, + 135, + "y = %.3fx + (%.3f)" % (z[0], z[1]), + color='r', + fontsize=12 + ) + +# Calculate Pearson Correlation Coefficient +cc_conc = pearsonr(ds['true_airspeed'], + ds['ground_speed'] + ) + +# Display the Pearson CC +display.axes[0].text(45, + 130, + "Pearson CC: %.2f" % (cc_conc[0]), + fontsize=12 + ) + +# Display the total number of samples +display.axes[0].text(45, + 125, + "N = %.0f" % (ds['true_airspeed'].data.shape[0]), + fontsize=12 + ) + +# Display the 1:1 ratio line +display.set_ratio_line() +plt.show() diff --git a/examples/plotting/plot_secondary_y.py b/examples/plotting/plot_secondary_y.py new file mode 100644 index 0000000000..d6062857e9 --- /dev/null +++ b/examples/plotting/plot_secondary_y.py @@ -0,0 +1,41 @@ +""" +Secondary Y-Axis Plotting +------------------------- + +This example shows how to plot on the secondary y-axis +using Matplotlib functionality. The secondary_y functionality has been removed from ACT. + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import xarray as xr + +import act + +# Read in the data from a MET file +filename_met = DATASETS.fetch('sgpmetE13.b1.20190101.000000.cdf') +ds = act.io.arm.read_arm_netcdf(filename_met) + +# Plot temperature and relative humidity with RH on the right axis +display = act.plotting.TimeSeriesDisplay(ds, figsize=(10, 6)) + +# Plot the data and make the y-axes color match the lines +display.plot('temp_mean', match_line_label_color=True) +display.day_night_background() + +# Get the secondary y-axes and plot the RH on it +ax2 = display.axes[0].twinx() +ax2.plot(ds['time'], ds['rh_mean'], color='orange') + +# Then the axes can be updated and modified through the normal matplotlib calls. +display.axes[0].set_yticks([-5, 0, 5]) +display.axes[0].set_yticklabels(["That's cold", "Freezing", "Above Freezing"]) + +# Secondary y-axis will use the ax2 axes +ax2.set_yticks([65, 75, 85]) +ax2.set_yticklabels(['Not as humid', 'Slightly Humid', 'Humid']) +ax2.set_ylabel('Relative Humidity (%)', color='orange') + +plt.tight_layout() +plt.show() diff --git a/examples/plotting/plot_size_distribution.py b/examples/plotting/plot_size_distribution.py new file mode 100644 index 0000000000..01b6f84d26 --- /dev/null +++ b/examples/plotting/plot_size_distribution.py @@ -0,0 +1,38 @@ +""" +Example Size Distribution Plots +------------------------------- + +Example shows how to plot up CCN droplet count +in a size distribution plot. Also shows how to +add different plot types together using +assign_to_figure_axis. + +Author: Adam Theisen + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import numpy as np + +import act + +# Read CCN data in from the test data area +filename_ccn = DATASETS.fetch('sgpaosccn2colaE13.b1.20170903.000000.nc') +ds = act.io.arm.read_arm_netcdf(filename_ccn) + +# Create a DistributionDisplay object +display = act.plotting.DistributionDisplay(ds, subplot_shape=(2,), figsize=(12, 10)) + +# Create a size distribution plot while plotting the +# size distribution in the second plot +t_ind = np.datetime64('2017-09-03T15:47:31') +display.plot_size_distribution('N_CCN_dN', 'droplet_size', time=t_ind, subplot_index=(0,)) + +# This part shows how you can use different display types in a single plot +# by assigning the new display object to a figure and axes from the first one. +display2 = act.plotting.TimeSeriesDisplay(ds) +display2.assign_to_figure_axis(display.fig, display.axes[1]) +display2.plot('N_CCN_dN') + +plt.show() diff --git a/examples/plotting/plot_skewt.py b/examples/plotting/plot_skewt.py new file mode 100644 index 0000000000..69c3674da8 --- /dev/null +++ b/examples/plotting/plot_skewt.py @@ -0,0 +1,43 @@ +""" +Skew-T plot of a sounding +------------------------- + +This example shows how to make a Skew-T plot from a sounding +and calculate stability indicies. + +""" + +from arm_test_data import DATASETS +import metpy +import xarray as xr +from matplotlib import pyplot as plt + +import act + +# Make sure attributes are retained +xr.set_options(keep_attrs=True) + +# Read data +filename_sonde = DATASETS.fetch('sgpsondewnpnC1.b1.20190101.053200.cdf') +sonde_ds = act.io.arm.read_arm_netcdf(filename_sonde) + +print(list(sonde_ds)) +# Calculate stability indicies +sonde_ds = act.retrievals.calculate_stability_indicies( + sonde_ds, temp_name='tdry', td_name='dp', p_name='pres' +) +print(sonde_ds['lifted_index']) + +# Set up plot +skewt = act.plotting.SkewTDisplay(sonde_ds, figsize=(15, 10)) + +# Add data +skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp') + +plt.show() +# One could also add options like adiabats and mixing lines +skewt = act.plotting.SkewTDisplay(sonde_ds, figsize=(15, 10)) +skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp', plot_dry_adiabats=True, + plot_moist_adiabats=True, plot_mixing_lines=True) +plt.show() +sonde_ds.close() diff --git a/examples/plotting/plot_skewt_with_text.py b/examples/plotting/plot_skewt_with_text.py new file mode 100644 index 0000000000..d37bd8d483 --- /dev/null +++ b/examples/plotting/plot_skewt_with_text.py @@ -0,0 +1,72 @@ +""" +Skew-T plot of a sounding +------------------------- + +This example shows how to make a Skew-T plot from a sounding +and calculate stability indicies. + +Author: Maxwell Grover + +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt +import metpy +import numpy as np +import xarray as xr + +import act + +# Make sure attributes are retained +xr.set_options(keep_attrs=True) + +# Read data +filename_sonde = DATASETS.fetch('twpsondewnpnC3.b1.20060121.231600.custom.cdf') +sonde_ds = act.io.arm.read_arm_netcdf(filename_sonde) + + +# Calculate stability indicies +sonde_ds = act.retrievals.calculate_stability_indicies( + sonde_ds, temp_name='tdry', td_name='dp', p_name='pres' +) + +# Plot the stability index values on the plot +variables = [ + 'lifted_index', + 'surface_based_cape', + 'surface_based_cin', + 'most_unstable_cape', + 'most_unstable_cin', + 'lifted_condensation_level_temperature', + 'lifted_condensation_level_pressure', +] + + +# Add a helper function which will format the text +def format_variable(variable, rounding_digits=2): + """Format a sounding variable to displayed on a single line""" + return f'{variable}: {np.round(sonde_ds[variable], rounding_digits).values} {sonde_ds[variable].units}' + + +# Setup the plot +skewt = act.plotting.SkewTDisplay(sonde_ds, figsize=(12, 8)) + +# Add the stability indices +ax = skewt.axes[0] +props = dict(boxstyle='round', facecolor='wheat', alpha=0.5) +for i in range(len(variables)): + ax.text( + 0.05, + (0.98 - (0.05 * i)), + format_variable(variables[i]), + transform=ax.transAxes, + fontsize=10, + verticalalignment='top', + bbox=props, + ) + +# Add data +skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp', shade_cin=False) + +sonde_ds.close() +plt.show() diff --git a/examples/plotting/plot_sonde.py b/examples/plotting/plot_sonde.py new file mode 100644 index 0000000000..8b96227cfe --- /dev/null +++ b/examples/plotting/plot_sonde.py @@ -0,0 +1,26 @@ +""" +Plot a timeseries of sounding data +---------------------------------------------------- + +This is a simple example for how to plot a timeseries of sounding +data from the ARM SGP site. + +Author: Robert Jackson +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt + +import act + +filename_sonde = DATASETS.fetch('sgpsondewnpnC1.b1.20190101.053200.cdf') +sonde_ds = act.io.arm.read_arm_netcdf(filename_sonde) +print(sonde_ds) + +# Plot data +display = act.plotting.TimeSeriesDisplay(sonde_ds) +display.add_subplots((3,), figsize=(15, 10)) +display.plot('wspd', subplot_index=(0,)) +display.plot('tdry', subplot_index=(1,)) +display.plot('rh', subplot_index=(2,)) +plt.show() diff --git a/examples/plotting/plot_state_variable.py b/examples/plotting/plot_state_variable.py new file mode 100644 index 0000000000..62c65907bd --- /dev/null +++ b/examples/plotting/plot_state_variable.py @@ -0,0 +1,87 @@ +""" +Plotting state variables +------------------------ + +Simple examples for plotting state variable using flag_values +and flag_meanings. + +Author: Ken Kehoe + +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt + +from act.io.arm import read_arm_netcdf +from act.plotting import TimeSeriesDisplay + +# ---------------------------------------------------------------------- # +# This example will create a plot of the detection status time dimentioned +# varible and set the y axis to the string values defined in flag_meanings +# instead of plotting the flag values. +# ---------------------------------------------------------------------- # + +# Read in data to plot. Only read in the variables that will be used. +variable = 'detection_status' +filename_ceil = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') +ds = read_arm_netcdf(filename_ceil, keep_variables=[variable, 'lat', 'lon', 'alt']) + +# Clean up the variable attributes to match the needed internal standard. +# Setting override_cf_flag allows the flag_meanings to be rewritten using +# the better formatted attribute values to make the plot more pretty. +ds.clean.clean_arm_state_variables(variable, override_cf_flag=True) + +# Creat Plot Display by setting figure size and number of plots +display = TimeSeriesDisplay(ds, figsize=(12, 8), subplot_shape=(1,)) + +# Plot the variable and indicate the day/night background should be added +# to the plot. +# Since the string length for each value is long we can ask to wrap the +# text to make a better looking plot by setting the number of characters +# to keep per line with the value set to y_axis_flag_meanings. If the +# strings were short we can just use y_axis_flag_meanings=True. +display.plot(variable, day_night_background=True, y_axis_flag_meanings=18) + +# Display plot in a new window +plt.show() + +# ----------------------------------------------------------------------- # +# This example will plot the 2 dimentional state variable indicating +# the cloud type classificaiton. The plot will use the correct formatting +# for x and y axis, but will show a colorbar explaining color for each value. +# ----------------------------------------------------------------------- # +# Read in data to plot. Only read in the variables that will be used. +variable = 'cloud_phase_hsrl' +filename_cloud = DATASETS.fetch('nsacloudphaseC1.c1.20180601.000000.nc') +ds = read_arm_netcdf(filename_cloud) + +# Clean up the variable attributes to match the needed internal standard. +ds.clean.clean_arm_state_variables(variable, override_cf_flag=True) + +# Creat Plot Display by setting figure size and number of plots +display = TimeSeriesDisplay(ds, figsize=(12, 8), subplot_shape=(1,)) + +# We need to pass in a dictionary containing text and color information +# for each value in the data variable. We will need to define what +# color we want plotted for each value but use the flag_values and +# flag_meanings attribute to supply the other needed information. +y_axis_labels = {} +flag_colors = ['white', 'green', 'blue', 'red', 'cyan', 'orange', 'yellow', 'black', 'gray'] +for value, meaning, color in zip( + ds[variable].attrs['flag_values'], ds[variable].attrs['flag_meanings'], flag_colors +): + y_axis_labels[value] = {'text': meaning, 'color': color} + +# Create plot and indicate the colorbar should use the defined colors +# by passing in dictionary to colorbar_lables. +# Also, since the test to display on the colorbar is longer than normal +# we can adjust the placement of the colorbar by indicating the adjustment +# of horizontal locaiton with cbar_h_adjust. +display.plot(variable, colorbar_labels=y_axis_labels, cbar_h_adjust=0) + +# To provide more room for colorbar and take up more of the defined +# figure, we can adjust the margins around the initial plot. +display.fig.subplots_adjust(left=0.08, right=0.88, bottom=0.1, top=0.94) + +# Display plot in a new window +plt.show() diff --git a/examples/plotting/plot_time_height_scatter.py b/examples/plotting/plot_time_height_scatter.py new file mode 100644 index 0000000000..950b36d998 --- /dev/null +++ b/examples/plotting/plot_time_height_scatter.py @@ -0,0 +1,25 @@ +""" +Time-Height Scatter Plot +------------------------ +This will show how to use the time-height scatter +plot function that's part of the TimeSeries Display. + +""" + +import os +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import act +from act.tests import sample_files + +# Read in radiosonde data +ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) + +# Create scatter plots of the sonde data +display = act.plotting.TimeSeriesDisplay(ds, figsize=(7, 6), subplot_shape=(2,)) +display.time_height_scatter('tdry', plot_alt_field=True, subplot_index=(0,)) +display.time_height_scatter('rh', subplot_index=(1,), cb_friendly=True, day_night_background=True) +plt.tight_layout() +ds.close() + +plt.show() diff --git a/examples/plotting/plot_violin.py b/examples/plotting/plot_violin.py new file mode 100644 index 0000000000..ce343c8078 --- /dev/null +++ b/examples/plotting/plot_violin.py @@ -0,0 +1,44 @@ +""" +Investigate Temperature Quantiles +--------------------------------- + +Investigate Temperature Quantiles +using DistributionDisplay Violin Plots + +Written: Joe O'Brien + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act +from act.io.icartt import read_icartt + +# Call the read_icartt function, which supports input +# for ICARTT (v2.0) formatted files. +# Example file is ARM Aerial Facility Navigation Data +filename_icartt = DATASETS.fetch('AAFNAV_COR_20181104_R0.ict') +ds = read_icartt(filename_icartt) + +# Create a DistributionDisplay object to compare fields +display = act.plotting.DistributionDisplay(ds) + +# Compare aircraft ground speed with ambient temperature +display.plot_violin('ambient_temp', + positions=[1.0], + ) + +display.plot_violin('total_temp', + positions=[2.0], + set_title='Aircraft Temperatures 2018-11-04', + ) + +# Update the tick information +display.axes[0].set_xticks([0.5, 1, 2, 2.5]) +ticks = ['', 'Ambient Air\nTemp', 'Total\nTemperature', ''] +display.axes[0].set_xticklabels(ticks) + +# Update the y-axis label +display.axes[0].set_ylabel('Temperature Observations [C]') +plt.show() diff --git a/examples/plotting/plot_wind_rose.py b/examples/plotting/plot_wind_rose.py new file mode 100644 index 0000000000..3e4eda965a --- /dev/null +++ b/examples/plotting/plot_wind_rose.py @@ -0,0 +1,56 @@ +""" +Windrose and windbarb timeseries plot +------------------------------------- + +This is an example of how to display wind rose and barb timeseries +from multiple days worth of sounding data. + +""" + +from arm_test_data import DATASETS +import numpy as np +from matplotlib import pyplot as plt + +import act + +# Read in sonde files +twp_sonde_wildcard_list = ['twpsondewnpnC3.b1.20060119.050300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', + 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', + 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', + 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', + 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', + 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', + 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', + 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', + 'twpsondewnpnC3.b1.20060124.231500.custom.cdf'] +sonde_filenames = [DATASETS.fetch(file) for file in twp_sonde_wildcard_list] +sonde_ds = act.io.arm.read_arm_netcdf(sonde_filenames) + +WindDisplay = act.plotting.WindRoseDisplay(sonde_ds, figsize=(8, 10), subplot_shape=(2,)) +WindDisplay.plot( + 'deg', 'wspd', spd_bins=np.linspace(0, 25, 5), num_dirs=30, tick_interval=2, subplot_index=(0,) +) + +BarbDisplay = act.plotting.TimeSeriesDisplay({'sonde_darwin': sonde_ds}, figsize=(10, 5)) +WindDisplay.put_display_in_subplot(BarbDisplay, subplot_index=(1,)) +BarbDisplay.plot_time_height_xsection_from_1d_data( + 'rh', 'pres', cmap='coolwarm_r', vmin=0, vmax=100, num_time_periods=25 +) + +BarbDisplay.plot_barbs_from_spd_dir('wspd', 'deg', 'pres', num_barbs_x=20) +plt.show() diff --git a/examples/plotting/plot_xsection.py b/examples/plotting/plot_xsection.py new file mode 100644 index 0000000000..126e3b9f84 --- /dev/null +++ b/examples/plotting/plot_xsection.py @@ -0,0 +1,66 @@ +""" +Multidimensional cross sections +------------------------------- + +In this example, the VISST data are used to +plot up cross-sectional slices through the +multi-dimensional dataset +""" + +from datetime import datetime + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import xarray as xr + +import act + +filename_visst = DATASETS.fetch('twpvisstgridirtemp.c1.20050705.002500.nc') +my_ds = act.io.arm.read_arm_netcdf(filename_visst) + +# Cross section display requires that the variable being plotted be reduced to two +# Dimensions whose coordinates can be specified by variables in the file +display = act.plotting.XSectionDisplay(my_ds, figsize=(20, 8), subplot_shape=(2, 2)) +display.plot_xsection_map( + None, + 'ir_temperature', + x='longitude', + y='latitude', + cmap='Greys', + vmin=200, + vmax=320, + subplot_index=(0, 0), +) +display.plot_xsection_map( + None, + 'ir_temperature', + x='longitude', + y='latitude', + cmap='Greys', + vmin=200, + vmax=320, + subplot_index=(1, 0), +) +display.plot_xsection_map( + None, + 'ir_temperature', + x='longitude', + y='latitude', + cmap='Greys', + vmin=200, + vmax=320, + subplot_index=(0, 1), +) +display.plot_xsection_map( + None, + 'ir_temperature', + x='longitude', + y='latitude', + cmap='Greys', + vmin=200, + vmax=320, + subplot_index=(1, 1), +) + +plt.show() +my_ds.close() diff --git a/examples/plotting/readme.txt b/examples/plotting/readme.txt new file mode 100644 index 0000000000..3630f89b7e --- /dev/null +++ b/examples/plotting/readme.txt @@ -0,0 +1,6 @@ +.. _plotting_examples: + +Plotting examples +-------------------------- + +Examples showing different ways to visualize your data. diff --git a/examples/qc/plot_arm_qc.py b/examples/qc/plot_arm_qc.py new file mode 100644 index 0000000000..d8abc6dd26 --- /dev/null +++ b/examples/qc/plot_arm_qc.py @@ -0,0 +1,167 @@ +""" +Working with and expanding embedded quality control variables +------------------------------------------------------------- + +This is an example of how to use existing or create new quality +control varibles and extend the quality control flagging. The +anicllary quality control variable can be expanded by integrating +external Data Quality Reports, adding additional generic ACT tests, +instrument specific ACT tests, or reading a configuraiton file of +known failures to clean up the data variable. + +""" + +import os + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +# Place your username and token here for use with ARM Live service +# https://adc.arm.gov/armlive/ +username = os.getenv('ARM_USERNAME') +token = os.getenv('ARM_PASSWORD') + +# We can use the ACT module for downloading data from the ARM web service +if username is None or token is None or len(username) == 0 or len(token) == 0: + results = DATASETS.fetch('sgpmfrsr7nchE11.b1.20210329.070000.nc') +else: + results = act.discovery.download_arm_data( + username, token, 'sgpmfrsr7nchE11.b1', '2021-03-29', '2021-03-29' + ) +print(results) + +# Let's plot up some data to see what we're working with. For this example, we'll use +# diffuse_hemisp_narrowband_filter4. The data files uses an ancillary quality control variable +# named with the same value prepened with 'qc_'. To read less data into memory we can tell +# the reader to only read in the variables we plan to use with the keep_variables keyword. +variable = 'diffuse_hemisp_narrowband_filter4' +qc_variable = 'qc_' + variable + +# Next up is to read the file into an xarray object using the ACT reader. We then can print out a +# listing of everything in the object. Also, call the cleanup method on the object by setting +# the cleanup_qc keyword. This will convert the quality control variable from the ARM stanard +# to Climate and Forecast standard used internally for all the quality control calls. +keep_vars = [variable, qc_variable, 'lat', 'lon'] +ds = act.io.arm.read_arm_netcdf(results, keep_variables=keep_vars, cleanup_qc=True) +print(ds) + +# Create a plotting display object with 2 plots +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot up the diffuse variable in the first plot +display.plot(variable, subplot_index=(0,), day_night_background=True) + +# Plot up the QC variable in the second plot +display.qc_flag_block_plot(variable, subplot_index=(1,)) + +plt.show() + +# Now lets remove some of these outliers by modifying the data in the Dataset based on +# the test results stored in the ancillary quality control variable. +# By default the ancillary quality control variable is removed after appying the test +# results, but we are going to use the del_qc_var to keep in Dataset so it +# can be used with additional tests later. +ds.qcfilter.datafilter(variable, rm_tests=[2, 3], del_qc_var=False) + +# Create a plotting display object with 2 plots +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot up the diffuse variable in the first plot +display.plot(variable, subplot_index=(0,), day_night_background=True) + +# Plot up the QC variable in the second plot +display.qc_flag_block_plot(variable, subplot_index=(1,)) + +plt.show() + +# Since the embedded QC is not removing all the outliers, let's check to see if there are any +# Data Quality Reports (DQR) using ARMs DQR Webservice. The great thing is, that ACT has codes +# for working with this webservice. +# In this example, we can see that there's a DQR for a shadowband misalignment and we can +# find out more information by looking at the actual DQR: +# https://adc.arm.gov/ArchiveServices/DQRService?dqrid=D210405.5 + +# Query the ARM DQR Webservice and update the ancillary quality control variable to +# contain a new test using information from the DQR. +ds = act.qc.arm.add_dqr_to_qc(ds, variable=variable) + +# Create a plotting display object with 2 plots +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot up the diffuse variable in the first plot +display.plot(variable, subplot_index=(0,), day_night_background=True) + +# Plot up the QC variable in the second plot +display.qc_flag_block_plot(variable, subplot_index=(1,)) + +plt.show() + +# ACT has a number of additional QC tests that could be applied to the data. For this next +# example, let's apply a new maximum test. We are also +# going to filter the data based on this new test and plot up the results. + +# Add a new maximum tests +ds.qcfilter.add_greater_test(variable, 0.4, test_meaning='New maximum tests limit') + +# Filter that test out +ds.qcfilter.datafilter(variable, rm_tests=5, del_qc_var=False) + +# Create a plotting display object with 2 plots +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot up the diffuse variable in the first plot +display.plot(variable, subplot_index=(0,), day_night_background=True) + +# Plot up the QC variable in the second plot +display.qc_flag_block_plot(variable, subplot_index=(1,)) + +plt.show() + +# ACT has a growing library of instrument specific tests such as the fast-fourier transform +# test to detect shading which was adapted from Alexandrov et al 2007. The adaption is that +# it is applied in a moving window style approach. + +# Apply test +ds = act.qc.fft_shading_test(ds, variable=variable) + +# Create a plotting display object with 2 plots +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot up the diffuse variable in the first plot +display.plot(variable, subplot_index=(0,), day_night_background=True) + +# Plot up the QC variable in the second plot +display.qc_flag_block_plot(variable, subplot_index=(1,)) + +plt.show() + +# The orginal embedded quality control variable plus additional tests we applied +# to the data did a good job removing incorrect data, but we can manually clean up the +# data a little more. By inspecting the data we can extract the time ranges where +# data is incorrect and create a new test using those time ranges. Instead of hardcoding +# those into the program we can write them to a YAML file for use in other programs or +# to give to other users. +# There is a file in the same directory called sgpmfrsr7nchE11.b1.yaml with times of +# incorrect or suspect values that can be read and applied to the Dataset. +from act.qc.add_supplemental_qc import apply_supplemental_qc + +apply_supplemental_qc(ds, 'sgpmfrsr7nchE11.b1.yaml') + +# We can apply or reapply the data filter on the variable in the Dataset to change +# the data values failing tests to NaN by passing a list of test numbers we want +# to use. In this case we are not going to apply the DQR test (number 4) so we leave +# that number out of the list. +ds.qcfilter.datafilter(variable, rm_tests=[2, 3, 5, 6, 7, 8], del_qc_var=False) + +# Create a plotting display object with 2 plots +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot up the diffuse variable in the first plot +display.plot(variable, subplot_index=(0,), day_night_background=True) + +# Plot up the QC variable in the second plot +display.qc_flag_block_plot(variable, subplot_index=(1,)) + +plt.show() diff --git a/examples/qc/plot_dqr_qc.py b/examples/qc/plot_dqr_qc.py new file mode 100644 index 0000000000..bc268b2149 --- /dev/null +++ b/examples/qc/plot_dqr_qc.py @@ -0,0 +1,38 @@ +""" +Query the ARM DQR webservice +---------------------------- + +Simple example for querying the ARM DQR webservice +and plotting up the results + +Author: Adam Theisen +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt + +import act + +# Read in sample AOSMET data +filename_aosmet = DATASETS.fetch('maraosmetM1.a1.20180201.000000.nc') +ds = act.io.arm.read_arm_netcdf(filename_aosmet) + +# Query DQR webservice for a specific variable +# As can be seen in the "Plotting QC Flags" example +# a call to obj.clean.cleanup() would normally be needed +# in order to plot up ARM's QC information. In this case +# the call to add DQRs to the QC automatically applies that +# cleanup so you don't have to. +variable = 'temperature_ambient' +ds = act.qc.arm.add_dqr_to_qc(ds, variable=variable) + +# Plot data +# Creat Plot Display +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot temperature data in top plot +display.plot(variable, subplot_index=(0,)) + +# Plot QC data +display.qc_flag_block_plot(variable, subplot_index=(1,)) +plt.show() diff --git a/examples/force_line_plot_qc.py b/examples/qc/plot_force_line_qc.py similarity index 76% rename from examples/force_line_plot_qc.py rename to examples/qc/plot_force_line_qc.py index a1b15ab601..1f804b4aec 100644 --- a/examples/force_line_plot_qc.py +++ b/examples/qc/plot_force_line_qc.py @@ -1,7 +1,6 @@ """ -=========================================================== -Example for working with embedded quality control variables -=========================================================== +Forcing line plots with 2D data and QC +----------------------------------------------------------- This is an example of how to use 2 dimentional DataArrays containing multiple 1 dimentional data, including a summary quality control @@ -14,23 +13,25 @@ """ +from arm_test_data import DATASETS import matplotlib.pyplot as plt -from act.io.armfiles import read_netcdf + +from act.io.arm import read_arm_netcdf from act.plotting import TimeSeriesDisplay -from act.tests import EXAMPLE_SURFSPECALB1MLAWER # Read a data file that has a 2D DataArray of multiple 1D data. # The corresponding quality control DataArray is also read in and # will be used to make a summary plot of quality control infomation # of each assessment category. -obj = read_netcdf(EXAMPLE_SURFSPECALB1MLAWER) +filename_surf = DATASETS.fetch('nsasurfspecalb1mlawerC1.c1.20160609.080000.nc') +ds = read_arm_netcdf(filename_surf) # The name of the data variable we wish to plot var_name = 'surface_albedo_mfr_narrowband_10m' # Create the ACT display object used for plotting. This will have two # vertical plots of 800 by 400 pixels. -display = TimeSeriesDisplay(obj, subplot_shape=(2, ), figsize=(8, 2 * 4)) +display = TimeSeriesDisplay(ds, subplot_shape=(2,), figsize=(8, 2 * 4)) # Create the top plot of data using the force_line_plot option. # This will force the plotting to not assume the data are 2D data that @@ -41,7 +42,7 @@ # Create the bottom plot of summarized quality control by assessment # cateory. -display.qc_flag_block_plot(var_name, subplot_index=(1, )) +display.qc_flag_block_plot(var_name, subplot_index=(1,)) # Show the plot in a new window. plt.show() diff --git a/examples/qc/plot_qc_bsrn.py b/examples/qc/plot_qc_bsrn.py new file mode 100644 index 0000000000..5cbae6e687 --- /dev/null +++ b/examples/qc/plot_qc_bsrn.py @@ -0,0 +1,77 @@ +""" +Plotting Baseline Surface Radiation Network (BSRN) QC Flags +----------------------------------------------------------- + +Simple example for applying BSRN QC and +plotting the data and the corresponding QC flags +using colorblind friendly colors. +https://bsrn.awi.de/data/quality-checks/ + +Author: Ken Kehoe + +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt + +import act + +# Read in data and convert from ARM QC standard to CF QC standard +filename_brs = DATASETS.fetch('sgpbrsC1.b1.20190705.000000.cdf') +ds = act.io.arm.read_arm_netcdf(filename_brs, cleanup_qc=True) + +# Creat Plot Display and plot data including embedded QC from data file +variable = 'down_short_hemisp' +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot radiation data in top plot +display.plot(variable, subplot_index=(0,), day_night_background=True, cb_friendly=True) + +# Plot ancillary QC data in bottom plot +display.qc_flag_block_plot(variable, subplot_index=(1,), cb_friendly=True) +plt.show() + +# Add initial BSRN QC tests to ancillary QC varialbles. Use defualts for +# test set to Physicall Possible and use_dask. +ds.qcfilter.bsrn_limits_test( + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', + glb_SW_up_name='up_short_hemisp', + glb_LW_dn_name='down_long_hemisp_shaded', + glb_LW_up_name='up_long_hemisp', +) + +# Add initial BSRN QC tests to ancillary QC varialbles. Use defualts for +# test set to Extremely Rare" and to use Dask processing. +ds.qcfilter.bsrn_limits_test( + test='Extremely Rare', + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', + glb_SW_up_name='up_short_hemisp', + glb_LW_dn_name='down_long_hemisp_shaded', + glb_LW_up_name='up_long_hemisp', + use_dask=True, +) + +# Add comparison BSRN QC tests to ancillary QC varialbles. Request two of the possible +# comparison tests. +ds.qcfilter.bsrn_comparison_tests( + ['Global over Sum SW Ratio', 'Diffuse Ratio'], + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', +) + +# Creat Plot Display and plot data including embedded QC from data file +variable = 'down_short_hemisp' +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) + +# Plot radiation data in top plot. Add QC information to top plot. +display.plot(variable, subplot_index=(0,), day_night_background=True, assessment_overplot=True, + cb_friendly=True) + +# Plot ancillary QC data in bottom plot +display.qc_flag_block_plot(variable, subplot_index=(1,), cb_friendly=True) +plt.show() diff --git a/examples/qc_example.py b/examples/qc/plot_qc_example.py similarity index 70% rename from examples/qc_example.py rename to examples/qc/plot_qc_example.py index 19c29b8c87..69513083c5 100644 --- a/examples/qc_example.py +++ b/examples/qc/plot_qc_example.py @@ -1,7 +1,6 @@ """ -=========================================================== -Example for working with embedded quality control variables -=========================================================== +Working with embedded quality control variables +----------------------------------------------- This is an example of how to use existing or create new quality control varibles. All the tests are located in act/qc/qctests.py @@ -9,17 +8,18 @@ """ -from act.io.armfiles import read_netcdf -from act.tests import EXAMPLE_IRT25m20s -from act.qc.qcfilter import parse_bit +from arm_test_data import DATASETS import numpy as np +from act.io.arm import read_arm_netcdf +from act.qc.qcfilter import parse_bit # Read a data file that does not have any embedded quality control # variables. This data comes from the example dataset within ACT. # Can also read data that has existing quality control variables # and add, manipulate or use those variables the same. -ds_object = read_netcdf(EXAMPLE_IRT25m20s) +filename_irt = DATASETS.fetch('sgpirt25m20sC1.a0.20190601.000000.cdf') +ds = read_arm_netcdf(filename_irt) # The name of the data variable we wish to work with var_name = 'inst_up_long_dome_resist' @@ -29,14 +29,14 @@ # We can start with adding where the data are set to missing value. # First we will change the first value to NaN to simulate where # a missing value exist in the data file. -data = ds_object[var_name].values +data = ds[var_name].values data[0] = np.nan -ds_object[var_name].values = data +ds[var_name].values = data # Add a test for where the data are set to missing value. # Since a quality control variable does not exist in the file # one will be created as part of adding this test. -result = ds_object.qcfilter.add_missing_value_test(var_name) +result = ds.qcfilter.add_missing_value_test(var_name) # The returned dictionary will contain the information added to the # quality control varible for direct use now. Or the information @@ -44,29 +44,26 @@ print('\nresult =', result) # We can add a second test where data is less than a specified value. -result = ds_object.qcfilter.add_less_test(var_name, 7.8) +result = ds.qcfilter.add_less_test(var_name, 7.8) # Next we add a test to indicate where a value is greater than # or equal to a specified number. We also set the assessement # to a user defined word. The default assessment is "Bad". -result = ds_object.qcfilter.add_greater_equal_test(var_name, 12, - test_assessment='Suspect') +result = ds.qcfilter.add_greater_equal_test(var_name, 12, test_assessment='Suspect') # We can now get the data as a numpy masked array with a mask set # where the third test we added (greater than or equal to) using # the result dictionary to get the test number created for us. -data = ds_object.qcfilter.get_masked_data(var_name, - rm_tests=result['test_number']) +data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) print('\nData type =', type(data)) # Or we can get the masked array for all tests that use the assessment # set to "Bad". -data = ds_object.qcfilter.get_masked_data(var_name, rm_assessments=['Bad']) +data = ds.qcfilter.get_masked_data(var_name, rm_assessments=['Bad']) # If we prefer to mask all data for both Bad or Suspect we can list # as many assessments as needed -data = ds_object.qcfilter.get_masked_data(var_name, - rm_assessments=['Suspect', 'Bad']) +data = ds.qcfilter.get_masked_data(var_name, rm_assessments=['Suspect', 'Bad']) print('\ndata =', data) # We can convert the masked array into numpy array and choose the fill value. @@ -78,38 +75,40 @@ # We can allow the method to pick the test number (next available) # or set the test number we wan to use. This example uses test number # 5 to demonstrate how not all tests need to be used in order. -data = ds_object.qcfilter.get_masked_data(var_name) +data = ds.qcfilter.get_masked_data(var_name) diff = np.diff(data) max_difference = 0.04 data = np.ma.masked_greater(diff, max_difference) index = np.where(data.mask is True)[0] -result = ds_object.qcfilter.add_test( - var_name, index=index, - test_meaning='Difference is greater than {}'.format(max_difference), +result = ds.qcfilter.add_test( + var_name, + index=index, + test_meaning=f'Difference is greater than {max_difference}', test_assessment='Suspect', - test_number=5) + test_number=5, +) # If we prefer to work with numpy arrays directly we can return the # data array converted to a numpy array with masked values set # to NaN. Here we are requesting both Suspect and Bad data be masked. -data = ds_object.qcfilter.get_masked_data(var_name, - rm_assessments=['Suspect', 'Bad'], - return_nan_array=True) +data = ds.qcfilter.get_masked_data( + var_name, rm_assessments=['Suspect', 'Bad'], return_nan_array=True +) print('\nData type =', type(data)) print('data =', data) # We can see how the quality control data is stored and what assessments, # or test descriptions are set. Some of the tests have also added attributes to # store the test limit values. -qc_varialbe = ds_object[result['qc_variable_name']] -print('\nQC Variable =', qc_varialbe) +qc_variable = ds[result['qc_variable_name']] +print('\nQC Variable =', qc_variable) # The test numbers are not the flag_masks numbers. The flag masks numbers # are bit-paked numbers used to store what bit is set. To see the test # numbers we can unpack the bits. print('\nmask : test') print('-' * 11) -for mask in qc_varialbe.attrs['flag_masks']: +for mask in qc_variable.attrs['flag_masks']: print(mask, ' : ', parse_bit(mask)) # We can also just use the get_masked_data() method to get data @@ -117,14 +116,14 @@ # request any tests or assessments to mask the returned masked array # will not have any mask set. The returned value is a numpy masked array # where the raw numpy array is accessable with .data property. -data = ds_object.qcfilter.get_masked_data(var_name) +data = ds.qcfilter.get_masked_data(var_name) print('\nNormal numpy array data values:', data.data) print('Mask associated with values:', data.mask) # We can use the get_masked_data() method to return a masked array # where the test is set in the quality control varialbe, and use the # masked array method to see if any of the values have the test set. -data = ds_object.qcfilter.get_masked_data(var_name, rm_tests=3) +data = ds.qcfilter.get_masked_data(var_name, rm_tests=3) print('\nAt least one less than test set =', data.mask.any()) -data = ds_object.qcfilter.get_masked_data(var_name, rm_tests=4) +data = ds.qcfilter.get_masked_data(var_name, rm_tests=4) print('At least one difference test set =', data.mask.any()) diff --git a/examples/qc/readme.txt b/examples/qc/readme.txt new file mode 100644 index 0000000000..cac283dd5e --- /dev/null +++ b/examples/qc/readme.txt @@ -0,0 +1,6 @@ +.. _qc_examples: + +Quality Control Examples +-------------------------- + +Examples showing different ways to apply quality control to your data. diff --git a/examples/qc/sgpmfrsr7nchE11.b1.yaml b/examples/qc/sgpmfrsr7nchE11.b1.yaml new file mode 100644 index 0000000000..a586393af6 --- /dev/null +++ b/examples/qc/sgpmfrsr7nchE11.b1.yaml @@ -0,0 +1,21 @@ + # This is a YAML file containing time ranges associated with + # the variable we want to flag in the ancillary quality control + # varible. + +diffuse_hemisp_narrowband_filter4: + Incorrect: + Values are incorrect by visual inspection: + - 2021-03-29 17:26:40, 2021-03-29 17:39:20 + - 2021-03-29 18:00:40, 2021-03-29 18:00:40 + - 2021-03-29 18:18:40, 2021-03-29 18:18:40 + - 2021-03-29 20:22:40, 2021-03-29 20:22:40 + - 2021-03-29 21:32, 2021-03-29 21:32 + Suspect: + Values are suspect by visual inspection: + - 2021-03-29 18:34:40, 2021-03-29 18:34:40 + - 2021-03-29 18:38:20, 2021-03-29 18:38:40 + - 2021-03-29 17:57:20, 2021-03-29 18:00:20 + - 2021-03-29 18:01:00, 2021-03-29 18:04:40 + - 2021-03-29 18:05:20, 2021-03-29 18:07:40 + - 2021-03-29 18:11:20, 2021-03-29 18:13:00 + - 2021-03-29 18:19:00, 2021-03-29 18:20:40 diff --git a/examples/retrievals/plot_cbh_sobel.py b/examples/retrievals/plot_cbh_sobel.py new file mode 100644 index 0000000000..100c2e9f25 --- /dev/null +++ b/examples/retrievals/plot_cbh_sobel.py @@ -0,0 +1,40 @@ +""" +Cloud Base Height Retrievals +---------------------------- + +This example shows how to calculate the cloud base heights +using the sobel edge detection method. This can be used +for vertical radar and lidar data. + +Author: Adam Theisen + +""" + +from arm_test_data import DATASETS +from matplotlib import pyplot as plt +import act +import numpy as np + +# Read Ceilometer data for an example +filename_ceil = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') +ds = act.io.arm.read_arm_netcdf(filename_ceil) + +ds = act.retrievals.cbh.generic_sobel_cbh(ds, variable='backscatter', height_dim='range', + var_thresh=1000.0, fill_na=0.) + +# Plot the cloud base height data +display = act.plotting.TimeSeriesDisplay(ds, subplot_shape=(1, 2), figsize=(16, 6)) +display.plot('backscatter', subplot_index=(0, 0)) +title = 'SGP Ceilometer with Lidar-Calculated CBH Overplotted' +display.plot('first_cbh', subplot_index=(0, 0), color='k', set_title=title) + +display.plot('backscatter', subplot_index=(0, 1)) +title = 'SGP Ceilometer with CBH Overplotted' +display.plot('cbh_sobel_backscatter', color='k', subplot_index=(0, 1), set_title=title) + +diff = ds['first_cbh'].values - ds['cbh_sobel_backscatter'].values + +print("Average difference between ceilomter and sobel heights ", np.nanmean(diff)) + +ds.close() +plt.show() diff --git a/examples/retrievals/plot_get_stability_indices_example.py b/examples/retrievals/plot_get_stability_indices_example.py new file mode 100644 index 0000000000..2dbd028646 --- /dev/null +++ b/examples/retrievals/plot_get_stability_indices_example.py @@ -0,0 +1,41 @@ +""" +Retrieve stability indicies from a sounding +------------------------------------------------------------- + +This example shows how to retrieve CAPE, CIN, and lifted index +from a sounding. +""" + +import warnings + +from arm_test_data import DATASETS + +import act + +warnings.filterwarnings('ignore') + + +def print_summary(ds, variables): + for var_name in variables: + print(f'{var_name}: {ds[var_name].values} ' f"units={ds[var_name].attrs['units']}") + print() + + +filename_sonde = DATASETS.fetch('sgpsondewnpnC1.b1.20190101.053200.cdf') +sonde_ds = act.io.arm.read_arm_netcdf(filename_sonde) + +sonde_ds = act.retrievals.calculate_stability_indicies( + sonde_ds, temp_name='tdry', td_name='dp', p_name='pres' +) + +variables = [ + 'lifted_index', + 'surface_based_cape', + 'surface_based_cin', + 'most_unstable_cape', + 'most_unstable_cin', + 'lifted_condensation_level_temperature', + 'lifted_condensation_level_pressure', +] + +print_summary(sonde_ds, variables) diff --git a/examples/retrievals/readme.txt b/examples/retrievals/readme.txt new file mode 100644 index 0000000000..a2e8768e5f --- /dev/null +++ b/examples/retrievals/readme.txt @@ -0,0 +1,6 @@ +.. _retrieval_examples: + +Retrieval examples +-------------------------- + +Examples showing different ways to retrieve fields from data. diff --git a/examples/templates/example_template.py b/examples/templates/example_template.py new file mode 100644 index 0000000000..6119c56583 --- /dev/null +++ b/examples/templates/example_template.py @@ -0,0 +1,20 @@ +# Place python module imports here, example: +import os +import matplotlib.pyplot as plt +import act + +# Place arm username and token or example file if username and token +# aren't set, example: +username = os.getenv('ARM_USERNAME') +token = os.getenv('ARM_PASSWORD') + +# Download and read file or files with the IO and discovery functions +# within ACT, example: +results = act.discovery.download_arm_data( + username, token, 'sgpceilC1.b1', '2022-01-14', '2022-01-19') +ceil_ds = act.io.arm.read_arm_netcdf(results) + +# Plot file using the ACT display submodule, example: +display = act.plotting.TimeSeriesDisplay(ceil_ds) +display.plot('backscatter') +plt.show() diff --git a/examples/templates/notebook_and_blog_template.ipynb b/examples/templates/notebook_and_blog_template.ipynb new file mode 100644 index 0000000000..cefe371a3b --- /dev/null +++ b/examples/templates/notebook_and_blog_template.ipynb @@ -0,0 +1,518 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start here! If you can directly link to an image relevant to your notebook, such as [canonical logos](https://github.com/numpy/numpy/blob/main/doc/source/_static/numpylogo.svg), do so here at the top of your notebook. You can do this with Markdown syntax,\n", + "\n", + "> `![](http://link.com/to/image.png \"image alt text\")`\n", + "\n", + "or edit this cell to see raw HTML `img` demonstration. This is preferred if you need to shrink your embedded image. **Either way be sure to include `alt` text for any embedded images to make your content more accessible.**\n", + "\n", + "\"ARM" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ACT Tutorial Notebook and Blog Template\n", + "\n", + "This template is a starting point for those looking to contribute a tutorial notebook, example workflow and blog posts to ACT using Jupyter Notebooks.\n", + "\n", + "Next, title your notebook appropriately with a top-level Markdown header, `#`. Do not use this level header anywhere else in the notebook. Our book build process will use this title in the navbar, table of contents, etc. Keep it short, keep it descriptive. Follow this with a `---` cell to visually distinguish the transition to the prerequisites section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "If you have an introductory paragraph, lead with it here! Keep it short and tied to your material, then be sure to continue into the required list of topics below,\n", + "\n", + "1. This is a numbered list of the specific topics\n", + "1. These should map approximately to your main sections of content\n", + "1. Or each second-level, `##`, header in your notebook\n", + "1. Keep the size and scope of your notebook in check\n", + "1. And be sure to let the reader know up front the important concepts they'll be leaving with" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prerequisites\n", + "This section was inspired by [this template](https://github.com/alan-turing-institute/the-turing-way/blob/master/book/templates/chapter-template/chapter-landing-page.md) of the wonderful [The Turing Way](https://the-turing-way.netlify.app) Jupyter Book.\n", + "\n", + "Following your overview, tell your reader what concepts, packages, or other background information they'll **need** before learning your material or being able to use the code. Tie this explicitly with links to other pages here in Foundations or to relevant external resources. Remove this body text, then populate the Markdown table, denoted in this cell with `|` vertical brackets, below, and fill out the information following. In this table, lay out prerequisite concepts by explicitly linking to other Foundations material or external resources, or describe generally helpful concepts.\n", + "\n", + "Label the importance of each concept explicitly as **helpful/necessary**.\n", + "\n", + "| Concepts | Importance | Notes |\n", + "| --- | --- | --- |\n", + "| [Intro to Cartopy](https://foundations.projectpythia.org/core/cartopy/cartopy.html) | Necessary | |\n", + "| [Understanding of NetCDF](https://foundations.projectpythia.org/core/data-formats/netcdf-cf.html) | Helpful | Familiarity with metadata structure |\n", + "| Project management | Helpful | |\n", + "\n", + "- **Time to learn**: estimate in minutes. For a rough idea, use 5 mins per subsection, 10 if longer; add these up for a total. Safer to round up and overestimate.\n", + "- **System requirements**:\n", + " - Populate with any system, version, or non-Python software requirements if necessary\n", + " - Otherwise use the concepts table above and the Imports section below to describe required packages as necessary\n", + " - If no extra requirements, remove the **System requirements** point altogether" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports\n", + "Begin your body of content with another `---` divider before continuing into this section, then remove this body text and populate the following code cell with all necessary Python imports **up-front**:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from arm_test_data import DATASETS\n", + "import matplotlib.pyplot as plt\n", + "import xarray as xr\n", + "\n", + "import act" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using comments\n", + "\n", + "When creating these examples, it is good practive to include comments describing your code. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Creates a dictonary for datastreams used in plotting.\n", + "# For the template notebook, using fake datasets.\n", + "ds_psl = xr.Dataset()\n", + "ds_par = xr.Dataset()\n", + "data_dict = {\"NOAA Site KPS PSL Radar FMCW\": ds_psl, \"NOAA Site KPS Parsivel\": ds_par}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Access ARM Data\n", + "\n", + "For ACT, most of the data we use for examples, notebooks and blog post originate from the ARM Live API. In other cases, we use the data found at [ACT Sample Data](https://github.com/ARM-DOE/ACT/blob/main/act/tests/sample_files.py)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Use the ARM Live API to Download the Data, using ACT\n", + "\n", + "The Atmospheric Data Community Toolkit (ACT) has a helpful module to interface with the data server:\n", + "* [Download Data API](https://arm-doe.github.io/ACT/API/generated/act.discovery.download_data.html#act.discovery.download_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setup our Download Query\n", + "Before downloading our data, we need to make sure we have an ARM Data Account, and ARM Live token. Both of these can be found using this link:\n", + "- [ARM Live Signup](https://adc.arm.gov/armlive/livedata/home)\n", + "\n", + "Once you sign up, you will see your token. Copy and replace that where we have `arm_username` and `arm_password` below." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sherm\\AppData\\Local\\Temp\\ipykernel_11112\\3818944164.py:12: DeprecationWarning: act.discovery.get_armfiles.download_data will be retired in version 2.0.0. Please use act.discovery.get_arm.download_arm_data instead.\n", + " files = act.discovery.download_data(arm_username,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[DOWNLOADING] sgpceilC1.b1.20220106.000003.nc\n", + "[DOWNLOADING] sgpceilC1.b1.20220107.000000.nc\n", + "[DOWNLOADING] sgpceilC1.b1.20220102.000011.nc\n", + "[DOWNLOADING] sgpceilC1.b1.20220103.000009.nc\n", + "[DOWNLOADING] sgpceilC1.b1.20220104.000008.nc\n", + "[DOWNLOADING] sgpceilC1.b1.20220105.000006.nc\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Morris, V., Zhang, D., & Ermold, B. Ceilometer (CEIL). Atmospheric Radiation\n", + "Measurement (ARM) User Facility. https://doi.org/10.5439/1181954\n", + "\n" + ] + } + ], + "source": [ + "arm_username = os.getenv(\"ARM_USERNAME\")\n", + "arm_password = os.getenv(\"ARM_PASSWORD\")\n", + "\n", + "datastream = \"sgpceilC1.b1\"\n", + "\n", + "start_date = \"2022-01-01T12:00:00\"\n", + "end_date = \"2022-01-07T12:00:00\"\n", + "\n", + "files = act.discovery.download_data(arm_username,\n", + " arm_password,\n", + " datastream,\n", + " start_date,\n", + " end_date)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using sample data already within ACT\n", + "\n", + "To use sample data already within ACT, use for example:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<__array_function__ internals>:200: RuntimeWarning: invalid value encountered in cast\n" + ] + } + ], + "source": [ + "filename_sodar = DATASETS.fetch('sodar.20230404.mnd')\n", + "ds = act.io.read_mfas_sodar(act.tests.EXAMPLE_MFAS_SODAR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting data\n", + "\n", + "Who doesn't like nice plots? Many of our examples, blog posts and tutorial notebooks contain plots to show the data we are working with. Below is an example on how to plot the example sodar data above and showing it in our example." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABRQAAAHUCAYAAABLQaRPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddXTUWBuHn6m7UCqUQnF3lw93d4fFZXGXxd3dWdx1cZfiutji7lCh1L2dfH+EThk6bSel7bQlzzlz2kneJDczSebe331FIQiCgIyMjIyMjIyMjIyMjIyMjIyMjIyMFujpugEyMjIyMjIyMjIyMjIyMjIyMjIyaQdZUJSRkZGRkZGRkZGRkZGRkZGRkZHRGllQlJGRkZGRkZGRkZGRkZGRkZGRkdEaWVCUkZGRkZGRkZGRkZGRkZGRkZGR0RpZUJSRkZGRkZGRkZGRkZGRkZGRkZHRGllQlJGRkZGRkZGRkZGRkZGRkZGRkdEaWVCUkZGRkZGRkZGRkZGRkZGRkZGR0RpZUJSRkZGRkZGRkZGRkZGRkZGRkZHRGllQlJGRkZGRkZGRkZGRkZGRkZGRkdEaWVCUkZGRkQHgxo0bNGvWjKxZs2JsbIyjoyPly5dn2LBhanbZsmWjYcOGOmrlr/Hvv/+iUCiYPXt2rHVNmjRBoVCwevXqWOtq1KiBnZ0dgiDw9u1bFAoFGzduTNK2KRQKJk2aFK9N9LGjX4aGhtjZ2VG6dGmGDBnCo0ePYm1z/vx5FAoF58+fT9L2asP27dtZtGiRxnXanG96ZOPGjSgUCt6+fZug7cmTJ6lduzbOzs4YGxvj7OxM1apVmTVrVvI39BfJli0bXbp0SbL9rVixIlH3XEREBE5OTigUCvbu3avRZtKkSSgUChwcHAgICIi1XtMzT6FQ0L9/f8nt+ZGhQ4eiUCg07lub1/nz59WeCXHdT926dVPZ/ExERAQrV66kfPnyWFtbY2pqSv78+Rk9ejTe3t4a7VevXk3p0qXJkCEDZmZmuLq60qRJE/bv3/9Ln0dS8eXLF8aNG0f58uXJmDEjVlZWlCxZkjVr1hAVFRXLPjAwkMGDB+Ps7IyJiQnFihVj586dajZRUVEsWLCAunXr4uLigpmZmepz8vX1VbMNCgqibdu25M2bF0tLS8zNzSlYsCDTpk0jKCgo1vE9PT3p0qULGTNmxMzMjPLly3P27Nl4zzEkJIQ8efKgUCiYN29erPURERFMnjyZbNmyYWxsTL58+Vi6dGmCn13Hjh01XpMyMjIyMjKakAVFGRkZGRmOHj1KhQoV8Pf3Z86cOZw6dYrFixdTsWJFdu3apevmJRklSpTA2toaNzc3teVKpZJLly5hbm4ea114eDjXrl2jatWqKBQKMmXKxLVr12jQoEFKNl2NAQMGcO3aNS5cuMCWLVto2rQphw4domjRosydO1fNtkSJEly7do0SJUqkeDvjExSvXbtGjx49UrZBaYhVq1ZRt25drKysWLZsGSdPnmT27Nnkz58/TmEsPZNYQfHIkSN4eHgAsG7dunhtvby8mDNnTmKaJ5mIiAi2bt0KwIkTJ/j06ZNq3bVr19Re9evXx9TUNNbyH+9pS0tLNm7ciFKpVDtOYGAge/bswcrKKlYbgoODqVWrFgMGDKB48eLs2LGDY8eO0alTJ9asWUPx4sV59uyZ2jadOnViwIABVKtWja1bt3L48GHGjRuHgYEBJ0+eTMqPKNHcvn2bzZs3U6NGDTZv3sy+ffuoUqUKf/75Jz179oxl37x5czZt2sTEiRM5fvw4pUuXpl27dmzfvl1lExISwqRJk3B1dWXRokUcO3aMnj17smbNGipWrEhISIjKNiIiAkEQGDp0KPv27ePgwYO0aNGCKVOm0KRJE7Vjh4WFUaNGDc6ePcvixYs5ePAgjo6O1K1blwsXLsR5juPHj9coTkbTt29fZs6cSb9+/Th58iTNmjVj0KBBzJgxI85tjh49yoEDBzReKzIyMjIyMhoRZGRkZGR+eypXrizkzJlTiIiIiLUuKipK7b2rq6vQoEGDlGpaggQHB0uyb9SokWBhYaF2rnfu3BEAYfjw4YKjo6Oa/cWLFwVAWLp0aZK0Ny4AYeLEifHavHnzRgCEuXPnxloXHBws1K1bVwCEY8eOST5+UFCQ5G0SokGDBoKrq2uS7zcts2HDBgEQ3rx5E69d1qxZhcqVK2tc9/M9mRpxdXUVOnfunGT7K1iwoFClShXJ2zVo0EAwMjISatWqJejp6QkfPnyIZTNx4kQBEOrWrSuYm5sLX758UVuv6ZkHCP369ZPcnmj27NkjAEKDBg0EQJg+fXqctp07dxbMzc01rot+JvTo0UMAhFOnTqmtX7t2rWBqaip07NhR+Lnb36tXLwEQdu7cGWu/z549E6ytrYWCBQsKkZGRgiAIwuvXrwVAmDBhgsa2pJbr8tu3b0J4eHis5f369RMA4f3796plR48eFQBh+/btara1atUSnJ2dVeceGRkpfP36NdY+o7/HLVu2JNiukSNHCoDw6tUr1bLly5cLgHD16lXVsoiICKFAgQJCmTJlNO7nxo0bgpGRkerYP/8ePHz4UFAoFMKMGTPUlvfs2VMwNTUVvL29Y+3T19dXyJw5s7BgwYJU9xsvIyMjI5N6kT0UZWRkZGTw9vYmY8aMGBgYxFqnp6f5p+LEiROUKFECU1NT8uXLx/r162PZuLu707t3b1xcXDAyMiJ79uxMnjyZyMhINbvJkydTtmxZMmTIgJWVFSVKlGDdunUIgqBmFx16+M8//1C8eHFMTEyYPHmypHOtVq0agYGB/Pvvv6pl58+fx9nZmR49euDh4cHjx4/V1kVvB2gMeY4OmXz06BHt2rXD2toaR0dHunXrhp+fn9rx/f396dmzJ3Z2dlhYWFC3bl2eP38u6Rw0YWpqyrp16zA0NFTzUtQU8tylSxcsLCx48OABtWvXxtLSkho1agCiR+a0adPIly8fxsbG2Nvb07VrV7y8vGIdc/v27ZQvXx4LCwssLCwoVqyYygusatWqHD16lHfv3qmFaUajKUTz4cOHNGnSBFtbW1Xo4aZNm9Rsos9nx44djB07FmdnZ6ysrKhZs2YsbyopSL0Gtbn+r1+/TsWKFTExMcHZ2ZkxY8YQERGhVXu8vb3JlCmTxnU/35PR4berV68mT548GBsbU6BAgVhhm6D9PantdRAREcHIkSNxcnLCzMyM//3vf9y8eVOrcwTtPvds2bLx6NEjLly4oLqOsmXLluC+P3/+zIkTJ2jUqBEjRoxAqVTG6+U4bdo0IiMjUyQUf926dRgZGbFhwwayZMnChg0bYl1rUsibNy8VKlSIdR2uX7+e5s2bY21trbbc3d2d9evXU6dOHdq0aRNrf3ny5GHUqFE8evSIAwcOAKhCoLW9LjURGhrKmDFjyJ49O0ZGRmTOnJl+/frFChuWcp/9jK2tLYaGhrGWlylTBoCPHz+qlu3fvx8LCwtatWqlZtu1a1c+f/7MjRs3ANDX18fOzi7OfX748CHBdtnb2wOo/c7u37+fvHnzUr58edUyAwMDOnbsyM2bN9U8V0G8L7t160a/fv0oVaqUxuMcOHAAQRDo2rVrrHMKCQnhxIkTsbYZNmwYmTJlYuDAgQmeh4yMjIyMTDSyoCgjIyMjQ/ny5blx4wYDBw7kxo0bCYoe9+/fZ9iwYQwZMoSDBw9SpEgRunfvzsWLF1U27u7ulClThpMnTzJhwgSOHz9O9+7dmTlzZqyws7dv39K7d292797NP//8Q/PmzRkwYABTp06Ndew7d+4wYsQIBg4cyIkTJ2jRooWkc40WBn8MbXZzc6NKlSrkzZsXJycnNfHNzc0Ne3t7ChQokOC+W7RoQZ48edi3bx+jR49m+/btDBkyRLVeEASaNm3Kli1bGDZsGPv376dcuXLUq1dP0jnEhbOzMyVLluTq1auxBKKfCQ8Pp3HjxlSvXp2DBw8yefJklEolTZo0YdasWbRv356jR48ya9YsTp8+TdWqVdXC+iZMmECHDh1wdnZm48aN7N+/n86dO/Pu3TtADFGtWLEiTk5OamGacfHs2TMqVKjAo0ePWLJkCf/88w8FChSgS5cuGsNQ//rrL969e8fatWtZs2YNL168oFGjRhpzpGmDlGtQm+v/8ePH1KhRA19fXzZu3MiqVau4e/cu06ZN06o95cuXZ9++fUyaNIn79+8neF6HDh1iyZIlTJkyhb179+Lq6kq7du3UwqO1vSelXAc9e/Zk3rx5/PHHH6rQzubNm+Pj46PVeWrzue/fv58cOXJQvHhx1XWkTb6+jRs3EhUVRbdu3ahZsyaurq6sX78+TuHO1dWVvn37sm7duiQR+ePi48ePnDp1iiZNmmBvb0/nzp15+fKl2vWTGLp3786BAwdUn/2zZ8+4evUq3bt3j2Xr5uZGZGQkTZs2jXN/0etOnz4NQP78+bGxsWHy5MmsWbNGqzygPxL9/Js3bx6dOnXi6NGjDB06lE2bNlG9enXCwsLU7LW5z6Rw7tw5DAwMyJMnj2rZw4cPyZ8/f6zJtCJFiqjWJ7RPgIIFC2o838jISPz9/Tlx4gTz58+nXbt2ZM2aVe340cfSdPyf8+JOmTKFoKAgjc+lH/dpb2+Pk5OTVud05swZNm/ezNq1a9HX14/vdGVkZGRkZNTRmW+kjIyMjEyq4evXr8L//vc/ARAAwdDQUKhQoYIwc+ZMISAgQM3W1dVVMDExEd69e6daFhISImTIkEHo3bu3alnv3r0FCwsLNTtBEIR58+YJgPDo0SONbYmKihIiIiKEKVOmCHZ2doJSqVQ7tr6+vvDs2bNEn6tSqRQyZMgg1K5dW3U8GxsbYdWqVYIgCELr1q2Fli1bCoIgCGFhYYKpqanQunVr1fbRIYYbNmxQLYsOmZwzZ47asfr27SuYmJiozuH48eMCICxevFjNbvr06b8c8hxNmzZtBEDw8PAQBEEQ3NzcBEBwc3NT2XTu3FkAhPXr16ttu2PHDgEQ9u3bp7b81q1bAiCsWLFCEAQx9FFfX1/o0KFDvO2NL+T55/Nt27atYGxsrBaOKAiCUK9ePcHMzEzw9fVVO5/69eur2e3evVsAhGvXrsXbJm1I6BrU5vpv06aNYGpqKri7u6uWRUZGCvny5dMq5Pnly5dCoUKFVPekqampUKNGDWHZsmWxwjmj12s6Vq5cuVTLtL0ntb0Onjx5IgDCkCFD1Oy2bdsmAJJDnuP73KWGPCuVSiFXrlxC5syZVWGr0ffp2bNn1Wyjl3t5eQlfv34VrK2thRYtWqjWJ3XI85QpUwRAOHHihCAI4v2kUCiETp06abTXJuR57ty5QkBAgGBhYSEsW7ZMEARBGDFihJA9e3ZBqVSqwn2jmTVrllobNBESEiIAQr169VTLjh49KmTMmFF1XdrZ2QmtWrUSDh06lOB5nzhxQuNzcteuXQIgrFmzRrVM2/tMW06ePCno6enFulZz584t1KlTJ5b958+fBSBW2PCPfPz4UXB0dBRKlSqlMdw7+j6KfnXt2jVWWhFDQ0ON53P16tVYodh3794VDA0NVd9ZXL8HtWrVEvLmzauxzUZGRkKvXr1U7wMCAoRs2bIJY8aMUS2TQ55lZGRkZLRF9lCUkZGRkcHOzo5Lly5x69YtZs2aRZMmTXj+/DljxoyhcOHCfP36Vc2+WLFial4WJiYm5MmTR+WdBmIxhGrVquHs7ExkZKTqFe2N92PC+XPnzlGzZk2sra3R19fH0NCQCRMm4O3tjaenp9qxixQpouZhIhWFQkGVKlW4cuUKERER3Lt3D19fX6pWrQpAlSpVOH/+PIIgcP36dUJCQlRejQnRuHHjWG0NDQ1VnUO0V2SHDh3U7Nq3b5/o8/kZQULY5M/enUeOHMHGxoZGjRqpfWfFihVT89w8ffo0UVFR9OvXL8nafe7cOWrUqEGWLFnUlnfp0oXg4OBY3o2aPmtA7RqUenxtr0Ftrn83Nzdq1KiBo6Ojapm+vr7G8FJN5MyZk/v373PhwgUmT55MzZo1uXXrFv3796d8+fKEhoaq2cd1rJcvX6pCPLW9J7W9DuK6nlu3bq0xfYImpHzuUrhw4QIvX76kc+fOKq+rrl27olAo4g2btbOzY9SoUezbt08V7pqUCIKgCnOuVasWANmzZ6dq1ars27cPf3//RO87OnR3/fr1REZGsnnzZtU5/wo/bl+/fn3ev3/P/v37GT58OAULFuTAgQM0btw4warX0d58P1f/btWqFebm5rEqG2tzn2nDnTt3aN26NeXKlWPmzJnxnp+26759+0b9+vURBIFdu3ZpDPeuU6cOt27d4ty5c0yfPp19+/bRokWLWIVztDl+ZGQk3bp1o02bNtSpUydOe6nnNHr0aNU9JyMjIyMjIxVZUJSRkZGRUVGqVClGjRrFnj17+Pz5M0OGDOHt27exQk415ZIyNjZWC4X08PDg8OHDGBoaqr2iQ8OiRcqbN29Su3ZtAP7++2+uXLnCrVu3GDt2LIDaPiHu/F1SqFatGkFBQdy6dQs3NzccHR3JmzcvIAqKX79+5dGjRyrBRFtB8efPxdjYGIg5B29vbwwMDGLZ/Rya9iu8e/cOY2NjMmTIEK+dmZlZrGqeHh4e+Pr6YmRkFOt7c3d3V31n0Xn0XFxckqzdceUMdHZ2Vq3/kYQ+aylIvQa1uf69vb01fq9Svms9PT0qV67MhAkTOHToEJ8/f6ZNmzbcvn07ligW37GiPztt70ltr4Po/f58bE3XuCakfu5SiM7l2axZM3x9ffH19cXa2pr//e9/7Nu3L1bOvh8ZPHgwzs7OjBw5MtHHj4tz587x5s0bWrVqhb+/v6ptrVu3Jjg4mB07dvzS/rt3786dO3eYPn06Xl5escS7aKKFujdv3sS5r+h1P4v8pqamNG3alLlz56qE2wIFCrB8+fJYIbo/Ev38i84lGI1CocDJySnBexxi32cJcffuXWrVqkXu3Lk5duyY6jnx4zF+Pi6IgiGg8Tnq4+NDrVq1+PTpE6dPnyZHjhwaj21ra0upUqWoVq0af/31F2vWrOHQoUMcPHhQ8vEXLVrE69evmThxouqaiRafQ0ND8fX1VaVFiGufQUFBhIeHq/Z58+ZNVqxYwZw5c1T78PX1RalUEhkZia+vb6wwdBkZGRkZmR/RbvpYRkZGRua3w9DQkIkTJ7Jw4cIE80hpImPGjBQpUoTp06drXB8tFO3cuRNDQ0OOHDmCiYmJan10IYCf+VVvG4gRCM+fP8+1a9eoUqWKal2BAgXImDEjbm5unD9/nkyZMqnExl/Fzs6OyMhIvL291QbL7u7uSbL/T58+cfv2bapUqZKgh5imzzFjxozY2dlpTNoPYGlpCcQUF/j48WMssSGx2NnZ8eXLl1jLP3/+rGpbciH1GtQGOzs7jd/rr3zX5ubmjBkzhl27dsW6J+M7VvS1pu09qe11EL1fd3d3MmfOrFoffY0nRHJ87gB+fn7s27cPgNKlS2u02b59O3379tW4ztTUlEmTJtGrVy+OHj36S235mWihc8GCBSxYsEDj+t69eyd6/xUrViRv3rxMmTKFWrVqxXl/VqtWDQMDAw4cOECfPn002kR/D9GelHGRNWtWevXqxeDBg3n06JHGfIIQ8/zz8vJSExUFQcDd3T3O7yqx3L17V5U789SpU7EK0wAULlyYHTt2EBkZqfbMfPDgAQCFChVSs/fx8aFmzZq8efOGs2fPasx/GBfRBVx+zM9ZuHBh1bF+5OfjP3z4ED8/P3Lnzh3Ldvz48YwfP567d+9SrFgxChcuzM6dO3F3d1cT+3/e5+PHjxEEgWbNmsXa54cPH7C1tWXhwoUMHjxY63OUkZGRkfm9kD0UZWRkZGQ0CjkAT548AWKEBik0bNiQhw8fkjNnTkqVKhXrFb1PhUKBgYGBWjL4kJAQtmzZkogz0Y6CBQtib2/PuXPnuHTpkircObo9lStX5sSJE1y/fl1r70RtiN7Xtm3b1JZv3779l/cdEhJCjx49iIyMTLRnVcOGDfH29iYqKkrjdxYtrNauXRt9fX1WrlwZ7/6keBPVqFGDc+fOqQTEaDZv3oyZmRnlypVL1DlpQ3Jcg9WqVePs2bN4eHiolkVFRbFr1y6ttpd6T8Z1rJw5c6o8SbW9J7W9DqLvm5+v5927dydYFAikfe5SrqXt27cTEhLC1KlTcXNzi/XKmDFjgtWCu3XrRv78+Rk9enSsENXE4uPjw/79+6lYsaLGdnXo0IFbt24lagLnR8aNG0ejRo0YNmxYnDZOTk5069aNkydParwmnz9/zuzZsylYsKCqOEtAQACBgYEa96fNb0V0JfmtW7eqLd+3bx9BQUGq9UnBvXv3qFmzJi4uLpw+fRpbW1uNds2aNSMwMFAlQEezadMmnJ2dKVu2rGpZtJj4+vVrTp06RfHixSW1KdrjPVeuXGrHf/r0qVp4fWRkJFu3bqVs2bKqz3P06NGxrpdob9Y+ffrg5uam2m+TJk1QKBRs2rRJ7fgbN27E1NSUunXrAlC3bl2N16GjoyPlypXDzc2Nli1bSjpHGRkZGZnfC9lDUUZGRkaGOnXq4OLiQqNGjciXLx9KpZJ79+4xf/58LCwsGDRokOR9TpkyhdOnT1OhQgUGDhxI3rx5CQ0N5e3btxw7doxVq1bh4uJCgwYNWLBgAe3bt6dXr154e3szb968WKFpCTFp0iQmT56Mm5ubmkCoCYVCQdWqVdm7dy+CIKh5KIIY9jx48GAEQUhSQbF27dpUrlyZkSNHEhQURKlSpbhy5Ypk4er9+/dcv34dpVKJn58fd+/eZf369bx794758+erwkil0rZtW7Zt20b9+vUZNGgQZcqUwdDQkI8fP+Lm5kaTJk1o1qwZ2bJl46+//mLq1KmEhITQrl07rK2tefz4MV+/fmXy5MmA6H3zzz//sHLlSkqWLImenh6lSpXSeOyJEyeqcvxNmDCBDBkysG3bNo4ePcqcOXM0ehclxPnz56lWrRoTJ05k0qRJcdol1TX4I+PGjePQoUNUr16dCRMmYGZmxvLlywkKCtJq+4IFC1KjRg3q1atHzpw5CQ0N5caNG8yfPx9HR8dYlXszZsxI9erVGT9+PObm5qxYsYKnT5+yc+dOlY2296S210H+/Pnp2LEjixYtwtDQkJo1a/Lw4UPmzZsXK5xeE1I+92ivq127dpEjRw5MTEwoXLiwxv2uW7cOW1tbhg8frub5GM0ff/zBggULuH//PkWLFtW4D319fWbMmKHy3tLkifbq1Su1KtrRFChQQGNV+G3bthEaGsrAgQM1PqPs7OzYtm0b69atY+HChRrbpQ0dO3akY8eOCdotWLCAZ8+e0bFjRy5evEijRo0wNjbm+vXrzJs3D0tLS/bt26cSfJ89e0adOnVo27YtVapUIVOmTPj4+HD06FHWrFlD1apVqVChQpzHq1WrFnXq1GHUqFH4+/tTsWJF/vvvPyZOnEjx4sXp1KlTos/5R549e0bNmjUBmD59Oi9evODFixeq9Tlz5lR5SNarV49atWrx559/4u/vT65cudixYwcnTpxg69atqnMPCQmhTp063L17l0WLFhEZGcn169dV+7S3tydnzpwArF69mkuXLlG7dm2yZMlCUFAQly5dYunSpVSoUIEmTZqotuvWrRvLly+nVatWzJo1CwcHB1asWMGzZ884c+aMyi5fvnzky5dP7Tyjq2znzJlT7XoqWLAg3bt3Z+LEiejr61O6dGlOnTrFmjVrmDZtmirk2cnJSWOqBBMTE+zs7BL8HZWRkZGRkZGrPMvIyMjICLt27RLat28v5M6dW7CwsBAMDQ2FrFmzCp06dRIeP36sZhtXBcgqVarEqsLq5eUlDBw4UMiePbtgaGgoZMiQQShZsqQwduxYITAwUGW3fv16IW/evIKxsbGQI0cOYebMmcK6detiVcONr/rksGHDBIVCITx58kSrc16xYoUACPb29rHW3bt3T1WZ88WLF2rr4qvy7OXlpWa7YcOGWOfg6+srdOvWTbCxsRHMzMyEWrVqCU+fPpVU5Tn6pa+vL9ja2golS5YUBg8erLFydlxVnuOqGhsRESHMmzdPKFq0qGBiYiJYWFgI+fLlE3r37h3rs9i8ebNQunRplV3x4sXVPpdv374JLVu2FGxsbASFQqFWZVbT+T548EBo1KiRYG1tLRgZGQlFixZV29+P57Nnzx6Nn82P9ocPHxYAVQXv+PjVa1DT9X/lyhWhXLlygrGxseDk5CSMGDFCWLNmjVZVnlevXi00b95cyJEjh2BmZiYYGRkJOXPmFPr06SN8+PBBzZbvFYdXrFgh5MyZUzA0NBTy5csnbNu2LdZ+tb0ntb0OwsLChGHDhgkODg6CiYmJUK5cOeHatWuCq6urVlWetf3c3759K9SuXVuwtLQUgDirh9+/f18AhMGDB8d5zOj7bcCAAYIgxH3/CoIgVKhQQQA0VnmO6xXXfVysWDHBwcFBCAsLi7Nt5cqVEzJmzKhmo22V5/j4ucpzNOHh4cLy5cuFsmXLChYWFoKxsbGQN29eYeTIkcLXr1/VbH18fIRp06YJ1atXFzJnziwYGRkJ5ubmQrFixYRp06YJwcHB8bZBEMRKzaNGjRJcXV0FQ0NDIVOmTMKff/4p+Pj4qNlJuc9+Jvq5G9fr52dKQECAMHDgQMHJyUkwMjISihQpIuzYsUPN5udn78+vH6/1K1euCA0bNhScnZ0FIyMjwczMTChatKgwdepUISgoKFZ73d3dhT/++EPIkCGD6h46ffp0vOf4Y5s0fffh4eHCxIkThaxZswpGRkZCnjx5hCVLliS4T0GQqzzLyMjIyGiPQhAklIOUkZGRkZFJpZQpUwZXV1f27Nmj66bIpBJGjhzJjh07ePHihUZPtfSCQqGgX79+LFu2TNdNkZGRkZGRkZGR+U2QQ55lZGRkZNI8/v7+3L9/P1bOKJnfGzc3N8aPH5+uxUQZGRkZGRkZGRkZXSALijIyMjIyaR4rKyvCwsJ03QyZVMatW7d03QQZGRkZGRkZGRmZdIksKMrIyMjIyMjIpGHk7DUyMjIyMjIyMjIpjZ6uGyAjIyMjIyMjIyMjIyMjIyMjIyOTdpAFRRkZGRkZGRkZGRkZGRkZGRkZGRmtkQVFGRkZGRkZGRkZGRkZGRkZGRkZGa3ReQ7FT58+MWrUKI4fP05ISAh58uRh3bp1lCxZEhDzAk2ePJk1a9bg4+ND2bJlWb58OQULFlTtIywsjOHDh7Njxw5CQkKoUaMGK1aswMXFRas2KJVKPn/+jKWlJQqFIlnOU0ZGRkZGRkZGRkZGRkZGRkYm9SMIAgEBATg7O6OnJ90XLzQ0lPDw8EQd28jICBMTk0Rtm5LoVFD08fGhYsWKVKtWjePHj+Pg4MCrV6+wsbFR2cyZM4cFCxawceNG8uTJw7Rp06hVqxbPnj3D0tISgMGDB3P48GF27tyJnZ0dw4YNo2HDhty+fRt9ff0E2/H582eyZMmSXKcpIyMjIyMjIyMjIyMjIyMjI5PG+PDhg9bOatGEhoaSydQU30Qe08nJiTdv3qR6UVEh6LA04OjRo7ly5QqXLl3SuF4QBJydnRk8eDCjRo0CRG9ER0dHZs+eTe/evfHz88Pe3p4tW7bQpk0bIEYgPHbsGHXq1EmwHX5+ftjY2ND94BSMzGO+sAHFH0g6H+HqFkn2wRckmQMQ8VGaffgHafaBd6XZewRLsweQ6gMqVfVWSrTPUUviBj9RdK/fr+1ABoDnU60lb6OQeHFY/VFYkn3kl6fSDvADmUt9TfS2MjLHvk6XZL/ySm7Jx6ie94ske3uzMEn2rjYhkux/pJLVxERvKyMjkzw0Orhbkr2TtbRnQJUcHpLsn3lZSbJPDFVzeCXr/m1NpD1XAVyMpfUvlG+uSLKP/PRekv2n/pLMAfB7J80+6qf3bsBqICsw5/uytt//TgfqzRL/P30f5h2Fk3/Fv3/9DNLaA6BnI81ekbCPixrKRIyxonFtnLixSUREBKdPn2bz5s0cP348XtvWrVvzxx9/8L///U+O8EtDBAYGcuzYMfbu3cvJkyfjtdXX16dly5a0atWKqlWrYmhomEKt1Iy1tThW9PPz0/j+Rz5FSnswGXy6oXF5YGAUJSq8wtfXV3U8bfH398fa2pplgKmkLSEE6I94blZWyf9b9yvo1EPx0KFD1KlTh1atWnHhwgUyZ85M37596dmzJwBv3rzB3d2d2rVrq7YxNjamSpUqXL16ld69e3P79m0iIiLUbJydnSlUqBBXr17VKCiGhYURFhbzAx4QEACAkbkJxuYxX7ellZGk8xHMJZmjZyzNHiBCWpMIj+MbvuML3uFQy0F9uSDx98BMmjmQ+gRFi198Nqbmm9zLywsHBweCgoIwM0vMt5VyWCTifohLUFx+AVoWB8efvhpLS2m9uUj/xHeQUvN1kR4ICwujRIkSVKlShRUrVui6OUmOWVjsG0IQBOb32Y/7Wx/mneyuts4gEfe3iYW0GU9Tc2n3g7mV1KdxDPL9I/M7IAgCnTt3pmvXrlSrVk3XzUkQqc8Zwzj6xdfmbsSpeD6y1yynttzUUtozyTgk+b02zK0S0Tn5CaVSYF7fQ2TMbEW38erfs8THMACWxtIGA0oLaWF6kRLHM+Zx7H6dDzwOg9mOYPDTz0eEtEPEEhQbIAqK74FgICOwDugOjAVaf/9cH34EL39YdRpGNIp7//pSR/uA3g+3g18g7DsLW46CbyCcWAqOdur2UifBE/8L+mu/oW3btqVt27aq90qlkkuXLrFu3Tq2bIlxntm9eze7d8dMMty6dYtSpUol+rgyKYOVlRU9evSgR48eass/fvzIrl272LFjB7dv3wYgKiqKXbt2sWvXLpVd+/bt2bZtW4q2GcTfSwBLS8tY17em690/Utpz0sA//jHir4jmpiROM0kr6LQoy+vXr1m5ciW5c+fm5MmT9OnTh4EDB7J582YA3N3dAXB0dFTbztHRUbXO3d0dIyMjbG1t47T5mZkzZ2Jtba16/Y7hzr3uw5gnum6FTHKzb98+ALUfgvRORBQsPQ89U/63TiaF2LFjByYmJjx+/Ji7dyW6VadRXv33haaO07i0/xEv7n7WdXNkZGR+kbCwMPT09NiyZQsXL17UdXNShJBvfmyr2ZPXJ6/w7MA5XTcnRdg29xL1Ms7g7O6H7Fp4VdfNSXYEAdb6QMU3sN4XrodAZDLFws39/rfb97/2QPSI7p+b4t/xzcW/a86K/cOkIDwSDl+DViMhW0PxVbQtTPkb3nwGH3/RJr2gp6dHlSpV2Lx5M4IgqF537tyhX79+GBuLontoaKiOWyrzK7i4uDBs2DD+/fdf1XesVCq5c+cOw4cPJ3PmzAA6c1C5f/8+AM2aNQNQOYflyZNHZRPtJJbaUCTylVbQqaCoVCopUaIEM2bMoHjx4vTu3ZuePXuycuVKNbufFWFBEBJUieOzGTNmDH5+fqrXhw9iXHCAu88vnI2MTOojf/78ADx69EjHLUk5DL9PMD331G07ZJKeoKAg9PT0aN++PQBLly7l2rVrOm5V8iIIAmObbmZozbUAVG5eiIOe43XcKhkZmV/B19dXlROpWrVqTJyY/kP8X5+6yj+thwPgXKYQdZclEIOaxjm35yF1Mkxn80xRLG4/rCInv43VcauSD0GAv33gf29hg6+4rKEFXMoGJsk02sz7w//RvdwF3/+O2i62SaGIERX/WC79GIIAVx/Bn4shRyfxla8rDFoBtx7/0BZXmNYXHu6Gt0cgi2Pc+/xVPnhA9hbw9oesJfvcICjxWUYSRfHixVm2bBmhoaEIgsD//ve/lG2ATLKjUCgoXrw4c+fO5ePHjwiCwN9//62Ttuzfvx+A5s3FG/rcOXFSKlpg9Pb2xsrKigkTJuikffGR3gVFnYY8Z8qUiQIFCqgty58/v8qrysnJCRC9EDNlyqSy8fT0VHktOjk5ER4ejo+Pj5qXoqenJxUqVNB4XGNjY9Vsyo9cW3uMRjN7aNhCRiZtEn1//U6Cokz6ZPXq1fTp00f13t/fX1WYK73y6Pp7/mq8SfV+1fV+ZMqRiERPMjIyqYb379/j6uoKQJ8+fWJNoqc3BEHgaM/J+L39BEDVaQPIXK6IjluVfDy4+p7hDWPCQis1yc9f65qhp5f8w8N+nS6hVAqs3FY52Y8VjSDAmm+w6YcUZo0sYGRGSIFTZiPQBRgDHAKMgdrAKWDKPpjYEv6oDFP/gX9fg3cA2MXTdXj+EbacgW1n47axs4JONaF9U3DQwU/y1++f9cp/YHY/8f/hy2DlfjizJOXbIyOTEvzzzz8AqjR30QJjtKB4+PBhADJkkPvJKY1OBcWKFSvy7NkztWXPnz9XdbSyZ8+Ok5MTp0+fpnjx4gCEh4dz4cIFZs+eDUDJkiUxNDTk9OnTtG7dGoAvX77w8OFD5syZgxRenb//q6ckI5OqsLe3B2RBUSbt4uPjo9Y52LRpE3/88YcOW5T8REVFMbDKat49Ed1s63crRe9Z9XTcKhkZmV/l7t27lChRAoC5c+cyfPhwHbcoeQl0/8rBjmNU71sdWIyRRfrMJPXxpTfdy6xSvc9ewIFFp7pgYpZyRQxOHflAgH8E3l6h7D5VO+ENfgFBgDnrYPn2mGWNLWGEXcoIidFkAPIAz4FjQH2gH6KguPUyjG4CxoawtR90XA7lJ8DzheK2Hn6w+5po9y0w7mN0rAEdakDenzJk6dlqtk9uin2vwfbPhRhBEeDVJ920R0YmJXj48CEApqZiwtNoQbF06dJq75s2bZryjUuAxHgcpiUPRZ2GPA8ZMoTr168zY8YMXr58yfbt21mzZg39+olPR4VCweDBg5kxYwb79+/n4cOHdOnSBTMzM1XIm7W1Nd27d2fYsGGcPXuWu3fv0rFjRwoXLkzNmjUlt0lQxqTAnf9vMUnbKip1T9joB8xrSDIHwFBiukcjV2n2lhJz6TpJTNwMIDWVitQ0JFIv6pfHJG7wA6bFE79tShId1p+a0UvMtRTHxVHwu0NzULj6cr+19yTt3yBzgYSNNKBnJheUSApmz56tEhOtrKwIDg5O92Li8ePHMTAwUImJ6+4N0kpMHFRZekXyU08yS7L3DJJWnOCNT+KEg2PPnBK1nYxMaub48eMqMXHXrl1pUkzMaKl9jrQPR0+oxMRsNcvR4czfCYqJZ19Ku/fzO/hLsk8MZ146xLve92sQTbPOVYmJBoZ67Hw6iFWXe2olJn4LlV705UOYOFk8e+JdnPQ3ERoqJgd85t0OgItnv9CzzXmVvV7OKpL2b+CSLc51ggCz/gbXGjFiYodGYmjzKAleiTbZJTWJ+MolzPz+dxXiGEOBWB0VoNUi8W+hrOJfQYDcg8XX/ybCkhPqYmLd0rBtDLzaDK+3iK8pXWKLiQBKiZmy4uqzxkVc/eLojF6RceSENHS1kHYgmVTH+/fvUSgU+PvHPOPq16/Py5cvddiq1MH27eKD5+tXsdq9np448j906BAA2bJlA8A/SlofNNJFc2RrUiCHPCcjpUuXZv/+/YwZM4YpU6aQPXt2Fi1aRIcOHVQ2I0eOJCQkhL59++Lj40PZsmU5deqUWqjbwoULMTAwoHXr1oSEhFCjRg02btyIvr60iq4AV/+5R/baYg6IEZWe4B6h/fSTi8dRyJ5fa/vg808wyiWtfVFeoC+hYnnEGzDVpIlcEP/8vC7oLpgX1n7/vtfBLmEzNaTOXOpLHJMqJZaOcx4hzV4m+ZAqKsZVMa9aQXj0Ba5/glqFYpZbdZb2YxHl8VwWB3WAh4eHKuUFiGEO0SEN6ZXw8HCyZcvGly9iUqTqfWpQe0AdvAAvr4S3X3kxn+Rjls3hxZ2PUp/g2uNqG8gTT/n+kZFZu3YtPXv2BODSpUtpOtdYQqKiMkrJkQ7DCPURB8Itlw/EpURuIGExsmK2r5La8uqbOXbmYmL+l9df8vTCExqOiqeULxARJW3auYiTH6GRsbcJD41kdKONvLofk8hu6aU+mGfJTDAQLEHr/OQvrdRzfvtA3oQ6EWJgA0A2861c8h2OgaE+l3yHU8lmHof3vqN3j3uMXlYXF6OvkF30Ylg1/z/qN89O1uxxx/0a+b9C3y6b2jJBEJg25TXLlsRMUHfp6szMObn5NuECuEg6BYLugr2EPIORvvGvb+MBu3xglRWMyQSF2wGT4MknUTzUROnC0LkJ1K0EJnbSRTg9q4ySt5GC0v8r+nEeQlRBo8XDHFmDeP1eINLRnJTziZVJLqIjy8aOHcvSpUsBcVIqT548KJW/Uv877dKjRw/Wrl1Lhw4d1LSi+JAiKmYMegBWsR9KekQi+kDLxIVOPRQBGjZsyIMHDwgNDeXJkyeqDlc0CoWCSZMm8eXLF0JDQ7lw4QKFChVSszExMWHp0qV4e3sTHBzM4cOHE125+e6K7QkbycjIpGqqfxfK3eRK5mmOMWPGqMTE7NmzEx4enu7FxN27d2NsbKwSEz09Pak9oI6OWyUjI5MUjB07VtW3ffr0aZoWExPC//1n9tbvqRIT+7nN/y4mJj/nVp3h8uZLzKo5I1mPo1QKLPhzP62yzlSJiVP3deSg53iy5rVP1mP/TOcR5anRQpxMqmQzD6VSwMBQn/PewwA4uOE+y8a6qW0zffQtKubZzfs32lVDFQSBKZNe4ZTxgkpM7NrNGfevVZg9L0+K5IbUhkHfdYDj/lD5GfSepL4+hwtM6g8PDsH7c+Jr32JoXB2M0qACV7G06DTzxVMUl1o2EE/i5Pl0VF76N6Zu3boALFu2TG25ICRTyfQ0wN9//01QUBAVK1ZUW75hwwYdtUh70ruHos4FxdRGZEiYrpsgIyPzixT8Hsl57nH8djKph+jwjlmzZgFw+vRpXr9+jaFhGuzpa0lwcDAmJia0adMGgPnz5yMIgir3qYyMTNqmdevWzJghClweHh7kzZs3gS3SLo+2HuJET7ECfe6mNWh9ch2GJkYpdvyeG3oD4PvFlykVJyXLMXbNv0gzp2lc2Cfm8hqwuBEHPcdTpJLE+N0kZNrmJpSuJuY3qmg5B0EQMDYx4KzHEAC2LbrJ4hl3VfZLNlcVbfPsxv1zUJz7FQSByRNFIXH5UlFI7NZdFBJnzc2DQpH6hrtzv3tJWuhB/w5wbUeMeHh+M3RrDtbpJBq4VQMxROfACVFAbF5ffL/3mCwopgc03V/RuQLfvn2bwq1JPZiZmXH58mWCg4NVy7p166b6vNLzb2xqRhYUf8Amp5hgI9Bdi/gyGRmZVEv07/C3uPvKMloSFRVHkp4kpHfv3qpiXKVKlSIqKipROXCTipQ457Vr12Jubk5YmDiJ5evry9ChQ5P9uDIyMilD4cKF2bNnDwCBgYE4OMSfiy+5Wbt2LZ8/f07y/UZFRLKnXg8ebTkIQM2l4yn+Z/skP05CKBQKZj4UCzYG+wYzrvhfsWwub7nMxXXnJO/7/N4HNHGYyvbZYr6gVkP+x0HP8dRsV+yX2pxULDnSljxFRRe9ChaiqGhmYcSpT4MAmDfxDuuXiiGUzdrlZNYK0cOntOtOvn1VD0UXBIFJE17ilPECK5aJQmL3nplx/1qFmXNSp5AYTUULuJoPTuWBkd0hs4SQ6rRGverfBcQjooDokkkc0p+/mvz9F5mUIbrY7NWrVwGxkBfAuHHjdNam1IKpqSmCIBASEkL16tVVy589e8aaNWt02LLfE53mUExtFOnRkotjFvDf33uoML6vrpsjI5MkODk54e7urpNjv92dejueMgnz6dMnXFxcMDExISgoSJX4OKl49uwZ+fLF5P67evUq5cuXT9JjJAYDA/Gn0cfHBxsbmyTdt5+fn9o+161bR7du3ZL0GOmB4lv2aWXn7msqed8WJtIS7VqYSPf4uNupheRtZNIeX6M6xlomCAIOhjHpc9zD2hGi35uQKBDCg2PZx8crIY8k+xsfbTQuFwSBIT1Fga3VpKZUbFdWtS4gTIoXuHpe8W8v3nKm/1TxjZ6CFodWoW+ou6GFQqFg1qM5jC06hsjwSEYXHMnMh7NVItiRWWLS/i9PP9FmbqcE9/f29mvGd12hel+xcX6Gr2mRasJ8f2TT1S40y78S9/f+VLadxyXfEVjamHD0TX8aZF/GxKHXMbc0pE2XPHTomY/AwAimjbxJ0UzbePS1E5ZWhkwZcYO1ix+p9tmzd2amTs+VqkXE3xVzM/E7efY67nx6c+bMYdSoUb91mGxaZsaMGezevZvhw4dz9epVqlQRiytt27aNrVu36rh1ScOGd9Mk2Rd28AOgQ7nNtOhZlObdizL7SAnCw4rQMM9qfLxC6N27N71792bc4iq0610kOZotGbnK82+EXd4cAHy8fFvHLZGRSToKFiwIiB5QKYksJqZ9MmfOjIGBAaGhoejr66sqqv0qgiDQqlUrlZhYu3ZtlEplqhATAVq0EMUgW1tb7ty5k2T7nT9/vkpMNDU1JSgoSBYTf4HUKiaC9oKoTNpFk5gYHh6lEhNtbI3wjGiPvr7Y1daVmAii0NZnXVcA9kw6wMRKM1FGKSWKiercXblDJSYW6NiY1sfX6lRM/JHp92diYiU+H8YUihFUpt0Vw88fnrzP1v7r4tz+61svxhcZzrrvYqJrfgd2vx3NyLUtU6WYGM3+J39iam5IZISShjnE3GsZHMy5+aYtAMN7XuLI3jcA9B5SmCHjiwNQMOMWshqtV4mJPXuLHonTZuSWxcQ0SPT1fuLECQBVfmaZtEXOnDkBuHbtWqx16UEkTqyYGBmp5Pl/nvw9/apqnZGxAafe9eOq7xAq1hFTUEwbdIGCJkvZuvx+0jU6kcg5FH9TlFFK5l7SvmIzwEfHBpLszapK2z+AvsTUWoYS07qYF5dmb1NOmj2AUuIzMEpaHxw9if3jz3Ol2f+IsfTCqilOtKD4+HHqTiion4hisEI8Y/2q37+bL74xy/w3XdVoG2ebHKUN6KJRmKSTJD1AREQE7duL4Wv29vYaOzZSuHv3Lnp6euzduxeA+/fvc/LkyVQ1aNm7dy8rVogDyZIlS7Jq1apf2p+XlxcKhYLhw4cDYhGW4OBgzMzirj739pu0a+jPyk8lt+vG6+TN1fjOJ3H3wemnmZO4JTIyyY+/XziZzXYCULaiPS+8Wun0uXZh0xUG5x3D82svAcj3vzzMvjMJAD9Pf4YWGIvHC2lCQwazMCJDw9hdpzsvDpwBoM6aqRTq1ESj/Wd/7StsAlx5K61qbs4Mcec1mXRtMtZO1kCMqGhgZMD0ezMBeHbxCRt6qD/bg3yCmFpuLIsbi6HT+gb6jHKbyJILvTE2065zaWcWLukcEsMTr7ifrec8xdQZ3h5BdCgliqZRDq5cetoKgD/bnePc8Q8IgoC/r3pbewwqyPvwbkxYVlfStZtxWlWJZyB9vPG9oLXWfJQYaKb0D5S2AWIV5uQkoSrSTg7idxQRKQ6sWnzPo/jEQ0yv0LlzZwC2b5cLjqZ1IiLEydDevcVcscePH1etGzZsGJcuXdJJu3TBjbNvAajbVtRRQkMiKG02j7fPvDE00mfR/hZc9R1C5QaiIDtz2EUKmixl05K7ce0SgK/mhZO13ekZhZAeJO5fxN/fH2tra2ruWM3bg8d5ufMAhfp1Y+I4aZWiq1j/J8k+9N/9kuwBoiSmd4z8oHl57sHi3xeL1JeHPfrZMn6C4r83NaKQOIGtL3FMKkhzQCFDD2n2P5O9Y+q+hdasWUPv3r1Zs2ZNrCrqyYlUD0Wp1zYA8fTvt1+ACdthSntoL0YJYNmyqrQ2eb9NRKNEMuV+k+htUyObNm2iS5cuACxYsIAhQ4ZI2l4QBKpXr8758+cBaNeuXarv5N65c4eSJUsC0LhxYw4ePCh5H+PHj2faNHEW1sXFhVevXmFklHChgj8vr5R0nD3/Si8K4GQTIsk+MFTaw9vBKjRhox+IiJI2x5maPRRBDntO7/zoofjpQxDFsh8AoGP3nCxcHXu2NaU9FF/efM2yTn8DULhmAbovjwnx3T/jCBc2XQGgUvfq1B5UX6tj3LrwiUMDFgJgamtJp/0z0dOP+77NlkGaSFM8k58k+0/+Jgna/FV9Me6vReFn7evJBEYYERUZxbCCYh4y12JZ6L+5J0varebDo0+q7UYfHYxTLkey20r73p54WUqyDwqX7tWZ3Tb+BNGCINA9+wQA8pRxZekJ8Vp9+9iT3v/7O5Z9/c7FGbignkpEdDKVloDa6tAiSfYAodKGTCi/SbPPMFKa04aelfSEi3rW0ia/lME+0uy94+9HzpzryZIV3mxc40KdWpZcuhJE647v6dHVlr/XfyMgIAArKyuKFCnC/fu699KSkU502PqyZcvo168f7u7uZMqUifz586scRaLv27Qm6STWQ3Fs5yOc2vOUHTc7k6uQPfvX/8eM/qcYPr86bf4sobZNZEQUf/1xBLeDL1TLBk6vTKchZWLtP5uR5gm2AP8IcmTYjZ+fH1ZW0rxfojWmbYC06TUIBjqApOMOHz6cGzdukDVrVjZs2KAab7x69YqWLVvy5MkTvn79ioWFKK4sXLiQvXv3Ymtry7Zt27C2tpbYShHZQ/EncjQXvQwf/71Fxy2RkUkaoj0UHz2SqBancap+n2hye6DbdqQXOnfuzIMH4oc5dOhQtSTICXH58mX09PRUYuLz589TvZgIUKJECXx8xAHAoUOHUCgUREZqJzB9+PABhUKhEhOPHz/Ohw8ftBITZWRk0g4P7/uoxMRx04tpFBN1Qa4yOZh0YTQAD848ZnDeMQR4iwJfs78aMvzAAAAurTvH+CLDiQiNX2zfN3aHSkysMKAlnQ/NjldMTC3MODcI10LOAPTIMRFllBJ9A30WPJ4OwLt7HxhRZIJKTOy7sTuLns3EKVfareihUChY+3oyAM9vvmNih90IgsCRjeopPFr2L8cJ778YtLB+qooSkIIgwKV3um6FbmjZXBz87/5HFFoqlBMli73f31taiuL2f/9JVG9lUg0DBojP6WHDhgFiXnyAJ0+exLJVKuPOp5meOLVHjMjJVUiMsjm2XRzf1moRu8KzgaE+c3Y04Zr/UGo2Fyfploy9SGmzeWyafyOFWpwyIc93797F3d2dS5cuUaBAAVUkGECmTJk4f/485crF9E+8vLw4fPgwly9fpl27dixfvjzR55f6ewIpjL6xMQDKcIlubjIyqZQCBQoAv5+g6JxB/CsLiklHoUKFCAgIAMDNzQ2FQkF4eNzhXVFRURQtWpRKlSoB0K9fPwRBIHfu3CnS3qTAxsYGpVKpqtBqaGiYYKXUfv36kTVrVgCKFi1KZGQkdevWTfa2ysjIpCxup75QreQxAFZvrcigUQV13CJ1bJysWfh0BjnLiB7M4ytM5+Z+MU+4S35nJt2Zjam1KEJMKTOG1zdfxtpHaEAI44sM595hcbv2u6ZQpLX2E0qpgYlH/iR3aVcAhhYYS1REFKdXuanZtJvRgkXPZpKnfC5dNDHJ0dPT4++XkwC4fvwFde1mcHit+B22GiAKiT2n1EhzQmJwBJx+HfP+8nvocwwmX9Bdm3RF7pzimPXYCbFfpq8vfpe+fr+HsPQ7YGoqRmKEhYWplkULxUFBoifxmDFjgN83tP3eVXEyKIODeZw2BgZ6zNzamGv+Q6ndSsyJtWz8JUqbzWP97Osp0s7E4u/vr/b68Vr4kWvXrlG7dm0A6tatq6oODmBmZhbL+/DWrVtUrVoVhUIRy14qsqCoAZu8Ysz9lzcS/etlZFIhtrZiVcbfTVCUSR4sLCxQKpXkyiUOuoyNjXn//n0su5MnT2JgYKCaGX///j3Lli1L0bYmFQqFAg8PD/r16weIxWrOnTsXy+7FixcoFApV/sVLly5x79499PX1U7S9MjIysbl37x4KhQIHBwcCA+MOxX3y5Ilq4iQ+tm98Rev64nPgwNmaNG+bLamamqQoFAoGbOmlCnnePnovM+ouQKkUPfX+ujSF+qPEHIgbeqxi57DNqm2fX3rC9IrjAXDI6Ujvi8uxcpaW5zC1MGZPDwpVFn+3hhUax/ElYg7IWn2qsujZTMq2KKXL5iUL+gb6rH42UfW+9aDynPD+ix6T056QGM3iGzD4JOz/njb4f+LcHbsfQ4DmcfZvQabsT8iUPcZrbdu2bXz48EHl0Radg08m7VG0aFEAPn78CMC8efMAMVwVYNSoUQCqPN0ycWNgoMf0TQ25HjCUeu1Eh5uVky9T2mwec6cknyfvr3goZsmSBWtra9Vr5syZGo/h6+urCo22trbm27f4dSyp9vGROsqxpTLyd+/ItZGT2TLlNCM3tNF1c2RkkgS5yptMUqFQKHjx4gUjR45k7ty5uLq6cuTIERo0aEB4eDjZs2dXefGNHz+eKVOm6LjFCfNvyIgEbbrMNSVrxcaMan+IGjVqMGhcCQZPEAehAzue5fDuVwBUqObM1hMNUCi28DYiJn3GsfeuElpkK6n9MqmPHhdWa227tkrvZGxJ6uS/UGl5WAGKmCxM9PEKFSoEiGE+lpaWDBgwgCVLlqjWe3hWBKBAAXGWvn17B+YvyKlReJkz5z0L5ouDuysPGpInf+LyDqUkhWsWYOa/ExlTajKeb7wYmn8sgw6NImM2e8p3qET+6oWYX2c6j07/x/giw8laPBvv774FoNnUNpRoUppPfmlThIpm6ObOLO69i/snH1K0TiE6L2yXJsK2fwVDYwNOfhur62YkGUPKwdYHMM4NmuQFPQUsqiOKjDW2wM1fzIue1hg/2oGpszxjLe/YUb0KfXS6FScnJypXrqx6FSxYED299H0PpHXmzZtHrVq1mDBhAuvXr6dbt2707t2b8ePHM27cOJXnmYeHh45bmvx8eS+G85evlQ2IyRtpZCxt4l5fX48p6+ozcU1dpv15kiNbHzFnygPmTHnAsLGFGDWpSKqZdPnw4YNaDkXj79G0P2Nra4u/vz8gioUZMmSId7+2tra8fPlSa/v4kJ8gGoj2ULx1QnrVTBkZmdRDhu+50dNYnuI0w5w5czhy5AgADRs2pEKFChgbG6vERE9Pz3QjJkZTvWke/nnQHYDF0+5Q1nUr2Y3WqMTEIzeas+1kw1gdEWlioszvhhTxMT2QGDHxV7YDMDAwQBAEdu4UKzEvXboUhULBiRMnVGIiwMaNYjjU9u2eZHK6xvFj3mr7+bPPc5WY+PBj8zQhJkZjamnComczKdeqNACLG8/GbfVpAGwy2TLl/lzsXEUPxGgxceTZCZRoUlon7U0Oui7pwKJnM+m6pEO6FxPTIyYG0PN7hej+3wvd1soh/g2KgPvuummXrujb244vb/KrXh9e5OPoP9lYsGABTZs2xcxMvRSEu7s7u3fvpn///hQpUgR9fX0UCoXqZWpqSp06dZg+fTqXLl0iNFRacTWZpKdmzZoAbNiwARB/y37G1VXsY/6Kl1la4MRO0Qu3fnsxvciDm6KzTLS3oVT09fWYuKYeNwKH0bG7qP/Mn/4QB8PtTB93L1UUurGyslJ7xSUolitXjlOnTgFilFjFihU12kVTqlQpVW57bezjQ/4lTYCoSO3zUFzwKyJp3yalmkltDvr20uwNpBWqxlhi+h/z4tLsAQSJRTOjpBUJRBFP5V9NfFsrzf5HjPJLLEH9G6GIO5WFRqRe2wAkEMFR/fst+eh7tfOAvecl7V7fLpvkJgEoTG0StV1apEGDBrx7J2ZEv3btGiDOpgqCgL19Yr7U1E+WnLY88esGgOcXsQJo/RY5eB3Wk4LFkyYc8Fuw5g5DXLQqJb2quNQqyVIrHntqUYH1Rwz1peV9klqlGiAwVNoPhNTK1tGUzPo1UdvJJD9t2rRBqVTSrl07AOrVq4eT41U8PcV8sHXrZeCLe3natxfzpnbt+gwnx6t8+hRGzRr32b9f/G5f+bXH0Un7e0hhJK3GY07Fc0n2ZV18tbZtO605g3f/CcC55ScZX2Q4keGRPDhxD+93MdfulPtzsbSP8YzIbC2t4vHbb9L6SHe/SBNnM0usJA9gZSztOfbGR9r3lt8+4XD5HzE3kl5J/o2PtA6WNtWwf8Q9RNr+/RsPlmQPYCJtyITeD84zg7/XFbjwDry+X5Jnvhcxb79f/PttTkz4b3BIwr8tSn/p3l1Kv08JG/2Anpm0yAM9u+yS7AEMDBSUqlmAIUOGsH//foKCghAEQfVSKpW8fPmS9evX06VLF3LkyKG2fWhoKKdOnWLcuHFUrlwZU1NTNcFRoVBQtmxZRowYweHDh1WF62RShujv4Of30f1wOzs7te/K1taWnDlzUrp0aerUqUO7du3o168f48ePZ+HChWzatInDhw9z5coVnjx5goeHR7y50ZOSkEhpMtQDT2uO7RArW1dpKIp/0QVZGnT4tfzFenoKBi1thkd4e7r0FvO8L5r1CAfD7cye+OsV0lOiKEvx4sVxcnKiUqVKPH78mBYtWtC7txj94uPjQ82aNbl//z6NGjXi+PHj2Nvb06hRIypWrMiOHTvo27dv4s9PSA3Sq46JLuldbsM6DL7P5Lzf9w/vd++h1aSmVGxXVqv91HKNP1H/z2TwuiS5rVEesRNmx0eku2Y1LltD8e/bI+rLwx9La0/4i4RtfkZPotCU3IH5Vm1/TRTMXFJa5zElef/+vWrWCkjRmZZ3R6U9CoWgRBxEw7UhCJCjJeyYAv6B0HsODG4Dg1qDWa36knav9JN2T/+Ik8vdRG+bFgkPD2fEiBFMnjwZGxubZD+eUqnE2dmZkiVLcvTo0V/alxQPxWgyGohhBYun3qZh65zkzGsTr71UD8ULr5w0Lr+3ZhcGpiYU6tREbfnZx86S9p8YvN0lPrzNpeVssrPU3IkNvXGKoJ0LyTD/KIofQrO8A6RXzDaXKIpmkihaVsmTePeY3ynsWZOn4asn3vRrcoAl+xqTp3DckxG/Evb8M97e3tjb26t+G6tVt2Hbtvzo6Ym/X/7+kRQr+i/BweqCxMdP5TFwyiPpWPoaZlOVSoHmtc7y5+B81GnkorbuZZhLLPv4uPHRRpI9QGCwwITS41D+NHnecVEnCtUqHMs+KFxahyy7bewfdqVSyfjayxCUAjPODVJbl99e2gyyf5j0DqJnkLTnhoO5tMH1zY+xRSOlUsmmXmuwdrKh+bS2aus++UkTLAHsLaQJqXZm0pIL2plJO+caIRtiLYuIEPhziBfPX0Zw6mAmTIzVxYOwB28lHSPqpzmaG8+hw3zx/5ffHbzbzYNbL2BoExizr4O4rJEbZ45/5sGH5jhlinsCIFApdXACwcqYiT9vz2C2Lr/P+vl3iIxUcvLJH7hkVxfIzfSkfQ9moR/jXKdUCgQHRWFhqfkecLBMfL/Iy8uLy5cvc/HiRS5evMidO3cS3gi4cOEClStXTvRxZeLm2rVr1K9fH19fX103hebNm7Nv375f3s+KVzMk2Zdx9qG0mZg/8lawmC+yisNiggMjuBE4TPW7HU2kIC0M2skwRhwXBIFJQ66yeUVM/QE/Pz+10GNtiNaYdgFSn/TBQJtEHjelkXMo/kBkcLBKUMzcqCHvd+9h37RDWguKMjKpjRcvEqH4pnGU38dFnafCne993LP/ioKiTPJhZGTE4sWLU+RYQUFBWFiIEwG6nhMbNL5kih3r3uqdPP9HDE/8WVBMr0S8ekjQTlFAUsh5ntItmxbdZsEY6ZOsv4qdnR1KpZIDBwvRrOkj3M754pzpGvPm5aRjJ0esrAx49rwMWVxiqkB+cS+fJLmVBEHA0UisylmxikMsQTElMDAyYMb9Wbj9fY6Ti04AMOHKJMxspItc2uDj4c+wsnMByOhikyzHSG08PvuAHUM2AaCnrxdLUExvhIULdO/rybmLMZMxesmQi6xsHlAoxEnkCw+hSiHYOhTy/gkLDsLQsCiMjfUZOLIgZ45/pnCWf/CK7JBkx3909yvL5z3g+B7N/WypOd2kkiXjCSIjBTz8xYnyt2+CWbHkNXMWFvrlfdvb29OsWTOaNdMcSRccHMyNGzdUguPFixeJjIxU9ctkkp7y5cv/kjeoUqkkICCAb9++xXr5+Pjg4+Ojcd23b99ihb1nzZr1V08nyQgOFCeuo8XEhaPceP7Ai5XHfm3Qp1AomLyoIpMWVmD8wMtsW/0k4Y1+Y2RB8QcezZxFyfmi8q3/PXntz7O26Y3IKDCQC5CmW6pXr67rJqQ40QV1wyPA/Ptk9INXumuPTNLy6dMnXFzEgXdSzZKmBZ7vP60SE5sfWqnj1qQMUd888F8meo9aj1ih49bIJAeCIFA/33o+vxc9/bdebBuvd2JyUb68Ne4eFZg96z0LF35k+PBXDB/+imPHClO//gMASpSw4NhxiXGa8ZDNZjcA2XNZMmJC0u03MVTrWZ1qPZO3v3D7xGOW99kBQPlmRem5sGWyHk/XhPgHM+N/E1Tv/9e1KnWGNNRdg5KZ0DAlnXp6cuV6jPgwdVwGuv+RfJ41t+ZDqaHQfanopaivBxPbwuSdUKvscS7ea0j5Sg4YGCiIjBQ4dfQTtRtklnycqCglJw+8ZfW8+/x320ujTb6iGek+rCS1m+fCwCD5J78sLQ3w8YlAEAQUCgXTJz/j0D9fGDIiF5mcpYW4S8XMzIxq1apRrVq1ZD2OTNKhp6enqhKcPbv0UPrUQGREFAAOznEL19uX3k7SYyoUCkZNL/vLgmJiQphTR0kY7ZAFxR8I+fiJqPBwlZiYvYQrb+68w+O1F4450mcusMevoUhuXbcibaNtuKRU12sDRZQkexfvMwnaPPqvMHYZYm57pU/c4RSaEMLTRnJmawvwC4SwlEkDIpNC3L59m1KlxKrKkyZNYuLEiTpuUcrw4dK/3FslFpJosmcxBsbSQ33TGkJYKL5TuwBg2W0CBs5pswOcVnF/Ky3Bub5jPmkHULji8TGA2rnXqRZd9+6HqZnEJMhJzKjRWRk02IWaNe7z8mWISkxs09aexYuTrrNUodBhgoMiMTTU4+bTxkm239TKqv67uHnkIQAD/m5P8Vr5ddyi5OXEvMNc2XxB9f6vy1MxtZKWszYxTC0+FICxt+ail0LeAqHB4TRq+4Xbd2PCeedMsaNjW8tkP7aNOTQuA4duwsTtMLk9dKomCopPHvrx6rk/OfNY8eRLC3Lb76VDk/NaeSn6+4Wzfc1jVs27j5+P5jDles2z03loaQqXckzq09KK2vUc2LX9E48eBFCoiBUVKmbg0D9fOH3Skz+6ph4PMpnk45TPOEn2oRJzFkrlo8RcrVK5euotAPXai/0TX2/RC7pwmUzJetykIL0LinL80E88mTtP9X/zsY0AODTnmK6ak+xcf6DrFvwe6FJMdHKMGaA9fx4jCKZXMRGgXwvx755zum2HTNKxf/9+lZi4Y8eO30ZM9Hr4gmvTRI/E+ptmYWyV/kOKBKWSb6PFUCvTen9gVLi8jlv0e5HsYiJwbOdTlZhYr3Ve7ocM1rmYGI2JiR6XrxTn4qViAIwb75qkYmKrumd58VTMwfopOH2Hv0aERtAt23iVmLjw5sh0LSa+/M+d8UWGq8TE9ou7MPW/eckmJkYX2oimSCOxGvf00iMQlMkbYRUSGMa4eqvomXe6SkxcPDsjn59nSxExMZr5Yn00tl2AwO/d1KPfHUPLFTgMgI2tMa07ipNSI/rdjLWPV8/9Gd3nItmN1pDdaA1F7Tcye+xNNTGxz/Ci3HjXkTfhvXgT3osVO2vpTEwEUVAEOHVcLCZTq270e0+dtUkm5fjdxESIKcCSJYeYp/bMvmdATIXn10/ERKs1mknLbyzz68iC4k/4/vcAIUoUc25EiuWzH7k91Wrb0++kJcX/Zl9JWuMAfcdckuwNnOIffP4sKBpJrLpulIg+tlJq8Q3pBfAk4b9TYhnpH/hSoE8StiR5+LNPjHftj4JicqMnMcpFalVoIM5ro30t8e+KfyDv94na0DAIPi1tckDPOnGFLvTMbBK1nYxm5syZQ/PmzQExMXXbtkk7CJcq+AN8jZR2gdfP+k6SfZWc7vi//4LbsFkA1Fw2HgunuD3laxRIfAEhbbFzkvjwDpImEEUXWfk2XAwLNCxQBrPa7eJuTxxFXOJtksSqzV8kVsK+8FxzMZ2ECAhLHWJaStCiwWXGdBXz9S3b34RZm+ppva3UyTZtURjE9vrNk8cMd48K9O8fR4jkV2k5iqMUBgzofo3zZ8TCPR7h7ePNxZjLWNqkn5Qqz9GYGEj7PKVUJPZ48Zne+aYAYJfZhnVvpmDtEL/Q9MRL2oSJ1IrNIL3IijZFXCIjouhVYQ39qooiec5yuZl8bw75qyWcz05q5WwAr0Bx8L62/QKmlRjGl6fitdJkSjuylhCr9k4rOVwlNnoHG2veURx4B8d9zkF+IYyqvoxe+Wfw7uEXAPotb8Xn59lo1Uz778+4cDZJbdLPqHm5QgFLe4n/Vxkj/s2bGTLbif9v3yjmvFm2QZyY2rj6BYf/eU+zmmewN9iGvcE2yhU4zK71MWO9bLmsmLmqMk8DuqsExFEzyuKQST23qNQiKz8WcdHK3iTuvKpVq4v9gZPfBUSXLOJv1ekTnpKrScukPnx8fDh9+rTasqdPtdMj0iuOJUWRYlrfk5Q2m8eSseLETa2W4qTm8R1iWHL99mLFZ6n9BfeI5LtvUqLKsy6RQ55/wKllO9z37uDx8jW49h5Io8Lvufx9nZe/QYLhA/9z9eZjsPaDzKLWH8G5qKQ2KnzfoZe9lNb2kR7PMcyhqU3i4PP6QwWGOWJchcOffMYwp/btifoCJtJOQbJwpEjmq9S8flXJ27w31f470DXt29oxcbL4fT9LQUERpImKQjAorBO2+xFFHH1eq++/CV+8oXkdeLYdbryF+oM1J5iOs00hPrI4qGM6duzItm3bAHj79q1a1fKkRKqoaKUfLGlwIHXC6eBVc9x6DgSg1IRhGGbJTUA8t+8LDytszaUNbgJDpYlY7p8kep2E6osvbdEX8P57pJhl39CUiLoL8P4Qj31UIrpbJlEESRA6XbP5EhGl/dxr2Rxev5U4KAU/33ByO8dUHr38sQe2GU2B5BEJpaJJVIyPcKucIMEJbNbYW+zc9BqAV0FdCFfoQzw1pV4GO0hqz2MvCwz1pXmlRUTpSRYVtbF323CJg7PECbyOf1Wj1eD/AQlXfc9l5SupLcFKYzKYSGt/YIQhLlba94VMDOL/TI9uecC0PjGTlcOPjSCja/TkT8Lfx4Mv0gexlsYReAWaULpvKw4PXMTadgtou20iNlkdqb94ODvaT8LvgyfTSg6nz8XlWBpHqKpJL6v1F7XGtCZv9WJx7t/KJCLWcyzYN4hV7Rbj8+mbalm7hZ0pUKMwXfI/IYoaks5B/81ZSaJipPtb9OOYU2uSHwasAb9geAIUzQ/HXvWiqM0aBvW4jnegIWsX3FXZd2utXgDqf7Wy0GFoeUpWzqIm8gcAAfFo1oER0p71GYxC8I/SvuCRs6EXxCEOWn3fzb07frKAmA7p2rUrBw8exNPTE3t7e/777z+KFi3KsmXL6Nevn66bpxN6DshPi9ZZaF90JWEhkYQEib8pX32UGFgZcnTHYwCKVMtNYIQ+4RL6bgAuZv4a+/UhyrQk7ekG2UPxB+xribPkPlcuqmb1qvUXq2fd3ntVZ+1KToJDdFshVSb5sbCIGdCntKCYGqj+vUj72evx28mkPvLly6cSE/38/JJNTExthAaG4dZVFBMLDeiOfUmJszZplcur4cP3hNr9T+m2LTJJykU3T5WYWLKMLQ9D+n8XE38P/l70kOVz/gPgme8fGBmlz2p4giAwo94ClZg4/3SP72Ji+sPbPZDy5rNVYmLfKVW4FjTqBzEx+clcPA91povueTs7TCbQQxT72m2fhJG5CQgCm5uOUdsmxC+IQ6M38PrKI62OEegdwJwaU5hZeaJKTOy0vDtT/5tHgRqFk/Bsfo1re8S/jXrD1GVQ1GaNat2UwZf4/D4mGqlO85ycedqRZ2F9eRbWl3VHGlGqStYkqd4uI5MU9OjRA4AJE8T4/fz5xVQR/fv311mbUgMZHC044T6CrXdjIgTbFVlJo6wL8fokFnczMEyfv6+pGVlQ/AmH+k0A+LJrKwDlOlYB4MTs/Tprk4xMUvE7CYp9v0dKuospNThzTXdtkZFGVFQUCoWCZ8/E/CgRERFYWSVfpcjURFREFKNLTgIgV9umZKlZRbcNSimen4WbW8T/B5wV49hk0gXD+t2lZYMrACxaWZzj56v+VgP3f7a9ZMqIGwD8594BM/P06cEa+C2IIfn+wvO1WAV3zr3J5CqassnyA/2keWknlmm9j9Iw53IALG1NOOc5hE7DyqXIsX8me+ViVPvrDwC2thxHiI84qO52YgEAwd5+bOo0V2XfdacoMO4bsoaPd1/FuV9/Tz+mVxzP7GqTCfASc352WdOLqf/NI0+l1JcHM7MjlP5eLP3v3errhk4tyx3vnioBccmOOmTJnv76FPYOYii8Uik7i6R1GjRoAMCqVasAMDRMn78biSVzDlvc/Maw+kJXAAL9Ysa3IYGpsyJneg13BllQjEWmNh0B8Dx2EIDXN57rsjkyMklC+3YZAPD2TuaElKmI7t8Ls6zYIf794qW7tshoT2BgIAYGYp6D7NmzIwiC6n16RxAEhhUSE207V61I7nbNddyiFMLzORz/nkW/534wlJZnSiZ1EhYWhYPZfrZseAvAv09q075zNp22KaU5d/wDg7qIeZ5uvG6DrV3yJ67XBU8uPWdc+WkAFKqen0XPZmJkmrLV6ENDIqiWaSmlzeYREZ48YfT3rnygvPlsjm4Vi8wsO9aWUx8HYWqesuf6M3nrlaPCgJYAbGo8ivAgsfpp74ui6On57CN7BorFvTLmcKLjRrEa9I7eS/B4pp6r09/Dh8mlRzO35lRCA8T9dF//J1P/m0fOcqm72MGeJdClOaybCU9C/lQJiL1HlsTcIv0JMgUK2wAQEiL27Ws3FPO93r/97fvyEBQKBXfv3tW4vUzq5cdJt+ioyWiR8fbt2zppU2okTzEn3PzGMP9QTL7t+pnnM7zJjmT7HUgM6T2Hoiwo/oRCocC2YmUAZlccza5B61TrvF6566pZSYIgCOzaH0zWwurJ+6Oi5Jms9M6fvaXlYkoP2IsaKo9e6rYdMtrz4cMHLC3FPH2tWrXi9evXOm5RyjIk318AuBbLQtEhvXXcmhQi6BvsEGeYabsKLFMuXFAGnj9/jkKhYPz48Um63wf3fcliewgAu4xGuAc2JatrYipvJR7PgAZav5KDf6960LmxGLp/7r8WOGdJnxXad03Yz+oeGwD4Y0Fbeqz8QyftMDE1JH9xsepuBZuFfPOUWgEwbkJDImiYYxl/1t4OQK2W+bkaOJKSVVJPGo4iratTsrOYuml93WFEhoWjUCjodX4ZAG+vP+XoRDH6KlMBV9qsEEMnN3eay7d3Hvh+8mZumUGsbjSJyDBRoOq5pT9T/5tHtlISkqvrED09mDIYalUEPb20NBxPHLUbiALipXNipec63wXFk0dEkdjX1xeAMWPGxN5YJtUzYMAAAA4cOADAggWi1/GgQYN01aRUS4kq2XDzG8OEDU0BuH3+LQ2dZjHnz0Oyx24KIAuKGrAqWhKA8GDRZbbDSjFO//SCQzprU2IJDFIyZY4fmQt8xqXgF4aO9SXqJ8H+8bOEE2XLpG1y5UyfXhFxcfsRZK2u61bISOHWrVtkzSqW5J46dSq7d+9OYIv0xYx6YkfRxMKYIbv66rg1KURkOKxtJP5fexw4J1wRVSZpcXYWiwVNmzYNhUKBv7//L+9z/syn1CjvBsCo8fl58r5Big/uk0sk1JanD7/RrMoRAA5daUzu/DY6bU9yEBURxeC8Y7i26yYAE91GUaKBbvO9br7SiTZ9SwBQJ9tKnt71UFsfHhZJNeuZHFqvvcfWzmW3qJZxAd4eokB58EVfpmxqnCrD9kv3aETBZqJTxNqag4mKjEJPX4+hV+YD8Pj4Lc4tFFM4ZS2Vm2bzxDxt61rN4O9mU1T76bNjEFP/m0fWotlS9gRkJFGnoVgF+tRRUUCsXENMMXDy6CcAMmX6/v7kSR20TuZXmTRpEhAjLObJI3oIX7lyRVdNSvVUa54fN78xDJpXG4Czux5QL+MM1k46p/L0lEl6ZEHxB5ThYfzXsyPvVixULWs8pR05vrv4v7oaf7n2y+/sJB3vvp+L5DYKNtrPhnZs/4C8pd1ZvTFmlrZ/Dwte/OukZnf1ZkyuAaP80iqR6iciPY4gcdJYSOYo3aBj5yVvkzXkX0n2UkvXS604+9GupiR7AD1badefwkiaKKlnJs0bQ6F94TsVwk9pMi7dFoXEZgO+t+F7f7/I9yid98ek5UJVmCaycp5hIk7mN2bv3r2UKVMGgN27dzNu3LgUPb5/mPSQaimVGgFquX6Oc926fltUecdm/jsRgDr5Pknaf25H6UKQhYm0ySSnzAHSDhBf9VVBgOXVxP+Lt4H89aRXbdZPROdQStVp4N1bG0n2N14nzsMyQGLF7V/B09OTFy9eAGBhYUFERIRq4Gltbc3BI9KupSgPsW+kVArky3KU2VOfAHD2WjWGjcmncRt75UeNy3VGIp7ZRv6a8899fBdAreLib83WY3UoXiZx10QuM09J9gXsAxM2+gmpVaGj8XzjpUrPYGJpwoLH07F1toll98ZH2uf60j/2PuLDTC92zsTh86oz6W/RU69TxS2c3P1Etc7wezGchUNOMLf/sVjb/siXt75Us57J4lHnABi1tA7Xgkbh4Bx/tfsq2bwlnUPhTD6S7IF4K8lXGtqWnNVFUfXvagMQlEqClaYMvijmUby94zzX1p3k62t39g9fq7Zt560jGXFzMZY5c0hqz8Yn0nMqRmWXVhXawCmbJHvTGysk2VvpB0uyB7AwlPYb+i1cWiGqzxHxPzuKlxZDcU59FxDNzcW+zMN70q8pmdRHhgzi9/vpU0x/0MhITK/g5x/Tv3p88yOREfGPMxOqVv+ruFglf47+x14WVLOeSfsiKxO0bdqzJG5+Y2g/rCIAe5Zco67dDP5ZeTPObT4GJ19e1fQe8qwQZLkWf39/rK2tMXHNTui7NwAUXLKGRwPFymmdD81mU+NRAPS5FPcPlNROwf8yS0/qlsFA+wHdhmWPmD/5X2bMKUiLNs5qs6mOVjEdqdr1HNiyqxQAkW/jvtE0EfX1qyR7AIWZtFwzCoPkzU0TVFh6eM7bIGlCU2ikNO3eyliaipo/9EKCNk6OYqXyO3dL4uxsjNIvboFDE0KkxCS3Eu2VwdIFkR+vjYhIgezlRLXazlbBqR2mBAVD5ebB5Miq4PV7gUV/l6NDV+1Dd5TBie+UOVgeTfS2vxMzZsxg7NixANy4cUMlLKYkp3ykC5gZTKQl/z/7RnPagaNzj3Bp40UAZvw3Cz198Vlx4aWTRvu4+Boo3Qs5OFyakOruK20wFBga9/7DZrSBgG8oXPJh1G+puEyi2Gccn2AZ13ElHiNXZmnPpcQIu9Eca9wp0dtKIUOGDPj4+FC6dGlu3Lih6hts2bKFP/4Qfw+zZjHkqltO9PUT7tLqO+bj/bsgSuWPqcz9wacxxsZxf9ZeetInVKMpYLwkQZuU8FAMNol9Dt5eIZTKLBYXWrKlOo3a5FKtCxek3W9S+xkvv6mLdyEBoQwvPpUsBTIx8kBf9PR+3YfA1EDJ+e232PyXGLFT/89KtBxVO077/BJFTifDpBNC7t70pPn/DgDQe1hRRs8sC8B7TwVVXFYDkDWnDYcfdlHbThAEBrQ4xKXj4njANbct+/7tqBIjE8LtvaOkdt76kFGSPYCJQcLPvmODF/DlnpgHvpvbShQKBWEBwWxtNDSWbYtNE7FxjfEQkCo0dy7xTpI9QE6FtBz10RMX2vLRUdoz4Fuo9Ny9Uvv2DubS+sUuRgmPsbIYiqm5PkR0V3sfPbyPfr7Lw/20Sd68eXn+/DmfP38mU6ZMrFmzht69e9NuRGXajhCL9jVxmIqtowUbHwyJcz/hUcnrQ+YZlPx5ZHNlCKZOhukAnPwmjhu+fvbHwsYUE7PYkyzR96cgCCwbeoQz2+6p1g1d2ZQqLdSr1DtbhGg8bqB/GNWcluLn5ye5QGS0xvQPIDXpSxDQHBJ13JRG9lD8gWz9hpJr7FSKbd6LoU0G7HKKuSiixcTo92mFrv0L8vx9bVq2zaz6QQkNjWL+rBdqdlcvf9NF82RSkEePYtxC1679osOWJB+GBgrWzDHhwVlz7p82xzGjHjmyio+41+/FjtTVCx7x7UImhWnbtq1KTHz37p1OxERdcmXbFZWYOPX2dJWYmN6J2DEdAsTfnWgxUSblePpUHJjfunULPT09Hj9+DECnTp349k38Xt5/iMAl11PuP9Dcwf6R7ZveqsTETl2z4RncLF4xMb0SGBCuEhMnLaqgJibqAhMLUSD58PgLA/KM5/1DzV7Px5ae46GbdmLN9OZrVGLimL094hUTdU3xMg5cf9sBgNXz79Oyilhs0cbOlNsBAwF4/8qXoqaLiPju3XP55BuKmS1WiYnbLrXl0H+dtRYTUxP1Fw3FxlWcmFpf7U+8nr6LJSa23DqZ7udXqYmJaQ1Pr0gyZX/CjVvSPQx/BzJnFseuUT/nu5JJEyxZIk6gRfeVu3cXheMdcy+q2fl4SPdQT6tY2MRMoHcotJQ/ii2L116hUDBgYSP2ffqLkjXF3+UFfx6gicNU7rrFXek+KUnvHoq/x+hFSwytrbHIK7rth3/zxvtVTOerwbz+tNo4VldN+yW+fA6lZ+c7OFodw9XhJHNmiIJil+5ivrLAgN+n8u/vhFIpMHv2e5wcr1Kj+n3V8hXLpXkmpiXqVzfA1lp8BD96FoVLKfUf2Imzi+uiWWmez58/U6lSJTw9pYXgxUfOnDnZtWsXAAEBAar8ib8LD08/4PAMcYA7/vJEDE3SXwVKTURe2oPyv/MAGE0/odvG/KY4ODggCALdunUDoGDBggwcKAostra2fHmTnz97iqFWdRu/pd9gzUKUIAg0bP6WwX+K+ej2Hq3I/OW/5zM2LCyKwnYbARjwVwk699V9PlCFQsHyl9Op3FH0zJvddAXrBu6MZXd08VlW9tzCpBoLUEZp9kwL9g+hX66xvLrzAYDlD8aSu1TqKUgSF47O5jz1F6/z29c8yG60hqgoJQYGetwPGUzuQqJ3YCmrpRQ1XUS/puIzuW2fotwPGUyhUtI8xVMbLTZNwshC9Fw91GemuFChoPWOaXQ/vwprF2nelKmBE6cCyJT9Ce8/iN5+JsZin69pa+lekumB6OCzLIbrVN6JIEZ/vHz5koYNGwJw86a0CDSZ1EGdOnUA2LBBLHylrx97ciNnUXFCwONd+g51//pZjAApVC4LgKrYiqm5dt6RBob6TNjejt1vR5O9kPjsm9RmO00cpvLibvodG6cEsqCogY9bN/B4sFhhU/HdY8TQPG0Vtbh1xYPqRfbhaHWMYvnOcWh/TIXquYsL8cW3HrMX6r7DK5P0vHkTQskS/+Kc6RoLF4h5qrJmNebGjRI6blnK8O99UUis00Hds+b0TlMcHKWFbMqIXLlyhcuXL+Po6EiHDh1+KXQmKioKhUKhquAcGRmJhUX6rH4aF+/uvmXrYNGTacSJUZjbpmz1W12hfHaLqGNrADCaeACFXtrz+klPrFu3jrt3RTFw6dKlKBQKvL3F/G8T/nLk8lkxj9o/B/3JlP0J7h4x+cK++UTinOMpt++Kz9kXnxtQuZrmsP70TlSUknyW4kC+bfd8DJ1USsctUqfNpMZMODUYgDvHHtAv11i8P8YMPGffEifLvd55MyDveF7fea+2/YubbxhRYhoAecpkY/3bqZhapp0+sbGJAa/DemLvJP7+l7BYQoCfmLJi762OsezPf+jNmIXVUrSNyUmnIwuwcnHA0NyENrtn0N1tJZaZpIdZpxZcs4qTb2Uri55FVlb6VKooiqZLVkhPw5TWufS0FQWKZIi1fOzYseTOnZvVq8Xw/goVKpApUyb69OnDiRMnCAuTlrZFRvdE971btGgBwJOb4gRPz+mi6LhxylndNCyFeHRDHNMW/C4ofnwh9lcKlpWWQsXYzJBF53qx9dlwbOzF/vfwOusobTaPdy/kqM3EID0TfTomzMuT5+OGq943XjIY6yyObGk2hgN/zos3f6KuUSoFdqx7xui+sSs/5cptzrwlhSlfMfYPjkz6QBAE/l7zhQkT3qotHzEyC0OGuKgqbFpa6hMQEEV4uDLd3fwXrkfSoX9MUmBjIzi/14yv3wQadQlh2YYI1rbUYQPTMK1ateL06dPUqlWL7du3s337do4ePUr9+vUl7Sc6lwhArly5VIUhkoMN76ZpbZs5iVKT/HfjMw9vfaFdvxJxVgD1euPJyo7ib0n/XQOwyyKtmFdaRen1gYiNfwFgNGwjCpPfQ0RN7RQrVoyoqCiKFCnCo0ePyJgxI/NnZaJ9Gxty5jDm8+t8NGvzjhu3Qihe7iUTxzqQK4cRnbp/rypa0Zy9p1Nv2GtyIwgCuUzFwhbV62dl5srKOm6RZhxz2LPsxTSWd9vEk0svmFB1HrX7VKHJ8NpY2Jqx/OV0Dsw5wek1l5jfejUFquSh79o/2D/7BGfXXgagw4xm1GifNicmFQoFN993YmDHsxze/Yr/Oa1k4a6GDGlzRGUzdEYlOg8pqcNWJh+ttk5J2CiNkD+fCZaWegQEKDl1JoDaNS3ZsSkrLrmeMnOuF3172WFgkJaCBX8N1xxWnLzdTG2Zz7cw7p2szcGDB9m/fz9Kpeh57O7uzurVq1Ui44/UqFGDJk2a0KRJk98uYiQ1MPvx3DjXVepSmUsbL9J+XgeKNShOzl65YR/8PfYkC073IH8ZUWC7evhJnPtIDzyOFhTLiuf76IYoqBaQKChGY2lryqZHQ/H65EeP4mJoecui69HXV3D4WW/snZPO2SExIcxp6Skmeyj+QLSYaJYrD0U37sa5eB7MM1qr1n97k/pyzz158I0shutwNV6vJibWb56NG6/b4OFfnyu3q8QpJmbLLs7qRUXJyXrTIl+/BNDjf+vI5HRNJSba2Bjgdr4o7h4VGDYsi0pMBOjXT8ylsn9/+pnFPXYuEpdSgSox0d5OwZ0TZry6akEWZz2KFxK9oA6elEP7f4WaNWsiCAI9e/YEoEGDBigUCr5qWZjp3bt3KjGxXbt2qUZMTEqGtdrPwpFulDGfz6Sex4iMVA8fDPgawPyG8wDosrIrLoWy6KKZKY4QEkjEAjHs0LD7bBQZ01Y+4vSOnp4eDx8+ZN++fQAMG/2F/MWeEREhoFAoOLA7Gzs3i9fq5OmeKjFxxWJndm1NewNPX58IQkPjzycWEaHEzzfhCq45jP8GIH8RO9YdqJsk7UsuFAoF/Td0YdhuseDgqVUX6JdrLEG+Yu65piPrMtltGACPLzynf+5xKjFx4pmhVGidujwvE8OSrTUYMUcUfaPFxGLlnbkTODDdionpkVuXxTxonXuKzyJ9fQXjR4se0q06vI9zu98F2wzGdOrUib179xIVFYUgCAiCQFRUFFevXmXUqFHky5dPbZuzZ88ycOBAXF1dUSgUqle2bNkYNGgQ586dIyJCWlVrGe2IT0wEqNFHrIh+6HuanAwu4pj+1f3YukRUHGkr0gOPvntk5i4mpqKI9lgsVPbX+tL2ma056DmeXbe7AKImUj/XKhrmWU2Ab9JUr1YgpieQ9EqSI6cMcpVn1L1mck+cgXnOPKp15bJ74vvBk53tJwHxV3mGlK/0PHHINdYvExOqDxlfnD9HFMHUVN33zCgkbiF0SP//2L75I2cuVaRwUfEzkCs9a4cuKz0/u/uFPlU3qi3r1SsTEyZmi3dm1scngvz5bpE3rykXLhZP05We9xyNYujUmEFhTlcFB9abqXIo/kh0LsWP/1pgXKyJxDZJz0miZ2ZLRv2tkrdLK3z79g07uxjPus6dO7Nhw4Y4vfKuX79O+fLlAZg5cyajR49O1vZJFRTtzMIxMZDeCfu50rNSKbBwlBs7l99RLStRyYVF/zRHEKCKgzgD2nxyC8q0LJvg/tNDpeeAIAXh40ShRb9hXwwqNovX/net9BwWoc/ZFu0lb5fUBAYGYmlpqXq/f5cr5cqYERyiJGeBZ6rld67lIpNTTN5PfUf1wak2JLbS869WeXa0OgZAwcKWHDhWDivr2PlLK5a8wMsXYjGzE24VKF7SJpZNiQLn+PQxFGtbY+55dNaq7Sld6TkulFFKJtdcyNcPYnhX26lNqNROLIrl/dGHCVXnqWyXPJ2CvkHMPWMq8Vmpy0rPcXHq9Ff6NT3AnpsdyZEv6aN3Ukul518htVd67jPgEweP+PNnzwxM+Ev8vDNlFz207t3IhaODYbqv9Hxw1yuq1c2ClbX6GClS0CebYWwvxPjw8PDg8OHDHDx4kCNHjiS8AVC/fn2aNGlC48aNcXJK2/lGdUlCgiLA6IIjNS7X01NgmcEUv68xRYmKVMqOqbkhJuZGmJgZYWJuhLGZIUZmxqplxmaGGH9fp/b6vvxHZxRtSe5Kz/1yiek5ois8dym5gi9vfDj+9a842yv1/nS2COG/G5/pXm27alm+4g48vev5S1WeDwLmEj/SIAGakDaqPMuCIjFfdt7lWzAwiwnDKugc06nZXUesqtRwy1zMHDR3PvI6+Ek6bhEnafYALlbSlPIfxccfObbnBYe2P6deq1yM7HqWMXMr0mVgUWwCH0vavzLYV5I9gJ6ZjeRtJGGoXYc6mnuR0pPIP/FK3pxvdmbxdzhGVFmC+2sxd8TEgz3oV8tbo5331zCa1rnEzoMVyOwifi4OZvsBcPeoIKlNQrjECnqR0vKzKEO0vx8yF4gRQksUNWLXRifMzeP+0WjS9gu37oTx75sWuGTV/rvTFxLv1ZieBcVoTp48Sd26MV45x48fV3sPsHPnTtq1awfAvn37aN68eZIcW6lUoq+vT5EiRbh//77ausQIilKJT/AH2LP8Jiv+ip3PpnqfGtQeUCfB/cclJt6dswxDC3MK9e2qtlzq4A8gMDTuQjB3Jk7D99ET8vfvQ6aqlQD4FixtsBUYasDLXk0BsCxfDceugxLVnsBTuwk8sgnHRYdR6MXc53aW0nNABYZKE3RsJQ7+MpglPi9VahAUAdw/FmfBInfmzhdzLxfIb8LjJ2LfI2tWI65fzq82eaBvl13yMTSJifdvuNO+yh52Xm5N4VJxCzK/KigeO+JO1/Yxon+WrKacvFSNjPYx17fHl1AK5zyutt3+E/+jYmV7ABpUv8Ct66IY9ya8V4LtAfCPit03iYxUUjf3OobNqkS9Nuqi7NsAy1j28fHRX/qEwqPTD1jxp1ioRU9fjz9mNGbjqAMAVOtUhk5TG6nZS31W5rLyjbUsKkpJzdwbadopP4Mml1ffv6E0MT4xv9GBSmnpFqSKwFe+xK6YHBEawcjKC3HObc+IberP7psfkj/tRUSUtEF1aKS0SZemBT/GWhbwLZgxDdby9ZMfG56MilU4oZSdtKgvs1D1YwiCgJO1eI++86yDiYk+N659o3Gd6wBcCxolaf+JEUPCv3+uSqXA3bMvOPr3dR5cEiuEL7rUj8y51IXijBLvn2ymmvv20WQ3WkOeAracvNcKgDljb5KnoC1N2+eWLCjGRWRkJFeuXOHgwYMcOHCAN2/exGmrqQ8okzDaCIqHZx7iytbLKdCahMld2pUxe3qoLfMPS/5EWoPzjgHgoOd4AJo4TFV7/zPhEp97P9+f106+5K/We1Tvf0VQPKSfOEGxcVTaEBTTWxq1X0IZEgJmmjsaNZeN50z/qZzsPYFm++MvT54WWDbtX1499aHHMFFMu3nxM10GFtVxq2S0Ze6FgT8t0dzp+PwphGdPAhg9+D5b9pbXaJMWqVvDhNAwgfUrHTExTvgHY9Cf1nTs6cnK+Y+YvjhhzzAZ7ahTpw5KpZLu3buzYcMG6tWrB8DXr1+xs7NjypQpTJw4EYBbt25RqlTShcxFV7rLmzdvku0zKWnVrwyt+pXB7Z8nTOl6AIBc5XNrJSbGxeM1m3G/chMUiliCYlJj7pIZ30dPeLJsFU+WrSJTjao4dOiDwkD7bsP7KYMBMLBzSFBMjIuwx/8SeGQTgJqYKJO8DB3sRKuWGShT/rFKTJw43pk+vZKn8MqGhXeYN0ZM22JumbwVz+s3dMLDvz4nj3vwR5vbfHgfQgHXY1hZG3Lp3xpkymyKYyYTPIOb8fljCJVLn8XfL4JmdcXBnIOjMZ4eonD8OqznL7WlpKUojn54I32COSkoVa8gK5+M58/8U1FGKVVi4rAtnSlYKVeSH8/PJ5QKmcQw8VdPfo/k92c332DbBNHjy8Aw/T/DfDwCGFZ9FQHfYiahjUySfripUCiYv7QwwwY8oHaVK1y8UZmy5WMcPu5cfE+JysmTksHrox9H193i0JobREVonsyzyiDNuSGxPH8c4/yycu49AJq2z51k+zcwMKBKlSpUqVKFBQsWqK37+PEjhw4d4uDBgzx69Ihs2bIl2XFl1Gk0pjGNxjRWvXcw1zx5qVQqCQ+JICwonNDgcMKCwgkLCScsOIKw4DBCg8IJD44gLCSc0KBwwtRsxJdqeXD0duL/0RSpmnTXV2qmfJ1cuPmN4eDa2ywadurXdqaH9BhmAUheR/QkQxYUf+DD8tnknKB5liBD7mwARASHEOYfiLFV2q5KumBrLZqU2s3MkWIH/ubFTzpukUxyULioDQAnj8VU+W7e2oV/dn/k7t0AiheX5gGRWli3VOw0Kgy065xXqyyGaa5b9lQWFJMYhULB+vXrmTNnDvb2ovdOxozqs/IfPnzAxSVx4Y2aiD5OtmzZ2L17d5LtNzmY1l3MeeNSKAs91iZefPh49hLvjp4BoM6edUnStvjI27MruTp34PGSlXhdv8mXs+f5cvY8Rg5O5B47BUPb+MMEP25eS/jHtwBkm7kmUW2I9PbAZ5UoSGccvzZR+5BJPFlcjPjyoRgLF7vTqKENuXImT2XfDlX3cu+66K108E57cuRNmQJydeo54uFfn8sXvWnR8Ab+fhEUzX0CgBsPa5E9hwXOLqa8/NKQr15h1Kl0ng/vg1Vi4ovgHnGmedCG9hV3AODkYkmv0br7XTI2NWL926mc2Xid3TNOsODGSCxsk14MefHIm6YlxTCyxu3zMnN9+i7m4+Puz7ByMWOKP6Y3pmqH0sl6zEBPH4wtTDE0S/kq3J4ffBlYcamawDZ+VyeKVM6RbMfs2DkLwwY84NmTQN6+CSZbdjMevKxB4Vxn6Vdvh2QvRU1ERSq5euQJh1bf4PltzWMlhZ6Chr3KUbdbGRyy2PzyMdMKLi4u9O3bl759++q6KTLf0dPTw8TcGBNzY6wTNk9X/Hv6BbaOFuQsEttL/Feo2brQrwuK6RxZUPyB0DevEJRRKPQ0u/pXmTWMC6Pnc27IDOqtm5HCrUta8hUWB/wPb4s5HAP8pIf8yaQtlEoBPT0FfQfl5p/dH1m54jNr/k6d3l1Jza8M+hLL9WDt8wSWM5uVjC1JGTJmzIggCBw7dowGDWLCDQMCArCw+PUJmOiQkOVtl6oKwfQ52ldjqIhDKikg3K38WpRKAVMLI/rvGpDo/fg+e8WDJaJXT/VNy9AzTJmfbn0jIwoPFz0LPxw7yYv1mwn3dOfRIDHEM+foiVgWKBxrO+8LZ/l6RhRmcq7YE2u9NggR4XydLBZysek9EQP7pO0gymjPkEHJkxsrNCSSkrYrVe9veffBzDxh78Tn4f0StLGR0I7/VbbDM7gZd259o26VCwCULXQagAu3apC/oBUZ7Y35o3s2pk8U08K89myk9YSWJuaPvsijOx4AnHjeLdH7SUpqdilHzS7lkmXfp/a/ZEg7MTx1/JKqtO0V+7mRnlg7dB9X/7kHQAZna2a6DcbQOPmf21tbiLnF2u2YhLVL8ngT/4zf+y+0qjlZbdm0Q93IWzplio6duVSRmpWuULboeTz86+PgYEzlanZcdPNm49xrdBkhLTrn0ytvDq+5yfEN/8ZpU6iiK417l6VI9bzo66dtr1MpfdVo2m6umAwtiaF1ybjDqjXRo+izhI1+4swH6cXh+ub8S/I2MklDVKToqpc1n32cNlM7iOk74gqB1iUKPbHQiqRt0lBSwrT9FEwG3HdsiHOdY/ECAAR89CAyNPF5klILZavKlTZ/B/oPFV3TD+wV888UKW4DwKFD8edmSW/kyC525n19Ut+9m5gOXWqlfv36KJVK9u/fT2RkZJKKiduHbeXDA7HK28yHs395v8nJxE7/8OaxOGFz9OPQRO8n1NuHayPFwVqFhVMwttFNHpUs9etQbPNeck+MmUx7NWsy9/5oicehfUSnYw58/pQP60SRKPv8TSgMEhe+6jFMLN5iXrsNJgXL/GLrZVIbb1/4qMTEPIXteBQ6QCsxMTkpUToDnsHNuHCrhmpZldJncTDbz+gh91Vi4ovPDbCwSLw4dHz3MzYvFnM43vLtr5MJr5Rk8YRrKjFx85nm6VpMvHPtC92yjVeJiaN3d2fe1eHJJib6vHPn/fVHqvd1pouTPTvaTSLoa/KG0X97+Z5tNXtypNsE1bI5p3uz58vEFBMTAQoXtcbSSvx8TxwTRfqd/4i/GasnXSQyMu78wmGhkRze9B8dSq+jicNUmjhMpW/5FWpioqmFEa2HVmLDg8Ec9BzPQc/xTN//B2Xr6l5MNDJSP36RUqLYEhqiXW5RWUyUxopXaduZKC3z+ZkYaZf/+7MlNEh0hMpbSj36ydQieQvDJBaFfuJeaQVZUPyJb2eOqf5/9Dl2db3yf/UB4OLYhbHWPfOU5lz8n7t0Z2SpSbe/RcYd0jpnXY1Yy3wtCkjaf2IKrCSmkIskIqQVDylmcFfyIaRWLZSKd7C0B+JJ72Jxrhs0XKxaPnH0w19pEgojiSFQBtIKOOiZSr8fpFSdHtTHBoD1y5/Gb/gDUYrEDQJehiVdeG9aRKFQ0LRpU1Wew6Tg6Nwj/HfiPwCm358Z7yA8RGJVN6n3G8SfgPrq8RdcPCR2cs98G4VCoaCsi7TKpVVyuRMVHo5bN9FDsOiwvljnyBanvdSk+wAWJhGS7DOYhWGeMw/FNu+l0PL1mGYTQ9m+7N3B/c6teDF9PC+njQMg77R5WNtLcxWNbo/X9N4AGGTNjWXDP+K09w6QXpHTwkRaEQcfiYn6pRauSQ9EeUsbAP6z+wMNCotFq/qNL8v+W9oXozFQaJdQSCHx90f4oYhY/oJWeAY348bDWqpl61e/BuDBq3pY24jXhHmkl6RjWOkH8+SeJ6M7i+Lamdc9MYpHaMpmqbmoXlxILdoHyf+sbFFpP2vmiOLMmRddKPm/+Afy3hHSJkwS8xttoRckyd5IkfAzIzw8iup5ttCuqlj0rlyTIqx7M4U8ZbIluG2ZLImf3D3YbwHHRiznzhbRIzx75WJUGdkBgC3NxhAWIPaHpRbtiq+CtNejl2yr2ZPjfaaqljXaMJU9XyaSvZD23sz/ekvzOg82ibtfdfthNQA6t70NgL6+gonTxCJHAxrsVNk9v+/B1F5HKW8+m/Lms6lqN58ZfY/z+nFMJeVStXIzeU8HDniM46DneHa+HkWH0VXJ4Bh7PGUk8XP9KvH+eRsSf8Ge0v8TP0Pfb+K9X7qi+PnfvvV75CdNL2jqv31+8pnRBUfi+zmm7zi64EieXxEro3sGpa6+RkKFCn+V17ffApCvjPgceH5HTD9QoKwoMPp6Bn5/H5M3NbnvT5kY5JDnH7AqVhL/e7cJuO5GhopVyGQdTMBPVSdtylYAVvH14Qv8AhXo/ZCg3jVDIF6B2gt++Rz8+CRRILQzC+flN+2FHRerUD5HxiHUZFRf/jHYihzm3wi2zKP1/g0UUSDRYSZYmbwPwUhBmohx+JX0mdS336R5XcXXOdOEk1UIn/xNtbbvkOcZYWjOO2Xy3Tvcwz2UMEPRJn/hDDx58A2fMBvsMmr3fQiRYShMbbRukxDiCxJESCHYR7KoqDCLLfrHRfMOSgaN+sqiGQ/4c4x2Hk8GiigiJDwmP4ZnTNhIRjKXNl7k0saLAEz5dxr6Bgnf41IGyg7m4ZKrwRnpK+MUFY1trclVLBMzDnQmKNIQIqVPIP332YZTrcQqenlb1SVv7ZJA3AJgYqo8A1hKEBUDQg1jRMgMeuRYNgEhSsmj9bt4ffAkQc+eAFD6rwFkKpaRwNAwSVWPA8IMCTiwligP0Zu6+MzpQNyDf0tjaYJo9DHMjLTv+BpLfHZL7cCmB6RUeR7Q6za7tr4HYMvpJpSpnJnkyjouRVTUNGGWI58ZXpEd+PIpmH5drrJwTTmcXGN++79FWYtJ07XknTu0LS/mENxwvgPWTtaEx7P950Dt+wAgin2mBsl7/WW31W7CNipKSc0MMV7kT/27YWxiAMT/PDCP9ErIRA0hxAepZ6xnnVmSqBgqmMQrZO9Y94yRfWKqr678dzAZM1uj7XX9n7s19hbSxODosUmXPeNZVXsUN9ccwsrOnEKNK1C8WTki/P25uuowG+oPp5/bfKIMTCX9RgSExfYW/nL7MedGxThT6Bka0GjjNCwc7aiRy50AiVVeSzp6a6x8HhfOhl4QR5/P1gyatnblwO53TJrwminzSlK5Zz0Y95R7lz9Q3lxzREMGB3Pa9i9F465FCTBQ33cctVZ+CalVnp1N/OKtMl6iojNXzn3ixtWvVGuQjWIVnGHxA/698pkOsX1GZFIxP4uKoaHi8+PwnKO0nR8zsbq+11qm/jcPS+MISZWVE9tH1BZNz4yEkDI2fntX7DdcPfqc8s2K8uC62E/MXSor4VF6PLguCox5SmdV9edDJU6YxTUWkDo+0Ehii7KkEWQPxR/I0v1PAN6vXhqvnUvNKgCc7zUs2duU3NRuV0j1/+tHnjpsiUxy4pxF9BTy+Sb21PsME0OONqyR5lmSljH8Xl0xPCyNlMySAWDbtm0cnStWyJxwZRJGpql/BjF3cWfmn+qBsVniQzgPtxd/X+zy56Roj1ZJ1bQkR6GvR6Ge7Wh8ZCNlxg+i3OShZKpQMlH7+nbrBh7HxO+65KbtSdlMGR0TFSWQyfKASky8+qHLdzEx9ZMpsxn/nK6Ja/bEp2+IiIiitusKAMavqkOhMuk3J2iAT4hKTHTIZMbrsJ7fxcT0had7MFkM16nExEnzy/Ihovt3MTFlMLE0o+eR6QCcmbmDl+fvAVCmc22Kta4KwPJqw1T5xxLDhyt32Vazp0pMNLGxpPnuebQ7vhILx/g96FKSNdvEUNyVi55ib7CNGo6xI8mqN8/LmnMduRY0imtBozj6pj+dhpXDOoM08T61ULKi+Bz594pY1Kpkhe/vL3/RWZtkkoYsRVwBeHT6Px23JHVQoY3oCHLrxFPaukxl99zzAOQtLXokPr31/vv7lEu3IAWFXuJeaYU01NTkR8/ISFW5MvjNK402nrfu8vGMmLQ7zNsHQZm2vREGzompsnfv8nsdtkQmORk/R6wguXTmPQAatRZDFZcveqGrJukEmwyix0pYaPK65sskDadPn6Zjx44AjD7zF2Y2SV95NDWye9Q2Qr+J+a9qLEo7ScCdyhbHoWSRRG0b9OkzrxbNB6DokpVq3v8yaRtPj1AyWR4gKkrAyEgP98Cm2Dn8HvdyNIUsVgPQomdRGv+RfnMIvnnsReNsiwCo1bYQN951TJc5Ikf/eZmSWcQq3RkymvDcvzPdBxZKYKvkwdzOii57xDyGR8as48NtMSSy6pAW5KlZAoC/qw2QPF55c+Y622r25OJEUQi3zOxAy38W0WLvAkwzpL76sQqFguUbYwqwZM5uw9D5NTnjPlglIE7f0pTCZdPGRIY2FC3jCMDtK58BVM/VO1djBMVGjRoxYsSIlG+cTJIRnaM6bxUxLdnnxx912RydkLtcTnZ/nkDHcTXVlncvNJc3D915dkvMr56rWPq5v9MSsqD4E7kniAlXn08cFWvdh9MXuD1NnPHKWFzsED5ZuzXlGpcMmFvFhATdOf9Wdw2RSVYatMgGwN+LxDyK0d56QYG/l7DWb3RxAPZseq7jlsgkxO3bt6ldW5zwGHxgKDaZbHTboBTi2rZLPDgu5nVteexvHbcmZYgMCeXGIHHAk/evCRjZpR6vF5lf48pFLwplF3MGtuuUlY++TdDTS38CU3w0KCYKT9nyZmD04loJWKddLhx8SrfyawEYPL8Of61ulKLHj4oScLQ7j7PDeZTK5IkVu/+vF1kM17FtrZgjd+epetz/0gFTU91OgNi42NN+kzhu2dd/KR5PRQeB+lO7krlYTgBWV+mvEibi49H+i2yr2ZOrs9YBkCGPK60PLaXxpukYW0nLi5vStO6YA6/IDnhFdmDvw9606lMSc8vUlWsuKYkuZHX3uofa8uCgmL79kSNHmDdvXoq2KykJDZCWFz89Ub5DJQCenBPHbrUH1wfg5MKjOmuTLlEoFDTpV5E9XyYyeGUL1fKRtVbz4ntOxV+JDEpOZA/F3wwju5gcaGG+/qr/X+4+xMNl4o9r5RWzKTVxOADvjp7R6gc6NSIIAtsXXFO9v3bipQ5bI5OcaPIQ0NcXl0VFpc3rNzG065EfgOWzpBfikUk5Xr16RalSpQC4ePEiTrm1T/Selnl1/QXHZh8EoOm+pejpuIJkSiAIAhc7dQfApW0HrArqxstHJumZO/0JzeqK4aBrNpdm8erEhcKnZaYMusjLJ2JS/T13u+m4NcnH2ikXmPSHWJBk8fGONOlRIsXboK+vwNbWgKgoyGR/gQD/pJswjYhQUr3IPhqWPwRAnSauvA/vRsVqzkl2jF/FIY8LLVeIRbx2dJ2Lz3sxjVGrlYOxzCRO0qyvMzTO7e9uO8WqSn25tEAsYuJYPB9tji6n3opxGJpJy/cuI5NULK0xhs1/zNV1M3RClV6iN96JeYcBcMgp9oVf3/i9oss0UbFpIfZ8mcjym4Owzhgz0dEq02TWjztOVFQqiyDVA/QlvtLQECANNTXlyPXXFABujpsJwMMVG3ixbS8A1TYswTxzJhQKBYrvIVke1//VTUMTSUR4FFO7H6S6zSz+nnxe182RSSHqNhXzcdy9KVam7DckNwDHDn/WWZtSGnMLcebK/ZO0Ko8yKYeHhwe5cuUCYP/+/VSqVEnHLUoZvn30ZmMvMSxy4MGRGFn8HiGhV3r2A8C2SCEyNWqi49bIJAWCIFCl9FnmTn8KwPX/atG0ZdwVWtMr+7c8Zdsq0bPkYWBvHbcm+ehfezPb5l8FYNejfhSpoLscVk9f/o/6DUTHgFzZL/Pqpbp3kyAI5Lbfw64tr7Xe576tL8hhtoEXT3wBuPK8NWv31kyVodwuxXPRaE4vADa1mUqgpy8AHXZPRaGvR0RIGDs7TlbZC4LAjdUHWVWpLzdWHQAge+WitD2+kppzh2FgnPpzFsvEj6lp2swP+SMeTz+m+RRjicHc9nv++0+xq3YrU5tgpiMcstiw9sFwtrwaQ8laYlHZ4+tu0tZlKhMbriHIN0THLfw9kAVFDVjkE3MUBH74xK1Jc/lw0g2AmjtWY5LBBoDrY6YhRIqzn/aligHwTmLl36ee0nOQeEssaf7xhyrS4aGRdC33N7Xt53Bu72MAmvQowZlvMeHdz32ltUlqRWUAMz0JJfwSQXzV+DTRKOcHycfIliFQkn1opLTPyV1ChWeAbc/zJmgzZnppAKaPvgnAHwNFb5HlC7Sb6ZJSMROQVBEapFVsjkYI9pFkb+rzUPW/NrNXUq9vF6OvkuyjkVqJLL0SEBCAk5M4A7t69WqaNm2auP1IrDbnGSR90CS16lsRJ78414UFh7GwvjiB1Wl5d+yzO1A4k7Rr++cKgcmBlIrQQExF6Dh4svJvwn3Fz6X4hDGSqzYnpqqg1GOESXx2J0k1wDRGlHdMca/AwEgczQ/w5JEY4fH+W2Ny5IrdN7KNSt6iAT760oqeCOHSw+oy6Md9T/93y4PRPc4BYgEaQ0N9rPSlHcPZQtpAyE5iBdnE8MYnZqIjKkpJNeuZPLohhpqd9BiBg4uVmv3bEGnpC4IM7CXZK0xj9xs2bC7EpClimG+Fsjc5fcpbbb2vTzj9u15jRL+b8e77q1co9gbbGNz1IgB/zSzNh4juZM1uGe925TJKy28W329DXMT3LM5ZqTC1xnUAYG2T8YT6BWFiEEUvN7HgpO87Dw4PWsylBTtZXbkfd7eeBCBvvXL0Or+MOtN7Y2MhLXLl7EvpUQS3PaRdG58jpF0buYylfQ8uVtIqbSeGrxLHcJ9DpY8T7TOJ92h09Fz0pKyXl1cs28T0PXf+cUXyNlLYfTu72vv/9RbDfC+vOqbRfu39hMc/P1MzyyfpDUtG4us3RIuKYUHi9Vmtj5g24+Ke+yqbOY0Xc2nbtdgb/0By9xGl9q1A+tj4vbchMztt15jSwsTMiNGb27H78wTaj6kOwOv7n+hTeBadskzk/RP3BPefmLGAtqT3kGc563kcZO7UnU9b1vH17gMAKmzdTKieIaGhcLNPX8J9xMFehW1bCI4ygChwtgnmW7D2oourbSCf/KR5odiZh/FJgtjkYB6m6gDunHqct09EwaPT1EZU6yRWTHofE9nN5hkX6D+9mqQ2SSU5b1iQPqA7+9JR8jGee0j7kU9oYP0zeR388A7S/lrqUuQl/lHxX0sZc4rrb1xyxz/KjExO4uDjzr8+KI2t4ts0Bgmaol6YPwpL7T9bIcQHhZXE78JQ2v3ja5yN6g0/c+7IW44e+EDd5jnjtTdSREoSFaUOnmRiCA8Px8pKvA4nTpxIr169Er0vE4MoSZ0nO7NwyR1rEwOlpGfNf+6anxmCUsm0cmMBqD6gAdkqFCQ8Cl57W2Kor/0MdGI6cyYG0iZfQiP1JR0nIMwwzoHv69PX+HL2PADtTq5CTz+YiCg9MlpqP6iT8vmo2hRqKOl5LLUTHhYhfZJNF7x+/ZocOXIkyb707cQB4JNH/lQpfRaAshXsOHymcpzbSBX8pJJB3w/0tf99iFJI7w77RWrOJ+flHkyr/+0D4J/rrVSFEr5Fxi9E/cyPE8LaEBAm/Ryk3kP57AIA8PsWQk2X5QBkdDLn2Ks+KBQCoH5vZTGOLWLEh8L3HVKkLGWwr8blvbtakj9XTtq0f0XHdg8YOdyJIYNE0evRswoUzHuVjatfcOH0R67fKhtr+3F/veDv1aLoYGZuwOPPLTA3NwASfj7d8c+GlbH24dZ3v1hjbiQtPDsiSg8787gn5yu3Lo5esB8nFxxhVd3RDLowBytTY4ZeXcCCCkP5dOcZn+6IeSBLtKlM9aHNv3tcRgFR4rNbwrO+TBbvhI1+oqSjtG0yGAQQKmh/T7hH2EpyMPgcaIpRIn5TpCDlugBwNklYbM6Zz5ZXT30ICY7A1MyQUhUzcXzvK16/fk3OnDmpVKkSp06d4sqVKxonaaX2fXruKpuo315taVda3Xu4au8aXF59jOsbT1NrUL1Y9h0LSE/XdeZD6ivcEVd/ssaQxhyasIPz6y5QrV89ynSqjtuq05yYd5iSzcRx/Odn7uybcohiLeP+zTXUV0oS8KT2D1Nigvf6ZjfunHnBnQtvKVQp7vFbvb5VqNe3Cv+df8ncTlsAGFt7JQB9l7WkfBPNhdGs/s/eWYdFlb1x/DN0SCgqGCgY2N2da7drr9216tqursHa/bO7u2Pt7u4uUBARBelm5vfHkUEkDwIDOp/nmQfmzrn3npm5c++53/O+79cwPNbfQ0gyiLFJEQjTXgx83KQj7TP1UKlUvN+8Tv28yrYt6Ojro1KpuNSug1pMrLJ9a7pyomz7d30W3B7DWmdHtZgIcHTFJfX/WxbEP2Or5edgy7L75DDYpOlupCqfPoVQwHApZw47A5Ajt9zNnZaUQ6lUYmgo1OpevXoxadIkzXYoFZlafhQA+asXoUqPOhruTerw5bULV2euBaD1rrno6KYPEe5n4cmTJ+TNmxeFQsHLl8lTi2nrBme1mDh5RtF4xcSfmdCQCKrmXg/AnA11KVJKLqoquQnwCcLpQfJG47x6/EktJjbqWJijb/qnyfTf6tXMuH5Z1E2eNceddh2F8JA5swGu7uL4dHoThLXVOUJDhUDy+JE/1lbn1GLitp3FeOvT7quYmL6o2q0mVbvVBGBhjVHs/Wsl8ypH1VAs3rwSI64voM7w1mny+9OSOGo0yAVAyYyrKGC4lKO7XwPQtWtX3NzcqFq1KgCXLl2KcxtpGYVCgZV9VgDcHstnlKV3ijUS2WSXVp8EwMBEjJWD/aIi2HX1xBgqLER+Yjk98fqeOC9nzyeuq8+uOdPZdiKhwbG/7+I187HJZTJzLw0hQ0Yxsbd00G46205ky+RjKH/BNPqUQisofodKGcH9rm1ApUTx9SbH/eQplOHhXG7fEQBDKyuq7tiW7i7AOjo6mFuJGfXwsAhWDt1FD7sJ7Jp+PFo73y8pH/avRTP8MbA4ANOGiRSe4f+UwD2iqya7lOKoVCp6d7tL0byn1cuuf+hBsTJZNdgrLZGoVCp0v55r69Wrx6pVv4azMcDWgStQRSjRNzKg/cKemu5OqhDiF8CRvqJOcf1FYzHKmMjoaC3JRuHChalfvz4ADg4OdO7cOdZ22Wzvkc32Hp8944+q6d7hOkP7C6OrI+dq0P/P/Mnb4XSCSqWimLmog9p9SAmatnfQcI9g+aCdODZbTg+7Cfh4+MXZ7vmNt4kyGDyz/wUdym0AYPSCukxe3SjZ+poS5MplyOvnIhrlwkV/stneQ6lUoa+vw0fPmhQtJtLxbbNdoELZa9SuIWqi166TCffPNahdJ31nHdT/qwklmwpB4vWlxwDU+LM5I28spP7f7dPdfYyWmIycXpm/HCuQ0y76tfTy5cvkyJGDWrVE1tncuXPp378/169fT3dmop2Wihq0a7ss0GxHNEBs5nyZcglBzd9TnNPrD28CwPVtKZuOrmmcH4qa/xltREDIgf+Je9nQoPiF1Ky5M7HswWhWv/ibknXEdfnY6qt0zT2ZyS1WE+CTCnUWZQ1ZIh/phPQ35ZaCKENDeNi3CwDGdnkoNXUyVzp15vXadbxeKyIWzQsVpPikiZrs5g/h/yWQWR3W4vrso3pZ9Q5l6ezYhEcXXrGwx2bmDD3BlA3NNNhLLclNYEAYjYttwsNNmJEoFOAc8AeGhunobJUEjhxyp3unO+rn6482o1LtX88cIC2TMaOogZUvXz6OHz+eQOufhwsrjvP6ikg5G31luoZ7kzqolEp2txwKQLk/O5G5UPKk3P4s1NmzNdFtN9rJmXyowqPX11s9GR511KNh13A2b97M5s2bOb1NHwd7BXo5RB3pkiVMuHc/kGIlHzFyuA1/DY1eJy08XIWtfVQdp+eujcmY6dc1cahbcAsARUpnYcysKhrujWDwqo6MqDwHf69AhpWfRfUOZek2Pbr50dvHH/i3tYgYHrezG4Uq2ce2KXbOOMWhJRcBWHmyPaWqpI9rqYmJLm7vSlCw6EN8fZVky3Kel05VMTfX4/S5spQpcRVX1xCcncRk+tUb5cmT9+cxxWo9tQMZcthgmsmM4i0qabo7yc7W1c8Y3f8yzsHd0Y1FfPnZ0dFR0HdUGfqOKqNeFhgQxsPD1Vi/fj1nzpxRL1++fDnLly+Ptn65OvY06FicKo3zY2gsn7aaGljYiHGiSqkiPCQMPUPRT8dSfxE0tRK9R5RKtb4sfDEjUe3k6gPGL8fkrVyA11ee8/GlG9b5s/PbX83YMXQNZ5efpOnfrSjXthJHZh7g+LzD6qjknxGvD6JGW+RESKTAGBl9mBCGxgYMX98JlUrFgf9dYM+cM7y67UK/ojNQKBT873wfchVMmWATbcrzL4Tbru0AWJStQIEps9DR08PIOqqmW9bq1dKtmPj+pQc97CbwZ6npajGx05QmrHV2pNv05ujq6VKitihse3L3U012VUsyM2PkRcpZLVeLiQAqFT+1mPjRPRhr8yNqMbF7r1x89G2kFRPTGGXKlMHHR9QISq7Uy/TA87OPOL9ciKdjrsz4ZaJEtjcWjs65qpfBoVlNzXYmHfOjYmIkRQvo8O6qPvVriOOvTocw+owJU0evHD3swOaNQvSdPdedbLb3+PhRRAK4fQhVi4mZsxjwMaDFLy0mjut7BldncbOz92obDfcmCgMjff53Zywjt3YH4MK2W/Swm8Cbe1GGFbmLZKNG+9IATGu7ngElZ8WI+JjScrVaTDz0ok+6ERMjUSgUPH9cnGZNLAHIb3+Jmzd8sLY6h6urqEXYrHkWPnrW/KnExEgq9aj304iJeza/pE/bqIwTX19xrDYqf0BTXUpzmJjq07lzZ06fPo1KpUKlUqFUKrl48SI9e/ZUZ4UA3DzthGPPAzSwmUMti+nUsphOl7Ir2DrvKp/c4o5qTm2aTe4AwGHHXdGWz/k7fjMSTSBrNpIQdYY0BeDMwsMA5K8uJv1u7LgCgJ7+rxkf5p9EB2eFQkGLITXY5DKZ4RuEgZVKpWJw9RU0z+rI5UNPkrObvwRaQfEbcrT/gwJT52L/50gAPF28CP4YFcnnMHBAvOu7ecsNQt5+kXOFBqSMOgAuHHlDD7sJTPhtkXrZ8M3dWOvsSJ0uMQtRZ8oujAM+vJV3nUssWU1T1olQtqhynXwfE270HQ7Wcp+Pf7DcrN9zSQfw9Q/yxVh28cRbihgtYtOiewDMWPsbj4MH41BUpPA8cU7Zn3+ijV6+EptbY4KERXfNVKlUdOt4m+IOYkbWyEiHly6/MWNeUQAsQ5ylNh+qkrtI2xnLFyaHX9MZtnXr1ty5IwTfhOqYBITKfQ+ygzlPSedFsY+Y31l4WARtsk1mVL2V+HpGPzYjnTw9Xruz8y8RDTT4v/HoG8e+7zxWcgP5pBTElv2cZIt0f1tw++KU5SjDwtHR16PaP/1ibS9b6D0proWyTtWyfTLUl/uMNI1CoWD1TH1ObhG/saPnVGTPdZ/HT8RAvU4tc1ycSpA3jxh7lCz7mGYtX1KmvBhw9+yemYd3CkuL4int8uwVIXcN1VXJmSUAWOiJSbodqx+zZ/0zAB4HxH5sgzCVkEHWddYsHsOHQpXzsMZpCmUaiBvRf1usYFzthQQFC/G41+zmLLo1AgA/zwB6OvzLiXXXUEYo6Ww7kZe3RO2yNS/HY5Mz8dd2lxC5GpIqy9xS7XVMLKXar1hmx5RJwpChSUORpq9QwCunqqxaWyTWdZQ+cjUoS5s7S7UvlU1+vC17XjKXPO/JmiXccJFPDZd1eY40Ndqy+jlH9zmzasEjAPr9JVLanzzw4ublqPG8jf4Xqe3LuqonBV9J46SkuDzHhUKhoGrVqqxevZrw8HBUKhXHvf5m+6MB9BxfnRx5osbgLi+9WDX5HG0LLVaLjL9lnsmcP48yxG5PiqZMb7sZe+ZCiWblAHj43y31spwl7AC4dk7uN5pUl+eUckr2S+Ae0dohOwCvLj/Dx/0LYcEx76NzFhO1NL+4xn4fItt32fFhUowBkzJuTW5K1nZgk8tk5lz4ExNzYfo0q+cemmd1ZP3kU7E6SicJnSQ+0gkKVXorpJAC+Pr6YmFhQelV69E1EaJggLMTT/4eHa1duaWLMbSK+wIoK2RlswxMuNF3ZDFN3ADz9pbTXFy8X/1cz0ifPttHYJU7gcGdywscmy0nX9lcjNvdO8H9BEm6g0HKn0BkT5pnX8i7TX70S7zTNoCJpIOfrGA5qFKUy9nnD/40zbdE/bxO64I4bmimvuG7cdqJIc128nv3QkxdnnKO3iY6cTsQxoaRQr5257fOnAd3OdOn/Xn1871n6lO5RvQUPc+wlK3X5hqY9O3Xy/hvMvYkZYg8hsqUKcOZM2fUrsyyDBs2jAULFgAQFhaGXgLmVv/cmy+1fSsTuWNP1nkxLsJDw+njMDnasrG7e5G/bG6cvpgS5BPAnJoTAOiyeiC5y8TtUvfJX87hNUkuzyksfgV/dTy+u/sSp2aJqIIR1+aj0In9HC17bZAVOJOyD+n2kpNHSXGFTq4IxdgYMD6cQ6fEWKZ2LTM2b8ij/t1fvORH2w6v1W3Xr7Gnfj0LtcuzDAF6KWtWYqwrdw6IC6VShY5O7GKpT7gpt698oGOtfQBcc+tBRqu4f7ey4sBnyYmOxLo8f3b5wqhq89TPByxoTq12JdXPT22+zYqRh6Otk9E6Ayvu/kWBjL5SfcqmeivVPsLTSaq9Kshbqj2AwtiSy1f8+L3da9attqdB/fi/Fx2L7FLbf6dXWKr9Q8kJZJAXpmTPY76S57Hi2byl2gMUzywn+EUK8iEhEeTLsB6AJ56dMTM34P07fyrm3QHAu9AeKBQKfCPkgjx+ZPyWWGTHGrKTEN/iYLAkwTYnvoyPdXlwYBhXjjzn5NYH3DkX/2/SvGhxMleviWXZcugaygW9xEbrks5xvra61ypeXX1Jt2XdKVi9EP5e/vxbTdRkfh4Sf9DPt8i6PKe0GOfum/A95YJKg6W2GR8mFiYYWxh//WuCiYXx179Rzy0yGWHytY2JhTEm5sbo6sf9vlLD5XlogbEAbHIR4+zOthOjPf8e2e/NzDCc4MBQ5vTcyf1zUWMdhzI5eXHbFR8fH+n7nkiN6URuMJWUTAKUUO8tSdpvavNrxsgmgO/TJzz/dxIABf8aimHmzNwfN577E/6h/NKET9Ca5lsxMUexXHRc0hcjs+gnq5vbL3J96wUGHfw72nL74uIk++rWu1Tpq5bkZXLPwxzb/lj9fMvNnnQqt4buoyuTt4i4gStfR9z87V73NEUFxdQiICCMvOZRtcf6Di3M5LnlNNijn5djx47RoEEDbt++jYWFBba2tty6dYusWRNfc2T27NlqMTEwMDBBMTEuVCoV/5YejmmmDPx1ekqStpHc6BnosdbZkadX3jC7o6i7O/331QDUGtSIs4uPANBwbOt4xcT42Nt3FsYZzWg4o3/ydDoOIsLCcbrxkryVC/5QSrbbQ2e1mDj41PQ4xUQtUfi9ceLmKHGjV2XlYgwzJSF6O4ks/VePUePzUK3mM86c9SN7rvscPexAieLGDB0eNS44f6YgDvnlRO+EuHDSla6Nj7DzbDPKVbFJeIUkolKpyKa3kco1bVi/txbmFrELdza6wnzE2ESP4zca41DIMtrr7q7+ajHx4O128YqJcREeFsFvmWcxbH4DmvVInTpgmW0zstbZkWOrLrNz6jGWDj3A0qEHWP1wBBaZTan7RxnyFM/O6PorAShVJz/jNndMtv2rVCoK5TpCo6bZmLe0dLJtV4Yqlc344FIy1fYXHBRGNauF2BfMxM47PVJtv5pEqVQyudlq3tx/z8onYzE2S57zhaGhLku21GJgp7MUttqES1hPcuTKwB99CrJ55TM6NTzG1mMNk2VfMri/82bNpDNc2C/KRi290Iu8Ra0TWCttYmSiT+3fi1L796LqZSqViic33jN99ns+XziHKlyIo76PHuD76AEA+YaOIGO58inWr07z/mBypYms77+OGY9nkSFTVKafv28oGcyTp+xGRFgEH50+4/biIx9efMT12Uc+vHDH0zWmCN7wz7rUH1gnWfYbH70PT+XamqMEe/sT7BtIsLcvn167o29sQFiQXOZfoE8ggT6BeJK0rKrMua0Yf2JEktb9UcwypWxJCiMTA8Zv+wOVSsWuuefZNfc8L267JrziL45WUPyGIPcPZMiTF+eVywAoNvEfLAoXUr8e6umFMjQUHYO0XSeoaIvK6BkbUKxZZSwyxB41+ejoXb64ePL+0VtyFI2eYpKvTC5e3X7H20du5C4qNzOrRbNEiolLj3ekVFVbder6qLZ72PM47lSs9Mz+bWL21Mxcn7vv2pDBTPMh9D8r9evXF8WMDxygRYsWuLi4YG1tjaGhIU+fPsXePv5IpU2bNjFq1CgAvLy8MDaWi/T9lrVdFgKQu2zMdH9NU6hyHtY6O+Lj4cecP9bz/oWHWkws0awcZdsmzbDh3MwteDxxxsA0eYWc2Li77zpHp+8BIGv+bHRc0hezLHIzpAFefmzpKaJLu24ehZH5z1ebLDlxO3WWZ8tXR1umb5H6s9L58hrxwaUkw4a/Y/tOLxo2eRHt9bevi2NgkLzC8LrFj5jyl6gHldUmZY+TyLycK+fccci0DYDjN5pQokz0DJQ9p+vTus5xggLDqV5U1GdbuLYK7brmIygonBp5hQnL/7bXp0DRpLkB/5Z5FgABPvIR+j9Kg95VaNajNH1KzSXQN4RexeZQr2tZilW1Z25vMQnQa0Yj6ndN3gm6IvZH8fIMxcUlFZw10wCXj79haMu9AOjq/RoTKq/uuDC5edS5zCjDj0eufUuztnkY0vUc4eEqdm54QduuDkxfUoXNK59x8bQbT+57krNoyp5HIiKUHN98n+XjThASFDPyMLtd6k0EpQYKhYIiFXJi17Mxdj37qJeHenriefkifs+eYmInH60ug7F51Jgx0DsQE0sTluxswMC2xxjR9STL9zWOc11vr2BePvbixSNPzly/idsLD9yeuxPs/2PR7PkqpI65nKmVOXVGtVM/ly3fYhpLppxSqSTYL5gg3yDx+Co0BvkEEeoX8FV4DCLQ++vfr8/r9qn5o29HmoAvosSIXTGhS0Qm2FrlSL6yAN+iUChoO6ImbUfU5MrBx8zvu/vHNqiLfApzOiqvrk15JiocFaDclp2olEpQKDDSjxLjPp4/z8uly7EqX55Cw4fFup20lPIcSVwnHB/3L/yvoSNGZsaMvDBVvdw+Y4A6HcYqhwWzL8c/A6FNeU4cqZny/D2VTGcCcDUgKoX/335H+G/TQ9YdaUrlOrZS+0osqZ3ynBi0Kc/Jy4ULF6hRo0a0ZQ8ePKBYsWIx2h47doyGDUXUgIuLCzlzJr6o//cpzw+P3Gb/3+JmfsLdeTHaayrlOS4mNVrCuyfuQOz9jY3vU55fn73DyX/EDVqfc4vR+c7NMiVSns8s+o/La09HW/b7nG4UqlM8wW0rwyOYWk7UI240+Q+KNExYlPgVU56DAlU8XbaSjxcuq5cZZraijOM/GGXJHOs6KZnyDKhdngGcnUOoVE1E3NSpbc7mDTFvnn405Xlkr3Ps3ihEyzOP22Gf/8dvEBKT8nzisAtdmp+JtuzfBeXpNbhQtGWvX/jQuPIRvL/E/Bz7jS7NsCkVE9Wn71Oe5w87xsG1dzExM+A/1+Ex2qdUyvO3RNZdfHDhDY7tNkV7bcq+bhSqGH3C2cFSbmzyfcpzp1ZXOHlM1LnzCGwZo31qpTzLkNSUZ5VKRY+aW3l0U9QLHTG3Nu36x4zI/JlSnlUqFdPbrefpVWcAfutegS5TGsW+ThJTniMJDAijgOVGAF74dsXYWI9Xz7ypVUxMhD0OlksRTcz4zeWlJ6v+OcX14zHH3A6lstFv6m8UqRj3mDq5Up5fP/vCx/f+8Y7ffyTlOT7GHy0hvY4M8aU8A7y49Jy1fddgX9ae1lPaYOf/gEFtjwFg72CJ0wvvH9q/nr4u2QtYk72ADdkdxN+s+bJhljlDorM1UiLl+XuSQ1CMD9nxVUqnPD+//JJlPdbSbFA12oyui6ebD0MrzKNM/YIMXS0Me1QqVbTvKCkpz7ER6BdCV4cZP5TyfDIvmEpWuAmIgN9ea1Oe0yXB7u4Y2cRMtbGuUYOXS5fjeeNGjAM2PWJhI2bOgv2CYryfzLbiNc/3KWfMoiX1qNwgL1eOvebOxXeUriaK9vb5pxr/bXrIzDFXOHCzXQJb0KIldqpXr45KpeL+/fuULFkSgOLFhdh08eJFqlatCsDNmzfVYuKTJ0+kxMTv8ff0U4uJI86nfRF225QjajFx/J25SdqGt4uHWkzssn96DDExpag9uDG1BzfG5Z4T67sLY6/dI9YDULRhaZpObIeeYeyDyEgxsXiLSokSE1Obzc2GE+IbQOf/5mNgmvRI2aQS9NmLa2McCf4UlXJkXa0KhQb0Rkc/7URZ29kZ8sGlJMHBSoyMkv+4q1V4B86vxFjjvkdXzC2TN5IpPuo1scU9oivvXQJoWesY75z8GT/0BuOH3qBuo5ys2F4dU1N98jpY8OxzB4KDIxja4xL7dzgDYJfPItFi4vfcPufMwbXCFOTg29gnqVOT4tXzsNPtH2Z338HN489ZdmsomZM58mPaxMdqMdHdv0Wybjut4fzckzal1qmfH3Pqj5W1qQZ7lPI4P/rAhIbL1c/nXh5K1lwpF6VnYqrPjKVVGDPgMqWyb+XZly7kK2hJo1Z2HNnrzIjOx5izqcEP7SM8LIJDa26zfNzJWF/vPKY6vw+sgJFp6mauNSohIqsj6wYe2PqcUd1Pc8ezN6YZxPXjU1CrRGxJrt5nWsChagEAnG45MafRrGivxSUmZslmQoEiVjgUzUT+IlZ4ZymITd4sGMRhivc9KWXGoiXxuDx2A6IiFJ0ffoj2/Iu7L3+Wm0vvOS2o3i51yodoiUKjv5BJkyahUCiiPWy+EfNUKhWTJk0ie/bsGBsbU7NmTR4/fhxtGyEhIQwePJjMmTNjampKs2bNcHVNeq77w+F/xvlatvr1AHh/8FCSt5+WqNSlJgC3dl6O8Vr5JqJuxv0zz1OzS1pSgLGLxYBqXKf96mVZswu3vGcPklY/Q4uWbylRogQqlYrXr1+j/1UMqVatGgqFggULFlC+vKipc/nyZQoVKhTfphJkfl1RhLnt/B4Yp/EU2qv77nFy7VUAxt2YlaSJqPCQMLZ3nARA04VDMLFKmfSO+LAtac+Eu/MYdWka+auLG5BHR+8wveJoppYbwYdn0a+5m/uJm0pTK3Pqj2uf6v1NDCU7C4F7U+NhKCPksgt+hM/3HnG0eRfO9RyqFhML9OlB7d1bKDJkQJoSE78lucXE8HAl9gYr1WLiy8BeqSomfksOW1NuvGqNS3BnuvRxAODUEVfymm/F1mgTTx+JSCojI91ov+HjjzslaX9+X4IY0VwIAtse9Ec3lSYIEkKhUDBqfXt2fZiY7GLirm3vWDBbRKE6f24ap9HNz8C8UWfVYmLjP4pwM3DETy0mqlQq5nbfohYTq7crxSaXySkqJkbSqXdBAAL8wzi63xmA5dtrA3B010vevvKW3uabxx8Z3XIL9TNNpbH1jGhiYtFKtiw+04PjXn9z3Otv/hhVLdXFRIDKtcWk7Pu3IoLR21Nk+Bza9iLOdX4meq7ujY1DNko0KsmwKRVYtqcRJx534mlQf56HDIjxuOTcjTX/NWX0zCq06lKQXEVzJFpM1JI2cH0snLntiomsQudHQmC0Ly4ExWfXRDS8v7d89meq8JO7PGu8q0WKFOHDhw/qx8OHD9WvzZo1i3nz5rF48WJu3ryJjY0Nv/32G35+USHgQ4cOZd++fWzfvp1Lly7h7+9PkyZNiIhIuntlsIeYQQ35LmQ5T7euADhv3RbreqGSMxgfvOVvhj8FyNXOii/9qtYgkYZwbMZe9TKnL2LQ03lqMwD+13NLvNs31pO/EUtKap4M+pKp57UcPkjvw9pMrvZPYKhcMPCLj3KD+cVX464jlzmbKFrs4xm9zwZGok/BsdR+SQ4ClXI3h8Eq+bpwuiq5vlvpyzlUypLTJGnbD05C6YC0SJ48eQgNDcXd3V0dhThsmIi+OXjwIJUrV/6h7W/sLVJ48lYuSIGaReNs5xkod+zJpo8lBqcH71k1TKRezb8xinxZ5dKws2QQNwir6w4BoGyPxuQoXSDO9klJNwmWdBg2NDWi/cJeTLg7j2aTRYqJMlzJ6g7zcCz1F5fWnOLyutM4XRc3NcNOTpTavuy1QTat6Nt9FG1TF/uaIv1wXZ243SFl+xRbGpJKpeLl9v0cbd6FmxOjIioqz5lEwwMbyVFPrqB7F+cVUu0VenI3TuHvn0i1l01T9f4SSn4TEXGbx8ECp9A+6CVzbbmgCHlxUl9fh1nLKuEe0ZVVO0Qph7AwJbVKHMRGdwMdGp1i33bxXt+HdsZCL0Bq+9mNhHjazG4BAGNXNMEmt2Wc7TObyKWqx5WuFR+yadIvvOXGJh8Uubl+1ZOBPW8D8PB1Q0xM4t6nbPq8bPoyyKdJK33cEtXui1co1uZH2LZYvNdNlzszaWXC5iDFsspnA8mmzsqex8wTmU75+fUH5lQYyr1T4pw/69xges9pkah1H3yWExy9ws1iXf7Q4w8A+rQ5TViYEoVCwZHrzQFoVHRTrOt8S0hwOKtm36J+pqnUzzSV/tVWc++8s/r1XpPrcOjDaI57/c3c/7qQv6R8maRIZMcacb3njv3E+GfnGhFk07KzEFa3rXwEQMYI+fuaxPJvw/sptm2APffsEmyTv1J+hu4bRofZHbFu3ZraTezInc8i0RMVdW3fS/VJ9r5SNl3Yxly+nqxseZUAyftQ2fFVUu7tZcatLl8Fxcw5LYFvIhSLxi4wgvz3lpSyIYlFoZu0R3pB4ynPenp60aISI1GpVCxYsIC///6bVq1E2PaGDRuwtrZm69at9O3bFx8fH9asWcOmTZuoW7cuAJs3b8bW1pZTp05Rv379WPcZEhJCSEjUzZ2vrxABik+ZxIN/JvFw2GCq7thGSLjud6KiLqZ58hLw5jUedx5iUbxkzG1L/ADNDMOkRcXMZsG4+SZ+HTPDsET9YJ3dFBiYGmOXyZ/3vsagEClgKpUKVx+jOCNrZOusgPyNb0qHml9zSrxDbSTOn+RmmzObheAfnPifW+Hs3ngFJP6GqF+ll3gExH3TWL1VES7sfcyR/W8p+1t+AIZOr8GsYadZtegpXYdXSPS+EouJTgi+EYk/Vk10QvBXyX2uoSq5U5hMf5KCm3/qp06mRaytrXFxccHX15fff/+dvn370rRp0x/a5pOT93l76zUAHZf0ibetjaTgD0mrBxsfq/4SEzWj9vXHIJMFTz0yJLBGdMIidDjQfzYAmfNlp2rvBkDcg1TZejogX1PnWyr/XorKv5fC670Xq7qv4Mv7L2rjGYDJNxzR0VNhqJf4foVG6CRY1/FbZOsWA3gGGKoHvs2nd2dlo5cEfvHjcP9pdFg7Mlrb56duY166HPqGib+u+wXrqwex4YFB3Ji6iM/3owQ6y/z2VJw8HANzcTyERYChxHsGWJUjbgE0LmRERV1rOaMjGRHo1Qs/Kpc8BUC7bg7MWVWN+I7rSMJVciPrxNRQjI+mv9vhHmGH82tfmlQ9ymePYM4eFzc0zz07oKurg0+43PXKOSAjQ+utB6BkdTtqtilBaDxvPb5remwkZawkK0IWz/RJqr33syc0rXMBgNOXqpI1iwJVeNzfjVJSnFb6yfUHQGGUQUpU1LHInmD7HTs8GPKnqKuXO58lh+53+hp5mvBx+MrXEitJ8dg3RE9qHd8QPTJJ1Bb2C9HHyjT+9ttGbOH+USEuVWpWhL9W/P71lcSdlwtn9Ep0fyDuCeEsVrr8Pb00U8feoWaRXdx41ZrSZS0pXy0bNy5+YOZfZ5i8ILoR2r2bHjgOv8qdax9jbK9CXXsGT6tF3iJZvnvlxyff9RRy5/rMerG/5/pNxITt1hWPGO1YlswZxfnx2QPPFBUTAWaeKSwlHsle35oUcZFqXzOnu/T14ZxrTN0hPmTPrbJi3MtP8vXxzAzDpERFK9MQqfehr6uUeh9Ju/4k/jjydBHni0g9wumhEBAtsmT4+lwc97mLRAn+sn0S7znmOiHhP29EfXKh8bCYly9fkj17duzt7Wnfvj1v3rwBwMnJCXd3d+rVq6dua2hoSI0aNbhyRTgB3r59m7CwsGhtsmfPTtGiRdVtYmP69OlYWFioH7a2oqitiW1UcdvgT7EPUhzG/A3Ai5nTkviO0xZ1HEVx98tzY0YiVukiZuhv7bmeqn3Skvz0mS5myad326le1rKHqHW3eMJFjfRJy8+Pubk5J06coHXr1j+0ncAv/uwZtQGAv05PSY6upTiD13dj+rWx5C6WtHqRtzaf4sMjcXP9x6axydm1ZCVTjkyMPjGWaQ9mUKNHTQCGHx6Boalm0ldl6f2fMCX7+PQd5xfsUS9XRig5OmE9OxoPFEZtEvi+fc+h5j050ra/WkzM27IBTQ+upfr8iWox8Vfj7KmPajFxyvyKX8XEtI1dXnMefWjH28A/GDiyKDfftMbCMmmpckc23OXpLSFKztyftHTp9ISfTwgVSpwDYMP2MhQtnraLyieF8HAVxYreVIuJK1Y6cORRZ42msXt98EUpec6S4fPbT4wpMkotJg7dN+wbMVEzDB4ljODeOflz4ZQQGrafagLAxqWPef3Mm3mTbmFvsBJ7g5W0rLJfLSbq6iqYvLAKF71HcDVgNAsOtI1FTExbREZ0+3rLCdFa0g9ravbjzZlb0Z7v7Z4+xr8pSWfbiSwesAsfD/9oy52/Cowm5vLZbqmBQidpj/SCRrtaoUIFNm7cyPHjx1m1ahXu7u5UrlwZT09P3N1FEXtra+to61hbW6tfc3d3x8DAgIwZM8bZJjbGjh2Lj4+P+uHiEjUbUnK6EApvD4lZJFulVHK3Tw/18+CPce8jvWBXTRQu/fakFUn1XqIOycEpP2iVrkXjmGUUkXPhYVGDTD39dBRLreWXZm7tfwBoPasLppnShxhjaWOBeeak9dX1/hsuLTkAwMAzc5KzWymGjq4ODYc3YsbjWWSxl4/61hQKhYJB54Xz9t0d53jyn5hA09HVIX9tcX3cWi9xrspOp69zsEk3zg38G9XXsivlxg2m2eH1FOnZHoVOOhodJjOrlr6mXTMx0bvzUBW6Dyqi4R7JYWioy4QZZbDNnbTf9NtXPiwcJiJ49zrHdHT+2QgPV1I26xoAJk0tSING1gmskf64ddOPnDmu8umTiLJ59boCzZvH7syeWqhUKoaUn0vX3JPx+pD8xoq7/9nFnEYicr5gjYJMfzQTG4ekpwAnJw/etwWgbf2TKJUqrl+MitSrW3wni6bdUT+v39yOs0/a4RTah1dBvenSv0i6HxOXKCdE0M+ffiw6W0va4eyU1dGef3Fyk57g/FmYdX8KFZqIccP1Q4/Uy12fewAQ5JfGj3ttDcWUo2HDhrRu3ZpixYpRt25d/vvvP0CkNkfyfaptYhyWE2pjaGiIubl5tEckGfKI1B1VRAShnlGGFREhIdzqHL24/JPxYxJ4h+mDjPai3oDXm6iaEq+vvWR69aj6VxFhSa9JqSVtUL+LqBd2YZ84ET+4HlUXyPmFXOqJFi2pRYMGwlQoV+k8FP6tpGY7kwoEevuzrfdCADpvHYe+cfqI9EvP6BnoqyMVT/y7GbeHIjK08dQeGFmKGlbHB0+PdV1lRAQ3FmxmS93eXJkuBv96psbUXjGDZofXk61ymVR4B2mbIX1v8/eIBwBcvV+XmnXSj+CcHISHK6lXRGSBzPmvM6ZpNIIiuVCpVBQxFQYd7TvloP/gPBruUfLTs8czmjQRNd+HDcuJ+8fKZMigeUFKoVBQ+4+yAAwpP487J54ly3a9XL0YU2QUt/bcBGDQzj/ptrRHkozGUoqsNsYMHClqC2bX30iHuoejvT5rVQ1eBfXCKbQPy3fVwy5f6hucJScNW4n71eePxPi9c18htmzd+FZjfdKS/ISHiAmLkl2E78GTfec02BvNYWCkz6BlbdnkMpk+81qql4+tu4TOtnL1urUkP2lK+zQ1NaVYsWK8fPlSXVfx+0hDDw8PddSijY0NoaGhfPnyJc42SaHE1H8BeDhyKAChX7y406MzABYlSlFui0gbjQgMJCI4OMn7SSvUdewHwImxwvBg15gtrO8jir5nzSe+h3MrT8a+spZ0Q/dJvwEwt+8+BldfTs9aW9WvLZ98SVPd0qIlTg4ePMjx48cB6LJ6oIZ7k/KolEqW1BNlNer/0xkr+7QR+fErYJrJnI7rRwGws888/D6KcUWrXXMB+Pz0DbeX7VC3D/riy6Ee/7Ctfj9eHj4PQM5KJWi0ewWNdiwjQw65Gk0/K5VKnGTbpncAvHjfmLz5YzcZ+Jkpbi7GU636l6dYpVwa7k3KUz3PRgAcimRi4bISGu5N8vL+fQg21lf47z8h4ly/XprRYzT7nW6aeITOthPx+iDq7XWf3pRhazsCML/nNtaOOfhD2z80/SCz6s8AwL5cHqY/mknOIkkr5ZHSTJhRBtMMorZ28w75uPSqI06hfXAK7UObrgXSjKN6ctC5nxAQN68UZTUatxHC/fqVb9Rttqx3Zs2y16nfOS0/TNURwmzozjrx+y3ZWQiK1xbtjHOdX4VqbUqyyWUycy78iXnm6LWMZ3feRJB/GoxWTEq6czo6XaWproaEhPD06VOyZcuGvb09NjY2nDwZJWSFhoZy/vx5tVNomTJl0NfXj9bmw4cPPHr06IfcRM3y5QVAGRKC94P73B8kBLdszVvhMErUssrVVaQ+v1m2KMn7SSuY5xTRAgEfvZhQfAQPjtwFYPjxvxm4+y8Azq04pbH+aUkejDNE1X1690zUCD30XJhbnN73QiN90qIlLr58+ULz5sKpcdipyWkqEiKlWFhzNACF6pehUMPyGu7Nr0fWArY0+ldc29e0+Iew4FAUCgXtjywF4NmeU9xYuIUtdXuzt81wfN+JlLrSfdvQ8eRKajgOQs9IG1EKIiovq8k+Xr8UdY7cfJtjmTFptQfTM9NHXiYiQoWuroK+U3/TdHdSnIFtjuLhJtyvD91pn0Dr5KfvCF9yFP/M/iPJf0O56H+ulCktHJxr1rTkg3slcttpPtrUxt4KgCHl56ojEkv/VoCFN0Rq/dkttxlcYALKCLlUSR93b8YUGcXlzWLCuf+WgfRd3y/NX4tf+3TCPaIrCzbUJkeu9FEiJSlUrCEmHDcvF4KikbEQUl1dokzphg24y9jhD1K/c1p+GIfGwkjo4XahcejqR5lQyv6Wf1as7a1YcncU615PIPdXt+cH517Rp9A0OttOxOm+q4Z7+A26SXykEzQqKI4YMYLz58/j5OTE9evX+f333/H19aVr164oFAqGDh3KtGnT2LdvH48ePaJbt26YmJjQsaOYebOwsKBnz54MHz6c06dPc/fuXf744w91CvWPUNxxMgAvZ4o0qDwD/iRnWzE4CnB6w7sNa0UfiiV99lXW7Rjgs5/c4CWx+8hZoaj6/6x5rZlyfzaW2TKi803Np7CQmG5M5klwFpW1lpe1fZelor2H9Dp2WQKk2n/2k7vJfOJmKdV++dX88b4eEa6kTa6olL3y9R044DEBG9uodH+VSiW1z4QIVMq9Z9n2AAYKOdc9c91A6X3IkD2DvLswCHdbLdHJlCkTAJs3byaDlVxUk7tf2nPbtsvkH+/rxxy3EhYsCqw3cewifd6TcfuLJCBUziVdFtn3IOvanJTfTULOpQ51SlGhu0izX1JrOJlNgtDR16Nwu/oAvDx0Tt32t/kj6XRqFYXa1FPfZMu6bSfl+tb7/VLpdWSI+PhKrv13zrw+3qFkNxc1QPPmz4BHYEu1iUAkhmFyZTZk3VGDIlJe2LXQi38ccPOiG+v/J4wrHvj2xc70S7ztvyerqZzhQlKOJb8QuXPAA6+4zSoWOd7g1EFxLDwN6g+At6Gd1PZ1JBzDAXTMovend2dx7h84xo8OfWOvIagK9iciIvHjHX93V2ysrzB1qoi03bO3CNt3FI5TWLPyuZ3obQPkM/eWag9g/o0792/dKsQakZgpmzkbnCeiZ6CLMkLJ4AIT+JLIuopnF//H9DqipnyOIjmY9nAGuUvmjrP9ay85x3OAJ18ySbX3DJMz9ZF1erfRl/t9JgVZN+LP4XG/58QIu3nzC0HV3z/2sXIpoydS/QEYXVtunZAwufd8+LFtwo2+QdaxGYQztAyy51YjPbnrVf4sMd28v/1+w7+ODUt3bwrAk71npDUEzwC5a2JSHJJlkX0PH711hFD4wC3acj0DPf492o9NLpMZsjJqIsux+Qp62E3gv6UXEnWPmxSnai2ClL2bSABXV1c6dOjA58+fyZIlCxUrVuTatWvkzi0uWqNGjSIoKIgBAwbw5csXKlSowIkTJzAzi7q5nD9/Pnp6erRt25agoCDq1KnD+vXr0dX9MVnX58lT9f/5R47BsqSoP+d18zqvF4gUqDwDBmNVJcqlMFDy5szEIFz6x2RmGCYlKhrqRyR4o3l31mLcr0cVOG26ZjJvv4AyPIL19Qerl7/zNos2QwKpI4qmNNffyBfRDgiQe9+mpmFSomLhHD589k/859S/ynM8A+OO/ri85y6hwVEDihvHX2Ckp8TFI+oEe+GcR7KmY2UyCpESCQ0U4fhGmEjtI1Ql95uTHcwFh8tdXD7H8x1oSTytWrUCoGzZsnTq1Il/7s2XWt8+o5zgHyT5PYP8wOO9T9zH9rOTd3h4SJiBDL8a9V5lBmhpcXInLEJHamAdHK6b4hNIAaF6CYp+9f6sx6dnTry5+pyFlf+M8XqHPTMxsYqsvxX9/X2SOG+DvAAJMCv7REDi5jpcTpjStXaQaq9jFlVi5vVLPyqVEBkN7f/Ixf9Wxl5DMkRfTkwAeVExTJmyQ9z4rm9+PiH8UXc/ACced0JPTwfngIxxto8NjwD564n8ja9c+7JWH2JdfmDbKxb/K8z9Hn/pjpGu+K5M/OSyHyI8naXaK30/R3tephA8PGVKsboBXLgaRo7in3l81hQLs6ib8yWblExf+Jna1fTZtCT+OnonzoXQ/U8/AIyNdXj2qCgGBjqoQuOenAy2Lo8JiRez3MMySovHHgEG0UTFmk3yUuz+EHqUWMjZLbc5v/0Ou13HoWuowx7XcSz86yhnNt9ifLVZDFvTgdL1Csa6XZ9P/gwqPVv9fMjmnjhUzIM4z8X9+8uXSX6y1iHDJ6n2GXQCQGLeO1hlJHXOcA/LKH2OkZ3Ult1+YifBdQlHoVBQs25Wzp3y4N3bAHLlNqV7H3vGj3zInu0udO0VU6y/G1xYqj8AS67kJ4PEdctIX+49NyjglnCjbyhj7Sk9tr/0Xs7FW3a8J3tv/Mwj9vNQxeFduTZ3A9dXHaRM/3YUaNeIO+sOcX3Jbkq1r01wuC4qlQrP1+/JnC/+MgRZMgRLTcIa6Cql3neSJnhN5ET/jw9FOv/Vg4/jLLtQol4R1jo74vXBh9kd1/HRyZM9s06yZ9ZJ8pXJxZ9rOpHBMu7xeGzvOTmExqS4NiuSN84nRdGoFLt9+3bc3NwIDQ3l/fv37Nmzh8KFo05uCoWCSZMm8eHDB4KDgzl//jxFixaNtg0jIyMWLVqEp6cngYGBHDp0CFtbudmN73m24H+83bZd/dxpxTIA3A7sVYuJhSb9G01MTI+E+QdwtHkX3C/fiLY8PCQUz5curKs7EFWEEoWuDt1PLYkhJmpJP1RpXYolj8az1tlRvWzr3Eu0shPHs56+DkUq/NjvRouW5ODYsWPs27cPgBs3biTQOv3j9daDQ38LI7IBRx3R+YlqPKVnOi3ti65B1DWvYNNqdD+1hJ7nln8jJmr5lnOnPdRi4tQ5xeMUE38FIh2OHZfWJHc6N39IiDvXPjK06xkArjp1wsRUfqI5OcloqcD1VgbKlRDn0iK1Arh4PUr46dxGiP5nLgrB0c8/pqiqUqlo0O6LWkyc/m9O3rwojoFB2j0/W2UzZ++Hv9HT10EZoaJVtql8douqq/jXuqgoxjWjY9ZVPPC/82ox0TpPZhY9d/wqJmpJq3ToISZ/bl0RmVbdvoqGG9c4A9CukwgSWLfqTcyVtaR58jQQac/P9ojrqo5ezLRnpwv32N19Gq9O30r9DqYykSnM9iWFmPju8Qd62E3gxc2YRkSZslkw/exQVr+eTL1eogzeq9vv+LPkdHrYTeDZVacY66QoCuQdntN2dYlopN0ro4a4OWgwn69eBaD0anGTF+7rw8u5s3i/U4iMxRcsIUN+uRn8tIbHrfuc6iRSUszz5KbB/g0UH9oXgEMDZ7O/t0j1LtW1MT1OL0VHLx0l8muJFeMMIpqiQR9xgdowVRgJjF/Xiv8+jkVHJx2dubT8lPj6+tKwYUNARLCn9VpNP0pYcChr2ohzbbtlgzC1kkvp0pKyjLs+i9YbJtHz3HKqDO/0U10H7ct8Jkfxzxw/mzy15lYve03bppcB2HGwMr0H5E2W7aZHutYX6d4lylvTtqd8BFB6wtXZj9bVxfs9dL0VNjnkU19Tin1rTJg3UYx7OgwMZoSjMFG0MNfB9b4VxQuLm/OClb24cjMqQvD5q3BylvDk4VMRWfXwbhG6dZXPZNEEuro67Hn/N/W7iKyqniUXcv3YcwBK1Y2qq3hu62265J6EMkKJ35dAOttOZPdsIQqP3PgH/5wYpp3cSgd07lsIgI3LRVZdvUYi/Xf9KiGWWFiKKOcnD2Om1GpJ+0RPexbX6hI9WgDwYOdpAGzLiWPg1KS1qds5DeD04D0A9sVzAHD7uEi/D47HhEVHV4f24xuy1tmR4Zu6qpfP6rCWHnYT2D3zBEqltiblj6K9WnzDte49Cfkk0ieqbNuCrrExBf4WVuTed4TyX3r1BgyzyIVKpzXuTFvIbUcRmVZ8SB+qzHdEoVCQrWoFALxeuQDQcu0Edb0GLT8HG8Ye4NjKy+rnRzzGUq15IQ32SIuWKCwsRCTP2rVryZEjh4Z7k/IsqD4SgCp9G5GrTPx1ULVoBsvcP6db8/i/hPDTY4gfOYp/xss75oDa0dEZG+srNG/2MN6ac0P73WHc18L/V+7VpVZd6zjb/uzs3/yMa+fETc+OC6003JuUxc83lGoO2wBYvvM3ipZKe6Jb26b6XD8s0tu2HwgnZ1l/gkNUKBQKjm63ZNY/osZcm56+jHH0Z/x0f2q38gagYytD3j/ITObMmo24TAoD5jRm/OZ2AEzrsjNGXUV9Qz1UShVd7SYzoPhMADLamLPuzT8Ur6W9FqUXipUWv7n921+zdPZ9Ll8Q97C+PvKlNLSkTSqN6g7AvbUic6dwO1Hj+dpS8VzfJKrMSnLXwk9rOH8VFDNlF/cKTvfFc7viibtfKFItH2udHVlwe4x6nSPLLtIrz0TG//Y/vD38UqDXAoVu0h7pBa2g+B3GOXJQdcc2FDo6qCIieD51svq1kstWo2uc9or9yxDq58/H66JgdK21C8lRuyoAPi/fcPz3Hup2rTb8Q6Y8P/8N/a+C6/OP9LCbwPlt0UPilcqf++KjJf3QqVMnAIoWLUr37t013JuUZ3OPeQBkdchB5Z71NdwbLb8aPTsZ8/hSVB3DYtW9GPtvdOOg3r2zA3D9uh85sl9lz+6YNc+qVrnL1o0i3ejF+8bkc5AzUPqZcHX2ZXRPEeV1w73HTx1hHR6upHjm9QCMnlae+i3kzFRSkxw2Ory7YYp1FvF95C3nycMnIgW60+9GXD0ialtu2hXMum0iivHELktmT0rfx3K5eg6svT8EEE7PkRGJOro6LL4zMlrbIava87+bw9HTT0d3sF/p2vo8WfS2EBwsV6vvZ2P6uFu0aRIVMJDVZB9ZTfapnxfO/R89Ol5n4eznnD31ES/P5HdC15L82P9WCYDne0VEos43HhHKcHHMF2tTC4AXx6+ncu9SF8/3wlQq8toamQJtbiUXGW9uZco/B/uxxmkKzYeKz87t5Sf+Kj+LHnYTuHf6eTL2+iuy6c6Rj3SCQvWzy9mJwNfXFwsLC0rNmolpblFvIjwggGs9egFgYJWZUM/PGGa1pvj8RfFuKynGLLLIFtI3/K4gbqC7B8bWWdQ/yKdrt+J84BgAuRrX5d1/p7C0y0br9RMTtX2tMUviMDWV+94K50icG18k/avEPAGqVCrmdFrP0yuifkqJOgX4c3UnTq2/xrbJR+g4oipdx9WQ2o8MmYzkBiyyBa7h5zBm8QvRo3vu8dLr/SycPn2aunXrAqBUKmPciP/7cK50wWdNGbOEBIQQ6BNExuyWMV6LNGa5vuEkF5YcBmDkjYXS+42LtGrMIkNweMrf0Mq6W7vFY6gTG6lnzCJBPMYspy+G0mVgVErc/g0WVGxQRP189ux3zJ3jqn5+/0FZrKz0yZnjqnqZm2/zGE7OCZEUY5a0RqQxS0SEksImywFYf7QZlWrHXjA+NYxZZEmKMYu9wUoAWnTMx/z1teNtn9rGLPGxeH0oMxaL38KwvsaMGGjK9n3BDJ8YJaa73LOKUQJGJ2P8hgffE2xdXqq9e5jccQGJPzYiIpS0s5tBWIi4F2gxpAb7F4qSN7p6Oqx8Mg4D45jjWV9JB/DUMmZxHHeXS2c/cvyqiNRat/wFowbdRF9fB7egDtHaB6vkzsVJ+R40bcyiUqlwfevPg9ufeXjnM2eOOPP0UdJTnK1tLchXwob8JbPhUDIb+UvaYJ4p+jVwyRW5KNbUMGaRJb0YswBsqdsbgLaHFqFvbMTjHce4t2oPFfo2p9Qf9UX5nN+GAtDv4tI4t5MlQ7BUnwwkx3spbcwytMBYALUfQA+7CdGe/wivbr9jWutV0ZbV6lyejhMbERoUxsBiU/Hx8cHcXK40UaTGdLYSZJC0ovAPh1pXSdJ+UxutoEjUl1194yr0TEwIdP/ItUF/AZC5ek3s+w7gZqe2AJRauQ4909iVcFkxMSkkpwOmMjSUB706qp8XnD4f+8JWHG3eBYCGBzYmuI2EHKRj40ugnHV9SvPY2VJ+pTDJk6a+3PeWL4fcYGBQjacxlr289polXVern489MgzrvFkBIdr8VehvADa5TI6xbnIg61ooe+GCpF28UpL3vkkXyn9VQdHf3x8zMxEJ8vbtW3Lliuk0/u/DuVLbtJMUE+NzSI+LuISvv0uMJeLrrHGtPrX5bXA9dHR08AwQ5z3Xe6/Z1ud/AAy9MBt9o9j3LTsAN02FySljSeFBVqRNDie9hPCUvP7IioNektvPbi5/Ez7aJu4bhthQBiU8OaVSqeg77Av/nRA3HJms9Lh1qwwmJuI4DwiIoGSJW/j5RT8u7e2NuP64oVR/AJSGcoPjlHZsTgrfujyXzryKAL8wOvQpwqRFsU/SaVpMPLn+OpWaFyNDxihx4FunYICFgw8Q4BvC8OUtMYxFZCpu+ZGq+bfy/q0/eRwsOP2oXbz7NP7ySKqPKSkmRvLMWZff2gfFWL5ylhGNasc8znTM5SacdfLKTdJ+DJUXsbxC5bKlQiN0WDTiKIfX3lEvG7uqBTVbF4m1veyxlxQxMaeB3HdnGOYFQKNa57l13Yu/RhdgzERRozQyEm/OopJ06SmiZRUGchNBHuEp7zwvi4We3FhGERC3QKtSqXB5F8SDez7cv+fLg7s+3LkXgK9XzN9CYjDJmgkrh9xkcshNpvziYWQZM6rXSE9WTIzdST4u7CzkPiOAG25yv7mUFhMffoi/P2/PXOP6zFXka1qb0oM6oYxQsruREBl7nhMTWWtq9gOgx9llsUbHZ7eQ+42mNTERUlZQjCTQN5gl/bapA3EALK3N8P7o90OC4rkqSRMUa15OH4Ji2huhaRif5y+5/fckAGw7dcGmURMA8o8cw8vZM3g6aTzFZs/XYA+Th4DXL3k5WfwwdU1MKbpkLQpdXSCQbNUr8eHCVdyv3sSmUjnNdlRLkvj3t9l8fuelfj54cx+1mAigoxN14g8JCsXQOOWjILRoiY1IMXHZsmWxionxMaH4CAAcH8xJ9n4llTGnxrHsjyV4uXpxduUZzq48g1lmM9ouG4yRualaTOyxY2ycYmJ8zKs7kQBPPybcnZfcXdeSRgjy9mdFQ3F97nlgCmZZ5QUHWRQKBSsXZMLNPYJytT/i5RlOHvvrjBmTi6HDcmJqqsvLVxXYsvkjw4e/BqBN2ywsWpR89dZuXPagWfWj7DpRj2p1siXbdlOaeROuEeAnxPm4xMS4iIhQ0ijLdLqOq0HHEVVTonsAeH3wYeOEI2yccASA6acGkrNA1hjtzuwQtTDb5p5BJhszZh/rQebsUTcy/dud5P1bEc2XkJgYH/Z216hU2ZytW1PftKZQPl3eXDUlT6UoIeL5BVNMTVIuRd3HO5QCVtswzaDHa59OKbaf+Bg8pyEVGziweeYFZh74AyOTlK0NqVKpaF96Ne9eeHHqw1BMzZMnmODgyWpkNz/AvJnP+aOHHTltTXD61BT7LIcYMfgezVrlwDJj6o9p377yYfKf57l8WkRz777yO8XKxPyNaQqFQkGu3Cbkym1Ck+bi/HovvFSMdiqVik/vfXlx9wMv73/g5T13Xt13x8czuiAV6OFFoIcXLpfuqpdVHtsL+zoVUvaN/ILkqlWB6zNX8erQGcKCgokIjhLi9vWaSkRIVADH2lr9U7w/xhYmjLs4JcX3owlMzI0YubU7KpWKk2uvst3xKN4ff7y2okJHPGTXSS9oBcVv+Hz7Ls67xCxX8THDMSwWdVK0LCkc04Ld3hMRGIiuidzMV1ojUkzM1rYT1k1aRnutaP9ufLhwlbszFiUqSlFL2uLzO0+1mDj68BBmNlnIoj9WsuD59Gjtes9twarh+9k18zR/TJKPMNGi5Ufp1UuUlciTJw/9+vWTWnffPzsAKNagZHJ364cwy2LGqONjUKlUnF15hhP/O47fZz/WtJmmbtNo8h9Y2cubfTw9/YAAz5QrGq1Fs6iUSg6NXsWbS1FRXRkyx50GlRJkt9HF/WNltm/3YOiQV8yY8Y4ZM95x7nxJPD6GqsXECf/kZuDA5Kuz/NbJj2bVjwKQLWfaGV9VK7QL51e+VKuTnf9trEnmrNEjw+5dd2fFLBH19ci/r/T2h9XfAKR8PeNM2SwYtaULszqJMd3YuksAGLexLRUaFFC3O+AxgbM7H7Bg0AG83P3oWVKUZJhxqBsPLjlxbJ9wj30V1CvJfRk79g1BQUo+f9accYSBvgLXWxnwD1CRwTRla10eP/iOri3PAlC2omZNHcvVzUu5uinvwO79OZCGuaNKRJmYJZ/Ap6enw8FT1WhW9yKlCxzHI7AlpqZ6rNlSnp6dbuCQ4z88AlsmvKFk4Nq594zrc4b3b6Nfl7PnykCBYlap0ofkRqFQkDWnBVlzWlC1acEYr2+8YwcI4THQwwuvl2/xfPGWoM9fyFbm53a11xQKhQJdQwMiQkJ5e+pKtNcijVRTCl09XfSNDTAwNkDf2AB9Y31q96+XovuMjciE2sw5LVNlfwqFgno9K1OvZ2Ve3HzLjDarE17pF0YrKH7Dk4VLqbVzEygUKBQK/L6LxM331yhezZvFU8eJFJ0+WzOdTCaKLFqNQk8/1vRtPZOoAbMyLBwdfe1hkp7InMuK+c+mxQh5DwkIwdA0aoa4WpuSrBq+n+NrrmkFRS1SuLi4sGHDBv766y9Mkji5cvHiRdasWQPAy5cvpdb1++zLnf03AWgzUzPRHgmhUCio3bcOtfvW4ZOTB3ObiCjKzHlsKNJQPvJbGaFk94j1AIy8MDU5u6olDXB/70XOzt6pft5y4UByl495M5datG+fld9/z0LTJg+5e9efmjXuqV/btr0QtWolX9Skn28oFfLtBWDDvlrkK5A6Iqqtvjj/lKmYlWXbapMtZ8zxULf+hZg0/DoXT7tRKsdWAP76pxR/jitJQEAY7aqLfh+53wF9SUML5ycePL8jaoX9Maraj7yVRFGsel42uUzmo5Mn4xsuJzgglGldxDHXYVQN2g2vhkKhoFbb4tRqW5yXd90YUV98RmOarldv55FXd3R1kxY68fp1EOvWugNw7FjxH3tDyUBKi4nt6p/g/CmRwrlofVXadE55MU/TXD/lxNDm4riq2igfs3e1TvZ9VKycmao1MnPp/GcG9b7F4lVladoyBzlyGvPeNYiZjk8Z41gm2ferVKrYs+4xkwaejfFakVJZmLK0BkVLp52oxJREoVBgam2FqbUVtlVLa7o7Pz2t9i/B560bugb66BoaYGmuQM/QAB19vUQZgKV0ynNK4+X6BQD7EqKebWRpoRwOUb+359ecsCueA0OT5I1Qti1o/eMb0f36kCEdFSVMR8GUqcPb/Yfi/GFmLFMWgKB3b4kIlitsmtbQt7CMsxYkQOG+oo7i800742yjJe3y7THcbaGok7l17O442wT6pu/jWUvqMmnSJCZMmICpqSkKhYJ///2X8PDE1/ALDAykevXqALx+/TpaCn5imFVbpFr0WNMvXTipnltzDgCFjoLu28cmaRsbe4mIoio962JkJlc/S0vaxeO5CwsqDVaLiRW6N2Do1UUaFRMj0dNTcPRYcS5cLKledulyqWQVEyMilOTPuA2A8TPKUL+ZXNmDH6HnYFE/7vY1D8rbb8dWfw3Txt4gLCzqRqrnn0VxCevJzlON0NMT55p5U+5iZ7SO0laigPuE+dXIW1D+M+lbVay/6pp8ZOOPYG1vxapnf7PyyViKVBKf97ZZ52lh/S9Tu+wgJEhEDuYvlZ0DHhMYt7Gtet3LrztimiFpqbIqlYoqlUV65LHjxWMYn/xMfPoYhI3uBrWY+NCt7S8hJs4edkItJk5e1zRFxMRI9hwRJQJ2bnHhySNRJ/bmExE5NXf6M967yNfWi43AgDDm/n2ZIkaLKGayOJqY2PD3vFxw6srzkAHsvdYm1cTEkf2u8vlT1Lg9ICCMwED5Ospa0g8KHR0s7XNilsMak8wZMTQzRddAP12MgZODdw9FKQH7EiIz4sMrUS/Urrh4Hhocxsz2a1k3er9G+pcgP7nLczrqaurwZutOVMq4Vfm8Q4RZy7N/J6VSjzRDroZ1ANTuz1rSLyUbFAPg/vGYxdH/XCFqIG2ZrP2etSSeNWvWsGXLFvXzCRMmoK8vBjbr168nIa8v06+TGQsWLCBPnjxS+75zQEQmGpsbY18un2TPU5/7R+5xe98tAP66nLS6hx6v3XG5J1INaw9qlGx906I5Qv0D2dtyIFu7zQIgi0NOBl+YT6U+jTXcs5g4OJjg/rEy7h8rky9f8orZOQw2AdCyvT2DRhZN1m0nxKR5FXEJ68nBS00xtxARDcvmPCSPyTps9ddw4tBbddtKNbLhFNSDtyE9GP1v2Wjb+WNAMel9r50iRIlilXORy0HO9CO5MDYzYtqBruxzH0+zvqLEz41jL2ibewY9Si7E84Mvn1x91FGMc070JLtthiTvr2uXZwA0apSJkiWTvp20zp4tbyiW/WuEXm0b3CO6ksX6554ECg9XUsl0JntXCsF479N+1GubsumvCoWCC7fEvUrN8mdQqVTo6elw4ISI9i1pvz/J23Z39WdI+yMUMVpEOavlrJ0bZWbTZ3RZbn/pz+PgwSzYUh/r7HEHZ6QEKpWKTateUL/cYfWyvOZbyWO2JZ61tGhJ36gFxa8CotOD9wDk+Rqx6PJERL6bZUo7JVN+JbSC4jfkai4MWB7NE3U/YnPAzFS+IgCBTm9iRCmaJMFlU5aUdsH84CN+iAqFAn0zcZEM+uQZZ3szI/kaOBklXZ1SmiJ23vIrSbo2y7pCv3ov5+a0+HyheF8vXEPUSHp8NsoN2jPQgHKNxIDvws67sa73I8i6BCbFISytheTnME9apKesG25aoGPHjqhUKiIiIpg9O6oERPfu3dHR0cHAwIDjx4/HWG/QoEEA2NjYMGTIEKl9RoRFsG+CqJ044uSEONs5f5Eb4FuZyDmSQ+KcCz85f2LbSJEmOf7CP+hIpAkGh0XlRqz4XYhO/XaPirN9QKh8aQpZJ0LZ41TWFVo/FX7Psq6CWTLI/aYzJbB9lUrFtRkr2d96MOGBYtvd906i04bR6CayvMhM9wFSfdIxlkshlnba9fso1R5AJ8SXakX2A5DLPgPLtlSPt72+TsqNr0pVyMrjz515F9qDKfMrqpf3bHUKW/01NCi7j3dOokaajo4CW7soMexZcOIL4NuZipQtf59gdiwQdbBmHfwjzvZZTeXPS7L4huiho6Ogp2M9DnhMYMiiZgB4uvnSo8RCepUWJlKj1rQmf8nsPPCWS/0KyihE4jt3/DhxQrz/tevijr7VtbKT2r6sAzOAKlzuc02sk7RKpeK35m4M7HIRgPV7a7H7ZP0E17M2+CLVH4BMBnLOvLJjJZlj76OzF9UsxBjA0FiPS74jyZYr4XOOa6jcdxeiH9OFuWBhczp2yQ1A83ric69UNTOVq4ltD+55NdHbd73zgpZlt1LEaBF18q3j1H5RL1ahgKmr6vIoaBCPgwczZHIljIzFuTpcJZvDKIdPeMyxTGREWmwRmCpTuRqdJfXkx/5dSjtLtQ8Ol/uMjj2PacgVEa4kIjz6MRxZd9bZR17QLZ9d7jcnOzaJTT+Ij2LZ5M8BsuM3Nx85oU32niwp92OegYk3aooUFHMVzQ6A030hKNqViC4wRkYspjUiTVlkH+kFbXG8b3Bo35R3Bw7z6doNdMP88VbGnsKSZ9AQ3ixeyJMJY6M5Pn+RFFCSIg7q6yoJkRCnZPeR1TyYz/5GAOQb+TdP/xnHzelLKTwl9ppdsu9ZrCPn9CZ7Ipd9z56fkjBzrK+UExXDdKRERRubAPyDE3+x6F3tebwn5saOXXhS/W9W9duodoe1MgnBM9AAAxMDQgNDeesaSoZMyRc1YGUSKiUqGkmKDwDBkgJHUvYhg6yI+jOgo6PDiBEjGDFiBEFBQYwdO5aFCxcSFhZGgwYNALC3t2fPnj2EhoayZIlI3XV1dZXe17IOCwCoN7QxBvE4kxfMImdc8t7XSLoviRnMzW0sbrJ6ru2Pv34WSFiDVBM5WXNm0X8A2Ja0J0veuI1cTJMwoSU76JUVCGXXCQrXkTrfJ+Ua6heiLzXwfS85CPcL0Y/zPbw5cYWrs9apn9eYMpDqTSPTIBP/XQzIvBGQuI6Gh0iJigoTufRdHTP5+kID+z7g5TORpnjjVcJpkWHKlB+uKhQKug8qQvdBRfD1CWV0v0sc3u3E4/teVHEQEWdtu+Zn5wZR8/Xq++5S6WbOAeJzbW0/F4AJG1rHm/abGtcTc8Po543a7UpQu10JXtx5z8gGawHoNLYmVZqKycfSGd2ktq/nfpsIpYpGDR8CcOVCIVShcdfyUvp5SG0/4rNcfwAUBgZSoqKOeeYE2793C6d83ai+v3jfWDgNh/gmuP0vutkw0pETOX0jTMign/hzRrhKV2r84xFgEOPYiI0z2++z8M+DAPwxuBQjZ9UgsecyWSFVEfAp1pJi8xcXYevGt1y77Mnlc25UrmrF3sPlsLE4yvYNb+g/yJ5CRWJO0qtUKg7sec+QvncICop+cbbLb8nU5TUpWzX7N0tjfn4GCrnrrp5CYhAAGCmC462jpqMMQ6FQUL9JDo4ffs+L228oUNAs0duPzeU5IfY9ziE1dkjM5Ou31Mob8xzQPJsjIEyjAEY0WMPLO24c8JhAVtNQaWH3zge5oA3ZsYas2HfznfzEiJlRmJRYm8dKblwsKxAmJSjExizxEyORgqKfZwDGGQzVgmJkfUOn+9FTotMcCuTD+NJRNns60j5Th5KjRPTMpaHj42xjmFUcvMFu71GGpvwMsqbIkFekEwa8ljNM0JL2+LbmWrBf9BN4z8UiQmLXpAOp2ictPx/GxsYsWLAAlUrF58+f+f333wFwcnKidOnSVKwoon+eP3+Orq7cAPDDs/d8fCHqUVXrUSt5O54CqFQq7MvlpeHIZtiVTVrtrGC/IC6vPQ1A1zUDk7N7vzxhIWFMKD5CnUKfkng7v2dL3d5qMbFAqzp0OrWKnJVLpvi+0yLLF71i1yYR/eMa0lnDvYkdcwsDlm2rjUtYT47dbEHWbEJYjhQTNx6qR6bM8pORV/57rv4/NgfVtIJD6Rwc8JjAAY8JtB32Y4YxvzUQ77lnj8zY28tNKKcH1m8LUIuJTeob4RHYUoiJPzkT22xRi4mrjrX+KiZqhrtPxZigZaPrhIcrUSgUnL8p0qFrlDutLsMSEhLBvBnPyGqyD2vT/fTpclMtJtZokItTTzvxPGQAxx91/E5MTFv0Hiyyjk4fE4L6n6NEPdglC95orE+pQWRUYo48wkH77tnXmuyOllSkSA0HAMbUmE8Puwm8fSSOfT0DMdkYKTDa5NFMCZG0wogRI6hWrRqdOnUi9BuNKjw8nG7dulGtWrVo2WFjx46lUqVKVKpUievXryd5v1pB8TuyVSkPQNDHT4R8+hTjdd/Hj3j6zzj18xezpqVa31Kbb2tJel65pMGeaEkO2v+vFwD7xm2OtjxfBVHDLrYai1q0JBUrKyt27dqFSqXizZs3VKpUCYCFCxfi4OAgvb2lbUU0+NDDY5K1nymFQqGgx5r+VO4cfypnfMyu/jcAv8/phkLSuEZL/EQOQvdN2MG5ladSZB9hQcHsbTeS/3pNAiBD9iy0+28JZQe0T5H9pQdOHnXnn9EiWu25Zwf09NL+cV2kpBW333XgXWgPZq+sxtKttajVwFZ6O0qlismdhTna7jd/JXc30yRnzvry5KlI7f93ck4N9yZ5USpVlK3tzt+OItJ2+xorVsyPmZb7sxHkH0rzrI7cOy/Eqy0vRlC+hvzvITnJnsOYUePyA1C26DkAChUxp/0fwnTI2nQ/WU32YZvxIDOmRJX+6T0gL6/dm+AR2JKVB5pgmyd1HOZ/lP5DxWTEotlPAChfWaQ679j6XmN9Skna/iUMeE5vuwdAt4l1AVg68oimupSifH7wlPNDJqqfB3/x5mCTbni/ctZcpzRM7yUdmXJsILr60YMR1o/ZT3hYBO5vRGkKWZPH1EKhm7SHDHfv3sXd3Z2LFy9SuHBhdu+OMmM9dOgQOXPm5OLFiwQGBnLlyhW8vLw4d+4cV69eZePGjcyYMSPJ7y9tfuoapvI84SD6YGj0iBDvO7d4Pk28VnDCZAD8nj5BGSZfRzCtE+rlxa3OUTc9b5b8T4O90ZIc5K8mUpZeXYoaTLk+cWN4kahoXG93n1Tvl5afH3t7e65cuYJKpeLPP/+UXv/Y3EMA5K2YH6tcv8bs47OzD9X/F6pTXIM9+TlRKBSMPCXSp04vPsaBKbsTWCPxqFQqri/YxM6mgwny9Aag6XpHmm+chp7hzx+5FBdPH/vSqbWoaXbtRUssLNPXZ6FQKGjf3YGmbeSMpCIZ01KYJrT5sxJmlj+3SQdAaGgEnboI0enBnSIa7k3y8sopHNuiH/jgLibeX96yoVqlny/68nte3nWjfZ6ZAOQpZsP+j+PJkEaO5eFjhKD4wS2YuTNe0rj2ebZvfhej3fS5xfng1wKPwJZMnVMcM/OkuZZrEtvcojzRlQtyJQLSK7//KQTFpcNFCZiM1uL9e7zz1lSXUhTXc1fxef0W9+uixqXiazG9SyP/1WS3NE7OgjasejmJZU8mYJ5Z1M68sP02ffJP0mzHEsMPuDz7+vpGe4SExF6r++rVq9SrJ5zuGzRowJUrV+J9zczMDCsrK8LCwvD29iZLFrkarN+iraEYCxZ57dT/+z17ilnBQnhevsibpcKspfDUmZja2WPXux/Oq5bzcs5MCoyNO0U6veF17QqvFy0AwKpKNTwvi0LHKqVSGyWTzilUtwRPT93nycl7fH78mvMbLgOQv0IeXl5/w7a/99B/TQ8N91LLr8C6t4kbGAX4BHF5w3kAuizvnZJdSjOolEp2/SXSY0deiL1+rZYfxzyrBX9fdmRqlQnc2n0Nbzcvui7vo37d+8MXltcfgV3V4jSY3i9R23x34TYXpyxXP6/yd2/sapVP9r6nNz5/CqFGOZG+v/94NezyytWwSu+8ef6F+xeFa3SvSbU13JvUoVT2r4ZU47KRJUv6E23i4n8r/Ji5UNQj69LehOn/WGq2Q99x7ZQzg5vtZt25ThQtH9PgIqnsmHuBrTPFtbjX1Po07Z32zmsv3v2GQ66TzJoWVarJKrMBk6YXo12nXBrsWcpTqKgFTx/54OUZSiar9DVZkxCGJuL8EZnyDGBbIDMuzz/j7uKLje3PdT0p0rM9705c4IbjQpodXo+hpXh/yrBw7b04YGhiwIJbIlvp1PprbJ30n/q1HnYTGLyyI6XqxW9Wmp6wtY0eAT5x4kQmTZoUo523tzfZs4tSDRYWFnh5eUV7zdzcPNpr+vr6FClShAIFChASEsLRo0eT3Mdf+4iMh1rrRETeM8eJeJw+qRYTi86ej6mdPQCBzk4A+D56oJlOpgAv585Ui4n5R4whz4DB5GzfEQC3fXs02DMtyUGzySLqdM+ojWoxcfShIQzcKISa55e09TK1pDyJFRMBBpcQZSU6LuyeZlMZkpvdA8X1p0rPutHqn2pJfozMjJl4S6R5vLrygnmNpqtfs7CxBMD50gN2do3/mPVx9WB5tQFqMTFvw6p0PLlSKyYi6pYVzi1S0+YvLaV2YP2VaFh8GwDLLvbScE9Sh92bXuLrI+o3Dewvb9rzI7jJm44nirAwFXlKuqnFxEPbMqc5MRFAT19cJ7vX3MKwVnvV9QOTikqlomephWox8X/n+6ZJMRHAwlKfnfvLUbtuFi7eroNHYEuevmv8U4qJ9ZsI84nnT0Rm0eCRIgp43aq36jbW5kcYO/xx6ncuBShTV9T1f3lP1M7rP7sxAAtHn9ZYn1IKfdMoMzhluDD+cejQHIDX+45ppE9plbrdKrLW2ZGRW7urly3qs5UedhPY/M9hIsLlTIFSih9xeXZxccHHx0f9GDt2bKz7yJgxI76+wgjM29ubTJkyxfva06dPuXv3Li9fvuTGjRtJyiCL5Ne4O0sCRpksMbMXF6C3a1cBUHzBEoyzixP468UL8Dh5HIDSq9YDkNFUzqBF1r0Y5J2mErsPZXAQb/s3w/vObQBKLluNZanSABjbis/Bbe+uGOvJvmexTuyhunGRUu85EqssiXeZUiPh2AzIOUID7u6mUu1XXSyQqHaB3gHq/02tzJj3ZCrZHIRzbGRdCq/3cs57ceEZKDdDKuvYDPKuzUnZhwxZk/B7AHlHuF+F28eeqP8vVCvxKXPPPiXe5RAgh3mwVHuQd0i2SuR5z9PpA+/viULjtQc1SvT2A0LlEw5kj7ugFP79yLpIJ+UaGtv3pmegx+R7swD44urJhOIjUKlUKBQKJt8Vy73euLGy1uAYN+fhIWFs7zSZbR0mifeQ0Yy2BxdRcXjXRDkAv/GUO1YBln7uIreCnlwqpipQ7hqg9ItbwVGpVNhmFMYNfQflpVM3OwB0EuF++y36OvIu5imNiU7iftNLpt0CoEjpLOQpknhxLanXExl8Q+TOG3e+JGxU4ecbyrAeFwB46iVnuqNjllWqvW7m6P25ehcqtoFc1cE/DjNplaSZotL3M4+ehmFX4gMhX1d9cy8bpUvEPsYJc5YrbJ8x4oNUewBz3ehv7tvIrbI1crHvkRCuLx17Q3nTubx/FbMmfHxEHnveHv60sP6Xz+/F73W3y1hyF4r5HTn7yZ/HPobKucmrTBOXjlejdha27S2HQ365815SvodQldzvR9aNOFhlFOdrkUYsi+aIcVKLtrnF8/nRjUrWfiMwfk9JvbtS/QFoWUSuTqOMEzHA2dexnwN6T60PwPJRYnKqSEVxb3ruwAup7QOUziZ5/ZEca8iOD8vl+hxjWdE+nQB4tnkvAAXaC0HxybqdAPgFy43fZMcasq7Nsq7QAO5+chPmPv4RhIfGPhYoVDkPa50dWfLwb4pUE0aIZzZep3e+SYypOZ8v7nLfebLzAynP5ubm0R6GhrGf2ypWrMiJEycAOH78OFWqVEnwNXNzc3R1dTEzM8Pf3z/Jb0+b8hwPxaY4cqVzVwCqbN/69eYggkf/TsX7oTCwqLRpA7oGBkAE7j5yPwx/yZNBJCFhiT85J0aMC3N+iu9CUSDcIEdubP9ZgL9CAQHwcd1C/K6eBcCm/xi+BEQfQCXlPXy/jYTQ01USLCvgSRAQrAdGcjMYhpICYYif3OdkaBYm9Tl1r/qST/5xDzwicX4YddHKbJeVLyHGqJRKFjWZSkSY+AwCyIAq8MdrAVmZhEiJivq6SnzltGZpsdncMFx6HRk8An7+GkqphVKpZEk/EdUz8epkqQFdoSx+Uvty+mKScKPv8JT8jSR28Lepo4jIHLxvhNQALbnEtfiQFfxkkRUsk/Jbjvt702HC3XnMqTmeIJ9A/ikxkr9vzsY9wJweZ5exseEQwoNDWVF9IN1PL0VHV4cby/bwcMdJ9RZarp2ASS65SJhytjFvJBKiveUhIPHHrCo0UEpUVBjI/R50zOIWyfLaHAagQmUrHGdF1QJVGsqnqMmIimHKlB/eBioT/kz9/UL53+QbADge7iM1qSUr9iUFc0M5obZ0RrcE2xS22gTAgnXVsQx4mEDr6Cj95GrCRbhH70/FopDTGlw/QuEGsH4a1K743Up60HtkKEO6QZH8Ce9j2hpjlm8QgtzgXsaM+dMUCIM4Pjo9u/KowhM/mAk1zoYJcoMf3wiTaIJ2ERORRTV5aW1+71EEh3zGPA4ezJD2Rzi1/zW/l1hL+34lGDu/VqK27xVqzOOzTxnXTtSWrdWqEP+sa/H11ZhvPKuh/I1oFqUrMm9bFSQ52a1vkuLfQ0pPdOiq4t6+2ohl4xsWr62E/tfI1KAgJYRFF5xVoQGxTnA90askLQQdeJIdI73E3zPJjk2q2sV+TcxmL6KtXt2LKfz6BigxMEz8+fLJpwxSfZKdfJWd4L31LmbUfs5G9Xi0cguvdh8hf+f2fBsDFuAdiI2NXJ/yWMmNi2WPC1kBEsDGTC6gZ1jRSQCsdXaMs42xmRHDN3VDpVJxYs0Vdvx7DA9nL4ZXnA3A0HWdKV5L3hgyPVCqVClsbGyoVq0auXLlYuTIkfTt25cVK1bQtGlT9u/fT7Vq1ShVqpTaKNPW1paqVasSEhLC+PFJL9+njVCMBx0DA6xriYvvmw0bAbg7aoxaTKy8ZdNXMTH9EvjferWYaNKqP7kmLkShUKAKC+NVnxZqMdFu5moylPp+VKYlvWFXpTj9Li4F4O3t13x2+si/ZUbg80EM1EZfno5JRrkLrRYtKcHcPzYA0LBfNYzNf4203ysrhPiSvXgesua10XBvfk1GnPuX7EWFKDi13EjCgkJQKBR0PfY/MuUVLrXr6gxgTc1+ajGx2qjO9Dy3nEx5cmis32mR9s2v4O8nbogPnUq623l6plIOUQt17sbf0E0HjtY/ytLZ9wEwtzCg9R+JUOuSGYUCrmyDmcPF827j4I9R0duEhMKxi9CwJ0yKx28wOEREOi7fIG56T+22/Compj0W72kCwMQBZyhlsZSQYPG7W7i9ETuvtANg+/L7lDBewGf3gDi3E8nMAYfVYuLkTa2+ERO1pGVMTMU5JixMiEHtO4pxxPVrP4fhYsas4v7E11MIpr2niajFnf+TiwpODygUCvS+pj4HfRa18MpOHAHAw4Wr1O0CPLx49d+F1O9gGuC/Jee5uPNOrK8pFArq96rCWmdH/t4XVRt7QfdN9LCbwI6px1AqU3aSPFp/fiDlWYY5c+Zw8eJFtmzZgoGBAStWrABAT0+PDRs2cPHiRf73v6gL3/z587l06RI3b96kRYsWSX5/P//o5gfJ11fUlvtw9BjX+/Yn4K0IHa+ybQs6euk3wFOljMBzdEuCTu0AwHLMSoyrNQMgxNWZ1wPbAKBrkZG8y/eil/HXq3n0M+PQoAIAy1oJt76y7aow4e48DEy0EXZaNI/7m888vSLcQduMqafh3qQOwX6B3Fgvymi0WTZEw735tem5aShF6pcCYGPDIQR5i5n936YNiNbOvlYZepxdhkOjKjG28aszbeJjzpwUqdAfA1potjMa4sLxd4SGiEieJu1SX1xLbTzcA5k+TqR333XrqNG+dGgMN79W6blwC3LVho+e4rmhAZwU81Ws3S1Ew4Dv0qNvPACH38T/FmYK3t6xopBD2h3z12psz01PYRwVGhJBactlnP1P1HkvUjordwOGULCkiGirY7+KdXNvxbqdsNAIShgv4NgWEVm68+kgqjdLXEkdLalPwSIWAHh5isjKwX+KybD9e0Wk78BBwsxh0f9iul2nRwbMFXUTN049A0DDbmUBWPPvzymolZs4EoB7s5cAkKW0iPL3uBmVqn5r0Vauz9+Ez1v5lP30zp7Zp1g3al+C7fKWsmWtsyOL74/DobwdAMdXXaZXnolMqL8In09JT/VNNLpJfKQTtIJiAigUCuy7ibTnMG9v4Gv6czo2B4j48gmv4U0gVNQNyzTnELrW4qLz5dheXKYMFcubd8R+9rp0/V61xCQiNIwXx6Jm83puHkbDMa012CMtWqIzrvZCACYdGZBAy5+H5fVGA9Bkek/tOTcN0GpGZyp3E268W1uMZE+3yexoN079ese9s6g9sXei6iT+auze7sKC2aKu1VvPZr/kZ6RSqejdTEQcX33fPYHWPwdlbEWJik3/1cfAQPN3QtZW8O4M1CgnnpdrA1vFV0IBe3A6CzZfy/IVagDnRWY6I2fA74PE/+MHwJPLVujppf1j2MRUn8fBgxkzpxoAg1ofpknxTUREKNHRUbDjaieWHmwBwILxlyhhvIAAv6h6ks4vvChrIVKnLayMOf1lDFmyy9dG1JJ6RNZRXLtUnG979BJR8pECokMBEVF76oRXLGunP8rXF6mqJzcLQe1nj/q2LCBqAXo/exlj2ednYsKgZG9x/3b+n8Wp3DvNYGqZ9IwlEwtjxuzsyRqnKbQaWReA9889GFZuJj3sJvDk8usEtqAlLn7uX2IyoFKpcFq/Qf28wqoV6X5wHLBLDBgMqzTGav5RFLp6qFQqvjh2w3OvSO22HT+PTI3barKbWlIA94evWVUnevSTubWFhnqjRUtM/lsinCRzFbYhV+FsGu5N6vDq/H31//lqltRcR7REo86QJlT6U6QLejuL2f9my8fQ89xyjDPJ1wD8Fbh1w4sBPUT008PXDTE21rywpAn6tRTGAZ0HFCNT5p+/ZMM/Q68CULh4JmrWy6nh3kRn00zY8NW8fcw8qNQGlErQ1YUbe2Da1/ToziNEtOIO8dVxYRv0aa+ZPv8InQeV5KKLMGVxeuFNcdMl3L8mak1W+c2OWz6DMbMU2SiVsy7l0Nan7Fr9gOYlxPi/9+jy7H8zFB2d9H2v8ysQacQyc/ID8mXeRfs2DwB4/iyQ/fs8eHBfrm5eeiIiQqSrNvxDRO1dO/FKk91JMbKUKwnAp7siarjkSDHbcXbMAgAscolxst97ufqz6Y3QYFHzO3v+6KY9ZlbyZSgUCgVNBtZgrbMjY3b1Ui+f02k9PewmsGf2yeRPh/4BU5b0gEL1vWXhL4ivry8WFhbU3bYCfZOogZ8yIoLjrcTMskHGjIR++YKOvj6VN2+Mc1upZcwiw/eF61XKCFAqUeiJfSt9vPgyqZP69TyLd6BjkPjU19QyZklJAoLlU1lSw5hFhu5VX8b7+tnpm3h+RAz6K/RrgU2xvBwYOJdshW3ptWWY1L4Si5WJZIHrVHA+ly1CL0tSjFkCQvWYUjJlvoO0yGbXKbF+byGBofQvLIotr3o1CV29KDFC9nNNL8YsKqWShVWEyN/vxEyMzKL6kVhn6Ei0xiyJQ/Z7u33eFf+PXuSvn7g6wrKulkk3Zkk8qtA4LG/jICnGLK4ugZQuINL2T12uRfFSlvGukxRjFhk0Zczi8saHuoW2APA8JHqU9TMfK6ntpwdjFqeXPlQvLOrtvQ3pEUOI0nO/LbX9HzVmiYuAICjUOOr5qY3gYCf+33kERswQ/+fOAee3wLeB4rqWcmV/9OzKS7UPNZafPPONSPg3OmfsJdbNF9FcVevbsXhfc3VQxKEtTxjf60S09hvOtKVkJeGc7RUqdz+TZGMWCZJizCJDUr4HTRqzAGTR2/JD27fJZUHOfJnImTcjOfJmwjZfJnLmzYRNLos4IwAPPEnY7f1bksuYBWD7nAtsm3WefjMb0rB7WXw+B9Cl8DwyZzdj19NBid5HejBmAQj19eN054EANDwg9IejzbsA0PHkShQKBVdnr+fN8ctUGdcLu9oV4txHejZmcX36gelNF1O9Q1m6TW9OcEAIA4r8i0N5O8bs7Cm93+/x/xLIgu6beHMv6pyUu1h2/trQBT19XQYWm4qPjw/m5nLjlkiN6UpbyCBpu+EfCpV3kqT9pjZptyCIBtDXVapPehFhYRxtJeonmjk4UMJxMpfadUAZFkbAu3eYxuLk+CXQUEpk8vSTFx5kb578YxXKvi4Lh4hHFwnfMgUAnRK1yNhtFD5hgNw9ZjL0KX7CJd53UsRHUyO5AYGZZHt3byM5J+kIBSHBib8pbVvZCa84bpJDfP050CYqKrHh2mmY5bAm01ex78MTFzz8DJM98tbMMIz3PokfzJkbpeBB9xUzw7AUvUGTFSp+ZWIbYA6sMAuAvgtaYWSoAEQbz0CDWF0FI8LFsm+FR4BCWeRubJ5KDixFn+S+67hc2A8MEundpTrXB2MzvtbSJ4dF3AJQeFg4evoxj2PZ60MmScFfVkxMaXFQVrgD8JQUpt18TchYtBAZi6L+buLDSC9CygGzit2nOF9TqVSxnpcbm50GEj8yVYWHxikQenmFcf2aLw0bRQldCr3o246IUFG6+FX+HJqLnr1jRp8pjDPi7x+uFhPXbi2foJioMDCJ9UY5IkKJrm7M4yBCIXfe1qTLc6SYuOfq79GWxyUmRqakfv9dp0UxsYJVzFpskWLi0WuNMfzu2Fe53Y/RHsSxHRFBjFTilBITAUyNRQr0P4tg/T6o2wUGd4LnznDismgzZTB0a4m49Hw93emYZ0D1tURQYtCzLY4qyDvW15RKVczIv8z50Y/LMjoOgiIMo7k8x8U/M8vRrW8BahTczqXjzpQ0WcjhB39g75CRuk3t+NbT87pHXzKYGwARBCoNyaCf+DFZZj3fOF+L9T0DpuFxn/ti3Y7fx1iXjxv7BheXEDZtLhRtuULPIIbbcXyoLHNLfw+6qnCIJSwnrvOYLKrQwNg2Hw2PwJbq/4M9P+DsHMzz54G8fx/Km9dBPH4cwO3bcY+J3N/54P7Oh1tnnBLdLz1DPTLlyoJV7qxkyp0Fq1xZyGyflexFc/3wvUTZHPGLxq0GVWbbrPMsH32Ugyuuo/fV3fqzmx8Df9uEnr4Ounq66BvooKuvi56eDnoGuujp66Krp4O+gS4+YYbo6umiZ6CLjp6u+F9fFx29r+voRy7XQU9fjwgdPXT1dNHVj2qvqy/+Wue3jjEGlR1n3I5DTATA2FL9b3CwAoWuDrmaNebdwf94uu8c+ZvXoeSATrw5fpnL01aTo0alWDdTIKucMU9sYqJSqSTAyx+jDMboG0UXWFPa5dn9lbg2ZM8r6lR8eC1E5+z5s0jvNzYyZDRh/P6+qFQqDsw/w8H/nePtQzeGlJ6RLNv/2dEKinHwX0shJmYqW4bCI4WrUpkF87g99C/ujhxN1R3bNNm9ZCFs21SUD84BoNdlCrqFKoHkxVRL2ubN0QvcWiBS9s1zZaP+SsdoF/vCzavx5MBFnuy/SJGWv6YLp5a0weNLbwjyEzdIVVuXSLC9SqVieBFxO7Tg+fQU7VtK8cX5Ax/uizSdCn2aJ9heqVQysaSwLHV8MCdF+6ZFc4SHhjOg6FTCQ8OZc2UEmbKnXFmKv8c5sW+fGJg3bWbF4sX5MfpuZOjjE467eyjjxrxi3JhXtGlrzfz/FUD/642cUqkiT1YRMTluUmGatEia2/Wls+60/O00G/dWp2Ez26S/KQ2yZp6IBstbMCNFS2dNoDUEB4TSzn4mTftWoJdj+jOg6tZSmCM0aGZLqXKJj+LLnus+BRyMOHe6YEp1LU6mtwurIQABAABJREFUDIY29aFxP1j0TXDXjR1RNRWTGz+/cPLnE0Ua3T9WTpmdxEGuPOY8Dh7MsI5HObH3FU2Kb6ZirZxcOysiccpUyc7G08lfRzs8XEl+k9UAPPjcDTNzyfCcOAgMjEChQF1O4exZb5ycgpkw3gnHf+2TZR9J61c4Y/68ybb1wlDu6KX6lK2YuoaWBgY6ODiY4OCQuMn8p0Y1APD3Dsb1tRcur714//oLrq+9cH3lhevrLwT4xhSuw0PC8Xj5AY+X0Y1AmkxoS6lWiYvkTyoG31yg3N5Erw355IZcxGtyULZ1OX6f0iZF95H3j/a83rwdp937yNOuNXk6tuXdwf+4u3Qr+ZvXQc8oSsCMCA1D1yC62BceHILnWw/8PHzw/egj/np4i/8/euPr4UOAZ+KjF3X1dZl0e2ayvb/E8CFSUPwqIH549enr84SvszIoFApa/FWHFn/V4emVN8zuuC55NpyUFOZ0lPKsFRS/4c3BkxRo34zILHDrOrXJ36e3+nXjbNnQNzcnzNcXz9u3sSpTRlNd/WFUKpVaTDT4eyeKDBk12yEtKUKkmAjQYNW/MV6vMqQNTw5c5OK87VpBUYvGUKlUzOggjtXFd0Ymap1t4/YAUKVD3OkdaZ0dnUV6d9uN4xNoKYgUEwvVKZpifdKiWV7fcWFqq5Xq5xmzpWyay+Il+TG30GXD+o8cOujJoYOe5MhhyOGjpcieQ0TVZsqkj6t7dUYMe8H2be7s2vmRXTs/kievMQcOlaRY4f0ANG2ZnaGjkuYI6/0lhJa/nQagUFHL5HhrqU5QYBizxoqyIgduJa4GdYe8IirbrnDy3hSlBndvfubYQRcA1u+rnej15i1wB8DcXHP1NYs5wJuTULsb2NrA5lmQUuXRnz8PpEb1e4AQ7TXF/K0NeXLXgzaVdqjFxElLatGmZ/JfT1ycfKleYDsAZhYGySYmAuSxF6aCd++VIVs2Qy5eKkXOHFdZteoDv/2Wkeo1LJNtX4nh4J539Gx3MdqyEmUyUapcplTtx4+QwdKIgmWyU7BMwqnMZ94IQUelVOLr4YPX2094vftMwBd/ijQoldJdBeCAxwT1/0bfZE5ERCiJCFMSHhbx9aH8+hDPI8KVhIdG8OqTIRHhEUSEfX2EK7/+/W7Z1+chIaqo18Kj2inDI6jTv26Kv99czRrzevN2nHftJdjjEyFeUULqzvrR0333NO2XIn3IYGWGubUF5tYWVO1WM0X2ER/u3wmIbi+jC4wpQaHKeVjr7IiHsydjai74oW0pdMVDdp30glZQ/Ibnm/eSv01jdHR1aXZ4PV6xhCyXWTCPaz168XTWnHQdpahQKDBwPKKuo6jl5+T3/1awu3FfAIK/+GCUMXqki66+Hjr6eijDwvH76IWZdfoZAGn5eVgyYBcANTuUxiJLwunHwf7B3Ngr6nL9PjHhyL60yM3VIqLLuqg9mewTHsQvazcfEIO6jvO7pWTXtGiI1X/t4creewC0GFabZkNqpfg+dXUVzJyZl5kz87Jt20eGDX3N+/chlCp+DYADh0tSsZIl+vo6LFxckIWLC7J+7XtGj3zJm9dBFCssBLRs2Y1YsyVp4r5KpSJ/FpE2u2htJezypE9n2Zp5RX2raStroa+f8J3AuV0PUCrFBHbdDiVTsmvS+HoF0q/CEup3LkW74dUxMo0uCCmVKhpW/A+AK89axraJWAkMUjJ7rhAU9+3Ol3wdTgJ6unBhU8ruY//+z/TrKxx4//3Xnl69NWs0VrhUVh4GDmL2mEu071OM3Pksk30fB7a9YmhXEbnafXBR/pmbvBGZGzcWpEuXZ5QqeRu3D5XQ01Nw/UZpKpS/Q9u2T3j8pBxWVil7b+P6zp8erc/y4E70CLmlGyrTppPmoiRTE4WODhY2GbGwyYh9BQdNdwcAXV0ddHV1okUxxka4ZJmbpJRXSU4UOjroZTAl3D8A9/MXE17hK7qGBhhnzohJ5oxY5zTFLIsQBM2sLTHPaom5tQUmGTOgE0t6vmz9xJTG/bUQFCMnWd1eiufZ8qWcoBhJUoxffjW0guJ3XBk3k6ozx8X5up6pKRlLluDLvfu47D+AbYv0eTMLaMXEXwAdPT1qzRnN2REzufjP//ht0YQYbVosHc7e3jM5MmIJ7TbFfF2LloQ4+OkfyTWiLj2ebj5cP/wYgJ6zEnc+nVJbRPV0X9Qp2Wt/pgYh/kHc3nAUgOaLhyfY/qDjbtyevgdg1BnZz1pLWsffO5A/S0al7U8/NxRru9SPZOrQwZoOHay59yCYBr/dAaB5k3sATJuRT10/sVuPHHTrkYMaVW/y7GkAAPdeNkjyfmuXE7+Fmr9lo32XPD/wDlKOl0+96fX7KTr1KkDnfoUwNo4+fL527j3eXiI1sHXXQrFtIhohQWHMH3gAgO1vRid/h+NBqVTi+d6HLLZxZ6Z4ffAjwCeYvYuvsnfxVzO3hgVYuqwYOWxNqVfuMAC9BhciT/7ER9FWqvoEgAVzbdHVTX/nbhnGjX3D2rVCPD14qCjly6eNovo6OgpGz6qWItvu3eo4pw6/BWDT0UZUrZP8jt/16meiQ4esbNvmQcECN3jxsgK5cxuxZEl+Bg58SZHCN/ngXonkProiIpTMmXKf+f8+iLa8VfvczF1egQwZtPdUWlKOqmuW4fv8JfoW5hhmyohNVrkjXLaGYlojsoZi5Jj/w1eB0TJrOpmA/MlTntNRV1MHr8cvCPrsFW+bwqNESt7bbdtRJbetuBYtyUyWYmLm8MsLZ2Izdc9aMLd43flDrK9r0RIf8mJidIZWmAfAhH2Jc2lzefyeQB9RyLlEvfSZ+ruuoRAR6zn2jnVm+Fuub7/MzV0iWmzS7ZnpUkDVEjfXDjxQi4m5imRjjdMUjYiJ31KqtDkfPWvy8GlldS2ucWNeYW11jkH9nxIWpmTNKle1mPjep3mSj8uVi57x6J4owr/raOLTZlObO9c9ePPCB8dRN3Aw34Ct/hqq59nAvk3PCA9X0rW+EAcvve2WqO11LjQXgP6zG2Esa/34gyzstZ2/Ki+gs+1EWuecxrndD2Nc++2KWLP/43j+/F8zdSrw9aPPKWO3GxvdDTy6J8bJ/y5IvJvxnbsBeHiIOt3t2mr2GE9JVCoV5creVouJDx6WTTNiYkoRHBSOvcFKtZh4261LioiJkcxfIKJbfX0jmDLFGYDWv2ehfn0hkletcjfZ9nXt4kdyGm4kh8EmtZhobqHPseuN+RTeiRWbq6aqmHjp/CeymuzjwV1v9bKsJvs4sCf16wdqST10dHWxLFwQ0xzZ0TOWc2D/Gfno5AmQbsbECp2kPdIL6airKU9FRyEUnuz2FwCZTGN3UFPo6mLbsgUAz/+3SL08o6RjppWZXHuI3Rk1PjJIuhEnxYFZFtk+ySLjCJ1U/CQ/JxvLxDsEAqArJ+ztvBJ/ikX+FnUAeLHvpHrZt67QxduJ1x/sOC213/jwC5EbYPkGp/yATLZPslhJngMiCQ5LR4UyvuHMmTM0z+rItC47cH4cuwNjbEQ6i57edBOATNnMcSibK872Viah6v/ntloMwPhTcddalHVtlnGFdrr7lqEFxjKryhhubLtIeGjizmdZMohzgNPFKNfTPDXjrjf03seEV1dfcHjaPgDGXpyCbiLSKGWIyxk+LmRdm2VdoWWvbzJuypFYxXFdj4vs5ol3CYXEp0aplEr2dJvMyiEi3b//knZM+m9AogbH//nVkerT967NCfYtXPzesmY14OLV8ri6V6d9BxsAdu38SE6bC4wbI8yEnr+ugl64fOSDKjSQp4+8+XuYKF3g7NMu3vaxOULHh75O4tuvXvgIW/01dGx4lLs3YneebdfNgVf+3ZgyvyIZzMR15OP7AMb0OkMR0+UAtO5WkCw2cZshFLQQN0AX9z8mJFA46DboGnctblkH5sQycEkbStYRE43hoRHMH7CfFtb/0jyrI1tnniP0q525QqGgTvsS7P84gQMeE5h+sCvWuSzV23nwPuE6kYrsUQZbjZu9BODmtcJxttcxk6slqWuTcLmIH0Xpm/jrQ1Cwimw2V3FxEecZF9eKZM2awO/v80vpPhnryp3HEuMIndT2rx59opDFWgDs8lnwJqQ3mTIbJbhegJ5cqqKOmXW05y6uwvxj6RI3rlwR56ANG0V08OvXwfxv3hup7Su836r/9/EOpVvLM9jobqBFzWOEh4sx+d/TS+MW1oUXXh0pWTaztPu8LAqDmOeTbNnFZ+v4z+Noy3t3vhnjM0qIQsHnpftUO4+cO7cst97L1fQPlhyXgNyYD+THGrLjjDK5Pku1B/jsl/Bv7Fuee8iZu8m6NiclRdrdTyuM/ixoU56/IWOBPCj0dFGFR/Dx5j1Mi5WL8weSv1MbXPbt5/PVa+gM6I2esREfJX8Ynn5yN3MAYZI/cFmBUE9XSXBY4vdhlgRxMCxCJ0VFRdmbUkN9+ZtS2f47fzLFVGKdAHe5eg21K7+N9+KSo0NXXu4/zf0VO7D6rRkAmc2C1YKCQ9d2PNhxmqtL9mLbrLHUvuPCzDBMSrAwMwzDM5a6pfEhW9ckS4ZgPCX6JHuBTA1RNC3x6ZMYWF4/9oLrx16ol9duV5x2w6tjYxf3wNCYYNaPE2lzK64PxCCem2dXXyP0dZVc2CKKsecoZEM2O0sg9u+nsORg8b574qNHjEzF8RMSGMrxWfs4PksIfpa2manevwkOtUug0Il5DvUL0UelVHJ83AoAuh+J36VZ8ektG/oKc47++8aglyEDofGcqpIymDMzDJO6pujrKqVERdnrlezvWXb7gPQ5xs03cW6ZkWRKxKSC97uPbO80Wf18+cMxmFoaE9fx/D31LK4DEv0KC5QWFb8ltvqJAFeul8fSUh+FsbypW4jSkOolxW/nxNUGmJrGP1aRvXEPUya+fViY+NwvnnLj4qmD6uXN2uVh+D+lyeMgbsQMDXXpPqgI3QcVAcDLO4KpI6+yc/1zAOasrA7EfR574Z8FnYhQ5vTZC8Be5+HRDAW+xyMgZSIXDYz1Gb6+EwB6YQFsn3WBA8tFFPSOuRfZMVfU6KrWsgg9pvxGJmuRUla4Yi6CfYXAPn5GGbLaJDzmVbmJCZQp/4qSDbVrmZEzR9zvS+nnIfVeIj67yd/JSA4/dcwTN0Hl7Kqkagvx+VSsYMq+3flBFYwqNP71dK3sIcRXqk8h+pnQUyR+7Bqu0pUSCX0jTDBQJPxBbV16j5nDzwEwfHJZBo0tneh9mAS7IjN1rvRxi/ZcD7h6sRCVqj2lVcvHPH1YFEtLPd68KE4ehwdMnfqO6jUsKVEicd+fTiY7Nq98yvD+N6Itr1g1C6u3V8NafbxHENlxVWig1HuQRRUe8zvLYy9+P+dPe8R4XemX+IldAKcM1TBK5HUnklOvs0iNN2TvyQplSbzbMAjhS1b8eu0ld48lO9aQHWfceifvBp7dUm6yUzblOSljStl1EjNe+mnQpjz/WtTftBCA65MXxNvuxvCxUf+PGBtPSy1aNI+Ori765uKmIOC9W+yvm4jBku+7D6naNy3pl3bt2nHAYwLzT/eiXP386uVndjygb/nFNM/qSPOsjqwefxxvj+gi36CqIqqn19T6CRbQBlH3a8dEcbM/ak//ZHwXcmRzsGHB8+kMvTCbmkOaq6MGvV0+c3DceuZUHMbs8kPY2nshLndeRVv34BBxfSnVqR6GZnELQsE+/ixrNROATsv6kdku/TnAaomdm6sPqcXEgk2qsMll8lcxMX3QrUcOPnrW5KNnTfLmkxNbv8U2g3CAHTOpOKXKaTb9tf+I4riE9eTMg9Y0+T0q2v/gjjfUKLIbW/012OqvYcKQq3z8EHUTZ25hoBYT91xIXP3XDoXEOWDAjHqYmstFmKQEJhkM6THlNw54TGCf+3j6z26kfu3ivsd0L7aA5lkd+avuKjZMOYWPt1DHBo1MfLkJP78Ilq0Qk0+b1qfNGpk/yqmL4WoxcfRIGyEm/uR0rLpNLSbuv9JCSkxMLuzsDFkw1xaAQsUeoVKpMDbW4cwJ4TZfv94DAgLiF15fvgykXNnbZNXfGk1M3HKgJp/CO3HoXL1vxMS0SdnylgC4uv5CAo2WX5K1I/cRFpKymY5a5NFGKH6HgVkGslcrj9vFG7xct4n83TvHaHNn0lT8375TPw/+6EHQp09gFHfKnhYtmqa04z9cHzKSOxMcqbZ2WbTXgjy9CQsUdemO9R5P2+NrNNFFLemUPMWyMX5Te/XzR1fesmXGOZ5cE+fJQytvcGhl1EC9TocSuL8VddOa9k5cDa4VfTcD0HBQLfQMNH/p0jcyoFyn2pTrJOq+BXr7c2PjaW5uFu6W7++/YXu/qJIYOcsV4sM9EdlVoV+LOLcbER7B+iajAGg4tjV5KqYN90QtP0Z4SCir6w5VP2+1chRZC9kBKZs+lhbp00WcC3LYmjB8fDEN9yaK/IUsWbatNsu2iee3r35k9sTbXD4rJtnWL33C+qVP1O3LVRVp4DlyZ6B0xYRTDS8deoa/tyh90LxPuWTu/Y+jo6OgQdcy6jTsBxedWDzsMB/fefP6gTuvH4iagK+8O0ptt0QZkZq5cpkdOjrpo96VDDOXhLBonUhh37rYiFrNbTTco5TF3zeEKtZRY8grHgPIZqm5G/x2ba3Yf9Cbc+f9qFPvOWdOFqRQIWMcHe2YMMGZvHmu4/4xutN0SIiSSZOcWfe1zmUkPQc6MHlWaQwN03YZmtZts7Nnpxs3r3+hXIWMjBiTn/atbrJokSszZ+bVdPe0aEl2qrQry+Udt7i06w6Xdt3RdHekSUpNRG0NxXROmVEi+sXlv2NEhESf7Xk4az7ej8SAstbOTZSd4QjA1f5DU7WPWrTIYppD1BoK8/VFGRE1Y/vx3lMOdYzuNKs1G9LyIxStnJvpB7tywGMC+z+OZ9zGtuQuFBVld3qbSINbdXtworbn5+nPo7MiEqjJ0LrJ3+FkwMQyAzX/bM7IGwsZeWMhvfdNoEijKNHA9eZTANpuGB/nNlQqFatqic+kdOtKlG1bJWU7rSVVcL31TC0mGpga0fvsoq9i4q/H4f3v2b9bpL/efdNCs51JgDKVrNl+ohEuYT15F9qD9Qd+o3DxTOrXb14SYsTpR/HXfwQIDY3AseseAHa/+StlOpzMFK9mz8pbgzngMYHl1wdSqXFB9p6pr64hmRiuXPUjKEiMJ5o2sUyhnmqOBp0C1WLi9cMmVK+o+cmulOT+NTe1mFi6Sg7uBw3F1Cx1TYViY9tmIaI9fRbM8pUibb53n+wULSpSW9v8LkTtEye8sLG+Qu5c19RiYq5chly8VJJP4Z2YsbBcmhcTAYaNEqY082aKLIiadUTK7Ib1cinP6RG3N56Eh8mXqtKSvuk4tSVrnR3pNrNFtOU97CawZeLhtH9M6CbxkU74ua98SUShUFBqWG/uzl/F9aGjqLxMpKg8XbqSTzduAVBzx0YUOjpksNNGJWpJP+Tr2olXG7bwauNWsv7ZhkebDvBks0gjrTS+Pz5vXHmy9RBPth6myB/NNNxbLT8DCoWCCg0KUKGBSEGKCFdyfs9DMtmYkdXWMlHbGFNBuOAO3tgjpbqZ7FjmyEyjSX/QaNIfALy+9x5leASZ8sRtIrCxhSifkdnBlsbj26RKP7WkLEdHL+XtlUcAVBnShmK/19JwjzTHh/dB9OgoohMfv2+VbtwZ4atBSaNc1Gkkxnzh4Ur273CmaKnMiRIgqubbCkDvKXUwS0cp7pFks8/EmHVtqGD1LuHG39C67WsA7t8ukhLd0hghoSryVg5QP3912RQjw7RxPN+7+YmmlQ9y6EozSpaTMz6Jj6WOV1kxTdQxHr+oNm16FU+2bScHr58XI2+Bh0x2dKNaVTOKljTh5KniZLO5ysWLPthYX4nWfs6cvHT6I2u6Og9Fkt9B1IU8c0pEuKfH95AYQoPDaZNrOjP/607BcsI1vH/FpQAc8Jigya5p0RDV25WhersyfHH3ZWGPTbx74s7pDdc5veE6Bkb6jN3di9xFU96sS0t0tBGKcWBbR0SGBH/6TICLKx5XrvPhjHDDqrltPTq6uqgilJxr3xWArJUraqyvWrQkFtsmDQFw/e8Yx/tNVIuJDddOw7ZaWYp0FiLi400HNNZHLT83uno61G5XgpI1EldL6/HVKOfFgpXTbypP1kJ22BSLu//Hxq0gyEsU5v99jbYub2oQHhLGgkqDeXb8ZrJvO+CzD8urDVCLiX/smfpLi4lKpYoS+Y8BsGVPJbJapz9R7Vv09HRo0TE/+QolbEhz6vBbPrmLkiK/D/p1xoqj+l8FoHlTS7Jm/XkMy9zclWoxsUAeHVxvZUgzYiJAWOjXiNDKB+ne4gQq1Y/ZhqhUKn7Lu1otJu672yXNiYkAJia6nDgqSoTUrf+cefNcyGZzNVqbhg0z8fxFedw/VuaPztY/lRBXqowwj3Jzi8qsK1f2Ns+eyZl3pCUiwsWxPLrxuhivfV+XW8uvRUYbcyYdGcgapyl0nCTMREODw5jcZBk97Cawa/pxlBFpKNtOQZQxS2If6ej0pBUU46HWsmkAXB82GqMsmdE1MqLG5jXo6OujUqk4207UV8xUsjhF/xqMtVmQ1PatzOSL58q6Zcm6EYdLOln5SbpIg/x7kEXWjSskTD6mWNY92y5LQMKNvsHURq79mSu5E9VOoVBglkcUnfdxcgWg9aHlmOUQ9Z/ur9oltd/48AuRu4GQbQ9gpCcX4v7JX64IvqxznLlRmFT7SJLy3tMK8bmUJgfjmm8EYNrVMYle58mnxLk6RlLCRs5hEyCHhdwg3cww7mPj1rojOF8UaeB9zy8GUv5YBfnjTvbcKnuul/09J+VaYmUadd1VfK3ndmzSRrb1nBPrjXd2c7nv2SvQkCcHLrKppRCFc5QpQN8LS8iQNXbh6bKzfATRCZ8KcivoJ908JTGogr4k2KZQrv8A6NA5F781tEEVKve56qrkxjL6Oilf0y0xLrthYUp6tzoOwJ0PXaS2n9U0AXvgZMA3RG4sc90zcVk5X7xC2LjyBQDLliRufAKgYyZnQKWbOQmRKJLDVqVvlHBx+WY45ZuIY7dfZ31O74z524r4+CrGsviI8HSS6xBgGOYV52vlqlhz4amIcD/1nwu5DNby9oWn1PbNdcV79PQIpKTJQjzcxGdw03sQeQpmitHeN0L+HBNolFOqvY5Fwt91saImjB+XDYBZM10A0NdXcOBgUdw/Vmbd+oJYWMR+ACTle1AYpOy5VaEXt1tw81bifd655Q3AiDHCCGjxIlFSQqVS4eISQrOmD+Pchr3/Rek+1c0rV/dXdtzw9JOZ+n/jDFHp9J7uwv152kERyPNPmy1A0tyI82aSu8eSHWt8O85IDGVzfVb/r4qIIMg9KnXd++EjLrXrQKCra7R13Lzljr3nHhZS7ZMyppTFK1DODfvtKy+eX3eOtkyhUFC3W0XWOjsy6+JfWOcRJm9HV1yiV96J/Fl6Ou9feiRXl5NMZA1F2Ud6QaH60amrnwBfX18sLCxouXcx+qZRs+af/Yy4MnAYwR89KDigD9lr1wDESfpsG5HGZpY3D+VmijqKsj+MLwHydUf8g+VuAIPDUvZozJwEUTSlSWnRNSn7cPE0lWrv/iLhqIdvKVk+pnNzXIT5ePN4cC8Aau8WF2SVSsWV/kMI+SwGnZWXLcQoS+Zo68leXDJJXlCN9FO+/oWsOCBLcHjSC14sq6o55+If4cSXuGsC/ihb51xiw7TzFK6alxGbuyV6vUJZ5Gaur7taynUMeO8jN5iL6/rgdO42ZyatAqDL0YXoG4t22SUFy6RgaiB37pMV/GR/D7I3Hr6S10OIKaKG+AWyrtEI9fPO+6ZhmtlS/dzNx4SDTbqho69Ho13L0dGLW41QRSg51X2oOtK00eyB5KoYf6pnwwIfpN9DpQyPpNqrwlP2Oh3fTS/AtImPWTBbiEsegS3FOil8Ix6sSnkH5XBVwsd3NYdtuDr7MdKxHHUH1pPavkcSxoiymBvKnQNKZ0zcWMNWXxi7bd5SiLp1Ez+eUfokfiwDEO7uLNVerCTXXGEivoelGyOYvlScA1fN1KNBjdjPV3rWcpH0Olb2CTf6fh2T6J9pFj0xllu0thLtu0RF//dod5FDe0SaeseeBZi5vGqitu8bYcLFE2/p10xksTT4PR9zNzeMs32kACmDQZDcuU/m2Jg73x2lQo/hw23R1U1cmI9uEr4HZWDCkyk/RFjcn+uzZwHUqHKTuvUysWVbcVQqFTaZRSbdB5eSAGSzvRft+fe4WsnXpD7tJCf6y44b7DNGf8/PbroyuvE6cuSzYumVAQA0zyruu/e5j8c/TH4c4PxF7p5M9v5HdkL4kVvU7/nBpMn4Pn1G2SWLMMqcmSB3d24PGQZA1R3b1O2yW8r95gpk9ZFqnxShVpYc5nKBWD3sRJr7WmfHeNupVCqOLr/I7pknoy1vMaw2TQbXQEdH7vsM8gtmYLGp+Pj4YG5uLrVupMZ0oz9kkJOJ8A+B8stI0n5Tm3SkfWqGCvNmAvBs6Up19MLZtiIy0cg6q1pM1KIlvaBvYan+PzwomPDAQM62+UMtJtbctiGGmKhFS2oTHhbBhmlicPzXBrnInvTC5+dv1WJiu53T1GKiltTD0MyEfheXYletBACbWo7j+dFr0dtktEAZFs7hFr3weRN7DTmfN2851LyHWkzseWJ+gmLir8D1q55qMdHVu7mGe5O6nD/ugquziKoZMLqUhnuTepw56qL+X0ZMTC6mL4dc1WHFtoTbJpb2g8LUYuL5nfpxiomaYtM+EfAwuMdVcptvJyRE9HXtjmqcvimEwK1rnmOrv4YPrglHZ03585xaTJy3pUG8YmJaZPgwG0aNypVoMTE9UrCgEMVOnRDRqrGlb1taiEmPSGOk9Ehk7cT3rzyJ+JrC2mGUON43Op7WWL9SijxdxHj31qA/ATC2iXKN93d+G+s6vyprR+7jf702x1iuUCho1L86a50dmXZmCBmzCTFu//wz9MozkZFV5vDRWS5q+4eRTXeOfKQT0lFXNYOuoQG5monc/EdzF3KxR39QqdAzMaHykvka7p0WLUnDbpBwdX4wYy4XuvQGIGPxotTevQUdfa1XkxbN81dDkercb9pv6Oj+fJeqgE9fONBXmM00WzaaDFljppFpST0aTOtLo9kDATg7bSO7uk1VTyLW37SQ/O2aAnD+z394unF3tHUfrtjM+T8nAlCiQ136XVyqFYcBX58wmta5AMCVe3UxMPj5fsdxER6upFvTowDcdO2s4d6kHiqViq7NTgDwwL2TRvrQqKb4O3WZEBbdP8ds4+YBuWqD47L4txUeAbYVQ7l8S5wLnp/VJ0+utCdSNWiaEyfvtgAEBkaQ03Q7xw6JFMnipTLxLrQH5SqL0jbl7bczZ9LtWLcTHq4kl8EadqwUabInX3Sjfuv8qfAOtCQHxYqJLDt3d1Fi5a9hQozasi2VxZNkpvP42gCsmygiztoNrwbAviVX41wnvZLha1kqVCqCP4rU57KLhDnsvdGJL/3zK3Bp1x3unXoebxubPJmZe3Ukq99MptmfNQHwfO/D2JoL6GE3gWMrL/1wndlEoRUUteTr0hGAT9duEuYrog+qb1ylyS5p0fJDWJavBID34ycAOPTsSql/tEYQWtIGHq4+PL8j0pta9iuv4d4kP+HBoWxvI35vNSf0JEsh+VQrLclPropF6H50LgCer9+zovpAgj6JG7FCnVtT439TAHi58zAHm3Qj1Nefg0264XToFAA1l0yl0oBWmul8GiRftsMAzFlUknwOZgm0/rmoX1LUIx46oQyZs6ZvAxoZBnU+B0CnXgXIaJXyaeexUaIgvDoNtqLEHOVbwbi50dtYfj0cV+0SwuLrWAKPP3lBnt/E/9ZZ4N1VfUyM056YGEmGDPp8Cu/E1PllAOjc8jzlChwgIkKJQqFg7/km7DzVCICFU+9hq7+GL57B6vVdnP2wN16HSgUGhro8CBhI9ly/1u82vdG0majBe/+eiIQePlQIiEuWCyHqj46intzcee4a6F3y0XpwZQAOrbwBiAi0AmVF5OKDc3I1S9MDpWaL7Mhbfw4FwChrVviapuv3+rWmupWu0dHRocVfdVjr7MiU44MwtRTX5Z3TjtPT/h/+rvs/PN97a7aT6RitoJhITHLmUP9fa1fM8FotWtITTgtnqf/P06ENORvK1XbSoiUl6VxcGJP871R3Dfck+VEplWxoIFJZSnVtTN465TTcIy3fYpjBmH4Xl/J/9s4yvMmkC8N36m5AKYXi7u7w4e66uC227OLu7rD44q4Lizss7u4uxWpA3SX5fgxNG5q2mVJf7uvqBUkm7ztJXpl55pzz5KklJuWnegzj3QmRem+dOztN9q9V11E83vF3AMwcMtH04HqscmTVvtH/II1rie+sfCU7uvb6bwnml8984s0LUa9q0IQyKdyb5MPDLZCDu94AMPsv3Wr1JRVGhnB5F/y9RDzeekBEKz77Nhc3MwXn01C+mHhcszt0HwuRgSq3H0OZNuL/nVvqceuQUZpxBO7zR0GeubUGwPm1Pw7GO7h2UdQrrPS/LLwN6kH2XEIoLO6wjQ3LHrN/52sq5/sbgJ6/F+auz2/op8PMgPTGkOHC8Khfnyc8fOBH2bIiDXrtOhGWa2oqfkNvn6SvUZ6UKBQKilYWn/XmSVFCY8K2XwCY12VLivUrqTDPHmV+FegiFtfLLRUXs/tjNeuWez5/S1igXC3CtIytw4/XEsxWIDNL741lzavJNOhTBQDXV58ZUWUBPXNO4OyWG4ketZjeTVnSUFeTn4yWYuXuwewFBH78pH7e59kLre3tzOQKn9smwMHPQtJF1sQwaetmfPFLfWldsoX9ZR2bE7IPpwxyjmIO+eUKPd+7oZvToSoigntd2+Bz+4b6uTc7dHN2li3Q6xkgd2wEJ8BtWxYX36Q1ApAtPh1JWnZ5TmyuHRfXVxNzQwqUFsd1VqvguN4Sg6eSLs8VsnlLtQd5l+fI+8P6WqKouFPFYpTu0TTW9i6Spi8JISBU7tona7KS1K7NCXFVj8ttOzp1p/Si8cI/ALi/dANn+o1BpVKh0NfHOm9OdbviA7pRZ+08FN+iB2R/t2PPs0i1B7jqX1SqfXymKT/K96Yvm9a+5eY1Udfr8L//0/4eSZdnWUwUcteMhKDN5TkiQknnBsLR+sb7zhqv5beQc0dNjS7Pd7xiH2uUcRJFC3ediqq3F2ZXSGr7ujj5RsfAIWecr1csCe/OQ62K4nG9HtBuKCiVIuBnz2I4/i3h6Mw1yFEbBs2EluLUZ/FYmPmH3HUp3F0ugkiZAHfh+MxAMmQ04XN4J4aOFdeKtrWO0rrmYVQqFQYGelx+0Y41e2oDMHHINf74Flm67VgDpvxZSdpkJSEuz6Gmctc+2WND9hqTEJfn781xEh3DuL/XIkXEWOfN6yDq1LxN0RJRhl1ZnO6pTVmiP87idI8yFR7TvNVLZnZcx7KJF9iz+h6Xj7/h9ZMvBPjFfd2pnUvOMVd23PDWS/tnHrNJpPRP77wLAEvbqMhvb3c/qX3ktJWbk8nOfzJZyN1/ijrGPJ9LL5wPwJ0hokSVccYM6BmLe7nv8xdql+fTA6ezr+Xv8e4jNbo8f/LVPXo/wEeIpo75NE2BMmazSfD+9Q30aTe2AeudpzHxUD8MjcX9cMuEQ/TKNZEpTf/C20Pu2Ip9Zwn8SyP8LJYWB37BhjxbtoIvt+4AUGPtn5z7dQh3Jkyl4YHNMdq7Sk4k/IMNpCdQ/sGGUu8Ji9BLUlHRwSb1rYrE9v2oVCqUwUHom2r+ThY6TjCjI3tzee9pLiUGv3og56KWt7hHrMKoMjgIPRNTwr09cR7ZEwA9CyuKLV/H/W5tAXB3CcTQJu6BkayIamsWIiUqGukrpV3MYyM8KAgD05g3qlwZ/ZJUvPsRl+f/EnGdP5M6CoF795Pf1e0++ppoPa9Dg8PQ01NgYKR57BfMIDcAuOFiG+d19cyGy+SrkAunwlETGmdPOdHSM9CYg/1FGouRpRn1Zg+Is72dWYhWkV2lVBLg6YdFRrnBoTasTMKkzmtDfaXUMS4rWMaGSqXCz8MHq8w2Gs/LOimCnHhvU7w4dXas4nSHvvh/dOVQU82I2Vqbl2FsbUVYNF1J1kmxYYHYU9ECfEMwt4p5DS1t5QzoPt5QhQZKiYqyrtDRt/3qhR8jBt4D4LVbk9jfE4vLs59vGBaWBj8cDRahMMBQobudb5hS/ljV5vLcpPxeAH4bWZJMDpqf8YV/Jq3b8fUMxMTMCCMTzT4kh8uziYFSauJYMeNHrc8f3iPEGGMTfSrXiLpOGno+1do+PFxFaKgSMzPN71DW5TnC0wWFUdzfkwLYtAhevlVRq0MY1+5BzjqwbR5UKwOF88D7MzBqAew4AvtEBQNOroWCuaNcnnUlNpdnlUqFv78SS0vNz6xnlTlON1+tn8nUVifBbPT4fHTpnpVS+U9w45I72Y3W8++dphQpYUfdhpqC3iO39mTMZAKEExRhjJme7tcBbeJ6JH6+oVhaxfwOE8vleeUqDzy9whk7OqbgKCMq6mfIJS1Cxnat9HAPIZP9j0e1qoK8421z/kJJThz35OPHED68D+TyFX9CQ+OOrnJxCcPFJQxuBgA34myrDT0DPWyz2GDnaINtVltss1iTMXsGyjQrGcNBV3aemy2WBWQL66j7/RcXXzI6WjH7cHdGN9nIjPabmHBisM77cPOTK0Php2VuEhoYwucXH8hcOAcGRpqvy84zHnyKWUNbP3NUlKLX20+YOWWn2IIl3P+9Lw8mTqLdiXUAWOfKhs/bj3y8dJtsVWOPiE8sl2evT54YW5hgZv3ji94yLs8uL4WQ7VQgE4b6Sny++AOQrYC99DGmjXwls7Dq+STCQ8PZMe0YZ7fc4N1DF4aWnxv/m3/yU1CMC88nz3E5dxmA+nvWo2dogF3Rgng+esbr3QfJ07ZZCvfwJzJ4XbnI+1VLyDt2ChYF/xvum2Ff3Hk3ti/mZasQcEscy9Y1GpGpYx8UinDyTZjOy2njeTN/BgWmz0/h3iYOKpWKC11+xeF/1Sj8R7+U7s5PJFg2WhTcrtWmMBY28YtFvfJNJ0+pbEw+2DvJ+qRSqfhnxlH14+4L21GuWQnp7VxZtIPPT8Wku/PBBfG0jp35FYcAMOLG4gRvIy0R7BfEvOrjABh3cx56Bskr2huamdLwwGbu/7kSl3NXAHCoUp5SI+OPCPgROhRejKebP5vv/05mpx8XjxODD++DyJDRKIYIFEloqJLKJYUac+jf6lhayU2qbl79TKNqJ1m0piKdemgXZVIz1y648OyhiMwcMV232q+hweG0zSsM/k54jkuyviUlSqWK/h3OAHD3U0ed3pMt61VMTPRwflcxKbumQb5cCj5cM2LK/FDW7oFOIyCTLVzZAYYGsOtYVNsHB6LqLCYGvr4RFCghou9d38pFbf4oWbOZ4RbRjWF9rrBt3Utqlz5ExeqZuXZB1NnLnsuC6y9bJXpKd0SEkpwmGwB48rWLVlExIahUKo2+zlvoRmCgkgwZDOjbW24xPjHxcA+hZ+c73Lwuos0On6pEuQpJ73JeoIAZBQoIcUdGEA0JUXI3uDxuH3xxfe+L23tf3D744vbRD7f34rmwUO1CsTJcydcPnnz94Km5zcBQqnZMunN63vGejGiwnnEtNrPqxu8UKu8EgNvrzygjlIli4KcMj+DzW3dcH3/A5fEHXB6/x/Wp9oUUgEINy1N/YtIYbxVbsISHwwbyePRwym37GyNbWwysrAj39cXj/jPsSxSk1sLR7Gv5O1emrVCLjImBr4cPj0894NGJ+7y/56zxmkKhYOr9eYm2L1349EIIitkKiHP843PNx4mFgZEBXaY1pcu0pry6/Z6ZrRPJMyMhJitpKI/4p6AYjfvr9lB2YNRFwTKHExlLFaP0mIFq59tyU0dxolUPXmzdQ66WjdS1lH6S+rEsLFI/Xs2cRIlNu9NMPZwfwcBOREREiokO/UdjUSrqZm+eryAAQe+dYwzS0iqRn8Ht/MWfgmIaIjgwjH/+ugXA+LXxL9bsX3QOAKeCSTuBUCgUTD0/nHmtV+L3xZ+NQ/9m49C/KfPL/6g5uIU61TUu7u+7wtP9oqZc91PLEnyeHRi9HoCcFQsm6P1pDfcXLqxuLxY6CtUtkexiYnRKDOlHrpaNUKDAMqdTku1HqVTRMONM9WP7bD9eLyg+QkIiWDjrOT375SazQ+xCftmiZ9X/X7WhJC1aa0YEZbM5AMDgEfmpUCmDdD8aVRPuwDXqOEi/N6VRKlV0qCNMaK6+1d3deGijTQAMXtQoSfqVHPRoIX63vkOL6SQaOTuLCCRj45QZb0z8Dfr/ImokfvaCfA2iXjM1gaeH1f4HiYKbexilKgrjiE6/2CTehiVZsLoy/YYWoVqR/WoxcdTUkgwZJ79AFh/+fqEUshO17bLnskw0MRGgWKnHfP0azsunxbCw0Ofh3SLkKfCQyVNdqFzJgmJFk75cSCQqlYpVy52ZNFYzErdlmyyULW+TbP1ICMbGemRztCFbbhup913+EHVtDwkIwcvNBy8XbwJ9AinZoFgi91KT/KVFnWI3Zy8iwpXoG+jRbFg9Di44yb7Zx2k9LvbrqEqlwtvNl3cPP/LklrtaLAzxly+PoW9kiEPh7GQulJ1yXZOuBr2JQ9S9MMD5LeY5c1F0zkLu9f+VcyPn0e7EOgzNTLHLnwvPF295f/Y62WtWkNpHoJc/T/99wJNT93G+8TLe9gVrFKH27/WlP8uPEikoZv0mIKof50+6OUDeMtlZ7zwN3y/+DC4754e2lZCaiGmphuJPNSwab46co0TvthiaigG1obkZ5SaP0Gijp69PwZ4debZ+O9dGT6fy/Mkp0NOfJARDWzvsqtfC88IZnJctINcfw1O6S0mOQk+PbKPn8HH2KAANMTGSTA2a8vn4IT4fPYh94+bJ3cUkwbZ4UbwePMLr0RNsixZO6e78RAd6VlwLwJhVTXQS3P5ZIMSNHrNjr0OYWGTIasvsa2MIDQ5j/cCdPDzzjNs7z3N753kci+Wk9aK+mFhqn8S8u/mCk7NEzZ9O++ejb5iw267rk3e8OHMfgDaL079Q/vDYbfaP3QZAwzGtKduuSgr3CKxyZo+/0Q8QGhJO0yxi0JopqxVbH/6RpPuL5PqVr/w59zl/zn0OwNhJ+fljSB709DTPww3bS9OjoygB07fHPfr2uEfBwhZs3l2ZP2c/A8AugxFjp8hnAAzqfQ2AZm2yk9XJ/Ec+TpJw/ZIbOfNYkTmL9vO8VbX9APQeWhyHrLr138vDn5f3RMp7w66lEqWfyc2n9/6cOSaid8bP0S0qs22bxwDs3y9XCzQxyWQn0pw37IVJwgOMZjVh2YTE3c+LVyH8r64wqhk1LBODf8+YuDuQJF9Ba1zDuzJj7B2atc1J8dLywn98uHzwp0Jucc9r0jYXf22vlajbHzHUgdHjPpKv0ENcP5TEzEyfU8fzU7fBC+o1fMHr58VijaJOLJ4/9aVd08u4ukSJUXp6sO9oRSpWjpm+ml4xNjfGIY89DnmSLzK0+6Q6bJxymrXjT9B3dkPq9avOwQUnObPhMlb2lrx78JH3Dz/x9aNcLfpIMuV1wLFIdhwLO+FYJDv2+bIQpJRLkU5Mii9axoPBv/Nk3CjKbfsbQysrjDJkIPTrV9xuPcKhbFFqzBvB3ua/cW326lgFxWC/IJ6ffcSTU/d4dUl7KYro5K2cn6L1SlCodrFESW/+UVwiBcS84hr66YWoSZwtv/ZSIolJZG3Fn8TOz2/oO452G0Xzv+NOJcvVvAHP1m/H5+UbAt0/Y5Y56Q/mnyQO2X/9Dc8LZ/C5eY2Qz+4YZ8qc0l1KckxyF8C0UAmCnt7Hfd2fZO41RON1x/ad+Xz8EC67tqQbQbHIoN+41Os37k2dRc2/058DXHrj3fMvuL7zBqDeL/GvcB9bLVJPKzYrGqNeT1JiZGJIv9VdUKlU7FxwlUsrj+Dy0JmltceAQkGP7aPImCeqLpXXew/+HrAcgFYbJ2JiI1d3MRKVUsnW7gsB+HXPuHQRSRwXR2fu4fZu8Rv32DiQbCVypmyHkoEA32Ba5RSp8KX+l4vZ+3RLHU0Mqte05+CparRudImwMBUzp7xg5pQXmJrps/tAeXXaXqMmDrj7NiIgIJzRQx/z945PPHviT/kiJ9XbevJOPtLO3S2I7RuEkcXaHSnrDqwNlUpFm5pH1I8dncyZtrgSNRvnQqFQcOuKG/dvisnN2Nm6p/t1LCJcO+cfTpp0ucTg+tGnqJQqyjcqFENgBqiYRwhHBy/ptrCjVKr48EHUnStUOOWF4x6toENj+OgOeRN5veDGrUCat30HwKJ5WWjfxiZxd5BAFAoF42cljfv43RufaVblIAAjppZh4JiSib6Pbl0z8s9+L27eDKBR0xccPZSfokXMmDLJkUlTXMhTQAiNiU1YmJLJYx6xZoWm6c5vA3MxdlIBDA2TbyzikPkKi5fkpX17IeTt3/8FCwt9aldPfUaZiU2L3yqyccppjq6/xdH1tzRe2z/neKzvs8lsRY7iWcleLBtW+XKTpVA2TK11vAYlvcdXrBhnskdhaIgqLAz/16+wyJOXIjPncbdvTy6M+5N2J9ZhYGJMpmL5+fzwBS8PnsHYyoIPF27y6fKdeLefvXRuitQvRcHaxbHIEFXnQdYrIKmJjEg0tRRBX5Epz45504gG8zPl+b9FiI8/ni+cscufM852leZP5urwyZzvM0yrQctPUi/5Js3i5ZQxPB02gJKb96R0d5IFx8GTed23JX7Xz2PTsDXGjlEjZ4W+PgbWNoT7eBP86QMmWZMunS+5MLIWNcdUSiUqpVKntNSfpBzdy4saJRtv6FYLcfu0EwD0W9wqyfoUFwqFgko961GpZz3eXHnCP4NXgUrFhg6zAWg2uwc5yuZnbZsZgIgotM4p51AZncjtlulQA9vsKVcjKqlRqVQsbTQdHzcRWTDk9BSNAW565YuLL52KLgWgUbdSDPoz+dNfK1bJyCefFkREqFg48zHzZr0kKDCCJnWvAtCwSWYWryiOtY0h5uYGLF1VgqWrSnDu38+0b3kTgPsvG2gVneKjaDZhZLL3ZO1kF8vdXAIp6bSboiUzMHVRJcpVibnIqFAo+OdsY0b2u8Tr5z64fAigV6vTMdpdeqW7CPz6kTvKCGGcUKxy0ka+/gjze/2t8Th3fmsGjytJ03a52bddCCuZMptSqoJu16VFi0Q045Ah2RK3oz+AiXHii4nHTvrRs6/4rFs3OFG7RsIWk9ISh/e8VdfS/GtHLZq0yZVk+zq4Nx9ZnO5x914ga9Z9pnevTPT51Z59+725dz+Q5q1ecmBvvkTZ1+ULn2nZ4JLGc9lzmrFzf2Xy5E5646TYGDTwlVpQ7Nf3W33OJBBSUxsKhYK2Q6qy+0/xmxiZGZG9iCPG5kZUaFmaHMWzkiGbbZz3EllTlpSm+MKl3P+jH08njqXctr8xsLDA3CEjAW5fONJtFIEeX1Epxf3k7vJtWrfhWDQ7ReqVpFDdElg7JH1tz8TG95sJSyQfvwmMRqZJZ7SZmCgUCUh5TkOxAwqVShW3FdR/AF9fX6ytram3cgon+00CUBc21ebsFMnJ9r2JCA6h+KA+ZK0lVtUT4vQsi6wTrqw7ryxpyek5kqejBhHi+oks7TqRuUnLZHN6liEhTs9xEfLRmQ9TBwOQZ9U+FAoFFibCBTPY1YVnowaib25Bsb82xrqNhDg9y5CYK2Jv9+zj7c495O7QjpytoyIvc2WUcwCWJSFOz37Bhhxo3C0JepP0nPMdK+USGknkb31q1yNm9jlE5uzW7Hz4W6ztP/qKVcmz22+xftQhStTKx/BNnWNtnxCnZ1miOz17ffjM5q7zCQ3QXMquNawVZdr/DxBOzzLYmYXw8vxD9o8Q6eBJYcRiJeE+D/KOjbo6PYcFhTK78mj1Y10NWJLa6RmQcqsHOTfFr29c2dJJ1EzsMaEGvwzRLbVbOD3rTkLcS91cg/m16121yUAkcxYWoVsvocA4WAsni3Xby9O0RVapfSiMzNi+8TWDfr2Gja0RLz+3lXp/fEQo4j/23r31o0LevTGeHza5NH2HFsPUNOY2PL8EM3/ybbaseqZ+rmm7PCzZWjve/UU6Pde3E4sNG+/8RpacsV97ktLp+Z/5Z7B1sKRuhxKxpnT5fAng0MorHFh+JdbtvPDphqlZ7N91dKdnh8xiOy6ulWIVnxPi9CyLKjBUqr2M0/PmfyIYN0+YWRw7kJOSxeMXL/Ss5LNlFKZy9yylsVw91qAI3a97S2feYeFkES126EozSpbTLWroR5yeAwIiyFvwIQCnjosoRYAsTvcAmDktKz26y0Uv6WcQIqivTxh/9LnNsUOa/Zu1sAQ9++bSEKtic3pOLLQ5PUeeR27ulQEoVPAGXl7hvHtfESOFXDjdxwx1pPsUvY6iLiSW03NsRI4PZUgMp+c42yeC03N07vTuTkSgbvfxot1b4VS9LJZZNa8rieX0nJjo6vTcM6eoR7HlwxQAujhN0nicWGib5wb5BTOg2Ax8fHywspK7jkZqTLfHgIXkYeofDGVmkaD9Jjc/BUWifuyWe5dxYfwivj55RfFebcjaLG5jgCerN/PuiFilbrB/E18D5C5OgTpOtKIjK0CGhCVtHRGnDAFJuv2EYKmDOKgMD+fcL0LAqbtzNQamcme57M3xvafc6vS9e3JF6TM46Sae+G2eTejd8xgWKovjwIkar73rL4737Mv2otCPeZzJHksWkkJFpLiZWKiUEdzv3h5AHYma3c4/rrfEwMRQu8NdbAT/wPmWVgXFtgPKs2fFTRyyW9Puj/I06FQcU/O4J18mBuL8UalUVLaYC8DZz0MxMdM+AIs+WGybRQwetjuPi3USnN9GbtB06ZN8yoRzLOd0aGAI+0et493155RoVYV6o9sBCRMTw4JDWVRd1PEdcHIGZnGkTCdk4chS8hyVRdfzwfvTF9a0nAZA1pJ5aPvXYJ3e9zkgAWKi5KRAdgGvTPYvOrf9cOcVO/uJyMQJqxvTqJNuNeVymbhJ9UlfJXdt1SY+njrmRqfWV7W2b946K2u26FY/LzphYUqyWgsjF+cvTTGLQ5RSGMkt1uoiJkbn9esgZoy+wdG9zjFeq1jdgSkLK1K4hOYk+taNr7Sssh+At6F94t1HpJh45ehzpnTeg52DBTueDIq1fVKKiSqViq7ZJ2s8Z2FrSpsh1anTuQzGsUR9FNB7zfqlj1k0/S4Qf408I9+o9NDnzwKoXuUmDg5G3H9cWWt7pa+71OeI+PpBqr3Yh9w4QEZMnPNXOMs2ifvb5VNZyZUj/uuHnrV89LrC1EaqvZ6ZnPgYrNL92tq/wxkO73kLwG3nNjrXQNUL8ZXqU8TXtzGee/gokHoNRXReZO1Ef/8I8hUSQuOZkwUoVEi3uZl+hlzs3vGeAb1uazxfpXpGVm8uTyb7mPdwVVDC6vTpiipcu/Bdv/597t8L4OHDsmSyN2Lp0o/MmP6eBbOz0LG9jc7b93CQN9eQHS+ZGsjNlyyN5e5XnxIgJn6SDP6RXoSUHO+9/RJ/JkaYjzf3fou6z1hmc8C+VCFyN6yObZ74Q6yLZUnaY1V2Xgxgb667GJ9cgqI2gvyC6VN41o8JiuMSKCjOSBuC4s88wO+oOX8kAA/W7UEZFvtF7f3xM2oxEeDJqk1J3refJB56BgYUHiiiof7tMiCFe5N8WHYVEUBhT28R4vxC4zXbNr0A8Fg+Ldn7lRQo9PTV8eLhvnIC0090x8JG3CHd3vuwZMQpGjkuoKb1LGpaz2JWv0O8ehj7BHFKL+GK2u63MrGKidG5+M8DAApVzJFqiyQbmRnTbulvjLixWC0mJpRIMbHOyDZxiolpmTeXH6vFxEq9G+ssJqZ1np++qxYTFx9sp7OYmFLUbeiAR2BLPno3p+/veTReS4iYCFCrokiPnDSzaJxiYnKQPZclq3bV5kNYL94G9WDmssro64v7x7ULbtQvux8nw3U4Ga5j3ZJHhIUp1WLihee/SO1rSmexwLX2Wt9E/QwyKBQK1jwbS+cJdTD5tgDk7xXExokn6Jx7Jm2zTKFz7pnsX3aJIP+oSZ+tnTGtOuVVP5Yx3GjV4h4A/+wvmSifIbUxcFKUmPjgqpNOYmJap3K+XWox8bVPx2Q3VCpW1IzJE4Ugm6eAEBEtLPQ5djg/ALXqPScwKG6h45NLKHUbPsfebJ+GmLhpVwU8Aluy73g1rWJiSjJggIgGX79eLC517SqCEFas+ppiffpJ0mJobUO5bX+r/xqum0GZ3zvrJCamJ7o4TeLZNeeU7oY8+gn8SyP8FBS/Q09fn5L9OwBwZcRkrW3cb9zl8be00FqbhD3c+2NniAhOwaqtP5HGobpILVOGheFx824K9yb5sBkn0vnd5gxHpRQDrQhfL7z2iOeDn6af7yLPKLGC9W7lkhTuSfql26iqnPUZw1GXYQycX48sOWzUr53c8YjeVderBcbu5VdzZPN9QoLD8fMO5sSuJwAMmadbys2S3/cBMG5bp0T/HKmN2zvPAaDQ16NUm2op25kk4vLqY/wzZDUg6kxW6NkghXuUPNzacY6DYzcCsPFyd8rXTrpaY4mNkZEe0+YWxyOwJW/cm+Ae0CJB27l/x4vnT0Vk/YDBiVPrLLEwMNCjS99COAf35ENYL07fa0W1OlFRZJOHXSe32QYAOvxaEKdcukcO7FosUhXL182DuZV8ZE1iYmJuTPPfqrDl1Rh2u05i65ux9JzeAEtbEdEVEhTGthn/0jXfbNpmmcIvTtNYNOMu1QvtBuDErRY67ysiQsWXzyIiOm++lHcMTWya/xrGvhNiPPXybnYyZkhDM8EEEBGhxMlwHR+cRbTnp9AumFukjIDat7c9xYuJY7Zlm5cAlCxhxvixwiAtT/4HMd6jVKpYvNSdLE73KFvhCY8eibTLXzpnx/lLUzwCW9KwacLrHic1jRuLaOnlyz8BYG0tFmRev5VL5f/JT9IKQzd1Vf9/RtsN6v+Hh8llkv0kaUidIR4pTP4Wdbj31w783r4nwMUNc8eo9FPv56+5M+NPAKr/NRdjGytKDPuN+wtW8GjkUEosWZFS3f5JAqi2YSUXe/Tj9vQ/abBv43/CvEM/oyMmVZsSfOkQbnNHYNumF+4LRmu0CX7xCJP8qTtiRhcsC4vP4Pfofgr3JH6q/b1Tqv3FdrpHxQy5tkxq2/ky6Z6KVPhb9oupuREte5ehZe8o98gnNz/x97IbnN8vao29e/6V+X8cZf4fR9Vt5u1prdN+rh8VdbhyFcuCsQ7RjGmZIC9fziwU4ungc3NTuDdJw9aef+L6yBmA3vsmYpM1A/+FceGZP/dxe8c5APrsn0iBkklbfyspsbBM+HlYt+o5AG48rpdIvUk6ChSxZfuxhgCEhESwfuljZo65ibWtMTNXVNd5O0qlivVTzgIwefuPRS8nBcamhjTsVYGGvSoAEBYSzrld99j95wW83PyICFeyYLJwDc2d3zpGCnhczJohotjGTUg74rmuFK8fite3JIg3lwwxMU/f40g/31AKZ9gCiOPg/OM26OslbskaWU4cLUAWp3tcux7Aps1f6NY1IwP6Z+afvV48fRZM+46v2LU9L4+fBNG2/Su8vKNuNubmeuzZmZcytYuk4CeQIzJ6OjT0P1+17D+B3/NnKPT0sMiXP6W7kmIU/V8+tnyYgs9nfxb23M6be0JM75F7KsZmRkzY14scheXKhSUnCr0EmLKkoVtJqunqrFmzUCgUDB48WP2cSqVi8uTJODo6YmpqSo0aNXj8+LHG+0JCQvjjjz/ImDEj5ubmNGvWjI8fP/5wf+r9NRmAC/1Hqp8LcHHj6kiRq19p7iS10Oh8QBQlV+in7xXJ9IihpSW5WoiJwo0Jc1K4N8mHeWuR7h367qVaTMzYcxjZ5opBovufY1Osb4mNecHCAPg/f5LCPUlcdBUgk1JMjI/C5bIyeVNLzvqM4azPGA69G0KfKTWxzSQiVBxzWlO1Yd54tiKIdBudsjdt1pqUYXtLcd9ptbAPBsbpSzyNCI9gXvlBajFx8IV52GSVK/CeVtk3Yq1aTPz95EysHf8bn/t7xg4TCzx16mcmZ67kTZH8UYyN9ek/vDgfwnpxz13uWjSnz34AOgyrgr5+qhl+x4qhsQF1u5Zl9d2h7HadxI7341m4rjqNWuXk1N2WUttauvg9AH8MSj/peUqlCqeKUWLi+6uGGBqkIVvOBPDxnZ9aTGzxSx7OP26Twj2K4sWTYgCMHveRZ89ExOG/JwsAcOGiP1mc7lGn/nO1mDh0cGY+Opfg1bPilCyZ9qJmzczENSQsTETGtmsvVndv3IqqgfvVM5ywsJ+iY1rjZqd2vFkZNXZ/NnUiTyeP56ftBVhnsmDKoT5sfj+ZrtMaARASGMr4+n/RxWkS/yw4g1KZ9GYy0ugl8C+NkCq6evPmTVavXk3x4sU1np87dy4LFy5k2bJl3Lx5EwcHB+rWrYufX5QBxeDBg9m3bx87d+7k0qVL+Pv706RJEyIifizUwSa3E2b2wnHp45mLQJS4WHrcEGwKiBpC9xaswOeVWHmtuVouksTMSH5FT9a4wljSVEKWD19T32RAtnhurs7CKdbz0VP83n/S6T2yBgiyZiAlS8oV3f/6If6Cvt9jkKeY+v9Zxi3BvNz/0Le0Vj+nDNWMnJE9lmTNDBLieK4LOX8bAsDrudOkzXFkTVZkTVwikXWRTU2YSBTctrAxocPgiux9NYirAaP453E/nd736YaITsyS2w5Ti/i/qxfe1vG2iU7VrJ+l2gPklDyn7XR0PL+yaAcAtrmzkqeq7hETCSmILWtQIsv354P/F18WVh4KgE22jAy/vghDkyjDA9nPkMlcvsyIrBGNrLnU7fcZtT6/vv0sXp0XNb4GX5iHqY24d+59LJ9W9zZYbhVe1qBE1gBFhq9fQlj71xsAtu2tpPP7ZF2qZY1oDBMQYWWg0P16HxgQxrm9YlGr+7gaOr3H3jzp0xeDw3UfyxgY6uPUqCardtXGyEi3e2OoVR4ePRRj9ly5TTXccbUh63asn8FJqr3Yh9w4QJsjdEioihyVxbUhe1b4cM1I/dlkXadlXa1Bu/NvnPsIlDNkMNHiFHznmgeV8oqFvdEzyrJ0Sw31a2FK+fGbrOt0pANzbFha6nPskIjgqln3OUePeeOYXTM7JX9+E65fLoTrh5KMGJZFHekH2k1f4kPWaVt6+waxGwL99q2O4sEDom5i//7iXhK9jmLRMi8pUf5lrNuwdzsh3SfZ8VKQxDUGwC9E7ljKKukIDZDVWu5+oovZZ3R0He9FkitjTGPNrxcvqAVEh8bCNNN1/17167oYuUTnoWvSHqsJMQb0kJz7RN+HQqGgbvcKbPkwhQWXB2OfXXy+/YvO0y3HFIZU+hOPd57SffpJwkhxl2d/f39Kly7NihUrmD59OiVLlmTRokWoVCocHR0ZPHgwo0aNAkQ0YubMmZkzZw59+/bFx8eHTJkysWXLFtq3F26uLi4uODk5cfToUerX1829KrrLs6F5lBuYt4+Kk+1+BaDBvo34vf+IKkKJdZ6cALzYuofXuw8CUH/vBjyD5MS1hLg8h4SlCg1YTXY7eZdnWWEqqd2FLU3C8Hb+xJFfJwPQ6fSaeN8je+GUvfDffGwv1R4TSSHryj9wPCo9X2HngNnoTYSe2ETYv9sBMJuyF4Vp1DEdICn4ZbCUmwzJ/m4yRDpY1/x7i1Rae1Ifq6EJuAFHR5e056SOUCydRT6iUWYiDlDObD4AW58PV9f3iou8Vt5S2z/3UT5NIjaX59hw8Y1fpPF578rhnsJ9fdDlxVLHanC4fIS87CBZluiLO64PXnNgwAIAirauQdXBP57y6SLp1AjyCx2y52jN/K4aj1UqFdPLDIdvQ61xt+ajFy06rVkBeTHBwfDHxYG4kBXvZLA3E6n8O/dXplY9OfFIBlmxIiGCSLhK93OudtFdvHnhw6jVzanVRrdyIknp8hyJzIIQQNkMrvE3ioZZ8EdyZTlBYEAENx7UIEfOuM9ZWXFN6SWfkRThrbsTO4DCSPN38PVXUaSOuHb+r6KCrYs0ryn6dnKLBLKOzSDvDK0wkJu4f3/+7N/5ln6dLgCwbncNGrfKIbU9bci6PCv9dHMAj3Q8js7CP/PQsWPc1xs9S/nrUVK7PCsDvWN97atnOEVLPKJwIRP+PVkQgCxO9wBweZETAMf8zhqPv8cre1PpPl13k5yfSCK7sOjsJR/Y8lVSyJINVPnsL1cf1/W7sczH3Ttx3b8Xx5ZtyNqmHSqlkltdxHi/3DYh6msTIeNC1uU5IYvUsmS1CpJqH9/9SqlU8c+f5/l7/nmN53tOb0CDnuXjXdCKbYEtMVye70xPmMtz6fE/XZ51YsCAATRu3Jg6dTSL8r99+xY3Nzfq1Yuqr2NsbMz//vc/rlwRRa1v375NWFiYRhtHR0eKFi2qbqONkJAQfH19Nf60oW9sRO7WTcS+Zi7CKmd2tZj4/sRZtZhYd9ca9H6mO6dpbHJmJVNRkXp5d82eFO5NMlC6AYa1O2I25zgAKk83Amd3U4uJpqM3aYiJaR3rRuJG/P7gkRTuyU9kuXtZTBht7S10EhPTKiqVSi0mNvxrfLqq5/pwz1m1mFhnUs9EERPTAsrwCKaXHgYqFUbmxoy/s0BDTPyvsffvDwAYG+slqZiY2nD96M+bFyIvVlcxMb0QFqYkMEAsIMUnJqYFXD2ixMTOLfViiInpkflT76nFxBM3miSKmJiU/PFHNnr1cqBuXVuePiuHm3vleMXEtEgGO7EI8uRp7AtGGTOI+01QcCpMAf1JrGRtLcZILvvEfFShp4dpNhGN7ff8WYr1K7Wjp6eg7bAa7HadxPx/+2FqIRaD1o8/TjvHqYxusAbvz3LZRYnXuag6irr+pbxKpzsp2tWdO3dy584dZs2aFeM1NzeR8pk5s+ZNIHPmzOrX3NzcMDIywtbWNtY22pg1axbW1tbqPyen2FMmCnQVJ/Xnm/cI8fIGwOPmXR6vEA5DtTYtw8Ak7aYr/iSKugtHAPBk1wlCfOUjL9MUJuYY1e+GQqHAdNxWQIiKAGYzDqFnl3oL2yYE68Yigvn1Vjnjk5+kPH3qit9s0ZneKdyTpOXfEUJwy1GzPHb5UmbC9ujwDeaVH8TxadsTbZsnxq/m8mLhCttu03jy1imbaNtOzYQGhTCjnLinZCmUjVGXZsW7Op6eCQ9X0q/7LQCevm+Uwr1JXirnFufT4pPdU7YjKcDkcWLyO31O4RTuyY/z8q2K8s2EmDiqvz6zRqV/X8uerc8yf4pIG77zrg0lyqSNuq8zZuZmy9ZC2Nqmf8E3OqVLCAHF3UOUcOj/qyj/smd/+pjTbBp/BOdHclHSaRGFnh5mOUWKv99TUSqjwJgJgKin+F+ki9Mkzu68q3P7HIUzs/nlGHa8H0/9HuUAeH3fhd7FF9A2yxQu73+UVF39T5JiguKHDx8YNGgQW7duxcQk9hjQ7wfgKpUq3kF5fG3GjBmDj4+P+u/Dhw9xbq/8DGFQcab7QLxfvOb2dE2X55+kDxR6evxv6gAA9rQanLKdSSaUnm4Ezegc9YSxGQrDpE+zSm4UelERxGF+cmkCP0k5Ht8SA0cTcyNs7OVSjNMS7vee437vOQBVx6WccJqzgihg//DQdeaVH4T784QbnKmUSlbV+J235+8B0OPYAuxyy9cLTA5CvX3wepR4pk0Bnv7MqTwGgCL1S/Hr9qGJtu20SqMaIgVp5PhCP+QOnda4d9ND/f+CZbOmYE9ShrUrnQH4tV/yLpK4uEXg8SXxorJu3FNSq4MQExdO0Of3bqkvKymz1VEyWx3l0YPEMVYrnWM3R/eL1OHXvh1xzJZ+slbSCy2a2QDw4KEoUxEpIK7bLMa5nduLcksr1vgkf+cSgWX9/8bTNarvpzfdYELDlf8Jc5L8o8YB8Gz6ZAAMbWzUr4UHREXZBXv7EeiRvmsFRv7ex9bdUD93avMtvrrGf60zMNTn15mN2O06ian7uqufX9T/H9pmmcLMTtsI8JWvwynNT1OWpOH27dt4eHhQpkwZDAwMMDAw4Pz58yxZsgQDAwN1ZOL3kYYeHh7q1xwcHAgNDcXLyyvWNtowNjbGyspK4y8uMhQtCHpCoLw6Qrg8V5w7Ue3y/JP0Q7bKJdWphs5nrqdwb5KW8KfXCZotXCoNa3cUT4YEEn7n3xTsVdJhP1Ccu0+WrkzhniQetf/ZHu9fWqZ79W0ALL/cP4V7knQow8M5PVzUiGyxPWWd5i0yWTP8+iLy/k8YNm3uMo+tPReiknTMC/YLZH7FIagilOgbGdL3/DKMLVJvuvrD+Yu5O3kGZ9p0ws/5ndY2EcHBXO3eE++Hca9qe77/zMLaIoKgSs/atJrdJdH7m9Z48siHe3e8ARg+tmDKdiaZaVllPwCXX3dM2Y6kAHdvCDG1cFHLZI/OLVfPi1K1PPlfcy+CQ7SLD3efQJM+qF2aY+PYOSWt+4mIry2LDGjbOPWJiQDtOgjBunbVS5Qrfpbg4Ji1issVOYm92T7aN7uMUqn9ewkPV+KgvwmXj0Kkcgnrirn5f2cRIC3Rv5+oZ/jXSnGuNagjygqsWCsOaksLMZ9590HedCo1cP3wYwaVX6h+XL9XRQAW907/2UaG0bSJMD8hnOUfJQKcXi6IMoE92H4wh7uMSNcia8g3Yyxzm6hx5OpRR5jTTe44KFQxB7tdJ7H19VgqNROmh3fPvKJ7gTm0zTKFh+dfJV6nv0eBvJiYhpJaUkxQrF27Ng8fPuTevXvqv7Jly9KpUyfu3btH7ty5cXBw4NSpU+r3hIaGcv78eSpXrgxAmTJlMDQ01Gjj6urKo0eP1G0Si2pLZ6v/X3rsYGwL5E3U7f8k9dB2/2IALs9ci/IH3cJTLafWErJBTHqNe03HqH43zKYK97CQnXNRhcgVyk0LmBYqBcDXO/dStiM/0YlXj6KcBDM6pt9I8L2/jASgeLdmmNvbpXBvRFZAy3m/8usesTru+ugd8ysO4fVF3dJDPF5+YmltEZ2Xu2Zpev8rZy6TEpSaNAbz7KL0yc3hY7nYsz/hQZrXwDBfXyKCgng0fQaX2ncg1Ns7xnb8Xr1meXNRwqXR2DbU+qNxkvc9LVCj/BkArtyrE0/L9MXBnWJykjOvNY5O6TfCOjZaV9sPwPY95ZJ93//+YwPAq7cR5Cn3lRl/xkz5vHwbHjyDEk3h17Ggbd1k8z7oM1qIMUc2GlCjYuq9li1dVYLr92sA8N45iBz2J1iy8LVGmy27hSBz9rQHDhb72bdbMwrd1ycMR6sDAOQvbI1bRDf09NLQrPY/RvFiQkDcf9CbLE73cCokFsSUSij7vw+07x4VlHP+chAubuFpSnhyKiiCg06suwpA58kNAbh94hlebokTiZuaiUxzfjlPaBDWxUsC4P/8mfp3zNusFgAv/jmZ/B1MJgK/RRCaW4uM1sjPntB1KmMzQ4auasNu10mM3Bhlbjm38xa6OE1i1ZC9hAYnrWlheiPF7oyWlpYULVpU48/c3JwMGTJQtGhRFAoFgwcPZubMmezbt49Hjx7RvXt3zMzM6NhRrPRaW1vTq1cvhg0bxr///svdu3fp3LkzxYoVi2HykqA+fnOdDQ8O4eKAUernP995oLV9Rgu5kFkzI/kVI2PD1FVY972nfAqErBOurNOurIun33ftDc1MKNGzBQBH+07T+h5Z9ytZN65yRTzibxSdYInvdFkvuLgDANMxmzEoIAb7ChNzjNqK1LzACS1ivM3cRO54/eonlzot+7slBOM8hQDwef5Sp/ZJfawa/YCL2o+8Ny5efpYT7+64yot9urijdii/CYB9j3/F0UJO4H7layPVvka22GvuxkZOO7nCzo5WMZ1z35y6Soi3uDYU66Lptvg5QM4OzsRAfvEjLudC2+z2jLixmArdxL1077A1LKo+gtCgkFjf8+T4LTZ1EivndUa2pfWcbtJ9ksHRWt6NWJubvJ6hIRUWzqbiMhEJEebry4Uuv/Js5VoM9cT3amJvT4U1q9TvudG3P4+mz1BHb3reucP9ceMBaLewJ2Xa6raoefC5fBq4W5ht/I2iEaySO5YURolnnjF1vBCiq1TPSN78lom23fiQdZA11JMfj8XnVj+oqxBSj9xsBUB+i89xNY+BvXmodJ9kic3VMjZufc2iU7uQkIhIY3OyOOp+/Mm6F+vZZtP6fMF8Bnx6kJF5k4SQu2JDEFmLf+HspVD0bTIC8HsX2CKCwzl5CXLWgG0Ho7YxZzWMFxWOuLjHkOIFdfuuIjzlnKpVQd5S7SF2N+ycucxw923E/CXC/GfG5OciDfqeOPYKFrbCI7AlfwzLB0DfbjexN9uH66cg3jkHkDfLYQDadXLiwsMW0v2S+gySTuwJcWGWQVcX6egoTOWuxbLomdnE2+bXXhm1Pu/iGsHFK1Hz0g493Clb/SNZC7zDMb8zjvmdKWKyVOOvdt4N9G68nxlDzrPtr/tc/fc9bh/9NUTICg6S8xNJwiKizrOpR/oAsHXyccJDxTV63O4eAAwsJ+pO57SVrw+ZwTz2cYw2LI3lxKVMknpAlljGMlZFRbZIwOtX6t8gc0OxUHllvcgmK9lPCGL31/wd5z4eusodq9F/h6Tik69umSsBPuL7NLEU7YMDxe8RKTD+COXqF2C36yTWPxlJ0aqibuWlPffplW86XZwm8fpuwkv/REfWkEVtzJJGUKhS0VJFjRo1KFmyJIsWLQKEAj1lyhRWrVqFl5cXFSpUYPny5RQtGuWSFxwczIgRI9i+fTtBQUHUrl2bFStWxGm08j2Rlt4t9y7D0Dzq4PYLNkQZEcGJVuLilbtNU97sOQRAne0rMTTXHHR/L0zFh7+kDT0k3gmuDAlBGRKMgZX1D20nu+SkGqKEWl0JlhR1Ytu+MjycYG8/zDJqXlRjm4ivq9EPgGYrx5Cp4I/V/3n7RW4ideaJZDp9gA7HUlgILKwb9XjccTDQIvpNrQMqJTQcCOVbRD0fLFmA3Fzud06IWG4Qi6im9HRDYZs5RppVTuN3PB7UBz0TE4qv3hrv9mWF4+RAdmBTPKtcbZV8meQm4qWzyK8SxzcRf/fSkzYl1gNwM3A4nsHaja8i656YW2kOKrKZyfXpupu9VHuApx5ykyEXX837RVhAEH83HwhAuwNLNO49EPvvHBYUgvd7dzIVyK75fALuDboeS0E+AaxqMFr9uMqgthRrU1OjzYUFO3iy/yIALf4ajkPR3NJ9Cg7Xfq2PCA3jy7O3ZC6eX+N5zwB5QzRd7tNfrl7j2aLF6scFhwwmY8UK6sc+T5/xcPIU9WPL/Pnxe/ECgN5bfid7iZw696dZvtgHqy7vfHHMEfM4s9KXE1JN9eUmT/qqxEmP8/YKIV8m4VLpHtpRI9JJFar9M7h+CsLewQR9/R+LipIVK8KU8gYbcS2MLJh0k2Wz7tKodW6W7xCivHOQdkOL9y+/YmVrik1GzWvER98fnywlNuXtdRNdxvU7y54NT1mwrCRdeuaK8XpAQDiBARFkstc8h2VFnYivzvG2USpV9B3ixdFTUZP8GwcNyWIfdYzNXhHO8s1R9/tiBRQ8fC6mR/eOGZLBVvfjUc9Ku8ATHq7C44sSRwfN40bPUv7+o4vQFB6upFnje9y+Je6HufOYce5aNYyNxf4D/MMpXfgs3t6a94FJ0wvy++gyUv2JUGg/f1QqFe+d/cmRK+YYWPY6E/H1rVR7WRIiWKqCvGI+p1Jx5l9PqlazxdhY8x6oCpdbJIjtOhl7f7w1Hvv4RvD6bTi37wbj6aXk1ZswXr8Vf2GJFICVwdGaLHkykr1wZtqMqI2h8Y+ZFX0/bji59go7px8jW8HMTD3+OwD9Ck0lNCiM31a0J0OlCto2Eyef/eWurZ6BMccaKpUK9zuPsc2XE2MrzQj0L35y249rcffDzu24HdqPY6u2ZG3dFpVSya0uQkRsd2IdAEe6jybA9TN1lk7ALn9OrdspliXmsRoX389/IsIj8HjtwcfHH8lZOieZcmaS2p42slrpFizw/MY7prdeT9P+leg6sR5fXXzpV+ZPKjYpzLA1bX+4H99zduddVgw5GON5Hx+feMvkfU+kxnR3IVhKVv7xC4JSQxO23+QmVQmKKUXkj93in6UYWUQN6PyCDXn190FebttDlmoVKTn8N9yu3uTu7KXom5hQb9dqje2kJUHRef5UAh7fo/C6PT+UjpaWBMWHWw/zYOMBWv+zEBPrqMFNbIKir8tndncU4ea9zv1Y3b0UFxSji4lZCkHXVRBbxGFYCMwUaQWMPACm3/qeRgRFlVJJ4OiG6JesiUnH0Rqv5XPw417XNgCU2LQ73rpOPwXF+EkKQbGcmQgb+ftOD3IVzKBVUFSpVDTIMBOnfBlYe72fxmtpQVDcVkeYr1Qe3YtcdSrGaK/td1Yplaz637cB9cUVGq8lpaAYyb0D1zk3O0qI77p/FqZ2VmxrOwF/d3GcdT0wGzM7qwT1SZug6PnyPcf6i0jxDsf/Qs8g6jqUVIIiiOPr1eo1uJ85q36u7JJFmESrz/z+n728/3u3+nHpPxfQsrbckCo2QbFpsY28f+XNkSc9yJZLc+EvrQiKmQxEDdTNe6vTsJnmIq+2ifLDe97UrnyWqXOK0e+PHysrk5KCYkSEkrymawF4HdxbLaRqExQjIpTUsRO1U8/6jNF4LS0LigWMxfXJI7Cl1tftzfZpfT0pBMVIvLyVlKruRti3w7tMMQW7/zLA0ED8PsEhKhr3COfFm6hz+PlZQ8xM5cRtbYJiaKiKXCWFydinJ5pRmEklKEby5nUglcpHmRlMml6Q3wbmVj8ePfQRG9YK85UN20vTqIkDemZy0UzaBEWVSkUWg80AvPDsgJW15gJ2ehQU585+y4J5Iu145uy89OqtGUGb3IJifPjlaBTjOV/vEJxfevPmhTdvX3jz9rmX+PeFN2FhcY+Ju89sQu0uP1biQNu4oWdOMRebfvoPHPPaE+QXzIBiMwAYf2eBdI3WhAiKyogI3p+5zpMdh/H/FHWdyl6rIhVHaZrpJaagGF1ALLdNRCE+HD6YYFcXai8aS4ZCeQj08ORwlxFAlMj4PbEJikqlEs/3X/n0+AMuTz6q/w2LJ+V39uO5cb6uC7oKindOPefPntvpMLoWrQZV491Td4bXWkntTqXpN79p/BtIIF9dfJnZeRvvn4qo3J+CYuz82DJCOuP+6l2UG9pD47k8bZqQoVghbAuJ9ACHSuJCGREcjNezl9gWzJfs/UwMzAsUJuDxPT4f2IV9yw4p3Z1kwSanGMQ92nqEsgN+iac1WDlmInuVEry/fJ+L87ZQbUQaLq7v/S09pkoPqNoj7raGxtBmIuyZCnObw6QzSd+/RCRSII+4dxa+ExQB7Ju2xOPQPj4fP4x9w6S7Ef0kYbi+j6qQn6ug9ogegBWjRb2YKk0LJHmfEpuHW0Sku7G1hVYxMTZ2dRHCWpGW1ZOkX/FRsHFl8tUtx7Z2Ewn86sPmFpoCSJ+zS9EzSDzDgshFIIASPVtqiIlJjUKhIF/fPuTq2oXbAwcT5uvLrYGDMcvuRMmZM9AzNCTYPWpSUXbpEkzsMwGffnjfY7of4/0rb4AYYmJa4cj+D+r/fy8mxkbtykK8bdIidbqB60qf1uLaNHxquXjrz60cL+6vfafWjLNdWuLGBXEOlKqoXaAJCEgZgwhbGz2cHzhy87IHLXqHc/uhitxVwxjZT58/uutjbATuX6LExLeXDDEw+PH6gSpVlJjYrUPilRPQldx5RBr0hjXvGD3sMVPGP2PK+Gecu1aNg3td1WLi6YtVKFYica430cXEoiXtYoiJ6Y35c52ZN8dZ/bhr9yz0/DVturpb2RhTvFxmipfTfv7e8Ij5fIBPEJ4uvmQrKC+O68K0U38woe5SxtdZynrnaZhamlC3ZyVOrb/K7mEbaLewZ6LvMyw4lGeHL3N70zGCvbUHz+RrUYciXZon+r6jo9DTwzR7DoLev8Pv2VMsCxaiwLiJ3P+9H/8Onkm7E+swi1Z/OywgCENzU1QqFYGfPfF64YznC2duv3+Fy+MPBPkmrEa+Q34HshbJRrYi2Shap1hifTydCPQRfY5McQ7w1qypmFRkcLRiwZn+BPgG073AD5omJsS1OQ2lPP8UFKPx9sQlSg3ohIFx1I1PoaenFhMjqbFuEed6DebaqGk0PLA5ubuZKGRs3AqPvdv5fHD3f0ZQzFZFmHI83/evToIiQJ3p/Vhfsz8vjlymTM9mmGVIm5M7MuWCURd0b1+kBhxbCgFecHEbVOuUZF1LSlTKCBR6mgJHlla/4HFoHy47Nv0UFFMhrYuLVOetV2IX8FUqFQfX3AKg+7gaydGtRCPAw5MHm0QqRatd83R+38vTN/F+LwSsakN1u34lBfpGhnTdP4uPt55xeMgSAByK56HF8mGJtg+VUsk/7Yar60s2WjUR2zy6lzFJTAxMTamwZhX+zs7cGzWGwPcfuNK5q0abihvXY2CaOC7W6+bd5Oiu5wDc8R+YKNtMbpRKFd3biPvNqy+6pSM9fxoVVZzNKflFl8TCzzeUM0eFQDNgdKl42+9ZcROA9gPl0/ZSK13qikWA5bsbAjEtlOdOfypeXyeXVptYlCmmx4drRqzaFsH0pRHMXSn+ovP+qmGiOVPnKiHExApljJg5wSZRtpkQevTOQefuTjSqfYUH93ypUfGi+rX7z2vhkCVxJuffi4mnbyftOCs8XEVoqBIzs+R3314435k5s5zVjzt3zcK8Bfn/c0Y25tammFsnzj1QG1nz2ZM1vz2fXnhwav1V6vasRIeJjTi1/irPzz7Cz8MHS/sfm5+F+AXycM857mw+hjI8ZhaNnoE+hTo0IV/z2hhZyvsH/AgFRo/j3m99eDZtEuW2/Y1CP0q+OT9mAb7vomqq7mv1u9S2M+TIiGNhJ7IWyUbWwtnIUigrxuYmqSpDK7K8kdm38kaxlTtKKhLjXpCQmohpqYbiT0HxO07/MY0Gq7UbcURimtEOu2KF8Hz4lFe79pO3fYvk6VwiotDTw8DWjnAvT0JcPmLsqL2wdXoiIRcEhUJBwz+HcGzIn+xoPeqHU5/TFEN2wfR6cGYdlGoIBkmz8pgUGNbpTNjprYTfPo1hufoaryn0owad4QH+GJj/99w3UytfXP0JCxUDuQIlY08/2jD9HADNepdNtEmfLjy7+pa/Z52g/dj6kLtEgraxv6Mw+Kozf7jOEXchfoH8O2UDAD2Ozk/QfhObbGUL0vfCcgI8vLDInHju1P7uXznQKSqy+JejK9A3SnrDpviwyJmTqrt24HrqNK/XRqUUVd62JdEiJ0/vf8WSiZcBuOLxG/r6qXM0uWj2I2aMv0/9JlkZPaUERUtopke2rHMagIEjC2Nto1tkUrUyosD8tQd142mZuqlXQqTAr9pdL962N/99A0CxStmS9TqWlAQFRqXJZbA3g4iYguJfi4X7dZtfUmaRIJK+nfTp1V6PToPCuXJbRCbmzAYX9yReNF2TXz4TFg4mJgr2btFeWzE5MTTU49SFqrx84U/VskL0f+NaD3PzxLmGJbeYCNC48QPu3wtgy9aC1K2bePeiuFg87zkzJj1RP+7QyYGFiwr854TE5GTS4f70yT+FHVOPUrNLeQwM9Rm1qxdz2q9jUf0pTLi7UGp7/p+9ub/jNA93a8/CMrGxoEy3hhRsUgU/ZfIZimnD0NpG/f+bndppvOZ+5wnaMMtkh23+nNjmy4ld/hxUqWqDmU3yCqGJRaTLs8W3iMRAn+SJUPyJ7vwUFL/D950LAe5fMM8c942//JRRHG/VnZfb95KrVWP0DVN+wiNLzhFTeDX2D5znTaLAn9prLqQ3slcvw/sLt/n85DWZCufR6T2OpQpgYmtJsJcfTw9coFDzlEk3THb0DaDTHNg2Cha0kYtwTGEMq7cm7PRWQo+sjSEoAuQeNpY3C2byfs1ycg8epWULP0kJfvnm7LzubMc42+368woAv82Of9KemFw/+ADnB5+Y84uIolTo69FoUicK1S+jkyBweeYaAOyL5ydzSd1TtTc0Gg5AnUk9MbZMPdFbCoUiUcXENyevcHWuEE7zNKxKxWFJ6xKdELLUrYND7Vp8uX6djBUrJpoQ9OSOO8M6CIfVY896Ym6ZelMEA7+lrJ44/IkTh6NSvH/plpuW7XJw5YKoNzRhZvwRegBv30Slk+XOm3YXeN6/8cXtk3Acrdc8Z7ztR7baBcCMHW2SslvJyvh+5wCYt7GO1tej12BLDSKqgYGCXcsNcf+i4sotJS0bJF6U28hJ3tx9IATWV7cl62InMfnyW+DuG7N+3o+QXGKiSqXi2dNAChUW4siSJfn4X/V7dOn8jN27C1Otuk2S7Bdg6cIXTBv/WP24XfvMLFpa8IdNpGR4/iIYD48wqlUVIpdKpeL9+1By5JCvKZyWMDAy4JfxDdk5/RjTmq1kyrEBFKiQEwMTQ8KDw3h6+j6F6sS+0PvF2YPL6//lwaGbWl+3zmZP6W4NyFunHPrfl26RK2WZJBSZNY/HY0ZgYGWFea48ZC2SDctsmbEvWRDTDPHXPDWzkTNlSU0EeH9LebYRUbD+36VApwnSecpzGupq0lNj7kgAjnQVAkNc5iEKfT2K9O8OwMk2veJtrw0LyYL4kLgmEcZZRH2PcG8vVMqEbfe9p/zgX9a8xsQwbgMHme2X7NUKgDurogrpx+YsGp32O2cCcOXP7YSHyP9uuTL6SbWvVdhNbgeSBiiAbiYrltFq2F1YKrd9XZynoxESJn85Co/F9EFh8k10CdQ053jpJgZgViVKA+B7R/vAIpLEMkFKTOIq3qyNB5/kBJ+Xn+UK/95x1b399sU36F5lI6tmXOX5PXeie4J5fwnE56sYJBSvoFlDzc4kylRix0IRwVW3Q/FYJ6QfA+U+QwUHD53adZvVnAXXR1C2UREAVBFKjkzcwvwKg5lXfhDXN50iQkuqDIC+6wucz4jC+HUWDI93X5G/88WFOwGwyZ6ZvHXKxto+IfcG2WMpNgOr2JDp05FBC9RiYq05Q3QSE+3M5cxGQP4+rQ2Fnh6ZKlXSevydeCpXN+vgy2y4f/SjQ5UdAGw5316rs3N0fCPkROWgCN0nmiWy/U0mg21kNdvB8gVPCAyMWe9u7LSSfA7vxJlbDanfJOrz7tz0hvaNRR3EC/cax7kfhVHUZ6hQ9BQA52/W1rmf8aEXImfMZKgnX9fve3Op/xUU5+qRG620ts9p+lX9f6/PAer/W9pqTxXMZhWs9fmURFv9tOgc3vUSgGYdhCO7l34Wjdf/WiKiE6fMLqr1/bLGGPoZckq1B+2mKZkzKhJNTFT6fmHVRn+27RYqxNt7WeIUT5V+ut1/NN4T6C33hjA5RUQZKCc+6CnDpMXE2JyhY0M/g3ALX7/ejZo179Ols0idL1DAjFOniwPQtu0TbtyQN4qDuA2BVix+ib3ZPrWY2PoXJ1z9WrBsQ2UpMVFhILdQFP06GUmN2s9o1+G1+vGCP92oWPUpr98EozC1kdq+5bujUu1Bd2OmhBLXuKHer5UB+PDUDddXnwFYfFPM3feM2KQxpnR5/IFdQ9YzrdRQppUayl8tZ2uIifaFc9Jwdn/6XlhOv4sr6LBjMgUaVIwpJgJ2ZnJjjYyWctduXQzyzLLnoNy2vyn111ryjxyDeeMu5KhdSScxEeChq5zRUnLMfz756pYmH/AtItHA3FTjcVKm2Sc6egn8SyP8jFCMhm3e7Cj0FKiUKtzvPcWsYPE424d4R6Vy+H/4hCpTTqn9hYTrS08CwyL0pN4TX1vHVm1w2bsHn2O7cWzZWqovIC+U6dKnH31PXJNekxxCIPvy+LW6nS4X8rXtJqj/v6fTOLrsm61zfwDeeVpgLCGMXnieGfPYXJi1EOCWwDD2sDgGN2EhsPLXqMdXd0PBX8BKx5V2kwg5UVFfSUiw5IDeUEkIsbzHxgG83Qj4HAhmorZK3qy++H8TUo1z5Sfk7Qu+PH2DSa78WjdhbKhMdaKirVkIoRJ9KpDZR0o4Kp3ta/yNoreXcHleOlaIDc/vubN2xmWtbVYfa42RQvPYdwuKOr43fkt3HrIkdsEiKV2ebTNb8duKX3jqYUVoQDCXVh/j9g7RpwvLD3NhuYgyK9m6CtUHNMXYwhSVUsnmLqJeYpN1U3WKzLE0DuPLq4883icig9tvmRBn+4Qcp4b6Sp0WVBKKZ2D8QlaoXwD720TVCmyxZwlGluaE6XC5dPGWj9YMkfy8sk7Y9QrJmbLUyvya8hlFhsCCrQ0oXcEeiPvDm+nJTW4MFBE6uxh37luIBZPvEBqqZPKou0wedReAzFlMGTutBO0658LAQBxrxUrasXV/DfV7W9Y5zaVzYrJZqKhNnPuJdC91+RhVIL5QkcRzMUyIy/MXjyCsbY0xNNTtXIru8nzjkqv6/4VLas9wie7yPKq1cOtcdDT2+sSp0eU5t/5HHt71I1cBW0xMNY+pS6eEu23FmtnU3429gSfoR52n0ycIQabP4GIoDGJ+z8pALylRJMLtibRIo/T9IvUeWWfekzfMmTpXCHJPrjlgZBT39V7P1BrC5c5phZmtVL8UBkZSoqLC1FZnh2GVSkVm8/2AXGSirMuz0ucTCgMjuvdyYtzYt5w65cVvA17x16rCFC9lx+HjpWjS4C7Nmj7i5L9lKF5ULmJPm5i9atkrJox8qH7csm02VqwvqxYRv3d5jg9pl2ctwm6bltbs2efD5YueVKlkTu3qpiz4E2bN+sTqhXKpuaF5m2CE3O9w62sWTAySrr6eR0Dc5+a4owOZ0WgJ4+osYfmrGTgH2VPml/9xe+d5ppeOvZZzzooFqdSjHtlK5cHFN+qa5K/DTyIbCOMZIHfsyY5LAPJnjllOIi5ic3mODdkF5ISQVcdFsxA/MU5wyGSIkb6S4G+PbWyNMErEQCuZudVPNPkpKH5H0x1/crD9YM6Pmh+n4cqnM5d4tWOf+vHF38dQddeO5OhiouLYUgiKn/bsSpCgmJaJCAtH3zD+U+DUjG34e3irHwd88eXT3RdkLaVdhEo3LP0WLVK1H2QtDrt+gw2tYZB2ISjVUbcv7J4CF7dD/f4xXnboO4J3o3vzcdZI8q7en/z9+w9yNWAUQQGhPDj3inNH3nD+yBu8vmg6zlWoEXtdrf2rxOpytWYFU0V9OSNzE2oNaUmtIS1Rhkdw5+8LnF20H4B7/1zm3j+a50q+ZjWwzpFFy5ZiooxQsqeHiIxut2m82r08PeF+9wnnRy8AIGPRfNRaENOVPT2jVCopn3EVAAMmVKBBm3zxvCPpGTyuFKPHFyIkJIJt618zc8J9fLxDcXcNYtCv1xj06zUAChezYczUEtRvkhWFQoG/X5haTHQL0d3orUppUW/x1KUaif5ZZAgPV1Iq63aN56rXzUqnXwtQt2mOeEXG9rWEc/uN953j3ZdKpeLlfZGFUKJK9gT2OGWo4rgm3jYLtjXU+nz06CEDLWJieuD+UyW9BoqJ+9WT9lhbpc/PGUlCxcQfwcBAjw+u1XHKcoG9ezywsNBn3oIClCtnzT/7S9C6xX3q1b7N2XMlKFQoYYvta1a8ZtzwB+rHzVplZeXGsqniuB05NBN79vkwdZYHJw7molRJEaV15LgfSAqKaRHH/JlxyGuP2ysPBhaaSEQsq48F65aiQve62OdLm27bP4lCbcIS6fKcBmsopndTljTU1eTBxMYS+xIFAXi7/5jWNl8fPOHB4tUA1Fy/GHNHEbHl9u+/ydPJREShp4eBlYjeCnZzjad1+qBc35YAPD90MZ6W8OjgFR4fFhOogRcX8evB6QAcGrhIY3Cc7vhnqPg3Q04o31kIipGpF89Opli3pCj0rdbltd1aX/Y5F3V+p+vfMpkY22kflcznUMl8DoOb/82eVXdw/xgzUtDU3IiaTfMwZWVdzn3oy/2gweQtIiJ3lu5tHuc+/hojjr3Ra1okev9/FD0Dfcp2rMmIG4sZfn0RzWb1wNBEc6W9/EDd3dJ3dJgEQLG2NbHL7RhP67THrcWb1WJi+eE9/3NiIsDYYuIz122Zh9/GlU/h3mhibKxPz/75efWlLZ/DO/HGsx2jJ0dlbTx56E2XluexN9xOJoNt5LIVEXdrdlTVWez3cA8mwF9Ex5QoLZeOldgYGOgxb1VV7B2iUqgunPpE3/ZnyG22ASfDdTgZrqNLkxMc2++sUQvw743PAChSMgOZHOKPmt085xIAnYZVTuRPkfTsvtqe1j0KU6pSFqzttE/mbGJ5fscmYULzx4jCSda/lOSTm4omPcTxfHBHRrJnS98xGykhJkZiZKSH88dqAGze6MqUSSIFuGo1W7btLAZAzRr3efMmKNZtaGP9qjfYm+1Ti4mNmzvi4tuctVvLpwoxEcApm4iWe/AwZnTXf2UsO+bgAAANMbF480r03DWGETcWM+LGYprO6P5TTEwnRAqK986Le4i/j6ZJS5rgZ8rzf4/qs4ayp1Efnm3YQc5m9TUiQ/zef+LGBJHuWnXJTEwy2FJl8XROtv2VV6vX4lA78WoAJRcFx03i0aihPJ81nRKLl6d0d5Kcwq1qcnPVPq7/9Q+FW9WMtZ3rY2dOzxJRp32Pz0bPQB8zu6jVv1D/oFRlkJBoPDoC70StN7puEf9+eQOR6S+5q6RMv2SJJa1UpYzgzaBOqEKiBmM+Z45gU7tJcvUsXWJuFZXicf30W66ffsuCoac02mTMYkG1xnmp0yQH5f7nhLGJAYEBYbx6LNKsqzfMFev2j2+5B0DZ2rkxMEy6NN3EQKFQUKB2SQrULgnAlzduBNvoHon05tRV/FzFd1JlYNuk6GKKEREaxj9N+6kfN948J14TtPTIwqbCrTuLkyWLdiSuOUJSYGllyLDxxRg2XkzW3d2CWDznMWuWPtdo16JtDp23WauicNc8eKpa4nX0B/ilZwF+6RlllvTxnR87N7xg25pnfPEQ94tzJz5y7sRHre//50LcCyKRbJwlBMWe49OewVvhUvZM/SvmOPf3Noc5e/gti3fFfixHRreOmFgsyfqXUvgFqKjYQpRHWLnQljIlUq+pUmKgISYWt05WMTESU1N93ryrSu4cl1ix7AMWFvoMG5GTOnUzsHZDYX7t8YTKle5y81ZpnJziFh42bXJj1Mgr6scNmmRh3bbyOpc/SG4UClCpIDRUhZGRgl7dbFm3yYtTZ0OoVysNiSwJxMDIgHm3xxMRruSrQq7u6k/SHhUaFeLdY3emd96l8XxailBM76TOK2UKo6evT+FO4uZ4Z/YS9fMhXt5c+mMMAOWmjMQyRzYAbk/7ZlWfRlPSTLOJzxH65fN/YnXLwFgM9JRhsdcNCfjqy65fRfRMx02jMLX+5iZXdRAA+euXT59iIsDJWeLf346JUUtYCGzuKp5rvwaMElivMSXIX1H86yoKxYd9ced1v9ZqMTH3UnFz+rJrbYp0Lz0x7q9GXA0YxdWAURx4+RujltanSkNNJ/Uvrv7sW3uPAS0OUN52GSVMF1Epo1jEmLc1blHlz0FHAJi0Ne0JbBlzO6BnoNv6XYhvAFfnCBfpHscWJGW3kh3vNx/UYqKxtQVtj635T4qJu8bsxOONMGI4/bJ7ynYmgWR2MGXmn2X5HN6Jz+GdePypFe6hcbuzR8fLMxQPd1E3rmKV1HkMZMthyfDJZbj7qRMfwnrxIawXV162Y+DYkmTIpDmR6dy3MMYm8Z/jD68JMTJ3kUzo6aW8y3F0/llwhi5OkzT+hldbzJ89t7Nr9iku/XOfR7fdCdBSdOzs4bcA1GmeJ8Zr32Nqmr5iGcLDVRSuLcTE0b/p07RBGjIKSADfi4lnrtVKsb6YWxjw4o1Y5J4725m/ln8AoGkze5YuywtAubJ3cHPTXihv6xZ3HDJfYdRIEflUr6EDn3yas/nviqlWTASYOEbUfd68TaTXD/5DXEOnzpOrq5eWMbM2xTJDGpqP/CTBtB36PzY8HUn1VkU0nm/jNItBNVbx8eWXFOqZBArkoxNT1xAhTlLv1TKFKdq1BQAe1+8Q5i/c+J6uE/V1iv7Ri4wlhUPdk9Wb+frgCQAN9m6Q2odxAgqeJsTERReyNGsBgNuhA1Lbf/tFvl5HUptc6GIyYJdX1Gnz9/CMYVgRERbOmibjAGgwuRv2+YXguvu3xQCY2lrQaHIXqT7lsPOXal+9gJyLmrlDQPyNdKVqX+i+DUy+/bbqWop9wUEiVUnWYCUhx0V8ztC1e4t/T6+G+yd5N7YvAFb/a0De1fvRM46KqosIjPkbJcR5Oqnx0sHoIjrP3a2l2t/5mCH+RtHba3F5tne0pEXPkszf00YtMl4NGMUl3xGsPtOZrsMrqtOcI6nXOvaapPcO3wGgcPlsGBnHPxlNKpfn6BSylzN+cbTSrcD9nlaDAag2sR/GFrpPTBNidpXU1+LozohPdx3lZP/JABTp0pzmfy/+4bqQjjZyzqUgf9+VdcI+GY/L8/n157h7UBzPM+7P4tDr2GuGxkagUu4aEN08RBeCVfKr/vaZTaUEska1hNnQroNJk/abVC7PTjktGTGlDPdchMj4NrQPT316Mm1p1Xjfm9P0KwPri6j/eft+ibd9crs8O+SKee13d/bkzqnnHF5+iVWD99K+yt+Uz7iKIiZLNf4AajSOGWHuEW4HwIlDQkjt0D13nH3QM5NLfdeXGZNE7kOLy3NcxGXgolKpyFVViIltGukxoKs+Sl+5ya0ySF4E0mbWEWd7WTOQWMxGYhMTZc83kHd51rPWfm21tjbk8XNxHZk88TWbNghjrHYdsjFnrjjeSpa4xdevUQZb27cLIXH4cJEqXau2De8/VGTrP5WkhESFqdzxKu3yHMv50L2reH7qLDFXyJhBfJdv32ne3758jft+Z/TqsFR/AMpmSNryWPbmUcdqWEg4Hs5RRoEvr79lQN5xeLtFnTM5JedXoPt4LBJLEzlzNjtzOZOluMYlEcHBPJ0ygYggzfT9F5Jje1mX56Q07Ivkk4TxmIWNKX8sb8MBjwmsuvE7DjnE53F+4sGAKn/R3H4ak9pt46ubvFlsJIlp8PI9kTUUZf/SCgrVfyEkLR58fX2xtram5d5lGJpHTeBeX3zE7el/YmhhTp1tf6FSKgn188fYWkxWnQ+d4OnabQDU27OOwAi5iLWEuDrJouvkSaVUcrmDqO9Va882nbefJQETOlnXTFl0cab6cOs5//yxjEKNytNmhubAflopUT+wfMdq1B8h6i2eX3WCCytPADD+zgL8Q+QGBW++ygmvN95kkmrv5ix3YwHAUIcL555R8Poq2DlBb92PCwACJKMQjJLoQr5Qc6Jn1X8mhvlLAaD0+YrXZFFE36LHeIyLa6ZzW0gOImRJiAhkIeH+DfJOcP/L4ybVXsblORJZl9oSposAOOoyDFPz+M89e2O5AaaMy3MkTz3kREtdHI8vztvCiyOXsc2dlVbr43Z1Tgy+P/42NhlBzmolqTFKe61HWQHSL8QQlVLJ4S4jCfoiJqh1l0/ENq/uabFxkRwuzxkt5ESd+gVjd3l+cPox6wdsBWDWrUmYWprQMOcHqe0DMVzQ48NAISeimiiSVsjy9wtT11z0CGyZJPtQGMkdGwkRUWWF2keu5jTN8ScAZ33GxNv+S6DcOCM4XH72Ed85rVKp8P3sj8urz7i8+kz4p/e8furJm2eeeHpojv8uu/fHwkrzOpfZSJz3BTLswMc7lKeff8HWLvZroawwFfH1rVR7AKWX9pT12FCFxn4+FKvtj5cPFM6vx8nt4phTmMndG/RM5cdvsQlNiYU2p22VSoWDtag9XbS4Ff9eihpbqczlxqwJ6pP3uzhfd3cLoXiRqwAsW1GQtu1Fffu/ln9g8kQhHE6bmZcJY1+p31Ojpi2btxXD2FhPWhyElHF5jiRLrqcAuL4tBECB4s/x9VPy8loGzMwUXLsVRuuePqz905KGtbWfc8pCupVpiM4dr6St6fzWK+raPbfZYlyeuzH96jgs7Cz48OgTC1ovw8zGlJnXJwLg7GkhvY/oLs+68MVP7v6gy3gvOhbR5sVuZ8/yauVqKm3agL6JCUGurtwePBSTzJkpu2SRul0BybF9vkxy11ZZl+eEzGeii8e6oE3we//Mg/l99/Lu6WeN52u0KcbA+fUwt9L9t4vtHhroF0KHPHPx8fHBykru+h6pMT1YB7KJjX6BULwXCdpvcpOGtM/kx76cEB3C/APwe/cRhZ6eWkx0v3ZbLSbW3roCfUO5KIbUhkJPDwNzEToe5C4frZPWcCor6iQ9PXpD4/mVbecCkCmPg1pMfHHhsVpMHH1lNopYavOlOx4eE2IiwK9bU7YviUHOCtjO+FstJoY8uKwWE41K14ghJv4kdXDuiEhFyl3UXicxMa3y5cV7XhwRrtAt141PkT4E+wTw7PBlVlb7jcCvP546FfjZk90Ne6vFxNaHViaamJjW+PjERS0mTvh3JKaW/93aP81rC2fnTbsqpHBPkpeJnfcCMGt32inboFAosLa3pFDl3NTuWoGxi2qx7kQbzr7rw/2gwRp/34uJ0fHxFhPHuMTEtEbHAUF4fbtMRoqJ6ZW4xMTUQmYHY27dE2Vufv/tGYcPCoGh/wAn8uQRwSKRYmK16ja8d6nOrj0lMDZOm1PhIoXEueTiKsSoCd/SoFdtEZFshQuIBY+xM+Qj+FILrcaL8mML2ojSOE5FRZRqoHcQAV6JmJmVijC0EALpw6nCBNQ0SxYAgt3dCQ+UD+JJ72QvaM+S8/044DGBWQe7YZVBXIvP7XlIq5wLqG83gzUT/yU0RG4hNtFJ56YsaairKUP1v4TAdGngWPVz3i9ec2eWSH/936r5GFnKr46kRopNEhEx96bPSeGepAwn5+/n8ysRndVvz0gAvjh7sGvQOgD+ODIeQ9P0K2ho4PURjn6rpTjwcKwGJ2mC8t/S0wvVR89MRIr6bZiO/wZxs7bsNQnLLqNSqnc/iYdBbQ4CsPio7g7JaQ1lhJIDfWYC0HrTpBRbtOh7YTn2hXMCsLnFGB7sPpPgbb0+fYPDnUcAkLNuZdqdWIe+UdpeeEsoPu6+zG8p0kIH7exHhmwp62ickgQGhvPgjicADZumP/fy2FCpVNy9KCKsKtbLm8K9SV5uXRWL1HUaZUvhniQeUxaGcOG6iOD5cDN913FLC2JiJE5OJly5Xh6AXj0eM3zoczJnOMfr10JkUyjg3adq7NlXMs0KiZFMHCvMSOb9KYTTX9raADB/uRCdrCzF5/P4knYTEfOWFynrXp+8CfYXkcL9N/QC4M/2f6VYv5KSDOXKAeD/+jURISKbp/AoMZZ6MGFiivUrLVC4Yna2PB3GAY8JjNkYtXC3Z9k1mmaZQ327GexechWlMgXOiZ+C4n8bc0cHTDKIGjCul28Q6P6ZqyOmAFBp7iTMHORT5VIr5jlE5EiQq9t/wpylaLNKALy+8oxHx+9yfZuo6TT2hhCRQ/yD+aulcPTuvLIfNo52KdPR5CYiDFZ/K67fcQmYpu4w63gp902IurAcVWgwX4c0JPSBiASznbodo6IVU7BzP4mLa2feA+CY0waLdOzmtqu9SH8s9ktdbHJkSbF+KBQKWq0aSaP5AwC4smQPK6v9RniIXFrKseGLOTddGMtUnzGE8sN7JXpf0wohgaFMqi4WZ7rMb0+uUv/NCM1Ifml8FoC/NpRN4Z4kL+uXPASgZZ8yKdyT5GdQT3G/nb08fUSkbtkTxprtIirs1WXzdJ21kpbExEjy5DXj3CVxfdmySdT7q1jJGueP1XD7UgMTk6QvN5UcVK8qhOydu0WYrIFBzOMwS2Yxzff2TbracEnNrytEUMCyLmsAKFBZLMh8efeVYH+58jlphQIDfwfg8QwxdrArXRqAwI+fCP+uluJ/gY65ZtCz8Fyp91RsVJATnuM4/nUsgxY2VD+/dvIZGmacSX27GZze9fA/oXckBz8FRR2otkyc0PfmLuN8n2EAlBo9EJsC8bvZpTWyN2sMwIfDx1K4J0lPpd7is55aeJB9Y0Sh9MEnJ6NvaIBKqWRuNRGVWmdIM3JViN0wIt0x/5sJS8VO4FQyRbuSKBh/iyAO+IrnKJHGrpfREbuFR9Gz/O9GCqUF+jYWKYIrznZL4Z4kHS+OXibwi5gQlO/XOoV7I8heoQi/nl6M4pvJxto6g3l39VG87wv1D2JdjX643BK1nZrvXoxD2aJJ2tfUjFKpZFSpSQDUH1CLMk1LpmyHUpiQkAiuXhTRaq3by5vRpGWmj7gGwIBZdVK4J8nP6xeidle27Gk/m+fc1XDGzBYixoPT5pgY/xQTUyOFCllw7lJZWrex5+2Hahw4XApT0/QhJMZFhdKidvmbb+YsE4YJ0XHZ2rQrQhWtLYyXPj5xITRYCPk9lopAgRU91qZYv5KSTFVECSbf589RhooF3YLDRH3/h5Onpli/Uoqw4HD8vKKO4a2zzrJ8mG6GQgqFgkbdS3PCcxxHPcbQdUx19Wvz+h+kQYaZNHGYza1/Xyd6vzX4GaH4EwMzU7JUi4piKtirIw6V0ufqeu5O7QF4tUnSgCMNYp5RFML+/NqNPruGM/TfqVhmEtF4syqNBiD//4pQqWuNlOpi8nPw243KzBb+1zdl+5KYGEbVNzJr2gvbcevSdVRBeuDuFRcA7OzNsLZLn/Wpgrz9uDhXLGZ0ObooZTvzHQbGhvQ9v5wqg0TayLGRKzjQd1asq7mud5+zpckQADIVzkXPs39hbJX2BYQfYWihcYCYEDUcWDeFe5Py9GgrsgAWrkwfkWq68uSecP3N7GSFvsF/a9j98plYLClZLqaDdFrj6asIOv8h0i7P7zHDzib1jSEcMl/BIfMV3r6NXUA6ecKTbl2fEhgYu+lCWhYTIylUyIIVqwpjZpZ+hcS2rcQ85tIVUU9w3BAhIM5eIh43rSfKNP21Me0KigCd57YDYG3/zQCUqCcWKt8/+Eh4SNKaJ6YU+X7rB8DjOfMAyFhepEIHODsTEZy0xmmpnd1/XuLklrvS79M30KPTiGqc8BzHgY8jadZbaDlhoRGMa7uT5vbT+LX0El7ec0nsLqd7l+c01NXkJ9ImXqVS4Xrxmvr5HA21rzDL2srr6sD8I8g6WoZjiL6JSC0M+vw5ntbgmgCXTb+QpK2jJWN1H1kT0c4pI+Z2YvK7a/A6IkLD0TfUp/0i7al6sr917gxyNvblc8f/3UfHIWcCDBTCvjv9n52Dp6JYPr/vk9/e95hLFsANTYLLkUoJq1pA2LdCxkUaYVqrjc5v9w9O2mNV1jUXwD9Yzj37hbucg+T51w5S7e+4yqfEByrjL8zfvbZwgd19vRN2RnKDYY8QOSGrgoO8EVUheznHPDuzmKk521uIuji1p/XDyCz5U7p1Of6KtalJ1wOi9MOX5+9YX7M/Xm81B1tXFu3g6BDhXlt1RBearRiFQqHA0jhpB/qONvIFymXvu1/85X6XE89E0fi5zUSdZatMluqULW0cc5aP1AtVyV0DZN2IE+J4HG8fwpWcOiqOmy6/5pV2YZZFFSp3bCTE2VpX9+ymFcX9dM+ZxlLbz2gmV2rAxEA+rVHWmfO2u5wwOLC3ML77c41upmdKY7n7iX6GXFLtAfRs5Wo5KoxMcP+ipO4v4j7090oT8uSM/dqpCpS7NyiD5Mdvsbn/5ssnzEcqVbxLjuxX8fCIeQxt3OTGiRNe5M51nc6dnhIerrlIlBAxUREgN2ZNCCqbpC0XIevYDEg7QysM5Oqwx+fmPWKIcNdu2+k9WXI9pUU3cSwdORVK867e9BwUNfdYsiaQLbuDOHQyhEvXQ3n8PBy3s3sJCpIbq5e2TXyxJTq5bGNeu8s2F2aKL668IiJMXHc7zBQZHacnrJTeh6OV3P0ho6Xc/UHbeC8u/LXMizP/738A+Dx6hDJMjKUKDB4IwKNpM3guObZ/+Vnu2iozl4aEzWc8AuTOh1DJfcTm2gxgYmbIgDn1OeE5jt2vhlCtWUEAPn/0YXi9dTS3n8awemtxfeMptc//KgrVz+RxtaV3y73LMDQ3VT/v901MONa8KwBmjg4EurhhnS83ledPjrGdkDC5k0/2xEgIsQlfIT6+RASHYJY5U4zXfN44c2XIRMyzOVJ9+ew4t5/DTt49TNaKXpbYBshhwaF4f/pCpjxRheDv7b3Mqdl/U/v3BtToU4dbe65xYOoeAKbenxdrFJuvpND0zktO4LjzTm7Q/upTLDcKZQS4vQZHHVK2p9QS/w7/B8y1DGL0JS8VAZJi3PcCpy7EJkJ6PAMTG9jcKsZLxrNO6bx5CxO5gZbs5MzYUP5ckN1HYUdvqfa18rlKta+QTW77EP9E/Nldd7pU2YKxiQGXPAfjH6b9WHp+xxWlSkWhMprmDvbGctel627ytXDfeskV4nfx0RRQzs/ayKsT18iQPzstVo+N5V0xCfDw4suLd+SoWlJq/9qQPZbOzN6mdqIu2Lw6FX9vx8a6v6tfb7djOpZZMqofJ9biUahfAP5un7HLl1PjeZcELGjFxYsVK/ly7RolZ87ALJsQBu3MNScGbw6c5NGa7ZhksKXaggmYZtSsrdui6AfWj9jHpd13AFj3dmqc0dA1HT9ofV6lUvHo7heKlMyInp7m+2UFRSOF3HXMVF9uMqSvin/7fTpdYt+ud0xbUIZ+gwrGKvgd3PuJytUykjHTj7kBywqWCRFRdRFqAwPCKGK7AYCrAdrNv+5ceI9NRlNyF9Ycj330letTXJOn2JCdBBazlxO/ypnNB+BtaB+N572+BuPrHUqOPJpjF9ljT+H9LtbXgoMjyJH1IgBnLpSlSBExDgt3f6HRLmthIZAUzGfA7k0ZsbPR/E4CvvqQv5qI+Fo02Zg2TeK+rinMtI/HAgKUvP8UQaH8mu+XFZkAFKY2sb727FkQNes+Vz/Ont2IU8cKYGUVdbz+s8+T3we+Vz/u2MGO+XPE4oZj9vsAFC1mwb/ndMvGik3sCw9X8vi+F8VL2/1wVoi0aBkmJxrJioOgXYRUKlWcPeNJteq2GBlpHkuqcLlFAqVP/OKdY35nqW0mJubWxljbmmJpa4JDdhuGL20Yo9617Fz36Wft86ULW66wd/ohSjYsRvdFos774AKi/nSfs0vRM9B9Dv79eCw+PAM070fK8HB8n7/A+/59stSrh3FGzTmbV6Dc/SuzpfZF80+nzvB81ToylCpBiXHCLPRMG5Hu3e3EEgyMdb92FMsiJ5h/Pz5UqVS4vvTg/qknZMpuR9mmJaS2p41sVroJtc3tpwFwwlNkfdS3m6HxODFx/+DDvP4HeXjlfYzXfHx8sLKSE2YjNaaHO8FScsjqFwjFfknYfpMbuVFpOkebtqoMFwNlQytL/vfXXI4174rPyzcEf/XCJEParb92Z8afeD9/TYP9m2Lc5K1z5wQg4KMLKpUq3aSGPth/hTML99FmcT9yVSoEQPFmFTk1+2/+XXacGn3q4PL0EwDjr05PH5/b/TWs6Qc1e0L1znG3LVgVKrfXLiamJVRK+Ltn1OMCDaDuRFhWOeX69BMpulQRacB77veMs12/mhsBOOszJqm7lKh8fubMqxMi6r35Kt37Hh4Sys52on2vc/Kr8j9KtRFdKNKqJvt6TefZgQs8OyBSWI0szOh0YD56+om/SPbl8UvODBULW22PrUGhl3QLcUGurihDQrgzbDgAhUYMw+5/xTTaOFQqw6M12wn+6sWp7qKmUdV547ArlA+AE2svq8XENa8mJ/g+0qHuYa5fcOX0w3bkKWCTwE+UOlAqVezbJYSffoMKxtru6WNffu18g2atsrJ2a/nk6l6SMqSbMKFZurW21tdDgsMZ0HAHELvgmFb57CIWdrLmiCkQlM4iUhe/FxoTk+guvrWq3wJg87ai1C6l2W79Ult6/uHFs5fhFKvsBsC5Q5nIl8eQiAiVWkwc1MswXjExNoJDVOQvJ7b96UnSupsXLGiK64eSXL/hT4vWr3j/PpQCRR5StowZu3fmxcREj9Yt7Wjd0o5VazyYPNWF7Ts82b4jKhJHRkyMi2zG4l7+/GsHrG3khdO0xt5/3OnfR9QQPn6qNKVKJ70I4PIip/r/quCoxdTwcBU+viq8fJS4eSgJDFLh5aPCy1uJl7f4v48qM16eIXh9jfoLDtZ9oTvAJ4QAnxBwhud33ahYPw8NOhVPxE8XRfUuldk7/RD3jj1EuVCJnp4eLcY0Zv+sI5yZuZk6E3sk6v5UKhW+b9/jfvM+n64/xO/FS63twnx9ydcvaUpEZa1bi+er1vH17n2U4eHoGRhQeOBvPFmyghMjl9J48bBE32dYSBgvrr7m8elH3D/9lAAv7cJ8YgiKqZHMTtbMPyyySt48dmdmz318ePn1xzeckJqIaSiP+KegGI3bS7dQaYzmRUHPwIB6f69B31isNlScPZ5ro6dztucgGh7YnBLdTBTsihbC+/lrPpw8R/b6NWO8nqNpPd4dOsm7I6fI2aReCvQw8SncsBxnFu5jz6CVjLgh0tG+X9FqNqE1zSakDmOERMFBuKFxdn38gmL7dFLoN3rRicbzINe3VCun8vDhBkq3t+g5yKdJ/SR5eP3ki/r/Dk6xD8avnxIFlKs1LZDkfUpMlOERHOwnBLI2W6ZICU6b6ot0l/L9U+4aZZcnGz3PrGB/n1l4vvpAya6NKNOzWZLs68n2QzzatB+A8sN7JamYCFBi2hSCXF25O2oMypAQns5bwNN5UKBTS/L/0gyFQoGZfQaaHd6I14s3XBwqrpmXRojVcsdq5XG5KFI8l90fi75ExER07t304PoFESmc1sVEgGH9rwMwekrcE80W9YVAPW5q4STvU3Jx8qAzAE3a5cFNS8LI1N6isPz4VY2SsVfJw9yh/wKwYH3MMWZyoFAocP9aA2fnIOrUuIWfXwRdOwlzqfHDrOjfSwid9Wub8umJKReuhNDhVzFxrNFUMxquQU19RvRPeNRsnlLifP69d/LVla1Q3gLXDyU5ecqHbj3fcut2ILnyPaBRQ2tW/5UTfX0FfXvb0+fXTMyY5cryv0Tpj3z5jBNFTJw6Soi4pqb66V5MdHUJoWSxq+rHg4ZkTxYxMS4MDBRksFOQwU6PvLEMefWL1JDe7lP/mIK4UqkiyD8Uc6sfiyyPjwZ/1OH40tPsmXKQdlNaUKN7VfbPOsKrUzepPb5bgsYIgR5fcb95D/cb9/G4/UCn95hkccCudGnsSpXCunAh6X3KkL9XN16s28TjhUspNnIIDtWr8GTJCtzuvyQ8JAwD44Qtcni7+/Do9BMe/vuE55dfxdve0MSQEnULUaJuYYrUSFvj7oSSu0hm1l7vR4BvCK1yzk/p7ujE8OHDuX79OtmzZ2fDhg0YGYlrb3h4OL/++iuvX7+mdOnSLF4sdJBHjx4xbNgwgoOD6dixI337Jkwc/ykoRuPDuRuUH9YTfSPNkzNSTASwLRSVOur19IXG47RE3l9a8OafwzxesUGroFiw+y+8O3SSp2u2phtB0dTaHOssdvi4evL22jNyVRSREjnL5sb51hs+v/UgUy751MdUTWRVV5USAn3ATK7mRponV7S6TZV/g103iDi+Dr3u01OuTz+Jk1/KbgRg70Pt9UsjGdtuNwDDljRI6i6piYxi/5Ho5R2tRRRSic4NsHbKrPP7bqwSjtdGFmYUa5+yBh8KPT1ark38VJNIVCoVJ/pMxPe9SPdqsGY6VtmzJNn+omOaJQuVN28kPDCQJ3Pm4vvsOc+37eP5tn04VCxNmZH90DcywjZ/bpod3kiwpzeXRs4g0O2zWkycfWEIZtam8exJOyqVipZV9gNw4fkvifWxUgyVSsXWdUL8HzauWKztIiJUeHkKxS1X7vRh5rNrwzMAWnbKF2ubM3tFamrjzrF/N2mVcwdFRE+FaprnrtdXkeZWolzMkjtJQc6cprxyroafbzgd2j/g5g1fpi8Qf22amzJ/qg2GhgqqVzbm0xNHXr0Np05zD8K+ZfI72CtYOy9h5zNAnZZCqCtcwIAxQ5JfZKpX1xrXDyXZ9fdXBg/7wNFjPmTLeZ8e3TIyY5oo7RApJmbMaMCFMz8ukNy79YUV8x8D8NK74w9vL7WiUqno1vkRJ44LIdrGxoA79ytibvHfml7r6SmSXEwEqD+gFseXnubKzuu0ndwchUJB6W4NubPpGJcX76bqkPZa3xfiF8iH6094d+Uh764+ItQ//rrcRlaWZC5XnMzlSmJQoDQGZiljDpitYT1erNvE5xu3UEZEoKevT8H+vXn21xpOjVtBw/mDYn2vSqnk81Nn3l26z8Grt/ns/CXWtpFkzmNPsTqFKVWvINmLZUUviRdy/yskxGRFtv3du3dxc3Pj4sWLzJgxgz179tCxo7j+Hjp0iGzZsrFx40Z69+7NlStXqFy5MmPGjGH37t0/nFL937ri6cCZIbOou3xinG1qbljC2R4DuTZ6epqNUtQ3ilot1JbWrGcQdWgEuLpjnkX3iW9qpsvm4SyrO5Y9A/9SRyk2GNaUlR0Wc2rxUTou6p6yHUwKOs+FLcPhwBzoMDOle5M85KkBr8/Bl5eQ8dtkLpMQ/5XPr6dYt34SNx9eR9V4ccoTe+q9SqVCqRTiXnI6QPfKFXVvqD+iBeV+qSq1Iv7s0EWCfURKUtlfW+j8Ps/XH3m44yQAnfbP0/l9aZGwwCD2tYyqy9j60MoYi3zJgYGZGcWnTMbWNIjH63by5sBJ3K7d4UirPphktKPa/AmYZrTFxM6GqnPHcbLrYAAGrOyAfXa7uDceBx3qioi1zn0L45QrddfM0YWJw0X69x/D4446nDXlCQDjpxVJ8j4lF6P7iojLWSura319zyrx3TTukv7ERD9vIRqamMaM0t23TQiNv/RK2sie77G0MuDwsdKEuDxnzFQftu0OZM+BIPYcCKJIQQN2rc+IrY0eeXMZULemCUdPic9w66hcvdzozFroy9PnQpk8tS9lF6zbt8tA+3YZWP6XO9NnurJh0xc2bIoSGIoWMeXU8R+PPAoOjqBBhSMAXHjUHIN06mx+aP8nenW8EfX4aCnKV/iPLdonMwqFgupdK3Nh8xWOLjpJ4yH1KderCXc2HePR3vPkqFyMd1cf8e7KQ/xc409TVejpkbl8CTKXLYF92eIxaiJH8n0NxeQmb7fOvNq0lSeLV1B06B841q7Bs7/W4HLrKRFh4USEhvHx+mOcL97j/aV7RITFX9e4YLX8FKtTmKK1CmFtH3OsIVtj+yfxoEA+hfmbNOPrq2n0ZWxsjLFxzGPy6tWr1KsngsAaNGjAhg0b1ILi1atXadKkifq1K1eu4ODgQFhYGJ07dyYkJITFixdTsGDsZWni4qeg+B1er94R7O2LiU3sA3kTOxus8+XG5+Ub3h09TY5G2l2fUzu5WzXmzd4jfDx1Dqd6mlGKblduqv9/fcx0am1cmtzdSxJMrc2xcrDF180L5xvPyVm+AFmLiELUT888SuHeJRG5S4t/X1yLu116onRnISje3gr1p8R4OT3VBk1PtCq2DoCdt7rH2e7AWjER/2VQxaTukga9F7VhzWBh2nRi3n5OzNsPQJ0hTanQ6X9x1hAM8vTl8oJtAHQ9tljnfSrDI9jXS0TUtlw/QarweFrD6+U7Tv0u0ojtSxakxpwRKdwjMeEo2rsjRXt35P2/l7j351qCv3hyqvsQACrNGMnVcXMBKDW0N2UaZE/wvqKnOk9bGr+zampHpVKxcrGI0pswq2ScbZfMF0YZfwyNPZovLfHmhTcAVjZGGBtrP2cXDBUGYaOX1k+ubiUbyyYIM5Q/N9aK8drOdeKYaNouT7L2KRJ9fQVzp9gwd4oN67b4M3GWL4+fhVO0shsGBtCsoalaTHz/MAuE+MWzRe2cOhfMsrViAen13eSJsNaFAf0z81s/eyZPdWH1WpHanVhiIkBO860AjJ9dhvyFbBJlm6kJd7dgiuU+pn7c77dsTJmWN9n2HxioJDRMhY111HXlvzSmbTm2CRc2X+HUynOcWnlO47Ujw5dpfU+WEnnJXqkoOSoXwzanA66+CV8kSAmyN23Iq01b8bhyjXe5c/L5xm31a9GN8b7H1NaKHFVLkKNqSeo2ssfA6KfskxZxcnLSeDxp0iQmT54co523tzeOjqIkgbW1NZ6enhqvRUYhRr7m7u7O48ePefz4Me/fv2fo0KEcPXo0QX1Mn8tGCaTqNBE2fLizmMTE5pAMUHHWeACerNqsToOTdWw1Sgb13y8ON+K8HVoC8Gj5Bo3nHy5dx905UQJiiJePVsMagHee8qlJslb0ssTnWth1s/h9d/++AtB0bNbV9NwqjmNDGzls5VxnS+eQKwCbN6tv3A2yfosEcHkRd7u4iJAcrJjLfUcYJuB8MIrlPZm/RcO8/M7RuWQHAJQPL+i0ef9guZuvrGOmrDN8QvbxxMVGqv2Zl3ITn+sfdd/+n8NPU912PiM7HeLo9sd4f41KO3H7GHUM5ymcUeN9Foaax9Li4SJar+d47ZE/HiFy16UKDh46tavUogTrnaex+sUkmg+OWoQ5/echZpQdzrRSQ7m07jQRYTHvBdtbCYe+ujN/w9BU99Xurc1F0e3iHetjlzurzu/TBdljSXbF2tJY92vAi32n1GJiqQGddBITHW3kXDwTQvTIhOy1q9Ls8EaqLYiKVI0UE/O1bYJTrSrsf+QUYxtxcdZFtJdJdZZ1bZZ1hQ6K0P34rFxwH8Wy72XEgBucPvZJo6D/3CkPAejRP1+MyW50F+Ynj4RzcPacZok2KY7NRTo2TBS6uU1GJy63+tbVDwCw90IL9XMOhlER2E/vCOHYIbsVBoba7wO6OmBGYmIgfw+VPacfeugWgbV3nXAK1la4/+VT8T2YW8Qcn8ocexC7u3BcGGSOKlXUq4sFn544sn2NiEwKD4e9h8R96eUtB/T1FbG6Nsfap0Bf3n0Ip/tvYjJ3/ZQ9JsaxH9eyzr8AqiBv6fdER6FQMGVSVj69K8HRg/liiInKQLntR7ptj/5dLFxnyGTC7yOK/lAfv0dlrj1FXqlUMXroI/x8v7vfGMplL2hzbNZ4XaWid5cbajHRxESP125NpMREWUdvPeuY9QrzlnxP4XIf1I+Hjf1C1gLvCA9XoTCRG/tEPD4i1R6gkEX8ztPRkZ3rFsoU93xJoVBQtZP2xeQSv9Sm+fKh9Dm7lH4XV6j/mi8bSqlO9bDLlQWFQoGjtdz9wc5czn3e1kyuvbtf/CUVcncS6dyvt+7E9zuDmEyFclK2dwtab5pEr3Mr1X8d982lyrBOZKtQhKdf5UpMyI4PE8JHX5P4G0UjODwNy1Z6CfwDPnz4gI+Pj/pvzBjtZo62trbqaEZvb2/s7OzifM3GxoayZctiZWVF0aJF+fIl/pT42PgpVUcjUxGxMq4MC8fH+RN6DjljbauIFiVyc/I8yk8ZKS0OhCbgZJW9MFvEIXwZmkb9/AZ6EaBUcaRNH5TfQqWbbl/Akx2HeX3oLB7/niZvkxoxtuFoJT+hi0uo1Uaw5PdqEo+wa5LJBCsHG3zdvHG5/ZRi1XNTrXt1Lm68wNNTdynRsGS8+wgINYh3P9F589VSauD+2MUWCxPdJ41PP1ljbBJ7f1SdxxM6pxPsGIPxuL8BMJA8lkwkBb+vfkZyomKEAuTuLRBsEL8QaR7te2zQDu7tIPzoasILxV8o3twknOAwufNUpr2JoTJBoo7Mtaawozf+cSwsfE+zYu+l+lPCwVfnm/zBzQ8IC43g7L7nnN33XGubLZe7xHjOPyyq/6EhUb+noZH278HeWE7Av/M5o9T5aWiqR/FuTSnerSkRYRFc3XyWs8vEqt7ZZUfV/6/etx5Ve9XhwETh4pqpcC6yV9bdAfHhzpOEBQhRoVyflnH3KQELVCYGcotgweH6UvvxCzHUqf3JwXP4/EgUBW+4cgJ2ebMD8b/PM8BY+n4ii7aJR6YyjuQ/t5LArz4cG7YIx9IFqTSgCRBMgwKuUtuvmPEjAG1qi4ldl74FyZXbHIj9twlUyokusgKkqb5ukyGVSsWbl2KAunHVSzau0u6COXtxuZjvjSb4tWwgotl2H64So11CiS5Y6kKwSvbmA+Eq7defkJAIvD3Fd5inoI36ebewqDIOPauJcjmrTneKdfvJMdnyDZGbBpTO4hvr544kJDjqeLPSD4xV0Nb2vJleCGFK3ftkHOYJprGXx9BG+Me7MYSdGv8zwuWFFS9fhTJiwldWL8mEuZXohyrYH4WR7r9FULghleuL68C21XZkyxr355EVmQAUhqYQLidaaEMPKFXMIMa2FGa2ckJnxnxcv+TOxr/Eff3Bp7bxvkXmd4Zvv7VBzGvf+zf+bFj7ng1r33P7WX2csotzXxUeIiUqKrRsO5ITR1zp0jYqy2ff8apUqZ4pXhHye2SFWm3Csa2NHl7eSnz9lFhZ6uGUTXyPO/f407GR3DFhXLI5qOTuD69CskktXgSH60nNXa9/jP98bjK2FY3HtEShUOCcgMAWFx+5+4OrZHuvALlzOl/meIJCgALtGmNkrIexjTWZypQgb/bYAmC0f9cF7X2k+mRlLHdcJISskotm3/cpOQKzAMISYT8/UkPRyspKpxqHFStWZMGCBXTt2pUTJ05QpUoVjddOnjxJ9erVOXHiBD179iRfvnx8/vwZLy8vli9fzsuXL8mQIQMBAQFky5aNGjVq0LdvX8qVizmG+540LPUmDQ3XixpzJ/rGXUfxeItu6v9/vfeI8MD4C7ymRvK2Fs6Cr/ef4FDznijDwlHo6dHm6BpMM9hQsq+IlLizdEtKdjPR6b1DRP1s678SgJp9RFrOkXnyq3VpAYXNt9o9/l46R2GmeRy+rbgHRIV8Exlp4KNbRNpPEpdjLsM56zOGvQ97MWRODcpUjxnNVbBU3PVa1049D8DQRclnxhIX+ob6VO1Vhwl3FzLu5jzqDGmqfu3CqpPMLD+Sx8fvAtB0+Uidt+v76TM3Vgojlm4n0kfJie8JDwllW53eajGx3aGl38TEtIFZBmtab5xEpYHaC8Hryt3rHly/6AbAzGWJJ6olNQqFAreIbriHduT45foMHl2EQkU1I9jyFrBCTy/26Kz0aMYy7jchkMZWO9HHM2q8aJ817dfJ/J5N84Tb7YjFMQ39fL2F4FGoRMYYr6UG8uU1Yv+OLNhnSli8hUqlIm9pISYOG2BJjaryQnVaJCAgjOb/Ow7AtRct0Y+j/Edi8OaVP74+UdeNcVNEVkqZgie4dcMzrrdK8fVLCPZm+9RiYvfeufAIbEmV6sljKKSNqeNE1NGyVUIg6tNDXEMmzUq8z50W+K+keEcnV/OGOP6vMoYWaStl+yfJQ6lSpXBwcKBatWo8efKE1q1bq12bmzZtyocPH6hWrRqmpqZUqlQJAwMD6tatS7Zs2fjrr7+YPXs2jx8/xt3dnSNHjlClShXGjBlD69at4933zwjF77DMmhkjS3NC/QL4fOcBmUrHjCY53ak/AMa2NhTq3Zl7c5dx8fcxVF6V9iZ9BTq14NU/R3mybicAOetWpvxw4a6qjFDyT5Mo+/Cgr16YZpBbCU6tmNmYY2lvjZ+HD6+uvSJvRZGy4Osut4KTltCr1Bzl1QMob59Av2zqEGOSlAqd4MBEuLUH/tcn5utB/mCaPiawqYHfam/i6S2RCpMpqyWVGuSlcsN8lKqWAyMTzVuNUx5bOv5Rlo5/lAWgfs4VeHoEsuZ0/K62u5eJIuhNupdM3A+QCOgZ6FOpa00qda2JMkLJrV2X1HUW226bpvMAWKVSsbvTBAAaLxmOgXHym5IkNT7vXDjcaxIAtnmz02jlhBTuUcqgUqloVvUQAJdftEvh3mjioL9J/f+iJe2o19SJ+k2dKF7aTuNY1tNTUKZCRspUyMi46SUByGQg6oVeetA4zn2kRzOWf7aI0iK/9NRe3HxYK+FQv+hA6vq9ZahkPifeNi16lgQ0o8UP7RDfTbtecZv0pFX+19wbgFLFDRk6wDJlO5OM5LHaDsD0xeXJmSfpRfKKxUU5myNnq1OuQgYGjShAnnwW9Ox4g0Y1zrNqUzlatEy46KdSqRjY9w67tkZlbLz41BgbW/lo0sSmZVNz/hjxhWWrfRg73BYzUyHeBgX9R4IFfvKTtEi0FGap90gyf/58jcerVq0CwMDAgE2bNsVo37ZtW0aOHImpqWbavbW1NQUKFKBHjx5cvx6/menPCEUtREYp3poyP8ZrFweOJcw/AIBaG5eQpUp5AIK/ehLknvainqK7PVeZN04tJgZ99WJPo94abS9NSnuCaVz02SmiFNf2Ws3oIlGRQ4E+SV+XKyUwaChEtfB/FqRwT5KJ/NXEv9fExBZlOCztGfX6ubTp0J5aKVc7l/r/nz/5cXDdXUa3+Zv6medR03qW+m9ggy1s+fMGzi/EarqPZxCeHuKcK1k5W5z78P4i2hka6af61Wk9fT3Kd6zOhLsLmXB3IVZZdZ/c/NNNGAnla1AJh+LJV+w9uXh97JJaTCzZq9V/VkwEaFtbpMd36VuQ7LlSlwBRsKiN+v+P7nmycNp96pc/TBaDzTjob8JBfxOOhpvp1vo82ze+5rOHSF/asFKIRo2aZ4s3Uik1mrGEhSmZPf4Wy+bc59zJj3z9rHsGypE9bwCo00R7bT+lUsXjmyKCrUKdXFrbpAVGLqmPbSYzrDOYYmljjJmlEcamBuhHc/TVFpm6a50QkJv+knp+78Ri6vwAXjuLUgWHd6ZcBFty88cfotRBjtwW/Pp78jh3b9xZAYDGNS/wzy5RT7BJi6yculQDgL7dbjJ3RsJqhp855U5m8/1qMXHXwcp4BLZMFWIiaD+vihYWffvk9tOZ9yfpl31rbqNUplHh/AdqKCYlhQsXjiEmfk+FChXi3c7PCEUtGFtZkKlYfj4/fKHh4nxz8jz834l6Rw32C5U3UlwECPXxxTSzffJ3+AfJ06oBr/cex/+DCxTPjdutR1wY9ycAuRv9j7KDuvJ3/V54vXyXwj1NXMxsLTAwNiA8RLMmw7k1Z2k0PO6oirSIwjBqMKQKCwH99Bf1pIFeZJ0nFTw7J6IVo3P1H2j4W3L3Kt3SY2x1eowVKX4REUqe3nLh6rFXXD72knfPogr9Prz6kYdXP7JknKYxzrLD8ddcmveHEF9m7oq/bVrlxbEr+LwX6a/VR3eLp3Xa49yEZXy6Kgwb6i0ZTabCKeP0mhp4eedjqk51Pne/ufr/AQFhXDztysnDHzl5+ANfvomHSqWKowc+cvTAxxjvX7uzWpzbTwozlsTg7nUPls+5H2+7zI5mFC2VkWKlM1GkVEaKlc7I7x1PA7B4S0x3Y4CVk8V1r9fY1Pd7y9CyV0la9ioZ4/ndK2+zcNhpfh2v3aX8+UNhOGdpLVcHNLVz7N8QVm0WwvPbe6nH0TmpuXjBm91/C6foay9aJdt+GzVz5N8rNald+Sz9e9zi5TM/Rk8qTInSttx/2YAS+Y6zYM4rHj/yY9OOMjpt09srlPxZo8oedeyagz//KpWqrk2RNKxrxrFTgdy5H0LpEsZMGWtH685uzF4eytJp/400+5/8d8iWLwMfX35lyfCTLPlmyggQEhSGsWk6n8smE1++fOHw4cM8ePCAwMBAdQ3FqlW138u/R6H6zxRUix1fX1+sra1puXcZhuZCpY0IC1en+zbYvwllaCgn24mIvQZ7N6LQ1yMiJET9XP4ubcnTpmmaM2YBiAgJ5UhrEb2Wp1VDXu8VDmaVJw4gW5XSAFybvZr3Z69TblgPctXTPLjSojGL65MPrO30p8ZzMx/OZmyx0QDMfjw33n0EhMrp8W++ykWfPHaRSy9/+il+98WIO6cI3z0XvQpNMWwxMHmMWWSQdZIGYcwSG4ubQHC0YsfVfoW6HWBibfF46r/xbt5cwhwnIch+pyBvwFHY0VuqfUKMWXTF1zOIG/++4eaJF1w48orgwHAyZbHg6Ot+cb7PP8yQmtazADjro93hLDoJMWaR5cUXuXM6vkLggV992NF6FABdjvyJkXn8zn/RSS5jFhn8QsRgLyIsnJ0N+6ufb7NvEcaWP14HKLoLc1Ih6wipizGLSqWinaNwtb78op10dGJqMWYBePfGj1OH3nHi0EcunnUH4PdhhZg0p3Sc78tv/zdenmFcf1Q3Seon/ogxi5tLAPdufubhna88uvuFh3e+8tld90jFt6FaymwAuYxWA3DFf6ROQkVqNWaJjchU6Atew9WmWXYGfurXCxivAOB5SOyLeWZ6ksYSYfK148I/3pVqrwqO/X7y2jmC6s2EOcetU7ZkyawPkkYrCTZmSUIUZnGPQf38wsmXV5QguXW7DNlKyrs6J8iYJRpuLkEUzytqN9ZtkJlteysDEBAQTq5MopSEfWZjHryoFef5NmLwQzavj3JOfvq+ERky6naNTQljljfOYVSt94lypY05sFMI2I75nQH4eCvqWqpUquKsYQvfjFkkeRUSdzbJ98hel+IyZgkJCMHYXPO3+a8Ys3xPDju5cW5aNmYJDQnn70VX2DLnYozX6v5SlN9m1MYmo9xvpCsBviE0cVqIj4+PTuYo0YnUmB4fA9khr18AFGlIgvarK56enkycOJFjx45RrVo1ChYsiKmpKW5ubly5cgUvLy9mzJhB06ZN49zOzwjFWNA3NCB7w9q8P/YvT9dsoXCfrpSdOIwMJYqg0NdDGR6uFhNzNq2fIDERkt6hKKOlDieqYVS/I8XE5ltnYeGQEVDy8dp93p8V+fMm5sYak9aEiIlWCXDlTKzvSalUsqbzUj4+EgOHIvWK8/7OG/y++PPp7mt1u/gm2V8D5SZzLj5mUhP3B5/spMSBD1/NsTXXwZGv2v9w2z0X5fVDOHTvHX/7aMiKFV4BxmSw1N0lUNZNGSAgwBBiE/x8PDTFxFEHwcRCmKfmLAnO98D9A2SM3QTC2CSC8ASI/roi4+QdHRln6EKO3lILF21KOkv1pVAmf6ntm1ib06Jjflp0zK/ze/zDDHn/QkS25CiQId72ySEmOnuZS12XPvmYxXsORYqJDef0x9zKGF2cjiORFQZB/pwOi9CT2o9fiCEmBhH4fvqsrglpkdmOdjtnfJvcaW5Ltj+egfIuz7L7yGQu50JYM49upU/GNhdZDt36FSBPHlNA92uBT7jcqFRWTDRQREhN9HPnMqXvwIL0Hai9ZqA2woMCktSM5Uddnh0czWnQ3JwGzXPG+p5wlT4eroE8uvuFR3c+8/DOF9699mXz0UZa2x84LCK1S1XJhqFe/Mehs4/c75xYYqKnizcTqs+T3lZ0IvQMiQgHO6MggpViYu3vK4TCvEUyqJ/7HhO9UCmx3NogAKWx3ERL5XIfhamNzu2Vfh6xCoSBgUqqNxO/698bMpAlq/wCR3KIiaowOeNIhamNhhO7NvLlvQfAgnlO5ChRUNotOEJhgKGe7u/RC4kpuDg4muL8pSk5Mx7i1HF3CmU/wpN3jTA3N8DVuyFZbI7h4R6Cg/UxPn5tgKGh5jly6cJXWjeJqg+27Z9K1G3ooHOfklpMVPppv5/k+qbn3bwTEsONWxkWgkKh4OQFJb1GhnNiiwGF82m/NhgVroMyUO4zuBnmlxL9Q1UGWMQT5BGd46+ivv/X116iUirJW1mYLG7uv4aXl58z5sIUzGzE9fGTpNAH8mLie0nB0j+uQActRF/0V0ZEEOLli2lGIap+On+N2/NWUmf9Aszso8a/uTP4fb+ZOMmXSU6wTA4x0V6Xees3jIwN+G1iZX6bWBmlUsXhLQ+Y9ZtYTDi18xGndj4CoMz/cjBqaX2c8iSe50OEhKt5bAiXZ7mgGYVe0sf8HT9+nJo1a7J06VKtiy4fPnxg1qxZ8QqKP2soxkHhvl0BeHfkNMrwcDKVKYGegQEqpZITrUUttizVK1Lo104p2c0fJtQvQOPxL8f++iYmwq3lOzk/fhkA/5v+O9mr65Y6kBp5eekZk0qOVIuJgw+P5pf5XRl1aBAAy7uuScnuJRt61uKGFPbFLYV7ksSoot0AbByEmAhwYYsQEwG84o8k+knqYHK3fQBM2ZJ8aVXJyaFBiwFwqlCYHJWLpUgfNnSYzbzyg/gYbXHlR3lz5pZaTCzRqQHtd81MlSlkycnzWx95fFVEAc9ZXjGFe5MypBczFvssZtRqlJ2B48uwZm99Tt5vi0NW7ULg4FbCtX3hnpbJ2UVpLDOYk7OEE6aWJhibG2FoYoiBoT56Ojr3zvlHu9nM8d2ipl2rHvKRbKkRlUpFvrJiHDVmiCVVKqSvNO64+LXvWwCKFDah4y/xL/IlJWZmBrj5twDg65dQMpvvJyxMiZ6eAnffRhQuKqK/s2U4jreXWMTw9QkjW4ZjajGxZZssuAe0kBITUwshoUJ06NVZXHeOnxOP8+QQ99lJC+UXG1MLG/usYlO/NYQGCeGpSrf/AbC8zcKU7FaScm7AOE51H0Kor1gYN88qjsnTPYelZLdSFXp6Cpp1K8HVgFFcDRjFwr1tsM0kROLb59/RrvhqKpnPoX3JNTy8/imFe5u66dixI61bt451XO7k5MSKFSvi3c7PCMU4UCgUFO7TlSerN3Nz0jwqzBiDSqXieMvuANgVLUTJYWm7BtvXZ2/4d9AMjef0DQ1QqVT803ooId8uaC22z8Hc3i4luvjDhIWEMa/ONIK+ma1U61mTeoOjaiS+vums0X7SuVHJ2b1kx7bvJL7OHciXNXPJMib93pSxcYBJZ2BKLfB2E3+LO0a93nYy5Iu/0OxPUgdvn4g6TTkKyEcTpnacLz3g053nADSe/3uK9aNk6yqcnruHHX2XkKVIDjqtG4xCT1NEcHnwhgPDV9Jl61gs7G3i3N75mRt4dVJM2BouGIxjGd0j2NIrKpWKkY02ALD65u+AXJRBeiE1mrEkJR+do35ni1ReP9DQ2JAR/2gvQVE4k1z0d3T2rhcRJE06JI9xR1JToY6IHqtU3ojfe6cuQ6Wk5PS/Phw5KlInTx0vkMK9EejpKfAIbEntSmd4eN+HrNYHeP6uLja2hpy9Uo3BAx6wY8tHCuQ4RaOm/2fvLKPiSNoo/ODuhCQQgbi7u7t7Nptk4+7u7rZx9924u22UuAtxTwgW3GGY+X5UGJgwwDTBv9xz5sB0V3dXT3dXV91633uzcuq4h3Lbp2/rYmdnkOEmuqaPN2f6/AC27Qqm31+mDB9oxuZ/gpn+t4zGtfWVhOKthxlX2az9gi7sH/cvW3quof/u4eStJDJbAjz9CfIOxNQm8z13xfr9ya0pi7k0eDINd/yNZT5H5bqgr26Y5vj/0WjVFJUb5uXUxyEAvHrkwdyBp3n92IPPb3zoW+cfAAyN9Zi6sSm1WhZIm2ddWxskRiiirUBKptKv4MqVK2qX16xZU6Ptf0coJoLcTYUhi8+zF0QGBXO2nXBBNrbPSsU5iet4pWe8OnBWSSaWHdZNuTzMP5Bd9fsqycTOZ9dlWDLx/uE7zCw/QUkmjr88XUkmhoeEM630WLYO/VdlG6vslqldzVSFXg5hghDx+W0a1ySVEU0m2uWBKeehSI20rc9vaIz7lz8CULlR5nM8Dg8M4cyEdQB0Ozo/TetSul11+h2fDoCbyycWVxrB18fvVcr4ffEiPDCUTS2n4LzmmNr9yGVR/F15iJJM/OPwwt9k4g9MbCnc5Rv/VZasuZMvJScj4flTkWKX3sxYUhJtax4F4J+b3RIpmXnh8kCQOBbWGd80YtJsP1zdROTXgW2Zb5IrPvj6yuj6l4hOfHSvaLp7fv+7WYeuPRwBKJj7PO/figysv1eXoFlLEekVTSZu/bcMHgFNsLNL3wR/fOjeSUQkzlwoUlmtLcWQ/ptH3LIRkRmTVCzRuDQAri5fCQsS8iO9topAnuUtEte6z4iwKy0iuMN9/AjzFu/K2mvnAnCxf8bmHVIDBUtlZfuNv7gZPI7DLwdQrYkYN4SFRDKxyxGqmC6ksskC9q6+R1RUKrqia+sk7ZNKGDNmjPIzZMgQGjRowPDhwzXe/jehqAHKTRsNwIU/B6KQydDW16fm2l/Tl0lr3Fu+g8cb9wHQcP0M8japSYE2DQA42HYkALlqlKXLhY1o66TeDZ2cOLXgKEemiXNsPqkNs54sxsRapL3e/OcasytNQv6jMZl7dyqm1uLl/O7uh7SpcCrCoLhIswt9Lk2YPMPB9aXq916rYcCmVG2kf+PXMbHjfgDGrFKvTZaRsbWJeL/UmdwdY+uUEV2WAvOsVoy5s5wyHQXhvrvPcv7puQyFXLSVRZpWpO3qoQDc23mevysPIcgrRug70NOXFdWHA6BnbEjPi2swskr780oPeHXvK89viVTn/gsz372sKVrVFU7I+09kbKdjTREeHoWnm5jULFjSLo1r8xu/iqOnQ9m2S1zPj4//v6KFipQQUaarV+Qma9b06a66ZHVp5iwuAUDlMlc4d9qDfDnOceKoSE+3sdHH3b8xTZpnvPTm2NDXj0vmZv/RvPj6CwJx0hDR1915KBWJk2TGH8v/AmB9lxUAOJbNA0BYYCj+7n5pVKuURbVFkwG40HsMAGY57ZXr/N99SpM6ZURky2nOov1tuRk8jnOuw2jdu5Ry3d9j/6Oa+SIqmyxg5cRLhAZrrueYGXHnzh3l58mTJ9y7d49KlTSX5PlNKGqALGXEi4kfhtgN9mV8rb0QD2Fw0OboGiwchbqvrnHMrHHlsT2oPjVh19X0jgLVC5GzZG6m3J5LhY7C+S3wewBTSozm1EIRLdB2Tmf+fjUPY3Mjxp0YDsDKPzekVZVTDRZ/DAfAc+W0tK1ISkEeBev6wKZYkgS5S0KOzJFq9f8EhUJBRJgQh7bK8uuuwOkJ/80Uqa82eR0o0DB9pd/XHdWWvkdF++D27COLK43g21Mx2ZKzTH6GOi/HNp/o5G5qMZnra4/x3vkZm1tOBaBEm+p0O/V3nJTp/1eopDrfG5LGtUk7REXJ8fURHfeUMGNJjxjXV6QSTV7TMI1rknYICRbadbnzZ+yo3NdvIxk4SkQNPbiSFT299BWhl5Lo1EVo65Yvb0Kb1un7OvYZmJddB8oB0LXjfQIDRB/i8as6PP9QL91FViYVFcsKQ593H8X5TR8ulMyWbxHRsz3ai/fvjL8zro5i4doiYu/7B09CfmSb9dslJjWXNZmXZvVKSVgXFlF18kgZwe5CWqHelsUAXBmWScdtauD20ZeG1nN490xN2K1EmFkaMnZ5Q24Gj+Oq72j6TauuXLdr+R3q2C2jsskCpnY/ho9HcAJ7SiK0khCdqJV2wS/Fixfn+vXrGpf/3dNPANHukQ8XrlJZHt+LyECCi1Vq4Xug+tSSGnNH0OHsZnQNRaj/uQHTef5PTPqaU/3KGu3/W4B0d62AsNSZ1cxXpSB9dw5B30i8cE8vOsbCOjMBMLezYNq9+ZRqXpbAcFEfMxtTTKx+RCneSzhK0cZYc4czAHsLaW7YJRx8JJXPaSOt8dM2idEdUcg1u2+lOAsDWJlI+40M9aTPoJqYqHF4fXENZtUHjx/GEtEp7Z8eS95/eFjKNuZSneCSghffLCWVP/DIUdr+vaSTAj5hmqcYHdsuIiLaDiin8Tae4dLqVCbLd0nlARytpD1zDj+1Ad8evubN+bsAtNs6UfLxf0aYTPq9mtgzbZHdmjF3llO6veh47eu7lL19l6JQKNDW0ebPnRNou0qQY3d3nOfYmPUAtFjYlzpjOmBmIM2BWWobYy2xHU7KMbyCpaVnXnqnPgJNmercoxxZc1kql9/2jt9lPj5Y6Eq79yIU0toZmULavfSzQ3JCmDtFtMNT5paSdAypSMyh9mcYaklz8wbhhq0Jju4W8iK9eueWtH9HC2nX2TAJTpRSnTyfS2zvfSKEG/G5g0Izs23PhA1Z4nN/jg9SHc8BtOxLSiqvbSae6aBgObVbCC3fQztsyJolefoHP7v0arSNBNfm+w9DmTLXn6Agze8PRaifyvcTp/y4clXogB49GFd6RObmovG+o6Ej0RVaqpt3vSY5uXxLvLvWbSmFR0ATsmWPv61SyKS/T7SMpBGr2saW0sqbJRzRPG2c+E1qNPGkWScv/j0h7snNe+XMWiFj7T/imisUcPaqnJv35Tx7JeeTqwJffwUhT85Lqg9AtsjXksrra0m7zo3yxTWM7La2DwBrOgjd9xzFxHszShaFceAXSfsH6WOyXNbStGNNDSW2q2r66TVXiPHqf73HAmBsZ4uOkbh/vV1e895bmn7kGy9pz09AeMqPTzyDE27vv74VY+Hrx0W2mXegFpVNFnB+//NfOq6evg5/ja3CzeBx3Agay+T1MRkj5w+8oGmeVVQ2WcCABv/y8ZX3Lx0rGlraOkn6pBa2b9+u/GzZsoXBgwejr6/5+1hLoVBkTGGFZERAQAAWFhY03rcWPWMj5fLIKG2eb9jBp5MiPQdtbZDLqTh3ItZF4+pBhUem/IWXSlpax0PqBHl4ExkUgql9FvY1j4mWKNymFi8OXab6uG4UaFwl0f1LbZQBTPSlNbRSB4B6OqqdJq8Pnixptlj5vdemPuSvHCMEH3vQG/A9iAmVxIzX6reqZjWx4RMiTXPF1V8a8fraw0JSeY9AI7XLFTIZQc+fYFq8dBwi3OfkftwO7CZ7u85kbdE20WP8/LsmBt9EXhQ/Q+p1BvgeGHMdFOGhhExrK6ITAd06nTFo9BcAwWN/RIbM/E/yMaTAQCIpKrXTAfGTkLJrB9AuUA7trI4qy0vk8pW0/7alPkoqXzq7f+KFfoKUQWxlkwUAnPUYg76h6rnfOP0GuVxBtaYFVJZb62s+2AJ48l16tMVHX2kDWe/gmHtVFhbBqtrCsa/HoelYZI/rkhkfQej16jNuT95Son0dleVSyTsAQwnvE79vPqxsOlv5veeOYTgUz41CLmdh9UlEhIh3zdDTU7DIJn7PQImTR/G1MX6u3vh8dCdPVVVH4OjJICkw1JX2DrWRODFSLXfczufzu64MqicIxUv+qhpIxUw+q91PVJScKaMfMHFWSUxNVc8zSJ6ykbqaEmXR0NPW/HnOprMdAM/IP9ROzi5f4EKLdrlwyqs6WJJKEGrpS3vnSiFFo6EJ8bp78wsmDrhGy875mLy5ldoyp3Y/x87elHI1Vcnlj/7SrnOYTPo71DtE2nvayUradbA3FW1xz1r/8vSOG+c+DcQqizHuXwPw/x5KwVJZVcoba0t73qSWBzAOjEuI3L7lR7FippiYxn2/Rnl/RKFQ4FBQpBpOG29Fv57x99HiIwh9fKN48VqWLG7QWrqaX7eGrb/x1CWmTuOGmTGotyk6OvFH6cXe/3fvKEpUFqTN01s5sbGOe9/r5iitdj9hYVE4X/aidv2scY4nlSDUDg+QVD41IA+MGzkVFiZn715POnTIgpGR6m8ltR2TB3omWsahyDdJ+0wJmJjp4ZDbnA3HW5Ilu2q7JXWC6tibHGqXTykh5GHGXZqGqY0Zbq++saa9IBj7X0vchTY2vkkck332UZ1IiQoNxf/hXfzv3yFb644Y5cipsl5qsEAZNf0GgH0NhW9Dw/UzsXB0IMzXn2OdhCzZmDvLJR2jsJ2058fsp356lEzO02vvcT78jMotilC2XoF4ttQctsYJT6Z8evWdvypspOEfxRm/thm6shCq2yyndNUcbDjf6ZePrw63//vIjL5n8HKLSyL7+/tjbi6RmP3BMb24bIKZqbTI6MAgBYVrBSfpuFLRoUMH5f9hYWE8evSI06dPU7Ro0QS2isFvl+dYiIqMRA9VYiaaTGywbxOy0FAudh/C7YlzaXx0R1pUMdlwdepqfN/FzOrYFs1Lw+Xj0ZWF8uLQZa4t2KERoZje8eraK7b23wyAdU4bfL54E+gVf6NqbmuKiZUxwb4hvL33kXzlHFOppimDsK+f+LxsNjaNW5Gtg6oYvF2zVrgd2I3bgd0aEYrpGYqwYEKmtlFZJn91D34QijqFKxL14jZ4fgQ7x1SvX2og6tR6ok6tx2Ce9Bnn9ApZZAyx8TOZCDCp0wEgLkmT3hFNJtYY1kYtmRgfAr5952BvYdzyM6GY0rC0t2bKw6Wcnn+Qe3uvs6XbcuyL5uSbS8x7ZNLdRWjrJu/E2vMz9zg5dScAo28ty3Ap1AqFQkkm7n4yQOPturW5yrmTrjRpkYNqtTO21lc0XkSbsTiZqiUTP38MYvakR9y79Z2dhzVzFkzvmDjgGgALN9ZEXc9DJpMzrdcpAO6GjE7FmqUunt5xA8AqixjINy8gpGVS+pyvnv9K96an6D+6JKNnlUdHJ277EREhp0XTR8rvJ86Upnx5VcKwZBXRztWubpQgmRgf5HIFxasK8sn1uX0ipZMXZw/bc+KUP32Hi+dvwfJAFiwX0YYbl1vRpL76CWkQ7Vc0mbhpZRa1ZGJCyGUtMp/efGuKhaU08jojYtcuD0aOENkxpUubUqJEyss6RN9PcrmCgC9u+AeCfyAEhUBgsPj/oysY6ENgkFgWGAwBgRCkMCcgQEaAv4yAgCiCg5OWaRccGMnrZ97cv/6NRu3yJ75BEtBzywC29FzLilaLmHhtJtkLxjxHfp89sMyVNYGtk4aoyEi8Hjzj4/n7+N2+AYq4k566Zhbk/KtPsh8boPGWuZzuOZGz/abS4exmDK0sMLazJsTThw83X+BUOWVknL699eThiUc4H36Gx6e4QQm3T71g59uU73fb5RAkmscXEbhgaCQmV90+Sw9k0BQV6zpy6p2QfHvz1Is5g87ici9u1KxkaOsk0eU5dbBv3z6V725ubowYMYI9e/ZotP1vQjEWboybR511qnoMtTb/jaG1JVra2ugY6GPmlIvAD59xveiMQ51qaVTTX0fuOhWUhGKZfu0p3F4YsugaxrzwFQpFhtcZMTQTUQdDDwwni1MWppSdxL4JeynTomy820w+PYwJleaxrNPGBKMUMwIMcwvxYu/TR+IQirFDqWVBgeiaSgufT1fQES8Zg05j0S1Tl+CxDZG7vlGu1qvdURCKznuhzbi0qmXKQs8AIsNRBPmiZZq+9Y00xcbZzgAMWVg/zrpAXxH5kjNfxnKgv7riMACGFiaU6VRb4+0iwyLY1VHoEzZdMjhF6qYJGo9vS6WutVjVbI6STCzWuAyt5/6Z7Mc6On4rry8+AqDD6kEZjkwEGNb4HwBa9i5DttyWGm0TEiLj3ElXgExDJgK0qXMWgH1n4z7PEJMOPWBE5nAEf/ZQSClkczBBX18H1ARybpp7A4ARCzVvC35Dc+jpiTZj3eLHrFv8mByOZhw+XIRcuWJINH19bbZuL0qP7iJtt1kjYVY3eGhOJk7Ow+hJ3/nuLYiEfzcnjbSo8yNVulfXtNEBbtrACNfnRkRFKVi9KUhJKPYZ5gv4Yp9Nh62rrClWRDUaumVnMZCuXd2IJg2l1f3w/q/K/zM7mejrG0nhQneV3+fMdUoVMjE2tLW1MDMBMxPIoeFrw6BoGcnH+W5SXPI2yQGncnkBCPUPIcDDH/OsFgw5MoaVrRaxp8sMyVGKsaGIkvP92Uu+XbuD67XbyIITznIxcsyDZcUqWFaogkGWlDPaMnPIipa2Fgq5Au+X77EplIcGa2dwpO0QDgxbJzlK8WcE+YVw//Rzbh15zKvbHxMsa5XNjGqti1G9dXEci6VOv8TIRLQbnl9Up+PcvwSmyvHzF8/Ctqt/EhQQTu1sK39tZ+mcUPwZ2bNn5+nTpxqX/yVCMTIyEnd3d0JCQsiSJQvW1hlrYPczgr66EfTNA1P7mA6Dka3qOVVeMJVzHXrzZPmGDE0oFm7XgEcbD4r/f5CJ0Sjarg4uBy7y9uwt8jfSTEsxvSJ3qdzMd1mo/F6oZmFeXnmB845rVOtWXe025ramGFsYEeIfyrv7n8hbVpruUXpCbEI4KiQYHWPVDmGe0ZN4v3gOXzavxWnY2NSuXrJBS08fk4Vn4yxXRMnQ0tFFx/FHyPajc5mWUNTrNpPIzeOQHVqKXrdZaV2dZMGOxbcAaN037gTAoQ33AegyOnUiqWURMnrknUX19qXoOqMxIH1g6Pn6Kw92XwSg78m5Gm+nUCjYXH84AOV7NSNnhSKSj52csHKwYcrDpVxdf5ZshXJQoKZmKRGaIipSxtKqo5TfB52bg7Fl+jPweOP8kt0jt1NnQAMq/VkdXT3VLtXzu648vSkG1cOXaG7I0byWiDJesz3jZwlEQ5ixiPRUx7zmoEY/7eDujwBUqZH8kSZpgeYVDwFw4ErLeMtsni/auE4DpQ/sMwrCQoUcg72j9Mi+X0XlWva8D+/D2oWPWDTlLl8/BlK+9G0Alq0oyB9dhEtzk2ZZ8PCuhbtbOJ06POHF82BWrfjCqhUxEdifnyetL3jqfChv3ov7feaE1PkNvL5HKaMqa1U35O85FmSx1UFHR4uh/cwY2s+MwCA5k+f4c+BoKN/co2jYTpCe1Srps3KxHc43w7j3QDyzUonUiAg5/boLgu2de7NkPLP0h4ULP7N0iWjnjYy0eeZSHhOTtDNTyMzou3MIG7quZFnTeUy7Nx+7PDH3pfc7V2zyOiS4vUKhwOvVZ1xOPcb16m3CvBOWBDKxz4pDjYpolagdJ605tdB0x0JO/DmG/4bNocPZzeibGmOZNyd+777w8vxDCtVXLzcQG1GyKJ5ces3tY0+4dfQJCnnCRFX5psWo3a4opWrnQ88g7WPP3L+kXETibwjMmDFD+X9UVBT3798nRw718gPqIPkuCQoK4t9//2X37t3cuXOH8PAY/ZIcOXLQoEED+vbtS/ny5aXuOl3gYt9xtDixLd71Ogb62NeqwrfLN3i9cz8FurZPvcolI7RjpX3IZTK0dWNuhXK9W+Fy4CJX52/P8ITiz+i6ohuTSk7gxILj8RKKAJPPDGNi5fks7bghw0cp5ho2gc/L5+G2cyM5+g1XWWdeQryI/O/fSYOapRz0GvUg8sxWZHfPoVepSeIbZAJo5xMDUvmLW2lck+RBgG+MSYK6SOl/F4vInrrtUodcCw4Q9bm2/xHX9j8CoEq3GtQb0hg9g8S1/KJkUezqLvQg//xngkobnBh2/zEdgGzF81L2r/RzP9fol/yutb5fvNjUVmg1mtpZ0P/4jDSLlE9MYtr1+VciwyI5u+wkZ5edBKBK43wMnFsPeyfLJKU6+/qE8+SBECJv38UpiTVPf5g/RUR9TZqnnjjLbHLeAX4xfWOHXOrJ8NhtnLbUyIUMhItHRLZAqx4lAIiMEGmV+YtnSZXja2lpMXBcaQaOK83zx960rX6YsDA5I4a+YsTQV9SuY8WGzUUxN9clW3YDLl8rj0KhoH/fFxw5JDTsntzMia6u9GsUHCz/EQUIT2+kXrRxFlsdalQ15Or1MC5fC6NUDXGv9exiwqTR5hgaaGFmqs3yeVYsn2fF568yBo7y5eHTSJxvRVC6Wkx04fO70omUisXOATB9XjHMzFPHiDG18eljMOWL3FB+37q1II2baC5h8hvSkbOkIPVlETJ8XX2wcrCm854Z7O40jf1/zVGJUvT95M7b/+7x7uJ9/D4l7BJsYGWBQ/UK2NeoiFXBvHH6HD9rKKYmjLNYo29uSkRAEB6PXpC1VGHqLJ3AoZYDOT5pWxxC8fs7N16cvc+Ls/fxd0vY4DNv6ZxUbFmC8k2LYZFF9Rx/1lBMS8ijMn7/QEtbS3KWjZa2dKO1pCI4OMYETldXl9atW/PHH39ovL0kQnHZsmXMmTMHR0dHWrRowfjx43FwcMDIyAgfHx+ePXvGtWvXqF+/PpUqVWLlypXkz58yWgopAT1zUyIDgvjmfAf7ahXiLVdiWF++Xb7BuwPHyf9HW7QkDAzTE8r0b8+Ddftx2XOG4n/GzCBmtrTn2NDR1aFs63LcP3yPs8vP0HBYI7XlLLKYYWRuSGhAGO8ffCJPmYwbpWhWSpD7/reuxiEUQYTuh358T8inDxjnzhwDWL1qrYg8s5WIs9uUhKJWNkcU7h8h2B9MUj9SIjWgZZsDxfevyL2+op1F85ml9IiFw0TE6ZKD7dSujx6U6uqlTiSAha0pO7/M4N7pFyzvKzRFbuy4yo0dVwGoO7gR1XvWRiceDcG19UUEcPnuDbDNq7mGlvPyfQR8FZEjrdaMSqR0xobLqbucmi5ShCv+VY8aA5unWV3+rhxjVlaodlEaj2mBdQ7VwWKtvvWo3qM2t/dc5/QioRV24/Rbbpx+qyzTqo/mqc4A1UsKYnLPicyVArtygXBrHzxGvcvvmeOCwOg16NeF3tMDercR7dfWY+r7GABzBwvS5e9DbeItkxlwZOsTAJp3Fdf++QORRlu2RupH/BQpacMn1xqEh8sZM/IVe/d4cOmiL/mdhLzGoaMlqVrNisDAKCWZeGxvNmxtkvaeKVBenOviWRZYW6buWGHPVkFg3rwTRtc+HoSEKtjybzBb/hUDxzlTLOjeyRgtLS1y5dDlxF5B8N6+F06bbsIkYtUSWywtpJ371UueuH4VKaMDh2WcMaAU9O9xl0N7RZtVtKgxZ8+VTBLh/BvSMXDfCNZ0WMbSxnOZ9WQxOrEyA9ZVH5jgtrpGBuSrUwbLSlWxLVEYbZ2MEUnaaONsjnUczpVxi+lwdjO6hgZkLZQTj5dfWFRhWKLbm2axoFqb4lRqWYKchbNlqnF9hoG2jjD3lbRN6lynvXv3MmXKFMzMki59JsnluX379kydOpXixRPWTwgPD2fz5s3o6+vTu3fvJFcutRDtwFN/21LO/yXck5of34qWlla8zrPvDhzn9c792JQoQoVZ45XLM5LTszxKzu6G/QDocmGjcrmhbhS3Vu7D5eBFakz4i/wNKyW4/4zg9BwbcrmcicXFNZv3bAFaWlpqHVL9PQOYWEVEFKmLUswoTs8Ar0b0QubnS4HFG9CzsVUu19ORE+7lwYtRg9Czsqbo8g0JHiO9Oz3HRrSzc3QqtOzBRcL3LIBa3aBOd8nH0RRp6fQsd/9A5PK+aNnnQ3/IWuXyjOj0HO3ufDNYpKjHdjCNCJPRMOsizK0MOfpxhNrtU9rpWaFQcGiLC0em74+zrvnkNpRvX1nZabu65SLn/xbGC8Nvaq7D4nL+MeenbgKgz6WV8ZKV0Uhpp+ekQFOn5+PjNvLuqiAeOq0bQs4y+TTbfwo5PX97/J59/ZfFWW5kYUzzSW0o1rCk2k7516efWd9lhfK7JoZB0U7P376GUNJRaGx6ybokuE1Gcnp+8dSX2qWOkcvJlDtvYwzAdGKlPZcvcJSP74N44dYW2yzqHZczitOzQqEgj4HoU32I6Kuy7rssxqmxvPFiIGFjkszg9NzSTkhwRJ/n1oW3WDPdmYW7W1K7ZVzCKbWdns+e+U63Ls/Ulps7Px+9+uQgyvujpP0rZBH8vS6QRSsCsTTXwuVWdsl1TAxSnJ4B5JHh7D0UyqgpfirL9XRhxzobalQRfal6rTx58VpGs0bGbFihuT6cbo7SyOUKspkeAeDp+8ZkzZbwM5XRnJ4f3felQfXLyu+nL9ekdGFp792UcHqOjajv0lyfDYrWklQepOsoJpfTczSiHZ8TQp7aZchXtyy5KhVF1yDus/KrTs+JIbmcnqNxqudEglwTjrQEKFS/NIUblcOpUiEVshV+3ek5JZCY03NtC+FtEd2Xiv6emiZm0RqKv+Ly/PJWFsxMpb2fA4PkFKrkleIuz0OHDuX06dPkz5+fVq1a0bJlS7JmlSZzIelu378/7sBJHQwMDBg4MOFZgvQIXWMjcjWowedzV3m8citFB8VPhtrXrMLrnfvxfvIcWUgousZGqUImmhpKe3FlMQ2Lf2Wsq6+nCEdHT1dJGFXq1xyXgxe5Om8bRZrEH62Z4P7jgVQyEaQRWZoMFuv0rsHFTVc5PusgvReoj4Ixso95eby68oJSdQsqv7sGxE/eqYNUMvGTj6kk4vh7kCHGCfyu+UeM5sW0SbhtWU6hSdOAWORDbkteAJG+Plgbx98xl0pkfw8yxMok4RdFbCSFTPQN1sfWTH2dQ80skAf6Y63nh7ahEYpqlfi8B3DejUmThAfr0ZAloU5SkBQy0TswgUGEjRCtVnx7S3ikqHspR19Jv22nsu8l1adwlkDJg1hzA1mC27i+FwSovaMlYTJtIn6q//GdQii408hqcdYBZDMKjrMsIUglEwG+BRpTqX15KrUvjzxKzrVtVzm9VJCGx2cf4vhsoZ/WZExTJZk44tpidDVsy9zfesSQicdnY2IIEP8zaBPPxFFCkDpBIBWRUdqJ1ksWIWNGuZhJuSnXp2FiaQIkfj7BEbqSCVFN3z/ZqmenjMtCzAwi+fDoC/tmHOfzU1dC/UPYN/Yf9o0VkZQ1ulSk2Yh6mFiKNr5hKz3W/9jH0Rd9MNVL+J2dm3cofjST0WTimSs1Exx0ButKSxWNUEgb2OhrySQNAI10Er5W6sxYdH7SUPz4PgggzcjE5CRol80Q+q4Dx5ZSWR6bTPz4SgweHQvGrz2eHslEB/MwtW1ufIg9WAyKFOT/nSsisqtARUflsmiY6kUSItd8stZYO1xSeQDbiHegF3N/NGyeC4+AXHz/Hk63jve5f9cPgEZNs9JrYAHk3h/Q0tO8zycP9cf1m4xFK4RxwKNrKZPqrJBp3r9CFoEW0KmlLp1a2hIRqWDhyhDWbgslUgade4v70UAfwn/sdv1SS42PoZujFApZOC0a3ASg/2An7Gy1UMjibxu0ja3itAMJIaE2YFDve/zVx4nyFZOecpxQXaOiFDSpe4NHD8TkaYvW2diwrTSESZtMlUwm+n5NvFAsRH3/Lqm8Xv5SyEP8JG0TlrUCxhq8n6MRIjeQNEF16HXiGWHDjo1jeQsx6ZyzQhHy1i2LU/WSGJhp1u77hBhI6jt8+G4mqb8UEqErKbigklPipHHrDePZ2TRmAj1HSUcK1i5G8SblMMsSH9kUc44FbKUZmSQ26f8zpLwXopHDXHMOwVBXrjJ5pK+VeP2S0veRslwS0nGE4ooVYhL8wYMHHD58mAYNGmBmZkarVq1o3bo1efPmTXQfGTNXNwVRckgPAD6fu4osRH2ES7ivH5d7xzzUziOmpErdUgKVhnYE4NHOUyrL9YxiOmiZTdsIoPlokYZ0Y+8domTqXyqv735S/r+i1z+pUq+Ugmk+EQUQ+NxF7Xr7+nUA+HrmfKrVKaVh2aIrAIGXjgOgFZ3aIJMexZWhkOeHRtln9dc6I2BmjyMAzPhHfSrgniXXAWjSPXEx6tSAto42NXvVYr7LQmY/nEvNXrWU604tEimsf2wajq4GWosAEcFh7PxDmLa0XzsME9vMmaL//aOXkky0tLdi3rMFP8jE9AWnUjkZd3ggq9/OYfHDKdTpWVW57uq/txlbbg6D8k1iTpMVNHISkcHt+5XCPrfm1+3Nq5jOfpnyGdvgLjbimLGoQYC/IC2y2EmPEEyPWDn3AQCjZsavJT6ui0iRX7g7fsOWzICIcDEQy+IQk0r1yFlE5FrYSCN9Uxq2tgac+q8K7v6NuX6/Btt3xzUD0xQV6gmC4OAOG/T00l96ob6eFpNHmuD6xJYnl62pX1MQy9Fk4ss70knQJ4/8uXNLTAbOmFs42eqaGBQKBft3faFp7atsWP028Q0k4vwZT+ytTivJxNuParJxe5k0SRt1dYvCwyuGqHJ5JWPlJulZYhkdto5ZmPVkMbOeLKbpksEUalJZYzIxo0LfxIhel9cpPz22DaVK9zoJkIm/ka6grZO0TyqiTJkyzJo1i8ePH7Nt2zYAunfvTokSJRLdNsmEYlhYGIsWLaJJkyaUK1eOMmXKqHwyKrS0tCg3XkRXXukfN5w2IiCQi38NBaBI324AhLp7EuqVcKhyekWRVjUBeLRDlVCMCImZNXi850Kq1ik1oKWlRYuxjQFYN3hfnPXPrrxhfvtNKsvePfgSp1xGgrFTHgBCPn9WWR7hH8C388J59vWmbaldrRSDaWVBkvodi0UG/5gdUmRmUrHND7fuXRl3ouP1I6E7la+4+pD7726CfDEylRZdkxrQ1del8cgmzHdZyIw7M6nYsRLtZrfHoYRm+qQKhYLltUWad41hbXAopVnqb0bDw6N3lREGtfrVY9SZSRlC18fIzJC2E5uw+u0cVr2ZTZ81f2D+Q8z822sPfDzF4G7ssnqS9lu1tHjPXn8obbv0jsTMWACWLxCTHzMXZ9y+YzSunhcRRWUqZU3QaOX9c9FndCqUuU0cTu54DEDT7qWUy2SRqSc0nxRoaWmRL3/STRh6DRFGCLWqGVCpnLToybSAjbU221aa4/rEFucTVjy5bC05NQ+gfg0x0XfzQc3krmIc+PlG4OEmxilaWlpcvVcXgMljnvJn25vJcozQ0Cjy5zzHnx3uATB0VF48AprgmCftJr0qNPSlTN0Yo40Js4OYvyKEz19TVrrkN34jvcDUPP31+zMDXF1dCQoSmSJyuRxbW1tGjx6Ns7Mz588nHmyUZC/wnj17cv78edq1a0eFChUyxEBAUwhDljVE+AcS8OEz5k65AIgMCua/roMAKNi9I7mb1sOiQB5ujp7O5d4jqHPg3zSsddIQ23EoKiISPSMdPjo/4cyEdcrlt9YcplTn+uo2z9Co06sGxxae5v6Z50SGRaJnKKKH7p9xYXV/Ybow6VBfrB0sGFVxEXPabGDLx1lpWeVfQt7Bw3g6ahjvViyl+OK/Afh+7wFP5i9RKRcVEYGOfsZvsLV0Ypo3hULB9y2LQS4GMrJbJ9Gr1iqNapbCMP+RDhkiXdcwPeDJDUHcl6ujnoCLikrfg9HYMDAxpPVUEWXprWEW9qr6EwFwqlqMMp0ylzFHNP4ZvJlXV18A0GvrQBzL5knjGiUNWlpalGpQlFINigLg882Pp7su0GdiZUn7uXfH58f+IH/BpItip0ckZsYCsGLhcwDadHJMjSolijULHrJoyl0AbLIYUqqCHaUrZqV0RTtKlMuCqVn878fuTcXk7Jaj8Zux3LrwEYBaLTKHYYX/92Dm/bmLd4/j125r3CXxCIfMgHsPQjjznyC6/lmf8SKNnXIlLSJmQK9HADRvlY08+VKecKtc8jze3yMYMbYgE6YXoVARc965NyNvthOcO+2OnfFh3AJboaOTtLHpjq2fGTMsRlfz+Yd62Nikfb+4cH4dXryJ4vlrGUUK6DJngimNOvnRb3Qgp/dYpnX1fuM3kh1GJnqEBscEgWTPZc6bZ98znGmslrZOElyeU+/82rVrx6FDhzAxMaFy5cq8fv2aUaNGMXnyZI30FJNMKJ48eZJTp05RtWrVxAtnQNTduJD/+ozl+vDJND66A1lIKBe6DAAgX6dW5GnTFICw7wlbsmcEVBnxBzeW7eLBthN4PHmNx7MPANQc14UrCwRJmtEeXE3RaU5b9kw6yOKu25mwvzfXDz5k8yihfTbj9CByFlZN+/j+1Q/bHJZpUNNfh2E2IQoe5iY6/c+WrsDzxm0Aio0ciiw0lJdrN/Ju524K9Eo505LUhF72XES6febzQNW0ssibxzMvoQhQqgE8OgfProBjxhrITep0AIDxa5upXX/9+CsAOg6vkmp1Si2cmvEvYQEiwq3l4n5pXJvkR2R4JDPLx5iUTLg2E2OLzJOmZG1vyZildSVv16TWFQAevY6fhEpLOOmrN+vKU8CCvAUtKVjYjHwFLchfyIK8Bc2xtBJRWS+eivTHXE6mGvUfEoroS03oG8SQKt5eYfx38jP/nfwcb3lTMz1KVbSjUPGYaEMLq/gj04a1OgjApNUNkqG2aY+Df19VSyZaZDHB30vMpNjlyPxpeTKZguZthVTOjbN2mbLPrA6fvsg4tF+keG/cnjoyJOev16ZMwbMsW/iKC2fd+e9mHczM9fAIbkXBHCfx840ku9kRXnxugo2t5lGi3t4RFHGKycpatLwY3XrkSolTSBI2LjOnWjNfegwN4PYZa4oXEcP4J89T3jzjN34jLZAtlzkfXngr5dey5zLjzbPv+HiFYmOXgfqPWknQUEzFd0hISAjZs2fn+vXr5MqVi6tXr1KmTBkmT56s0fZJJhQdHBx+yV46vcMkux1muewJ/PyNz2cv8en4OQCcWjchf2cRceJ1/zEP5wshyxprFmCgF5XixixBYXqSjFm8ggwTNU4p1KI6N5bt4smus8pl3Y8twMjKDO+3rjw7eJk35+5QoGHFJO3/ZwRH6CbJmEVThMl0NDJmAajUrhx7Jh3kzd1PnNl4nX1zzgAw9+IwsuURbshbxx1RlrfMKu55B/NQScYsDhYhkoxZclsH8UmCo5itaRjfgxLXn7IsUxa/B/e526WDclnVjaswsLJCoVDwcu1Gvp4+p5ZQDI/UkWTMommdoqGnI5dszGJlEhGvk7TMx4tIt5hBoFnNJlh36s+nAS1QeGkmdK2rI09RY5agMF3Jxiw2ZhEJG7MANBksCMV9M3lU7D9KOWru8rznfh5JxiwvvMwonEVV7PnO2dfM6bo30W119bSxsDHGwsYIC2tjzG2MCPIX7YlNtpj7X19HrhR83r3UGYA2A+I3i3IPNZFkzFLC1leyMYvUNsDGJBzv4PgHNk+P38Ll5B0ARt1chrbE58E72ECyMUtklHaKGrPEfqa9PniyouVCAKxz2jD8xPg4A26p9THRlxEcIa0bI/X9ExiuJ8k9+843KyrYa/687TojfoPs9oZkd9DsfjKReUkyZtHXkkkSJ49Q6KqIkPccWowtK+K64L5/7c/71/6cP57w/mKbsUQjSksXHYWMx/dF6m/DZg4J7kNL31iSoYEiIkSSMYupdrDSmKX38BL0Hh4zEePpFsKjO548vO3BwzuePLztSUR4zLswKDAS5wuuOF9wBeDYrdZqj2GrG4BXpBlyuRgYWdokfL0dLYIlGbMY6solG7PYGEdIMmZxDTDE4Sch/Z6zG9NjViO1BFr77DNUvssixe+Wp6j6+zcoUi9RI6PYCJEbSHZ5/q6fVxizaAhtGyfk3h8SLVeuqtDvGzbIhtw5kzy8Shno6oNEExc0dJGu0lCQiWcvV5FEospDfNE21vy9G7sNyJHTmM8+LchlfYynj/2xMz7MF98WGBjo8Nq1GUP73mfPP58pnOsUZ6/WonS5xI8zb9Zb/l4k3L8tLHV5/KouRkYJj+m0jCxRhPol6Rw0gbZVDhVjlugI0q/fYt6T9Wvqc/5KBFdvRlCjsq0kY5bIN4/Qy19K4/IAhh53CMsaf//rZ0g1TmpT4JNGxizRkDq+ArA2DscnRPM6OdkG8uG75pyHsb6MEAl9k1sf7DQyZomNb/7G2Ftofi+9/m4myZglIFxXkjFL7H66pvgaYJioMUu2nBZ8eOFN60Jr6TOlOnY/DFPdPgckSij+at/n/xGXLl2ifv36GBgYYGCg+TOS5DfekiVLGDduHOvWrSN3bs0f/IyEyktmcq59b1zWbKXmhiUEu7qRpYzoZHo/ec69mSJVtNryOZg4ZJdMJkp1zQXprpyaNDYPdpxR/p+/Timazun141sUOj8com6tPUyJpuXibJsUZ1Epg7PUwOD1nVnVb7eSTFx0fRQ2DpYArO6/m/tnRDrW2udT0NUT11iqy7N3sIHGJCfAtwBjzCQQx4FhethqQOzKm9Xm/gPhQGmWIyuNNs350QEM48HqmJR9W7O4+5J67/kEG2hUp2gkhYz3CTFQ6yTt//AersvmqyzL26sn7n4xxzA1iEy08xsYpquxK29SYJYEl2d3Pw1IWsOYQWgRB+kuz1LKF8oSGKcTkTWvnUbbyiLleLsH4e0epLK83eBK8XZM3j8TnS7LLPEPtK0NwyV1Ip56Sjc98UyAHFSHhMhEj5dfODNrNwCDz81FW0ecu5RnzkFCxzIaP+8/0DsYHV1tjC3Ut29GutKehdAf5MaNfff4d6JwMG4ytA5Nh9YF4j63UvcfEK4rqV0F6c6FZhLLF7GSlrUwvI2IiL9yV/PIxtRweY6NKYurMGVx3IhghULBd49Qvrzx4u1Lf96+8uftS3/evPLn6ydB6JeuYKvWjCXa3XXaWKGxOHVe4pFNUp2bpSAhl2e77MY0aOlIg5aO8Zbx8wnj8V0vdHS1KF5G/fUJiDLmwFqhx9Z7bPlEBy6v/aS1S4Hh0rv0UtsxB/NQjUlLWYQ4Pys7E2V7/vyeiGQsXjW32jZeX0cex/k5IVjrh0pyJAew1/MCXc2JLJmbC+gm/DvtP+iDh6c433HDpAVbSHJrVlZK2jbykABJ5bV09SEi8f7bnBViDFC6tCklCyOJXNM2yyrZ9Tg2DA118AxpTc0K//HiWQA5rY7x8HVDHHIYs2JDWapUt2Vovwc0rHGZxStL0a2XehmVD++DqFgsRiPs3/3lqNdQsz6MlPMFUIRoPtkEIA/0irOsYysD9h4J58ipcFo1MWDpLFOK1/Dhj/4BfPpP0u7RcyoMCbhbq4NWrgoYSXB5Do2SRvrvfZNPUt/HPcBIcj9A6kThKw8LDCQcI1ymg7GEicuyuaS5cwM4WgclXigW8lprPskO0vtKYTJt9CWOl+zUjN9+RtdRlbh57j0eXwOZ3S/G76FL9T3MWFOHFn8WQl9f/TtAptCRRBDG50auq5UM40AtbRGlKGmbXz+spihQoACdO3fG2dmZW7duERYmLVgsyYRiuXLlCAsLI0+ePBgbG6Onp9oB8PHJ+KnAOvr65GnXnPcHjvNi87+UnTgcAN8Xb7gzRZAVVRZPx8wxZxrWMumQhUeyqd4wlWVmWYXmS0RIOGvqxpjStF05OFXrlpp4/yhm9m/m2cFKMnHRH1t5cUNEaq1/NQ09g3Q24ywRr3bs4/3BE8rvjTcLF9moSBkHm8WkVzbZNj/OthkNOkZi4Jl/2lzezJioXB58Neb85YG+6JhnPI0jjVHzT7jyDz4XTmLToHmqHjq7kzX73abFu15dRyUsJJIAnxAiI6JwyKP+umRGx/lQ/2B2dFsMQNdtozBKQ5fj8RVFm1Ctc3k6z2qVLPtc3XMbz6++AWDk3r7kLZs5JyCTgqP/CB3J0mWtsLRKe30uqdDS0iJLNmNyOWSjai3prrAA1694AFCgcMZ2Mre0NqRmw8T7ggtHi/T2/pMrpXSVUhyR4TI+PXfn3cOvPz6ueH6K2/dv3C2GLH56Q2QNFK+SedoBf38ZQ4eL83r9vDigeRRQRsZ3HzlrdwhS5uSp4mlWjyt36jJryjNWLnlD6QJn2X+iKjXr2NGpa26KlrCgbuVLjB7yiOtXv7N+e4zzukKhoE/Xuxw7JCKLS5e14OSFKknWXUwtzB5vyt4j4QwaH0irJgZYW/4wG1QImXCpWZUZCRv+WkfW/NloOalVWlflN1IJpavl5GbwOAL9wji67harZ91Wrps28CLTBgpTUZusxgycVIE23YuoyJakFwgNRWn10krFZ3nLli1s376dwYMH4+DgQEREBEePHtV4+yQzJJ07d8bV1ZW5c+eSNWvWTKsVUrBre94fOI7n7QdEBAQS6vmdW+OFMUel+VOwyJ8xxeRdH7zi+LDlAGjr6dLzzBI21R3Gg90XyVEmP8fGrAfAxNacXkdmKSNmMhv2Tz/C9d0xjdOCjptZ+Wgi0xqv5ssL4TS78e10dHTTX+OkKeRRUZzv1Bd5hOj4ZataAffrd/h86TYWTjk4228qAHrGRrQ8sCJTXGvTQkUotUNo8ZkWLkbQi2c86tYuZn3z7pmbTASo1RWu/IP77q2pTigmBYbGehgaJ0wqPHYW+lSNupZKhRqlPBRyudKEpeGkTmQrkrZaTeOODGRBqzU4776L8+67zLo6Bmt7S5UyBxee5+Saqwzd1IVS9QrFu6/IsEgGFZqp/L7o/uR4Ix//XzGxt9DqOnKuehrXJG0Qmc7dfpMboSExETF6ehmnTxHkHcSqjivwc/OTvG3+Utn4Y3Q15ffoNrx4lYw5Ea8OhYoJOYA1K3NjZqaDIjSNK5RKKNVARBf+s9IwzfVPp8wqRoVKNnRtf4v2za4zYVoRRowrSPGSlrx2bUoBh5Mc3v+VU8e+8cm7BQ/v+dL4h3YtwHnnWpQokTH02IyNY37riEgF+npajBpgzJK1IazfBwM6iXW56oCNJTw8lDb1TA6MLzqWOv3r0mBIQwDe333P+7vvqdatOjY5bRLZOnNgz58z0NHVpf22SWldlTSFmaUhAydVYOAkkW4fFBDB7nVPWDv3DuFhUXh7hDBr6GVmDb0MgIW1If0mVKRtr+IYGmXsgKDUgJmZGYMHxwSP6evrkzOn5u/pJP/CN27c4ObNm5QsWTKpu8gwKD9jLHenLVQ6PANUmDUeq8IZ06Hv9Pi1fLr+FIDKg9pSspNqqlU0mVhvQmeKtch8xgfR2DFqDw9OPAZg9bPJDCo2m2C/UEZWXIifh5hh3vR+BtoZeLov2M2Dq/3HKL83PLgFuSwK9+t3uDU/Rmi/yB/NKda9VRrUMGUhj4gg3N1V+V03e25sxixHS1fzlKoMi1gu1/LICLT1Ml4E1M/YvfQ6AB2GSXPRTa9YXGkEAEUal6NEy7Q/p1zFHFj1ZjZLO27g/YPPTKmxiLq9q9FmfGNlmYIVHTm55iorev+LbQ5L5l0eHmfCxfWNJ1PqrwQga94sTDkzLNNOOiYVW5Y+AKBR02yJ6nRlVvyzWWjOTZiZ+fuRAEvGXwVgzpaGaVwTaXhx+blaMtGpuD15y+Qgb+kc5C3tQFZH6zj9pZ9T2p5cF4SipW3aRWInJ+bMEyncOXLo0bqVNB3ejIxNu8V1tbPRolbl9DFYb9g0O7ee1qdS8fPMm/GcSxc8OHa+BpZW+rgHtSKn1VHCw+VkMz2i3KZtp5ys3SLknBQSU3/TEnMmmjBpbjDzl4cwdbQJw/oasWRtCPM2xBCKAN5+EBYBhhm4+3dx3X/U7FkTAxNDhhwYxsp2y1nUaAHzXRamddVSBOuqD6RAo0rUmdQNgCBPP2Sh4Xx0foJjtYxlspiSMDXXp8/YcvQZK57fkOBI9m18ypo5dwgOjMTfJ4yFY66wcIyYODA21aP/xEq071sCY5M0GANq64LECEVSYaJm1apVuLq60q9fPxwdHVXWyWQyTpw4wdKlS7l69WqC+0kyU1KoUCFCQ39tGm7t2rWUKFECc3NzzM3NqVy5MqdPn1auVygUTJ8+HXt7e4yMjKhVqxYuLi4q+wgPD2fIkCHY2tpiYmJCixYt+PpVM8MFTWFbqpjK97JTRmFTokiyHiO1sKH2ECWZ2OXAbCWZGPBNVb+hz8k5mZpMvPbvTSWZuO7lVIxMDZh6vD+Akkzc/GFmhiYTQzy8lGSiY/OGND66A21dXXQMVHsW9VZOyZRkotuhvTzp/QeRvjGaNbYT1vx/kInRaCEIK88D/yZSMGPg0ZWPAPGmRGckHB69CQB9EwOazuiaxrWJgZaWFqP29WPEnj4A/LfJmUH5JuHvKTS4itXMz9/3xwPC9b5Pvum4OMcYHFzZfU9JJjYfWY+pZ4f/JhN/gkKhYMlEQY5v2R3X7Oz/BVNHC1K1//D4I10zE/ZvFH2vZp0Lp3FNpKF82wrMd1nIfJeF7PwyQ/mZeaof3Wc3pVrbkmTPY6tRfykyXLp2eHrFhw/hrFojNH1vOWfMMUFSEBSsYPoSQSjePJ6+ovry5DXl43eRkXHrujd2xoeJjJSjra3F5n9V29p7LxooycSMhu4dhZb2+h1iHB47Tdv/h7Teoh+xBHPWpmrVkhVdlom+0eImiwBwKOyAnqHow7+69jLN6pXSeH3mFn5fRNvS9eAcAM5MWJcpZX+SC8Ymevw1vAx3vPrjEjaE+74DGLu4JhbW4lkJCYpk6cRrVLZdTUmjvylvuZLNi+4QHJgEDdukQFsnaZ8UxuDBgylYsCBNmzalSJEitG3bli5dulC3bl0cHBw4evQoO3fuTPz0klqB+fPnM2rUKC5fvoy3tzcBAQEqH02QI0cO5s+fz71797h37x516tShZcuWStJw4cKFLF26lFWrVnH37l2yZctG/fr1CQyM0ScZPnw4hw8fZs+ePTg7OxMUFESzZs2Iikq+TkuIh6oorl25jDubnqd2GfLULE2/q6uVeokPdp5hV8epKuVMrOOKqGcm5C6Rk2z57Fj8dBb6hnooFApmNl+nXD/nwtBMMwiuOG8ShXt3ASDM24czrWIcnIv3aIN1Acc0qlnKIPjNSx51a4fHkf0A5OzZP41rlIYo2xQA73OJ2LD+Rqriwd6rvL0qyIWhFxekcW3UI185R1a+noV9wawATKyygKN/C60acxsTtnycRYthtQFY8uc2pjZaxaIuW9k+QWiuTDrUl0YDa6dN5dM5Fk8QZGLHPsXQ1c24k1a/irAw0U8zNk4fEU4pCbevYpRvZfs77T8zQKFQUKWG0EA9dSx/utfdS04UqinMHZbPNMBAP/2dt7GxLh7BrcjlKMhOB4uj5LQ6SrcOtwAYOb4gniGtyZU740bJamlpYWoifnt3T9GOblspxm3jhV8oHRqJv9s1l0FLdyjeQGhzBn4PxPOd0Nud8J9I/d3af0ua1SslEZ3avOeP6QAYmBlTuIWQjfhv1rY0qlXaINAvjEA/aeYg0TA00qXLoNJcde3P49Dh3PEdzKTltbHNJtqFiPAoVky9QRW7NZQ0+pvSJstZM+cOAX4ZJ1I5ufDXX3/h4uLCwYMHadeuHXXr1mXcuHG8f/+erVu3amS+rKVIIt0dPRP5M+miUCjQ0tJKMqFnbW3NokWL6NmzJ/b29gwfPpxx48YBIhoxa9asLFiwgH79+uHv70+WLFnYuXMnHTt2BODbt2/kzJmTU6dO0bChZmklAQEBWFhY0HjfWvSMVTt7gZ5+XOo5HACTHNkJ/upGga7tydtOvSZZRnJ6/tmUpeXqkRwdtBSAgf8tRt9YM/e/jO70LJfLGVlYNODmtiYEfBedpS0fZyW4XVKcnqXgW4C0md/AsIQj775dvcnjJWKqMnvNyrhduQlAh7ObNT5GUpyepSCpTs8AUSHBuAztizxC3I9mxUqQZ/RktLS1+bhqKX53bpB/6lwCbaVNCASGpexgN8WcnqMxvT7I5RRcuR1dU83cJzuVfS+pPoWySBehl+og997FgwHVN1GlaQGm7WyfaHlrQ2ntUmo5Pbs++cCu3n8Dgkw0MJVwLRNBcjg9q8ML57es+mur8vvyB+MxsxaDMT/PQEZWUE09WvVkEsbm4rxCNXSEjUZSnJ6lIi2dnuVyBcWNVwHwLHSwMDaRS8+qSG2n58RgpCPteXP9EkxZxwMULWHJ5QdNJW2bUkjI6flX0anecW5fdWPnlY6UqJBd4+3Sq9OzFMROe25oLaJtzvrErwcm1SnUWl96tpS9Xlz33IQgc1PNjurQ+S3XnINo2dySdWsc45SX7P6bXp2ef8LRs5EMmiSe9a/3TFXW6eaUno6pbZZV8jZSMHHUYzatjenPvPraFCvr+PN/k5L2nBZOzwB3H0bSqrs/lcvpcmCLJQAOJUS22Wcx90fpNiLt+cYuyBGPb5aek/SIaa1cFSSVD42S1sbsfZNP+b/nOw+WthAsaXSa87aBW3l55QX1BtWn3sD6uEscj4FwepaCVx7S2uJwmbTxTGyn512dpxHw1YsaoztTpKXQWF5XfSAA3Y8twMhK9OXTo9OzVCTk9FzZREy43wwWPJCPZzAyXx/yFdFcP1OmUH8dIiOiOL7rBevn3Mb9q/oxTL/x5ek2pCS6ejpUtFuPv78/5ubSAq6iOabXL0thZibtnggMjKJAoUdJOq4ULFiwgFatWlGwYMEk7yPJI+VLly4l+aDqEBUVxf79+wkODqZy5cp8+PABd3d3GjRooCxjYGBAzZo1uXHjBv369eP+/ftERkaqlLG3t6dYsWLcuHEjXkIxPDyc8PCYl0Z8EZU+7iE49x4OQMF+vchepyaXO3bj9c792DdthrburxENSSETzQylEXHWxupfji9P3eTyPBHCqq2rQ69zy9DR06XZrG6cmLKDG2sOU39ch0T3by6xPpDyZGJ8A+SA70G8uPaGiq1jHAejZFEMLyyiM3MUysrMM4Pp6TgFgA9PXHEq4aB2XylNJnoFG0oi7yKjtNXeG1ERkXy+fJtP/93C85GYTa8+ezjZyxdn3w9C0YgQdA0Sf7FKvW5ewYZYSyCbA8P0JBOWQWF6WBuH83L9Zr6dv6hcnr9HV7LXqYmukaizQZfW3L5zg6/79uAwUvPUpKAwPUmEX2SUtJepaRKen09e0ga9uYZN5POy2bjtWE/OgaMTLS+VTHS0CpbciTA3kEneZtdScb+2GVpdue3ZHQ+QyxU0/qusSlk7k4h4OxHq8MLLNPFCPyEgXBdDXc3bcO8QA2QBfkoysd+BsVhY6QHS3gNuL74S9D2A/NVV72MnK2kdRdCcKLNrmItqX6YwpPIKvL76M6zMfHpMr0ergZUJCvVXKXvEY/KPicYIIqK0MZPQ9MVHJHx87sHbx27U7VRSZRIzIFwXG2Npg+qEOq9S6hQfHI28E1w/rPt/AIyYWhYTnQiMw76iblY3PDyKP9rdY9P20nEGwBFG2dGVcN+EyKW9f0AaAWmhK/3eWzDlPgAzF6k+u8P63KL3oAIUL5W6sgZJIROl/Ea3r7oBqCUTtyy+i31ucxq1V+3Mfww0k3T/eYdIF0qTSibamYRLes+ZGciUpL8sUtyzOQtm4YWLH36eQRSt4qhSXl9HLundYGcSIfn+zqH/nTCF5hM5ej4v0NKPmeB1dvbnmrMYyK/fFLc/Iff/pnY/X7/JePAonBZNVO+11CATo/y+J14oFrT09ePUKyJSwaBJos/y/D89lfW6WfOqJcoCA6M4cTqQ9m0s0NVVDUDRtnFKcd3COQsK0aiJLQH+Mpq2yAYo4j9mpPQJOXXXLjg4ijVrXOnf3x4zM9U2QiqZGOX9Jd515YqKvzfvyVBEiCiugo7w6iO8fC3+3zYTmg+FQTPhyN9x96Gbyx75T+/wnxEWrsDrexQeXnI8vaL4HpULT/dbeLiHqXy0tOD4fzVwyqPan5IbmEuacNr2sqjKd7u8WTGzNSPweyBPzz6heMMSdFvVnYnFx3Nh9XkqdG8geWzsFSRtjPXJx1TlGLLQMFwvX+frucsU6d8dq4L5VMqHR+pIartjk4kAvXaPY1n10VxdvJvybcqjratDuxUDODB0LdtbjGPMneWSJ5CdrKSV/5lMVCgUPHb+zD+Lb9CgczEadFJ1do+I0sZQ4oSwphP/ulri3dEszyoUCngVPlCj7WQKHeW2cfZpAB16FKZDD0Goy2Ryzux9warZ9/jyQfBC6+ffZf38uxodKzEIl2dpvFFquTzr6enRp08ffHx8aNGiBa1bt6Z8+fKS9iHpzD5//kyuXMKFsmbNmomWd3V1xcFBPSETjadPn1K5cmXCwsIwNTXl8OHDFClShBs3bgCQNavq7FXWrFn59EmIOru7u6Ovr8vIL/4AAQAASURBVI+VlVWcMu7u7vEec968ecyYMSPO8sigYJUIxRdrNwKCnHCoXweAfN3+4O2OXTyYOptyc6cneG7pFa/P3laSiRX7taT0nzHEa6EGZTgxZQePDl7XiFDMSHh64QW7Jh/B65M3zYbXA2BFVxEyX6iSE2P39ARg8c3RjK68mFkt1iUapZje4fvmI3eXxEQWtdy/HANz8bKvNvpPnBf/w71NR6g0KPGIr/SK+5Nn4P/yNQDFxwzHtnxZLnXoyufjp6i6bgUAJg72AIS+fJJm9UwrmJUoA0DA3RtpXJNfw7XDIkIkf2l75bI1o08CxCEUkxs7Jh3j8r93KVG7AP1WdsDIVDpBI5dFsazeNABaz+uKXd54wgUSQICHH5v+EFHkUx4ulbz9r0BHV5tND4Zy+8wr5nbbx9bpF9g6/YJyfdfJdWg3tGqyH/f5rc9MaLEdgDodS5KRlSgiIqI4tlfoTQ6dnPA927vbQ5yvePPyRRCVq2Z8zdCfsW/nBwBq1I15DjzcQ9m19R1uriHsO1UnraqW7HhyV6Tqlamqvj+8fIpIgf+ZUMxseP9EkKpFKudmePXVAOx3m5aWVZKMiAg57dqKd9GDh9LeOxVqiUjknwnFjIKa7QWhMmmIDmYmmjXExcu9ITxCQZNGZliYp435VPWatql2LBeXYOrWEfrsTZrYULRoyma4VCmnw417Udx+GEXF0jqsnwK1ekHDAfDPHPD8ESz/8CUMnie+R3+CQwHUk98JI35S9M3LwDiEYnJg9KkxTKswlX9H/sN8l4Voa2vTZExTTi06yb8D1tFt06DEd5JEKBQKvj96xqeT5/G88zDOeo8bd+MQir8KXQM9qg9sxrU1J9jdfyVdNg3HqVKM1vD76y44NHFK1mP+jKgoOdeOveLfJTd5+9RDZd2n195xCMXUgIGhLmGh0rO6NIGurjat/ixEqz/F7xwVJef0gXesnnOX96/8UuSY6QUjR45k5MiReHl5cezYMWbOnMmLFy9o1KgRrVq1olatWugmEkQnifssX748ffr04c6dO/GW8ff3Z+PGjRQrVoxDhxL3qi9YsCCPHj3i1q1bDBgwgO7du/P8+XPl+vhSqhNCYmUmTJiAv7+/8vPli5gButBnrEq54mNHUHX9SnI2baRclquFSM0JeP2GsO8JRyKkV+ibxpCmkWGqs2uxf7fwoKTpFqRXVO4gOn+nV10i6sdM+Z/z29BjYWslmQhgnd0CU2sxG/3ihrRorfQGm8J5lf+3P7NJSSYCFGgqBv8u+/9L9XolJ/J3/xPH9m2ovf8fslQsj9YPOYbweJ7P/0dRYz0bkR4Z4eWRSMmMg+jrqG+U8vprpeqJDsaTS68ZVGw2PR2n8P7+R0n7mFNeKKSX61iVYo1KJ1I6LhQKBcsbzQTgjzX9JG+fXKjYqCAHvkzAxCImwmfRmZ4pQibe/++tkkycdfBPtFPB8S4l0b3pKQDmrKmeYDmFQsG500KQPTOSifG1wTs3CtfnTt3ypGZ1Uhz924jrPm9rozjrIn/0RXI4SZdcyGh4fvMjQJyoxPQCmUzOf6c+ExERf/RvoYJi/DNpUi7s7TWfWFq7WUSB1aiafBIXqQnnu3K+/ojT6N9FM2Lw1ZtwwiPEs55WZGJqYtMmNyWZOG16booWTXnieOVscQ+27RNKjnJB1OollisU0GUijFgcU/b4Fbj9FD64RpOJCcPYSAvHXDpULKtP80aG9O5mwqRRZqzaVJb9J6py9V5dXn1tikdwKzxDWuMZ0poGTTSXc5ACAxNDSjUT/aYTC4QmeI2/RGDTp/vvCPKWLrsTHwK+fefGqoNsqDWYddUHsr7GIO5OW6hCJhpls6Nw7y7U27WOQj06J9uxY6PSX/UB+PbkA75fRQTj4HNzATg4YkOyj2UiwmSc3nqPniX/pqXdLOpZL2DGX0dUyMQmXUuy80E/9r8YnKzHjg8mZqpR9/mLiv5QQm10ckFHR5tmHfNz+skf3Pfq/es7TKemLLGRJUsWevXqxfHjx3n8+DG1atVi69at5M+fP9FtJY3EXrx4wdy5c2nUqBF6enqUK1cOe3t7DA0N8fX15fnz57i4uFCuXDkWLVpE48aNE92nvr4++fIJZr9cuXLcvXuX5cuXK3UT3d3dyZ49poHy9PRURi1my5aNiIgIfH19VaIUPT09qVIlfodiAwMDDAzUdASi5Hg/e4VNMTFLrK2jg4FN3M582bnTuT9xOjf6D6VOBnRPdaxagn5XVrG+5mAebD9Nhd6qepAt5v7FsYnbuLziCA0ndkqjWiY/tLW1aTupCQfnnGJ5182M3NOXLLltyJXXKk7ZOReGMqzMfBb9sTVDRylqxXJd/Jlk19LSAi0tUCgIDwzGwCxjzpqb58+Lef68Ksv0rSyJ8PUjMjgYPRNxXjkaN+Dr6XOEPL2HSQlpodwZHTkHj+X9jDF8Xb+MPJPnp3V1JMPrqxiMFamYU7ns/VMxuqneqqjabZITJWoXYMvHWTw4+5xV/XYDsOKP9QDU6V2DZqMaJuhwuqqriHa3yGZF4/Ftk1SHLd2WA1CwTnHyVk7bSCY9A112vRnDx+ceZHe0xsA4+Z3Trx1xYXFfMSm58HRPCpZNONshvSMoMIJbV0SE1h+9E9asWrZIRDH2GeCY0tVKE1w45QpAtz6qUR2bVr8CoFmbnHG2ycjw9hSj92w542rYPrwhIoRqNc1cJKo6uNwQ2UVFKjumbUXiwenDHxn4R4ycU68hRRkzsyyWP75v3+5OSIhI6RsyNIfG+1UoFMxaIKK6/tmYspqBSUFEJKz+B5rWBnUefXK5gs5DRFTQ/ZOat/W1GogJ+WsXMv+93azpU+7dE6TW2XMlKFky+aP01CGrrTYtG+py9KwMW2st7CwVaGuDsSGULwZ21uJjbgy57MHOCgxjDX91c9nHv/N4oOeYKxnPQHN0nN+JRyce4rzjGg2HN0LPQI8+W/uxscd6ltWblqSsjcjQcF6fvc2zA5fx/RR/ZmPupvXI1aQepjmk/16/gm47x7Cj6yI2tZnFmDvLMbI0oVizCjw7cYfdEw/yx7x2Sd53kF8oJzffZf/fzkSGqyfo/hhRmbYDy2NtlzbjwzxFbHl6+xvhYTIMDHXJX8Sap/c8+fTWn/xFMthka1IIQu20C4AxMTGhXbt2tGvXDpks8ahQSRGK1tbWLF68mG/fvrF27VoKFCjA9+/fefPmDQBdunTh/v37XL9+XSMyUR0UCgXh4eE4OTmRLVs2zp8/r1wXERHBlStXlGRh2bJl0dPTUynj5ubGs2fPEiQUE8L18fMSLWNRID9auuKm+P7gUZKOk9aITTRFRareKAXriVmgJ0dupmqdUgN1eogomnf3PuHvGb9AtZm1Cdnziaiue6dd4i2XEWBfqRQAPm8+xllXf67Qobi+dHcq1ijlka/bHwB8Ohzjbpy7TUsAvI9kvEmAX4WRoyBcQ9+9TuOaJA2HV4u2qP2IasplVw+J5zI1CMVolGlYhC0fZ7HszlgcCouJroubrjKy8CRm1VuEj2vcVKDz6y/z9o4YWA05NTlJx3125iHfnn0GoMOSHkmsffLDsUjWFCETz+54oCQTV1zpl+HJRIAWlQ4DsG5f/UTLLpgtntOZ86SL5WcETB8tNInGTlM1cfD+LvSU9PUzTzTTsd3iWnbspV6798pJ0TbUbJb5SZfoCEUL29QfnE7scpjKJguobLKATcufERUVV+urefs8zFpeWfl980oXClntIFvWG3Tv9oJxY8W1eve+oqRjDxsroosG9DaPoyOYHvD4JSzbCvW6Qa4a4rNiaxShYWIw236gGCP07qSNnY1m9b/qLHRVTU21yZdXukRIRkFwcBTZst5Qkonv3ldMNTIxGqvnGPL1nimPzplweg2cXAX7F8PYv+CvFtCkGlQrA7myqZKJGQ1aWlq0ntYGgDWdhbFZ3goxwQRfH39McHuFQsGH26/ZO3wz66oPZF31gWxuMIJrS/aokIk5yhem8YIB9Luyiv7X1tD/2hqK9O2W6mQiQNaCOTCzswTg6THhUt5oihjf3Dl0n2A/zXURvVz92TjpLC3tZtHSbhZdCixm14IrSjLR1NKQHtPrsef9OI56TuGS/wT6TK+VZmQiQJ7Cwnzl4yuRu5+vsAgAevM8fuO730ga8uTJg5OTU5wPkGi6M/yCy3NyYOLEiTRu3JicOXMSGBjInj17mD9/PmfOnKF+/fosWLCAefPmKcMt586dy+XLl3n16hVmZmKmd8CAAZw4cYJt27ZhbW3N6NGj8fb25v79++joaNYpjXbgyVKmGF4PnpGvXROK/CX0A4Picc6NDAziWg+RdvYrUYppaczy7NAVnJftpWz3xpSPFaVoZhDJ4sojUETJGfLfPAzNEnYbzkjGLABv731kWScRMbT6rXAcVOcsGhYczsCiswH1js+pYcwiBfEJpQd8duNMn8lkKVGQ2otU0/rNDCLZXKs/AL0ur0v0GEkxZpGCxJyq1UHdM6qQy7nUoSug+nxebNcFgHwbjvzS/hNCejRmKZrTnw9zJxHy5gVOUxZgnCfh8PWkGLNIhRT3uJZ24vmLMfyAniX/xtstkEPfJqGjG/c3l2q+kRRjFv8wHS5suMLJpWdVlv+5sAPlWpbm1Y23rO0hXNQXPppBoEIzl+3YCPYJYmldYRw1+vIsjCziv/YpacwSDakmJRESn4fjq6+xY7YwWFp/ZzDZHONGkMdGUlyeU9uY5btnKOVzCN3iDxF945Q3DotxeT5/xpM/O9yjXAVLTl6If2I0wkhaallSjFmkQIoxSzYdkcbuJeuisjyL7r9ql6cWUsKYpaDBGgAe+fbByFiPMLlqClfzYtv4/M6PewFD0NOL22f9GCitzUgtYxYpiG5j2mcX2uX73aap/P8zpD5vmjzPz+640qf2P3GWD5lQkqETS2Fo+JN5hkLBkT3vGdb9MrFHSdu2FaJR48QjY6KNWULD5OQtISaDvr12jLd8ShmznLscTo+hgVSvpMekvpEUiUfq7dlrmL0GbjyIf19fbiV8b+lmjSF3sjsJE8Bn9/NjYx3/M6Jtk7I6cJIhwZjl6ZNA6tUW5lJlyphy6rRmLtfJacyitvx3ac6/SYtSlEaqyw2kOdT+bMwSG+OLinHM+PMTsLS3wt/dj3l1RSpw7ChFX1dv7u29zp3d15DL1I+1ze1tKdauFgUbV8bANOEx3ScfaX3E8MikuzzHRmRYBH/XEJI5o24uQ1tHm/fXXTg4YgMAf79SHwjl9tqd8+sv8+DEY7Xr7fNY0354NWq0LYaumncPSHd5ltrfg4SNWXatus+ysZeYsbkJTToX4ca5DwxrdZCBE8sxbJpmTuNSDBoBtSYuQQERlM2y6Zdcnt9+qIaZubT+amCAjHxOzinu8gyoyA2GhYWxd+9eDA0N1XqOqEPKi08lAA8PD7p27YqbmxsWFhaUKFFCSSYCjB07ltDQUAYOHIivry8VK1bk3LlzSjIRYNmyZejq6tKhQwdCQ0OpW7cu27Zt05hMjI2yYwdwptMg3h44RYFOLQkj/sZDz8yULBXL43X7Lg9nzqP01AmSj5caZKK9efwvx7LtquC8bC/3t5+mev8mKvtvt6g7+0du5eryQ7SYEb8+hIm+dHHUlCYTE0O+co7K/9/d/0TpKuqjX/TM9ShYMTevbn/i+v671OoUI8DtGmAkySHMXSL5GBiuJ8lBNqG6WBcSnV+vJ69UyOXo62BqZ0GQpz86/m5YZI+/oyyVOHb1N5Z0rSOjtDE0lfZMeAUZJkrIqVtvoheOlgZthG+wvqTnNDxSR9J9kRQy8a27tAFm0ZwiXdih33DejO7Hl1ULKLh0U7zl25T6KKlT4GQVLJlENTOQJanjESmPuWbebiIiIEpLl6ifLpGtcYQkp9APvglPmqhDQLguWlpQv18t6verxdfn31jafjVymZx/xu7jn7H7lGUnnRtFuLYJ+mh+b0TfR7N+kIldlnXFNosBoL7NdTDXQBTpJ6Q0sSYVW2ZcZOfS2wAcfzsI2+wmQPx1DJNpS+7wmupJe+aMtaWRJzZ6cSPfaxfeA8Chiw3juF1q+X1S+f5nh3sA7NpTNN7BbYR5XrXL40NKk4nG2uFEyjXrTgYFiutpYalPlFbMNo/vCxK2dScnleXR0FFIu87q9pEQQqOS3wlbJot5XtSRiQCf3/kBpBmZKHVi1MwgUhKJb24gI/Cn8tHfdXS146yT+m4wj+UinRBylczNWZ9JREZEcWn9BZZME8/ZynmPWTlPDLg79SrEhHkVMbcU90LzTgVo3qkAM/ufYOuWb2hrQ+PmiZtpRXl/VP7frL2QOVi+IH5jEEWYNAIIULr6JobIMPHcXLsVSaNbMcuHdYP+HcHkx+Uvlgf2/NDbk0XB7pMway2E/WiuruwARUj8bbFOthi34F0HxORC6eJ6WBkFI4/n1aRj44gi1E+j8wDQ0pV4f+tJfK9LIBPXr/vC1ElCmmLmdAf69MqCIiLx7aWcL0CUjzTTlKjv0t7putlMUYTEn62lDnoFakhy59Y2tpLUfv/7rliC458R+weyrP0a5tefx9+v5hGZxRq7vFnxfOfBrNIjE9x3xU5VqNi5GgbZ1Y374u8bfPI1lTT+DpM4FigfD5kIgKEWtfvX59K68xwauoqemwdQqm4BDv5Y/eXOS4pUy8vr2x85sfoKLtfeqd1NkQo56DyqKuXr5VXjMxG3rlL7VmEybcl9RGv9hPuthYqKCeVPLzzR1ypAyWLimX4rIUIxPpdnddDXUn/OevEslwRtXfGRtM2vH1ZTFCmimkVRpkwZqlatqjGhmIpVjYvNmzfz8eNHwsPD8fT05MKFC0oyEUR48/Tp03FzcyMsLIwrV65QrFgxlX0YGhqycuVKvL29CQkJ4fjx4+TMmTT9HS1tbUqP7APAxX7jEyyrUCjwui3SdnyfPCMqPAmzi2mMhNKeC9UW7k2PjyWPXXp6w9wbQqNzaccNCZYbsELonW0ecyzF65QaiFIzS9dqoVBxPjUt7ux9RoZdWTFb7P/+s3JZtjYdAfC5fiVN6pSW0P9hzCLzzVipAoG+osPhkC/1nBqTghxF7FnqMoeFj2dSpllJ5fLea7uRJXfS6r51gHChdyrnRPEGqe+ol5pYNPiUkkw882UottlTN20spfDpfSBBgWIgUqVmwmTE+3diQKqjAxYWyZ9Knh6wdvFTAKYvLqeyfOualwD0GlwozjYZFatmi/7ThEXJb1iUGWDjYJnqx9TT12HwhDJ8iOjLu7A+KgZJeza/pKTddpz0N9C//Tk8vgXz2sWHrVsEqePqUVPSsTw8Zbx4JZ799q3Tpj1rUkeXr/dMObcJasUK6Fm+Awo3hVx1oG4PuBqrq6+rA11bQOMfP03jGuCkuWQkY6YKYvHgzvT9zk4qGta7ryQTz58pQJ9eWdK4Rv9fyF0ip5IQG15wAlNKjMbzXVzDwXxVCvDnqp7MeLSQWU8WM+vJYppNbEMWJ7vUrvIvo87AhgB8uPsOv28+yOVyus4WmYVLum6nl9NUFnTaokImlqpXiEmH+7Ll4ywh1XOmOxXq50vU2DY9IV8RkfL87oUYt2TLIdrR3ynPKQu5XM69e/dwdXXVeJs0jVBMj8hZpyoPl24kzNuXwPcfMcvjqLbc5U7dVb7fGTWeyqukC8KmNWqPas+lJfu5s+0slfs0VVmna6CLLFxGqH9wgml2GREWdubkKZOL9w8+c3bLLRr2rBSnjL9XEMMrxlzTE2udaTagWpxyGQEV+rbgzoZjvDx+naKta6isy14kNwBfH6mf1cqoKNKjPZ73n/B82z4qzxwNQJaGTXE/tBe3/buwqVEnjWuY+rCoWB3/29cIfHQXs1IZw5jmzBZBMrUeGvPsRf2I/LHOLj2FOKWhb6hHtyWd6LakEwqFIsmdt5dXX/DqqiBZ+m7rn5xVTHeY0uUgzieE1tx/HiMwNpUeaZWSKGq4Uvl/xVo5aNGlEPVb5Y3jQKgOFfMLLciLD5snUhLq1hZRU5euZoxnMylYMfcRAB26qUZZ7tkmHJ7LVso8g/O180Q6ZLfBmqVCZmZET2Zmz5eF8FAxAZ8WhGJsaGtr8UfvwkqTpDOHPzCyxyVCQ2ScPfqRs0c/KstevFpOsst86WpCyuDonsSjGlMahfLAjh9+bFFRcOAczFwDgcHw5hP8OS6mbKcm0KERHL4gvq+Lm5UeL2YvFmRih1ZGGOhnHOJCEwQFysjr6Kz8/v5zdYy0ks9d+Dc0x6wbE5lceY7yu5WDNeXaVaJc24oYW2au8Wo0+u0ayvo/VrCk0Vy166t1KEOT/tXJlifzEPk2WX9EJLqICM7o/vSH135pVaWkQ0tHfCRtk3qqhDo6OipjFkNDQzZsSDjoKjbSNEIxvaLuxoUA3B07Se362yPGoYiKQsfQUKnPFuruQbCrtND09IASbcQg/faWMyrLQ/yCkYWLqMUdfdaker1SA8P/FTbw/0w7jVyuGqbt5xnI4DKLAOg0SUTN7p17njSUHP0llOggyLMbqw7GWffkaIz5jsfrr3HWZ1SYO4pIZa8Hz5TLtA1Ffo/M3y8tqpTmyN5VRGB/Xp64+VR6waEVogNftVVMdPoz5w9iWctiardJL0gqmRgWGMq2AVsBmHh5coaaUZaKIQ13KsnEKz6j0h2ZCFCmSoxe4e3LX5nU5wIVsqynqOFKihqupEauTSye4Myrp6ppS88excyiFymRsO5aUKCMkGDxHipYKHMOiGJDR0d99zOz3Ot+PjEpqfERUT5eIiK1XA0J4V8ZFJ+eidTfghUd8XEVpJO1vUVaVikOGrV24rlfTz5E9GX3hWY45BbRMP0H5qBoUWkRhk9cYlJCy5eRpiWd0tDRgY6NweU4fL4Id/YJEjEae05Bm6Hi/+NrQNNHMipKwdotIt156RzL5K10GuPxo0AlmVihojke3rUwMUl786j/rsvx9c+Y45Jfgam1KX+/EinPs54sZuTpidToVSfTkokAOYrlIneZGM3Rxv2rs+zuOGUEYs+FrTMVmQgx/QHXj9LS8tMltLVjnJ41/qQeTRcYGEhQUBCBgYF4eXmxdOlSvL29E9/wB35HKKqBSXY7LAvkwe/1ez4fPUmuljGRe08WLCX4iyBdauwUOmSlp0/i4fQ53B425pcMWtICcdKeDeHp6fscmRhzHp5v3NKiaikOHT0dGg+uzelVl1jRdy/DNwmtSD+PQIaUE2Iyf0xtSOM+VfD85MvFf+6xd955Ok1skJbVThJ0DcQgPSoiRgNEoVCwpeM8fD7GpAocG7+VPoempHr9UhoKuZzvT17wePIi5bKo8DB0DNJXRz+loWMSMyj6lei51IQsQkS2xBaNvn5UkMTpnVBMKuZUFc9gu9kdMM+SskLMaYk/S6/D9b0QqL/gPQ79dOpAufNiO+X/Hq5BnNz7mmP/vuSNi+hseXuGsnXZQ7Yue6h2+9tv2yR6jG5/int6647Ucy1Pbbg8Er9XrYaqBFq01qCpWeZJ85468DIAG442jbeM89mPANRqmvkcnsOCwnlywYVHxx/w3Dkm+yFPqRx4u/oBYJPOCMXYqFTDHuc3wk3VOPC15O0btRb95juX0j9ZnM0WFo4WH4Ard2H2OmhUDUpKUCDoOURMoEwaZZYh+haaYs2qz8yYJozq5s7PR68+aXNNg0MUFKoTybKpOrRrIvpDf40SgR+JGeb8RuZA722DlP8nRTf7N34jPhgbG6v8369fPypWrMjQoUM12v53hGI8qLZwIgBvd+5CLpP9+H833++KFJbae3eipaVFVFgYD6eLsOtC/XunTWV/EbVGisHS7a1nWNt2gZJMbLuwG/omYoQX4itdNDojoNnwegDcP/uSYL9QFTLxz+mNaNxHuGwWryms8U6uvZ42FU0G2OQXnaAgDx8C3LxZXHG4kkwcdmkBAH5fExAGzoDI374ZACfb9eNmNJn4w4zl+/nTaVWtNIVN41YA+F46k3DBdICIH4LyZlaqxgHXjwjyJU9JaU63GQEHJu4GwC6PHeVal0ukdMZFE4clSjLxP9/xap260yOyOpjSc2QZjtz/A5ewIbiEDeFx0CDWHW1Okw4F4pTPktWQ3E4Jp+bL5QquO/sB0KRp5kn5/Rlzxt8BYNJ81ZTus8eEi2l61E+MikqaEdHZw4KAqNkod7xlrpwUZWo1yxyEou83P4YXnMDwghMYX3Y6u8btVyETAYrWyIf3tx8Rimmc8pxSOHFGROnlcNAhh0PGi9uoWR7Ob4ZRPTTfJihYzoXLIipzYK/UlyIJDpKR1eYyJYveIDIyeczDFAoF9WrfU5KJF6+WSzMyEeBHXAAjZsZooUd7C37z+P+LUvyN38hI0NLWTdIntfDp0yfl5/379+zfvx8fH821KjNGDz4NoK2rS7E+Ynby3gQhIPL56AkAav67FS0dbeRRUVz5Uxha5G7TEvt6tSUdQ6qlPEBgmLQZ/G8BibuclWwrlJfvbD3L9/eCYBp9ZTZF6pei3aK/ADg9/5DabYMjpN/sgeHpKwphwMauAAyvtFRJJnad2ZiGvSoDcO/0C5b3ES6d8y6I2SGpM0PZJJaX6oStictulUHCYObslI3s6iAioIo2rcCYO8vRNzEkXw1h+vDxziu12wdIvPccLDR3zIOEnarjQxbThJ0OtfXE/Sn/EZnZYOdySmwU5jNu+3cnun8riS64Up3bgyT+pgD5sknT7HH5ohoFYtdaROK67dyotvyhR46S9v/BV3qKyc/OnvHh0h4R8dVmWHWV5dFEY3xREN8lup06WUm7V0G6A54mz/SHe+94fEJMWg0+PEbS/qW6tQJ4Bkv7nZLizP0zFAoFtS3mERoUgbaOFhf9xitTQqU4cwMY6kpvM4IipT1zmjgk6+pqU72hI4t2NMQlbAjuUd1xj+rOc8+OPHHtkOC2CsvczJklBqwjRsVPPsWGfoA0vVupTtVSoamL9LX/hCxMoWLWKq7Qm1cLrdBu/QrGu61U12aprtA/u28DdGt6inxGm3DS36D2U9BgTZxPIcM1VMy+GYC8haxU9meorfo+uXJKSDfkzGOptk6OZtLaehtj6eaAUvsyCfXfQgNi9mVfMBstxjZm+tXxbPk4C30jsZ1VVnO8v/mJ+qqJUNT03RANKY7T0XgdJI20DzGLO1GQEPoO9QLg4nF1TrJxoWUo3bBFS19adoW2ecqawtRv4Q7Ahr+tEikZg9hu2JpAIYv//jYxFfeBu3sEObJd5dJFH0muzYCKK3RggIxstld4+kQEU3z4Ul1t2ru2saWkQ2gZSSuvY22v/F9XV4voy/jxqyAQj2wU5911hGjvdGylvdNl7tKDRSJfX5VUXh7iK6l8l7zPEi8UC1LHSwDmEhybAXJbSfudDCWOBe5+lp6qLLXP5xogrc2Q2rYmpT/mEyHtHMLkKRuJG6FIQQJPcrrzj08qoXz58pQrV47y5ctTrVo1/v77bzZv3qzx9hlv6iwFERmlDbEGTHYNm8LGXQR9+EiIm7tKOrNCoeByx24AZK1elbx/JDxoUAep5AMgybYeNGsEr2+JidQq1bIcbWd1+vFNzuv/HgHw/NwjOi/+M862SSGBktL4pySqNMrHWiAsOIKuM5uQPY+NMiLx7qnnrOi3F4D5/w3CoYBwB5PakHsHG0j6rSKjtCX9Tprsu2AlR44DXi8+AdBzywCcyuUFIgkNCOHtVeG++eHyA0rUiBsxIfW6eYcYJEr4xUZgmB6GutKeCa9gw3ifiYvjluF2/7nye5cLG/nkbYp59PtIIcc0kXPyDTHA1FDzgWl4pLak62ygJ/35eetuJmm7wg7+Kt+/7Nik/F9dXZsX/xxnWULIZhZKqEQiyNxAFoc8UigUBPmF4vXJF49PPnh+8uHAoosA1OtaVvL+pZBfb30Sn3hRBynXOjBcL8HykWGRbOm5FoCxZ8djLuG+g6SRonYSCfNfJaaiouSUMV0BQJbsJlx43weIaSN0taQ9/zKFDsYS+5fmOtJ/JykwkXnBj5/J1hSISPg3lgd6sGqFiNAbO8Y+wUGzErb50UPz+8NfJo30lykS7sRePfORz+/8CfALJ8AvnFC/YAL8wwnwi8DfNwJ/P/F/tLu1Ouhpx9T/xmVBRjjkTLieUklFKQiNikuKzllVjVG9LvPdIxRvr1AC/BK/NgoF+PmIG2Dl3kYq62QKHZV7PDJaziGe+/5tgKWGtRfwljiRAtL7Mno6csJk6u8P63w5mO+yUGWZmUEkoTKICBX3QqhMG6+vQg/LJJt1nHeHka5cEqloZiCTPPAtYuWjMQkOYBvxToVsSghLF7wBoFEDU8ysNHvu5IFeGtdFuU2INE0xuQb3bmxI4eO/ecHnH8pITapFogjRrK+oY5MThQSyScvYSqV9DA6O4sH9QKrXsATA3aMKfy/7yvz5n+nU/gn58xtz5Xp5dHQ0S7+O3vfDh4E0biT6w1WqmHPocDEgCoUs7nMqpf4AikhpBH6Uj6o2/4F1ujT4U0bnwZHcPKJPqSLi+Xn9XoFCoSDqs7R+uk52kIdII8v0C1ZBEeqncXktI0tJpOJJn8qSJmwDwnUlj0/CZDrYmGjen3njZS75GFLKF88u7T4C6RNIOcw1H48BmOpJO1+ZQkcyqSilP1bS6G/MzGMmtPS1pPWRNUF872KpfdOMCE9Pz1/a/jehmAgqLJ7HndETuDVklAqheKmDiGozz5eXosMGplX1fgmy8EiWVR+tsszKXgjHhwaEMrdajJbesGPjyMxY4jyMUdWWs3PqKXZ+mQHAnZMurOy/D1AlEzMifD97sqldjCPasCsLsbUSHZEXl1zYNUwYQOQolpMWU9qmSR2TG04NqqClo4Pvh6+EevkS7h9EhJ+MO/0GpHXV0gRR4WE87RMzKVB40coESicvbuy7x9m1V/j+RfPw+dgwjMUahYWITlSuwhn3eVSHKWWFCVizcc2xzmENZK4OTGREFOUsxD1XqFQW9t7sksY1Sh84dkzITNSqZZkhdMfOHnzDyC5Jl0vYsK9uMtYmZZHTyZx9F1vEuz5FoxkyAXy/+XL99D3uHn2kstznh4aiVfb0q6GYFMjlChbMEYTipjXpXzsxuVDlR2r08W3So+R/BTNmfGTHdpFV9fRZObJk0Wf4iBx06WJH8eL3ePMmBHu7Kxw+VooqVS012ufKlV+ZM1tMqi5YmIfu3dPeoTs2CucT/fav7uJ+09bWon8Xbdb9K2fdP3L61EjjCqYwHl98Ra6i2bHKmnm1pX9DFbuvtadz9f0ABAbEkJxO+sKBuFo9B3oNLU6NBjnjNUBLF0hKxKF28sg3JITw8HAMDBKeYNOkzO/eUCIwdcyFoV0Wwjy9+PbfZezr1uLW0NGgUKBrbEy5+TPTuopJwuf7b9g7YBUAekb6DD4/l2XVRnNp7Tns8mZl7+idANjlzcrgQ6MzxEDnV2CX25pseWxwf++N88HH6BnosmrADzLx4mAc8mdcXas7O//jyspjANjkyYb3e3e+3H+Lbb0CbO+/kbc3RIpzu3l/ULJpmbSsarLCqW5FnOpW5PPV+1ybuY7zoxbh/1HM9uqamVF+deoRammNoJcuvJ0rpBv0bGwpsmSNiiFTSuPfiYcTXK+jq41dbmvsclthl8uKLLmssMslvmfPq5oKcv+cEMjPTIYsx+eL59PEyoRq3aonUjrjITQkkko2qwGoUj83a4+1TuMapR/07SPu581b4k/3TU9o2DY/y3W1CQ+LwtzKAHMLA7Jby7GwMsDcUh8DA2kdZj9fESVSuLjmqZKZAQqFSFk0t0qnTkQSIIuQ8cr5FQ+PPeDZ+afxlqvYujQAPj9SnvUN05f8za+iT3ch0TF6uK3GUXEZHc/exvxfuljquh7PnZuHa1f9+fAhjOLF7jFpUi6GDM1BFjt93D2qMGfuV1Yu/0zrFo8oXcaMU2fLxEs4KBQKatZ4yKtXIoLw0uWSFC6cPh2DR/XRYcnGKP7eHMXIPrqMH6jDun/lzF0dlekIxdPrnanWvjRm1uJaLO8pJIs2f5iZ6cel0Xh46glZ89phXzB9kduphRLls+ESNgQAvahQDv/7mnF9Y9LunS+44nzBVfndxFSPnkOL07V/EbJkS1r2UYognRKK27dv59KlS/Tv35/q1aujHWts6O7uzp49e/jnn3+4d+9egvv5TShqgIrLFnKlSw9ert2I1+27hHwTsf3Vt29I45olDUfGbebNpScA1BrWivJdVLUfo8nEzEYwJYY5ZwbQq8Bs1g+P0YtceHlIHEIjo0AeJWdVg4mEB4oOUpfNI7Cwt2ZN4yn8t+QQh0bGGLCMuzQNU5vUF9JODRjaiCiIaDKx2JTJWBbLvE6qP+PzxtX4XLsEgMOfPcnSoEmq12HVm9kqnT+p+oMQ81J1/mHIUrVV5iAUv7p85fpOZwAmXcl8DuuB/uFUyyZSuZt2LsTcLY0S2eL/B8+fCTkCCwsdTExSdzD+K6jXMq/K919JI9+zTTASvQalP0OWlMSrpz8iU5s4pXFNpCHIO4ibe27w8PgDfBKJOC9UsxBV2pSkeJ1C6BvFRJlHE4qZCcFBMk4cFan7o4Zl3AloqWg2XPy9dTz1B+66ulrcvFWG8+d96PrnS+bM+cycOZ95+aoClpa6TJ6ahx697ClT4hYPHwSSPcsVTp0tQ9lyqtFtAQEy8js5K79/+FgRI6P02x4P7aHNko1RLNssZ2Qf0NHRwsYKvH3h3TfIa5/4PjIK9s87y/55Z9nycRYA1TqUwXnfA7ZPPMZf81qmce1SBo/PPiNfBSdMfkgmbB8h9N4XP52Frv7/N22jp6dNh78K0eGvmP7Cp3cBbFv9jG2rxNggOCiSlXMfsHLuA2WZqnUc6Dm0OLUapfMoxjRA3759yZcvH/Pnz6dVq1bkyZMHQ0NDPDw8CA8Pp3fv3ly6dCnR/fx/35kaQsdAH8e2rfh48AjeDx4BUHvfzgw5O7Kl41y8P4gUgX7HpmGeTaQ4+/7k7jvh6gyMLdPn7FxKQd9Ij6LV8uDiLATyF14ZQvY8GZNMBFhSeYTy/xHXFqNrEBMN4O8qrrdT+bz03Jw5U4CjIiI53mMKwR7eymVV9+zKkM9tUqAIDyVieotoOTcKL1mNQZasaVKX5PzN750VEbVZc2f8iCZZhIxVHYSm4Iijo9DWSXuftE1znNk89zpFy2dn7bku6OmrH1hNH3CeLoNKk79Y/G2kt2cIdXKLibcug0oxdnGtlKhyhkWtCkIj9Ny5kmlck7TD5lXCkKVNl8zhdKwpLp0Qhiy1m2UsQnF2jbhZOZb2VpRpXobSzUuTxUlVikKdjphCnvkcaWtXEYTUxu2lia0Lm5lx/rb4m90WcmRPu3dX/frWfP5SiTKl7/P9eySFCt5h9hwn+vTPjYODIR7etZgw9jVbNn+jScMH1Khpxb6DJdDS0uLeXX+aNhKRpTVqWLBvf/qfbNbW1iKXPXz+Bi/eyCmcX5v9a/So0zmSzjPgzvq0rmHyIXu+LLi99eLK7nvU7FyOHgta4bzvAVd336PjxIYYmUkzGskI2DpUyKv9/WoeAG2ntuDgzGPMb7qMyeelmfX9PyB3XnOmLa3CtKVVAIiMlHP28Ac2r3jKoztCF/D6RVeuX4yJYjQ00qHn0OJ0H1gMu+ypMxmSFNdmLe3UeVfWqVOHOnXqEBgYyLNnzwgNDSVHjhwUKKC5IVnaj14yCHRNYm64yquWpmq6YHKidPsaFGlcjtG3/1aSibe2nWdTm1kq5f7fyESAG4efKMlEAKtsGVujo3iLSlTp3Ygxd5aja6CHQqHg395/K9e3m9c505KJb05cYU+TgUoyMVvZIgAEvX+f0GaZBvK3D4iYLrS/9LNmo+S2fWlGJv5G/JhabjIAdQfWI2u+9HF9mnUrAYDLXTdqWC3m77H/xSkTEhTB4W0utCv/DxVtVuHnHVdo3u1zgJJMHDCl0m8y8Sf4+sQIqud2zHyDIk3x5aMwBDA2/v+a3778w+G5ar1caVwTaRh2aARdlnVl1oM5zHdZyHyXhYw/P4EGQxvGIRP/X/D1SyifPooo3Rats6dxbVIPfX4MG86tSdt6AOjra/PMpTwbN4kB8ORJH8hqc5mgQJENMW9hAW7frwjA1Su+ZLO9woB+z5Vk4uJlBTIEmRiNXStFgECbfuL88juJSVsvP4hK+SzJVMP0E2KMsn3CUeRyOVpaWgxc0xGAsdWXpmXVUgxFagn5k8NzTwBQvUtlAL5/9uHzky9pVq+0gJd7sNr+ZULQ09OmWYe8HHZuxYeIvnyI6MvVV53oNay4skxYaBRrFjyiYu5/cNLfgJP+BjrXP875E5+Rp9CEl0JLG4WWjsRP6nJNZmZmVK5cmTp16kgiE+E3oZggol2Y3Z1v8HbHLuXym4NHJsv+wyOlh9QHhknTnPnka6ryvXS7ajSd0RUtLS1kETIWVRjGtTWi0fpj03BluahIzQwBIiU4qUYjMDx96eYEhOty/dBj1g49CMAfUxoCMKHe6ni3cTCX1sBJcRMD6e7Z6q5Do8mdqdq3MQBB3/1ZXHE43558UK53feMdZ5uEIPW62RhLO2epDuYAWUxUIwFCvvvyb70+3Plb6KyUG9yZLhc2Um6QcC5337dT0v6tJJ6DVNfm8Ejpz0++bIEJro/cM5fIzcJESbfVMLSG75Q0AXL8qbQBrnugdCF2qa6cPztCJ/f+81mnrPMvxI3UubDmPPIfPf/6gxrEKR+fk2p8+OArfZbVMziuK2y2nObcDB7H6GX1Adi7+h6VTRZwZreL0hnV2FSfEy5/iXqGyKiZYz19Gh9EJhPn8+GVD40KbgFg3JJa9J9YSaP6JOYu/DOS4rwXEJWys9HBupqlO3ZscR2AvceqSD/I9zeSilvoBksqL/V3TcpvGilPXwSikY50B3OpLpOxf9dn90TkhIlZ/M7M+cz9JO1fqusnSO/L2OZzoHiD4ugZaNYfkNpv+Nn1OfH9S7+PnvtaSyr/XT9vguvLFhXpYGcvi2dZ20Za1Km2mfQUaW1jaRPe2pbSHMATM1TffFT8rV4azIxB5i7NKRggylsaOaKJo3Lz5rZ8/FQJQ0NxH+V1dGb3v0KmytHRCA/vWnTsJCbvDh0Qz+DV6+Xp2s0eLV3pLulaxtIyJbT0pPWXdKzV5y/ndhAEYlAIRMoEATJugHh/Lt6j+f6j3CRVB4CIVzcklZfiCA3Q1Pqm8n89Qz2aDa4JwKq+YhxeromQuwn2C+XTs29JkNABQ11p77j8WaS5qkvFU7eY+6jPuu4AXNl+nWA/0TedenEsAEvbx7D33iHS7tevAdImLoMipbXdKdEfq+W4haoOm5Tf37wP59nD7wlsoR45ncyZvKiykmB8E9Kb1bvrUbZyzET+rStu9Gx9ntwGW8ipt5l8ptuYP+kubq7S+k//r9BSRCtD/x8jICAACwsL6u1ej55xTGMfHqlDwJt33JswFYAqa5dza/hY5OHhFB87giwVyv3ScaMJSymwlkhM2ZurHyg/PnKDc3P3AqClo82Iq4vQ0dPl2f7/OL3oGHUGNaR2v/qJ7l8q8QXqU2BSAz7f/Lix7x5Nh9VVScF8cuK+Ujdx8bVhZHW0pmtOYWCx6OpQsjnZxNmXa4C0ToF3cMoKr5vHQ8ZFhEZwaPIeXM4LzcxCtYrSeVl3ppUWL6fokHqNjiHxpe0p8ZyTQk5H/64KhYKzM3bw8qwQjdU3MaTLjnFY2MekY/5dWYj6Nj66Q+P9fw+S9gKWeg5JeX6eu6p3xoxwPkLksbXK70YTdqJtZUf+RAjIn9G8+GdJ5aUSxyD9vKPvPf/vQQwuvYhClRyZtL8Hh5ZeQiFX0HZ0HbXlNYXUjlZSEPvecH/nyfwmy4D4dXHiO4fXdz/x/YsvVdqUUlnuZCWdFLUzSHgQqFAomNz3P47sfKFcdvRma0qUjRkAX7vwlW5NTim/N2zpyNmjHwFYvLkWbbtqPssZX4f00V0v+nb4j9vvO6q03VIJSABT7ZTtHMr9XRMtExWlwN7uCgDuHuoJxeDgKCpWeMClSyXJYvfTwME2v6Q6+cukZRxI/V2NtaW3AbpaUbx75UetYgep3zwXWw6J/kbrGscZO7sclWuoRnrpaUsfNEqB1N8Iknb/RaOooTAFcwkbwqxhl8lT0IouA1VT398GWEraZ1LaMakTQvoS2251bf34oqL/8efybhSrp6qFK7V/aKQr/R1a3M5fUvncvIt33d3b3jStLQwCPEOE2VSUx0u1Zd+8C+f6jWD+6qpKaMoDvSTVB0AeIo3giPoujWxWJPBIKxSQp534/80+0NUBnXg4UR8/+PcY9P8D9H56zelYSpMUkkq8HjgZyZDBQqNVWxvevqtIZKSCggXuKMvEJh8VEUmYWJTF/aH8/KOYNdeDCWPssLVVPWl5qLR7L+r7t3jXbTsIU5fDX21g5nBxXXIL7o33Gs6d6zpIqg5RUfBNJy+v3oTz6nU4r9+G8/p1OK/ehCOTwcXTThQupNoOSSVdz0c0jLMseky26uEYLGxN8fzsy6iqfwMo9RWlQOrExUcf1eCcAA9f7u+5wqMDzrRe3BvHiqoawFLHAiWy+6l8f/TfK1b0EoER0ee3ovc/PLrwinp/VeKP6U0lTyDZmUgr/7M2skwm58TuV6yaeZuuQ0rSfWhplfXRE85SkFjfIfZ7Mvb3L5G9JB8rMXz9FMiOtS6sX/Y83ihFf39/zM2lTeZEc0xvfDtjZi6NBA4MiCC/1e4kHTe18TtCMRYiA+MOrnyfPQegwuJ5GGaxpdoG4Yz8dOEyMioX++3ZRyWZWG1AU0bfXIbOjzd9pT+qAXBx9dk0q19K4d29T5xedYnNQ1Sn734mEwHmnhsIwJgaK1K3ksmMi2vOKsnErqt70WVFj3Sh05bc2NN7iZJMbLd6KBHBYfzzp3qyVJGZ8kF+QO7xSUkmamXNjfGCM2hbZb70szsnXACo/MPh+fCyyxxZfiUtqyQZ8ii5kkwcuX+gJJHtKFkU89tvYtPIgylVPRVoaWkxZ2M97vn0x6mAJQAtKx/GSX8DXu6is1m9Xg4+RPRl4gIRhRhNJq4/0EASmRgfwsOjaF7lGG5fgzON/umk8SLCcMq0+HUDR418x/fvkbx+Iy2CLCNh+1pBVPcYJCQpFAoF9256Mm34rbSsVqpjz/qnzB15NfGCmQz/DNN8ci+9IppMfPI2cbOpGvXeM2GqR0pXKcUx+YcfZY+mgkxMCPX/gkWbICgNgnzat7fj3XuR5iyXQx6n20oysU5dS9w9qijJxOTCp88RFC71ml37/PH2lR40IgXd24i/2374SGppQZ4f8zBPP6jf5mfI5fDZDS7chDW7Yfg8aNIP8jeEXHXifpzqQ9U67+jZ7ysLlnhx+GgALi8EmQjg7ZMy5zx+j4jaG1x6EQB2uazIXUyc7IVtKfu+UCgUfLj5gr2DVrOowjAWVRjG+ubTuffvJWThkXx7+jHZj1mqbkHl/w/PiffkkI1dAHG+QX4pn1Ujlys4e/ANzUrspKjhSkqarmZSnwu4fQnk6D/qJ00yMnLkNmPawnJ8i+yGe1R3XCO6suVALSpWS56xlFyhlaRPRkH6yjlJY1wfMYX6u9apLMvdujm5WzdXftc1Mca+fh2+nb/Ii5XrKDI042nQmWezQs9Qn8iwiDhuR7HJpqjIKHT00q/TmVSUb1GSbSP38fDMM/zc/bHMJiK9lt0agbm1CfpGMeHdOQtnxcTCiGD/UB6ce0mZBhnTgbJwnWJc3y4IlwLVCyuX569WiDfOL/n64hs5Cmd8S7iaw9rw6dYLKvVpoiQdIkNVZ+Mq9mrM7c2n+XrpGjnr1UyLaqYYwnYIoXy9hn+hX7dzGtcm5XDrmHBxK9+kSBrXJH4MyjcJgKK1CtBlXhsssqi6p0+vOR+AGl2rkKtETkn7XtFbiHV3mJS6TslGxnqceNIV36/eVMsn0o4q5PqHkuWzsO9SC/T1dchXyFJZfvmOOjRo4Zgsxy5iLUiH8XN+LSMgPWHrFhF1MmhITohSH5F15IhI66laVX1EcmbA1tViwrZaHfEO8nQX5GkOR9N4t8kMCA0R17xQyYxr+pZciAyP1Dh9Or1h/24RzV+oiBnZ7BOO9Hz5Ssiz2Nhk7D51RCTsOif+n9Ij8bJeP4zArdKoGTMx0cHdowo7drgzdozQ0F66LC9//JH8msX3H4bSrM1HAGZNzUrB/CmbmaSlBcULwtNXcPcplC8O28dC9RHQcipM7AyvXeHNV3jjCiHSA8lVoKsDBRyhYDFzCuY3EJ8CBuTKqYeOTsoSH0Wrxky+Pb/xgSJVnJh+tDc98s5i1/ST1OlaIdmCJUICQrm+5y4XNjkT5KOeCc9RKi/lu9Yhb9UiKeapsOrxRAaXnMvKvrvY9H4G2traDNvyJ8t7/sPQUvM46jklWY+nUCi4cfY9G2Ze4/Vj9RMfg6dW5M9BJTGzSNl7Oz445Tfnw5sAFApFik8w6+ho06R1bpq0zq2MFPyN+PGbUIwFWXAIQV/dMM2RsKhyoX69+Hb+Iu5Xncnf40/0zMwSLJ/eYGprwdCL81lSZSRXV5+gYnfV1ObGY1pwetExrm65qFHac0bCyL19WdpxA5OqLWT12zkA2DpYqi279MZw+hWdx7Jeu9n5ZUYq1jL5kLu0ei2fhiOa8sb5JccWnmbg1uQPHU9t2JfIg32JmA5H9mJOuD37gO8XT6xyitmlsp3rcHvzaV5t3ZPpCEWF11eATE0mAry+KwZwZtapbxrl/dWXqbUWA9B9cXvKtyyptkNTtmlx7p98isvl10ysLMjDim1K03pSC24fuk+Al0hBbzO5eZxtE0JoUDhPL4vItkZ9qv7KqSQZDrlM+RDRl9vX3OhU9ziP73pR0HQzpSva8fC20KM6fL0Vpconz4zuhmVPiYgQEcWDxmYOJ+Q9u4RoVbPmtmhpaaEuz+H9e0GsOf6fmLVEP0ef34tnI5dTxupTScWtS6K9rtUk5v2sp5/5MgcSgraONvIoOZ8ffSJvxXxpXZ0kYVCv+wCcuVor0bJNfxBNxw84plyFUgF//ugKz+ojCK2EMF4EkzFvdMrWSRN065aNzp3tiIhQYGKS/KTuiVMB9Bkk5C62bchBw/qp04ZtmQfl20DbQXHXzdWA/yjgGPfj6JBw5Kmek8Q86WTCqodjGFx6EfM6bmPnlxno6uvSdnQdDi6+yJKu2xmzKxGGOx58ef6N/zY5c/fY43jLlOlQg7Kda2LpkHqTQMYWRjTqW5UzG67z9187GbmjOyXrxEQu3jr1kkpNfi3Y5f6VT2yYdY0nN9VLtfQeXZa/hpfGyla6VnpyIF8Ra94+90EuV6CtrUXBolZ8eBOA29dg7HNmrIlHBdooJCYGSy2flvhNKP6Ea4PGaaSxVnLiGB7PXcS1Hv2pc+DfVKhZ8kI7gbdFpT+qcXrRMS6uPpvpCMW8ZXNjamVMkG8Itw49oFKbMvGWNTY3pHzTItw9+Zy9887TcULG/C3KtqnI/UO3eeP8kvzVxMsna35Bmr++8TYtq5ZiqDWyHbt7LuLq8sO0XNwPELqKAJFpkXuTgpC9ECk8OiWqp3FNMjdMY5GY20fvZ/vo/ejq6dB33Z8UrRmT2ttzeSd6Lu/Em9sf2DjoX4L9Qrl96CG3Dz1Ulln4SPoExYymQox70LpOv3AWyYOK1bPzIaIv/6x/zpQhzkoy8ezDdhQoKs3wID64fQ1m1lhxb78J7J4s+0wPGDbkFQCr1xWOt0yf3qLM1q0F4y2T0RGtURSblPj8QejC5c7khOKlEyJSqlbTGEIxW47Mfc4/wyyLGf7u/ry99TZDEoqzpwr5jbadcibqUB4WLickRNzvTo7SjT/SC/yD4O4POd0/NQiSP3BG/O3SIuXqJAV6etropUAw7Op13sxeIN6Bp486UqpE6pEvWW2hZgW48kMWMk92sLeBLBZQuxTkdwCn7BCfsopUDcW0hIWtKSXr5OfxxTccXHyRtqPr0GpYTQ4uvsiLG+/x9QjAKmvCOnOyCBm3jz3l1Hpn3N54qi2TNY8tdXtVo0KrUsro6Z81FFMLHSY24syG6zy7+hbPzz7Y5bJWRi7O+2s/h90nx8k0TAjP7riycZYzdy5+VLu+/YCydBtVCdvspnE0FNMC+Yva8Pa5D64fA8iZx4KCRa04c+QTL5/5ZjhCMSkpzBkp5TnjUJ+pAG0D8aL//kik1SVkmmJTppTyf99nLkk6XlJcnn0kGl18C4jfQalYswoAfLgZI7gfEKYXJ+05IWREl+dZV8cAsHPsQaJkUQk6wg5e0x6AE2uckUXEiMKntMuzVAQk4P5dd7AQOD654Kja9VEyzTRPpDrn2qWwszXE/7tmLSycij9cf6ay3OLH7GK4v2aC5ramYYkXioXkcOdODEUcVEW9w7eKtAeDNsPUln/jLm2gKtXl2TtEeuqD1POWeu9JLZ/DPPHrbGCsz+q3c1j6ZBo1ughdJllkFGt6bWdQvklMqraQj49jXCvzV3Ri4b3JrH47h96rYiJH+6zvjr5R4oPK2Ofg4+aP5yeRO1a2UVG15ZPk8hwurUP2s+j2n/2K8D68D2NnV+DG+z9+mUyMbXJRwUlo3e451xhDQ/XXMymugkHylI1u1baIf4T24L5odxwcDDA0FOeqzlnUxUV05AsXiaeu6czlOSli7JcvuAMx+okAnz/8iFDME7fNSmlXaKm/ESTt/gO4fOojAEXL2BEWKvoV2RziPotSXZ41acd+RjYzaX2ZCIlt989tfVigOJ6tozDYeHtLdVIzpV2hAZ56Jp5/O6DJPsobL6a88WK693rFrevflbrpMpmcFYtfA7Bmc9k42+pkVY0aGjVORCUvW6g++yk1XJ51bBN/59x+Bo7NoFh7mLUDXv3kz1ZH+CKwbXLcbaN+8pU59CMtulEC85xRftLcWqWa12jiCh0bWvrS36GjJngoycQ71/IlSiZqG0nL/daxTVySaOdi+HxVfC7vhR3jYEl/aFYJCuaMn0wEkCXuIRYHkR9eJF4oFqReh/r68Wv4j9z6BwBHll8hMly0nZMP9gRgVMVFccp7u/qxZ9ZpejpOoafjFPoWmMHm0YdUyMTSjYsx+kB/Vr+dw+q3c5h6bgRVO5ZXkWJwtJbmYi51LPDEzTLedVOP9wdgfA2hvW1sYUTjfsLvYEbHXQnu9/1Td+Z020tLu1lUNllAn9r/qJCJzbuX4NDz/twMHsfN4HGMXFwP2+ziXZSYA/PPSIo5W2J9h3xFhCnqm+feAOQukg2AVy7S7ilNkdL9jMyM379cLFRfOZcrfUdzd9pCGh/dkSjhV23TGpx7D+Th9LlJilJMS5dngBqDW/DsxB3OztlD/xMiYiaaoGkypimnFp3kxvaL1OlXV3I9E0JauTxHQ99In+Yj63N86XkWt1/PnFN94y2rra1N99lN2T75JD3yzlKmPqe0y7OhxHsjIaddMwdRV+9PXiq/fasRdTiy7CJPjt2lZufE9cnMJLs860u61pFR2hjqSjtv7xADzOJxuI6GsU6YUgu0WO+OXJ+xms8HD1Nm4B+J7v97oKGkcwgM15PUkTCQeL4Abz3MMTMU10IhlxM9DDa3NgLiXqOcNtIGyo2KfJVU3kRfRphM2uSIoW6UJFLR3EDG59eiQ1G2URGVbQ1M9OPsy8xAJmng6yrBHVXbwJA2U1vRcUYLgnxD2DvtGA9OPcXP3Z9FbYUGb86i9vT4uyNZnQSBfWrlRVH35qUoWkuzFJXYDn6jK4tU6+nH+sR7fxWykebmDWCrK80p1EhHfTszckJ0tN2vTZxoh4v6dGlzA4A69bNSp5ohRPqoLa+lbwwSJ3Dl/q6kpC2TPMQv3nWNGzwC4NjhvPGWu+YsrmO9uubxuo7qZi8KCs3bY58oaYPY1HB53rlWTPZ0HxCLUFSmPKsnS1Kys58UUjSpLs/eHuK6amtr4eEqBqpZ1RCK6dHlGaSRivo6cpX22eureMYt7W2At3x58lllvZ6OXBKpaGYQKZlULJM9INFrV7xSDu5dFoza6d3POa0mfXTa/NJoG8Ql/WVuLqAbcz8dOirOuVNn9bp9cl9p71yQTsb9TPipg+LHKycoFLYcFR91qFEQFD81TTpZVJcNny3+/j0qbtloaFvqS3Kr1rG2RxGpOQGuZWQpzblZjWNzQmjS6gMPHwsS/+X9XJibyVBEJtwuK8KkEVNR36Vd58hPkoqjkwXkEgPR9PLYS3Kr1jaykEQq3jFph3kC443+C5uwbuwppjVdy6prAyhZJUaL+uii07x/4sbTa+pdaYzNDWgxoAoNupXDzPpnwix+F+SXXmaYJzLW+BUUyhJ//614uazY57Xh2ztvrm53pmnfSvScXpfT6515dOU9ga5eOOQRTtqf33izfd41Lh5UT/o27lCQfhMr4lTw58nfuPe+obY0V+gwuT76WtLGiYkdo1AxcV7vn3+nQfPclC8l3nGvXbzR05Z2LE2go5ChTodGR/HrZkNytJBL7LBKLZ+W+B2hGAt6ZmZYFc4PwKfT/yVaXt/SgiwVBBHzZvs/KVq3lICJtYgCCPT0i7OuWlcxrXhuReZzewZoNLAWAJ+fuvL1lfqw92hc3n1f+b+Pm7QBeHqBma0YrIQExHTGGv7QYdsz+3Sa1CmlUX+kyLO5u9dZucy+cmkA3h5N/PnOCAi5LHr8Jg3TPg02pXH3hCAgKrYorrI8LfQUo2FqZUyvFZ1Y/XYOs66OIX9FkcL4xeUbM+svY1C+SUypuYhvr4TAddfFHSUf45OLm/L/vKVzJE/F0zGcr3hx/oz4vfYcrZLGtUk+eHnFDEbss8cfLfRnd5EOu2yJtEjhjIYLJwRZk6dADNn56UeEYmY3ZYkNty/inLPl+P84Z383QSxY2lulWR1O7HhCv3r/cOrfZ4SFqicJ+k6prozauXC7EV17x03LHjw6cXOwY8fF+TZsIC2iMLkRGAKrDsDzBNx/KxaFDwfh3X4R5dasYtwyp+Ymfqz3P/hRY0MwyoQysAqFgpz5XyjJxE8uuTE3+z2cTi00/ktEBX959Z3tMy/Qq1hMZOLR1TdUyMTClXIzfkdn9rpOZb/bNLa/Gk/b4TXUkInpG4svCgPYbdPOEhEmiLQNV4Vm5J+l11HbYh61LebRvdwGFTKxatP8bLzWk0v+E3gcOpz52xurIRPTLwoWE3V9/UwEFDjlE7zFKxe/tKpSkiFXaCfpk1GQcWqaSqgwawIAz9dtV6Y3JIRiY4YD8OX4aWSh0tNN0hp2BUR6lp+r6iyYlLTnjIopZ0SK6IR6q+Mts7THLj65uCu/D6uwJMXrlRJoPbEZAOfXXlIuMzAWg9rwYGmzUBkF5TuJlIDzS2Km2VPaFSy1EXhkEwCmjRKPtszouH38KQDFawu9wuhU/bQkFGPD2t6S4f/2ZvXbOUw6NZRs+YQxiY+rHwBz705N0n4nNxJRj0uuD0+OaqZrhIVF0aaxmAB4+LphGtcmedG6vUjtPHoofr04hUJBRITod9ja/P8lkESnPBsZ/f+ce3SEYrYMpgeVVPj9IBQtslmmWR0WjzzPk5uuzOp7ktq2S6lssoDKJgvoX/9fzux2ITxMNfKlZFkblq6riJesC1myCobs3yOaGbv1GyhCxtaszJ28JyERO8/Akt3QdDQ4tY35jF4pdBFjD3e0taFaMVgxGN7vhH2xzGQL5Yy775/Rcrj4e2xFsp5CukBEhAL7PC+RycDYWAvXV7nR08tc/cqMgOWXRWbZoVU3CfCOCbEsXScfq24NZb/bNPa7TWPm4b8oW7+AJJ3B9Ag9fR36LmgKQBenObTPPoO+NbbGKVeutiOrznflkv8ELvlPYPauduQrkfyO5qkFB0cxEfP6mchS0dUV3MSLpymT8vwbScdvQvEnaOvpkrtpPQBebdiSaHktLS2KDBf2WjcHj0jRuqUE6o/vAMDFJYdUlru9iomKObnoRKrWKbWQLZ8duUuKiJ8jy6/EWb91wnEeXhDi+Ns/TlMuf3EzgSnedIrSTUoAcGnLNeWy2IS552f1KYUZGTp6CQ9K3e4+TaWapAzk4TETGFo6ye9amN7g9lbkbBn80B8M9hPRtua26YNQjA37AlmZcmYYq9/OYeyhAcy6OgZjc+mphY/+EzpdFllMscuVdhE9qYVc1scAmD6vGA450l8EwZcvYQQFSk+ziYiQ8+6dSCmqUD5+4mj7DjELP7B/8rhkp1eEBIuosJ+1Ej2+pb0IfErj2yeR5VC7mYhmdv8af8pzZoRfrAhFPcO00dO+/H0UJ98PZsCMmmTPHRMh+/jGV2b0PkEtmyVKknFAw10c3P2B8PAoPrwLxMtDvHcbNEs8WvzL15jJWmPjtH1HD2wDe2ZCyxqqyw9ehg6TIU+7GJKx/0K49AiifmhDdJgl/t5emfhxwiIg4EdWb/5MFmTt5x9F7oIvAahY3oj/sXfW4VFcXRj/bbJxIgRJ8AR396LFKe4tUhw+KC6lQLFixa04xYsXd3d31yCBCBCSAPHd/f64yW6WbJK9IckmKe/zzLO7M3dmzuzMXHnvOed9erdgmpukTi1wK+zC8BUt6TvzB9Z7jNISiCPXt8clV9rsK9XpFDM1VZEK2Ri/toWWQJy+40eKlE87kSxRRPDje/pj1IiI+B2+UhqiQp5ll9SC/840sAQK9ejIi71HeHP4GPm7dsIsHlmwTGWFUnC4kUIPKQlZi7oB8PSMTlhm15SdnFt3Vvv73PqzNBnZNLlNSxYM2dST/gXHsG3GMer3qIR1pNfev7OOc2zdFQD+fvI7ZuZmzL00hAHlZzK5zSqm3p1mSrOl8WWn5/HFZ/zVaZn29+65J+g2s0Vym5XkyFe1MI9P38Pr3ivMLZVsbj1Yu+3Omh1kKVcsjr1TNj5uXwqA48/DTWyJafDRT+SGtM+Q8gjF6MhVXHTuEuLoPbOzyM375/FfEtOkFIkF00VIu5kZ9BmQz8TWxMSzp0FUKn/J4LbceWwoX8GRihUdKV/SDDc3S706d8hwIdYzdXLcHf3fRotYwV+HuSaS1SkTOzYIb80ufeIPGU1rOLH/OQA1GuoTilnSuMrzq5svOL74EI/PiklaR1cncpfPy8NT9wn0DcAhs1yez6+Fs4sdnYZWpNPQitp177w+sXfdbXb8fQPvl6I/f+PMK3qfeQUdz2nLnbze0KhztGornvOD+/InouUJR4UiYpkTqd+m0cDtp7DpKGw6oiMQD14US3TkzwaZnOI/x9DIIJ4Zg+Mul9rw8lUYFao9BaBTeyf+nGhYYOcbkg/fNRbth6xQVGrGeo9RPLn+mkIVc5LJzrR6BN8gh4SEMKemkOdvhKIBKBQKivbtwp2/VnJtzB+UnTIh1rIalZqTHboB4NaqeXKZmCT49D6Q6eV1sQ0Dtw9iTnOhKqWKUGGuTHteUOZKc3rNbs6SQdsZVGEWi26P4MSGq2yffQKApfdHYmGlRKPRaMOdq7QqYUKLE44yjUpwdc9NxlSZTOBbEVpWq3NFjq66wNlt19MkoVhnSBMen77H2l6LCP0kPAtcyxbF+8odPjx6blrjvhLB50R+U5syxoVepWZEedNa2elyzwW+iyQUU0jIc2LjyBpBXhWs6Iado7x3Y2rCqxefmDhC5Kp98b6Jia0xjNx5bJk8NS+7dr7lwnn9hPTPngbz7GkwG//xjmVvgZ87Zox1W3CwTirG0jL1dCITgjULxQRm659THnGc1Di+R0Q4VG/gBkQLeU5jORQ9bz7n5OIDPLvwyOB2BxdHclfIx8NT93l26QklG8VUS05uZMySjp+HVeLnYZW06956feT8P2dZu/wxni+DqFHblcLF4veAUqk0vHwpPBSLF0t53tYACgUUzyuWSb106594wuaDsPkkBERqum0fb9wxd0cG+7Sum7i2mhLXrgfzQ4vnAIwbnZle3TKYxA6vt/D0FVQRPiycvAwdf4XLW8DFNCZ9QzLD0lpJ4UqmTZ/wDd9gCGm71/oVyFG3JgCBj58SFofn4fG2HQHIVLE8udu1kjpHfCrShuAnqRb8JjD+jkzdkUIoYFEDQSY6Z3dm8q2puObPQoMhYib21MqYIcEJhYyCX3KgeGPhRv7JP5gHF56zY4641gXXh2GTTvzfnXKOAyB/uZz0mt2CbA7GK82BTj3bWIRIPhvvg+J/LtxLi0Yoikwcf/o32o/7wehzfAyVm3/IbCeXm1FGHTkKcalbAwR6+wNoycTe236l2iRdagK1Km63sYz2cnlRZRXMQyXVkQHyugSi8hNCQmb2TvGWf/VejnA7cE8uXOJzmPy8lKwq9O1LIgVDhSbFtevi8lCUfVazOcjnv5VRqQa551uj0bB61F4Afl3f0ah9HryX93B6FyEnFBCsklfCjQ8ajYZyubcB8O+xelhZGf9sSCl4RsLMMZv0PlHo1iM7O/eUwud9Db3ljW91jp0qy9Rp+WjWIjNZXGO2cX3/F3cY86QpbwCYNT3+JGURXnfjLRMdzubGK3ICKBVy7rSyCskPI/MhOTol/vOUUCREqVr2fwI4d0SI0WTKIuot70hC0SlDTPWKvA7+UsfOnoB6zNVeri9jDJ5fecLKzvP0yMTiDUvRb8cwHFyEJ6LSQkmeioJQfnbhsbacbL2akP7kNS/j671MWexpMqQ+1581521Ee7YcqBXvPsosRZgwUbzPo0fG78lmll4+RNHcKfbJCYPlMxlfNm92GNkNri8WORSfrQWbeF5V1VvYFKnh2KSGcedR+8v1EVV+b6TKa4L9pcpHV+aOwp79gVoy8e8l2WOQiQoLuck+hbXcxIF5Rt19bjUAfhoKbyOjPx0iD9Wsr668hSTXZIz695cIfyZ3H2QUoQHKf94qVd4yAWMHWcSlwpwYePA2Af23oNjF3QzBL0zuWQ1Ryx1fVhU6IecIiEhaBwKVIun87DQJCHfWfAt5ThsoNW4k18dN5lzv/tTYsCrG9jM9RC1umzULxYYOkD6+lYV8Z9RZkpjKnSH+SrB8y3IcmrwJgNaT21KmqZgpVqvVnP9HhHlc2HiBmj2+l7TWMGRJl6SGg1UE8y4PoX+5mUxqvZK1r/SnYv9XbCoAGbI68vu/whv1daBcxfxekgh2sJb7j+IiOEM+h9K36CS9nIl/P/8De6sIIIJchV14cc8Hj4uPKF4td+w2WcnlDvP9bCm1T7jKDBulXMfgdaBNrJ0Jv1fvWNd7sfb37xcm8SYkA/aE416zDB7Hr+J17CQFG1WN9fhvP1mTTuJefAqxkHq+E1IH3HvjROBa4TWduc/v8R4jj2RH6Ls8PlLlLc3VCSLXZEjFG/tuAFCyYXGCI8S5/N6KZ97aKZ12XRRslGopUtFX8v2EhNVjxpKK2ybtA6B2h9KkszUD4t8vv5Ncpx3AxVIusbVZaCBIVAOaiPjbq3bNhCdmvYaZ+a5EKJpguTZOEyx3DepAuefb0CDzSyiAQu5QyN2On1srgVjcRQz9H5HHX7FSCKO1axu/AqMyS5F4y0SHn0ounDQhA4kwTfzvW8CHEB7ceq/9HaExXAcYWp8Q8k4Ggaqk9yKLfg1R3308Rf1sYRbzHX8QIOd25BkoL6nr/VFykGnEZGemInmpMaAZeaoUIWte/WsI9BH1VJjKDCf3rAA8ufBYG7Yo255YmKulScVSWQIIlGgfCtt7E6Ix/r9Vel9l6XLB1BiTD1X9wdPoY0dB5f8u/kLRy3vFXyY61JJzNWYOMFwENDGtF6g/x7+PeXrQBBlPQphnzIgm5FOs2+cuDWLagiAa1bVk8XR7zB0yG65zY4EmXL8fvXB5ABOnifZl/7YslCimjFFGEyFHomiC5FJjqd7prnf2UGg1FFr0g1MroWQesf61LwQFCkXt8BdSh8fcCTRG3KvosMiTTuo6FLYOUqTio2w/4yDR0QhTmWEtOXaQxRM/W5zjcWD4GuR1lp8clR2TOSvlxgKWCrnjB6mtpNtpmYm8AlYL9X6ba+TzWccHTVgQhrIzasK+nrdQaxSoNXIEoWx5U+IboRgH0hcVnXZ1eDifXr4iXU6d58CNiX8S9sEfgIrzZpjCvESDwkzXeSvdRPjSez/y0oY7AwzamcYSonyB9K4OVGhUhIt77rLi1110+1OE3Y1usJhPkeIPcy6mvv/g8MrzbBi/T/vb0taCsKBwQj6HwudQuhaZrt2WOaeTCSxMOjhlc6ZEo9JkLZSN/dN3c+rv47i1bMI/LYYT/ll4cqR3T7i3kikR+vQ+AFZuaSdkUK1S8+b+a56cf8KTC495cuFJjDL5yrtrv398Lzra6dJYyLMqQsWxlSKHbc9pjUxsTdLi5LG3nDgmBsZrNpaF8LQvymEIPj6is+rgYJbqkvyHhUbw9MFb7t98x4Ob77h/6x33b77j88e4O+B1Gqf9sK03LwI5vteDY7ufceG4YdLI3y/pBqmmgrnSnHLta0b+EgNMtUrNvcM39cpFPesffeUnQ1IyTp0WA/eyZWxT3fucUDwSjrc4pgMrufmIREPzhlZMWxDEnkNhZD/0niXzrWnSSM4LPwpDRr5jw1bRx7h0PDvZs5l+uFyuqPh84SXEb6wtYe6vMOBP6DUR1kw0rX3f8A1Jgd0XW9Cy2k7CQvXJykxKkWO8eGlnevUvQLM2ubC0THup2VILTF9DpnBUnD+TC/2GcGnwCL7fKh7ex6vX4XfjFgA1N681pXmJhrJtvuPK5rPcPXIHjysenF13BoDKHb6jyW9pU5DlS/Rd2JqLe+5y4p+rtB5ei+VDd/LijpjWXfNynEltk0Xgu08MLPun9neP2S2p1LwkpzdfZeXwHczpspZHl8RUpp2jNUuuD8bKJmWFon8tzMzMaDX5J9RqNfun7+bk0iOcXHpEu739jhlYO6W+vFWhz4TKoFX+1CcoowpXcffILTwuPeLJ+Sf4vzHeu6ze/6pjZq6b/EgtoiyyWNxrHQCdxtZJ04PR4GAVbZpdBuDmw8Txfk+t6DdQ1MVrVsbuIZ7S4PHQj2Yl1xhd3jmTDYWKZ6BgiYwUK5uZJi0NE4pW1qlrQBAWpuLKqdcc2/OM47s9tCHMcWHB5vrJYJlpoY5Qcf/wNS4sP4DfKzlvutSOtj8J8Y7Vqeh9/lo0/VV8bp+SvOdVq4U/kZmZgpzZzXl9KyNjpn5ixT8h9Or3ml79XnP5TF6yZzO+f9uo9Ruu3RSehw+u5sTBPuVkB5s1FAbPgL6TYMV4aFZTEIonr4A66SN/v+Ebkh1FS2Xk4UcRHWjLJw7s9mRon0u89RGOIbeu+dG383n6dj6v3adDtzz06l+QgkWcTGGyQagxQy2ZaVC2vCnxjVCMB7ZZXLF0ciTMP4B3V64R8t6PV7v3A1D9n5V63n2pGTX6NuDK5rOsG6gjSAf8O4gsBf47SmYKhYJhazsyveNa+pbUqTivfj42VQ3sN085yIElghB2zGzPtNODsbASr3rBisLDK4pM/HV1O8rWLWAaQ5MJwf76Xk/fDW0fZ5hzSofvwj8AyNgl9XnMTq0xjpCPhsPznbM7k7diXvJWykfu8nlI56wjew2FF396n/ZEWUI+hXLvpMg71rh3ZRNbk7RwcxEJtyb+WRjXLPKhmmkJp88IEqpC+dQzweGSLR35i2XEylpJ4RLOFCqRkYLFM5KviDPp7ON3UVJ8EU4VlZIjp3vCPIqSG0Ws58dbpsYP7nzfyJ1qDdzI5GqX5GHbpoQ6QsW9A1c4t+wAAV5+BstU6V6HCu2rYeuUdursL+H3TpfH0jn9f2OIFRwqPOYAIqPYkw2VGn7A842aUsWU7FjtiFKpYMKIdAzvZ0uF+v74B6gpV+UJ31WyZdPanJibx96X12g0uBV9QXhkd+PF3VxYWKSsvn/L2oJQPHJRqHQrFND/J5j3D0xaDiPqmdrCb0hsfPQPxt4pbQvzGQszMwUNm+agYVNdxOi7tyGsXvqYpfMe4vdeePyvW/GUdSueasvkLeBAr/4FaNMxN7a2pqmX1YBaMidiQuYIhg4dysWLF8mZMycrV67E0lL0xyIiIujevTtPnz6ldOnSzJ07V7vP+fPnqVy5Mh8/fiRduoT1Q/8brd1XosLc6Zz+uSe3ps7Urqvy92LMLU3k158EeHFFF17olDU9ww/8qucN9F9B8Rp5UZgp0ETOev795PdU9T88vPhcSyYOXvMzRavl1W5bMfRfzm69rv290fN3zFPRtSUEB2ft4cyqE9rfdaf+Qo6KRU1n0FdCo9Gg/izCqZROqU/Wr9/2odw5eJN8FXLjWsAVs6+YkPkU6aGYLg15KE5pvACAHn/9ZGJLkhZzZoj2xtrajB7/czOtMSbGzVtiwqN0qZSpBBsbbNNZsuVSByBhydi/RBQRk8NdPjm9KWCbzoKgT+G45XOiZiN3ajbKTcmKrmm+TY2CRqPhzp6LnF26n48+/gbLVO5en8odq2DjEPuz7ZwjI36v3qFWqVNVXys2dGl2CIAtG/OY2JLkw8Al4nPuwOQ/9/pFDlRv6s/12xHkKv2eib/Z0eVHG9LZmXH/RgGtQvPZ80Fkz/uA6ZNd6fBjTJXusDANuQqIiXZrawVPb+ZMsY4EfdvCX5vgz5UwoisM7igIxeX/pm1C8eOHYFrmn8+aKz1xzeVkanOSDa1yzwLgoN8oE1uSMpExkzVDRhVjyCgRtaXRaDh/2pel8x6yd8crAJ48DGRY38sM63tZu1+LdrnoPaAQpcqlvrFUbLh+/Tre3t6cPn2aSZMmsXXrVn76SYwndu/eTfbs2Vm1ahU9evTg3LlzVK4sHBfmzZtHmTJlvurcqb/1TgZY2NnhkF+Xq6zC3OlYOqSOTm980Gg0LP9pFluGrNKu67qkW5ro2CUER9de1pKJAOYWqet/yF8+F91mtGD5s/FaMvHVfW+6uv2uJRPzl3cD4NktySzdqQjvX7zl9+JDtWRiy0k/AnBpkZx6XErDm+Mit166ag1MbEnC4JDZkcodq5G1UNavIhNBF/JsYZU2QvU/eAXw7pXw7ClZT050IzXhxfMgpkwQXpiPPeua2BrTo0s3DwAW/5X2cwrGhZceYqIkZ+7U4aF4+V1v7ob0Y+/tjgydUoUy32X9z5CJAMdm/suBPzZoyUQzczOq9GpI/2NTGXZpLsMuzeW7ng3iJBMB3MqLvrX3g9dJbXKSQ6PRcO2iEGOp8l3aGCMYgyOR89RNTBD4kdddyetbGRk1UDxno6d8Jlvxdzx4LDygS5eywcujEEMHCrXkYSO9yeJ+n6fPdLlL/QNU5CogUsmULW3Fs1u5UiyZCDCss/hctFl8KhTQoIr4vumMSUxKEkSEq9g494I2rD08TEV4mIofiy8ysWVJi3rOk1gw7ID2t629EG7buexybLt8QzQoFAoqV3Nh1dZqvI1oz9uI9jx935o/ZpQmWw5de/TvxhfUrXSATMr1ZFKup3iuf1k49zGBAUkjHKvWmCVoAQgMDNRbQkMN514+f/48deuKfnX9+vU5d+5cvNvOnDlD8eLFE+yZGIX/Tu8nAYhSTw15/57AR4+1622zJk4YcKgRanlfwk9SjfTZ+9g7NX4v3zKx9BC87otk4R2W/g+AXZN2SNslA1lFvqRGlNrfpb13WTVyDwC1fy4HwLQOhnNkxqWqbAgZJNW5A0Pk/qMo1WmFQsF3rUphZmaGRqNhWru/GdvgLwBK1SnICo8JdPmzGQArRh+Us0lCFREgs52c14qxCrjR8eV90Gg0rB+wkjmNRf7IHCVyMf7GNEo2FjMv/i+8pY6fKV1I/IWiQUYRGuTrgFtzlwKQvmVXo/d5+lZuYHP2qYtU+TBJhWdAWhXaUJ3x6X3sucq+VH2OD5kl38/YbPoajK4q0iwM29YbECrpMnjkL6fkC+ATFtNTIy6oreTIHsUXCskajYbyxU8AsPtQRSwtv7hPFknvpWfmIPd8y6iEAkapQkeHl7eoM3LkMH6/CK+7UudwNpcTvZD1OJRVhQZiqEK/eiZUQ3PG4qEYmyJ0YsHBPOkFgWSvoaDj+/gLRUN2B7n2CsDVXq4vYx3ZL676vx+oP/pH+h/7k2GX5jLk/GwqdauHVTr90Lz4VKHdK+QHwOOimGSQbU9k2xKA615ydeW9j65GlVs4XeRW7zlILgrCLH12qfIA5k4Z5cpLDlvMjKyK1x8Tny2ryB0fQGV8CmVR/l3suTj7dLXF42oGCuUTz1utlv5UqvaQkFDRrxwyIBMeDwrglku021VqPeP7+s94+iyUQiXFs9fhRyd2bZT7oxRKubpPYSvXhppnjDnIVyigbiXxfYtwiGXucPE5SjKtv8pfrjxA+NP488RGh6yydf7XqwG4de4VS8Ycp3f1lQA4u6SjQh2Rl3Rcp+3a8pYJGDvIIiEqzDJ44qf/wu1ecZVXj0X9v+nhQAAW/nqIz4G6Ol52TOYXITcW+LKNjg8yis1RCFLL9Zc+qRMWkeTgaEnvgYW44dFcSzIevlCfVj+5act4vQ5m3G93yJtlD5ltt5PZdjud2lzg7Km32pQsXwM1igQtADly5MDR0VG7TJliOFmtv78/Dg6ijnF0dMTPzy/ebXPnzuWXX3756uv7FvIcB6IG++d69QcgQ5lSvL96nfvzF1O4//+++vhRhKUMnCUHvrkzGJaJ3zlmA7d2i9mOYj+UodnE9tpthtRVExOG8qElB3yfv2Pn9EN0md0GpaXu0XewiuDZzdfM7y2m+2aeGUDmXM4cWX2Zu6ef4fPcDxc3Z71jRRF4xuK9JBEsS0Dmcf6s9/vuueeMa7la+3vy3m7kK50dUOFQUHSmn157hYOVfh6ruCBTFsAz0BprpfENfUiEmTSp+D7IUvs8Pbv6nHk/LdFu+3FyKyq0LINQmVThmNmBAN9AlCH+2Dga1yi9CbTVDqCMQUi4uTSpaCzUEbr/38HBHNC/H293bSFd8dLYuOmHWuV0luv8lc0pn0BfdhBoaa6WGgjaW4XHKP85Un3970Fb6Dijrd42C3O1FKnoFyT3fgI42yaeOuure2+0391KiNwwsZED+1deYefiiyy+2FdvvSz5AJFEk0Q/SR3wWqY4mgh9YqpF8zsANGqcgXIlzNAE++uXDzPcab9w8RPNWz3B61VJibMbhvqjr1R5hdISwuVIF2Oxe7+ot9u1cY6xLSAggoJF73DlYmGyZdUftCqzyHmw+qnkCBRZgjChIc/RByweHqKemjn2MpmyO1C3mX49ZqmISFJSUXZgA/IEYVz/09HdHtRq7K637kGAXCiWZ6B8LlLvj3J9mSiC0NLOmmJNKkrtEx2e15/i88iTwvXKAvD04mPKdKyLtYVKqj2RbUsAirsGECLRPhR38jHqXk8ddQWAscPsURjI1Xfr1icOHvRj2LCceutVPo+MtkW7TxzkmiFESDqAqo2cgxgTSWBN6gYaA9X363ewcDeM6QBfBhMobOVIRWU2S9RxkFNK4NBac548N6Nmu3Cev1LjXvAhQ/o5MaSfE1ZmcO5wNu4/DKNW4zfcfxhKlVrPABg7Ij09O9nEaLPihYHyHwLU9B/5kam/pyObq/5zE5f9hqB6Z9ieecOgYAsYOgtafQ+WZpA3Bzx5BefvQqX8xh1fYQdqSa7MIo+Y0L18G85ehXPX4ZZw8GTnYihVWL+8mW06KVLRq3Bv0hFOtdrZAHh8y4fbJx5RqY4783c0p7zdTE7ufIDnHU8KlnIhQmMuNdYApPPZPg+w03OSCAuJYOdfZ9g84ySDl7WmUiP9i5apX0CfsFx1tjOdv1tF9wqLOf/5V7CCSeuaMqrDTlq4zRTrkCfwZCfNbMz1jx8RoWbV4oeMHnCJ/iOKMXJSab3twSoraZtk74NVuJ9UHzQulChuw8LlpVi4vBQAQUERbFnvwbKFz3n0UPRHDuzx4sAe00fzvXr1SksGAlhZGe6vpE+fnsBA8a75+/vj7Owc57aTJ09SokQJ7O2/3qP+m4diNHx69SbWbXk6/kiJ34YC4H3qDKrQr88ZZCqcXHJQSya2m9ddj0y0sBYtfuhn+ZnulI63L/y4cfAuQ0tPjLHt6XXhpTnx4P/InEu8gBP29gJgaNW5McqnZAR9DNWSiVWai5nybXNP65VRmInObliIHEmYUhERFqElE8s3F43chpH64c0txzYB4MKyvclrXCLh4fodALi27x5jW0SgP77bN+C9YWUyW2V6XN19w9QmfDWmNhFexOOPD4m37OJf9+PlYVj0ICXj2LEPnDsnOjPLl8sJQTVvlbSTXKZCrwEiPHLihGwxtk2eKjqxjx+nvbbYEF55iGfj86cIBvx4yMTWJD/6tNpvahOSFVsHLObYzH+xiRRoeXH5cTx7pGzcvibe5Vx5HGIV/qhb5xYzZ3gmp1lJinuRl5LZASxjcU+pPhg2HNOJtiQH8ropeHXBkmkTBCE/c74/WfM/59pNQXYUKmDJ8vmZtOVnT81Ar67yHv6GoFJpKFrVj2Onw/n4MbGoj5iwttQJ4FwU83Rsnio+O877+uOHR8CVxzB/F7T/E/J00S05q0HBetBxKCzeoCMTIfGVpvc/E847/ZtuIzxMhUKhYMsNEaHT8bu12nDo5EDAu8/M+2U7rbOMp737JDbPOAmA7wtJV9t4UKCkC5XrRXpidt0NwPfNC2LvJEikTX9dSdTzxQXPl5/o0fYEruaryW61ltEDLgFw7dLbJD2vj1cQKxfIRWJ8LWxtlXTqkpPTl6vhE9gQn8CGnLpUlU5dc8S/sxFQaxQJWgAcHBz0ltgIxYoVK3LokOg/HTx4kO+++y7ObTdv3uTo0aPUr1+fW7du0bWr8dFvX+IboRgNF4aPN7j++63rydW0EQCF+/cB4MpvvyebXYmNQrVLkKOkmAm/vFGfaGoxviUARxYeSXa7khpFqospu/CQcI6tPKu3rU7nCqx9NZ5chXWhLe7Fs2o9Ew/+fSH5DP1K2Npb0bxfFZbeGMyAheJ+Xj2kPwPe5Y/6AGxffCnZ7UsKKC2VNBxQh7HHf+Wnqa216yPCdIRpsVpiBvHmttMx9k8NeLxFhOM714qZP/Hdvh0AZKjbKDlN+oZEwJ3jojdunzEdGXPE9FSLjuf3fADIXcy4ELyUgqAgFT/9eB+Am7fKSu3773bRWS9VMnWJlsSHiAjdQMjOLqb305p1wuO0erX/Ri62KEIRSNZB4jeYBnmriclO38eRrnOJEFJmSjSpKEIw/zn032mDm4rMMmwabHj7p2CIepWNDApJVHRoZ8+r+7moXEF47jZq7UWhsi+ZMe8D3fsJQmTvliy0bZF4dWzOUqLebt3EioL5kjYIcIvIkkLbEeLTORon6uET975qNTx4DSsPQa+5UPx/+qRhwR7QdjLM2Q4XHsTcv3QR6NsB1s2EBwfh5SmxlElkzcOMrnb0m1gNgLq5FgLglt+Zlj1KANC56rrEPeEXeHz7LV1rrKd1lvF0LzaD09tuabd1n9KQjZ6/07Tvd3EcIWGYsa0VAAc33eP5Q/FM7XkmwlLnDD/KR/+kmWjUaDQc2vWcCrnW4Wq+mrLu29i99YV2+6gppXkR1IGth5NW/WfMwPOMGXRBK9ZmKhQoaM/0OcV44lnnq4+lxixBiwxKlSqFq6srVatW5d69e7Rs2ZJevYRzVOPGjXn16hVVq1bFxsaGSpUq0b9/f44fP86BAwcoXrw4f//9d4Kv7xuh+AWe/Ru395JrNVFxfH7pSahf4s5KJBcy53Gl88p+ADw991BvW8kfhOvv6VWnkt2u5MDsO+MA2DZpHx+84o/pmHJEhBWuG7uf8NDU483308hapHcRnaT0LiIHywcfXfh7nY4ip+DfE44nv3FJhLp9vid9VicA2v7RHIDdM3SJjaMn2U6MfBjJidAAce8UZmYGk4W/P7gLAPvSFZLVrm/4eizqIWLGxhwaGG/Zad23ATBsWYukNEkPZ457M+G363z+nPD6L7f7RQCmTHXHxUUunLZvf9GZ3bo5bzwlUxfmLRbtz+iRcefsSsniAIkJTw/jQ+LSCj59FG5bNraCeAgLk0+Dk1pRuKHIU31vf/J52yQVPn/SpTnJmsNwYvszZ8T73qp1JoPbUxs+h+o44ByxpHPsHRncs2RgsphkEObmCraudeXSCZGnMiBQzawF4l5cPJaNUiXkUx3EhlZd/QHI6KxgzsSknwjK6KT7/iIyKvPAaPHZcDK8egebz8Hg1VB5JOT9Rbfk7w+NpsDEDXDkBnwZlJYvK3SsBQt/gSvz4elK3fLyFOxYBL/2hGrlwFYua4I0Og0uD8CngFD2rBPumCPmCoLn/nUfLh31SNTzndzzhNrZF1DOdgY/VVjN7Uviz3XOYs/oDR3Y4jWWLV5jqde5XJIJcSkUClaf6wzAj6WXA2BppWTy+mYA1M2WeJFzHwPDmDziAu6WS8lttYxerQ7h6yXCowsVS8+OE/XxVv2Mt+pn+g0vhpVV0uYzBqhYVUyaH9jxPMnPldYwY8YMTp8+zfr167G0tGTJEhG9p1QqWb16NadPn2bevJhuzCdOnPgqYZZvhOIXeLh6E6qwuH3zy0waB8DZnl+fxNKUcC0owqx8HulCvVMz6WIMLK0t6LdGuPRGiSDEBQsrJZ3+aAjAiFp/JaltSYVBi8VM19JfdWS50iLpGwRTomJrMVg5uVrfE7Vk6+oAPDlxM9lt+hrcnC9mjSqMi8UVIBL/FfLhS6TWuurUOuH5nK+8O7YO8ffKXz8RM9VZc8vlVvsa/Nj4BPOn38PNcRMuGU4wYtgjPn8ynlycMeMVAPb25nTpIpfwfuMmcb2VKtpha5O2uisz5vkD8L9emWNsu3Zd5FZs9EPihOGlBrx5KZfrNS3A57W4z1lzCfLh+nk50bDUDLfyIu3B3X2pX7l0YCehTPLXhtqxlhk7RpAev/2WM9YyqQn9VojPBd0Mb9do4FxkxGKdMsljU1zInlXJm0duLJqdCef0Zty/koMc2RNPWG3WoiDOXxHt4o3jcUcaJCYORQ5LqvcAt0ZQPzKjU7gKao6Dkf/Arsvg+8V8Tdb00KICTOsGp2foE4ZPV8KBSTCuA9QrA+m/Tvw1UXDCR2gZjO95gE+BInR9/1MhYDegyWbCv2IyJiJCzbq5lylnO4NytjMY2mYHAX6CYS1TLQdbrndhi9dYllwbTIkaeeI5WuIhfwkXvmsgzjems3AaqNmsAA7OwuN23fxrCT727WtvaVF1B+6WSymecRXLZuk8Lzv0Ksw1r054q37m+I0mVKwqKWSXCGjYUkRR7t6SuGSxKfE1Ic+pAWmrh/6VKNjtJwBO9xsJxC6a4lggn/Z74NOEP+ymVnlu+WcnADYP1rm4fg5TUq2LcC+/see6tH3GwNQqzwUr56FwZPjzX11XxauUVaez8PryfeHHk2ticJzUKs+yIi5P/WKPJylUMRcAVw7qe6OWqC4aqmd344mNiISsopis4qRsUmWADLaGyX+FQoGVnfgPA6L1pFoPFc/28RmbjTp+Vge5JMYyAi4y8L4g3sXMpYuSJ5N+zzD8vUjObpM7X4z9AF76yfUGr7yUU49MCGRFXOKrMwJ8vvhPJI+fEIEVY4RcNk/YQ9+8oxhUbBybJ+zB874uubNGo2HTOJEf55dVnWPs+6XAws1Toq2pUN9wtnVZAQcwTqzj5ce2LFhZSft75d9vyJ3rDC4ZTjBk0EMCA2MnF1+8UjFjuqgz790vF++5FJb6Yc2Dhop9/1mbeJ14M/uYBF5ckE7SbwQCP+rqOkVoTE/5SVPEczJiuGECNi2oPMeG9BkNC4vIKk7KIiEKlbIJ5b/8n7w9BYlaqLioc08dfKm3PSWrPH8tzJSi/xvk95EcpYX3ccjHoHhVob+EbFsCcMtbjqi/5R/3gPrIHuFF3bClyHsWnD5m3Ofdu6IvkS1bzHbD3MVIBY3o+2SUa6eVMdO0xgmzOP4ijQZO3RPf64ugphgiLn/tFJ/dY2Zo0R1HUgwk4rVcvaTyi5kXv+kPdty5mBNHh5jPmaxiMwBKSw6fDGPmInExTy5miHNi10xa5Tlum/Lnin1bvRIwtjXsHwWP58OTBbrl1B8wrSO0KAVZJbsO4U/lyquD5CaLstxbHGOdnb0l41cI546arvMByJglHX0nVAXgh9wLpM7h5xfO1P6HKWc7g0oOs5j720nttqadi3H4VV8uBw1l8YG2uBXIgJvj5ziOFhOy45kvVZ6jMH2LSFt1eMt9nj8Qff3dT0Tk3PThpwj8YFydHxGhZsmCR7hbLsXdcilNKm7n+kUhUGfvYMGc1d/zLLQHHmE9+WN+FdJnsCZYJTcO/VLExSi7YhG7cski/o8zx/Tf4VCLpCXrFcrE81j+EpoEhDtrUhFN903lORrc61XlwYp/CPb2Jei5B+bZYg+xqrxoLuf+N4Arv47m+63rE3S+hKg8Z3WUa4HjKu+cU4Re+L/WJfi3s4yg1v9qc2rlKbaN3UqpxqVj2z3BMJXKc3T0XfEzffOO4t6px7y6/IgiVXLHWb718FpsmXaU8U2Xs/bV+CRXec4meZ/d08ddPn3mdHzw/cSndwE4R4ZCD5hak66VnrL89yPM2PljvOdIZyF33/xCrKSUoUMizLCUVHn2DLSOVRm6z/JOzP5xGRtGbKbfauGV6q8QnfAgv49GKUr7BVlJPa8fQy2kBlzG2BDwQjSojm7ZsLcO5+6b9Hr7ee8T4jNZWrQ1eDxZlecS2eQEP2QHgAnZz8E6PE5S8flDP/Kk1w2wDKlCx4X3CVB5zmAbGu85bBxFpygsOJyTa85zcs35GGW+a1dOT3U+CtFV/wAmddoEwOB5DQ12VvOnk0+SbRviiTFvXOuW6WndsiEq/9fs3OXP/34RA+h1a7xYt0aQX21apWf82Gw4OYlr0Wg0VCgrPIH3/OuGMjwATTyvkiaamvKq9YIk/r6aDVaaQDQGeA+FhXysler9K6nyCktrOVLRiEHpiDEiXcrKv5zFNUTod8TPnRfvbJ6cihjbAMxdCsaqiG0IH8zlPEMDVXL5Km3NQhNNgblEhSyc2OuB15sQMmXRTZQpFSopUtFSIReibwqVZ69IQrFURRf2bHrMqYMvGDZZR96nRJXnjyGJPyGcvWwBXl17gsflp5SqVzj+Hb6ALKlY3DVAap/izm9jffa2rhK5YZu2z68t4/Tpnl498Pmz6BOkS2dukLSKeH3HaFuiIKvyHP5C/3dgEJTqq/udMzMUd4cS7lA8NxRyAptYqrKVJ8Rnu8qgiXzNFDb6asGzRHYOhjeJXUXYzFaOVFRmA02Q8XWxecaMaEKS1vP56ZMgOvcTF3Fupy3W5qFo4jBRllxTGdGse2wTORHNzCAituZNhUF1XIUSNHJcGRZ55e6bmZOlVBsaWLIXtsRs91q1z8OsYdYE+IWwfsZZegwvS5/hJflrzGk+fgjh2KYbNPqxUKzHffHkA5P6H+Pi8Zh/0uBJlenUvyQWetFbOhs8gxykxjMADhJNiqtN7Ddh88X2tKmwnh/LrOBm8EBsbWDmhkYM+XEPVbMu5mFoH4P7eXt+4s8R59i3JaaoXa0G2Zgwqxx58kefOdC/R+aaCMMPTSwI0VhLT7JZmMX/n0Yvo/j8VkrlWZYg1Bjob32DcUg91GcyodZyEQZ7csDYOMtZZ8qItYvwdPA9fzHJ7UoqFK5bEoBHJ3UeD1Z2olMakYpyBiYEE08PB2Dqj6sJC4l9pPv0uidbph3V/t4wKfUpUA5dKnKuLRq2T7vOvbAglK+eeG4Kk5Icecu5AfDgrP50asbcIjdHoE/qyIF6atwiAKqN7W1w+/tj4nm0L1Yi2WxKaXj7zDfZz/n6gRe7pu/H63HsHr71f6nNnIdTmHV/Ev3XdqVs4+Ixyvz4R9N4z6XRaAgNEnWUU0YTZLePhEKhoFnT9Hi9KonXq5IsW+yGeWT/e/PWDxQqdocsOW7Q55fn1KgtPKKbN3GgTCl54m/keEFs/71QzqMwNWDHXsGO1q0ZkwBSqVJn+H5ioUR54Q1263LaD//1fi3IhRzuYlD36E7qU2//Gji7i7Y4azER3vbqyqO4ipsEGo2GAlYL9ZYidotp9d1WxvQ9waheIg/1xEU1Yz3GwgXC8/SPySk3D+xLX9hzESZtFGIcxYdDvoH6S6HB0GYOTN4h9hnb0vCxzgmOlSI5BcmVVvHps5pqLQSz9s8Ca3JmM93FpuX/OTpOPBfOAXPGnOetlyDhzvoIJehRXQ/y+aM+KXbxxCvq519BCZs5NCm2Wksm2jtaMndTQ+4E/8LdkH50G1LmCzIx5aBA8UzUaCScXoZ3FGO42s3yar35/559AxB11bE9z6mWezUFrBZSPc8aPTJx5KTSPP/cAW/Vz6zfU/sLMvEbkhoqdcKW1IL/SBVkPOxcM5OhWEEAnm3aGmfZ8jOmAHBnZszklqkFP4wWiribBq7QW5+3ouj4vLkfM2QgrSB9Fkdajf4BgG75Jhos4+cVyLgmywAYt6sHAPsWnyXko1yYkKlRtLKIi7h0wHCHPSI8bSaDdy8l8hW9uO2pXVdrmMgpeWr+LpPYZAjra/eIdQl8JQbWDjniVvb9r+ZPBHj7zLiw/cTEXz8v49jyU/zZaA4DC/ymXf75bStPr3jo5XU0MzOjQKU8dJndlr+eTNKmXGg+ooFR9+3IptsANO6eApJRRUOjH5zwfC7IxZXL3bG2Fteyfac/jx6JUJyFcyVj7YDFK0T83A/1bLG0TFvP9bPnYqLOLYfhwcu/O4Vn5sBfki9PZkpC8fKinrtxMe0Tij6eYkDskt10kwSmRKH6Ig1CoI8/kDIJRQC3vPoD74gINbev+LJp+T3tOss4hApmTBPugW3bxd2GJyccbPVz5j1eAUemwKye0LkOlHaHL/mVCDVcf677rYzlkjvNEZ8rBySF5SkDGo2GApXEBMCo/pZUq/gt4C85YGlpzrI9YhK2hrtI15XOwYqJy+sCUDnzQrauuE0JmzmUsJlDzwbb8HolRA2LlHZh4/mfuBk8kAs+vajdNE+q6TfP2dwYgINbH/H0vkiFccrjZwD+HHGOAlYLKWi9iP+13KfNzZuvsDNrDzflYWgfHob2of+IYlhbp0zS1BCq1xaRFV6vJV1oUyhUGkWCltSCb4SiAVSeKDzXnm/Zjiok9vwEShtrMlUUHSKPzduSxbbEhrW9znNEoxZUuCpCxZMLYlZjXqs5pjAr2VCzc2UsrUUIz855J/W2hQWHM6D8TAD6LGhFnlLZ6b+kLQATq/2RvIYmApwyiUHLBx/hFaFW6wiPJWPSjtpzdHSZ0waAxT3Xate99xAD1fuHEp7QOLGRoaB7nNttMxnOGxLqI8JN0xUqkug2pSa89Uh+D8WJ50fTe0UXSjYoprf+0r9Xmd9+KYMKjtSSjMv/t4ZbR+6jilAR8imUeyfFwLl29ypGnWtGH5Frsfu4Wol7EYmI+vUc8XhcAq9XJVm3Jjflytpx56rhvJ7xYcKfwnt40ey0oYgaHb0GiUHo8vmG3+mJUwU53qfnf5NQLFZWeCjevJD2CcWokGfXbClA9cAEKFhP9J8fHhZKz37PU949VygUHLzbXjsoj1puBfTUltl1ta1RxzI3T7mDQzMzcHeFppXg959g0wC4NxMez9FfonAyliCuSG4YAOc0/FjnryhInVpVzPlfp8TLIfsN8aNy7ZwUKSMiFyb0O07QpzAe39Hlm/3jF11EWYM2BTjq0YObwQP55+yPFCqZOiMeFAoFWy61B6BF6bX8XHMTxeyXxCjXtnthzr/uwsPQPuy53o7y1eQndFMKmraNFGbZqsvX4OKwj62bXpvKpG+IA9+mVAxAYW5GqSE9uT5zKWd7D6DaqpgvbRSKDu7P8TYd8dj8L+5tYvH/T+Go2qMOp5cd5uL6U+Qq4sLybstMbVKyYsndEXTJ8wdbpx+jUtNiZM7ljEajoVt+4bXYpF81KjUVpMHrR4K4iAhLfeHgw5a1ZFSzNSwavo+GXcsytrUu9+fWhZfpOyV2hcLUigzZ0gMQ+PYTQYHBTC8/Sm+7WqXGzNz08yr1F4w0uH59beEV23DpGIPbvXcIL2rX5sYNaNIarO2tCfkYwrvn8vkDvxZmZmYUrJKfglXywxyxTqPR8Oq2Jxe2XuHCtiuoI8QkzZ1j97lz7L7e/j3++smo86iixTxY25pW0MpY1KrpQK2aDgbz/8WH2X/5A9CqqR1KZcodgCcU9x6KtqNQfsP30vet8Ba3t089ngSJBQtLM+zsxeD85qWURy4lNqJEWRzTW+GWz4nnj/0JD1el2NC7xIa9i2ifX158YDIbJv64jpsnnmJlY4F7sSy4F3MVn0VdyZ4/E8pY7oVZNHKwQNHYyf+bN4R3VN36KWeCIE8X/d+ZHEX+xGJRORTdwZB0SPTAnKzpDR+7vZiDZ8uviWJqikSPwYEERf4Xq+fIp/P4hq/HpjNtKGqzgE3L7rBpmX4O0p8HlqHPmEpY26QtiiN/sUx83yQPx3Y95cYF4Uxgm86CX6dWpm33wqnG29JYNGyek8E9zrFz83N6DtDl1u3b4yat2qY+ojQhqs2pSeU5bb1tiYgcNStzfeZSIj59wv/BQ5wKFjBY7tHfa5LZssRHtZ51Ob3sMIdn6UJAa/2vNuc3nCPIP4iggCBsHeWStKcmKC2V/L69G380X8GQKnNZ83IcMzqtA6BI1dy0Hi68gi7vv8e2mcKTb8JlwyHSKRlRYc8X9z/k4n6R36zdgIpsnHvBlGYlOb5rW5azm64wrLS4ZxY2lpRqVZVLa49yZ/dFijerFM8Rvg7hwSG8OX8DK0d7rJ0csHKyx8oxHWbKuKvfKI9hACt7wyFxH84Kr9p0BeUT2acF2KZPR8jHED6+DYy/cDJAoVCQs3gOchbPQZsJzbXrfT3ecmX7Fc5tuconv8+kc7ajZD3jvEo3zTkHQLdx3yeJzSkJGo2G6XP9AZjzZ9KrjScUz16ouPswgozOZmR0VpDB2QwnBwVmZnF3/k6fFwRr7RqGE4UHBgoy0dXlv9U1i0oPEJVLECAiPBUlD0ogonIoKhQKqtXLyfPH/ty44EO5qllNbFnSw/fhK/7pPM3UZvDspkjrExoczoNLL3lw6WU8e0D+Is54PPYHYOy8anGWHTdGRPuMHZd4SvVfiwZlYf8V3e+3AXD0hliMwZIehtdHqOB5ZLBAqbh1DlMtlq8LZt8Rkafv1Y0MCZo0Syx4+sLJ69C+nslMMBkUCgVbL7SjVcWNKJVmjFtSh0Y/FkxzpNqXmL2pMWvnXaNKPTcKFUrDLsCAU3rRT7p6IfkdBpICKrUClVru+ZQtb0r8t3qtkqizahaHOw/m2ugJBpWcn67fxOsDhwGovn6l9PFDw82llZ7fBNhKKT0bU/7NXX3Fq5HHR+GQ2ZEsBbOybsAaDs07SLPfm8eytzw+hlqkCKXnKASGKslfNicVmxTlwq47TGz5Nw16Vsbe2Zbec4XX6Yu7XszrKVRWZ18YREZXFa8lOIwMdqFSSs+vA2yllJ49PtjGq/R8fo++h9Sq24PIldOae5dfc+vcK14+fk/OfLHPon8Kt5BSena2DsUvxPhrtlaqCYmQ8xbM7hASp7JlUEAwZzfpes5d57YjQ6VKhIeEcWntUY5M3xInoehsG4qfhAKwvVVMNeLtzfrGUto4FOvYWO93kawfuPsmFvcAA3jpl05K6fnma2cppWdrC1WClZ6NRWCIBQ7WumdPFZnzM51zOvxexlS7lK1jMtiGSis9vw+yIoOtcYOJzO6ZaDi4AU2HGd/zf+JnS17nIFZPEqRxy74V4iz/6FMmaaXnIOvs2IZ4xl8wEmaOWVEHSOTVVVpJDbj+nCue047t0sVLzoFQhZZVejbPkENK6VkTFoLCUr+Oqdr46wSdZk9y0n5XBwdgZiOItL+WiLCt0SPiDstS+TzA3KWg0edLr/KSUnp2MA+SUnoOUltha5bwgXWAn0gtk93dkF+UQITGXEpBMkyjlFJ6tjULlVZ6VipUUkrPIWpLPaXnjwG679Xq5WTNglucOvhCSygWdHwvpfQcX3toCK72wVJKz/bW4V+l9Pz09G12D18aY72tsz1Bfh8JDFbiYJO0ESC3vB0p7irytP59b7h2fWhQOC8f+PDsthcet7x4dtsbj9teMfZ/dFfXPv7Uq2iM7f7pCgulZ+DcWXGevPlif5+U2YpKKz2bZ8wopfRskUun9LzAQJfE5wPc8hDLbQ+46SGUoA3hewNzYZpgGBuZdn50G+NsUgcJpWdjEfFaKD0bC9W7d5hnTLyJqfNXwhk7TeRzu3/WWbRRltZowmJPjfUlzGzTSSk9m2fSKT13nQTP3sCJv8TvcSvg6BUokAvKRjYHyhxxKD0bgCZCKD3LIPyJUHo2Fmr/MMycjA8Ld7ixhMCSveItV6hkJu6G9AOQqoejysu0J9ltA/EMir19+lp4B9vFqfQcHR37lwYgRI1eexIfAiLscFQan49QpVAKpWcjYa0IIUQj1/6Eq5VGKT0nFJqIUCmlZ4XS6pvScwLxjVCMA8r0GclcvhS+l67zdPVqCnfvoN32dOtuXmwXHn11NixBaWtOqCRHls5anlTLlM74hgswinxc2VknKlOhTQUcMovBjZ+nGNxc2Hg+VkIxXCUfLups5CA8uWCjVBOuMqPnvLZc2HWHR5dfUr9XVbrNak24CgLefmJ0/cUAjNzWA0dXZ14HSpIPEmQigJsEAQSQ1znu+xwSFM7UrjqRoco/5KdAbktATZ7CGbh17hVrp57ij9WxK87KDhj9wmywNDfeyyRMZYa1Us4rxfezJQ5WsTdGfcvoe5LmrFIKc4tw3nqJHpoqXKVHVH2J1wG2WEhcQ7jKLAaR1XHvbB4fOE+I/yeC/T8S8iEw8vMjwf4fCf8c9ztd9uf6mCl1HZ9br52xMFcT9Ep4UjiWLBWnje4ZPxptP0CBzAFS5RNCJsrWG/bW4YRF2+fje/F+WDvpZmijb7c0V8cgduNCYAIGyDKEPyD1HAEUzvSJ4M+6zqKNJUDsx8hrK59H0jLwafyFokEdKCd+owk3XrxKo9Ewb6Foc6b8bo8mwriOsrHloqAONH4QDqBQWsYYMB7fYsuxsxG889Pw/oMmxmdIHFVlOjsFzvYq4c4DmKXPrt0Wdf3NW2SCOAhV8wxx51z9EjJkIoBfhL1UeVuzUOkBXXQ8fybe56xuTnrHif5dlrxTKlSEaYzv4oaokz4PWlyDv/LVBIl46uBLhkwUk1wyZCIgTSYCUmQiIE0mhkTo7lnQ+wAtmWjtlI5Wy0dwYfEOnhy5Qsb8OXl54S4fPb2xdHMx+vjWkpPyAO7pP/Mx1MCzYa7EtYgbrkXcqNxOt7qCq37dqlKp8XjkT0YXW4PPZMawp2BhS1hYtPraInbmLMLzBijlnj+Vt5xgYhSZGBtc0kOd9FBHcBWoDXQDIlQQV4aYTWfE58+VBcEYHxQ2glQ0FspscuXNM1qiDkqc6IU3PhpadRV9u6MbLEhn/gl1EGjC5NofJLkTVbQ5wpuPwe8j3H4ExXLDlB5Q/gq0HgUewt8h3vv8JRSWglSUgTIHqCV0MszTgybI+P9JVaUnthg/3gjTKKXIQZAfz3iHp8fZOunGrg7mcv1JkL8Gq3A/kPibNBGhcfQ4DZS3y4SFxCQeIAhLjZHlgJKl7Llx/SMB7wJwdDSiLbKwlSMIw2O5D+FfT3omRGQlNYmyfCMU40HpkQM50OxnXuw+RL4fW2BhZ8uLvYd5tHYLALXWLURpm7pzaHRa1gen7BmY1+APLm6+SIMhPzCugi5nW7flscQ3pEHMufIrA8v+ybzu61l4dzTmSnMGlfsTgG4zWpC3TE4TW5gwWNtaMGB2Q6o2LUir3LM4t/cR/u+CaJBrvrZM6/+lLAXZxMDEA70JDQrH4/Yb1o3dz7GFB/H39ufWXiHIUqJR0l+zpZ0NRVomfrjqm38FQZytpZHuAGkEb5/5sGeC6D3bpU/b6qiLRh0DYNTyJia2JOkxborw+uveyS7Fhy3lczcjn7thAuBLb8aEwBjvzLSA8HAVezc8YGwvEemRPTLk2SG9FYEfUtbEY2LC710wf8++obfOylp0xx/cem9gj7QB2wyO1BzZCffqJbG0Fe9J/noVeHLkCi8v3AXg1bUnZJAgFE0Bc3Mz8hYyLKoUHSuXCXZn/GTjvYlTMmJTdQbYGRkIUjumw2aqR0iohgpNBZm4dIqS/O6mqZ93T4Xv+kKT3wSBmMlJELwqNTx8CQVS5/DkG74hVjRsmp19Oz159uQjufPa06x5Zm5c/8iBfe9p+6Orqc2TglojH/L8LYdiGoJCoaDUiP5cnzqPox37UrRvV+4tFYqx36+ej6V96s9hkKus8F23drAhJDBYSyZa21sz+tQYlJb/ncfEIWM6Ok9tyqoRO+lTROfdVrdbZb5rVcqEln09Gv4s7HfMaEtANDLRKaMNOx720Q5o0hJyFRGeOfnK5mDd2P2cWnFMu63P5kFkKZj6EvtG4cMlkfvSLnfKyc2UFAgO+MyFhQe4sPZEjG3FfijL9e0Xk92m5MLuldcBqN06bat4azQalq0SniTjfk26sKKUjEePhRdktaqpv08RG4I+hbFl2W2WTbvER/+YhGHtZqIvUrx8Fs4cfI7f2yCcM6X+/M2BH0JYM+8ay6ZeirEtRxxh3mkRBRpU1H5/98STfcP+0tuer0bx5DYpyTDmN5FmpkuPXCa2JOkxVKQdZ1Yn09qR2NBoNOSrLsjEvj+b0aCm6UT8skaL3n72BnJnhaOzocYAqD9M56X4Dd+QVtCsTS727fTkl87nmDq/HI2aZGLcmKfs3OGb6gjFtI60xyAkAVwrlQVAo1Jxe55QQK6xfDZWTo5x7ZaqEB4cRkg0Cbd2f/5IyUapm0BLKKq1K8u/M44S+E6EYeUpnYN2vzcwsVWJg3dvAgl4p3Ppnr61JVUaSCRDSaX4q68u3DtflYJ0/KtbiveC+q9CFaHi7q7znFm4kzAD4eC5K+an5i8/kLVIDgCs0lkT+kkuFURqgJ+PqH/sHOXSJaRG/DpGeGX165nuP/teTvlT5GobOSLtCHK89w1i3fxr/D3jisHt1jZKeowoT9teJbCP9pwXryAIxVuXvKnxQ+pTd/gYEMr6BddZNNGw4FnuAk70G1Oe+i3y/Ge8UaPjxfk77B++MMb63qcXYpeC8msnFqys0rZq9+NIQXZ766jUHGkHVVqK57FkYQUj/mf6IfPhmVBnCNQaJAjEXNE4FU9fSNm+vfIIDVWl+ffnG2JH3UYiJczlC++oVW6/dv3RI364ZDhBvny2VK+Znuo10lO5shPp7E3/jsYGtUYssvukFqTcfz6Fofjg/3Fr1iIAqi6ahk0mudw2KRl3D93g31/11ar/q2RiFHKXzMaNI0IJucu0ZqY1JpGwcMRBdi7VH9ildTLR86Evv9XW94AwMzdL9aTF52ci91368hXjKZk68OLSA878tZO3j2IKhDhmy0jtAT9QqHZxg/cto3tmXt9+iSpchblF2ul4Tuu7F4CJ/7QysSVJC7Vaw7pNgjz9dYBc7r60hAMHRdKyEsVTt0feiumXmTfmrMFtLtnS0f3X8jTtWDhOj/gSFYRn+a2LXqmCUFSp1KyadYWFEy4QEREz61TOPE78b3RFmrZ1wzyOJHS58jjy4mkA4eEqLNJQXRaFO/+e5MxsnRuVha01rVeO5J+2Y+LYK3Xi6WNRp1WoZLyAWmpFsxni898hprUjCuduQfcJsHyamqrlE+5R+NufEbyMTFW5+++ECxElJvLqUu7i7QeuzrD3T/jhV6g9GG5PMp1tiY23PkGUz7GOTn2KMH7Od6Y25xtMADs7JY98W3HisBcnjnhz4qAnb97oohsePw7i8eMgli99HWPfdOnMqf59RqrXFItbbtOmSPqWQ/EbeH/rnpZMBPDYtodi/bqb0KLEgSo8gtl1xxPsL7LrNhzZitt7LvHq1ks873qSvUj2eI6QNrF7wQktmQgwuvZ8lj8bj5mZ6UIdvgavn/nRtazu+Z2+uwMTO/9LwPsg/Hw+4+yS9vLQaTQa5vXcxJUDIuSoXMPC9Fvchk45x/Hw5D0TW/f1eL1tMwDZWrY2sSVfjzmV+sVY912fJpRsXR0La+HuYB+HcE4GNxde337JB893ZHRPO/PzFw8/A6BklbSdGGngr0IkZfhAp1RP9CcUGk0qmoaOA2q1Ro9MLFA8I92Hl6dWs7xxEmlfokgZ8R7fuhRTYTclYlDbPZzc+0z7O2suB/r8XpEGbQuiVOqu2zweRc5q9XKyduFtbl7ypex3ckI6KRUatZqz87dyZ+sJ7bpMBXLSaHZ/rOwFeZ7eLQsfnnsRHhwKVqmzn/UlJowRfcjxkwuZ2JKkxedQCIvUK3DLZFpbovDUE4JC4Kf+wrBe7c34rY855ubGty9b9qpYt11MDnicSRlkYhT+nQgtRkPD4XBtORR2E+tDw+H9J8iQRrJmZMws9AnWLLzLLyNKkck1dU+2fUPCkN7ZiuZt3Wje1g11gD5xGBam5trVQE6e+MDJEx+4ekUnwvTpk4q9u3zYu8uwmGCpMo7U+D4T1b/PSJlyTlhapo22x1T49u/FAQtzNf4Pn3Lp96kAVJoxDgDPI6cIC4ypnGolqTb3KQHKom8/ySV8fxNguAJ+fPoek8sP15KJw05NokzryjSbIhKgrOm32qjjyyqXAvgFpawQvuAI3Wtw/dB9ts84CsDCu6Op/qMIdx9bX9/LLbOdXML4DJLln/vJ9Qie+Bm+z1N77tCSicUq52T/u5EU/y4XI1cI1e7pgw4ZfY4gtdx9c7Y0XuEVkFKEjkJmu5gDtJf3vemUc5yWTJx6tC/9l7RFoVCQs7CID/F+ZJxCYlIr+SYExbP5EXBD5NazyZ4j3vIe7+S8vh76yqVySIjKZvT/qUKX+hRtWpluOycw8Px8Bp6fT7mOdbRkIsStLJrRLTMA7zx0nYYwSRXpuJS+Y8PrWOrW2CCjbO39RKiKuhXKGE9JHZ4EZZayByDMQS7/ppmDHGGrsIhbsCwiQsPWnaINGtjHCYWk0mlCYOZg/H8K8irSXypCxwf1B08OHxGd4K6djbNN9d5D6hzpVXLEnLNSThk+qm0wM1Nw6cMv3AgawM3ggWy+2IG6LfNLkYmANvz59iVv7TpZFWnZ8nEpMMeHKSvrM2tjI64E9uNm8ED2P+hK4/aF9chEiF9Jumo9MXlw+qAQ8yjoKCfQkt1BPvWDq71cOx3X5E50RISEsWPwIpZU/0VLJuatXZYex+fTcvkILZkIkL9eeQA8Tt/kY6ikinS4vCenxwe5SdSL3nJ16zvLPBzYK9qjUmWc4i2vzF5S6vgA5q5yqREsJNM4mhnZDei3UnzO6yx3fDBOCTo6ImI6IRlEx4Zw/R8oE8nlLlmvxu27cGq2DcP7bfyTNzfvqxn8h+jX3NhvgVIZOxGpsJRssyTdeMwNkLSl8onPDx8hQDjCsnGs+GwZM5NAnNAkoNqLeCVXXvVBrrz5GaEEr1AoWHfgBwDK51wXa3lLSWVhkB/PuFpIXoQkAlW6+vDNS+PaX9lrCLWIX0gqOhRKueMrPr+Nv9AXUCnkXggzR/2895aWZlSs5MSvv7mz72BpfN7X0FsuXq3A9LlFadzMFXsH/XNdvxrA7OlPaNbgAjkyHsDFYR8uGU7gkuEEJYueY8AvD9i21Ye3bxPeN4gOlVqRoCW14JuHYhwIePOe88PHA1Bh8iic8uWm7LhhXBk3naMd+9Jgp36YcKhkxyZdAgaxmdLJdRizfkGIqFVqFrX8E78X4sWvNaARlTvrFGizuYkE4YE+AUYdX2aQHAVn26RVb4zNpjcPvVnacxUDNvYmfRYn7XoHK11jNL/nPwBMOzMEazsrfp7SlJMbrvD6kS+Xdt+mfONiAPh+lqto30uWd3P+JFW+cCb98k9u+9Cjyt/a31M2t6ZivbyABtBQvqYYuJzY+QilwjhCyNZM7r75hsqRorIkEIDvZ11nTqPRMLvrBq5HepcWKJ+T0du66ZVvM6MjMxpOZ8PAVQw/OCLe43sH2mCtNJ4wC4kwlyIVZY4dhVuvdZ0C+2j5pm7PmEuOhvVwKqyvKOmeUY4ckH32ZJ9tEP9TFEp1bRJtveHy9lbhBgeO2wYt4YOn8HDzfvIWt6qijLWFSup5iouwjA2uDsF61xEf7CVyg60YsBGAyWubYq3Uf55WTDnLiklnOPfpV7312S3fGX38KFgGPpUqr3r/XKp8fGRc74F+AIwZ7iDKxlL+2OkwOvYN5PWtLwi3BBCQqnfGTSZEwcxWrh6TVXk2S5+dPyaLyY9BA3SEbWCgigJFbnP6REHy5tE/pnkGd6lzfDCX83bzi5CbhFAqVIRpRHdSYaUkHERTkwCUs53BiLm1AQgJjtAe11IRIUUSKhUqqfKyBGR02NlbUqtp/OlDYiMt1/51iwD/ULoPFqlmTh18yaAJFXkQIJdaxzNQXmHc+2PcpP+XMKauVIVHsKCmLv61TJeGlO3yg54H8otzt3l16T5VBrYhX51yXFyyk0cHLlK8YRmpfqWFuVqaVHRz/qQ3kRwfymf9IDV4zx521+D6C+f8+GfNK+YtLqG3PsLzhtHHjoLKW64eC38heXwjuAGNBk4/EN/rFzZMTnm8hQk7YHFnsPri0VFYypGKyiyg+Ry7LXO3Qvs6Qv3YyRy2LxHr/1oP05bCkxdQrrFoh1dMgToGomjf+0OjLuL7nmXgbBceN+lmoM/yxhd+GgqrpoDbF7p/sgRebPdh1TDoPB1aj4GDU6F8ZPXz5h18/ATpJKoCjSQfZ5EDPvnBubtw4qZYvERTzvrfoFJh/fJm6UEtMTdv3eBnQIw3atfJiHNGK/zehbJ1xW069swfo3y4Wmn0OEZ7DoXcWNpP5YiDue4iLp58zczRF7h5yYeJi2rQuqv+Rcu2J1HHDg9XUzPfWrLltOPC03Zx7iN7DeqA1wltlsX+ag1LF3sy9vendOiUhZmzC+htN3PMJv0wacKCpGxSfzTsbRgb3NxscHOzoVOHmJO1nz9FcO5cACdP+HHqxAcePtTdXy+vMDZu8GbjBu8Y+yUU30Ke/0N4e/MeWSuV0f4OfCZa4LLjhuFcRLw4mUoV0273uXgNlwqlk9fIr8TStjO0ZCJAgZpFY5Qp1aQ013dd4/ah2xSrWyzG9tQKtVqNv3cA42v8ydgTv+qRilEoUjUPLYbWJmN23bb5N0fSr8RkFvfbTJFqebFzlOuAmwJRZGK57925fMyDv347Ekko6uCYwYaA98H4+X7GOXPqD3tePXqvlkwEeHjpZYwyGXOJ6V4/T79ksyux8eGeIB9cq1XRrvO//5C3Fy6BRhODUEzLeHZWF77+/rmvCS1JXLx5KDpN7gY8FJdPPJPc5iQJwsI07DskOsS9OsdN2nXsKzz41GpNmhSxePJEDJ4yZtSNuE+dFhMBR44ExiAU0zqmDjhiahOSFRMHi3e696+i/3nvhvzkQEqCuYWSHGXyU7hRRdxrG87ze+j3ZajCIvhuQGvSuYhJMs/L95PTzCTDlg3ClW7gUH0P8Kb1hUjPl4RiasXSE+KzYxzp7TouBt+PIjT6S0IxMeHhJQjFuZH6eytHQK0soFDALx3Ecv0eNO0ttnf7TXx2aAoTBoBSCRERUCpyfnPmb1C8QMzzxIfwCKgYyQOp5OeLjUa1SDH0x68hOBRsrGDJQOg1Bzr/DVv7fP05gsPg4jM4+RBOPoLXRjjpOSXBUOLq81a4p1vPsP+dp83PefREWt6/C8HBOeljvJ8/9mfu+Evs2/Ik5sZE7JJYWIiJjtcvP7Nm8X069TZtygSNRsOGf7wZ1P+h3voAf3mv0JQGu3RK6tTNQJ26uom7qElwtVrD/ftBnDzpz6mTAZw44W8iK1MPvoU8R8OVSfPRqHXeIK6VytJg5xo9EhGg9noRQnpt8pxUl/uoxZ+daDLhR3ptHQ7ApoF/xyjTdFQzANYPWpucpiU5shfKSpsJItR3fI0/+fDGP0aZIWs7415CP3eknaMNPeeKXHX9SkxOcjsTA5M3tWLdtV5M2y56Np5PP8R4VievaQTAtEFHk92+pECLwTXpMrUxa1+Nxzqd8CbwfRmzBxQlOHTn8O1ktS+x4LFpGwBurZtr192ePgeA/N1/NoVJJoN9Ziftd78XcjOXKRWPL4lw1kp1U74YxdegWz9B6k/6Pe7YunfvdW1yWiQTg4PF9dnY6HfHfHyFJ03mzCkrf9c3JD6GTqoEwKIphtWwUyNaLuhHofrlYt2er24FAHzuyoXvpwb8/puY6Oo3SC6lRGrDzEjR1ZGNYy/jGxkgkdScT+6ssHWC7neXqZCzGoyZI4hCgFKF4eUpuLMPqopsRqzbCbm/hwotxSdA+ybQukHC7MhTV3x2bwV5kjj98ZxI0rDbTPFZJ9If5ranLq9lfAgNh9OPYOJuqDsTCozULSXHQa818M/FmGRiidwwoDlsHw9PVsOztWIpJBlabwxsbJRMni/qi4r5/tWuv3DahyIum5g5/lqinzPAP4w/Rl4nk3I9mZTrqVf0Hz0yscXPBTn2qCMPQ/vQukvhOI4kjwcfROqxUf3O4eUZi0tuEmPf3re4ZDiBa8aTemTi8BFueHpXY/nKIiaxK7lgZqagSBE7+vTJxsZNhXn8pPxXH1OtBrVaIbkkwsUkE74Ril/g/Ojp8ZaxSGdHrh9ESM6NaQuS2qREReY8rpRoXI7MeUQuOUNePdbRfOXVqlT0NBuBym3L0/aPSFKx5p/4GTPlBlRsWhzX3MJbaO3o3UlmX2KhUv18ZMsjZv1b/k/0nHYsu6pXpnxN0fIf3f4oeY1LIjhksOP79uJaR2/rCsCfP62JUa7Z7+L+rxuYOglz/7vCi8M2i6t2XXig8OCySp/2FSWjI1/N4trvaYVQXNJL5AoatSjmiOadlwhHL1kl/tyZKRkhoRqOnRZeeZ1/jNulofcw8Wxv/Vsut2dqwcrVwhvt95H6Yck+PoJQdHH5bwWSVKztBoCN3X+HSO02uCQACyamHUIxPhRoIAiCRwcumNiSxEeU9046+7T77l6O1CDK7wqxpUg991h81k4m7qFMAfDYBDf/hoqRHM+qfwVR+F0beB3ZRXBIB+tnCXJx/ACxzisycCu7K0wZmrDz/zRMfGbLDGMSwUMwPjQR8xBcuC88IwEmtRCf/dbryoVFwPmn8Oc+aDhbnzQsPha6r4K15+HFFylbi2SF/9WEjb3h3kR4OFksz9YKInFAC0EsJodeZdc+IvLG63UQ506KMNRylUXE0ZyJ1wkM+Lo8d+HhatYse0y+TFvIpFxP3oxbmDdNFwFTvlpWNp5swcPQPjwM7cOUpd+TLZdcahBjYZfOgvX764vzum9MNsel06c+kM/9NC4ZTtClky5tQ6//Zee5Z1V83tdgyDA3rRdlUiI4OAnde00ElSZhS2qBSQnFKVOmUK5cOezt7cmcOTPNmjXj4UN9t1qNRsO4cePImjUrNjY21KhRg7t39fOThIaG0q9fPzJmzIidnR1NmjTB09MzQTa9u3WfwBfxZ/4t3FPMIHifu0yIn3+CzmVqlGgiZo/v7I85u1OnXz0ATv19MlltSg5UalOethNFqzvh+2m88/Q3ar+JR4Qa7fF1l3h60YDbewpF7z/EtOu8YYdjbHN0FuSxn69pZsGSCrkixVd8X/jFaIxTM2FuqGPx7qoQaHGpUim5zTE58tfUhY6FfU7a3KzJheCPIgw4g2tMl44964RXbbOuJZPTpERHh55i5DJrolO8Zc9fESOlSmXTJsH0xySRC639T/r58nx9xXX/1zwUOw8TRFO6SGEW//eSyg2pEGZmCqLSC0YNUiMiUlfbJAvXYsJ77+H+iwDkrSUmA989kcsNmNLg+1q45BUopF9/f/oo3udiJRyS3aakQPvF4nN1z9jLDIjU0ZjQIuntiQ4HO9gwFl6chDG/iHWvvKFSa+G1uO+ErmyXltCnve732U0JO+fyrXAmcs7+3IaEHSMhGNtRfPb/Cy49hOeR2RJOPNSRhsXGQOcV8PcZePpFTsYCrtCzOqzrAXf+0JGGDyfDv7/AwDpQKmfspHFy4sYrESnW4vuDaDQazM3NWL65BgBFMso5CGg0Go4f8uL7cvvIpFxPVpsNDPnfJfw/CGIyRy47lq7/Dp+wn3gb0Z61h5tRqqJrPEdNPFSrnY36zYTTR/Nqe/S25bBYQcdGBxPlPDeuB1K25HlcMpygVfObBAYKIq9tOxcee1TB530NJkzMi41NwnMMy6J6+aPkyrAr2c73DYkDk1YRJ0+epG/fvly4cIHDhw8TERFB3bp1+fxZR25MmzaNWbNmsWDBAi5fvoyrqyt16tTh40ed0MDAgQPZvn07Gzdu5MyZM3z69IlGjRqhkkxgUWXG7wCc6DsKiF+xtcJkUe54l/5A6lJ5BmgwoiUA20fq1LM+h4kZ1Zo9agJwYM7+OI+fElWejbGpUutytIskFYdXmcm7V/F7KppFm4Zb1nWpFBmV1CrP997GXl5poWsI/Hx0ghufwi2YtEbEqhgT9iyrKJbZSk7cI7FUnqPQ5JeqAOxecFq7LpuDGJzWHyi8v44vPRbn8V0d5AazsiIrMqIeAC8uigzoWevohJRuT58NQP5unQ3uI6vyLPvsyT7bIP8/xab8ma2E4bBg2ST9xiqXRod3oKSYgRHqpVd23wTgu7ZlueYVc+C5Y7kgj2s0jZmY3DNMTr0Y5FWezTO4SZU3pNocHKzm/GXx3rZt8UX79EX5fUfEs/VDnVjEVyQVmAHMM8qpo6qD5OoxWZXnKFhaGg55djFAKKY0leevETT5EqWriJQjb9+I//3uZWF7lDhLUtkkm9Q/IYhL5fnvvaItjpo0unXZJ1WrPEchtro+SqBFFSaOly9S6fn2vstSx0+IMKBsG3fpjfGe/4vGi3yYf0zVD4M8dEBEAzVuFpOUSIkqz4bUhaPwNlr1kCGOvzIg8tHKGEsXRFagJEKuGkPtDd3bCE/Evct063uPEcTisKmw6ygsjPTme3QYFLJZNZRw7R5MiFRXvrcn7mMoJHXE4roPAD9HhlgfvALtJsKyUzHL5MkEXarAqq5we4I+abirPwypB+XcwcLIKjNcUuVZLSmQHLJ/tcH1rllt+amrkLju3voEAI1a6h7svdvibhefPPCnZ5uj5LBYQWaLf2jT8Bi3r+uMG/lHCZ4HtOVtRHuuPW1G87Zu2jQrzubGCZVGQbY9ia7yHIVlW0Qk5NULvuzZqn9tJw56smqFnNJSlELy40efqV3zCi4ZTlCv9jVevRL9rPoNMnD7fmV83tdg3l+FcHCQa3PVAUbKsEeDwjLmdefNJyqV2zf9Y2wzs3eJsS4uxCcMGMOeBAj9GQt1pCiLzKL+JspiHA4cOKD3e+XKlWTOnJmrV69SrVo1NBoNc+bMYdSoUbRoIcif1atX4+Liwj///EOvXr0ICAhgxYoVrF27ltq1xcu3bt06cuTIwZEjR6hXr57R9mTK7ULmkgXxvfGA+8vXkrdL3PnInIsUQGlrQ0RQMF6nL5ClakUpUjEhZNzXqjzrnd9G9+KEh4RhYW2Jpbk6soOm66R9+hiOlW3ikYD2VuEJ6gQmNiq2LgcKBRtHbWN41VlMOz2YjDli7zjuW6TfUv9Zdwq/HR1l1LlklXALZQ6UK58p7kHv4sPt6V1nPWM7bmPZMTGlqVSoqPC98WHPsirPgSrbGAq1cSEkwkyaVHwXZBnrOX4aUYNdC06zZdpR2gwSAiavA62xVqqo27MKB+bs5/CCQ/zQr2asx38dYCv9nibkvTYWF5fvBSB/28ZYWajQaDRoIkSdk87ZBohZ/+SSVG3OFkedYQhfq/JsDKyVqljqDP11UWVklT+NIfu+RDbHIKl6zBh1+5WDNgPQYmRDSmeJWQf4eIqRnJV1zKY7ISrPFn735RT2AuS8hwx15lp3FiTJwhkG6tovyvcYLK531oQ4Rq2SHUaVv9z/pLC0lOqUmtka74H02lu8r8WKxSSnfSMJRXv7mM+YrMrzW7PsUqrLvqFyhIu1Up2opGJ03LzkTYV6+fSUpI2BrCp0ciC6SuiXqFFbhLy/eSnq67MHn2NbOKZoXlxIiMqzX5CVVLsrW98bU7eGq8xwLS3iYh8fukTN/k2NPn5C2lvZurtCdn+jn6U960QEVY06+vK+u3aIeNsmrXKhUOr/hxGe16UHshGez6XKf6nyfPQG9Jwbs1yRXFAqDxTPBCVzQq6MMQmyTkvE5z//061TfxHkcjIy3Llh0ZjboqCwkhOFVWaRUwtWZgFNZPmiOeDFAfgcDP2mwtGLsGmfWAAurAVrcwyqNseF92+hWaQX5MFFYKeMmyiVVVQ2Rm179VCY+A9ULgxVXKBcLrCO7bVTgeYr506UWeXug3lG0EgMH+waNIdQw2OgOQuK8s/fj9m7/SUvH3jh5m7H0/etyZNhC73bHcMr5EeUSvFu+70PZe7UuyycbVjsqUOnLAwZmous2aLVmxE+qA1wh2EOeaTHQDKITbH5oU8rCrhs5X8/HqNWrVakd7bimV8bcjtvZlivM9SraYmLa/z1/mvPYPr1uMrZs/r/a8VKDsybl5ecOXXHiOrvaMLkxgJmjllRB0myxwbQb6A7u7e/Ye70ByxbVUpvm2wfVGFpK9V/i+2aNWFfP+GoUitQqSVVniXLmxKmZ3WiISBAvMXOziL3m4eHB97e3tStW1dbxsrKiurVq3Pu3DkArl69Snh4uF6ZrFmzUrRoUW2ZLxEaGkpgYKDeEoXqU4YA8HjHUUL945+RqPm3aJFvzFioJ+iSWtBkwo8AHJy+I8a2NtM7ALBvasxtaQUVW5WlyzSRU2941Vm8jcVT0evJW7b+KUKGlzwYA0CAdwBXtsvNppsKJSoLr487F2NWxg7pRUPy4a1c45HSYW5uhmMmkZ/t9WN9EsEsWvxGUGDqCanzuitGBTaZRHjkm5PnAcjZ4PtY9/mG1IHoHs/WdknrxW0qfPqs5vptQZQ1bRi3h+fnIB0Dls4uRXVVEg2zFok69/eRMb2NvCNzKCqkXWZSP3JHUze/c1He6yG1omT5zNrve7Y8NaElyQPXEsLbKOh9AGZK88jvcpOpKQlx5Trbv1u41+XOk/SKtMagfAHIkyXm+rsvYN0xGL4J6k6HAr9C/uH6y9PI1Otl45jXGCDmxvg9geImSQU7G/h7vCAXJ4ksRmydAVni8QQ0BLUaSrUV32cMhoJy8zyJhipF4MAkGNMequaNg0xMIzh0ugYA5YscAsDB0ZIR40Q+7SzWG8jluIlMyvUUcNmqRyZWr+XK4Qv1eRvRHp/3NZg5u4A+mZgC4ZzBiqX/CBn1/JmFhLm9gwUbdtcAoHj+Y7HWO+/fh9G1w1VcHPZRuvBxLZlYqJAtJ06WxNunMjt2FNUjE1MCSpQS+bJ3/SvpkvwNJkWK6aVrNBoGDx5MlSpVKFpUzMp6e4vEqy4u+i6uLi4u2m3e3t5YWlqS/gsxguhlvsSUKVNwdHTULjly6BLcK8zMqDZ5MADHfu4Xr91KG2tytxKhKpfHxS/oktJQorHIo3j935iJsYvVKwnAtR2pgzRLKKq2KU3X6YJU/LXqLHxf+ultV6vUjKo9D4Dfd/bCwtqC8ZeEnNzW0VuS19ivQN02IgTn8JZ7euuj1J6Htt2R3CYlOcZv6wzAuFYxQyi6LxJ5UDeP2Z6cJiUYhjoNt2aLREYFOv+Y3OakGJhbpo3e89EVIlSu0aDaBrf7vhadwTLVk0BGUQJlqr0ia/7nZC/4nD6D33LgSBAhocZNpjX9SRD7K+bFH0I4fLzw1Fo8I2kSn6cEbNwuPB6qVol5jX5+aS8pubHoNLSi9vudS6k7p56xUKs15C3opP39/EnqJdaMRb564j4/PZo2+pin9gi3vK69DKfiSEmwt4FDk+HpSv3l3lL493cY3QQalYTszob3/ymelM0hkZ546WPPumRydPhBEIvl5ByBtcgfSZY2qQGt68ZZ9BsSESXLpKdQUREJ0KnNBaqX2svUcbe024M+i4fPLU86Vmyqim+4yIO49WAtSpbNYPCYKRnN27hRsqx4Ebu1EymcajfIRq06ggVv2fiStuynjxEM+uUWLg77KOx+hL27hGd0tuzW7NtXDG+fyhw/UZKCBVPwi5lGoY4MYZZdUgtSjATZL7/8wq1btzhz5kyMbV/O0Gs0mnhn7eMq89tvvzF48GDt78DAQD1S0bVMEawc0xEa8IkX+4+Sq0GtOM9VoGNrnm3dzfubdwl5/wHrDKlLaTV99gx88HzPOw8fsuYVFVRQQBBTqo7RlvH3+oBTltR1XTKo0ro0CoWCFUP/ZUS12Uw9NYjMOUUF3q/kFADqdq+Mewnh6be8+3IAClYvZBqDE4ARC+pxaPM9xnTeTZ3Wglx85/WJXxqLWa9bF9LewC1bPuHp4u/7CbVan5Ar+r24dzf234Y5yW2ZYXx+H8i6LrMI9I49bCBHPRGiHd0jWmmdNj3ajEHeGiV4eCj1q6PumCaSbNftVc3g9t2rRYe5WbcSBrcnF3K7WeDlrUKthh17PrNjj348m52dgiYN7Gjygx2Vy5ihVIp2OCBQzYPHoqNfv3b8+Sd37BdkW+O6/91n+7+KWq0KMa6bSEQf/Fk+v2lqQni4mgEdj7L/X7m8mGkBbtVLc3raWp4cPE+xNrWxcXYg2C+Q8OBQLGxS5ns/td8Bdv59M84yQ0cWTCZrEobQcFCaGxbasLIQyr1F7aGTgX3zDxefY5vFfvzDkU5hzUt+paEpGAMmQ1i4UDieP8LU1vz3cPRcTbI67OTAHn0vtp975uWPmWWwsUkx9Eai4ND5+mS2+IddW19y+pg3Vb935Z9t5XBx2MfZU++pX/Ms16/qR1Xa2pmzan1pqn8vxvWaYH8TWJ4wlKuQnssXP/DmdTBZs8nlK0+piMqLKLtPakGK8FDs168fu3bt4vjx42TPnl273tVVJC/+0tPQ19dX67Xo6upKWFgYHz58iLXMl7CyssLBwUFv+RKN1s0A4N7i1ahC446/V4Xq8iqEBcolM08JaDevOwAbBwiS7MGJu1oy0SpSEXfLiPWmMS4Z8V2rUnSbKXJ1jqg2G98Xftw4+lCrutputJiOPL/9Bq9uvQSg88IupjE2AbCx0+Xo+RQQypYl12mQZ7FembQW9gzQ7ldBwG2adjzGtkxugnD0eWZEoppkwKtrT+IkEwHytBH5pV7uF0I6eVo3SXK7UjLy1oiu9JwwQQxTIyxER5qYKw3n6tqxQgxiqzeOKciSnNiyxpU3j9x488iNY3uyMrCPI7nddJ33z581bNj6iR+7+JCruBfZCr8hW+E3FK4o2vE1i2JxeYmGS9fE/1G2ZNoaFERH1DW2bJF2J+oSiqgcWGkZGo2GtrV2k99uuZZMHDC6NB16p55Jyq+FpZ0YKPo9fc2aHwYS7Ce8Mu/vT7kei6W+y6H3287BEpfs9uQurAvTz5hJnwz9GCje9RKlnJLcPmNQuCfk7wZ5uugvNX+FIUtFyPNdTwj/wkl6XySPWqNg3MIjAyIDd0Yan8I+VWHbIdh+RHx/uifust+QNFAqzTh6via9+uXh9qsWvI1oz9uI9sxYWCHNkYkgHKuuP2sGQIu6R/kYGM6cGU+026OTictWl8InsCEeXvW0ZGJqQ//Bwst70fz/3kRbaoVJ3zqNRkO/fv3Yvn07J06cwN1dPwGFu7s7rq6uHD58mFKlRGLOsLAwTp48yZ9//glAmTJlsLCw4PDhw7Rp0wYALy8v7ty5w7Rp0xJsm7mlBUX6dOHuwpUc7zqA2usXGb4GtZpDbXoAkKdNExzccyb4nKZCRndBvH549Z71/Vfy4IRIKt16anuKNyzF78WH8vL6cxNamHz4rmUpFAoFywdvY0T12QxZ9zOZcznzxyER/u7v+5Flg7YBMObcOBNamjBM29KS4a230SDXPCLChYfbvJ0tUSgU9GuylWmDjzJlbWMTW5m4aDGgKhv/PM6/c09TrU9DvW3d/urA1B/msLLfOkbsHWQiC3UoWKc0BeuUNrhtevkBANhkFITMvaVrAcjbtlmy2JZS4VZRNwD3e+GDa2HThQR/ev+R0E8h2DjaYm1vo5erMy5EeSd2+LNlrGXeeYsQYAvLlCM0UTC/JQXzWzJ8oI4U02g0XL8Vxq69n9m17xPevvrh0LWqx5+vp0UX0TleNst4gZPUhklzhGfnr0Njqr5+A6RztOJTQNIlwTc19m3z4NJp4V0zYd53dOwtRElCQyJYt1i4eKlUasyNrENSI8KCdBNA4dEmg56eukXxFlVMYVK8qNeuCPXaFYmxPsAvmPo55pEpa8wciQf3icmUJi2zxdhmCoxtD2uPwrMvskK99BXLjvNx7z+nQ+zbNBqICgaxT1mp2RIFDz1g0FTx/fq/wkPxG0yDYiWcKFbCCYVl2vBgiw/Zc9oxZW5ZfhtwhdzOm/W2DR6el+Gj8qWZnMu164l8wksXPuePqSKirkm981w8/wGvVyVNaFnCkdZFWUxKKPbt25d//vmHnTt3Ym9vr/VEdHR0xMbGBoVCwcCBA5k8eTL58uUjX758TJ48GVtbW3766Sdt2W7dujFkyBAyZMiAs7MzQ4cOpVixYlrV54SiSNMq3F24kvBPn3l77RaZShePUeZA884AZCpbgvztW0kdP1xlJq1Q9/aTtZTS85sA2ziVnqNQokl5bu66pCUThx8bg31GMZjLnNcV3yfeeN55SfaiX0+Yfgy1wN4q5YQxBYYqcbDSSa9VblEShZmCZQO3MrPDaqacGIiFlVLk+SwvSOoBf3fA1tH4HBQZ7EKl1BHv+zpIKT3ff5suXqVnAJdsIldXFJl46m1/Pc/FI9sexkooBqmtpFTOHMyDCFQZ/x9ZK9WERMj1zjLahvEuKG51RIVCgUuu9Pi8+ECE5wuU2XWEk2teQaZ7P/E1uG82xyBeB5g+10h0wY6iWT5wy1NHtJhZxF2Nv/BLJ6X0/DrAVkrpWfbZBqHaLKP0HBJhjrXScE656KFxfs+9cS2cS7putbcKl1Z6NvQ//VlzvNQxvkTFFjpFu2teDgaVnmODZ1hGaaXncOdCWPgZVkA0BDPHrPGq7CkUCkqXsKJ0CSvGjXTWKQYakaoEpSXhwaFEpQvNnDHxR2vmThmllJ41YWEoLI1XYFUHBRql9HzlhmhzsqV7C2SPu/AXUL33kFJ6zqT2FErPRiKz1ScppeeQCDOslYkrStdpSEUWjjmp/R2hMUepMD6vZJhGiaVCUlI1iRGostUqPTds6c517044OeuzLtEV3EPv3sS2uL7KZVzI7hAirfTsbBuKX5Dx9bdsfW+oblWFR3Bw2Dy8bjzSrqs/YwDZyhZiRY3evLhofJ2UkH60bBt30dOJCtn94yyz6k8hAjlwWi2eavKTR6G7tl3bPAFo3NwwoajMXooIz+tG2yP2cZNSerbIpVN67lRbLF9CrYanXnDjKVx/BjcewsMvSMei2cHWQHVoZifUnPeJIQTtysRvkyZUKD0biwgvodycVOU1YaCIo6r/HAx1uonv/86DDE66/YyFQimn9GyeSaf0/C5Q5L60iqOrYuEG4c+NP35CEPFGKD0bC9U7ofRsLD7v3y6Uno2EJiwIhaVcP93MMRvqAOMFvywDnxLmkEfqHDII0VjHqvQcHd37FuDQ3tccP+TFmCkl6d07C+bmxpFOChsnqbBnhaWtlNKzOuANZo4SD0YcMDOLeU0Xz4voLZVKY/Q1yz4bstcsA5VGLLL7pBaYlFBctEh4/dWoUUNv/cqVK+ncuTMAw4cPJzg4mD59+vDhwwcqVKjAoUOHsLfXJTGfPXs2SqWSNm3aEBwcTK1atVi1ahXm5l/nyRESbk69dfM42KE/V8bPoPGuv1FEm446NUgMHi3S2VFp3KAY4QHxQbYTBEiRiYBRZCJAsR/KcHOXSOw64eZ07cBv79Qd+D4RPQqlZczHJUwlP+DLYJuyvA4szNUEf0FklWxUis5qM1YN3sxvNeYw9sggVg7cBEDx2oXIUiEmuRwXPocpsbYw/gFxT/85/kLRYAyZCNCrti50fdHu5jimMwMiGNhmt3Z9bIMwmcEcIEUmAtJkIhAvmRiF3zd15JeK8xjddCVTr44DIPRzKL+WHhfnfu+DrKTum7EI/RRCoI8/H98G8NE3gECfyE/fAD76+hPoE0DQh5j3tEr32jz0deTFv7sAKNy1bbz1SO4McmkYXB3kVK+9A+Vnh2XJOwtztVEE5FuPt1ryMVyibpK1B0Td+mX91/SPn3h24SHBAUHRls8EB8RfDxeuXoAIte4aow9gvV4Kj70Ktdxi3V+WTATRSUZpPFmmev9c6vhRZCIYqVYcEcaUueK/mvCrXfzlJWyPguqdXK7YuMhEjUbDkn/UPHiiwc9fg18A+AWY8d7vPUHBxvUEzV3iDmE31BmWIRMBfCPiDzOPDs8gOc9QS3P5yaD40LBLGS2h+O5dGBkzWhKhMb5Pp1SoCNMkbRdXlrCMIhNBvA9fkolR6NKvKCvn32H04CvMOmI8oShLJgJSZCIgPXlkqG7d3vUPAl4JsYBcVUvy4vQNVGEJm2ROSD86g11orO3J9vHbuLj5YoJsAajUqBDu1l6o0b1DB/aKPnTOglkwZK3m5SUUFnLtaLiH8aQr6MjEuGBmBvmyiaVFIeAH44+vjuyyDhEBPAwzUqREIzEcUGYCjUTXWOkmR94plLGTgxoNFIr8P0b1gDL5RVmZ44Pc9YIg46JQQQSp8GRJ7OXDXyatPQCWboDE62rmCBoJjsauYQ00wXGn/tGDhS2aCLkLiW9i9EsosxTBmqRLqaMO+mCwbjCEjVtLAaUEORgWgLGckyZI4j8FNOFyYwHzDG4QnnhkXI6c1rx6GcLH94HYOyjpNyAn8+e+ZN+edzT+wbg+isJWLqVMUpGJ/wWYPOQ5PigUCsaNG8e4ceNiLWNtbc38+fOZP39+IlonYOXkQJ7m9Xm6/QDnRv7Jd1N/A+DWojX4Pxax/fU3LEj08yY33Mvn034PDwnHzNyM8WV1mYYH7PqVjG6pMxdDQlGuicjNtmrwZsbXnq1d32txBz6mLE7UaBx6PYCPH0L4IfcC/td4O0ee9aB27mXa7fsfdDWhdUkHl1yiUQn5FIoqQsXzGy+Z334pAJlzZ+K3fckT7rxr3EZu7rwUf8FYULnz9zzwhwfr/gUgT9M0mqRIAmGfdZ0e/5fecZRMehRvVJbijcoa3PY1Eym7VonkVc26lUzwMVILlqwR97PrTyk/Xu7CdQ2T5n854WD8BMSuDRJuG/8xeL3w135/eMObjLVTXzqZhGLohHKsnH+Hp7dMW58lFepN74//8zfkqFgM/xdevDh9g4d7z3Bl+U5Tm5ZgMtHazoL2gyqlmZDDhCD6kM5Ofq4nRaNaZNe4UgnoGXtmkiRF4Rxw7xUcuAb1DWfG+YZvSDPoPzAnwwY/Ys3qN/Ttl5OevbMzf+5L5i0ynlBMSVBrFKglQ5i/qTynMRTp1o6n2w/w/s5DAp+/wu/eY57vPQZAo+3L00wHotmk9uwYtZ4tv67jwYl7ANg42jLixDijc4GlNZRrUoKgwGA2jxMefMO3/8/EFn0dLCzNcXbRef5EkYnla+Rg6b4WaeZZNoSfx9Vl9bhDzGyxgDeRcTwtxzShavtKyWZDhZ+q4X3fEzvndNi7OGGfyRGHzI7Yuzhin1l8t3Wy0/OE/hIqn2heX//R9xLgxdnb7B+hn9s2X90KJrImabEzUpClSsO8JrYkafH4mXD3yJHVLFXURZVKm3FmmwVqNTg7gb0dKJ3+WxNviY39624xre9evXWFykrELaYB2NpZkD6DFR/eh+Lz4oN2QiytwN41A/auGQBwyCZyZb08e0u7veX8X0xiF8DUuzFzr1fILufZ81/F9kjRlp/TWDM8aRm8jBQT3vin6ezYMBRKDIBflsTtpfgN35AW0KatC8MGP2Lu7Jf07ZeTzJnFLMWdu6nTo0edAJXnb4RiGkTNRZM5/r+RnPjld+26euvnx5u/LDWhWMMy7Bi1Xksm1u7XgOo9apnYKtNCo9FoyUSAac0XMebQQGyzJU6eCFMgIkKNjZ0FwZ9FzMJfO5pSpZ5cCF1qRN2fy7J63CEtmTj68FAy5syQrDa45M9Kz01Dv+oY99eImKKS/dOmN2lcCPsczLGJq3l+5pbe+iLNqnJ3x2mtSmhaw4d3IgxDaZFyBFmSAu16ivu3blHqmX3OlS3pOnxfmbUl1SA8TMXMAfs5+M9t7boMrukoU9ONQxvucOeCJ9Xqp/02KjrW7vuBRhX+5c9uW5l1pIepzUl0aNRqTk1dzZNDOo/AmmO7U6J+CRNalfgI8BcTgKXKp31v5JGRDqYD09Cw4ehFWBoZxv14d9xlkxp21t+8FL/hvwNra9EBCghIWbmQv8Ew/rvuLZKwz5GV9IV0YcE1F03GytE+jj1SF1ThEfxRarD2909zO//nyUSAKU1EOHup+kXpOrcdABPqzsH3mWERj5SO+9e8qOo4XUsmAv8JMtHjthft3Sdrfw/c2DvZycTEwrOdQhE4R52qJrYk+fDi/B0WV+3D3/WHaMnEXJWL0mX/THqfXkiZzkK9+9mpGya08hu+BhqNRqsIndc97UzUfQ1cXNJY3OAXePs6kHbFFlI30zQtmVizRSEO+g5j68N+dBlZDYD1s+KRnU2DKFJKEFBpLexZo9FwafE2/v6+jx6ZCJC7puF0EakZB3e9AqBxq1zxlEzdiB7ubCOfkjjR8dxX36aE4JU3dB0rvp9bA5Yp4Lo2RM5H//LNQ/Eb/gOwtBQTtrt3+XLn9kca1he8y6UrqS/XYZTKs+ySWvCt124kwj5+4sP9x9rfFulMr/yaWPB++Jpl7WYCYG5hjipcxb4/d1KoZlETW2ZanNtyhdf3RWe++4IfAVAoYEX/jcxqPIPBu4eSOXdmU5oohcl99rN7tSBjfh5WiYuHn/DgxltuX/amWDlXE1uXdNg47TjbZp8CoGa3qhxfcZp5HZYy6+4kE1smj9BPuqTQqSEk9GsQHhTCqamreX5KX/2y3qSeuFcrqbfONoMjAK+vPEgu85INrz38AahcL7dpDUliLFklsu337Sov8pPWoIqU9osK8UlruHLMg2HNN+qtGzizHk2767vcuOYU7/Wts6+SzbaUhAr183PxwCOuHXtC6e9Tf7qD25uPcGnhVu3vUj//QOkujTk6ZgnPT13H/4U39vlT50RfbNi99TkAjVu5mdSOpMamq+Kzx3emtQPA6wPUniC+u2eFtRMhu2RXPTQMqnQW31f9AdlSSFc/upfiwWtQL7LKfOoNq4/C72lontnjWRAVy13i9Lly5C9ghEjbN6Q5jBqTm7Gjn9K9yz299U1bG1aZcnI0wy2XJe5uluIzfzhubta4uVmTKZOFScdNao1COoQ5NYU8KzTGKKOkcQQGBuLo6EjzfxdgYac/mAkJN0cdEcGeZt0BcGtUm+d7jgDQZM+qGMeSURYF0ys9n1h0gNNLDwFQtUcdavRpoPVU/OPWDKOOn1aUnqNDFa6if6ExAMy4/js29jqBgGv777Ci3wYABu8aQuY8Lkad43OYHH+fWErPAX7B1M8xT/t7w7XuuBXIgO/rQJrmX4S1jZKLfsblLEpNSs+qCDUd800hPES4y8841ptchVxonUWos8+4/YdB5fIv8V5SBTMpESXqUnbkL2StbLw3R2pSelaFhbOqbj+9ddkrFKHO2C5Y2cf+PC2u2geA3qcXAmCtlHtWE6r0LAPZeq9Cdn8WjjnJ2pkXmLa5BVV/yBdn+QQrPUvga5Se40K2wkJ18cW1DCiVEp0oEys9G4KZg1x4o3kGN73fb33DKFbsCvXqpWf1mkKx7JPylJ7jw9rpZ/l74im9dYuO/UzBMrGnEKnpOAWA4wG/Ya2U6y/JtlcJwdcoPccHf78QSrmuAWCn7+/xlBZIiUrP13df4+TkldrfBRpX5bvBP2kHdy/O3uTIqEWUaF+fsj2aYW8lp/icUKVnGcjmUSyUTtQxruarAfBW/Rxnec1LebG2pFB6jg7VW+PL5h8uPm+NAiO6VQmG0sgUtQv2wxz9VKz80Qc6Nox7P0Wk7bnqi8//tYER8WSXSU6lZ4DPISKXIuhyKY7bAOtOwJRO0CxH0toDkUrPEjBzlCtv17AGnp4hlClxAQDvd9XjJoMs5J18EqL0nJRQS6owA0LpWaZ8cig9JzJOnfzAndsf8fAIxuNZMKdP+Sf6OSwtFeRys8bdzRq3nErc3axwc7PE3c2KbNksCQ5Wk7/wbQICAnBwkOsbRXFMf1waj3U6ufY55FMIv5cfm6DzJje+eShGg4W5Wq9jEq4yw9pCxf7eowHI3bA6Zfv9iPe5y4T4BfBq3yHyNdWFBYeEmyeoYyMDWTLR2TaUkPCYiZhu777IgYkbtDEBndYNwyV/dizNwynXuiKXt1zg2s7LlG5aLs7jJ4RMtLOMICQi+ZNDed55xYK28xmydxiZoilWG+q8hoeJHkK/1V30yESA0g2KEjK7I+sHrWVWk5kM2jkEl7xxk4pJTSYWyxxgcP2aWZeYP1oM4PIWzcg/F3+ObJRVZM0uZvxCgiMICjdDqYz7XtqayfU6fEPTSZVPCGIjE6NIwyj882I0Fpbm+H62pN0fTdn4+062T9rFTxObxXl8vyArowbKyYUohejc1UvxpZrsgR6/U7x7K7JW0M9BlSu9YaI5NsgOtBKTTATwe/Za+/378T1xr67zWgr/gh/4t8sEQvw/8dP2adHKmGFhrpaqY2QH1CD+V0N1a2zIJkk+VsjuD8COv28AUKleHgBmDT3ClkVXOf/5V73yrhYfiNDI1au2Hx9JlVcH+qCwMP5+q4MN10tfwstH3FhLC1Bax7wXuw8E03vwB17dyYKZmW5QoUgImej3RooglD3H15KJAL7vxTt48OAHbt4OoWQp/Y6kximXhJY0+ITJiXp4B8t7g8TXF7h67JmWTMxfOguTNrfDwdk2cl9duXrOk2g3uDJdRtcEoPIP+Tm39xEPbr0ldxHjJu8AHKwipN6HhJCPiUUmzhx7mZMHX7HrQgu99b6WOmbAQhGBeTwiXK8DrbGRJF19P1tJ9Vtl6nu1Ss28KgO0v3NWLk6tCb0wU5rz5NBFHu49ww9zh5CjgoiGeXzwPDV/+cF440keMrFQpo8Ehhrfhyud/g3hav3y4Wol/yx/wK//O8vLsK565IjS85yUPQDhr+5LjeDC5eaNpMhEdbRbYIE+wfbIF3puhL29v175WZnJePKubx0Y0BXuPIOWIyEsHH5fKJaS+WDZb5DxC5JLYSWO3zqSHM2dDX7tFPc5DZFxnr7wfT/YPxPyZP9ioyT5aOg+2JlD4exwzxMOXoZ6JeG3poJQ/G0NNJVJ052A9HTKrPDxA5x8AAdvw+E7EBH5DCzpAjW/mAMzl7hvALa1S6IO8ierMzRu5MTuPf50aHudtasMR2koLG3ByInLKMiSieYZ3FAH6PqmZ05/YMighzz3CGHs+Nz0+SWn/g6SBKcsMQjy5KD6o8RLHQtWbQxm1OTP1K1hycp5+v0Ss/TZUQf5Sx1PYRn//1T1Ozuqfif6JOKa4xZpi4jQ8PpNOB7Pw3j+SoPH81CePw/F40Uoz5+HER4e048uLEzD40fBPH4kR6DKQJUAURbZ8qbEtxyK0fDs6AWD64t3a0XhnxpTdkAnAH5YLWS+ri/8h4iQlOVpZyyOzdymJRMHn52JS35dq9dgWFMAtv++ySS2JRWUVoLEmPnDdD6+jdtjy9rOir+eTKLgd4bDjIrVLUaHOR0BmN10Jt6PU16eo4hwlZZMVJgp2HCpc4wZvv6TqwOwaPyZZLcvqRDd6fqHnhXZ4jUWC0vdwLLqj+UBOLvxcrLb9jX49F48sxa2MQd03lfvEPjyDS+OpP5cY5kKutHtxGK6nVisRyYawgePNwR/EEIeGfKLDl14kNykS0rHxw/ieqII/y2LrprSnCRB9/5+AGxZbZiM6z1YdJz/K/EUPtGU3Hfu+PpBQEpAqRruTNzcjv3vRjL/SFctmWgIG2fpCJa2AyoDsHlu6q/bYsOZo6+5fe0d/TscjbHt55Gijd40R550MjUiQsRznLFgLn4+OI86k/tgphRt8Y21+/C++ZjgD4HadUHvjJuASK04sk+E7r/1SbpBqymw5qz4/MVAuO2oPeDzET4nw1Ap30CxzNwDqkiCq2hueLhRLD/VFetuPIZyXcG9Jez+ouu7eCtcjoyuPLo4YXZU/R+ER4A6CdurDYPEZ9/l4tPKAioXEN+33Ta8T0LgFwRb70DP7VB4jljyD4dSv8PA9bD/lo5MBHBPZO2hpYvcADhyNJAbN02XNy8iQs2yJZ64ZDiBS4YTtGx2k+ceom+WPYe8V3hqgn+gmlZd/clW/B2jJgtnl0wZUy59pFQqyJXTkhrV0tH554yMH5uN1Stzc+pYIV4+K4HXq5IGlzcvS3DzUj52bM7FnOlZGNA3A00bOVC8mDX26b6e2EvrORRT7hNhAlyZ9w+qsJjeatkql6Loz820v80tLSg7qDMAu9oNSibrEhet/xLhgRY2lph/oVRtYa3zHgoNSp2EqSG45nOl5YRWAEyq8Qehn7+OeChap5j2+5xms/B5krJIRaWFOX+sFLP9GrWGkKCYz3aHASJsds1M+XCblAqFQoFzFpG4t2qLYgbL5CohCPQnl58nl1lfjZ0TRO6pymP7xth2fpLo+Zbq2z5ZbTI1clQU9zfQ0xe3qiUB8Lx014QWfUNCcOO2qJvKlozbhcXcPPV0rr4G0QnFjx/ThsKhmZmCcrXz6HmYGkL5umIS7/LhJwAULJsNgONb0+57/e9pMYm7e/NTjuzRj0ttO0gQqqsnnUx2u74WlnbWdDuxmKaLf0Nppf9ul/9fSwCur95raNc0Af8Pov9cuoKIiMlfWHgKP7rnbyqTkgSTI9WPexrIn3jHS3xmTgYNy6aRWWAWH4GCg6FiD/CIdESztIBJvcBjG2yYoNun/2xBLHaZCMcuw9RVYv29rSJnuixGLBKf5QpBPsnQYxnYWQkvRYCDN8Tnst7i8/eD8sd7HQCrrkH7TTrisPAcqLIUxhyBM1+EyxfOCoPqwb4h8GiabnEzMiRdBudOCZfHBo0eof6CpQ0OTroIovd+KoaMfEfW/M/J5nKK0SOfaLc1bZ6JG7cr4fO+Bk2aJl6CTY1Gg6vLObZuNf1E4qkLYWQr/o4iVfw4f0X0Q9q3tMLjagamjUn6CLTkhkKhIHMmJRXK2dK2lRMjhmZm8fxsHNzlztVzcacb+oZvhGIM/NvGOF/x3PXFVFxEcChvLt5MSpOSBFmLuAEQHhyGWhWzQm4zrQMAeyb9m5xmJTnKtSxP7b51ABhbfgwRYQkfrB1bIrwJLCIl7WY3nZXiPBXrty3ExFWCVBzTbV+M7QqFgszZRE/v+SO/ZLUtKTFxVzcARv6w3OD23ksivUt/XJZsNn0tHhwXA2qXkjFzqoV/Fh4P1k5pR3neGBRuXgOAeztP4latFEAMEZfUjJePxTtZ9YfUL8gQG7bvEV4HLZsYDqU8dkpM/LRt/t8Ra/Hxjk4oJn0ewJSE4YubADC6bdqKkIgLCoWCC8/FZFCPFgd556vzYIse5hz4Ie14tuWoJCaD7u8QRGl6d5FHM+wrJ3pTEg7tEizMDy1FvtMChZ0AeHRXPldaSkVEtOrJIvkzGelhRgd4NBuGREbN+/iJ0GP3lrB0p87DvWIRQSzeXQ8NK4l1J65D18hMOUcWgW0CnM483sAmkWKfTX983bUYA0NeihUjI28NeSlqNPDwLcw/C01WQuEZOuKwzkqYdgque+nvUz47jKwBx7rBvYFieTQNdgyE/9WCeLI9JQrc3a3o3Em4Pv7QRCeO6uUVRu78txg6RDKePw7cuRdKo9ZvyJr/OcUqvmLDVl3KoBEj3Xn5pho+72uwdHkRsmRN/PzqUVFkv/R9zM2bcumKEgPh4Rp+m/iJbMXf8WPPQO36dQsdeH0rI9PG2mNp8d+Y2E1sRImyyC6pBd8IxS8Q9ikIz3M3jCrbdPMcAM6MmYdGnXLyrBmLqn0aAXBuxYEY24rVLwnAjd1pL7yudp86lGkupjJHlxpJQnSJNBoNh+aJacDxF/+g03yRcHtOs1lfRVImBeq1EQTU8Z2PDW7/a4/w2vyl0ZZksympkSm7SI6jVmkIDY7pmemQUTe7FhYilwDeFPB/I4glp6wxc6F5XRY9xxw1yierTSkB2cqJZ/v+9hM45RJ5VZ6fvmFCixIXO1eKyapmXUua1pAkxC/D/QH4c6zhrO0j/xBhkL8NStkJqRMTvj66yIBPacRD0VjYO+mI46i6O39p8W6/95YTl0pNcMlqx18bagNQLvtavX7JxM3tAJjVb49JbEsKfJl+JV+9igA8Pn7DBNYkDfZs9QB0hKLOQzHtEIorIjWWBteMue1qpDh7U8OBIkkChQJ614HHc+DwXMgQ2WxMWQO5W0G9geD1XqyztYa/hsKTzbr9h3WCvAn0LPw+Uktu558J826UhSEvxUWRaVh/PwhTj8P3SyKJwxlQZCY0Xw2LzsOT9/rHqpkbptSF8711xOG9gbCqFXQoCa4mnqueMklc6I2bQZw9J9oBV1fhzLFunQ+PHycsHFqj0fDv7k/kLv6CrPmfU7eZF9duRqZqyGDGykWZefPIDZ/3NRg0JBdWVklPmxw8VByAenVv4eeXPOOTJx4RFK32Hrcy71mzWUzqlC+l5PYpZ17fykjNKl+ZAPUbvoU8/5fQdN1UAE6O+Qu1ShVvsmcrR3sKtBZSYMeG/Im1RdJ7Erz9JDdtFpfYQIVOQlDm/HKdf3xgiC7cOVNu4cbt8/iLKatoSIhghaxASVKg9cQ2uJcTCX5/yTdaev9DM3YCULn9d5iZm1H4e536l5kBcRM7S7lBoccHuaT4t33jllCr304QL7vWxJy2dCuQAQAfz49xkqtBarnZuMxWST+7ltE29kTMfeeKMLIlQ3frbLLTle80XRCp/4zaEesxnFOIGvm20RsBaDezE8Wy6A9Gzk8W4c6l+/xkcN8XH+RCE2QVPGUVocGwEFJCoDAT75o6mpuEOjyCcEmxqITcZ9n/9XWAXJLui55OWkGWCnXiV/T1DpcT3gAIss8vVd7MQc4dwcwm7nop8KOu/bCxMXzPXr0W9zZTxpjuL8YqSEeHuXPsisKGIHsOdaCc0rYh1ezoIc+BgTHbDoW/nFyri6UcgeFqIycKltgYurAxAH8NF32TdgNF2O/2xcbnvZUR0QCkBY0AwjRy5whUxV0HNGyZm9qNcgFQv9RW8qcTYW/lagtBpvP74hZRyuYg792XWVKgRLa+j6uuz1NbiP5533pCnjoVALizVy63sWxdD/Jt3P23cmzKtQ+ijjl+wBOAbDlFW5G7gKgPvwx5jsheWer4ABY5DKu/x1o+j9zxzY0MXZ25X3z2qBdz25LI/IQ95S/PICIko0DdNHBlpSAMewjHZx69gso9hdfixkhvwrxtxGfr76FvG7lzKCIfpQGzxWeNUlA8roACyeFPfPchupdi3l+g1BzdtjVXIfocjLUSGheGeU3h6gC4NzRyGQh/NYGmhcHRiCFmhJyeiZTAD0DQkRsG11+7VBiAVm2fEhGhQaFQcPiA6MNUrXLDaOeQz59VTJkfLkKZC7zglyHvCAkR+1atbM2pA9l488iNW+dzUq+WqLMNtdNxIlyO4FTYOGm/lyiRjlmzxAtbuNBlVCrD16WwlevzmdnrP0wajYaVG4LJVvwd1Zv688FfnOePEXZ43szA9tVOODsZX7+qP3hK2QOgCdP/n4KCVIwd4xHrvZS9ZiIk+/bKxPc6/a/A9MxOCoJDeivKdGvC1RW72Nd9LPWWT453nxLdW/NwywHe33uCz8PXOObOGe8+UUgIASk78I2rM6cwM8PG0Y7ggM/4v36PU7YMWFuotGqNbWZ346+mU1jTZwUDDowxeAwZldMoyCrsJRV6rerN5O8nEegTwKgq0xh3coRR+6nVao6vEgnSG/8meimnVoqwnSK1i2JmFrMCliVR82eU88QomCHu8qMX1uPAxvv80fsgTTrFnC7uNLgca2ZdZv28K3QYYFjZ21Ihp5rpFyYXopgQxfC4Bo012pTkrwE7Of3vbfr/JaZtfT/rZtkqNC/FmmFbubzzBp1ntjZ4DFn136RSeX9+5RkAbsWzcc1Tv0GNiBQhsXI0POgpEIsCeGzIIFnHvA6wlb7uhKgqx4cvOyAyA03ZiRqA3Bk+Sp3D1SFYSnm6QvYPBH0UxFK4Rkl4NF7JzFxBSIT+ubNaB0gTHE6hz6XUCDXB/lIdOk3QhzhJxYEDhAvLqqXZMbOxRxOuT1Z4eYuLzuOuNKi2LKM4HQX1x7eY2Up4O8qqPMdDosYonyEmWezjq7vZgR/VMe5RmE0WkHjlZMnmN59MG15etVVJZvTZzcH1N+kzuwml6gryZMu883QYXduoYzhYRcR4R+JCOgv5SQ5ZlWdnZfzt+srttclhsYJH9z4wfdZzmvbUHwTePPOCElVyGdz3daB8PeYrSa69l1SF/hhqEWv5Cj2b8PTIZS4v2kqLpUJa1+uGnPJ8QtpcB+twqbq7YKaPUv2Tshm89PpKUd8trMXnw3sf9LbbfLgDkgPlcI8rUmr14Y/DUEg0D6r3oIjn8HrBOAYe7dOi20LuRBLqMHcEjcT8jjILaIKE58xvrcVy8xm0Gi9EW35bJBYAG0uY1tewanOciBAk5a5I8vTvX4lTOVnGfhD3IS7YmkOVAnDmoW5dBlvI5QS/VIKy2cCAj4NARAKuF1DmkFNtNncAjcQclW1dN4Oqx65OMKivI7P/CqBy1btcPJadIrmh0Q+O7NkbwM8d7rJ6pWEl6BcvQhk15jVHjwXG2NajozVD/meLfbqoPyoUzReCq7IKxrLK018qNv/Y3JKzpxzYtiOQbFnP4+Whm0AY8usb/tkcwP2LrjjYSxB+kZOdHwI0dP81gks3dH3m9I7w7xIL8ropgHA0weHSfR/zDDkSROBFJxWPHfZnyRIvMmdU0Kd3zNyUsmrY0YlaoyBrvwTUCVB5/hbynIpRsmNDAAJe+eB784FR+9RfPgmAk/0Nk24pGW3+EgIP/w5eGmObc07RkQ308U9QWHBqwMhjowDw9w7gr07G5dNbP0zER9TpVw+FQoFGo2HfDJFYvP2sDklj6FfCylqJnYNoHF48jpkr8X/jRE7Qub+lvsTvcaHU95EJ/g8YfpfzVRCD+ftnnhjcnhLg88QHgCwFY3pWRYU756xZIVltSkko0KgKILxc7FycAX2PxbSEqHo4W255b8SUiIOHhRdzvTqGyfA/polO9tTxGZLNppQAn/9wyHMUchdzBeDx9TfxCrmkNTz40AmAhSMO4XHPlwaZdJPbEztvM5VZiQ6HLOK99r3/3LSGJDMC/eU9q1MiFh8Wn6Oam9YOGZTIDY9Xw/2/oU113frbCUynrdFAvcjU+/unJ0+o85dY+T8R4v14jvA2PN0T1rWBijniIBNTKYYNEH2fV54R7D8sWMpli0U//tARfSXoEycDKVPhLlly3KBilftaMtHcHGZNSMerGxl4fSsj44ali0YmphwsmJ0NW1vxQHXp9Uq7vlxZMcFYqIK31Nj85EU1OSqGUbxeuJZM7NDcjGdnLLh10DKSTDQt6tYWE7J/TJJ0g00FUKsVCVpSC1LeG5QC0G7LFABODJ9uVG5EhxyuZCkvvL5uLliVlKYlOjLnFwqK7z3iFhM5sTBmnsW0gln3BSH8+OIzNoyMv7P+5pH4r2r1FiHjB2aJmI8KbSpgZp5yX6mVJ0TS927fb4ixLSxEN2j18Uw7eaoGLhZhzdO6GE7w332BCBNe0HllstlkCH+1m8+IIsMNLrObzgTgx+kxQ5rPTxTT66ViCXf+L6BQsxoA3N9+XKv07H075RLExuLFQzGbXLVxAe06/3eis5wWCMVTZ8RgoOp3sXtI7tgjynxX8b8jyALg660jFNOKyrMsRq4RsYejm68BIL2LCBsNDUr5OW+/FnbpLNhxSuS47l1lGWqVBqWF6FsE+qUdYRZAy8CowsIxtxQudGlhAtvfT0QOlKmUDKoVSYiiwyDfQMPL/MhsSZ2qxtzvSWSYazXJUOvkgpUFTO0Oz9aKxUBgkVHoOUN8NqwIBY0PUPuGr8CdiyLJZbe+bwkJFWP0s9GUoLPkuEGWHDf4scMz3rwR7UXRIjbs25UPr1cl8XxekrbNrFPFRNWTO6L/d+DQJ/5eLZxB2rV2ol4d0R4WqhD32D08XMPwsf5kK/yGDgN0fYl1c5W8umDJlF+VWChTzv9g8U3wJdUi5bIfJoRdpvQUafk9AMeHTjNqnyrj+wPw4sCJpDIryVC8uUhwcnvXBe06tUrN5ArDtb/PLD+c7HYlF8zMzJhxW0iyXdx2hQMLjsZZ/tfdA5l6VzwXarWak3+fAKDZmBZJaufXwr2g8AYIeB9MeJjOg+vhDR+qZ56n/T2k9fZkty2pYGuvC+cKeBcz5iJdeh2ZEfLZdKH4hWsVibdM5twx3f8jIsMyrBzk8vmlJWTIK5J1e5y4plV6fpEGlJ53rxTX0LhLSe2618+Ex15aIBTbdnwJwKJ52Qxuj4hI/aRCQhEaqpvI/Gggh+J/AZmyCU+FkKBwVCo1rQZ8B8Dhf1L/u20Mbl/Tj3Xc6/MbDTuL+u3wxlumMClJUKmv6Dfd3XGaLCXyAeB5PfVOCAV9DOXQzuc0LCsmp39oZTgEM7UgpxHO4YbIuGXnxWfvKolrT0rC3Wdw5Ir4/tcg09ryX4JzenMmjBLRKLmLvWTAoBd8V+1+jHKtW6Xn1rUieL0qyeEDBShVSi43fUqAQqHg4U2RJ3LUOB+uXBOTyquWClL14ycN/X6NmSP58dNwilT0wq2EF+u3iH0qllJw66AFry5YUr1CyqV/vq8pIlZu3U6Y0E5KhSoy5Fl2SS1IuU+UiVGxn5gdf3f3MX6Pn8dbfkcrQSi6lCuRlGYlCWoNFh26AxOF59qH1++ZVHYoqi/UikM/yyf8Ti1QWiqZenUcAAfmH+HC1itG7bft960AfN+7VgzVwpSIkQvqAjD5l0MAbFx4jQ6V1wIweLqQ6Xt409c0xiURxm0TCtxTOv5jcHu3+T8CsHa46ULJavb4nql3p8VY+mz4BYDc5WNO87+5KBSAc9WqmKy2pmRkLiL+p+enUz/psHvlDQDK1NTl2HvjkbIIxbAwtR75ZSyi75PB2XBir9X/CE/p3wY7Jci2tAIjgiTSLDqOFhO7G6adpM5PgkzbOuesKU1KFvxYbz+/DxSMjIWlyLX3168H6T2pDgAz+uyOdd/UhqLNqwFwbv5WPC8LUuDK2tQxgR3w7jM9S86kdZbx2uXn/FPp1foQXp5iArNOEzfTGvmV2DdCF04bfekpAnSYYDj9NLsi9f9KZU9yE00CjQYaDRPfj8w2rS3/RXT/WZcHefNWHaH2v16ZePmsBF6vSjJvdi4yZbIwtHuqgoODOcf2i35g45YvePtWjM1f3s4CwL+7g9m4LQiNRsPytZ/IVvgNNRq/xT9QTMpO+t2R1/eysmWRBekdU/44ddwYMck8ZtxrE1uSuPim8vwfRoO/Rd6aI7/8EWcIxoU/lxH+WYShVBib+qaplFa6CvfK5jMsaCRCgMu1q8Lv12fRarogZPZO3GIS+5IL1umsGH/6NwA2jtrG3RNx59BUhau4ukMQj3X7GZC4S4Fo3rU4AHvW3aXb9/8wc+gxANae7ciPfcvQuGNRAHavvWMyGxMbRSq7AfD0xhuD73HpBuKabxy8m2Q2JDSEa/2gdQC0mRRTevD8JKHuXLL3jwk3LI3A2knMaEalqAh6JydEkxIRlYYgeljOGw9/IOUQijlzXCBXzgu4upwzuGRxv0+xso9o3PI5vwx6zYw5b9m6PYDOPYUa4LRJrrEe+/eJIrynZ1c5kZNvSDto2U9ET2yZfQYrW9FP+eD7yZQmJQvOHBP5o3a8HMbO1yJSZNeyKzy4qssrFT1NSWpFSMAn1rYYFWO959XHJrBGHpf23eeDj/7zWKBcDgaNLav9nT2XnEJ0asHSyECedomk4Jza0GG8+GxdA/LETG/9DcmAJzdyUrumDevW5MbrVUm8XpVkzOhsaTJstlBBaxbMFg9a8fKPiYjQYG6u4PY50Yca8rs/2Yt4MXaKyBOZwdmMk3sz8/peVjr/mLo8M/PlFeJiFy9JKPl8g8nxTeU5DmTN7UzOmhV4efwi5yctovLoPjHKPN13kpfHRKhw6/3LCJXQAggJN5dWevYLspJSev4YahGn0nMUWs3tzdYBi9k/5V8AOiz5H+7lRfhJtuJCUfDugeu0mNJRbz9rC5W00vP7z1YpRukZICTCHGuluA+OmR34bf9gpjSYxbJeqxm0pQ+5iueIsY+1UsWi/60GdErPccHOMkJK6fnRO3sppecH7+3jVXqOQtWGeTi97ym3LojByQmf/tjZC8GWHHkFUTGp7yEtuRiFMI1SStXS2TJYSunZ0lwtrfTsYBXxf/bOOjyKqwvjv91snCgBgntxd3eX4lDcCoUW+bCiLe5WKFaguBSKu7sUd5fgQZJAXHe/P+4mmyWbZG/IZpPA+zzzzO7MnZmzOzNX3nvOeeNUeo5Egx5l2bf8AhfWnqRcp2p6+z566sin4IAQbOx1YdKudiFSisRhEcoYqpPvHr9ldtNZRp/DEJwz6Qikklm8uPIyLREhIrF7fOHO9985SSk9ewVaSyk9Z3YK5NUn45WCQf5/jQ8Fm1fnyopdeCQw1DldmmBppecnXg7kMvKdA/D0tcXd8cvyn0WFPOeMSSi+DnYik40ckfrROodQejYSCltnPZW9RYvysny5Jx4ewXz4YLid+eAVwQevIC5difnbO/7grH9+S9sYSs/WVrEPDjRhQdJKz0qHdKj93ht/QHiolNqhOuiTlNKz2uupQaXnuGAV9EYoPRsJd0sfKaXnTGmCzK70DCLcyzmdPR/fB/DmiU5MLCJCjUU8+Yp9Q1Q4WhvfXvmHWUorPcu2id7hDkYpPb8I6xF5BHf83Fl5pS9dSy5kWNO19J1Wl4W/HuTQxhs06lpS77jMjsHSSs/p7UOklJ7T2ofgJVHewToMvxB9L6GI0DC29ZnJhwcv9La33zSB9W3GEBFm/H9qqM2ND77BljjaGH+v7713IH+6mPetTufS1Olc2sARMGec4SiXXN858eTBJzQaTVRUS5BLYaH0LAHLnKUJe2pcJA2AZV4rwh7qi8FsPwODFktdNgYiA3NU6SBcW62+1QrpFk1koi3ik1B6Nhbhb4TSs7HQBILCiK7M1QdwVuuBOb0fcao6fw6FlZzSs0VandJzt0VCnXr1z7GXt8wBYR4S9ljLKz2HvxBKz8YiwlcoPRuLwIMe2NXNEW85Ozslq5dkAOTd+JUuWVD7vDS6vNrnJUoX491tNaGBQunZSCjsXGIoPX+Ols2cOH8hkLUbPpI17z3WrcxKh6764iVd29sx9lcng6Sq0tEtSunZGGjCQ1FI9H0ivF4IpWcZhIeAKmZ7YmEBEREQFKTG1la09QMHPWfUiIy4pTGeaNQEfZRTelZZm0zpWa2RV21Wp6DMP98IxWiwtFDrdUz8QiypMqon6479x8tTlwl6/RrHrDqPig/3nnL5D5EwvNXWuSiUSmyUplUXlSETQRBfYUaQNFnK6nK49Ts8BRtHO4LD4P6Ra+wcIQQrSratKk0eGoKjTZhRNiUUsp3LSDIxEhlypWPgP32Y23YRc1ovZNSBwaTL4aZXxtcvgvsnhQdjpY7xJ4mRIRMBKTIRII9rIOEa4+7N2BVNqZVBxGicC/gVgHAN9Ky+mtsX3wCw8kzXGOdTKSII1Rj/O7yD5Qij4HD5Z8IYMhGg7ej67Ft+gdXjDuoRindPPeTPbisBqNapvB6ZCEiTXoaevbTZ3SjZtBRv7r8m2D+YEP8Qgv2DUUcY95w26F9b7xm9+MKNtxcEcZazdvl4n3cZ0gvA3UGO9PLwls/fmJhkIgil5ysrdnF323FUNlaEB4fqDdjiw2tJQhQgu6s/weHG14eZnQLjrPfCgsN4c+8Vr2694NG5+wBUbVZAj2R/+Vh0OF0yu8Qg37PY+RpdB0Qivcob7IwnmtSBPnqdsxYdnGnRIW/s5T+Jzm5IiJoXL0N59iwUj2chPPUIoXFDZxSWMckPhcqaq1dFh7Fubcc4O4NKu9j3xYYILw8UNsY/s7KEpULi/wSwMIJMVH52Tn+1PUh0NGXIRICXkqRUQmBsfT9sfRdG1lnIuPYbKFEzD1ePPuLsnoeUa1QgzuPc7OSUdGXJRAA7pVx/zNFCLifUo8D0WFmoyZ7biSHzGzKz314W/nqQIfMbUqlhXqw+q/tf+tpI93+8Aq1i9IHiguzk0edkIsCJGeujyMRGs/thYaliZ785XFy6U+rcIN/fA6TIRIAcLgFS/RP3wCdRnwPV+m1droJuPHnwiacvwnHPIuoht4CbUpMWAGFPL0kN9sOe+ccgy0oUBpUFhCdw2LL0J1Bou2Dh73WfV1wU695VdNsMQSPpZKu0lztGlVGuvNKOeMlBtRpaiEAmTswTJKQMZH9zRLS5r9OiW4DHa8juZrh82FPT2gOgyiRHQlq4yF3HrqYbmmDjPdEVNmn0JjqNgQyxBoKMk7mGwtIWjQQxpQ4ybjJ42hg7Dh325e17NR266iZkNsxXUbmMEgiHIC/UBrrxmkBJdXkVaEKNP8bCLZPRvyMSCpUVhMU0duIYV0aM9WbxwucM7OuMRqPhn83e7D/gw53zxs8SKG2dTEYQyiJCIx/CnJJyKH4jFI1AwyW/sbf3eHZ1G0OHw0sBCPbx5cAvIiS6weIxWDvaE2ZaLtHkyF6uAM/+u8ubO8/JWT4/O4b/zYOjIk9bi9m9yF05fuGI1IIcxbPRc1FnlvVZzaR6s5hwZiQObrrQlb+6iGndttPamcvEBMMuja4T6vnCFydXG2qm1yWBOfL2f3plUgMsVBY4utnj+yGANw/fkTFvenbMPMjBxScA6LWoA8XqFDTZtdtMaWtwn8xALjpOjRfPX6mfU97zZwrYpRVuC29vPY7aFuoXiLWj+UM9NBoNvq/e43XmIS9vPefV7Re8uvWCCCMajDYDKuh9j8yhqLL88omdpIS1tZI8uW3Ik9s4omr4KOE5MO53w4ItqRHh4Wo2rX3K5DHXzW1KskLW/EIl980T7ygvxfTZnM1okXnQqHMx9q6+xp2Lrzmy+TaNOqe8fN2RqDL4B4q2rYVbHn2Pn4eHLprJIjloNBqe333LzROPuHniEXfOGGZxqtbPHmNbngKuHN7+mEd3vaIIRXMhR0Z4uMnwvog3CT/vKq2+Y418CT9HckXLMWLduR5kyyDnbfil2DMIGs2GOtPhgXF6od+QCnH5eAYq1ntHlgxqlkxR4eyYckgnY9GhjQMjxnozfe5HBvZ1jnIO+OSbglz2vjJ8IxSNgEvurGQokZ+3V+9x4Y91lP6lHVtaDwagwrBuuObJZmYLEwcNxnVhcf3h/Nt/kd72vvsnYu+aOvPAxIXCNQvQZnxzNv22jTGVJjP18lhs0lgT6BvEy9tiwFuiccl4zpI8sfJ0F7pWXkXvmmt591p4sBUolZG/T3Y2s2Wmw+gt3RlWbT6z2i7BwdWedx4ijmTc0cG4ZXM1s3VyUGtDwqwdzE+YmRvqCDUnp6zQ21amd/NkQSbe2HyUs/P+jbecUqUkc6GsYiks1g0qqfTyJwL4en9ZyHRKwY2b4nfmyJG4nqzJCRqNhkMHfZg64w53bn6MsX/UxGJMGv11k4tqtZqZnddFfbe0smDpzSHYO5regzI54s9DnanpPJWrJ59xcONN6rYrYm6TEgRLG6soMjE8JIyd/fRVLdotH2IOswziwj9nWbb9LM9uexpV3srGkip1s1KlXnZados5CZ+noOhrPLrjTeU6MQnH1ARlKuM5/rsD17QC5OO6J/3180ZLOez5Edydk96GbzA/FAoF5w5mkPayTElQqWJWHgXzW3LnXhgvXoWTNXPKo6/UCVBtlg2RNidS3h0xE2pNH8T6Or14uOs4D3cdByBPo6rkqpt6MhLbOOkPwJ2zutHz39EpQr3YVKjYtiyf3n7iwIKjDC81llm3JjK96R8AdF3UzczWJRz5SoieSSSZ2G9yDdoPKGtOk0yOjLlEjEiQbzBBvkKxfO7tcVhap6xq8MWZawDkqlsh7oKpHOrwCI5PWsHTY/p5pDrunJUsyESAHJWK8vDQRZwypyNviUxkLpyVjPkyYWUXP1GmVMadTye14uNHQZa7uqYsL0xjcPGiL1OnPOfMGV+D+4ePLUqv/vlxcBRhol8zoXhy01WWDt6uty0sNOKrJRNBDCR3PB3I9znnMqX3bopWzIZ7tpQpWqSOUHP49+U8OaGf9/b7mb1xL5g8iLYg30B2TdoaY7uLuyNFquWmSNU8FKqcEwdX/famZLrYB/p5CqYF4PEd71jLpGT4ia4VWZzNakaiI0IN7bRCLGcWmM+Of/tBq/nCU/HyePPZ8Q3fYGrUr23H/sOBXL4WTKniNkwak5bmHTyZNMuXxbNTlhMICHJQPodiyuFfUtZI2oxQKBTUmTOMQ/8Tfua2bs6U+1+neI5KWbi4+mDU54yFs9Px70FmtCb5oEH/Oni//sjFbVcYXHh01Pb8VePO4ZSc0afe+qjPtVvlT/VkIsCLe2+jPjumd2DK2eFmtCbhOD1BG+7c9+sMd1aHR3BswnI8TlyJ2lamd3NsnNJwavoaHuw9Q5F2dc1ooQ6Omdxo+ZfIU5rZSTLZ0leKmbOFJ9C0yZLJvZMhPn4MZ+jQx+za6WVwf8+eGRk4tgIZ3M0vgJJc8PapF0Oqzov63rRfVVoPq0WnrL8D8OlDAE5uyWPCwBxwdLVlxrZ2DG2+kR+KLOSIz/AYnszJGRqNhrPzt3Bz89GobTVGdiZruYKs/n44J+dtI2elwnGcIelg62jH0MNjyJ9Ng5VtzFyQCUH2vM4APLpruE5I6VivjVr/qYp57UhsNBwq1j99D5liyV+YFIjUiPQLBm9/cDVv1Pw3fIPJMOZXF/YfDuS3id7s+TcT5cqIycRd+4NZPNvMxn1DDJhOGSMV4HN15LfX70d9zl0/phBHQpJDy0JWzMAY0QCNRsPfLcdyZtGuqG1vbj2Tts1Y+AYnTscsNsgKvhjzH3WY2ppcpXNEfZ9+bZzUNeyt5DIfP/ggF2L+yNu4ROnBgWFUsJ/GtdO6ZL6H/71n1LGygg+uNrICQglIrm6kiufJTVcZWWdh1Hffd8YJlciKIJni2fscam0Gdas0xt3zJ15yz5Knnxy5kcPV+OTZkZD9X0H87iO/LWFF7Z+jyMSyP7Wgx/HFFP2hHrlqlQHgzrbj0ufOlACy75mkGI2smMGFl5JCGoESMopavAuXm+X9XBwk3vJO8jKfy1cI755GDeP3vFIHfpQ+v0XaHFLlP1edjrd8NKXG8uWu6JGJLVq4cfZcCTzfVsTzbUUmTsqJm6VxoZTRkUZpvMohCJVnGWRxDJYqnxB8Xt+Hh0XwW8MlUWSiWxZnlj8YTethtQAYuUlEBMzutdmo838IlMsD7B8m3y/5XHAjPvhGyNUBeezeGdxeumbOqByKzXP/EbU9IfctraR4jezESPR+9LUNh1hS9ecoMrHsj0356dRC8jUoj52rqL98nhv+zbEhIQJ/Mn1Qx/ROvA52ljr/lfexM05WVqLNfxTNQ/GDvXzoumVOw+rSsZbPLtdeWUioI4NQeQZYckqsmxqR4jMuwRZDUMtVe4RL5oFUx/Jon7oBD7SCwL+219+nkEw3LvubLdLF3Lamt1i3nK/b9vdJ+G4Y+KU3rT0A4a/jLxMdEZLBFoFH5UJ5ZQRcIqF0lGOFZcOLZfsNSlt5T3PZ36Cwk3xYZQWEPkg+GAgl6diQM7uop6/eiFkmIsK4XIqyIjGmRIRakaAlpeCbh2I0WKsisI4mkuAXYhklmvDywm1urNwRte/W2t0Ua1UdG2ddIx0cbmFyUvFzkjM+xCf6EODly9LGo6K+/3JsFuu6Tsfn2Vte339DujyJnxQ/rb3pFZdkOpmWFmqjiJ1eq/oyqdoE/D74Man+HEYcGWn0NZJC5Tk+PLnzng5l/gYgb5H0zD/ek6FN1nLz7HOO7HlGmdq54zxeKEoa/7/KDugSAj8jVJ4X/fwPF/fcAmDAxp/YOX0fT6884/bpJ3xXIU+cx8q+0wkVWTEWNw7dBiBXvUpGH5M/vVyDmtlRriP01MceG0u53/3e33g10ojwCA6MXsbzM7rwz7J9W1GkTW29cipr8bz5v5UPJUuIynOmeFSbP4cs8VrU/VOsyqKGtudw8JMn/VV+BGuMDyG1UQRLkYrqQB8pUlGj0QDXALBwjr/tkSU4ASK8niaI6DQW0VWpbzysxZPHgRQoGDupr7FPR3xvT8Rno75P4XIeeq+D5QYrsirPCSF1ouPg8rNsnLAv6vvYvX3JVjCj9txiW4EKOQC4c+6ZUYq76e1DYyihxwV3W0m2ArBRypFxTiq5a9z1j/05HTK/IXtWX8fXO4iVU07RdUQVPgRaSU/MvQuwkmrjPP1spep7v2BLPI6cZ//Y1VHbiraoQo0hrbXpdHTnsnawJcQvCE1IkFFpIRIKG8sIqWcjp0uA1DNeKoNXvHVxoH9YVBn3sAdgKdcGhXtcQGFl/Hsa9vwDCom/NPwVIMGxR3iBwhoCtUMUayN+jixBqFDJqQurMsmJpijtYpYPj4DOk8Tn/+bH3C+rkiwr4hJhwJG1rDYjwCsf8PUHBxsoILSraDUb9ksEr6gTMByzzCr3uy2c5H63Xc00aEKNnxxR2DnGSUwZgiz5ZeGWSfoaMuU1gYbToMQFta9cnzI2wjw2KFSAxE9WZXIDyf8IlVWc/5ONjYLgYA2ZvvPQ256tSMzZAgsLsLdTYGenwM5WgZ2tEnt7JfZ2PtjbK7C1VWJnq8DeTqHdLsrY2imwtxPf7e2U2Ntrt9sqsLdXYG2lQBP+TQwmPnzzUDQSB4aJqaDWa8dTd+rPAKxrlnwSR8tiQ4+ZzK3QL4pMzFurBAPPzUdlY0WzWT8BsLX/n+Y0MdHx7OpTxhQdwuu7rxJ8jlEnhMTbJ8+PLOvxV2KZZjLcv+pJBftpLBxzPIpM7Du+GqvPd0OhUPD72lYAjG6z0ZxmJjq65xjDngUn6J5jTBSZOO/qCHKWyE7PhSJVwcKuy81pYoKwcoAIVS/Vp02MfVvaDOHelsNJbZJJEREewdIa/aLIxHI/t6bH8cVRZOLapoNZXv0nc5poFnyffoK5TTAJtm4Wnfw+/XLqbV+/5gUZHPcSFmb6KIDEhLW1RZxkYlzw801C+VAzwdcrgO45xkSRiW1H1wdg76JTBsuXaVgQgIv77iSNgUmEYX3P4W6xSkuoG48D70Qc5qqpp7l/5QtkeU2IuRX6RZGJOSsVpv+pudQc2oYtv8xnboV+emWr9msOwMW1R2OcJzVg5exLFLOda24zTIZQLclkH424vPYc8o0U5FdKRA3tMG9gC0jnbNwxrz5A7m5w23SBXizW6id2XCrW5bX+AC/9wN/ETUdAKBy+D6N3Q+W5UGCSbknMqvn1WzWVvg8gIDD5kTn3H4ZRqd5bMhd8zZQ58mRgSoRaDZOXQfb60LR/0lzzn7/TGl02IgJ8/TR4vlXzxCOCW3fD+O9SCEdPBrFrXyCbtvqzcp0fC5b6Mn3uR36f7MPQMV78MvgD3fq8o02XtzRq/YbqDV9TtsZLipR/Qa4iz8mc7xn5Sj7/4t8SoRVlkV1SCr55KEbD5XVHqNirscF9P2yZhoWlCmtHexyzpMfGxYFgHz9ubzlKoZY1k9jSL4eFpW72tPGUnuSprotPcMqsFa/w8UejVqNQpg7e2dZJTJkuajuHYUd/w8FNPkQQYPLNqYwsMpxH5x+x5bd/aTm+VWKamahIl0kMZtfM/g+AZcc7UaiMzuvBwVkX3urzzh+X9KknIcuWGYJcs7a3YsHNUSiVSnxDwN5F590T6BuEnWPKyV+mjhCEyufhzhqNhmDvT9z99xD5W9Y2dGiKhIXKApecGcnXuIrBejbEV7g4hIeEorK2ImuFIrw4d5NPL97ilDVDUpubJFBaKFBHaNBoNKlOMGvY/4QH7uBf9T2H//fzTQAsLFLX740Lxob0pGSc23YNgGyFMjJ6e29Ulhb8M3E/F3bdpOesFqis9LuoP85qxsW9d5jX6x/WvJBLO5Kc4e8r3Lryumzg0cf28ZTWwcpaxfKzPehRcTk/1VjJ2scjsbYzbUqZhMAtTybaLh2MpY0uaiEsWLAePs/f4ZJNxGkWaFiOQ5PXc3bZfir1amAWW02JD29Tdx7d7Vp9nZ+q67YtPSnW6hRYnR25IshBgP7NjT+u6lDT2BMdNfKL9b03EBQKtlawqBP0WQPddsPmFl92/gg13PKCEy/hxAt4+DH+Y6wsoFQipj5+7anh2SsN+aoG8PKS+ccmn3zVDP3tI3sO6ntPli9t+mgsc+K9D3QcAfc8dNuqlkqaa5cubsWrOwmPKAlTWxIQqCYgUEOQdh0YJNYBAWoCgzQEBmoI1O6LLBsYqCYoSPfdzy+Cp8++LAJNrVaglgxhli1vTqQOpiiRcGHFAYI+GnYhtkvrpKcc2u6fyQCcn7+J0EDT5xtKbDQY3xUAG0d7PTIxEmW71gPg0rojSWmWSZE+VwZaTvoBgOk1xxMeKhmroIVSqWTiVXH/L265wO5pu+I5wnxwzaB7Znc87KtHJkZi5h7hsTeqderxUvxOGxPSaWITFt0eg/IzUvzHJV0AWDVwfYxjkyuuHxCelrkbxMzf6v9G9HrdCuSMsS+lo+3qMbFO2lT8n3ifb/5zCICCzaoDcHf7iSSxLSkRpHU7cHARBPjbZx/NaI1p4O8n6uRIlePPkZLEJ74Uzi6mC/lMLqjXsxJ/e0xg7J6+qLSTnJ0nNQVgyYCYuRJt0+j+k+AA06dOSSosXFsVAH+/MPp0OCl1bK5C6ekwuCIAHXNPTnTbvhQDz82n45oRemQiQI3BrQE48ceWqG1Ki9Q9JGnSIeUK+RmDxcfEun053bbDWo+1rMlMlDUoFC4+hNicgkPD4cc54vOlhYbLGMKTaI7ChUwsVj6rrVj3WiXWNbWP110vCDZyePPSD9bdhd6HoOhq3VJiLXTaB8tuxiQTC2eEX6rCv93hzki4O0os14dD+oQ55BtE6WIW5Msl6oSeQ+VS8SQW1GpYsBYyF3xNwfKeUWRige9UnNqbnld3MlGjilyKkPhw+FR4svDKPHNNeCOW/kFHJg7uDB77YEgXc1pmPKysFLg4W5Alk4q8eawoXtSJatnAAADQAElEQVSaiuVsqVPDjmaN09C+tQM9uzjSv48zIwa7MHFMWuZMcWPJH+lZ/VcGtqzNyP6tmdi/LfHTv6U2pO7WOwFY0mCEUeUsrCypNkokCV/TcKAJLTINHNKL3FPBvgEGw2zK92wIwJmFO5PULlOjeJNSVOpSDYBxpYdLhxhFQhFtYHt69Skubr2YKPaZArO3iY772O6Gic8iFbIB8Pjm2wT/H8kN/ZZ2AGDNaMO/uVB1Mb17/8yjJLPpS7FSS36W7N06xr4Pd58A4FYwV5LaZG7kayykJK/8Le5z5jKiR50QYZbkjrfPRMxY+qzOADy6Lp8AOznj0UMxmVe6rLPe9pAQMSvs6pr8PK++IfFRvYMQV7q87w5qdcwQ918WiXQPy4elrr7J6zARw7ht41NWLb4fT2l9rJt1NurznJ/+TVS7TAX3goJt8TirHyOZvex3AHx4nDxDuL8E+YoaUNhIRXj1UazTJC6/YhL8+Cf8MBPy/gR5esOs7RDdNyQyGn9EO3CVIMnqaFOr75+YaKbGisZaX5ALT3Xh5tNqiHWf/bpyfqGw/zGMOAYVV0Hhpbql4TaYdhHOffa6udtBm+9gQU240B5udNYtm7vDz1WgUEYwdZDE4X/EBOr+YxEcOJ4wJ5CE4Ph/kK0q5KgO06Jlt1q1yJVXdzJxeHt6cuUwTZBn1/8Fk69qAOFmyNun0cDMNZCjMbQfrtu+eSY82w/925v+nqdWpPaQ52+EYjREqsxdWmtcHrI8dXTTcA8PnjeJTaZEsVZiVvzOnv9i7FNaKFFZiwGc37sUmvwkFtQf3IRsJXIAMKXq7wk6x9+9RP69Cu2FZ8CWMZu5d/JuotiX2KhQV5BMV0+9iJUwbD9EeL2tmSrnHZFcYe+kC2P28zac+btM85IAnN+cfMng6NBoY4YMqTt7RRKKBb4uQvFzj5bI9AwaA0RESsebp0JsJkchEcr96FrqGnCPHiaIhamzCult37JJm1ex/9f1bH/NaPyLmPTbNOlAjH3lGovn4/zOW0lqk6mhVCq490GoKfz683kunTNO7XjxGJFvMGN2ZwDO7rjNxQNyhKS5ER6iExus1u97AE78mboIY0NQp8Q44FiQnJrcnzZA/nEwbCV8iCW93fJ+0L6a7vuifVD4R8jVCQr2AB9tsNqPjYy/7t1oadbyJpFD0zjxuvDzWrj4FO5pRVwuvtGRhhVWwZCjsOsRRE/Nq1JCrWwwrgIcba1PGh5sBaPLQ5UsYGPG5GgKhYIr+0Wft8eQYLx89N+ZDdvD8HyXOGKIHq+gfndBJHaOFrY+pAc8v5mRV3cyUbua6dnyDs3FH56jvLxQWELh/Qma/g9yNoE//xHbin0HV/8RRGLZwklmSqpFZMiz7JJS8I1QjIZO64R34ukFOwj+FGCUonLnvXMBODl5JaoI04c++4XIeWnEpV5c5ZdmAByatM7g/pYLRNbV3cOXSV0zPngFmD+U68dVvwAQ9CmQVf1Wx1NaH77vfXn8n/Bs+35UMwbvFlmbV/ZZEZXj7nPYW8nNrD34IBc38Mg7bkm9Nn1EwosN83TkmaO1zqZOwwW5vG7G6VjPIaOKCOBmZ3pRAQfr2P/XoeuFB/G8HrrnO/pvbjteJMXZOHprrOeQVW02Ri08Ibi2T+SQq9CmDGWyfoixP9JD0SVPthj77r2TU3h95SuXUzKni3ynJ10auboyLhXSnDXEs/3m+kO97TLetpmc5HNbySpDe3jL5QC64al/3948FRM7BcqKJEWPrusTih5+8rFG3uFyx8goQoOcCvOxI+K5LlJM/3cvmvcUgM7dYj7b6kD5yS6LtKZNC6AJ+ihVXhHwPtZ9NraiPrl7S/93yqoFZ7KRU3rP4ph472dC0HxwLUCoP0ciuspu3tLiHbh/IXbVg3cBcnmtPIPklLMBgtVy14hPndvZxZqjV5sA0LjyPtwCHsdZ/tVjb/6ZJyaE11ztzb/3hVvV9K4b+fjeOAXQ9PZy7bS7g1zooYNN7P3oagNbAnBl47Goba7aNuzJGdMJ7wSHybXTT33kno3Lb40TEnjzQrBdnpbfSZ0fQJWjrFR5y2xucueXJMSOa7UOu0fLyBKp0J4tlnBnpeQrZ6yycGRmhK3noPxQ4YHYYBxcihaQYm0J49vDoyXwYBFM6SwINgBtek+uLY7/WopoZFtjrX/CsWlxlJdMt2cRz6PUTuvXcvKBEGhZcSNmmWLpYUAZ2NYSbvaEWz+K5VoP+KMeNM8LbhLdvrAXxpcFiJBrfgg8ql93pXdTsmSa6HsUq6MfVTd0Ygilqr8lNFSOnLdwE+mfAoNgyFRBIlb9Ae5on5H6VeDGbnh+Evp3AXxMO4GrsNPl9J82yobsWQSRVK997H1TpaNcn1JpoMt64ZbwRizZAW5ou9C/tIUnO2HHbHCVGD6Ev445Non/IP32JyhYQ+aCrzl3MXFSmsgqc39DwvFNlCUarK2VfD+tOzt+/ZvF9Ycz8Nz8+ElFawuqD2rF8dn/8k+bEXTYMdPo6yWEfDCG5DT6Oha67QGBaiys9MlKl3xCNuzt3eeJSpSkSxMsTU7JwMrIwc24a9P5vfgw7h69xbG/jlKjl3HiOpOri1iGfut6YaOKIGN2XY1rZ60BYpJQXoFyJOp3bn5S5bM4BhMcHvt/2mtSbTYtusz8kcdo8XN5AD4E6vdschR2x+OWJ/+dfE2BcjEH71YW6jiv8Tm8Ak2fqDgoDntylBXCDo+vviAwTIFCodAblKqsVKisVISHhuP10oe0WWKSH7IEvuz7aexAPDLcueWI+tx84xKD6PS67wFAGnsLPn/+crgaN7CMRGZHuQHjK19bo9+5SHgFWEuRtXHdh7I/teTpscucm7uBFit+I3+TKtzbdQrPaw/IWCKfUeeXJQdBnoTM5BQoVe8Vdf+kV/7lE0EqZSmQEYBH117r7c/iGEygWq6ecbQIxDfC+N9upwzBX2P8KNDWIgTs4w/zCwoSI0WFAkJtM+rte3BfPL92mbLxedcwUG1tqLqNE64Wn6RIRU2o3H1WWzsiM7QJioj9Nzi72uD5KoB/N7xgyHj3qO0y9wzkyWbZujuuejihKNusOBe2X2PPX+eo2b0Stip1VP3dd+EP/K/sdCa1WsHyp+MNHp9ZkhR1t5WfGHG0kHs2bC3iHyQVLOrKwjVV6NvpFEUybeLUxyFR+SWjQ6PR0LHkEgCWneiEvTUEuDgzbHlLpvfYwo9FZ7H97eh4hZu8Aq2wVRlff8vW93FNIBdtWYUTc7dwdvEuynapC+i3icaIAoYloC8ZF8lpCO4OQVLPeMmMvrHWxWVqZOfiMUGE37nth0vW9OSxfgmWxk++AIQ9OYPCxnhCIfylh0FCIdbyrwwTELFh4W6x7lFHd9xFraNsnWKGzxXho0/IJRZmthDLGW8Ysw5ee8PD19Buhq7M6DbQsTqoLECphNaVoG0dyN8dQsNgcGtwNKKpiyQ5r2m5f5UFaDWGDJeXrGYijBAQXt0Txu6ASnmgij2UzCAEUgxePxS99slYkjY6LDOBRoLvUcXxfxiCbVWrGERQw2pQu5KCw2c0NOwYyN5Vok/4vx5K5ixXk7P4G6OFWzQaDStWB/DbfP3tWTLA8olQIHe0jdr/R+mYBk2g8WrOCiu5ydeIj/pk3Kn1guS8/UDN79P8+b2fbt+ZyzB1CWyfIRd+HPnsaTTw51aYvUl//9rRUKmI9ksQaFSS9zmzFWqJ/whAaeeoRyqqtcRwj1+8uXPGeIXn2CBTR5oa6gSEMKu/hTynXHxXoxg2jqLlu/rPcaOOKd5a+M0Hf/Ln+VkD00PJGFWHCkXB84t3GNz/XT0xC/rwUMoIC5WBUqlk9PlJABz4Yz+3j96O95hH53VeULlLi0HprJYLAGgzXkIGLolhYaHEPZsgPh9c8zRYZtR6kXfwt2YrkswuU6Nmt0oAHF56yuD+gZv6ALCwy9Iks+lLYOuQApITJTHSZBDuDz5PRWhsgebVAbiTyoRZPD1EyLN7DjHwjBRpSQ34c7oIX52yoJKZLUleSJ9R9EV2bUo5uV4TCx2nCpnSLZP3xtjnpM38r9FoCA9LnHC35IQW7XPRra+YDKnibHiS+n/fi9Fgjeb5KFRaJ7ZWqUlBytYXHm/HN980saVfBguVYdajXJfaANw9eCUpzUkS1P9BFzv49E4CPHqSKW5qvdbSR/NoOqQdDtUtmvT2AFQrDCenCC/EE5OhXkndvombIH9f4b04aDm8+wRbTwsyEeDnpnLXaqnNmXh8euLYLoNyuWDf/2B0EyifKXYyMaVjxSxBIt68r2HddlHvD/pRRaSj3qhpcbNf569EkKeSP1nL6JOJf46G50fh7IbPyEQz45FWE3X5Zth2ULf9/DW4fg+KtpM73yd/aP0b5GqnIxPzZYMLS+DpP9HIRDPC3k4QaJ/8Uk86iEh8C3n+CtFn7wQATszdQoi/cd46vfdPBeDQyIWow1NOB7dAEzGAu7n5qMH9kYP1I+NTD8kUHdZ21gw7KDLPrum3Cs8Hcbu1L+shiKeJ50YB8OGFN28eCIKuYlu5EJSkxty9gjDsXc3wvXROp5vJ8f9oHkW1xEbz4fUB2D49Zi4ugCwFxEDM66VPrOHqSYFzW67wc55RsS4AlX8oYzb7kjtstflvgz/545pLxGp5nEhdg1FPbQ7F6Eq3qQWzxl8HoF13/dC/G5fFgLtJm9SnXm4MHJyEp+DzJ3Ie66kBFioL8pTJAcDlPTGJsR9+F8Jx/049GGNfasCU+eXJnMsZgB9rrImx/78jHgBMXtssxr5Rq9syfEVrytTNa0ILEwd5a5YA4OVVHWkeSSgenp4yBGZkUK2p7p48uZt6CEVDOKR9bYubWO3YGGROCwt6C3LxzgIYGm3+f+cFqDgMhgiHX278ZfgcseGcNn26sz1kTGZq1qkNd44IUnH41AievRKk080jwpV01eYwzl/RH3+/fqumeY9AspT2p1WvIIK1nGOfdvD4oCASmxoXnJbksLKES9vE5wET4abW43dwD7H2C4A+k+M/z9X7Iqy5eA+4pD3Hj03g8QbYPwPSOSe66V+EPDkFI/72fTJKzPoN8eIboWgAKisVTSd3BWBRnWFGHWPrpPON//gs5STLVygUWKURyTMCPnyM2q7RaNjYYRxXVuukwkIDUgfJ9DlcM7vSe7XwVJvbfA7+3rGHiJZuWYYmI78njasg3ybWFjEUQ7b3i/WY5IIMWXVTx0EBhr2bIr0UZ3T/J0lsMjWUFsqoUOYXtw2r4jYcUAeAPXPMNzB1cXeMt0yzYfWTwJKUiYr/+wGAKysMq3qnBni9lgslSYmw+ExkZ8kcMSLt/b9kMHVuBjg4fN3K1n2XdwHg7wEbY+yr3VWk7oieZzG1YfONXgDcuvCaJeP1BdNWnu7CSZ8hsR5boVF+0jjL5cM1B6r0awbAsZm6+Lsjs0ReY2Mn9FMS7B10E0JPUxChGBAMzX4XoiWGFoDKn2UYea9tsuKJWk9yWKmgd31BLj5aAqsGQjZtZo65fSGN5GvTUeuVeNAIcucbvgwO9go2LRRx8pVbhhERocHCQsHp7cKbv1WvILw/ahgzI4Qspf0p2yiQi9cFMVWlrAVX9tvx8lIaRvQCyxSQ9C19WtipzeXZ6Ef4oE2n7HFcrPedhWXbYh6n0cCSLYJIbD5Yt33FcOGNOLJj8nsvIzF2qOBTZi5IOlGapMA3leevFPlql8DSVngHXN9qOFwyOjb3/QMAp6wZcM2dxaS2JTYaTu8L6LwQQ/wCWVL1Zz4+fwtArd+FuMXxKWvNY2ASIGepnLQYJxKET6wynvBQw4lFWo1vTaUOwqvzxiERIm3nbBvl6ZbcMXaVmJad2NOwgmLxGiLv4J1zz6RELZIzBqwV03nTWy4yuL9OnxoAHFlqvhDZ/JXysODRpBjLnw8nRpWJL9zZ2piEP6kU2SsXB+CuNszZ1kUQtBGhcrmyviHpceyAyObfpnPMWKOd/wixoWKl48/DmBoR6aEIqUsR1lhY21lFTQjd/89Db59CocAtizMArx8Zp4ic0qBQKDj2YRAAK6ed4/Q+nRdfvhLuWKaC2EZHd+HS5fXkDe8evGRG2QHc3nMhan/Qx9Q1qIyOlOSheOOJWOLCr98njS2JjUoF4OhEeLIGmlaQO/boNbHO4gZp458X/oZEQIWSSjq3FPRFsQaij5c9s4LSRcW2orUDWPGP2O7kCDtW2PLyUho2LLQlvVvKoz2KF4RZQjOWkt9DWLggA29q52AmLofT18Rnv0DoMEqoNU/RBqPlzATnVwoisXqJpLZeHjUqi37P+q2JI8ySXBChViRokcWQIUOoUqUKHTp0IDRU5zwUHh5O165dqVKlCgMGDADg+fPnVK9enWrVqtGgQQM+fvyY4N+X8t6sJETvvVMAODZjE6EBsSf4vrT2MK+04RotV49NAssSF+5FxEDu9dWHvLnxmBUNxax31nIF+enUQvLWFqGWT05cNZuNSYGyrcpR4YeKAIwuMTJOQk2j0fD3L4Jg/e2IcV6syQHVmuUH4Ozeh7GWadBDhG7vXnIuSWwyNSIHpOpwNaHBMQkmhUKBe94MAHhce56ktsWHK3uFh1aV9rGH0wd6CQm9dAW/zrBQQE94QKPRROVR9DiZOuuszHmFYmeEGcP0Ewu//nwegNFTSpnZkuSH6ITixTOGc9+mdgzd8hMA09ouj7Hvf6s6AzCr46oktSkpYWNryda74j8Y2moLLx55m9mixIddWpETc30XIY+bt3pRmk4RE9nn/jacriQlw8VNeFOFBidAEcNMqFBQEG6GlkjkjzavHtl9tknlTtY/Cl8Sdo0zrx1fGyYNFe6Fn3whS2mRF/HSDV1/aPpoa15ctOf20TSUKpLyJ15aN4DOzcTn3NoQbQc7OKoN0+84WngjFmkDZ0QGGbo0hkc74Nhf4C4n8v4NKRRXr17F09OTU6dOUbBgQf79V5c2ZNeuXWTJkoVTp04RGBjI2bNncXR0ZOvWrZw4cYLmzZuzdGnC9QS+EYpxwNZeRf2xosO6sPZQg2VeXX/M6QVC0OTnozPjVdSLDhmV00jIqs4ai4zFhGfajp9nAVB9eEcazfwFEB6LkUiMsOf3/qYVlpBVkI6uEvj96GZkLihysE2tHXv8wj9jRWhl2RalsEkT/+9Jayc30/Lgg5wq50tf4//T+h1E+OD5TRdi7Pv0IYB9y8V2Xy99BUvZ/zWtnelFI4xVp+w6uw0AG4ZvirEvwCcAz4fCG/fJZQ+9fbKqzbG9nwPzjTC4xJU38ec8o/h7gAg9b/arLty5ZBYvvXO/v/sUgPQFDBOKHt5yKmevfOXifWRVoQHS2su9D8bch0ItRS/L48QV8jeuDMCdbceNOr+sYjPIK0PLlr/h6RTrvtzFxMjt9SPdsyBTB0RCVi04LhXpkOBwvD8E4/kqgOdPfHl4x4eLl/y4ePYdp4++4ci+l+zb/pztG5+yceUjVi2+z19/3OH5U5FiIr27LZZK3QD7o494RvIWcI71mnZK+Rls74jY/1dDUFjJ/UfKELnQ9LiUf9M46AjF3ZseR32WVRfO4SCXg1G27pZRCZaFQ9o0KJSiX/Xqob4n4ocXHwHw8Yz5n7+SfB88g+Q9vGXfn6AIufynOW0EiZwxmxN/7GoLQJtiSwmMRZApvb18myt7r2Xr+/jq+tfXnxDopXs+u/wzhmbTe/BdzWIAXN4Yd+SApYTidCT8guX60Z5+cm3ilTdxu6rV/6GQ3vdHIfJRTZa55ASsVFlyyJXPLFU8Bh5p5z/qxCHIYiEnbC2NcMNZbmKFWrIbsFvMhVEgKzgaWRUoJKsZi2iP0isfCImnK2SdX+78CVHZDpP8X8MlHciDThpXJz06qf8ed26l4uFpe15eSkP7ZpZxjseVjnL9YrVv7KmwDEETGrsTkiFYOMfP+E0cBHm0+UhrdQalI5w0kCr8r9HgsRvG/SRUxyMh++whOd8R/kq+/YlNFbpdc9FWHj/zZeNITbDcfTMl1ChQayQXxDPs6+urt4SEGG5Xz507R926dQGoX78+Z8+ejXOfs7Mzrq4iSsDS0hKVKuF5AFJABoGkg41lBNaWOpIvOMyCIg1LcXDCWtQRau7uPkPR73X+8AHefmz+aS4A3TeNJMLSDkuM79yERSilSUXZzlOYkSRQtdE92Nha+FS3XD0W52zuhEXA21uP2f2LyBOYpWwhFDb2RBdVTEhnzsE6jOAw080Y2VhGSJFfVhZqvf/pp43/Y0zRIXzy/MS6IRtoM62DXvnQwBDObxTeez9MbmnUNfxCLLGS+K8yOwYZfe9E+WCjf/Mvsxqxf91NZg3Yx9/fV4za/uTaSyY2E9NdNTqWpemQ+vhFq7MsLdQEhxtvk1egVfyFvhDB4cY9R/nrlQY2cXXfLdrO1B3z4uYLFrQTcm8lmpakYpcaRHcakLkHAK6xEMelmxTl0q6EKcCncbHDxl43EL3yMq3e/vd3PYDYPRRzuMo1qDlc5ELMXvnaStcDXgHWUsf4hVjGW75sj4bc3nKUs3M20Gm78C5/d/uJUdd5/clO+jekSyPXYZQlLb9z8zP4vgWHK8lWJDP8e4P7V9+QLrfwrk1vH4pviFyT7moTEidJaAiGyt+68IZu1ddJnSc6ChRPh1eYI+Ea3bu5fPE9ADoMKIN3uOEJFlnbQZBx78KNz5xvpwwBlfE98VCNSqojHqyOvZ5UpdFdd+emxwydKzqD3qFyBIcs2Sz7HMnWkyDXd/jt4EDG1Z7DmDrz+dtDiOatH7uHwyvFiP7nxTHlLjM7yr2fWezkc5TKErs2imCQiFz3CM2ISiE6XBVrZeWXCVX4c8wpamWYw4WAwTEGzN7B1thIkruyxOs7ybo7vrp+009z9L6nzykG1o9OGKdQnZBnz8FGbqIwrV2I1HWKufvG2Veq2aYIG+ZfBER9nsfuHcEaufug8ryMwtbZ6PLhr+6gsDO+T+Z1P5Tnb+GZJzx/K5YX2u+v3scsX70wKKJVSwe1QiX1Sutvjw71J1BKkBxqyeh3VTpA4lYr5eaa6L9ArP8ZChojeQ+N5PxrhI/uc00xFOPe77GXD30qd37Z/xTAKitSbZxFetBIlLetDJrQ+P9QK+DeAQiKsMTNNbIuDDPqWuqPckSV0tkKTbjcMTLljbXnyBLIXh8eekC2qrrtVpawdxrk1k4EaAzc14iPRpsDgNIOkPjJqsygCZT7jxR2VgZJxcHdNWzcBuOm+1F1g444VqjkxpUKO0ep+yB7fhlEqBUoJUOYI0Oes2bNqrf9999/Z+zYsTHKf/z4kUyZhMOBk5MT3t7eevscHR0N7vv06RNLlixh3759UvZFxzdC0Qj0PzaNuVWHcmDSRvLXLYmVrTXqCDUL648GoPGEzqTNkUGPfElpsE+nmyp0yioGqFdW7ubqyt0AVB7aiXyN5GZEUzLGXZ3O7yWGcXPfVTIXzEylLtWj9s1rJlr1TrPaSnmkJhdYWlng4GKLn08Qrx+9I1Oe9JzadJkVw7YD0HN2Syq2KG5WG02BInWLcPPgTa7tvkrxxiX4b9N5to0Tyd9bTWxN6eamU1HuNqct3ea0Ncm5390RPch0+XOY5PwpBdYOwkUg+JM/S2sIkSQLq5TbxGk0Gq4decCuBad4eOmF3r6cRUWH4cmN11RuVdwM1ukjX/H0fN+lCF7vArCytsDKRoW1tQpbG7CytsA6cpuNhdhvbYGVtfhu72BJ5boxZUBX/3EZgEbt8sXYl9qh0WjYtvI2s0fo8jf7+qTgDsYXIn0OnfeG1+tPjK4zjxCtsNj004OjcimmdnQZXI6Lx5/z35Fn1MuxkIPPfja3SV+MIefnoFAqmVFW5HQKCQxmQd1RRGjzWFcfkEIT88WCIP9QVk07bW4zYmDvUTW9RyY8BHu8/rw7B7XZRqoWilk2NWCT1nG2TB6wk5/XShDyZYD7b+HQXahTIGmumdxhZwv2VilvHPYleLgL8jYRn9vVgvHdU4bAjAzc04l7+uDp15c72hBevHgRRQYCWFsbrnRcXFzw9RUE7cePH6O8D+PaFxYWRvv27Zk5cyYuLgl3G09lj6BpYGljRYPf2rNv/Hr+qDaMoRf+YFaF/wFQpGl5CtRLHbmfCraswZ0tx7i/5ww31u3H741IGN1y1Vics7ub2bqkhdJCyagzE5hUaQz7Z+0mXa4MfFelAO8ee/LJ8yMApRoXN6uNX4K5B7rQo+xiJjVfSumGhTj1jxi8/767D9kLpwyBGVm0ntyWmwdvsvHXDdw+coubB4UHRL9/B5C5wBfG95gR7+6ITOmRhNrXiqenrut9r/BzC4q1q20ma+QRHhrOjd0XObP8CB9fG86TNuKfrgBkLyTq46c3JGOPTARLKwtGL6oXY3tCQpIj8dFLeJhZWX893ZQD/z5gWKe95jYjWWLUtl5Mav4XQyvOjNq29NFYLFQpPz+WDP7c1ZoydjPxeR/E2F77GPtXA3Ob9EVQaKVGy3SsycW1R5lX/deoff2OTMEmlbRrV08+Y1CT9eY2I1bk0DrAKJWQLRNkc4Ns7pAtg/5iH4u3YcRn+jJ3tHNgSUW2JTWGLxPrlQOT7prrukHpqdBvU9xeit+QumFlCc/2Cw/f1AwHe/ALgIBADfZ2KZ80jgxjlj0GwNHRUY9QjA3ly5dn1qxZdO7cmQMHDlCpUiW9fQcPHqRq1aocOHCA7t27A9C3b1/atGlD5cqVpWz7HF9PT/0LUbhxOfaNF52BNV1FnkErexvqj/7BnGYlKsr0asGdLcc4M1On5tz14HwsrFJ5VuVYYONgy8Ddw5nbeCprfl5O/x3DmN9cDGZG7BtkZuu+DFnyiLDZIL/gKDJx3tURpHFJHZ13Q7CytUKhVKBRa6LIxN/OjsXOKWX/5oj4kuqkcvg88+SfjuP1tuWoWizZk4lBnwK4sPE0Z5YfJiLMcOqL+j0r0KBXBVwz6sdiWduKsIzkQigmNr4mReMzhzwY1HY3wUH63kFd/1eKvr9VwNpGRZMiK3n+6CMhweFY23yd3bbAT7oQ5nJNi9B7XhszWmNenPcbRHmH2exZe5viFTLTrFsciepSAAK8/bi49mjU9wa/tadw43JmtChxEBoSzh+DD7J3jf5k19hVzRnbZZuZrDKMgnmVvDivC/dLSD60rwUrtDpBNYqDdRIOj9JYQ8GMcOcN7L8N9VOp9+c3fAPAbwMtGDopgsXrIhj8Y8rv93xJyLOxKFGiBO7u7lSpUoVs2bIxdOhQevfuzZIlS2jSpAnbt2+nSpUqlChRggoVKnDu3DnWr1/Pw4cPWbFiBc2bN49SgJZFyr9DSYgBx6fzR/VheN4RSrD9j0wxs0WJi0hxB4CsFYpQd0rKD6f5UqTN5ka3pb1Z8eMS5n0/HQCXLGnJkCudmS37MoQE6ZNQX4OnR+DHQDSRRIUCJt+YilL5TZcqpSI0IIgNP4wlyEck9LdxSsMPG8exosFgPE5ej+do82H76HXc3HM5xnYbB1sq9ahFqZYVsU5jw3du8QtpxEZEpnScOegBQIefi5vVDlPhyrk39P/hAO/f6Ofga9m9MIOnVsXeQT+PT/3W+fhryn+cOehBzaZ5ktLUZIHNE3ZzfNW5qO/vnqU+pWMZWFgoOfTiZ+pkXcCknw+St0g6CpXOaG6zEoTj83bokYlAiicT7195w891VhMRrssdWaRCFiasa4lTWjGBWbJaDq6c8OD9az/yfH2vdIrGBK3PxeIBSOWYSwys6QqlpsDAf+HeN0LxG1IxWjdUMnRSBHOXqxn8o7mtSTmYOXOm3vclS4Q2gkqlYtWqVXr7KlSoQEBAAhKpGsC30XQcsLHUH6z5vNRlIrawUkWFakRCVhE2IYImsgmojb3GpWXb2TtwdtR3h4zGacwnJCG2qZSqIyEr+BKfmEmucnlpPLJ51Pc+/wyU/g2yz4as0q5MYvW3Lz7RNPN0vW3GkImy9zopVJ6NFTV6decl4yuN1W3QYFRyfNl31DvQ9PE9n6s8xwdZlWcPHzkpuKRWedao1Rwcs5S/6w+OIhPbrB5D193TsU6je2/U4caTbQlReZZVq49UefZ6JtoRt1wZaDapA6MuzmDM1dkMPTmJil1qYq1VjZdVen8XIJ9M2jvYtM+rrGhKpADFqrmCcO3Qr0Sc5RMSUp2YytaGYKUwnIfszQs/GhbbQD7rhfxQfVsUmVi/ZW6Ov+jN9aCB/LagdgwyEaB+6+8A2L/5AQCuVnLvXBZJgRJHa7lcaqbqy6jVagYVGxdFJk4/PRiAp9dfER4at42yYiMvA+MPJ/ocss+SrPBGDqs3se5zTmvLmjOdAOhadR0+7wNxtZF/H2TFa9JL1t2x1fU+L94zo+yAKDKx1bw+ZCycAwDvZ8bLwiaFyrOXEe26OkLNzun7GJhvBD/VWBlFJg7+owHHPo1g3v5OUWQiQJ12gg06svk2jwLTS9kDEO4ul2pJlbmgZHm59sQi2pDBS6uxUD6e9LeyIigyAi4A4QbEY+KCMSGk87eLddMKIm+dUjLAJTaBmtjwuRK2vRUU1Wbo2XNLt/32G+izAawMa/PFCtn/FCD0RfxloiNCVuVZMsWoMQIun0PpLPd8y4q4yELWHpB/fyyc5crLqp6Hv5IrD3GLuFhY6Lzznr7Q4P1RQ1iwXPujiUVFOtbyksI7UudWK1BLLhpJD0Vz4puHYjTYWYVjY6XrpIZFKKOUeUMCglndcUbUvojQcDyOXaBoA92AxzfYUoo4Mka59EsRV6ddoxGMysZWwwn0Ei1pk5UT2dV1NHe2HqNE3/bxnt9GFZFoSriJhc+J4OjQaDQxhFSMUV8u164Sb+6+4vK2C0yuNIa59+W8U2UJSFmSxsE6PFZlzui/+eapJ4xvswaAWn1r4/nAk9uHb3Ho37sUa1A8zmvIKpIb0wmPDhkV7EjERgZH/81Xt55n94RNAHz/e2sCPwVwaO5e9szcR/0hTaSvGRdM/WxDTJVnAIs4MjKbWuXZK9BK+tnwC7HEUUJp0yvAGhtVBFc2HOXkPF2oWOMpPchdrZj2XgsbKvVtypmFO3mw6wTFW1cz6vyvfe3irDcMQfZeR6pC91gz0KjyOV0CjKpbI8vEVQfEBkfrcJOSilYWavwxvu6LfJ8vnngJgEX6THjGURUmhERNbx+KL8aTR47W4dLEkSFUz7Mw6nO5WjkYuagB6TM7EhyuRAN4G+jHRtZjLrmzACLH4vDlLaXvs6zKs2ybHhwu790eW98h8jf7vvfjt8qTo7ZHetF3mtiENaN3sWTAZn5eFHvKmZwucqOhTDbyCalcLeSO0YQGGpzHMtQvAXijyB4rQQ1QtGRaJi6ry+ieB6mbfSGHvX7FSlLl+aWvjVQ/VHay0ytAv37RaDTsHLGCB0eFF3mmojlp/1d/FEolto52rOk6i6NzttJq7k9GnT+hCuMyE89p7UPifMa3jt3Chc3/RX3Pms+N3ze2J11mMeL3NdBUFK9XCNjD/g23GfRrAemJC2f/O2DnbHT58LcPUDoa5ygAEOH5OgaZFWf59zrC4tgVsa5XIW4SI+K9HCEX4QsKib/JQnKOQGEftxqxRgNztojPM3uKsrGpO2s0YEizUTbvXbgBMm5FKyj1BwzeAg20BOL2S3DsASzbBZ3yG39+TQK6rFZZDW9Xa0Bp4DcrneSuY1cNKRVpVPKkokaSLFPYJYy4NBYRkuQ3xMxbGh9kFcYVtnKkoiqzPAmpdIz7f61dEQ6fhaqto48XZNM86Y+B0tgrcHRQ4uQo1o7atZODEkdnFU4OQTg6ar87isUyEQL4IjSgkMyhGJGCsv98IxSNxPOrHgA0GdWCoo1KMqniaDb/uo4CNQtjmZRJNBIJG9uOJOCtfthQ10N/EqawxsrBjlC/QAI/+GDnlnDFn+SG44v2c+qvg7Rf2JvcFeSVQ5uNa8Ozq0/54PGeSfVmMerAYBNYmbi4f/EFo5v+zfhtXXly4w0rfxfJX4av/gHnUiUIDQrlt9Kj2TBkfbyEYkrCxJKDKd22EiH+IdzccwmAnuv+R/YimdFoNByau5czq08kOqGY1Aj1Fz2EdAVzsrz6TxTrWJ/SPZuZ1ygTQKNW80clXV6PMp3rUKlPU+ZWEGrOA8/Nj9pXom11zizcyfHZ/xpNKKYk7PrzONtmHjG3GUmKncsusWDYAXa8HIaNXcprbwGOvR/EJ+8gMmQxbpTr/ymYJtnmMHZ1c6p9LzFCTOH4X/6RpM3qitcL0T8p06wEHaa1wUIlRpg1OpZlzehdXN53B7VanSrSVnT74T/27nzDc++m2NjIjVyadCjI1XOv2bL8FrXTTuPYpxEmsvLL4fXUk7/b6k/Gdlg2MOqze8FsADw9ezcpzfpiPDr3EIAGgxpStXs1CqY3PIm3dsoxNs85zb8vR2KXRjBjz+5Kum+lABy4INZ1y8DVB9BiDOydDgWym9euL8W0zWLdvgZYxFHteLyF2r/Bb+2gc43Et8PWEkpkgquvYdcdaFIQhlSDNVdg5hU5QjEhCA6HUx5w8CEceAjRIvuZVAeafwWh2JdvQZv+EKYlPp+fNK89SQGNBiZvhhXa7uejJaa/5qLxMHMZeH4AXz/wDVLi66fB1w8++WmQdFgEwD9Ag39ABK89E9/erxnfCMVo2DFxO22ntjO4L2/l/Iy/PiNqFrnRiGbsmbKd6TXHMerMxKQ0M1HgnM09ilDMWaMUNX8XCQrCwqHGpP4c6D+VM5OXUWf2UHOamago2rg0p/46yPq+S+i7fThps8uHmQzY+Stjig7hvccH1o/4l/ZTWpnA0sSDe04hCz+jxyb8vMXU0bwzv5AxV1oeewuhEqVKiTpcjfcrb1wzu8Z1uhSFS/+cifo85PgEbJ3sATUKhYIsRbLx8uZznl58RM4yKTeB0ft7HgCkK5ATz+sPeXL0cqokFCPDGzMVy0XLP/vHCNHXqNVRKShUqVxE6s6pxwBkyZeBl/ffEh4ajsoq9TTlns8/AlC0sm70uXOpmBSwtE65eV5t7CylyFBrW1F20o87vypCEYgiE7vN60CxeoVj7G/0c1X2LDjJpkkHaDcmZascA+TOK9JSZHPdyduAZga9FePCb3/W5tiuJ3i/C6SG05RkSyoemi4YmYINyuDr6c3Lq4/xef4Ol2wx+2LhIWGoUshk/bADw40qFxkGfePUU0rVSrn9jvhw7KpYZ3KDUzfE5+uPUjahqNHA0n3i8/hOcZdtoh0Slv/OdPYsbw0l/4Bf9wpC0dIC6n4HBx/AqrvQpcCXXyMoHE55wqGXcPhV/FmC8qaFWrm//LqRuHYXmv4M62dC5ZKJd96EIjAIfp0BOw7rb1813XD51IIINYxaC//qhlQMbJo017a2glF9dd+VdnLRIgq7uCdwQ0I1+Pmp+eSnwddXjW+ghVj7qvnkJ9a+fmref4hg70H51EjRERnGLHtMSkHKn9pNRFzddYV3T2KfLYzeySv/g5DXDvYL5vahGya3LbFRZZhoEW1dHKPIxEi4FRQtwrsbD5LcLlPCNasb7Rf2BmBhs6kE+8nnfgMYe2UaABe2XmbrpF2JZp8p4OQmEqT4eQey8eUYNr/5nYy59ENmf/mnPwB/dVmc5PaZChW71gSgfKfqjLk6W0sm6tDxzx4A/N0jZf/md3eEkJJ9OmcA0heUTKCTQmBpY8XAc/Nps/h/emRiibbVAfA4d0evfPbyojf97r5ksp8UgNINxfS/nZMIY331IHV5uGxbJNxbWvcrH7XtxUORN9QiLreQVAZLK/Gch4WIUPwCpTMB4OeTsHYrpWDE3v9FfTZEJgK0GCIU3A8uP5skNpkaYyYUpnI1EY6a2WlHgs4RmcIGYPV0ySRkSYR2i/ox9MIfNBrXker9vwfg5MLdemVqDWkJwKX1x5LcPlOjSjNRd5/efhsAR21OxfBw06Y+MifstRHygXKpOpMdxqwW614NDIcyR8IvCIK0EZzfZTadPTaWUFYberxdm0txZmOxnn1V7lwBYbDvBQw+B8W36JYKO2DYf3DoMzIxtyv0LQc7OsGdgbplRydwlMuuEScyZxDr9kPA62PinVcWe09DtqqQv56OTCxVGC5uFZ6JNcrHfXxKRVgE/LwE8vXRkYm96sHDxfBLI/PalliwtlLgltaC3DlUlChqRfXKtjRtaE/Hdg78/KMTIwa7MGVsWuZMNT5dRGyI0CgStKQUfD29cyMxu8nM+AtpMfL0BAA2Dl4db4Lw5Ab7dCKUOcjHcMLSDMVESPC7W4+SzKakQO4K+agzWHRkZ1QdhTpCviNnobKg+UjRcp9cfZYH55L3f1SuoSBX7p5/ZnB/pvxioPrxzUciJIQskjNq9het3fk1xw3ut3fREYxBvl8262RORCqzRwqQpC+Uy5zmJDlKtBPxRJfW6k8ZVxsoBqXHZm1OcptMjZL1RXJ9fx/x3D69kYBM2MkY25dcBKB0Yro6pFC4ZRLCPAG+IdRsJe77qd2pa6Lvc2TInR5nd5F77spew5O1CoWCCs2LAXBwWeogFbfuq4KtrQXh4Rqa1JaLnzt/9Dk+73VE84pJp7hw+HFim5ioyFhIuKtF5lKMRPEWlQA4tWhPkttkauQsLBiSU1pCsXqrIgCcP/bSbDaZGvZagsk/BROKEWrYcFx8HtY67rI9tdlXFvUxqUkALBHdHEbuF2uVEuprvUCX345Z3j8Mdj+FASeg2HqxFN8ClXbCiAtw5LV++byO0LcgbK0D11rqll2d4ZcKwiPRlEjnCn+OFp9LtBBeokmFd97QYhBkrw99ogUhLhovSMRtCyHDl3NMyRIhYdB1ERToCwe0+VAHNxMhzsNaxE2of8PXi2+EYjTkry6IlzUDVhtV3tbRNioH28y6KS/sOWeN0gC8+O9WjH0VR/QE4PjIeUlqU1KgfMdqFG4g/OcnlR4ifXxEeATbJutm1Rd2Xc77Z5LZcZMQPaY0BGBuny2xlmk8XPiv756avD0ujYVCoaBAHTHgvLTpjMEynRcJz9z1A1cmlVmJjvd3PQD49OIt8PURio7uIkT/1TX9wbNrdjFwe3PzaZLbZGq4ZBAhHK8fiizeHjdfx1U8xUJpKLv7V4auI6oAsO2vy9RoLvonR/+9E9chqQKRXoqr/7dBz/MuOrrPaA7Axon7kswuU8Pjg+hP/nfWi5GDr8dTWkCj0dC70VYAtjzsz7prQszk15abeP3UxzSGJjKi32OlKuWmNYgPkVFOkV7HNdoIQnHH+tQzSRCi9c7LLeapsdOKqASkYMfqwX+J9aB4yBS1Gi5ruyJ1ipvcLKxVUEFLIP6rnXuZXEGs512HX47riMNi66HSZhh1Do5/NgeZ3xl+KQQ76uoTh5vrQK8CkEtS3CYx0bQmNNKmwi7X1rTX0mhg2VZBIpZpD5e1TW3TanB3vyASG1U3rQ0AwxbAv0dNf53PERACLWdD4aFw5r7Y9ns7QST2ScLMIs9eJy15nFSIUCsStKQUfCMUo6HdNKEYePvwLV7ffW2U8l2lzqKmC/D259U5OT9zGUXohCKu31BxoMgXeWS0LuwzUq3Vzs0ZgLDAoFg79JAwdUdvSfVfWRij3td8ckcc0gsviIVt50qdf1nnPwFoOLAuvZd2BWBS3VkE+cU+BSt7r2WVFP3iUP10SS/yM316r6/em9tV971SR+EVcG5D7N4esvc6raQKbmyKzXEhLmXo5pM6ALBvio5IjX6NvJWEF67HpSdxPuMyMPWzDVAyi1fU5+CPfgC8u/0EANdcMWNsPLzTSJ3fw8c+/kLRkNZOXvlO9n1Iay+feVllIxSAQwPjPzaTo7yXquy9fu8vFwv01Mj74KH1UIyrDogNsmrBspB+p8PFs5TG2bj/Kr29/LMnqwxt6v/IJg5V3no/iJDflVNOkdZdvMeXj3vgaC0XEZHFUc49SEb1F5BWeYe42xNre2vKtRQTnlsm7ARi3gcLlQXflc0BwIXdN2Oc46mPXK6l18FOUuUBvCPkjlFYxW2TQqHghY+Y3Fu26AkH/joe7zn7NBWq9z/0KU6eLEoy5XRh2pY2AHQovpjgwLjrWtlnI7OjHDMUV91dun11IKaXYv46JQB4cSX+6A/ZZxXklaE/V6qOD3ffOxhVLmdhdwB2JoBQ/JimoFR5VQa5hH4W7pnkyqcT67Naz7h6ZcU6TRwhz5HHGH0NSWIrwnAAVgxM+Bfy/AJVBsH0zXDnuY7QCAuHXVoB758NaPgpojUnEzeJdVz55ZSS1YwqnlTvi8S8Cr8dhIIzoeRG3b5Tn801FnKFgcVhdxO43l63bKwFPfNDduMeW0IlM8nIKlsHntD/vuh3sfb8ADOWGzggAQGCimhV8YNnUK4j5GgAE7TkscoC/p0Fz/bD/BEg15rII/q7sPkoDF0Am+LR3rOQ9JBUxDKs/BQI9SZD8V/hxnOxbVp7eDgXOkmICoUnIFhGbeAdrdIOuv0aS/lAw4JXsUETaGQlEFk+3HRK3mqNIkFLSkHqyeSeCEhjFcaYAwOZUG8u81rNZcqtaUZ1Vsac+Z0JlcaxfsBKRl4ohIWR+uJ+wZYJ6ojL4H1AHAMze9GyRYSFR3Xuo3e08javw8Nth7i/+zS5GxpWS7W0UEsTTensg6U7dDJwsDGOrBiw/zcmlhzMm7sv2TVlB/WGNY/3mPdP3vLylmhNG/0i/pOsBTPy4s4bzqw9TYNfaho8TpZ8cLULISjc+P/IVqWOk1AoXjs/1w7f49LJl+QrlwOAu+/0e2fZSufl+aWHXDjwiNyVY8q02VhGEBBqfJUhS6Ak9qAUIF2B7Ly/+4yLBx6Qo1JRHKzD9AjnEq2rcHXzKY6vPkeptjGfcUcjn6VIuEqSqAnBlZcx40x8noqeoyHvjhyucg1w/nR+UuX9QlTSBMe7AGupgWBAqCrW9zpv1UI8PHmb4FcvSJfbPWp7wxEt2fn7Bq6v30/NXxrGef7Xn+ykSU5Tk6LGDtyf334DRNbFcvWqjUotRZjJkpayg/1jG68BUPfHyrzyFfVHWLD4n7MXyRS1LRKyEy8g7ptXoPGkYmbHYJOTivEhIlzNh2g2y5Jl7yQJEVO2z5GI7/1pN6kF/225xOl152k6rCFuTjE71v9b2Yk+BSew+JdNlG1cRG9fgXRy9V4WK/koA6ugN0g94WHxT1xYAXceVKTgd2cZNuAarnmyU6FWNoNlH9/z5txhMQIcPacKgWoVaSzDqNkgG73HVGLJhDMsHX2IEfPrxHo9j0/2cZLan+OVr41UW+0VaI2NpeHy1XvV4tL645z4YzvF6ov7FxxmQbX+33Pv0FUOTdtM93/iFpjxC5EXbjF13Z3bNSDWyZRsBdLz/O47fP3CsbHTvdPBarmJjoyaZ2DrYnT5iLf3UNoaz2ZFeL1A6Wj8ZGTEB3+UTnDwmvhev4Ygzxy0hFigOiaZFvFejmALfwMKiapYaWQ1GaAlO1/7wJK9Yvkcv3cwfKwmGv+wWpv28+c4uhsRXrHvM1g+nhTJVkCzgrA9muN6EVco7AId80LmWOYlNV/QVbVML3e8haT+pZ2B4eajA5CnHsxfB1VKQ/linxWQJBWDP8Hkv2HlZ0FZfVrB4E6CUATQaM+rtJO/hgyik3Hn5kGF/vDrQnCyhLqlDR8j/Sx95rD+wR+aL4H30ZrK+W2gTjRBH43E/JEqI2gC4i8XHUon0BhoFo+eN7xd6WwlRfop7RyjJqqNgcJGzgHjG3T45qH4Gdxzp6N8KxEOu7znUqOOsXe2p/5A4Q+8oOlkk9lmCuRtLGpuj2MXYuwr2l0k6Lj8h3Eh4CkNCoWCkReEPNeFDae4vjPmf/A5FrcUgiyj9w0AIDgghBd3xIC+Xp/qpjE0EdBpkpha/WtA7Dnlmk0XQiVbB/2VJDYlBZrMEYIz+4cbFl+p+T9BIh+dtTXJbPqGxEWlboLEPxfZm9eiaONSAJxZfjjGMSkdOYuZMNu7GbH/LyEmUb1DmahtHrcEWZ63lGFSJbUjbSYx8eP9Vo7oT+lQKBS0nyYSls343nDqFWs7K9Jmdgbg/n8eSWSZ6ZE2rRWnz4l3oGejHTy+522wXNPi6wDYdumHGPt6jqjAkoNt6fZrOdMZ+oWIFEv75Kk/0nXMIIgyr6eeSW6TqVHpe+F1fOXwQzNbYhrs12aYKap1iLTTzgGZK+RZrYZ38XjITe0Ij/6Ee0th+f+gWUUdoRSJzrXjPkekaEXd4kmfY25yXZ0wyrWWsKYG/Fo8djIxJcLKEk6uEZ/b/A98JL0eI3H2KmSrCd8115GJOTLCsSXgsRt+7Rrz3ic1MrjAkRni809/wH93E/f8rz9B8UlQeZaOTFzWEe79rk8mmhthKUuaIl58C3n+CtFpqiDSHp1/xPPrhoUsPkf1H4Vf8CdPH57+l3LyoZTsLTrsZybFJE8trHQzv+EhpnMDNicsLFUMOjIOgJ2/b+TldY9Yy57WEhMZC2YlY14x5TaqoiAYu85ugzIZK5BG5l3z8Yzd/ds6jc7bx/+DnJt4coWVvS02zmLG6e0djxj7lSoL7N3Ef/P+cerMRZfakbW4ULa+vvOi3naFMvm+j1+K0g1iehCnBkTmhUzjrHMteXRJeGDlKf11Eoqt/ifyKPYuPjtqm9erj2ayJmlRtpmY3H3v8YF3zwyTaqO39wZgWltDsXApF3m/s2fZHiEg17T4Onw+xGRkug4swaBJFfmusOHYt5KVs+KexYwJ0IxAGm37G+yn//vSaFPSBH6U8zRN7qjQVNTdZ7TSvIUri/br7avU8Tu1WViiSLVIlWd/M2nfFRgIFUeJkObIpeufsOW8UGSODksVVC8Ks36E+8ugdF6xfVr3+K8zXOt3Madnopr/DdGQIzPMHi4+F2tufJ49X3/4cYwgEtsN1m2f0Bee7oLjSyFnMpujzekOu4TuKz9MhtseX37Op16QfxzUnAvBWrJufTdBJFZORhp4Q7qI9aYD5rUjsaFJQLizJgWFPKfeEdcXYtwxUessbL8AtVoubOuDRzw+6skIKltdKJShPHJlBnUD4PrSTUlmU1LD3tWBHzeK+72i67wYs+WR8LggZpS7rxJeb/fPPSY4QPj9l2n6uf998kPRGmLK+NHl57GWab9sIACb+y1MCpOSBK3+HgnAtt7TDe7/4S/hbbqu+5wks+lLoY5Q8+yMyDvlmjuLma1Jvij2vUjk9OhMIk/xmhmlUimhaAgPtYRi3tLZzWxJ0iIiXM20rhtZMlSndluythjhXtgdU0gttWLYDtHeDq9muH52SpcmSuzi1cOU0/cyBhVqZeP3+WKyunKWZYSG6IcOD51amR6DS5nDtERDnUEi4dyZv/UThtX5VeSBPJ3K1J4z5hRCYhf23QOgWuuiAOz7557ZbDIlIocYhnIoJgWOjYPqnzWXp+/Br2uhxFAdyZivPwxaAseuC8+ogGC4pHUibVUl7mtc0QqxZE4L1vIR+N8ggVZ1oU5F8blyx7jLbj0kSMTCTeGA1oO0Ukm4tk14I3ZqmLwViwvlgPVi+EKTMeDxNmHnufsK8g6EBn/qtm3pJYjEkslwnraHNvvY5NQ1R5jqYVZC8eTJkzRp0oRMmTKhUCjYvn273n6NRsPYsWPJlCkTtra2VK9endu3b+uVCQkJoV+/fri5uWFvb0/Tpk15+fLlF9vmltWVSp0qA7Cg7fx4y0cqQ9u5pKFM28pffP2kRKEfRLj2w10nYuzLUVeIdTzedSzGvtQE93yZaTm9MwDzGkwgLCimR2bHJX0Yc3U2SpUFGo2GeZ3+BmDK+bhz/CQXdJ4sOu5L+sce9py5qJgt//D4DRpJIj25Ik0656jPH1/FzJPlkkV4d4QFhRIemvx87CPCIrh28DYLeqzi5zyjWF79J1bU6svhUYsAsLQXMUVp3GPmVvxa4JZTqDoHfdJP4BKZO3H/1NQV0p4+u6u5TUh0PL0hPITLNi6stz1yAsTFPXl7WiUmtv95mnZZJ3DpwH297QMWiuiJ/3beMIdZZkGm/BmxdRR13NVDhicGJh8Vk0Jj6sTfV0tpaPNjYTr0FaRTCaeFiSYgllxQqF5xAM6u1Jc1jczjfH1b7EJxqQHlGooYw90bUj6hGPloOkTLXRgZKGCukOdMLrCsjwhpjlxOT4SRLaBotDmqCDXsOA8950L+H6FoH7F9ft/4r9FGO1e9aViim/8NBrB8oli/eAOzV+rve/0OGvQSROLAKbrtf0+C50dhw0xwldffMhvKF4DFonmj5hB4a9jfxSCueggisekM3ba9PwsisVDGxLQycRGZJsFcXs2mQoQmASHP3zwUjUNAQADFihXjzz//NLh/+vTpzJ49mz///JOLFy/i7u5OnTp18PPT5RIaOHAg27ZtY+PGjZw+fRp/f38aN25MRMSXi500GS4ImFd3XvHofOxqc5e2XeL2YeExEBk+m5JQpLP4nRfnrYuxT6FQYO0kQkYD3xkOOUotKFinOFV+FMnLp1YcHmfHfc0woRxcrnkJHN1SRhJX14yiFY0vXK58t7oAnPlrn6lNSjK0XjkKgBXtphrcX2+UUDw/OHmjwf3mgjpCTf8Cv7G073runNClUrC0t8FSO/WfraIYbKYvlMssNiYHVNTmUby0SX/wGRlO5/NSMnt1CkOIgQmQlIZ9f4l7V6+X/oScv08q61UagXWThLdW1/H12Pzmd9JldQZAoxZtUqQQz9eCMUfESH3+j+sN7rd1kBOdSWkYObsaJSuKEWCZtIbzAadUxJaaQhHNdSi1kajRYZtGPLsPb8mLAiU33NZ66tWvFHOfuQhFQ3B3hu41YetQfaJx73jo0wiyahV3XR2gYZk4T8WbaARPBmdTWfwNn+PhfrGeuxou3IT5awWJWL4d3NYO19s2gAf7BJFYu4L5bP1S1C0NU0SKeyr0h0/xCJ+cfSCIxDZzxXdLCzg6RhCJuSSVoc2FyBB0r49mNSNRkdpVns1KKDZo0ICJEyfSokWLGPs0Gg1z585l1KhRtGjRgsKFC7Nq1SoCAwNZv150Kj99+sTy5cuZNWsWtWvXpkSJEqxdu5abN29y+PCXJ+J3sA5j5DFBRCzr8RcR4TFJyrePPPl3tAgH/u3MWL1OULznl1SQTQjS2ccfZ2BhqZNNsyCmTRlKipniq4s3xNiXEDXIOJWnEwF+wQmPOajetwG5yovQ4KkVDOvW+3v58d+2qwB0mt7SqPPKqv/KqkIbqwhdqEoeAB5ffUGB9DHzJHo/e8v5FQcBsLLXv0/R1ZGNQbo0cjEusmrhYLwydNrconUKDwkj6KN+axz40Z8DkwSRqFDqv7++ks+S7H2LD0oLJZV/KEO9PtUYd3QwCx5NYsGjSXTeM5cs5bWqptqxVvqCOQ2ew8NbjvC+995BqryDpMIzQHpJ1Ux7q7ivUbi+yLX2uZcLgEsW4bnp7xW7qEUmJ3nSSlZd1EtSaVdGwfjFHc8E1cWyqtCy91rGpnM7bgKQs6jxyYyMVcKODtn79rmydFJg85vf2fzmdxr9WB6AtkOqA7B32fkEnU/2fZNV504IZO6DnaMtxbUqwJun6CdWeuvhxcDSIpdxwz662MS77+XqvZeh8iOtUFtJNw9LOXVut4CbUZ/XHG2FSqUkKDCcbvW2GSxvp5SXbs3hJCfLmdlRrl1Pa0TfJ29V0cd8c/elniJ02U61ALiz/1Ksx8oqNoPp6+7H3nGrYeQrk1XY4ZNwlu2NQi4FhEWG/HLl02aVK++WhgPa+bx6FWPuN+RtZJFO6hKoJF83tWSz/p0rDGkFx6fD4xVw0bAWlB5ai6qHLcONu4aFZCCJrEKyldxtSxDCJDNLxKdU/TkCYwbLxYC1FRxdKT63GgAzRMAYDvawa5EgEWcMBZtYXl1jFcAjIfssyUIVT7enbXUYKrJAUOInCAqJ+SwduSWIxC7ajFUu9nB6HNyZBVnTgoXxovBATFXo+BCegHlOdSziOiO1uUjnfTaHqP4oN3muDpTTA9AEp45ctuaAKv4i5sHTp0/x9PSkbt26Udusra2pVq0aZ8+epXfv3ly+fJmwsDC9MpkyZaJw4cKcPXuWevXqGTx3SEgIISG6To6vr3jgHK3DsY02YPINUZE5qx0NfqnBvj+PMafxjKjcigAhgaHM+V4kSh+yuTd2znK68l4B1tIdd9lB42tf42rNoj1bc2PZZi6vOUzu1sJjUaNWc7Rrf0I/if8nV/u2Mcg6V8mBCogOYELII2MhS2R9jg6LfmJSmSGEh4Sz/ue/aL+gl97+ObV/B2Do+m7YWWqIYnTiwDvJey3bSQ6LUBr1bLQa35LbNaaxZMC/fL9aX5H82ZnrUWG0Zfu0JE/LOnh/QSP63l9uIB59IGEsZP7TWjMGcWTobNb3mkfnDWKi4O2952zoJuIBCjYqT+1RHQiLZoaDTRihEu+cu0PiT8P/MKGZ3vezHqKH+e7OUwB8XgrPBqd8eQy+V7nS+kn9htKZ5XoRviEq6XrMN0Ql9Yz7hVjGTSpaiVVoYIheOY8rHlHeie9uPCRDvaIGD/cKsJYm/R0lJ4Rk32nHeMi7LPkz8PKeSKrz9MYrCpRNWC5NGVLRK9BK8tzieQz2D+b9k3e8e/perJ+8492Tt3zwiOmVExuRami77EA/Ice5OwbFSxB8CYyZFMlZuzSwnU0zT2BhaUFEWAQvP9kYPYEp8/4nBFYJICBl37dBf7Wkc7ab7FtymtZDa2BpreLR1ZeMayoE5bpMakTtzmUBYUtRN7l6LJPle6nyAOFvbiPzyxVWcqPYIJfC2KH7nx4E9CCX9VIunHjJ7OHHGT1d3+3GN8IOK4Uc6e/h5yB1/1762kjV955+8U+M1BrQmIcnb3Nk7i5a/fkLINKTXFgjPHWfnrtLoQaGXcUSMomXkLpepu+dwyUgznq1TOPC3L/4gjN77lG9XSmsrC0IDYkgMEyJSmXcdbJav0eN8WkgFB+foXTMYHR5te9bo0lFtVrDlVPPogb/1erYY2ETvW7yJzBYkI7REe7pj1KC5Aj3kCSCJH0LZEmm4FCITLleLAsY8MeIgXDJakaWjJMl+zQJyPJjlUmuvCwpalsBNEbwRrnd4Y9fYcA0GNQJ+v2gC7GP73jZ361QGWdTVHm5rhKhRoi+964FH7xgxREo1BNujhbeh7tvwpBoWX2yusCmnuBiB6h1xKBabu4Ipb0cqWiZQ554VToatquW1l9i5U74vYtuu0U60IQafyOUdmnQhBrPCSgdTefCGaFWgKRqc0pSeU62hKKnpycAGTLoN4AZMmTg2bNnUWWsrKxwcXGJUSbyeEOYMmUK48YZH5rceGBt9v15jA8vvLl59B5FaoqZvkFFxTma/VqfnCWy4SfPrSUbfNeiLjeWbebB2n/J3bopgW/fc6KXjjytu3kZFlaSNWQKxsgLM5hYcjCPz97jxJIDVOstyOmbey8DYJPGmgIVU16IqUsmZwA+PNcPX7/8906urd4LQIPZA8lUUm42OyXAvYTIVeTt4Ul4cCj3D13m0GTRA64zqgOFGpc3p3lxIuBjIBe2X+PMPxd585nwgNe9JwC45E6CqelkjEiiJSI8AoVSwaIOC3lxQ+Tfq9SpMkViIRNTIjQaDWlcdKOf97Eo4CY1NBoN/8s/MsHHNxrezOB2a/vUHdIaHyxUuomC9lNasWbIP2jUGhQWKaez+aVQKBR0ndyYlSN3M67ZMloMqsGc7qL+HrjsB0rVS31t1udQKBTc8+1Ofse/WT73Jnnyu9Cue8r/3elyiX7+U63w3cGpm7i+VagoZCuVl0bjOpnNNlOgXKNCrP19H8fXX2H50J1R28NCwlGpkmc/W6PR8PhJKIeP+XP4qD9nzsXOHNjaxKyXwpJfeuovRj9ttq4ZqevxTFFoVkMsXwtGtYEPvrDrIhSZqL+voDus7gppUkF3KTmL5SQUao0ChWQIc0oKeU62hGIkPp+B12g08c7Kx1dmxIgRDBo0KOq7r68vWbPGPRif+t9IhpebzOJea/jjzjhmtBR5bHKWyEadH+ORAEsBUFroZkWf7T3MnSVCZCZLnWoU+aWHucwyGxQKBb+encK0iiM4ufgA6fNkJF/1wmwfJfJMzv5vqJktTDjyls/Nw/OPeX/vGenyZ2f3LzN4e0skv2mzcRIOqVjco97vnTkwbjUr2own4L3wtf9hxVAy5E8+Ume+H/z5b+sVzvxziffPYs/955wzMyV6teLYiD8A/dQFXyOq9ajO0cVHOLbkKIcXHoraPvzwSJwzOpvPsESEv08gc7ut4ck1nfCYnaMNrUcY9sZPahhqdx3TO5I+V3rS5Uov1jnTkz53ehzcHGKU/9wLKMBbhJ9kK57DZDanFLhlc+XDc28KVM3HhBszzW2OWVCrUxlWjtzNs1tvosjE33f0JE/Jr2cyxdpGxcWXnSiTZQ0jfjpJtpwOVKxhfJqA5I4ZZQdEfe64YhAZC6U+dfeQIOHK9viqqMftHazYerMHtvbJg0x89SqYUUNfcvioH2FGeN1ldFdRswLUqqyiSjnTRR8lJ2g0cERkPqJ5uaS5ZrgajHRg/YZUjDk94e0nuKBNq14mO/zVAWxTmcJ43bJw8ALceARF85jbmm+ID8l2BOru7g4IL8SMGXWJM969exflteju7k5oaCg+Pj56Xorv3r2jYkUDSTy0sLa2xtpajsJ3SGtP8+H12TZ1P0NKTiAsWEy3DdncW+o8yRmlBnTm8h+ro8jEshOGk7ZoQTNbZT5Y2VrTf+8Y5jWcwL9DVpLhO+HnX/WnetikYI+ZdhNbMKH2DI5PXI7vS523W5cD81BZJ48OramQv15pDoxbHUUm9t43BVtn84rqeL30YXa7pXz0jCWZCJC9aGYqtilNqUZFueqVfMjP5IQKP1Tk6OIjUWRipU6Vo4S1Ujru/+fBtLbL9bY17FOFvYtOERIUhqW1CqSCL02Hufd10opfmtri2TUPALKVMJwf9GtC/V9qs3bYJo6vPE2Vnxqa2xyzoWqbEpzcJEby00/0I2NKyTKfiHBLb8uBq62oV+JfOtTbw5Fbbcj1nbO5zfoiZCqUlde3XwCQtVQe2i78RSoneUrAp/f+DKo4l9BgHUs368xAqpZIXkOxkkVj5mq1s1NQp6YDtWqkoUY1e9zS6tsc4fUiqcxLFpirDTHtlkTecSefQZ+9MKsO1P9Grnz1WD8YTp+BktnAKpVy+MM6CEJx2lpYN9bc1nw51GpQSHbT1cmjW28UklcrFg05c+bE3d2dQ4cOUaJECQBCQ0M5ceIE06aJLLilSpXC0tKSQ4cO0aaNyFb65s0bbt26xfTp0xPdpto9q7Bt6v4oMnHOrbGJfg1zIfijL5f/WB31vfb6xVjaSyYUSYVwyuhCl79/YVX3P3n74DWANvxZMhlFMkLarK4AUWSifQZX2m6clOo6758jLCiYP2r3j/pepHkls5OJAOtHbdMjE3OXzk6ltmUoUb8QVrYGCN7ULVicIHhcfsrizouivqcGr0SNRsOOOUfZOe+43vYh67pSsFJuAPYuOkVEmHzu0ZSC51dFntDsJXKY15BkgBKNirJ22CYOLjz61RKKC/v9y7ntOqGSDy8/fZWEIsB3hVxZubsBXRvvo1bhTVz17IzSKeX12T6+9mZ+I13snqWtNe0W9TOjRYmPIL9gRjdYwjsDqSnSZ3MBYhcMMwdev6vGy/uvyJollbk8JSLmbxfrEc2T5nqltH41gw9B3dygTN3d9W8wAuVT+Txrbm1a8LM34y6XUhChUYBkCHNECgp5NqvztL+/P9euXePatWuAEGK5du0az58/R6FQMHDgQCZPnsy2bdu4desWXbt2xc7Ojvbt2wPg5OREjx49GDx4MEeOHOHq1at07NiRIkWKULt27S+27/Ok+P7en5FIGn0xDtmk+2kTIGgiK36QyTH+DKkvT19mZ9v/6W80klzyTkBSfFmFPVnIioHEh2wlcuGUUecBGxEWzlMfuST9siqbsv+RzHPx4tarqM/Zqxan3T+TTUImSqs8S6pIg/EiRb4v37KpiRikZCuTD4Cb287Ee5ysYrgxCeg/R79V3fnz4cQoBedBG3tRrnkJw2QiUDGHXNbtJ15yqs2XXslJwcUnHpIYx8RWt6rVav5sM0+PTASkycSE1MWyCuDGvtP+3gHMavknPXL+FkUmZiuUkbmXfuVvjwlRZOLnSIjKsyzS2skp7Bmrwh6Jz+ux51oPxcyFDXvlJuS+ycJTQm07ITDWizN6HkXZvkZCRFNkkBDRF1kxjdGN/ooiE2efGwjA9A6rYy1/44NcPfY6TFJyFlBlLCRVXhMql7He1udWnPur1c3K+HmVACjhvhqbCHliKoeD3DFZJFWe4xIq2zd1SxSZmFXrhRwWJPdOywqsgPyzJ1vXe2j7h6HBYUxosZxeBadEkYmj/+3OmhfjKFJNuJl5v/HlnmQbDfAiRO551TgbHzpuYaEge0E5kS9ZVWgAlbvchK4qh+QFJAXAjRWU2H9RrMsXAJWkcq5KspqJFDSxt4KewreG3rtjL28pKYCiSIBbUehrufKywjJB5+TKJwSyv1tWxEVGwAXAKq9ceQCVpDiOUlJbTlbEJcxDrjyA2kgR5pYjoecUGDwWJi2Chetgw244cAou3IBHz8D7I0R81uVUB8qpNqt9YwoFfoNxMKuH4qVLl6hRQ+cvHpnXsEuXLqxcuZJhw4YRFBRE37598fHxoVy5chw8eBAHB13jO2fOHFQqFW3atCEoKIhatWqxcuVKLCzkyQkH6wjsog10QyOU2Kh0tcLPeYQqbo12xTm28RqDio1n06vfova/C7CS6uh7+tlKK9sGh1lIkUf33zkZ3K7RaIgIDuHy9EW8vXgdgNIjfyE41IJbM//g9rINFOjzY7znd3MIlh7IJqQDKIO4iKyQgGCs7eUJxz5bf2XXuH+4vf8qk8sOY80L40V9IHbl0thgo4qQ+l/jIitCAkOwthMd6Ks7L7F19MaofV5P3/P6k3FeDbJktizZbGWhxl+y424dy/sTHhiEyk78528vXOXKpDkAlO7VnGLt63Fq+hoe7D3D6RVHKdY+9vxzmZzkBoCyKs8JIYEuvtB55Gi0kxp26VyJCA1DqbJAodQ/ZybHQCmytnIO+QZVliD0DVFJHWNIFfrRRQ/m/LA06vvEk0PZPvMgl3Zex+veE3IUM36A4xdiKU1OyU4SxPf+qCPUdMmhX6807VeVlkNqoIy6p2pRd4dFoLJSkSGHK289vFFEhJLGTv5ZklF4Bvl6LCBUrovx+XP64roQYAtW2BPgH6FHqkHCFF5lJ5wyOQXi4W06T+a4+gwRYeF6uVFdsqbD58V77j1VYONk/G+XDT2XnQxKCGGZ2dFwXRnkH4JttKzyGo2GvoUnEhIg+mJbX4/CQqWkVK08XD7yiH1/HqXt4KoxzpPfSc6V29n/jnTSgPC3D6TKK1RWaII+xtgeFqZBpYqZg1SZuxq2xF3P9Po5D4/vfGDV4vvkS7Oce8F9pCYIPQJcsFEZ/8sfect5QRqaZPvcK7Hbyv5kKZaDhS2m4vX0HQFevtinNU7B+LWvvFdmOnu5fqt7LM9qbMhoH8C8nzZzcc+dqG0DlrajdP0CBAeK57h808LcPPGIC3tu03NQCfzD5Po+OWy9CIowvg5IowwAJ+Nzbao/vUpEVei7QEzSMfztYyzcjE+zE3o3FIUkKSIDY0mmvvPE+q//gTqWTDUBIWAoM5KsynN4NPJuYGlYdhXOvoQX3pDFwCsiq/KcEMSm8vwxGJysY/qjJETlWQYJUapWqBJGpn6OoGCwsgRDlIMMqRj2SP7aoR5y5WN7VmOD0skwqRihFvk8rT/7/yyzyF/DIi1o4hhmje8Cv62CK/flzquP+ElFFydwcVLgktYKV5e3uLpY4OqijFobEpqShUatQC2p2qxJQSrPZvVQrF69OhqNJsaycuVKQHSuxo4dy5s3bwgODubEiRMULlxY7xw2NjbMnz8fLy8vAgMD2bVrV7wCK7FBrdbEW6ZW+xL0nfM9ABq1hiPrryToWubG7uY92dv6pygyse6aP8hUsTTpy5cF4M2R42a0zjQ4OHM70yuP5MGJ29LHWtpY0WJKJzLkEx2y/1Wck9jmmQRPLjxiYvlR3D12m30zd0aRiT9tEInP/V+8iuvwFItDP/TmytT5PN68M4pMLDNuWBR5WGlwBwAu/bXNbDYmBvzfCPLPrUBONjbsy+6eY81rUBJhfpe/9cjEBY8m4ZLJOUog69Bfp8xlWoLx6b2u0zPin66seTGO1sNqRSMTBdaPP0C33BMAKNNI5Li9c+Zp0hlqBlzbeobZFQcRKum9lJIR4h/M7EqDubzxeNS2ij/WB+DKxmNmssr0+LnwRPqX1OXh7JHzN0ICQlEqFWx/OxoLrSrBqLVtAVg/7QThKTzsv8tPb8mc7xnbdst5U0Ri2oLylCgrJpry2yyKp7R5cXLJAT0ycfTlmWQplgOAOv8TOW/PLN1vDtMSDV1yjIsiE3vMaMqaF+MoXb8Aa8fu48d8kwj4GBSlSn5+Z9xeqCkd5y/ITcomd9wVc1yksRWLITx7D8UGw8IDiX/9f5qJdf1/Ev/csnjhC78dg0KLxFJpBbT619xWJQ3+PQTZ60P+ZpCrkbmtSRpoNDB6PxSZDSXmJs01O9aGJ2vg/gq48CccXg2b58GSCTBlCAzrBb3aQqv6ULMClCgIOTKDk6TTt88nePJcw+WrIRw6GsQ/W/xZtMyXSTN8GDzSi76DvtxzMUKtSNCSUvBNLyoahtZfHuf+zW9+56dZosOz5vEIABYP3kWgX8ob5DjlEuEP9pky0GTXCmxcdJ6MFrbCgyP0k5G+yCkEFToLb9h/Bi4nwDthOWt6bRwMwIcXH1k8YEui2WYqZC4kwlbWD1jB2dUnARh+fCyZC2XFOZ8IufH1eG42+0yJt+cu8mCt6N1UXzobt+K6yQilhZJMJUWH/snRS2axLzHw4a5Q53YrKMJgAz/4mNOcJIFGo+HeGfG77V2Ed0qgr/AgyVJAJBq6dkB+0sDccHF3ZM2Lcax5MY6CFWNPjvPuubjHnk+9KNNAEIoX9t6JtXxqwNV/BUGssvp6cnpZad1bjs7WTXrkr1MSgAsrTTBSTUbw9w7k1UOdq022QhnZ5jlaz/POwkJJ93F1ABjTcm2S25iY6NZRuBr9POgDtZu8ivI8l8G+c7pRbY9GuxLNtsTGicXi2XUvIPomPi91nqR5KhcA4PrW+NORJGeUb1qY1sNqsebFOKq3KxW1PXdx8Zt3Lz6NvZNgoyKVnlMrjHHUSEloNFqsd02Ivcz/Vop1zcKxl0koCqWDLFqy5J8kbvZfBMDYqzoCsf462HJPt790RljWOPGud+GWIO12JJP5sxeeUPcnYdPgWbrtu+ebz6akwvwzUGgWbNXOf0yIPbDLJLBUgZsTfJcDyhWHBtWgQ1P4pSOM/hlmj4SV02DHYji5AW7ugecn4eWlNFLL8zvZuXk+Kyf2ZWLbeneWL0jHjIlpGfSL4WjPb9DhG6EYDa8fe3Nym3GzhTZ2VvSbL7LxdvluqinNMgnKjhbiFOFBwTHCY4oMFfkU7y/9O8ntMiUc0jvRcnoXAGbX+j1BnXaAUZdmAnBm6w0O/B1TDS85IXp49/jrM5hwYyb2riJ8r0h/EdJ+Y84Ss9hmSuT5QbybOZrUo8GO1dimj5m4v87kvgAcG78sSW1LTHy48wSAdAVzAWDrYlyYWEqGQqGIyjfZ5vcmABxYdMLMViUdqrQuDsCpzdfIWVTEHl1M5YTih0dvADER8LUgerscHiLCor+G3z/5qPCeH1NHjNL+9pjA2D19DZb9vk95AO6cf4732+QlbCGDOjXsuHNRRNbcuR9G5nzP8HgulwBu/jRd5vrTh18wY2QSJCJLAMZcnc2Yq7OpN6QZAKeWHoral1qE4X5e0Jqm/WKG4ZdrKnJu7l5wOqlNMhuKFErcnObmRHQ/hOxxRIPf0Hox5jc+wlwKO1uL9YQzEGbC9LjP/eG3K1Bih1iaHoYd0fwPymSCFU3hdh+xrGoGLomYcjhfDrHuPw2eeybeeWWgVsPctYJErNwV7nuI7e0bwP2d8Gw/FElA/sOUgn+uQ8GZsEjbnPQsC7cHQ8si5rXLVFCpFKR1tSBvbivKlbahQR17OrRxoHf3LycU1RpFgpaUgtTfO5XErN7b8P9kXP6gqq2KYmMv8n/sWZq8iaXPYePqDECIT8yEB65FxbTa+/MXk9KkJEHBOsXIX1PUhAu/nxJPacNQWihZfGs4AGt/38fNk48TzT5ToEqPmgBc3KQ/wEiTRXhz+Xm8SHKbTI08bZsB4LErdk8elY0VDplEhuw31x8mhVmJjg93BaHomF0QSzbOqZ9QjI5SjcS7fHipLsQ5Mnfix7epy8M6EsVrit7rqc3Xogbggb5yOe9SAjRqMVJyypzWzJaYD3VHiLDes8t0IaCu2UVCqqCPCQuPTe5wz+WGjTaH4u3T8betk3eKScJuReaa0iyTw9nJgtcPctCmuUgSV7H2K+ZNNU7eMjg4gkkjRfqdK15ionDZrKtsXX0vrsPMimwlxSTYjd36EQIFG5QG4PnllNkmx4XP01d8DXBwkM9nn1zRXqTRZ+3w2Mtc9xDrsnlMZ4eVBQwtJz63ScSsPc/8YUw0AvH7I7Ar2vCgjBssraQjEFd+D2VNRJoCOKWB9Vp/nSpdISwBuRITipsPoXALyNkQ5mgd4J0dYM+fgkScMgBsjE//meJw+KkgEsdp53uaFIRbg2FQVaM1W7/hM3wLef6K0HeWCBnpkHeG0cf8fXsoACt/O4C/T8rKFZKhTDEAvG7FzHZq7SYGccHvU5/iUetZ3QDwfvGBs6uOJugc9k62TD8uVIOnd1jN26dyCeCTEjX71gVg16StMfY55RWder/nqSvsRqFQkKGCGJi8OBS791qThcMA2DtgVqxlkjO8H4ip8PAgQSjZuH5dhKIhj5Y6vUUexeOrzia1OUkClZXIhO3jmToJ00h4eYiQ18xFc5nZEvOhaDORnf6/VYejtlXq1QCAKxsS1nalBEw7KaIkZnVcGW/ZQuV1CuC3z6f89B1zp6Vjx0Z3ACaPukJmq9WEhsadI7Jq4e0AjPuzGvZpLDnzvCsAI348ysVTkpKsZkbln0Q//PgfO8xsiWlQqIqoz17ef0fZxsJj8fnD5Nt//AaBsHB4oO0mV4xD3L2vNuBlZhfT2tOlqFg/9IYH3gk7xzN/GH1ZRyA2OwK7oxGIZd1gWSW4+r1Y/qoEpWMG+5gUlYpD71bic55EDKc2hOAQGDpbeCM27gd+2iH9kC7wdC9c3wyFTUgUJwdc8YTCS2GgtstRNitc+x9MawjKlMNtfYMZ8I1QjIYqzQrhnsMFgL9G7DdKudDSWsWQ5W0A+LXMJKnrySrCAtKq0PnSxy65VPTnrgBcnqkLeU1jI8JsigwWYUd3FsQdDvvBTz6cISHKnDIwRsVz+Fkx7XVk7m4878sLkzz44EDG3G4MXd0RgCFV5xHkH3suzdgULWODrCpnXEqhqmgqoRHRktdXzPmOogO0Yc9z/4r3GtJq3pIquKEJUDwOiUO9uNjgPgDc+lOXG/VzRWtbZ4coVWQfj5gDL2MVsCNhSNEyLsgqZwOUyRqT5A/2EeSSjYGQZ1kVzNMepu8xyqpCx1W+RAPhUf3kiiATitYWebhkhFnien9iwztJFfOEKHobA5cMIqFSYAJS+cqou4J8PWZvJXefo7dvr24I79ssxWMnFF3t5H+0rIKxbB0gC7+Q2PNC6oU9h4r/Ml+t4gBcXH3I0CEGYaOS6zfIKmEnpO6OSzHcwdWenMWE68upTZcB8AqM3R1k5U1BQI5suipq271Pcp6tH9MUlCoPoMrwnVR5Tbhxsp9lStrw9FZ2FAqIiNCQzXYtl88bloe9edWL50+Ft2rvPjkAcMtgx87Lwru1Y+3thATH/h7msJfLu5vHVW7iPK5+bu6KIo/x+ydvo7ZlyCZCy97eMy5yIpOj/ET++wC559tTUt0+rme73QiR93PztMOUbyLarh0b5L0xPYLknm9/tZw8slJCERqQUoSOhCpDbqnyVgVM6xIWl1rwcC1R+Hsn/e3KzyIh334U60wuhs+jSidnkyoWRWWAXdrQ5xbR0rlbxqGo7OEHoz4jEPdE8yUolw6WV9YRiEsqQSkD3cFQyTmKCEnl6aDPsjWM7AmRXduB02OWT4hac/R7feQ/QSLm+x42HRTbCuWGc2uEN2K/H8DUzsWW0YjKB6/hnhHDUqscctf4/FmNjkfegkjsrE2/m80RzneBlW2FR6wxCEuAX0qE5FxK+DO58upAuUgOta/pnKhSe8hzIoimpx44WIWz7mpvarlMZc/yizTuWoxcheJvJOs0z8vK0Q58eOPH0cVHaDagmlHXe+VrKz3g8pIcxN5/F3sNYusmWrzgD7rpLW/t+W1yibC6j7fuxDlYyOQs35lzsA4z2eAaIJNT/DZZ2lrRc/0glrWfzdJ2s/jfqZmorI1P+F82q/jPytbJTdpMjni99uXKnpvU6lDSYPlXvjZSg7rgcAspUjG+Dm+1gS05MXcL+xYep0LPhgAcf5gRtI2072MP3sQzcE4jSbr4SBLHCSHX0liHxfF8WmKT0Z3gN568vPIIp4IFyJ7WP8b/2vjv8ezqOpqtXcfT4fBSvX250srl5ZKdJEjIe3DWI2aP0f+DsNPKySnGOTM5Bkpdp0Zuud6fLDkI4BuikjouNEKJjcrwYLzH7zX5Zd8tdk7dzeQ9PRNsm+zvyOJo2jDjuOrdnAXT8/TOO+wj/Kj2fX62/3UR71sPyVYlu/Q1HCVe01e+NqSXmCh45Wtr1MRcdESWf39LhLt+VyYr2j4+jjb6dZBvsKU0qRhXm2gINpYRUpNgfsFywjGu9iFxkoplB3bkwty1HFx4hOLdm+vte+JlnJShg41c3Z3JMZDgOCZrPkdayckjgNyuAXHun7i9Kx1yTmLFsO007FQMN7vYyTjHbDYUrZiVG2dfsP+vM7TpV44CaeRGvZrnF5BtgcLfyqU7Udo5Gk0qWgFvA5ozZ9p9poy7Q6NKe2nfOTtzF+v3MeqU3g3A+Zt1CFOrsFOKe1GiaBpW7qjDuCH/oQwNxM7O8DP8KDC91Dv61McOW4mJiLjqgFp96/D47D3OLD1Am+lictYrwBqFhRJNhJqgoIh4hZhkJ8xAnoR0l5xIiWviJUcRwRBdOXSfvguE69XlPTfht/JS10hv7U+g2vh6yU4ZIkUqplEGSJGKmtBALGxjYdG4C4BFhvx6WyPe3pMiFYOv3EUpEYShScSgsW1anaAudfW3qwMB7SN6TJuhoEkZ3bbPESbpRB0WB6+e3RaKuMHND7DoIvQuCuHR+JAn/rD8EeyLpSos7wa98kBxV/3tmniaC2u5bgYWcZCchmBbIea2KxtF+PG2o1CnAjSqotsXFxEcG7z94ZepcPaa/vY5Q6FFLfnzfSlCbug+N9SG1k9vC81KGS4PECo5DxFuwJPVMxDq79N9t1bCngbgZgOWdqCJu5nWgyqr9n2QgEVauWOs8gIS91thZ2V0mwtg4RoHg/+FUKsVIBnCrP4W8pxyoVQqWHamBwB9qiwzWqFs1bWfAdgy8ygf36Wc5ODpS4kcZN53H8XYZ59dtBqBr+Q9+FICMhbIQo1fBLk2p8qQBJ3D560fXq+Fd1jN9iUSzbbERvHWIkH4f8v3xdhnm10oyga/Sl1hzwBFx/4OwM1x42Mt45hFN2kQ5PXR1CaZBHF5KKZ2ZMguBjEPr+jqqTRa9efQYHnPw5SAOj+IeKfTO+/y2kN4GK2fkzxFGBKKZ9c8AHDLKVw6XLN+nbkU8zQSdfft9XsBuLl2d9S+kE+pN+zdykZFlRaif7J+8pF4y8/e1R6ARaOPEhFhQqWCJMb/fs3H+RvCq2396mekt9vGp4/6A6Qq1dORK3eaGMfWapiNk3da4+Rs2qiQhCJrUdHHvLn/mt72qv0EcX7935NJbVKSwspGsE7P7qW+1EKpCZHd5lYxdXb00GuBWI/9wbT2RMeq+mK94Brc8YKRV6HkXrG0OqlPJlZwgxUV4EpDsSwsG5NMTK5QKuHSBvG57yR4Jen1CKDRwJq9kKMxlGynIxPrVYSbW4Q3ojnIxM9x+FexHvYPbL0Ud9mE4lMo1N6jTybuqAv/NRdk4jd8gyy+EYoGkLtwepr3EtMC3cssMuoYlaUFw9YKX/h+pWaazLbERrFfugJwZebiGPvy9Rc5Au/P+zMpTUpSVO5RG4f0zgDsHrNa+vhexWcDMHZLl2StUKiI5q8fFqTvTZKtt7jPz5emvvts5ewc9Tn4Xew9kHrzRJbtfT/LpS0wJyJVym3TOhP88eslFAEsLMXzHRIkCMTGfSsBcHrLdbPZZErUbC2SOM3uv4cLB8Vk0MUjT81pUqLD+7kYZPu9E8+2ez7TzRwnZ0RvV9bV/pEbK3W55R5v22/okFSDX+YLYmnb/NPxkoQWKiXdRgm3lVFtN5vctqRErjxpeBvQjPwFhUdq3kx72L1dTKDcf9mILXsrm9O8REfRFuL3nJq/3byGmAh1uwtFjSsHY+YvT80IDU2ZRP+k9WI9uXvsZTQasQA4yUWXfxFUSphQUXxutwf2v9Htq5QOVkYjEBeUhWKxOZGmAKRzgdUTxeeKnSHcyKCvp6+g2o+QswmMWajbvmGaIBH/+g0ck/CexYdsaeGIVvhn+CbYkoj6qMER0P4oVNsFH7RBNmtrwLWWkN24gIdvSCAiUBChkVxIvrzC5/hGKMaC/jOEX/ubpz4c2WSc0t7fw0XygXLavCgpAbbphNdH4NuYM6R2WUS4Q4CHR1KalOTovWssAHcPXObhCePuNcCJTYKssHe2oVDFHCawLHFRf5zIEn3ys066bRaR1D7wSUwv1dSAEtNFvsyrv46ItYxbQRF2E/ThI2GByV8xN/CdN1cWrAPAJW/2aB6KcuGcqQXdxotp+r3L/gOgZgchyLNn4Wmz2WQqrJ1+inb5/4j6Xr9jMTNaY3q8uSdcLDLmN6GcZDKGOjw8Kj0JiLqq8XaR0OvRv3vNZVaSQKlU0HZodQDGd90eb/nOwwQR9d+hJ3h7Jf96XAYKhYKTl2qz8G9Rt3Vvf4EG1Y/j7CIXYp/ckL+6mBzxfKBjQiwsU3c2pu/7i7RIGycfxMpW3L/ICcLUjLu3Ys/pbkr4+EGuTrql9XiY/g8cvw5+8USzn9IOCQpkA1UcWSA2aUOie9RJHJtl8H0eaJobKmeGVRV1BOL8MlA0BROIhlCtNHT7XnzO3Sj2cuERMHWl8Eas0RueaauXrk3gwTZBJFZMxl2nrK5wVEsqjtgM/34hqRiuhoFnofx2uKNNm7ugkiASCycTL9XdF2HkGnNbYTqo1SKEWW4xt9XG4xuhGAe2PB0MwPSfduLrE3ers2ryCT68/AjALwtbm9q0RIVbcdGh87n/JMY+x4JC4MDvkVyuoJQEhUJBn70iJHb70GX4f4g/jCwiXM2fA7YDsOTyIFOal2jIX1cMRG5ui0my2GQVpGLwm5SlCGkMIkP3IwIDCQuI/T2uOlaIuBwb+UesZcyBD8+92Dl9HyPLjmdgvhFsqteD3Z2G8njXMQDs0qUlREsoWn+lHoq1OwqP8sjQSFsHEbPx7rmc4EByxtM776jnOok1U/XDAP83z8TSh2aG5wNRJ7l/l9HMliQ9Ptx5zIb6fQj6oHuO680bjlKVugmX6Gg1SJAvJ3feJzgw7hQG0b0Yb19LPe9+dLRql5U7z0SqlssXfMhgv50XzxMxWVwSo0YfMXl/bNFBve3uhXIA8Ol16gsHdkwr3KE8n3hFCbM8uOZpTpNMCguV8LK5evmjWa7/uaDG5YeweDd0nwnFeumTjbk6Qf0R8NtK2H0eumhFQNYOj/sao7REyKDvE918ozCxEiysBUWczXP9pMTYPmCnDcsdNkd/3+W7kOd7sSz+V2zL4AoHF4DHbhjbG+JJy5pskMUVjmn9IEZuhk3/yZ9Do4HJZ6D4cjiuJVUnlBZEYiX3xLM1MTB1C2w6Da++id6nSHwjFONAGicbRiwTITetc8+Otdyt8y9YP1OQNH8/GpMktiUmivfvBsCVaGrPkfiuryBZ7s2dm5QmJTnSuDnx/TQRz7Co4Zh4Z4tHNhIeIu1H1MTaLoW0TggxGoCgj/rKV9l79wfgxbIFSW5TUqDAEDE5cGzUvFjLWNoLYZv3t5KPp2aQXzAT68zk6PKTBH7SkaEZShbELr2YVsxavSzBPmLm38b56yQULVSxN2WpxfPj3iUR4ljnh6Ls+zASuzTiXVarNTi6imc3tfzW6PC8ryUUv8KQ5+enrwJQ4sdWUdsiQgWp5pA9CwAhH1NvHsVIDFjYAoA+NVfGWkaj0VDbdRoAVRp/R5VaqZeAdktnzbvA5jRpLt6JUvkPsOTP5NNuySBTAeF5fOeIfnRIlX7NADizeFdSm5QksLEX9Xep+kKo5NjWu+Y0x6SwtxcTINcum4fkd7KHJ2t0y82lsGoY/PI9lM0Xs/yDl7D2CPSP1h12iSMcNHrorYS24zd8AW5vFet/DsCO49BvuvBGbDlUdz9G94Cnu+C/1fCdpJBMckFmFziuJRVHb4GN540/dtk1KLIM1t8R3wcWFkRik2T6XyzuK9Zd5prVDJNBrVYQIbl8E2VJJbCyUFO9RUGyfecGwB+DYoYX+X0MYnBDkXtv2X8/YWltvOdAXEpwsUFWTTFf+vhDDOzSi98X8OYtrp+d39JBtKIh7w3PEr/+KK+wF5eiZWLgdTxqxZ/DxlK0Pt/VKEa+2kJYZWnzCbGWf//4NU9uiKme5v2rxFouOjJLKsLKKEKD8SqETab1AuDw1A1Uz6sLMbLRhj0HPIw9p4+/5H1zkVRfTYjisbE2pS0jvDPf33qE2kAurqdHznNkqJg0qDVzcNR2Y1VUI+HpF7fa9ueIT9na1sGGlmOa0OuvLsy+M4m596cw9/4Uqk0ZjI2rM6Af8qyyiZl8X1YF89hjOUk+3xB5bylZRWVjVEiLVs0FwPN777BRqanZUdzzO2dNk1vwpa9pM1d//psbdC7BAe9RDFnQBKVSQZ32QpjlxulnVG4qBqX3rryJcR6Za8QH2XosIW0cQJhWTCdLkWxRhKKTu3OMcp+rPhsDY9rE6JBROwZ5RWXvgNgFM0r2akWHw0sp2LYeZfp3AODWuj042ISRr0MzAB5tjT/sWVZ5WrbO8IrjN8SGx97GJ62q3FyIs3jc/YD3W3+DZWo6i9QW3xV3Z/y6ltz1lyOgFdnKSpUHpBRqAdSBcuRv2KNTce5fvq4c2/aLMO8xw25SMO0qwsPl3uk8dnLqBjld5LwhZeuAyD5u5mLiv31w6Eqc5WUVm0H++fb0lWvXXxlRvu1IERv78v5bQJ5QfBcSU4QnLsgoQgNSitAACqvY/1NHJ9FHuHpFn1D8XPU5PtiULCBnUywm2dtAlSIwqBVsHK1PNj5ZA/dXwNbf4de20Lg8XF5o+DwASjtYpBW2GNEq9nKRsMwm9ROwzCpXXuUmVz4hCHkmVz5CUkAlyAh9OaUSLoisPwyYCbu0gRulCsCF1cIbsWdziC21fUKUoU0J66Kx78vkAidGis+/bYUN2v/HKq/h8jseQOGlMFcbJt2pMNzsCT0NqGfHhTDJ+xYehyJ5bIiI5o1YWPtueLzT5SP9HLLK1ppA4xWeASK8TRelp9YkbEkp+HriZoyAi1UQaax0nbFQjQosYfOVLpRLM4u9K6/Svldh8hUXqrAajYZ6uQQJMWZxPbLmTQsY//DefZ9GmjjyCrSOIsCMwfVXxiVHSFskP1437/Homif2OcXA3PfWTe5PEcSabbbshITHHFjldJNXtHawNq3yaiYnuQ5m9AFj08ldmXH4Kp9ee/HfqkOU6xIzIcrKH4QXxIKzfYwekL/0tYmXPIoO70C5zp+Ht3GdS5eiIrzm8YkbbLsmpqlCXz3jzUQhzIJKhU+AlcFj0zsGG3wGYkNs54kNCSEUZWzK3OYHXm3awKUFGyirHZwD3Fq/l+t/bwOg0dKxOOfU5WrLlVbu+XZ3kBs8GUOul2knSOtQDRAOZ5+mR6PR4H1PpCgIV9pGibIYIj8yOQUSLHHfGuSTI6XS28s12JGwURl/nG+IChtV3O9P38m1+KnyE9ZPOMDkf3+IIllPrD5HjbpZ4jxWluAEcFXJ130yCNfEfc86dsvNjr8ucWbTJVp0yM/elVe5uPsm1Sqazkv1XUgaKULhpa8NOVwCjC4feY//2yMG18UrZmL3EjElXyC9YSJJFmc83KTe6/cBcsTxg7dyeUytVRFGEX5WFRrCvHXcWrcH24ZdoEBl4E/eP3rDm3gm0TI6BUqRirKkaw5X+XuTx1WunV5xqDXd6mymbcEFXPbrr7evQb7lADi52rD5XDsgCPfAa/DR+POHv7olZQ9A2HO5cFylI0SEGn+MVb6KqP3exlmmQgl46lGOnDn+w883nJy2Kzh8pgZFSzgbdY1n5CaNpfF9spvv5J5vY8i1QnWKcvvQDV7deQmZvwPgxPR1Ufvjar9kJ5BBvl2Xfb6NmXip36kEq0btYfO0owC8eylHNrtaBcXbRkSHShEhRSraKUOkSUVUhsvbpbEBgrh7y5cAVTrd9uCXKNPmNPr0IZf2YiGREzDiPSjkuqEAWFlBiYJiifcaH+EPrRNtNyMUgmUJkVDJ+dAIyTSVCfl/rCU93FSSpKhNSePKZUgL66ZAp1EwfxA0jEaYaeLxZ5B5jgA0kt1c2f818ETc+zNYwvH/QfU58Ps2iAiBFp9VrafeQL+zuu+1M8O0cmChgAgf+WdDlR7CJY6xzAQR3nLXsMwCmmjDpp9qw+LDsGgX9DGQj9Qqv9y9UNiBJtT4AyzcMqEJj1leIzlR9zXim4eiEVAqFWy81BWAjhXXROXpaV1iBQAV6uSgaeci5jIvUVB8QA8AniycD8CjebOjyMRsXbpTeMoMs9mW1Bh4UvzWkwt28/bBS719p5cIb5ACZbOSJU8STAWaAA6ZhN1hHzzx3rQ0ikx0qNGE7PO3mtM0kyJj02YAPNx5PGrbf7NXR5GJzTdO1yMTkwvUajUPzz1k/ZB1DC80jJ2Nu7KrSTe9MqG+iUO2pGTkLCg8Ky8ffUI910mc3fMAgPaDK5nTLJOhQHExMNu5/j5lqgnCtEINyZ67maHRaHh4+QXLf91J15zjaJ1RLDN7bgKgZO3vzGxh8oEiWiIwdVgYCqWSwjPmkrtv/ziOSj0oWVnUzeHhah7f1bk1dK+zmdfPBUF08tVPZrHN3LC1tcDzbUUGDhXvS+1Kxxj+v5SjcF/jJzFyPLbwAF6PX7G4Sl/u7hIqF98vSBk5qmURV5qO1IKrF95RKc96Htzxib9wCkVgNOLq81yN32B6VC4Bjzfrk4mpFe6OglQEGL8XNmqlDW56Q/EtOjKxqCv81wxmlhdkYkrCQJEemNl7zGuHKSAb7hy5pBR881A0ErkLutG+XynWz79Ms4JLad69GM8eCCp+3g4j/NyTOezdxeA0+PUrLnZoE7W96B8LsXZLmcRZQmFpY0XnNUNZ3WkGqzvOYODJGVjaWBEaEMy55QcAmLSjs5mtTDhqjuvFjh8n83pMr6htGUfPwypzDvMZlQRQKBRkr1GWZ8cu8GDncZ4dv8i7G4J0ar39D6zSyHs6JDYiwiK4d/IuF7dc4N6Je3GWzVa3KnnbpG5BDhn4vNMnVau3LMTwv75HEVvMSwpH9N+lUim5HdzPjNbEj7CQcK4evs/JTVe5fjRuN41Sdb6jfrcyFKlsvPfK14Bc3bvx5O8VvN6+hSyt22Gb6evKK7njRhe+L7qKFiXXcD1oICO67efyaZFb9GrAADNbZ36MHFeIlu2yUqXUEf5e8oS/lzzhydvGpHFI3ondMuQV+S7vn7zL/ZOTAMhesTD1p/ZJdfW3RqNh3eQj7PjzTNS2ln1K88tUM8gDmwB3rn2gX8cjPHlgHkXnpMYUrfDH3J7mteMbvg64O8KJQVBtNky9JpZIZLCFzbXBMQFep8kFFkpI7wjvfOGhJ+RNZsIxXwK1RoFCI9eeaSTLmxPfCEUJ/G9aDdbPv4znCz8WjRMiLKe8Uk8nNk2WjPi/FOGO9rnzUGDcpFTXmTMWGfJloerPjTm5YDdzqw5l6IU/WFB/NABNJnXBwiLlTkX6vXof9VmVzp1MYxfreb+kZlQY1o1nxy5wcZ4unKrdvkVYWJqvKrx/6h4rfvo71v1WtlaUaVmWMi3L4P5dRs4+lctxmNqhVmsY12kz5/fpSKqe42vS+pevYMo6mcPPO4C+xabHut9CpaRKmxJUbVOCPCWzYGuZghLGmAEZ69Tmyd8reLN9K1latzO3OUmOHHldsHewIsAvlKEd93Bwi3jnL/n2Q6n8OvsqnyNfAUc8/ZtRttBBnj8LJFeG3azbUoE6DZLvyOzJf/oTDG3X/oZL9uRrb0Lx7+wT/DPjeNT3Ck0Lcm7nHQJ85fJNJzc8vOPDwC5HuXNdX561Uq3MTP+rGpmypiGn1V9mss602KDN3de4jGmvExAG2zygYyx5877h60EGBx2pGIkDDQWhmBqw9heoOxk6zIcLk8xtzTcYi2+EoiR2PehFk+9Ew7j0UDtsbJP3zK8x0Gg0nB46KYpMtHRNS8Hxk81slflRrksdrm89y6c33mzoPY/wEJFnKH+dkoBc7qTkAI1Gw/aeE/F+/CpqW7ofh381ZCKA8jMiuP2hv8xOmp9aeTLqc5q0aSjTsiylW5Qhbda0ZrQqZeDQxhvM7KtTAZ20uR2jWm9k1aQTXwWhWK1BDk7s8+DFk09kzSWX2ywp4P9RlxzHNaMjVduWoEqr4qTPHltu32+EYlzQC3sOD0ep+vq6cHvudKN61iVRZOK5Dz9jaSknnJPaoVQquHS3HuntRDqPDi3PUbVmOv7dXdnMlukjPCycuY2m8snzY9S25ouHpjoycdfic6wedzDqe53OpfhxaiMUCgWtd45j/7qb/LowZUUbPHvsy+Dux7h8Tj/HZ6kKGZj1dw2y59bP5evgaImfr2nzpyc1PmidMO1Nq88GwNanMOsmvAqAX4ub/nrfkLyRwUGENfuFgVsSPH9JiZxanwmfAKHYrUolzbtarUAhGcKsSUEhz18Pk5AAWCn0E/VrNJooMhHgxzob9fa72sjNMhZIJ5/3LK2kcm6xzHFnSA364M2uJt3wufcoaluYt1ccR+jj6Qc5FVxIvirPhvDj9t8AeHlVJKv4+YCYLjntIRcGnkVSHdVV8j7HlzT84zNP/q7RJ4pM/H6pkAx7v3Sq0dd4J6lq6yIp1iEjWhMJGZvUoaGsr9tbb1t8ZKKpVZ4drMPoubwXU29PZ+rt6Yw++Rv1BtSPk0ysmFNOek32fdh3P6NU+XeS4jsJweeiKa8ee1PPdVIUmdi6fwUOeI+idC2hDBoWIid2lRClau9w+bpPBipF/L/h+05C9XLnurjD4xML6a3l2qwyxdOw5sU41rwYxx8XBtNycM04yEQIDtfvkkTmK85WIPG8civlkJsMSmcvV3d/l0Eu1E9G6AogV7euALzZbny+2/hEWz7HfUnhDWNFwaLjkbek0m6QEHw4e0gnMTpsZjXs7A33JzztikudX5W5sFR5AMtscv0AtZzuBqH3z8ZfKPr5owm4vH4pyHyVSrRxJ4++J73dNjxf6wuHZeex1DWKSAr2xKbyfH3PFcaVGh5FJvZY0ReAm6t3SJ1fVoQP5Nt12ef7lbZfcmDVRVpn/H975x0eRfX94XfTQxISQktCIAkdqRK6KEWkKF2lWJCfWBBQLKBYEGyICogoTUQQQUEB+SIgHULvXTqEXkJJIIXUnd8fk2yySTa7N6ZtOO/zzJPszJ27d3fPzNz7ueee84lJTGz1dH0WXP6YV77q/J8nMm8nqvU1VBK4gOWs0F9/uIsQlx9pXWu+SUx8oH5pVh94mvDEV1gY1i2LmAhQr5F+D78Tmd63jXPLOVlaZlwbPa5U3rGs9TL/hRHT9b/TBtl+jqXMvBbLp0b9eDb1vN/PwO0cHkmOivOKqslGQD3Ls2r23/icE7tnwUExdxDoSUpUUE2yovq9lmilVh7Au76amKhqG8mKWZ6TcpEgOelS9vvf66r/HbfMfH+iYldXU3w8pNzMvyzPKZohV5u9cP9Nb+eAl+M9vBzTB3GJmhNuGbI2D376HwCatArgzu0EThy+xZevLePLH9sCcDelhJKoeDjCWzm7aESsKx4utp9jaXlkcnwCZ5eu5vicRQD4twil8Qevs3boGOLOnOTuuYu4V7Seykt18AT5n+XZkrhmTDFy++ItygSb9zLu5pD90mAw8NqKz5j6+MjUOnT7eLzGNaU2hUeWwN1KltqM2JIZMSO7L1ge2Bz4fhYXVukpxCq1f4QGb7xo8gNKvnGNhGwyA2dH1fJqo6GYBGc83Wy3VdWs0AAVfbPPIJsUHY2zV/qgISkmht0DXgagQrN6XN5xCIC7l65TMrC8xfprKg6eVIXg3IjrYacte2/ci03Cyc18IBDgHaeUQbtXPbXen5+77Vl8c0ui5oSvWwpJiSm88PBcTh3Wl+2XD/Rizpbn8C3nAejf/QOhfhzde42YqzcJCPaxqX4/Z/Wg8SWiT6qd4KwmoBicsh/QJSUZiY1JxqeUC093cuZt4O9fjzDqvfyPdetQohTlnGxP4xeR7Es5hYmzEg7m18+Z41EAhDb0prIWjm+m3rMtomtm9kUG0KaK7T3lPZdL4eVm+zNr5VG1QXJO972UmLs4epoPzg1Nu8Ks2Vz5ayElOj1n03tU8o0lRiHLc2glNdG1nn+UUnmAmhYy7V48E0mFEJ8sS5j9nCPZsOoSH7y4yrTv62FhvD60arb1OJz6B5XeVco19YGEasZWpwrZi4rRceDsCJlu3bhUD8Z4x/Z2OZYORrun38vefFVPyrJkWQMaN/bm2T6HWLvmNvWqruTrcdV44f/0JDfXSjTAReGb2ntdzXM+c18mPvoeXzw00vS60/CutHj+EdPr09tO0k6hftWs6qD3W3PKHJ2ZJhVtn2QHOPHPDt58LT2rwMNdajBqdncMDgaio+7g7Zv+LHisTx3WzD/C0W3naPhIJZvfI/O90hZUREU3h0QStaxDxKnfHAAgpLoP385tT636+nMn3ujCXQu349s34qj+oD9b119mx+67NH9UH1v4OkWT6G77BKbh4AIcStou7iZfi8GgIDZpil2ZdXv1v81rZD129hoEldNjwmUk8Zjae8Rn6GZMaQyDdkPb5bDPgrZqVPwMBmd18cvNgih66DpULw1umcwmv7I8p6H6mSEXYnNy9qLilQhwdoKyludJbSJmhfo58UfVyicpCoTO5fQs5pmJTYbbCVAx07XlGqR+DTlVBGM2ot//NYWvlsLMDfBuhvCyrvVAU3iwG5zUREWnSuZxqTVNI+KmkQOHc6G832eIh2IGEq14tVSvU5rgaj78uro7/9utJy5Z/MtxDu9VvEqLACueetUkJjb/fDiNP9AD+ld6ZTAAF6Z/X2htyy9WfLWE77p+xbIxapmMPcuUpPs3esTlqY9/jKbZz7K8pZ37m8TERyaOpsEbL5qOudbTl4QmnDhQGE3LV3a+9AqHRo0GQDMa2ZkqJtbs2Y7Wn79O55mfALDilU8Kq4n5wrrnFKbK7Yzrl6Jp4fOtSUz8becLuLo70SF4qlm5t79uA8DUUWEF3saC4L2hB6heYTmapuHqqg8QL15Q99KxB44e1IWti+F3CQ2YQ3KyuhezvWJMiCf87X5EzJtmtj/jsmctuXgtIQToWXcmTT3HZ3usX2ddTFx7oCc9+ureyGM/2lNgbcsv+o2Emk/CXxvyrs6NG3RhsXFjXXCbN78e8/+sB8C7w06RmFjw19KJTUfNxETATEwsDoT9voevUsXExo+GsPrGu3w6tyeOTg4smbGX7iHfcft6+iTLix/qn3/yyI2F0VxlTiQM4kTCIFYefsYkJubEycM3aFPpR4wper/5373XrZxhH4TrEaKonM189JXb0H4UTFBztrVKs7LgkypqLbyQt3Xnhgt3YNgaqD1V3/ouhmfUhld2y8rNUKktNOsDofafl9Vmpp+Ch1dDt3zuXhsMUD312jqk6OFqjVtRsP0g/LIUPvwBeg2HBr0gqCNUeOCK2RZY+yoNW13nxSH/PVO90Zi7zV4QQTEDjSr8muPxoaOasOrIM4DuubbiYF8Anmqx0K4GOhkFsbqD+1G2QW3Tazd/fdb63oVzBd2sfKf9m08AsHP+NpZ9+ZfSudVa1aVme33a7Mdu9iFCJUabewb5VA02e+3dWxeRo376vKCaVKDcPX6C5Hv3SLmnL7kK6fc8oYN6A+AdpM9CpSQmkRhTfMQYY1LxExjSSEzQpyWHj2/L7rhhVKtb1hRy78aVdFuv31y/h61dWDDLgAua5GT9Q+/f8987OEWdY4d0b8g92/RBqJPT/dNlcXDVvTHvhq3McqxMH32C6/aKhQXapoLA0VH3TNy7KeuIeervbQn79ylq1C7FxNn6GrHJXx00LY23V0b8n/73rfEw+Kv/Xt+5c/ozr0oVc+/ANm19OXvhYVavC8XFpeCvpaPrjgDQe9zzVHtId+uKOJO+2uPBbo0AuLJf0fu7CNHo8dr0fbMZq64P5+vFfXB2SfcKDKxSCoCfP0+Pm+xXSRd8j+65WrANLSD8KuorRTYs08MqHdlTPATFoZP0v9+/mvXYvFSxpUFI3r/vP/p8KWOOQLy6g/5/IjYZfjybLiB2+g3+SY+WxZO1YF6Pgm1TQWI0whfTdCHxlVH6PlcX2JSzdFAsuBQHDVfogiLAeEUv0tzwU3/9b69pORYjKhp2HYG5K2DUNHjmA2j0HAR31kXCzFvDPtDnPfh4CsxdBjsPQ6SFBXghQY50fNSNV/vnYl19JjSjAaPiJjEU7ZivP9xlc9kqNUvx0jsPAtC6ypz8alKeYzAYeGKxHgvy8OSs7XYP0Wf+4y/n8bRAIeNSwpWRO/QYiDt/38rysUuUzu/y+QsA3L0WydxxarGNCgMXL0+6Lptteh0fab5818FL78hqCdnHOLJnar7zNgBHPv0MJw8PWi74nQpPmK8Raf3FGwCsHzGxoJsn5IKKVUqxO24YvV5L78m8++2jAEwetSnbc+zJm9hW+r+sj1JmzwgHoOYD+oAtNkYtfIY9cOyw2lLD4oZXs9YA3AlbZbbfu7V+L4tctqCgm5TvrDgzEICBHf/IcqzzUyFUrq4/txwcDLwzWr8XDHomD137CoGmdWDfPP3/5Zv1gVDSf7ichw7RJ1OmzXggyzEPD0fqN8jf+K+W6PFJLz47NI467evTeqC+ji1sxjrT8dav6vv2zFqe7fn2gIe3O6980gaXzOs+gSbt9L718jkHsz03OamAFaICoKSPPjFy4bTe/ywuHoqHz+p/a1TIeuyXVJNuWy/v39fVET5I9QF5PJ9ve0YNVl+DJ7ZA6Fp4ZCNMP5t+vKEfzO0B/76mb5+2hrzOU3qqCHhiRkVD9yEQ3A6mpz6WWobC0WVwaiUEZ2MDxQVNg3f3QdeN+usaJWFXR2hTAHmzynunt+HhsVDjA/3ZmHlr0Bd6jYCPpsAvy2DbIbgZlX2dFf3g0abwWi/4dhgs+x6OL4HzK/Xt8tEAs23LP+WZ+b0vbw0qnGemPSGCYiamfnOA44dtjxE1fIy+bPTGtTiWzDqUX83Kcxxd0oNBpGTyagp6RfdcO//jDwXapoLApYQrH6WKijt+28KKr9TWJLy1eRwAMz8L4+QBtTiKhUWLL0cAsGfs5CzH3B/qBMC9vcVreWiZJo0BiDkbTkpC9rGGKjStC8Ct4+Gm2Jj2TNpSyHs37h8RpumjwQAsn2ceTOaZoU0AWLeo+HkpPthI93KZP1fvafd+To9H9ff/7ON+pMLRg+m23GdAzUJsSeFQrp8eguTGPPNl/cV52bNvOQ/qNtHjqi2acSDHsm9+qE/orlh8jntx9i2o+3pD+N9QOnUQVa07XLqcu8+0Y7su3tSrX3QHQZXqBwNwaMV+0z7fQD0+45X9isEp7ZCMk10DR+vLnv+ec7iwmlNgRFyxPaZuUSXNPJvXzv54fOotOXP8xLziqdTw9lGJsP1G3tZ9MhqG7NcFxMbr4P0jcC01CYyPM4x6AA69qguIv/aAB/NRWLp0Hdq9Ao365t975MS/p6DSI1DvCdiX2sV8uz+cXwe/fQOeamGx7Y6DkRD6D6xN7Vr+2gJ+bwkFuVBknB5djggLHoQBZaFVKLzcA74eCkvGw5E/4NwyfUsTCtO2LbPh509gxIvQsx3UrQbuBZUlWzPkbrMTRFDMwJ8b9LRCnULVljDvvakvP/pi8GpuR+R/goK8ot5g3eMuLZZiGm4V9KDy98LVsv/ZC64ZRMXt8zaz/lvblz87uTrzwtx3AXi11Szi44r+YK5MXX0gfvvfrMuIvLrrtnvnl68LtE0FQY03dGH83y++tFim4cCnAdg1cW6BtCk/cfbSg5Vf3bKzkFtSOBiN6QO0/u/qEz0T311nqbjdkjk76FO99YjnC+ZZSJdnx0RcTQ9H8MaHBbDGpohhcHLGyVePHh9/7rTZsTK99Xt35D+Lspxn70xf3QeAsUPXWvUy/v7X1gB0bpHHAcsKAYMB9s6DAd30103aXOKf1ep9yvVhjdi0tXEet65gKY7e5QDdXtLvY9syrBXtPVhf6j35I/v2tLVEmy5VCrsJecrA1BCv4wdnPVZQZrtGX5zB4N3/7T0jE2H8CV1ADF0LfXfC9gxz0i8EwfpWsLcdrGsFXQPyTyjNTFq+xBuRMOiLgnlPgD//0YXETgPS9/36FVxYD2/20+/TxZlkI/Q+Av+3XX/9RAU9CVBtn4JvS5cG8O9ncGKMvqUJhWnbtlnwyyfw4QDo9Rg0qFGEhV4NMCpudvQYFEExAzXq+vLa8AYANPT7BReDbbPDnl4uTP5T9/TKnCAgJ+oqZpAFKOehltmtRYjlhDFBHVsDcOav9BhNlVIzJLtXCgYg/urlHOvPTYa93GS2VeHcbetZ4FxLuPLRdj124N7fN7Jhou2iYrnqFWj1eqr47D/OpnNCSqnF6atQUm0ZcmMrWTkDHtY9tq5sSV/S36TyDVOcLtCTl+TE6eslczyeGU/FbN6lPNSzaF28bTmuRdmHWgBw98QJjIl63edvmdtGrafaA3Dmny3Z1nE8Qs2+b8dln5nXErnJeN6qqrknmjFZv0+5++nCw9XNO8yOX7mj9nT945BaSr5r9/57bBFr5HQv7j+sKQArfvvXtK9UKf0ec+u6bYPxa0mllNsU51Vd7YQktXuAlmz5Xu/kpPdoNU2jvL9+DW/bYrtnfW4xxqnFbVTJCA0QZ7R8/fgHZr2vq2QtTaNhKbVsvo0qqH3mjg+oCbvW7nuB7+kTIpfGDDPb791GX/Z8++/5Vt/jQg73yezYe0EtY/ihqz5K5QGO37LsPefs4kjvQbrw8sXg1YDla7R7H12sOPlvFBHX0q8xY7VOSu1x9AuwXigTLhaynVoiOefulImRL8Ps1FDNA4bc4N2RtmXdTrl1DoDadTypUdO239wv7oBtjUoltLyaB3xOfZmQxvpvd/tSep2NnmoGwOW9J2yqv3p59X60ar9110W1zNbhkZafuf3ffxiAySPWpu900e97sXdt7wPldK/MC+KNlrPPZ4ebg+W293sj+8mg28lqHrRa/d5K5Z38bM8IDdicEToi9ZHgXxocfcyP7Ug122dbZX+uSy2lJuFmoZtR2hX6Buv/D8oQqcvBymdINsKiK9BqCzQKg3ab4LcM0a0eLgMLmukC4t528EY18M40ZItXdCBOVoyeFb8v/f+zqdEPlm+GKRYifFj7zNmRksmzMzkZ3v1aFxLfSfVBKOsLWxfAhU3Qqrn6e6jgaSFrd064ZY1okSPO5ayXWXMbHtoH51K9Upe3gc/q21Z/wnm19oBttuGUoZuXoLgQVCUjNEDyBbX+oZCOQSuu04AK3L17F29vb87e7oVXSWfKOunBbEaNfZAhw2y/Yts0Xc2RvTfo+kx1vpnVzmr543fUOimQc0clO9af8s/x+PInXyElIZH2v36HWylvLqSKcfcuXeDEB29Tokp1qo8aY/H83HTmfEuoiaJJKWq6d7WyFnyjsyEhNp5RTT4GoPFzbWn9RjebzutV5yI96/7ExTNRtO1eja9+y/m8nAZP2XHyplr5rWeySTWXgeR78Wx6Xp9ua7tQt+/r0XrA9oi/5nNj6R/49X2R0u07W6yjisL3mhuuKgpfAGU843M8fmn9Zg5/N4PS9R6gyWcjCPDOKups+nI2p1btoOngp6nz9KNmx+r6q4kJzo5qyQFUBUiADSfNr+mE25FsfWUIZZs25sbO3UD6bwxQxivn7ygzAxqftV4oA8Ee6slBbJ2ssYXYmCTq+M6ihIcT/0bqWczjjK40LjONuJgkNoa/SFn/nHucZRLVvbGTTmYft9ESBhfFdRVOlgd0I7+4w8/zYpk/szQPN3elwgN6J+jSHrUBlDFObfmZwUVtkOlUQa3Ha4w0F+Mq1EsXUi4fyipyGePU70mu9Z5QKr8/Xu0zzNxdWan8uqPWhaxbb+niWKnP/8DBwwtnRyNachLX3+4OQPkJSzA4WZ6oeyAgSqlND1VRi3PWMkg9zEJ1z5zX6mmaRmXXGQAcv/sipZIs35d2bI+iW+cDODkZuHxdH8nH796o1J7MA0xbSFIcKDvl3B3LQqRfCRp10p9ZLs5waouHKWlNdjiWVpsMArjtb72vmpGd12wYlWYgPNLyvTd81ynmvjqVB3s0pfPHulh08mQ8C3p/QLk6lenyw7tW61cVvwGa5TDRnh2daqglTAn2is7xeH33iQAcvPcmAE6GFDrVnsOFM3fYcuklSpVxt3xyAeFkUAsDczfFcv9N0zSaeKRnbt8dp0+OlHRUm2TzOr9CqXzS2XNK5Y02zD+u3Q0vj4Vuj8DEoZCSSet/dQqsOwirPoEq2SwHTjig1CTuHc35eKPUaEV/NILKHmDMZni17y58fx7+zebzVXSHNypD69K2e965qwpZislp3BqZv46JgwdShyYzP4fHWpgfT8lFfjqnCnpf5sYtjV6DkjidQQx7oq2BiaOccHNN/0K0RHWHBxWif1c/J2a3WvnkHB7TMUbokOE7eLUUDKihVr9LLmJJuijahrui472tkwRpOFfK/nkSHWOkZovb3Llzh5Il1Zxr0jQm3lsGrooNSoiFrzrn6n0LGvFQzIaLMfpym09G7Ofs6Zw7BhlZuFXPHb/0t5McspNMZk1H68kr9n87w2y/e2AlAOLO2G+2PVtw9XDjjfV6WsXdc9ezcZLty6b+PKCLF+uXFP14P04ZgkQkx5l34sp20e322u8/F2ibCoLAtro3wK1DRzFaiHLfcvjzAOyc/GeBtSsvSYzSRX0XH3Vv4eKAh6cupMTF6r+vpmkMeWoZcTG69+eYd9SEP3vg+d764G3O/Fh27EkfQWRc9m2vaJrG7gNJDHo3XSx869XCH2AXJl4D9Um9uz9+BEDi2aMmMREgdo193rtywmAw8M1PujjY8+Gcn8vNmvsAegb0E8ftJ+yMNfzKOnB+pweOjpCYBEFNY7l+074zWmckuHFVAPb/lR6mw7O8LwARR9QmtuwJv0B9wvjO7fTJvnfGPATA9K/2FEqb8pPMYTrs2Y/l5bH6309fyv74utR8O9mJifnBglTxrVcGs7maAKNPQ5Md+jbwqLmYOKgibGoMu5rBX02gTZmivYzXswRsSZ0jH/ARnAj/73XuPmikYrNEGj6RLiaOfsuRiztcmDbG2UxMLO7MjjQXE1cHQT+fQmtO8cVoyN1mJ4igmA1ubo6s2KwvhWxac6nNgzSDwUDdRvrs7fIFp62ULhqkxde7se9IlmNuqaJiwjW12Vl7w9Uzd6Ji38azAXjm9dD8alqeUvfdtwA4NvlHs/0Gp/RshMZiFuAfoPag/wNg39jvsj3u4ORI6eq6rV/a+W+2ZYoyiXdSBUXvkjg46+KaPXfYc0ODJvp9d8Wis1R2ncGGZek9ztWL7eNerEL1qvrvvGJNPE/2S5923nXA/sSGm7eSGfv1Vao/cIgK9W4SWP8W3fvd4X8r0z0CXul3fwuKLjX05CMpF04SPWcstycOB8Cz07MAxPwzz+K59sxT/XQXiaMHb3Htas4rG7bt1MN6PPKQottGEcfR0cD5nZ707qo/p0M7xhG2w74T0KSRWWjKTHF9jg3/RhfKp32RHp7k0a66Z/Ov3x8ojCblO77l0j0Yr5xXX9lUFMhojiXzP9KLTVTxgNDUueRGYbqA2G0/rMjgOfl4GVjSQBcQdzWD/hXATT1aSKFSyR/+/Fb//7EBcDuXJjRrGYQ8CT1fTb+HLp7uxMUdLgzoXXS+lHsFMBS7lgQPhcOMKP31Z+Vgawh4iDIk5AIxGws0bl6W51/SZ0+b1lxq0zlr/neWw3v0pRQjvm5hpXTRwae63pGJOn3ObH/QwDcAuPBT1uzAxY3MomLYDzn/5mHLThN+XI8P9tZXbfK9fXlB2Sb6VGbastiM+D33sn7sf38UaJsKgkod9N/nxp6DGJOzX8bTafxQAFa9932BtSuvSIyKAsDF25tyLfVAL9GKS33snY8n6J97cF89LlXXZ2vyb/zrhdmkfOPq9RTTEmcAd3cDv0zVvXr+/Nv+JgTqNjjCd99fJzo6XQzt3d2V//2a7nFb0ku6Km5t9QRSifv1NW5lRv6EZ6dnTMe1lOIhMmVmYZger7h+ne05lqtStQSenvqAMGxj/scTLWjGf+zG9K/0lQbPDonns+/UQscUVQLq6JN5d66lr1t8oEdrAC7uyDrRXRx4tJseO/K3KQdM+6yJq/ZOxon3o3uv5VCy6PL7Gv3vKxYiHMWkOpwGq0UF+M9MzRTjrpYHTK6VLiCOrgoBBZXJNh9pWh/G6ovqaNBD99q2hYREGDROFxI/naXvqxoEe5c7c3GHC43rF63+RVIKNPoJak+F+Hx4rGsajI6AJ1MjzFR2hrBgaFtERPJii2pClrTNTihaV1ERY8I0Pdj/ubMx/PJjzstab96IZ0gvPbnJtov97apz0Oi91wDY9elEs/1piVliTx4v4BYVDrqoqK9n2DVnHZsm/51tuaT4RIb1WgLAmguDCqp5eYJPHT34ye3D5p54vm07AnBzWfHLGApQ6+XnANjw6U/ZHnf18sCQmrou6rx9eeQmRulLQ11K+eDXUp/IuL5la2E2qUBJiE+mZ8t0r+JNJ/rw5czHAHiyv27vW9bkIlp0EeS90VE0amMeTuP4Tj8efUSPxfnHMvsTlf5eUo0Z04O5GF6fy4fKcPlQGSZ86oUxVft3yd8cXnaBMS6a+PXpy5rLf7cMp7J6QD6vHvrau+K47BkgtHn62sH9+3KOmfnZGH0S+Nk+h/O1TYXFE486sX2p7uk1/dckHuwQa/defI+8oq8G2v5Leobjes/q/ZH9s7Lvg9k7lsYHrR4PBuDYwVwE9Czi9HgxXfWyV0Hxw+n637f7Zn98ceqcxwttC6Y9aTgYYPcjsPMRXUD8pS40LqYRcJ7pDM/rc0xU7ZBzhutLEdBkANTsC/+k/ja928GpP2DDAhfKlS6a43RnR3gw9bEXOgMu52H4+qMJ0PIcrEldAv+jP/waCE5F86soXmiG3G12ggiKVgiP6gXAsEG7uHLJcgDhWv66EPPd7x0oXc625BI1vdUDmatmC25bzbo4UqK8nh02/naUKctzGq4BgQAkRGQfEzI3WZ5VE1GoJro4dUMtcGnpDJmzXT3dTaLizl/WsnnKsizlJz6iLzcbPuFRfMrY+FuXtj0WJ0D1MmrlbQ2iX+ct3WvrwCdjKO+Vnn0xYwc35V72WRnPKH6vqvhnkzDFGjdjbJt2De6sD1rObdqPMSV7ewpsXBuA7ZPSU8kdvqqW/Vc1gZBqgiKANtXNr+n0Jc/eJsH4+pZ0b56b0WpT06pJJc7FqmdITtScrBeykei75tPUfoGelHDQv9fXR+kZQ78avjnHOm66VFF+X+fqjyiV1xLVkuOQnDUI+L/H9c/69+9leP0VPQHLmo3xputXVVtwKKGWxEU1MHnyZSsR5YFGoR50ftwHJycDDqUCTft/mqffhx5/zHIiGIcS6vekhEPLlco/6Gb9M2RENanRoxm8TS2S+rs6+usRzGMPpC+VLNFKH13FrJhr8fSjV3yU2mQtyVdmtpxXTzB3MqaszWW3ntE9MTs+ts9imXVrb/HWG3qK1fVhjXBr3FqpPY62N8eEs2IOlGTFuaqEw1mTJlUMcCB8h+5KcuOWRsXGsURG6QaScksxSwzge3Wt9UIZaOqnltAkpFTOMS2rttTT3u6evwWAAO84PMr4AHDz5AWr9YdWsi0DdkZ2hKu5kP1zQi2bzrlo60n1uj6vP6u3rztvylb/1mf6hODEkduU3i8/SGuTrVhLsFKyVHo/JE1QzCmRS3ZEB6mlwnWuHJxl3+4jUPdJaPoctB8IvYbDy5/AsPHwxTz4YSH8uhKWboaw/XDwNJy7CjczLLF1zTDJ5Zghh8Mv6/W/PXLICOzaQOkj2JwAxWAARwM4KOb5yy6JizWsJYrJTJJizMN4K2FEv3gT6uhzRzTvC46ZuqBh+3VvxIdfgxtR+r5xQyB8EYx9Tc8anHxZrS+jmpBOFa9MIvXcHjAw1am3/TzYms2t3VMhQUmyBv2uwcup3Y3HPGBLMNTOYXiQpJgKIvGyWnmAREXbuKcY0URTDKmcdEH9eSLo5N2orhiQcvscKUnpX4nByYUSwB8L69HrqUPUD/6LazdbZZld7NF1PwAPP+pP715+gG0WHB7vRzkPtZvasRuelHS13Qtl5YkA3JytZ2sL6dCS8FVbOLJyP6WbP2TaX/7Rdlz4dTZX5syg+nsfZDkvN1mey3qoDazjkx2VREXVzLzXot3NviO3Ui4M3/QF3zzyITtmr8HJSaPNYL0js3t+ujDx3Gt1Adt+i3PRXkq/25ZzapkLbc106OKdPgB3d4yjStl0MeZCUCDR5y+RsuF3qr/wVJZz61dQW0YWn6TWIT0f6UmIopCqIsg1G9SDHVP+Ysc3M+n8aT+zY7+9PJHLB/UnW8+x/XBPrbdWufzNbH35rnpsuFXHzFOpxUfq16DBy4dk9J5uYmQUianippdbEtHxtrt5vfnwCaX21Pe+ZL1QJhy1vPOk8/SDG8nPMnn8UUa/t58F0/bz8pt1cHdMoLS+mo6zxyMp7Wz5t0w5scbGKzmdhL02CEEZMLgAKGRVzubpvHhU2n838XkQvgdmz4zk0Qrp97z4vba/R4r6nBZg+zPLuSIknTpgc/mMgsvy1OVlT1dKJHZl9p08W7JyZsa1HiRf/svm8h6deiiJitNPP6T0DJq8sZb151tJD/wmLccYH0fEu08TM+tz/JovMR1O6/d7umW/BqxaebX7WAvFLLhdq6nfA/ySToKNXYGqZaFqZSdOn03mj58O0LOLuRCxeXsCzwzQjXnNX2Wp7HOZ6IVq16cxFzG5VAfKziFq2aTdGoHxbtbr2RG4sB5eHQ3/bIK67WJZ+B00b1MGY7Sad1tMjV44YXtG361X1cS1nLI8Q1ZvvbO3zMW4e0kOOa742XlWXQluVf2a0uTfS43VfuhAF+uD0pGf12Ppr0eZ8O4GNh3W19CWbqA/p7esvpDj8wogyZi/wzdnB7Un4q2kkqaJPGsc23vNVFZFuCwTexhKB9tcPuHfjRgyaZZ/bYK7sfp2LRfawUf9zV+nZHhmnU+9bXo6AhaW48btUns/VfFOUxQIHSxkhs6JEnVBpQvnUk2t/sxZnrNjxY9QqS1ciYDBH8F3b8CkhTBxoXm55V/BA8GpLzK02aWW2hjLGHc3X0XFyClZ+1WDakMdbxiyHl5ZBkMawCv10o9H5zxPbmJDLHyU4ZE+vyT4O0KKlWeec3lIjrLtPQBcA63XmRm3amqin3sL0BRkE4OLWv3OVTyznfzXEvNgJUBukqxIUpbiRas2vjzRWb/5dGpvPkO+5K8Itm3Vr6A/V7cv8LblFQ8O0j0Azv6Qnrji1ISvufDrbADKtH20MJpVaLh5uTN80xcAbPlpLRsm/0NcZAwrv9IHojtvDynM5v0nag7Ul8gdma4H8k+Ou8fSzv2JPq8PCit3s187zokGffVlsMdW7kUz6gN4TdOY0PIdk5j49tbxuHvbVyCRNA9FZ+9iusbFRl5+XU/gMPKdvWb7e/WrgotL8XvUBaY62WxJzSrZqo7+96rafEqRp1ZAYbeg6ODgVgIcdSEhMSJ9JBv89c+U6188Y4amsfJPvQ/2+ntRZvt37kmgT6qY+M+fZXigxv2zRn76aJgwQv//qaHw7TR1L/+iQLlqukgZe1ufULx5PF3AizqrLlbbA34Bej/j5NEoQO+LvPjkhhzOsH/adNY9rO/FFV5oji+HwYVN6dvJNbB7MaydA39+ATNG6N5sI/8P3nga+nWCbo9Am4bwZGt4sXOhNV3IRHjqpOPf26Byn3Qx8cFqcGAmhC/IICbaKY8EwrLu+v8/HIABq2w/N9aoJ11JExMHuEFYKV1MFAoBLZebnVD8Rln5xM+/6KO1/fuiWfKXfnVGXE/g1Zf06aNjpx6yeK494OSW7iefcPMGu5/tRdRe3e+83ndT8G3ctLCaVmiYi4prGN/2YwB6ffsibu7269wb0E5PUnJ+5UYi9h5mRS89hqZnoB9d/p6Fq0/+Lm0uTFq+qnuarhqzgJSkZMY1fZOUxGQcnR0ZtnMijs5F/3fVNI1bu3ez96132NK7L3eO6PEwHd30tQuuZfWBtzHZ/uLp/RdcXLLvJU2a1ZLzcc8VcGsKnjHPw1MPQdlicPneyuCU5VkMgsnnJaXfnQTApTHDTPucfHwp2aJ4T/q5uzvwZFfdo/uzb/RJlH0HE+mZmuV86e9lqFc7f5elFUWeag8bZuv/j5sSR+vukXYXVzEtjuLWWev465n3WDVkDAAVmtenVBXFdeV2RKnSer97w6rL+DvNYcUSfYn3ql3FS7UyGjXGfbCVDcsUXXoLADdXKF8GqgdDo5rQrjE82UYXDt/qA5+8BBOHws8fwrjX9aXF2XE6NSzko3ULrOn3PY6O8G+GMKsvd4Ezv8Piz8FbLZpLkaZSSdiRuiR693WoNweSrSxqmBsF7TOEDl8VBP3UF0QJgs2IoKjA8dO6aPjqS0e5cSOBug/occpm/1oHX1/7nxWv/2pvAA4NHQxAyTr1aDR3Aa5l1FzDixNuXu4MC/vc9LqEjwc1WtcpxBblDR6V9E76jlHjAaj/+v/RdtpYu0omlBuaD+gAwOGlO5jw0DsA+NcJ5u2tE4r0Z790+AKzXp7OyHrD2NrnGY6Nm8C9K/qSPoOjI9WHpCcHKttCj8MUdehQobS1MHm0o+7Odni/+Vreovzb/hcqpK72i0+A8j4wtp8eH8jemZYai2ris4XbjqKIs38QAMa4WIwJxSPTr61896UPANNmxbL/UCJd+uprFhfNKU1o/ftPTEyjSiU4qecE5NTZFALr3yI6xn7SQ9Zsq6swO+duIi5CD63Sbe6XtP7MfleC2MLIr5sA0PdxPY5ln/5VuZbyAvVD1WOSFkVuXo+jR6PfqFviB2ZNsBz/tDjwa5j+t3/rQm3GfYeXh+6JGL4APngOHIqpqlHCGQ4+D2VTRcGGcyEym0gV15J1r8SpqStVPikLW0PAs5h8L/M3wENDC7sVuSRtybPqZicUExMrGEqVcubn2Xrihjo1dTHxsQ6l6fS4/QtuxuRk/p2zxPS6+oiPqPH+R8V2IK5CXGR6AIa4qFjCpq0sxNb8d5Kio4m9kB7h97HZ3xLUoVUhtqhgafBkS9P/9Xu04Lmf3yrE1mRP5KVbLPrwd0bWG8bIesOY/uwkzu5MzzQf8MTjNJ0xnZYLfueh3+ZS7uGHTcfKttQnPm5sKfzA7gXN5+P1KNYfvakYqMhOeU7Xx1lezH7qX/T8DHSql3O5+5XyA/R71vWfxhdySwoWg8HAJ+/rLrid++hi4u8/laZZI8VMBMUQNxe4fKgMDzXRJ7drtrjNoaNF30v99sWbfB6a7m3b+I1neXbtDDz97L9fnROL553m7QHpQdD2nX+KiTPte6VTGjvWX6S22/e0CprJySP65N7ro5px5F7xFYjnpf6UzaoXbjuE4ovBAOuehh6pCWk6X4BjGeYUP7sBT6YO7YKcISwY2hUjT02A1Xvh6m3YfLiwW5ILirmgWPTX9xUxnuhSlqpV3Tl9Ws9AOfc3+/dvv3n0NOvf+tJsn0dwSCG1pmihaRpTuuvfzXPTBjJ34DQ2TV/NtHJ3GfhBs0JunToRO3ZxZNx3ZvvcSt0/sfcuHTzLgUVbTK8fG9GrEFtjTnJiMp83+5CU5KzTjrXb1+PRwR0pG1IuS1KWzHhU0jOR3Ni2jRpvFN8OfHZUraGLDTu3qCWVsFeebgtfzYW5q6C7/T+KsiDzWdnj1bQV12d+S+zBXWiadl9N/LV+KF08nPyND4+0EDExI3/85M3s+ff4cEwsnfpEMXxICd58RS2bbkGgGY3MG/Qj4TtPAuDg5IgxOYWgNgqpS+2QqMgE6pbLmpE9INC+YjdnxmjUmDRqOzO+MY9hPGdtT0JbpvdZSpVxI/JmPIkJKbi4FgN3+kzcR7dioZD4pAU0LA8jt8JLV+CpkrAwQw6naf5Qt5iGihn/KoQOghe+hrO/FnZrhIyIh2IOaMlZUwldvZJgEhMB1q5JX1pniDqfpXxOhLhdU25TrbIKWUKBjjVyznS4/cvpJjGxdr/uPPKF7vkQ/tM0m+o/eV1djLoRq3anc3OyPQMhwOGrpZTK+3nds3hs0XtzAKj5aD1CmlZn2MbPAJj62Q6mf7nT5vcI9lLLXtwyWC39XGilnMtrmsa+jz83iYm13xpC5Wf1Je7Hf7Mt4+nBy75KbbIlu3hGgkqp2TbA7TjbB5On1u7m95f1z1+1la6+bJz0vxzPORaRvwHpKpRMt73oiDsmMbFi/SBenDmQzw6N47ND4+gzrh9lQ/QsHB1qXbat8tQ4WioZngEmbq6hVP7gnUCl8gAphvyby3J11R9rsbEW0ixmg2ONx9TfJ1QtW4hKZjrApgTypVNvvwdOgWMuHHoc83llXdJF62Uy4uQPZ1O14BY2ZIZ0yMUYPEExEkDsP7ZnhAZ4tepWpfKDWx9TKg8QE+9MyVYdAYhau9Rq+VPX1e5j28LLKZVfekr9HnDNWc2VxymwAeHnk2nVOT2L8bCPLaeUdH9Y7fp0yMW8mrPivKtqVuj4PWrlU27q/YD+fdKDZX3zQxzd+kVZPMfzxB9K7/GQ/1XrhTIQUipris1jaw/yeegwk5j40m9v02WU3h+JWPWPUv1NK6tltQYIO+mnVP6n3Wo/9KXE7G/G34zaaxITXVwcOB7Zjy699Lp3bVWbBFPNwqyKrVmkb96I57FGf1O3xA8mMbFek/JsvfwS/8a/biYmArzwxoMArPjjpHKbbnqozZq51m6tVN5RPWE4jv6QNgfsZkNXq0QTtfrdH1Arb1CcXzEqZMBNI07ROyzxlPUyGVG97+Xmd0s8pjbGciiRv2OBUoPUQnZ0qwLzn9D/TxMT25SALcGWxUQnH7U2JV1XK5+Qi/xZ8Yq24ZbB9mKzJmPOgmq/O+mM+jjUZop5UhaDZm/Rm/OBu3fv4u3tzcmjdfHyynnGrEHoEa5HJDN5UiUGv6EHUD7xb11KlnTEsbRap+M8VZTbevyWl1L5lSey71TfvXSdv/t/ZHrddc4XeAWU4/wtT7b01qO/tlzwu9X6a5RXzBEP+JZQi/uUlKKme9fzj8p2f8K9RI5tC6fBo+aCSXik5VHp3FenEr7rFCP3TzDti4uKZXybkQC0HtSJDZNXWG3T6siPrJbJyNrTagO6vRey78Bqmsad4yfZN/JT076WM6fi4l2S4NJ3+bmNnpBlwEbrAnJd//xNH3vutrpvvpdb9qLRrfM38K1YGkNqQJVNP64mbKq+VP2l39/Gr0YFPm+ox1D8aN94ix4+9fzU7Ds6QU0oy8n2LLHyaPaD9+hjR3GvVAknD092P6t7Xjae9wderrYLawBDHzmuVL6F71ml8gBaolo2Ui05+3vG7VuJGDWNMmXSe9Hz5lzk7SGHeefDOoz4pL5N9cfv+VOpPQDxO9R6Knmlod5LhMgYCEjV96umOqEeH6VeV3LO801ZMCqG7HNRFFySr8A762DVWfi9G9RNvQ0aNQiPgiqZ5oqSb6vVD+Aeqlbes7uaMLXe61Wl8p/8Y9lGE69fxrlcQJb7k6dbMlpKCgf/TxdhGsxZmON7VPJV6yS3CFETN3pUPadUHsA76kC2+8+fj6dsWWdKlDDvi53dupsWPfV72eTPHBk8Uh/Fr5nnRM0qWfsI9zapXZ+5GVgnKA6GLF0PN2IgMg6qZ3rsuzdXq9+xjD4ovROtUeexrPf9kxudcXczt6W4B19Seo+tV/2VymeclIuLimFy+w9Nrx94vBFPjH4eAGNyCuNbvI3BwcDT//xkc/2bTqiJgwBP1FOb6RjY5LRS+SDOmL0+eyaGZnXXmF7/sqApnbro95UL52NpVGs1DR70ZlWY7UueDU5qypHBRc1L1ZZndIeHN7J/b3q/cOhHDRk6MtTsfqVpGuGn7hBSzRuDwUDkrXga+s+hVr3SLNndW6lNPgnnlMonHl2rVD75vOqsH6TcgNUHYdAMePUxGN5N3x9+HSqWyRrTOFYxPElsPoeedMzFkliPB7Pf/+8NCPIGz0zamGtttfpdFUOdpKjPKeBSV+25brybvQB5K1LDaISypf+ba+rtSeq2F70Z7qTAiJvwUWmoYKWPmaTYX3K24ENyKQkiUqBhJuHSrbJa/QAuQWrlPdrAit3w+hTo1Ah+GJxzedV+t3O1dOM1GjUuX4PT5zSOnDDy9XQjd+7coWRJNXE5TWNi4GpwVRzzJcTCtPa5et+CRjwUM/Db/FtWyyz/uzoLF1ShZw9fJo7XE1vUqG1fi/mv7TtmEhPLPFCFZ9b8iFdAek+2RGrCjoxx9ooDC79aw6QBc3mt9mc2Z0F8bvprZmIi6IlZ3tmgeypunPIPY8aMyfO25hVXN24yiYmlH6xP24XzcPHWb0oGgwF3X/3/O5cUp6KKOFO6f2nKyr15xhqTmDh05cf41wzEYDDQqLfeed84Rc0joqhy/PPR7H/lRQA8qujuXcmx+TjbVgTo0n47tSuvM7ue+z6nC67jvzhSWM3KVz75Ex75GBJS9YLqqeP7aBtma+2BVan6dN0M4soPe6DbQohW73PbLcbEBC6MHMyFUa9ne9zg6IhrgG7rMSeOFmTT8pWmTfZROWQnERHmP3aamPjtx450fcyRTX/o7kCPPVv04wRaY9gS6DYDan0By//97/W9OVr/TmaNc+LiDhfqVNcHu9VbJ3HibOEka7m477RJTDQ4OuDg7MjRFXtM926HVOVFMxYvH4eZ086axMSgEF3Ui7iePjNTKUgfYB7Yrz45X9jcuaNfo0tWPUx44iu8+XGjLJMfVy/F8midP+j3hD7xXqq0rkIcO2R9vGUv/LJR//tsaijr2AR47DP4vnh0La2y6DjUmQG9l8AyNe3drtmw3UiDTkn83/DCewZ5O8LU8tbFxLzgRCK0vAh9rsEbuRBx84rHU6Ni/KPoyXovAY6cgyVbYfyf8Np38Nh7UPn59K1is0TTFtQiiRY9k+j3djJfT7efJGeFhQiKGRj96RVeHpjzmpQKAS481EL3EuzdqzTVqumzhK+/qbbcuTC5sCV9yqt6tzZZOgC13tKXPR8bby6k2Tt9P+6EwWAgITaRASEfE3fH8lJna5Tw8eCd9bpQ9+GHH/Lll19aOaNwiD6Tbs/13h+W5Xin8W8CsGr49wXVpALj3p04bp2PICFOV1re2/olJcv7mI53fK8nAFt+UpvFLqo4uOnL3OIjruPbQhdLI3cX7+Qknbvp3imfjzph2ufgULyDGNVKXUE2e6P+95nUQcz/inFS7/Wpj1cPtdX7do2Di963SLp2iYTL2fcvqr4/GoDTX3xcUM3Kdz7/Qnfjq1d3DzdvpnvZTRzlyNzvnHjqcV14CqlkoFzqkv1Vm+y7sz+hB1T00f8ftkQXFqdtMUWtUGbtVv3Edi31Lv4/c5x5f5D+vbV7Jpnk5IIX7ZJTZ0Ce+m4gw7Z/S+Nn2gBweOkOUxmvcj4AJMXlvm9W1AhPXUK3blsbNu1pB8DwNw5w7156SBj3VG/c2Fj7Esd3HGpPRFwPWjxsOd5GQEXdBW7L2sucOR5VQC0rWNLy5aWtGohK9XY+X4iiS0Hwv5O6kDgqNSFNy0B4Ui1ijt2yfa+Rfm/p1+s37xe/WKAZ2RevC4kDMvid/KruGJ6nPFxH/ztuEfyyFj6eA898BU2HQpX/S98yioW1X4KuI+HtaTB5KazaA2csrNJxdIQaVQx0ftSBNwc48M2HeSCXaYbcbXaCCIqZWLb8DoHBBzDaOEsatq4mAAsXRbJ1k308PZq88Sy9/tYFpG1fZl1a4h6gu7zEX1OP8ViUcXBwYGb4p4R20oOSDKk/hgv/qsUDykiJUp4mUfGDDz7gq6++ypN25iU1XupP5b5PA3B00tQsx0uF6G7/0Vdv2uy1aQ+8uvBdAKZ0H0u7oV0YuX8CLiXMlwgZDAYadG8K6Eui7Z1ao3Wv2ROfj8a3qb5W7ta2LTmdYveMGKnHYfthovmy66eeCQZgy4bidQ+DdAHxm9Twn91SZ2vnK87WFkX2pf5cnaua7z+duqqumGvFWaj02WQALn4yNNvjzt4+pv+TovI3JEVB8dJL/owara+DqlN7N5GRuhD1ZCdHWjU177JuWKArzC+9a19CTGZKe8DqwbDvXXgoddnYd2EQ0gXenpAeo80W1m/TxdU2zc0vlkH9HPnfT058+LojjoUw/g1pXovhu74jpHktAJoP0FPUr/pivqlM85f0faf/3lDwDcwnPv+mHhFxPajbwAd3d0e+mdQAgAerr0wv85XeJ532vWKQTTvhn71PAdCunh6vs+3jeuK4syeKxz0rMzGperhnMU2Msfy0LiR+GKa/blYB9r0I0zqBc/HW1gDYc8hIr8H6M+fvn52oVa14SilhcbqQmOaN6G6Ahf6wpSKEFNDkbkIK9Pgf1Jujb2lC4ebUBUhTl8Gn82DeBth5HG7ezb4eXy9oUgP6toWRz8Ev78KWiXBmjp7cJW27uMOFiztcOLfVhbXznJn6hRPvvOzEE23zwLA1wKi42dGwXLI8g0lI2bOjFg+1OkZCAlQIOsiubbXw8cn5KwrbnJ5so0fHLRwO70gJd9u+1hgUA1IB96LVruKkWOszvRnLJMfpN8bSTZtya+dOIrZswbdhQ4vnJtpQf2YSjGrr1pIU06bfs7L278Wve1A1tBILPl/J6Cem0HHEk9R7QjGwViqOzk6cOXOGKlWqMGLECOLj43kr1cMzI7F31X7rhBi19YvJcZbj3QR2as/Z3//k+pZtVPu/fjikPvHTfrtaPVpz7K+NHPx9FQ90a2WxnnjFNqmSEKt+w3ZJzn4g6V3eBwyABme2nyCwbvaBOh57qwsHluwkbOpKmj7zSJbjcdFqv9u9BLWBbUKM+mdOsfBbu5bWvQQSb93CwUW/T0T/eyRH28gO1c8c7aQWoxFAS1Q7R0u2XP7Rx8qwbs1NZv90nid76QL52x/UYeFv5xg+ZDert3e0Wn98rPpTO17xcjDkQ0c7OsPt9/QNiFF8pGSTdyxHFG/duCi259vUPFf960FMNu+VeV8OZmGRFMXfTYtR8367h9obGO9Zvj6dSpbCuUIQSZfPc3vFQnzaPA5AipZ+n6k87EPOjvuCU198TI1Ps5/UUvX4Ur3Xx9xVX4vuEG35Xvncc+WJvpvChAmXqFVzN3v3heKezTVqMEDrZrBxB3wzPZmBz6VfZKrXp2p8UEgPO2ArtlwPE3vqMUO/WQcLD8Di9frWoDpM+wA8cgiF5xir8cLb+vc65l1HojN9Z9VCDFQLMRATB2kjlXuKv521/lVmEmKsJxuIj76HwWCgWut6rB6zgH/nLqVq5zY21Z/T9WMJ1X5rjGL/LRrLhtGzVyDD3zjA7VuJLFtymVZty9G5a3neef0wX485xSuDgm16D4OTmohhcFF85io+o2OdLNtRhSBPHmxSlv27bvDZO9t45uVarF9xgZ/G7+eDcS1tfg9HxQsuUfG5nqxuSqTmQaJmhfTncUTq6nVnR/NnNECc4j0jTi23oTIOCvWHRcKn59JfP1geJrYDVydITNG37EhUvBcnKsazTcnF7+ai+Fw3ptrS0ZNGnnpN/6BzJzpSJciQ5T6bG2Jy0ZeJVXTMT7KxmauS4PskIPV38HOASeX05dU5va+F4ViOuFh5/EQnwZlsokEEldOHeE1rQd1gCPGD4HLg4W5ezloMxcxdHWcLv2VM6v7/5Hijati5PaeQkKQswKVLl6hYsWJhN0MQBEEQBEEQBEEQBEEoIpw5c4bKldWyz8THxxMSEsK1XK769PPzIzw8HDe3ou3yLIIiYDQauXLlCl5eXhazvQr3J3fv3qVixYpcvHixyGdYEoouYkdCXiG2JOQVYktCXiG2JOQVYktCXiG2JOQFd+7coVKlSkRGRuLj46N8fnx8PImJucsq6OLiUuTFRJAlz4AeWy8wMLCwmyEUYUqWLCkPI+E/I3Yk5BViS0JeIbYk5BViS0JeIbYk5BViS0Je4OCQu3iZbm5udiEK/heKZyRRQRAEQRAEQRAEQRAEQRDyBREUBUEQBEEQBEEQBEEQBEGwGREUBSEHXF1dGTVqFK6uroXdFMGOETsS8gqxJSGvEFsS8gqxJSGvEFsS8gqxJSEvEDuyjiRlEQRBEARBEARBEARBEATBZsRDURAEQRAEQRAEQRAEQRAEmxFBURAEQRAEQRAEQRAEQRAEmxFBURAEQRAEQRAEQRAEQRAEmxFBURAEQRAEQRAEQRAEQRAEmxFBUSi2TJkyhZCQENzc3AgNDWXz5s2mY6NHj6ZmzZp4eHhQqlQp2rVrx86dO63WefjwYVq1aoW7uzsVKlTg008/JXNeo7CwMEJDQ3Fzc6Ny5cpMmzYtzz+bULDkZEsAx44do2vXrnh7e+Pl5UWzZs24cOFCjnWKLd2f5GRL169fp3///gQEBFCiRAk6duzIqVOnrNYptnT/sWnTJrp06UJAQAAGg4ElS5aYjiUlJfHee+9Rt25dPDw8CAgIoF+/fly5csVqvWJL9xc52RFA//79MRgMZluzZs2s1it2dP9hzZZiYmIYMmQIgYGBuLu7U6tWLaZOnWq1XrGl+4svv/ySxo0b4+XlRbly5ejevTsnTpwwK7N48WI6dOhAmTJlMBgMHDhwwKa6xZbuT3Lqd2uaxujRowkICMDd3Z3WrVvz77//Wq1TbCkTmiAUQ+bPn685OztrM2bM0I4ePaoNHTpU8/Dw0M6fP69pmqbNmzdPW7NmjXbmzBntyJEj2oABA7SSJUtqERERFuu8c+eOVr58ea1Pnz7a4cOHtUWLFmleXl7auHHjTGXOnj2rlShRQhs6dKh29OhRbcaMGZqzs7O2cOHCfP/MQv5gzZZOnz6t+fr6asOHD9f27dunnTlzRlu2bJl2/fp1i3WKLd2f5GRLRqNRa9asmfbwww9ru3bt0o4fP6698sorWqVKlbSYmBiLdYot3Z+sWLFC+/DDD7VFixZpgPbXX3+ZjkVFRWnt2rXTFixYoB0/flzbvn271rRpUy00NDTHOsWW7j9ysiNN07QXXnhB69ixo3b16lXTduvWrRzrFDu6P7FmSy+99JJWpUoVbcOGDVp4eLg2ffp0zdHRUVuyZInFOsWW7j86dOigzZo1Szty5Ih24MAB7YknnsjSD5ozZ472ySefaDNmzNAAbf/+/VbrFVu6P7E2hhs7dqzm5eWlLVq0SDt8+LDWu3dvzd/fX7t7967FOsWWsiKColAsadKkiTZw4ECzfTVr1tRGjBiRbfk7d+5ogLZ27VqLdU6ZMkXz9vbW4uPjTfu+/PJLLSAgQDMajZqmadq7776r1axZ0+y8V199VWvWrFluP4pQyFizpd69e2vPPfecUp1iS/cnOdnSiRMnNEA7cuSI6VhycrLm6+urzZgxw2KdYktCdoP3zOzatUsDTJ3o7BBbur+xJCh269ZNqR6xIyE7W6pdu7b26aefmu1r2LCh9tFHH1msR2xJiIiI0AAtLCwsy7Hw8HCbBUWxpfuTnPrdRqNR8/Pz08aOHWs6Fh8fr3l7e2vTpk2zWKfYUlZkybNQ7EhMTGTv3r20b9/ebH/79u3Ztm1btuV//PFHvL29qV+/vml///79ad26ten19u3badWqFa6urqZ9HTp04MqVK5w7d85UJvP7dujQgT179pCUlJQHn04oSKzZktFoZPny5VSvXp0OHTpQrlw5mjZtmu2yMbGl+xtrtpSQkACAm5ub6ZijoyMuLi5s2bLFtE9sScgNd+7cwWAw4OPjY9ontiTYwsaNGylXrhzVq1fn5ZdfJiIiwuy42JFgCy1btmTp0qVcvnwZTdPYsGEDJ0+epEOHDqYyYktCZu7cuQOAr6+v0nliS4K1fnd4eDjXrl0zO+7q6kqrVq3M9AKxJeuIoCgUO27evElKSgrly5c321++fHmuXbtmer1s2TI8PT1xc3Pj22+/Zc2aNZQpU8Z03N/fn0qVKpleX7t2Lds6047lVCY5OZmbN2/mzQcUCgxrthQREUFMTAxjx46lY8eOrF69mh49etCzZ0/CwsJM5cWWBGu2VLNmTYKCgnj//feJjIwkMTGRsWPHcu3aNa5evWoqL7YkqBIfH8+IESN45plnKFmypGm/2JJgjU6dOjFv3jzWr1/P+PHj2b17N23btjVNgIDYkWAbkyZN4oEHHiAwMBAXFxc6duzIlClTaNmypamM2JKQEU3TePvtt2nZsiV16tRROldsSbDW70773a3pBWJL1nEq7AYIQn5hMBjMXmuaZravTZs2HDhwgJs3bzJjxgx69erFzp07KVeuHKAHBralzsz7bSkj2BeWbMloNALQrVs33nrrLQAaNGjAtm3bmDZtGq1atQLEloR0LNmSs7MzixYtYsCAAfj6+uLo6Ei7du3o1KmTWXmxJUGFpKQk+vTpg9FoZMqUKWbHxJYEa/Tu3dv0f506dWjUqBFBQUEsX76cnj17AmJHgm1MmjSJHTt2sHTpUoKCgti0aRODBg3C39+fdu3aAWJLgjlDhgzh0KFDZqs0bEVsSUjDmh5g7bjYknXEQ1EodpQpUwZHR0ez2QWAiIgIs9kCDw8PqlatSrNmzZg5cyZOTk7MnDnTYr1+fn7Z1gnpMxOWyjg5OVG6dOn/9LmEgseaLZUpUwYnJyceeOABs+O1atXKMcuz2NL9hy33pdDQUA4cOEBUVBRXr15l5cqV3Lp1i5CQEIv1ii0JlkhKSqJXr16Eh4ezZs0aM+/E7BBbEqzh7+9PUFBQjtnnxY6EzNy7d48PPviACRMm0KVLF+rVq8eQIUPo3bs348aNs3ie2NL9y+uvv87SpUvZsGEDgYGB/7k+saX7D2v9bj8/PwCrekFmxJayIoKiUOxwcXEhNDSUNWvWmO1fs2YNLVq0sHiepmlmy3gy07x5czZt2kRiYqJp3+rVqwkICCA4ONhUJvP7rl69mkaNGuHs7JyLTyMUJtZsycXFhcaNG3PixAmz4ydPniQoKMhivWJL9x8q9yVvb2/Kli3LqVOn2LNnD926dbNYr9iSkB1pYuKpU6dYu3atTR1YsSXBGrdu3eLixYv4+/tbLCN2JGQmKSmJpKQkHBzMh52Ojo6mlR7ZIbZ0/6FpGkOGDGHx4sWsX78+xwlVFcSW7j+s9btDQkLw8/MzO56YmEhYWFiOeoHYUjYUWPoXQShA0tLEz5w5Uzt69Kj25ptvah4eHtq5c+e0mJgY7f3339e2b9+unTt3Ttu7d682YMAAzdXV1SzD6ogRI7Tnn3/e9DoqKkorX7681rdvX+3w4cPa4sWLtZIlS2abJv6tt97Sjh49qs2cObNYp4m/H8jJljRN0xYvXqw5OztrP/74o3bq1Cnt+++/1xwdHbXNmzeb6hBbEjTNui398ccf2oYNG7QzZ85oS5Ys0YKCgrSePXua1SG2JGiapkVHR2v79+/X9u/frwHahAkTtP3792vnz5/XkpKStK5du2qBgYHagQMHtKtXr5q2hIQEUx1iS0JOdhQdHa2988472rZt27Tw8HBtw4YNWvPmzbUKFSpod+/eNdUhdiRoWs62pGma1qpVK6127drahg0btLNnz2qzZs3S3NzctClTppjqEFsSXnvtNc3b21vbuHGj2bMrLi7OVObWrVva/v37teXLl2uANn/+fG3//v3a1atXTWXElgRNs97vHjt2rObt7a0tXrxYO3z4sNa3b1/N399fnnGKiKAoFFsmT56sBQUFaS4uLlrDhg21sLAwTdM07d69e1qPHj20gIAAzcXFRfP399e6du2q7dq1y+z8F154QWvVqpXZvkOHDmkPP/yw5urqqvn5+WmjR482pYhPY+PGjdqDDz6oubi4aMHBwdrUqVPz9XMK+Y8lW0pj5syZWtWqVTU3Nzetfv362pIlS8yOiy0JaeRkS999950WGBioOTs7a5UqVdI++ugjMwFI08SWBJ0NGzZoQJbthRde0MLDw7M9BmgbNmww1SG2JORkR3FxcVr79u21smXLmu5JL7zwgnbhwgWzOsSOBE3L2ZY0TdOuXr2q9e/fXwsICNDc3Ny0GjVqaOPHjzezC7ElwdKza9asWaYys2bNyrbMqFGjTGXEloQ0cup3G41GbdSoUZqfn5/m6uqqPfLII9rhw4fNzhdbso5B01IjRAqCIAiCIAiCIAiCIAiCIFhBYigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAIgiAIgiAIgmAzIigKgiAIgiAUUUaPHk2DBg0K/H03btyIwWDAYDDQvXv3An//NIKDg03tiIqKKrR2CIIgCIIgCOaIoCgIgiAIglAIpAlllrb+/fszbNgw1q1bV2htPHHiBLNnzza9bt26NW+++WaWckuWLMFgMJjK5PS5goODAbh27Rqvv/46lStXxtXVlYoVK9KlSxezz7t7924WLVqUnx9REARBEARByAVOhd0AQRAEQRCE+5GrV6+a/l+wYAEff/wxJ06cMO1zd3fH09MTT0/PwmgeAOXKlcPHx0fpnMWLF5OYmAjAxYsXadKkCWvXrqV27doAODo6cu7cOR566CF8fHz4+uuvqVevHklJSaxatYrBgwdz/PhxAMqWLYuvr2+efiZBEARBEAThvyMeioIgCIIgCIWAn5+fafP29sZgMGTZl3nJc//+/enevTtjxoyhfPny+Pj48Mknn5CcnMzw4cPx9fUlMDCQn3/+2ey9Ll++TO/evSlVqhSlS5emW7dunDt3Ll8+l6+vr+kzlC1bFoDSpUub7Rs0aBAGg4Fdu3bx1FNPUb16dWrXrs3bb7/Njh078qVdgiAIgiAIQt4hgqIgCIIgCIIdsX79eq5cucKmTZuYMGECo0ePpnPnzpQqVYqdO3cycOBABg4cyMWLFwGIi4ujTZs2eHp6smnTJrZs2YKnpycdO3Y0eRIWJLdv32blypUMHjwYDw+PLMdVPSIFQRAEQRCEgkcERUEQBEEQBDvC19eXSZMmUaNGDV588UVq1KhBXFwcH3zwAdWqVeP999/HxcWFrVu3AjB//nwcHBz46aefqFu3LrVq1WLWrFlcuHCBjRs3Fnj7T58+jaZp1KxZs8DfWxAEQRAEQcgbJIaiIAiCIAiCHVG7dm0cHNLnhMuXL0+dOnVMrx0dHSldujQREREA7N27l9OnT+Pl5WVWT3x8PGfOnCmYRmdA0zQAUxIXQRAEQRAEwf4QQVEQBEEQBMGOcHZ2NnttMBiy3Wc0GgEwGo2EhoYyb968LHWlxTi0lZIlS3Lnzp0s+6OioihZsqRNdVSrVg2DwcCxY8fo3r270vsLgiAIgiAIRQNZ8iwIgiAIglCMadiwIadOnaJcuXJUrVrVbPP29laqq2bNmuzZsyfL/t27d1OjRg2b6vD19aVDhw5MnjyZ2NjYLMejoqKU2iQIgiAIgiAUPCIoCoIgCIIgFGOeffZZypQpQ7du3di8eTPh4eGEhYUxdOhQLl26pFTXoEGDOHPmDIMHD+bgwYOcPHmSyZMnM3PmTIYPH25zPVOmTCElJYUmTZqwaNEiTp06xbFjx5g0aRLNmzdX/YiCIAiCIAhCASOCoiAIgiAIQjGmRIkSbNq0iUqVKtGzZ09q1arFiy++yL1792xeppxGcHAwmzdv5syZM7Rv357GjRsze/ZsZs+ezdNPP21zPSEhIezbt482bdrwzjvvUKdOHR577DHWrVvH1KlTVT+iIAiCIAiCUMAYtLTI2IIgCIIgCIIAbNy4kTZt2hAZGYmPj4+0RRAEQRAEQTBDPBQFQRAEQRCEbAkMDKRv376F9v61a9emU6dOhfb+giAIgiAIQvaIh6IgCIIgCIJgxr1797h8+TIAnp6e+Pn5FUo7zp8/T1JSEgCVK1fGwUHmwgVBEARBEIoCIigKgiAIgiAIgiAIgiAIgmAzMs0rCIIgCIIgCIIgCIIgCILNiKAoCIIgCIIgCIIgCIIgCILNiKAoCIIgCIIgCIIgCIIgCILNiKAoCIIgCIIgCIIgCIIgCILNiKAoCIIgCIIgCIIgCIIgCILNiKAoCIIgCIIgCIIgCIIgCILNiKAoCIIgCIIgCIIgCIIgCILNiKAoCIIgCIIgCIIgCIIgCILN/D8n/FyU7UVF5AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create an ACT TimeSeriesDisplay.\n", + "display = act.plotting.TimeSeriesDisplay(\n", + " {'Shear, Wind Direction, and Speed at ANL ATMOS': ds},\n", + " subplot_shape=(1,), figsize=(15, 5))\n", + "\n", + "# Plot shear with a wind barb overlay, while using a color vision\n", + "# deficiency (CVD) colormap.\n", + "display.plot('shear', subplot_index=(0,), cb_friendly=True)\n", + "display.plot_barbs_from_spd_dir('speed', 'dir')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Splitting our notebook in sections of information and code\n", + "\n", + "With the code example above, it is great to split up your code and example into sections. Each section will be based on your overall goal and scope your trying to explain to the audience." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A content subsection\n", + "Divide and conquer your objectives with Markdown subsections, which will populate the helpful navbar in Jupyter Lab and here on the Jupyter Book!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# some subsection code\n", + "new = \"helpful information\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Another content subsection\n", + "Keep up the good work! A note, *try to avoid using code comments as narrative*, and instead let them only exist as brief clarifications where necessary." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Your second content section\n", + "Here we can move on to our second objective, and we can demonstrate" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Subsection to the second section\n", + "\n", + "#### a quick demonstration\n", + "\n", + "##### of further and further\n", + "\n", + "###### header levels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "as well $m = a * t / h$ text! Similarly, you have access to other $\\LaTeX$ equation [**functionality**](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html) via MathJax (demo below from link),\n", + "\n", + "\\begin{align}\n", + "\\dot{x} & = \\sigma(y-x) \\\\\n", + "\\dot{y} & = \\rho x - y - xz \\\\\n", + "\\dot{z} & = -\\beta z + xy\n", + "\\end{align}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check out [**any number of helpful Markdown resources**](https://www.markdownguide.org/basic-syntax/) for further customizing your notebooks and the [**Jupyter docs**](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Working%20With%20Markdown%20Cells.html) for Jupyter-specific formatting information. Don't hesitate to ask questions if you have problems getting it to look *just right*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Last Section\n", + "\n", + "If you're comfortable, and as we briefly used for our embedded logo up top, you can embed raw html into Jupyter Markdown cells (edit to see):" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "

Info

\n", + " Your relevant information here!\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feel free to copy this around and edit or play around with yourself. Some other `admonitions` you can put in:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "

Success

\n", + " We got this done after all!\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "

Warning

\n", + " Be careful!\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "

Danger

\n", + " Scary stuff be here.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also suggest checking out Jupyter Book's [brief demonstration](https://jupyterbook.org/content/metadata.html#jupyter-cell-tags) on adding cell tags to your cells in Jupyter Notebook, Lab, or manually. Using these cell tags can allow you to [customize](https://jupyterbook.org/interactive/hiding.html) how your code content is displayed and even [demonstrate errors](https://jupyterbook.org/content/execute.html#dealing-with-code-that-raises-errors) without altogether crashing our loyal army of machines!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "Add one final `---` marking the end of your body of content, and then conclude with a brief single paragraph summarizing at a high level the key pieces that were learned and how they tied to your objectives. Look to reiterate what the most important takeaways were.\n", + "\n", + "With the example code above and our format, we can create a notebook for users to use and learn about ACT, ACT data and open science.\n", + "\n", + "### What's next?\n", + "Let Jupyter book tie this to the next (sequential) piece of content that people could move on to down below and in the sidebar. However, if this page uniquely enables your reader to tackle other nonsequential concepts throughout this book, or even external content, link to it here!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Resources and references\n", + "Finally, be rigorous in your citations and references as necessary. Give credit where credit is due. Also, feel free to link to relevant external material, further reading, documentation, etc. Then you're done! Give yourself a quick review, a high five, and send us a pull request. A few final notes:\n", + " - `Kernel > Restart Kernel and Run All Cells...` to confirm that your notebook will cleanly run from start to finish\n", + " - `Kernel > Restart Kernel and Clear All Outputs...` before committing your notebook, our machines will do the heavy lifting\n", + " - Take credit! Provide author contact information if you'd like; if so, consider adding information here at the bottom of your notebook\n", + " - Give credit! Attribute appropriate authorship for referenced code, information, images, etc.\n", + " - Only include what you're legally allowed: **no copyright infringement or plagiarism**\n", + " \n", + "Thank you for your contribution!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "nbdime-conflicts": { + "local_diff": [ + { + "diff": [ + { + "diff": [ + { + "key": 0, + "op": "addrange", + "valuelist": [ + "Python 3" + ] + }, + { + "key": 0, + "length": 1, + "op": "removerange" + } + ], + "key": "display_name", + "op": "patch" + } + ], + "key": "kernelspec", + "op": "patch" + } + ], + "remote_diff": [ + { + "diff": [ + { + "diff": [ + { + "key": 0, + "op": "addrange", + "valuelist": [ + "Python3" + ] + }, + { + "key": 0, + "length": 1, + "op": "removerange" + } + ], + "key": "display_name", + "op": "patch" + } + ], + "key": "kernelspec", + "op": "patch" + } + ] + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/change_units.py b/examples/utils/plot_change_units.py similarity index 55% rename from examples/change_units.py rename to examples/utils/plot_change_units.py index 6844c9eb35..cdd79ed643 100644 --- a/examples/change_units.py +++ b/examples/utils/plot_change_units.py @@ -1,42 +1,46 @@ """ -===================================== -Example for changing units in dataset -===================================== +Changing units in dataset +------------------------- This is an example of how to change units in the xarray dataset. """ -import act +from arm_test_data import DATASETS import numpy as np +import act + -def print_summary(obj, variables): +def print_summary(ds, variables): for var_name in variables: - print(f"{var_name}: mean={np.nanmean(obj[var_name].values)} " - f"units={obj[var_name].attrs['units']}") + print( + f'{var_name}: mean={np.nanmean(ds[var_name].values)} ' + f"units={ds[var_name].attrs['units']}" + ) print() variables = ['first_cbh', 'second_cbh', 'alt'] # Read in some example data -obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_CEIL1) +filename_ceil = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') +ds = act.io.arm.read_arm_netcdf(filename_ceil) # Print the variable name, mean of values and units print('Variables in read data') -print_summary(obj, variables) +print_summary(ds, variables) # Change units of one varible from m to km -obj.utils.change_units(variables='first_cbh', desired_unit='km') +ds.utils.change_units(variables='first_cbh', desired_unit='km') print('Variables with one changed to km') -print_summary(obj, variables) +print_summary(ds, variables) # Change units of more than one varible from to km -obj.utils.change_units(variables=variables, desired_unit='km') +ds.utils.change_units(variables=variables, desired_unit='km') print('Variables with both changed to km') -print_summary(obj, variables) +print_summary(ds, variables) # Can change all data variables in the dataset that are units of length by not providing # a list of variables. Here we are changing back to orginal meters. @@ -44,18 +48,18 @@ def print_summary(obj, variables): # longer if we keep the QC variables. Faseter if we exclude them. # The method will return a dataset. In this case the dataset returned is the same # dataset. -skip_variables = [ii for ii in obj.data_vars if ii.startswith('qc_')] -new_obj = obj.utils.change_units(variables=None, desired_unit='m', skip_variables=skip_variables) +skip_variables = [ii for ii in ds.data_vars if ii.startswith('qc_')] +new_ds = ds.utils.change_units(variables=None, desired_unit='m', skip_variables=skip_variables) print('Variables changed back to m by looping over all variables in dataset') -print('Orginal dataset is same as retured dataset:', obj is new_obj) -print_summary(new_obj, variables) +print('Orginal dataset is same as retured dataset:', ds is new_ds) +print_summary(new_ds, variables) # For coordinate variables need to explicitly give coordinage variable name and use # the returned dataset. The xarray method used to change values on coordinate # values requries returning a new updated dataet. var_name = 'range' variables.append(var_name) -new_obj = obj.utils.change_units(variables=variables, desired_unit='km') +new_ds = ds.utils.change_units(variables=variables, desired_unit='km') print('Variables and coordinate variable values changed to km') -print('Orginal dataset is same as retured dataset:', obj is new_obj) -print_summary(new_obj, variables) +print('Orginal dataset is same as retured dataset:', ds is new_ds) +print_summary(new_ds, variables) diff --git a/examples/utils/plot_parse_filename.py b/examples/utils/plot_parse_filename.py new file mode 100644 index 0000000000..b0719c4c8b --- /dev/null +++ b/examples/utils/plot_parse_filename.py @@ -0,0 +1,42 @@ +""" +Parse the ARM datastream filename +--------------------------------- + +This is an example of how to parse +the datastream filename into its constituent parts. + +""" + +from act.utils.data_utils import DatastreamParserARM + +# Here we have a full path filename. +filename = '/data/sgp/sgpmetE13.b1/sgpmetE13.b1.20190501.024254.nc' + +# What if we want to extract some metadata from the filename instead of reading the file +# and extracting from the global attributes. We can call the DatastreamParserARM() method +# and extract the string value from the object using its properties. + +fn_obj = DatastreamParserARM(filename) +print(f"Site is {fn_obj.site}") +print(f"Datastream Class is {fn_obj.datastream_class}") +print(f"Facility is {fn_obj.facility}") +print(f"Level is {fn_obj.level}") +print(f"Datastream is {fn_obj.datastream}") +print(f"Date is {fn_obj.date}") +print(f"Time is {fn_obj.time}") +print(f"File extension is {fn_obj.ext}") + +# We can also use the parser for just the datastream part to extract the parts. +# The other methods will not have a value and return None. + +filename = 'sgpmetE13.b1' + +fn_obj = DatastreamParserARM(filename) +print(f"\nSite is {fn_obj.site}") +print(f"Datastream Class is {fn_obj.datastream_class}") +print(f"Facility is {fn_obj.facility}") +print(f"Level is {fn_obj.level}") +print(f"Datastream is {fn_obj.datastream}") +print(f"Date is {fn_obj.date}") +print(f"Time is {fn_obj.time}") +print(f"File extension is {fn_obj.ext}") diff --git a/examples/utils/plot_tar.py b/examples/utils/plot_tar.py new file mode 100644 index 0000000000..d09c301871 --- /dev/null +++ b/examples/utils/plot_tar.py @@ -0,0 +1,106 @@ +""" +Working with TAR and gunzip files +------------------------------------------------------------- + +This is an example of how to use the TAR and gunzip extensions +for creating or extracting data files. The functions for creation +and extraction can be called independently to manage the data +files directly or a TAR or gunzip file can be provided to the +netCDF reader and the extraction will happen automatically to +a temporary area. + +""" + +import os +from pathlib import Path + +# Import standard libraries +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +# Import ACT functions +from act.io.arm import read_arm_netcdf +from act.plotting import TimeSeriesDisplay +from act.utils.io_utils import cleanup_files, pack_gzip, pack_tar, unpack_tar + +# Create a TAR file from multiple netCDF data files and pass newly created +# TAR file into read_arm_netcdf() to be unpacked and read. + +# Here we get a list of MET data files to pack into a TAR bundle +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] +met_files = [Path(DATASETS.fetch(file)) for file in met_wildcard_list] + +# We can pass the list of netCDF data files to the pack_tar() function. +# Notice that the new_dir directory does not exist. The directory will +# be created. +new_dir = 'temporary_directory' +filename = pack_tar(met_files, write_directory=new_dir) + +print('Created TAR file: ', filename) + +# Read the data within the TAR file +ds = read_arm_netcdf(filename) + +# Create a plotting display object +display = TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(1,)) + +# Plot up the diffuse variable in the first plot +variable = 'temp_mean' +display.plot(variable, subplot_index=(0,), day_night_background=True) + +plt.show() +del ds + +# Create a gunzip file from TAR file containing multiple netCDF data files and +# pass newly created gunzip file into read_arm_netcdf() to be unpacked and read. + +# Pass the TAR filename into gunzip. Have the function remove the TAR file after +# creating the gunzip file +filename = pack_gzip(filename, write_directory=new_dir, remove=True) + +print('New gunzip file: ', filename) + +# Read the data within the gunzipped TAR file +ds = read_arm_netcdf(filename) + +# Create a plotting display object +display = TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(1,)) + +# Plot up the diffuse variable in the first plot +variable = 'rh_mean' +display.plot(variable, subplot_index=(0,), day_night_background=True) + +plt.show() + +Path(filename).unlink() + +# When working with a TAR file and reading it often will be more efficient to untar once +# and point reader to untarred files. Then clean up the directory when multiple reads are done. +tar_file = pack_tar(met_files, write_directory=new_dir) + +# This will unpack the TAR file to a new directroy created with a random name to ensure multiple +# simultaneous uses do not collide. The full path to all extracted filenames will be returned. +filenames = unpack_tar( + tar_file, write_directory=new_dir, randomize=True, return_files=True, remove=True +) + +# Print the extracted filenames +print('Extracted filenames: ', filenames) + +# Print a list of filenames and directories in the new directory +print('LS of temporary directory:', list(Path(new_dir).glob('*'))) + +# After the extracted files are read for last time we can clean up the directory. +cleanup_files(files=filenames) + +# Print a list of filenames and directories in the new directory +print('LS of temporary directory:', list(Path(new_dir).glob('*'))) + +# Remove the temporary directory we created to clean up directory. +Path(new_dir).rmdir() diff --git a/examples/utils/readme.txt b/examples/utils/readme.txt new file mode 100644 index 0000000000..57af554fbc --- /dev/null +++ b/examples/utils/readme.txt @@ -0,0 +1,6 @@ +.. _util_examples: + +Utility examples +-------------------------- + +Examples showing different helpful utilies in ACT. diff --git a/examples/workflows/plot_aerioe_with_cbh.py b/examples/workflows/plot_aerioe_with_cbh.py new file mode 100644 index 0000000000..717d47933e --- /dev/null +++ b/examples/workflows/plot_aerioe_with_cbh.py @@ -0,0 +1,62 @@ +""" + +Plot AERIoe data with cloud base height from ceilometer +------------------------------------------------------- + +Example to download and plot AERIoe +temperature and water vapor overlaying +ceilometer cloud base height(cbh). + +""" + +import matplotlib.pyplot as plt +import os + +import act + +# Place your username and token here +username = os.getenv('ARM_USERNAME') +token = os.getenv('ARM_PASSWORD') + +# Download and read AERIoe and ceilometer data +if username is None or token is None or len(username) == 0 or len(token) == 0: + pass +else: + results = act.discovery.download_arm_data(username, token, 'sgpaerioe1turnC1.c1', '2022-02-11', '2022-02-11') + aerioe_ds = act.io.arm.read_arm_netcdf(results) + results = act.discovery.download_arm_data(username, token, 'sgpceilC1.b1', '2022-02-11', '2022-02-11') + ceil_ds = act.io.arm.read_arm_netcdf(results) + + # There isn't information content from the AERI above 3 km + # Remove data with a height above 3 km + aerioe_ds = aerioe_ds.sel(height=aerioe_ds.coords['height'] <= 3) + + # Convert Ceilometer cloud base height to km + ceil_ds.utils.change_units(variables='first_cbh', desired_unit='km') + + # Remove first_cbh if it is higher than 3 km + ceil_ds['first_cbh'] = ceil_ds['first_cbh'][~(ceil_ds['first_cbh'] > 3)] + + # Create a TimeSeriesDisplay object + display = act.plotting.TimeSeriesDisplay( + {'AERIoe': aerioe_ds, 'Ceilometer': ceil_ds}, + subplot_shape=(2,), figsize=(20, 10) + ) + + # Plot data + display.plot('first_cbh', dsname='Ceilometer', marker='+', color='black', markeredgewidth=3, + linewidth=0, subplot_index=(0,), label='cbh') + display.plot('temperature', dsname='AERIoe', cmap='viridis', set_shading='nearest', + add_nan=True, subplot_index=(0,)) + + display.plot('first_cbh', dsname='Ceilometer', marker='+', color='black', markeredgewidth=3, + linewidth=0, subplot_index=(1,), label='cbh') + display.plot('waterVapor', dsname='AERIoe', cmap='HomeyerRainbow', set_shading='nearest', + add_nan=True, subplot_index=(1,)) + + # If you want to save it you can + # plt.savefig('sgpaerioe1turnC1.c1.20220211.png') + plt.show() + + aerioe_ds.close() + ceil_ds.close() diff --git a/examples/workflows/plot_merged_product.py b/examples/workflows/plot_merged_product.py new file mode 100644 index 0000000000..bc9764bb83 --- /dev/null +++ b/examples/workflows/plot_merged_product.py @@ -0,0 +1,87 @@ +""" +Merge multiple datasets +----------------------- + +Example to merge multiple data products into one using ACT. +Shows how to adjust the timestamp if the timestamps are at +different part of the sample interval (left, right, center). +Also shows how to apply QC information, merge and resample +data using xarray and plot/write out the results. + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import xarray as xr + +import act + +# Set data files +# An alternative to this is to download data from the +# ARM Data Webservice as shown in the discovery plot_neon.py example +ebbr_file = DATASETS.fetch('sgp30ebbrE13.b1.20190601.000000.nc') +ecor_file = DATASETS.fetch('sgp30ecorE14.b1.20190601.000000.cdf') +sebs_file = DATASETS.fetch('sgpsebsE14.b1.20190601.000000.cdf') + +# Read data into datasets +ds_ebbr = act.io.arm.read_arm_netcdf(ebbr_file) +ds_ecor = act.io.arm.read_arm_netcdf(ecor_file) +ds_sebs = act.io.arm.read_arm_netcdf(sebs_file) + +# Check for ARM DQRs and add them to the QC variables +ds_ebbr = act.qc.arm.add_dqr_to_qc(ds_ebbr) +ds_ecor = act.qc.arm.add_dqr_to_qc(ds_ecor) +ds_sebs = act.qc.arm.add_dqr_to_qc(ds_sebs) + +# The ECOR and EBBR have different definitions of latent heat +# flux and what is positive vs negative. Check out the ARM +# Handbooks for more information +ds_ecor['lv_e'].values = ds_ecor['lv_e'].values * -1. + +# For example purposes, let's rename the ecor latent heat flux +ds_ecor = ds_ecor.rename({'lv_e': 'latent_heat_flux_ecor'}) +ds_ecor['latent_heat_flux_ecor'].attrs['ancillary_variables'] = 'qc_latent_heat_flux_ecor' +ds_ecor = ds_ecor.rename({'qc_lv_e': 'qc_latent_heat_flux_ecor'}) + +# Also going to Switch some QC for example purposes +qc = ds_ecor['qc_latent_heat_flux_ecor'].values +qc[10:20] = 2 +ds_ecor['qc_latent_heat_flux_ecor'].values = qc + +# There is a difference in how these timestamps are defined +# The EBBR is at the end of the sampling interval and the +# ECOR is at the beginning. Knowing this, we can shift the +# EBBR timestampes by 30 minutes to coincide with the ECOR +ds_ebbr = act.utils.datetime_utils.adjust_timestamp(ds_ebbr, offset=-30 * 60) + +# Now, we can merge all these datasets into one product +ds = xr.merge([ds_ecor, ds_ebbr, ds_sebs], compat='override') + +# Apply the QC information to set all flagged data to missing/NaN +ds.qcfilter.datafilter(del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect']) + +# Plot up data from the merged dataset for each of the instruments +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(3,)) +display.plot('latent_heat_flux_ecor', label='ECOR', subplot_index=(0,)) +display.plot('latent_heat_flux', label='EBBR', subplot_index=(0,)) +plt.legend() +display.plot('surface_soil_heat_flux_1', label='SEBS', subplot_index=(1,)) + +# Plot out the QC information that was modified as well +display.qc_flag_block_plot('latent_heat_flux_ecor', subplot_index=(2,)) +plt.show() + +# Resample the data to 1 hour mean +# Check out the xarray documentation for more information +# on the resample function. Options include mean, median, +# max, min, sum, nearest, and more. +ds = ds.resample(time='H').mean(keep_attrs=True) + +# Plot up data from the hourly merged dataset for ECOR and EBBR +display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(1,)) +display.plot('latent_heat_flux_ecor', label='ECOR', subplot_index=(0,)) +display.plot('latent_heat_flux', label='EBBR', subplot_index=(0,)) +plt.show() + +# Write data out to netcdf +ds.to_netcdf('./sgpecor_ebbr_sebs.nc') diff --git a/examples/workflows/plot_multiple_dataset.py b/examples/workflows/plot_multiple_dataset.py new file mode 100644 index 0000000000..fba3c58f05 --- /dev/null +++ b/examples/workflows/plot_multiple_dataset.py @@ -0,0 +1,58 @@ +""" +Plot multiple datasets +---------------------- + +This is an example of how to download and +plot multiple datasets at a time. + +""" + +import os + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +# Place your username and token here +username = os.getenv('ARM_USERNAME') +token = os.getenv('ARM_PASSWORD') + +# Get data from the web service if username and token are available +# if not, use test data +if username is None or token is None or len(username) == 0 or len(token) == 0: + filename_ceil = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') + ceil_ds = act.io.arm.read_arm_netcdf(filename_ceil) + filename_met = DATASETS.fetch('sgpmetE13.b1.20190101.000000.cdf') + met_ds = act.io.arm.read_arm_netcdf(filename_met) +else: + # Download and read data + results = act.discovery.download_arm_data(username, token, 'sgpceilC1.b1', '2022-01-01', '2022-01-07') + ceil_ds = act.io.arm.read_arm_netcdf(results) + results = act.discovery.download_arm_data(username, token, 'sgpmetE13.b1', '2022-01-01', '2022-01-07') + met_ds = act.io.arm.read_arm_netcdf(results) + +# Read in CEIL data and correct it +ceil_ds = act.corrections.ceil.correct_ceil(ceil_ds, -9999.0) + + +# You can use tuples if the datasets in the tuple contain a +# datastream attribute. This is required in all ARM datasets. +display = act.plotting.TimeSeriesDisplay((ceil_ds, met_ds), subplot_shape=(2,), figsize=(15, 10)) +display.plot('backscatter', 'sgpceilC1.b1', subplot_index=(0,)) +display.plot('temp_mean', 'sgpmetE13.b1', subplot_index=(1,)) +display.day_night_background('sgpmetE13.b1', subplot_index=(1,)) +plt.show() + +# You can also use a dictionary so that you can customize +# your datastream names to something that may be more useful. +display = act.plotting.TimeSeriesDisplay( + {'ceiliometer': ceil_ds, 'met': met_ds}, subplot_shape=(2,), figsize=(15, 10) +) +display.plot('backscatter', 'ceiliometer', subplot_index=(0,)) +display.plot('temp_mean', 'met', subplot_index=(1,)) +display.day_night_background('met', subplot_index=(1,)) +plt.show() + +ceil_ds.close() +met_ds.close() diff --git a/examples/workflows/plot_qc_transforms.py b/examples/workflows/plot_qc_transforms.py new file mode 100644 index 0000000000..b3ba93b01c --- /dev/null +++ b/examples/workflows/plot_qc_transforms.py @@ -0,0 +1,51 @@ +""" +Transformations and QC +---------------------- + +Built-in transformations using xarray are not +quality-control aware. This example shows how +a user should apply QC prior to performing transformations. + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt +import xarray as xr + +import act + +# Read in some sample MFRSR data and clean up the QC +filename_mfrsr = DATASETS.fetch('sgpmfrsr7nchE11.b1.20210329.070000.nc') +ds = act.io.arm.read_arm_netcdf(filename_mfrsr, cleanup_qc=True) + +# Let's resample the data to 5 minutes and take the mean +ds_5min = ds.resample(time='5min').mean() + +variable = 'diffuse_hemisp_narrowband_filter4' + +# Let's look at a before and after of one of the qc variables +print('With no QC applied before transformation') +print('Before (10 1-minute samples): ', ds['qc_' + variable].values[0:10]) +print('After: (2 5-minute averages)', ds_5min['qc_' + variable].values[0:2]) + +# That new QC variable does not make sense at all and should be an int +# What needs to happen is that we apply QC as the user see's fit to all +# variables before the transformations take place. +print('\nAverage of ', variable, ' before and after applying QC') +print('Note the change in the second value') +print('Before (2 5 - minute averages): ', ds[variable].values[0:2]) + +ds.qcfilter.datafilter(rm_assessments=['Bad', 'Indeterminate']) +ds_5minb = ds.resample(time='5min').mean() + +# Print out the corresponding variable values +print('After: (2 5 - minute averages)', ds_5minb[variable].values[0:2]) + +## Plot up the variable and qc block plot +display = act.plotting.TimeSeriesDisplay({'Original': ds, 'Average': ds_5min, 'Average_QCd': ds_5minb}, + figsize=(15, 10), subplot_shape=(2,)) +display.plot(variable, dsname='Original', subplot_index=(0,), day_night_background=True) +display.plot(variable, dsname='Average', subplot_index=(1,), day_night_background=True, label='No QC') +display.plot(variable, dsname='Average_QCd', subplot_index=(1,), day_night_background=True, label='QC') +plt.legend() +plt.show() diff --git a/examples/weighted_average_example.py b/examples/workflows/plot_weighted_average.py similarity index 61% rename from examples/weighted_average_example.py rename to examples/workflows/plot_weighted_average.py index 7ea60f5cd8..b0645456fc 100644 --- a/examples/weighted_average_example.py +++ b/examples/workflows/plot_weighted_average.py @@ -1,25 +1,32 @@ """ -========================================== -Example for calculating a weighted average -========================================== +Calculate and plot weighted means +--------------------------------- This is an example of how to calculate a weighted average from the MET TBRG, ORG and PWD. This also calculates the accumulated precipitation and displays it -.. image:: ../../weighted_average_example.png """ -import act +from arm_test_data import DATASETS import matplotlib.pyplot as plt import xarray as xr +import act + # Specify dictionary of datastreams, variables, and weights # Note, all weights should add up to 1. -cf_ds = {'sgpmetE13.b1': {'variable': ['tbrg_precip_total', 'org_precip_rate_mean', - 'pwd_precip_rate_mean_1min'], - 'weight': [0.8, 0.15, 0.05]}} +cf_ds = { + 'sgpmetE13.b1': { + 'variable': [ + 'tbrg_precip_total', + 'org_precip_rate_mean', + 'pwd_precip_rate_mean_1min', + ], + 'weight': [0.8, 0.15, 0.05], + } +} # Other way to define cf_ds # cf_ds = {'sgpmetE13.b1': {'variable': ['tbrg_precip_total'], 'weight': [0.5]}, @@ -27,17 +34,27 @@ # 'sgpmetE13.b1': {'variable': ['pwd_precip_rate_mean_1min'], 'weight': [0.25]} # } +# Get a list of filenames to use +met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf'] + ds = {} new = {} out_units = 'mm/hr' for d in cf_ds: - obj = act.io.armfiles.read_netcdf(act.tests.sample_files.EXAMPLE_MET_WILDCARD) + met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] + ds = act.io.arm.read_arm_netcdf(met_filenames) # Loop through each variable and add to data list new_da = [] for v in cf_ds[d]['variable']: - da = obj[v] - # Accumulate precip variables in new object i - obj = act.utils.data_utils.accumulate_precip(obj, v) + da = ds[v] + # Accumulate precip variables in new dataset + ds = act.utils.data_utils.accumulate_precip(ds, v) # Convert units and add to dataarray list units = da.attrs['units'] @@ -54,10 +71,10 @@ new_da = new_da[0].to_dataset() # Add to dictionary for the weighting - cf_ds[d]['object'] = new_da + cf_ds[d]['ds'] = new_da - # Add object to dictionary for plotting - new[d] = obj + # Add dataset to dictionary for plotting + new[d] = ds # Calculate weighted averages using the dict defined above data = act.utils.data_utils.ts_weighted_average(cf_ds) @@ -70,8 +87,18 @@ # Plot the accumulations display = act.plotting.TimeSeriesDisplay(new, figsize=(12, 8), subplot_shape=(1,)) display.plot('tbrg_precip_total_accumulated', dsname='sgpmetE13.b1', color='b', label='TBRG, 0.8') -display.plot('org_precip_rate_mean_accumulated', dsname='sgpmetE13.b1', color='g', label='ORG 0.15') -display.plot('pwd_precip_rate_mean_1min_accumulated', dsname='sgpmetE13.b1', color='y', label='PWD 0.05') +display.plot( + 'org_precip_rate_mean_accumulated', + dsname='sgpmetE13.b1', + color='g', + label='ORG 0.15', +) +display.plot( + 'pwd_precip_rate_mean_1min_accumulated', + dsname='sgpmetE13.b1', + color='y', + label='PWD 0.05', +) display.plot('weighted_mean_accumulated', dsname='weighted', color='k', label='Weighted Avg') display.day_night_background('sgpmetE13.b1') display.axes[0].legend() diff --git a/examples/workflows/readme.txt b/examples/workflows/readme.txt new file mode 100644 index 0000000000..c49a4f6fb6 --- /dev/null +++ b/examples/workflows/readme.txt @@ -0,0 +1,6 @@ +.. _workflow_examples: + +Workflow examples +-------------------------- + +Examples showing full workflows, including reading, applying corrections, and visualizations. diff --git a/examples/xsection_example.py b/examples/xsection_example.py deleted file mode 100644 index 47e8ccff26..0000000000 --- a/examples/xsection_example.py +++ /dev/null @@ -1,37 +0,0 @@ -""" -Example for plotting multidimensional cross sections -==================================================== - -In this example, the VISST -""" - -import act -import matplotlib.pyplot as plt -import xarray as xr - -from datetime import datetime -my_ds = act.io.armfiles.read_netcdf('twpvisst*') - -# Cross section display requires that the variable being plotted be reduced to two -# Dimensions whose coordinates can be specified by variables in the file -print(my_ds) -disp = act.plotting.XSectionDisplay(my_ds, subplot_shape=(2, 2)) -disp.plot_xsection_map(None, 'ir_temperature', x='longitude', y='latitude', - sel_kwargs={'time': datetime(2005, 7, 5, 1, 45, 00)}, - isel_kwargs={'scn_type': 0}, - cmap='Greys', vmin=200, vmax=320, subplot_index=(0, 0)) -disp.plot_xsection_map(None, 'ir_temperature', x='longitude', y='latitude', - sel_kwargs={'time': datetime(2005, 7, 5, 2, 45, 00)}, - isel_kwargs={'scn_type': 0}, - cmap='Greys', vmin=200, vmax=320, subplot_index=(1, 0)) -disp.plot_xsection_map(None, 'ir_temperature', x='longitude', y='latitude', - sel_kwargs={'time': datetime(2005, 7, 5, 3, 25, 00)}, - isel_kwargs={'scn_type': 0}, - cmap='Greys', vmin=200, vmax=320, subplot_index=(0, 1)) -disp.plot_xsection_map(None, 'ir_temperature', x='longitude', y='latitude', - sel_kwargs={'time': datetime(2005, 7, 5, 3, 55, 00)}, - isel_kwargs={'scn_type': 0}, - cmap='Greys', vmin=200, vmax=320, subplot_index=(1, 1)) - -plt.show() -my_ds.close() diff --git a/github_deploy_key_arm_doe_act.enc b/github_deploy_key_arm_doe_act.enc index 85f0a174b4..90b0d3b3f8 100644 --- a/github_deploy_key_arm_doe_act.enc +++ b/github_deploy_key_arm_doe_act.enc @@ -1 +1 @@ -gAAAAABeFfK7-mxro6ICv7wzwXEvXf3OJv275q8u4BNeWjZaIJCtC6vEV7wXGA8XgO0Q8DiWqPdbJHR3hhgL1iVFSCIXbRHvG8524V6f-FUjZhR7gGBUu8PYuc-Mf3wDKKAkMrewXF3h2PG6BpfRVOA1UiydjGrZXh_H3cQC6Ppauult1oy2XsodqgeMGyr_8lYVk2Eg8vt1D3pEh3XIQzv5QpBYLJ5y6PaVMbpZP8kXKbv8_ltKm2mgsc9Nyv7OLhw920bbA2J4Ky7_IMEOXyD2wGJ2T4Skjf7rIpOdlkMjfpZt_PmZaCD3pr1G2f0VHar71FAWVG2cVtusngjh6hiqQhQz4fsRp55xA1ssn-NtUc6TUh5aXWv2M3DdSWnX7T-L9y7xtjOH15PvB_POMRo7z6LgFzuJe4BbeCGaQFUFvyTNkmN7kuFHTL-_-j-akPY6ObpQDQfio9ieyOStBhw1a5gpwxcDGRPavCuWYUitZfuE5v958C9qmRiha57F9bv2wIVHVUiQKsM9O5ktVXcI0biRXqCV9xYzyNNMI_IjA0njngSBRqfwwizDHleoUxaXnYcEn06r3eAPRPs-dD5AVO4dPEgPinVLEcZ2XuVyIORmRmu9S41T1CDGzQR4zo3MMl4Ung7DD0XsAckYREMwtnLr3fTccrzFzEmkaxkgNxfcA7ss149nf5zBVowsgkC080EquWZ9Fl1rZ4rcn8b-EdgdM30nuzubkHY1Iw7d1NyhAPL66PLxExnWPeDknDVCA0Mgt1ZxGj6ndJqnujgdVe5X_YlBiN1FAS7TauGnVsnXBHy5EdxvmHamhiYrfxT22vI2WO8D5b2V6WB1ieqYhlfSthfiURCs6k2Fu6gh7hs9bOJt1JoO4xTdTMngP1DIimFc2btwVH_lFUc_C2WN-Us918BRlhdw84LAMEJs9PlTUllPIvCUZqxpKxUlKaq7g1FgDehD1PWFsRZieaik35_y42l7hZmYX4fGqR1t9X2vCZYMDF5x8_lJ5YLxR5-LRc8pJj-csnuKCFlk0oWDRBDzGhHniUDsOyANAncFXZ3FVcZ0RDryTISoByVxRlI3s6XyL2TwG5-LAs_mIjsJjoxxeD0BJkEQo2A2YrqRNbrXBCs7ruyo4qfzjYFAkc2wGdZHan7T9IQWE51m8e11AQgcjMFuG5ZvXH8IIBY3b1b8phEJeJwl3VSQexsK7D9ZZkY2z8ci0Hg_K0xI6GD4_kMk8_4-9r7zbS8Nt13zXx11DciJH_3xFQQBfXTxhSKqjOYbFqDpKtH081UyCa0-kqKMj4NC9GOOlGfRmcE3OCznhaj_OaqlDujKngLesJQ0J-K2higJ5XWWwhgdSJ2BoICwkJkJ-_LELGOTnJs-n6ThsQ_i0R7tIWkVHDkC5DjKAaK3OL_uDX4DYzlhysVNk4F8epzCHC2ts3_LoDjx_rciqT9a5MOxa4MmoT2FdPsaYJssEeJ7mm9JcQSBoOOO5ADqCwFpKctxQ_xiLYWIJd1x_ZPJsDa5SBodJqsDjNZnX-ue320mIIhjUlt3af7_hLlW02V6CVz2ITvrBKqZJaaXUE2KFVW4jcT4S1vSjZa9cSyjep_nGaH7W3guWOLcEnL4eeBZ8vn8K5jrpAefWTD_U5TslwnG9CFKPAHNDpDAY1tXHO0QrIZwoLldlf1p3ighKi-k0_60pG3-A-Xvl_B2iJk4i0QDr9h7ykKAP-DrDhdXNSEIjsy9Un3magCfD1Ce_sl7qsvPQJi53qQzL-gnDz_lD9azSMTyWb-6rVFLgf1csT5f8z5h3LD59JIlIqAzq8VhWoU3LpzOvyUIbbVqEvrC9kXK9ffvrfqRFOy2cDiUgJfymCBt8CRg-P8mfg9Z5oJreQbSI2YmL2dRq6hAHjYvo0GxBIacDJA8saJPaz-Hgi6LhHO-5f8HSPvFCk78musIR27_YB_eibDgj0pMZEexzmn_z2IH5T6hMcnmQVb9Is8ixHC0QWZcx7wfLDl7oKxVlgIbpIpKexei5Oy0GXT7gSfBk_VWlELhflPrjjdIFYjcRyq9x6PMto4FTMJwpbbBTQXZdYJF0PuIOnFwjDwq2XfwxZRE-jSmP_HBxIRZFHpLNcw-0TQB71YzqxAQivfsvUKbZY61wXDV4umqbXKlQfRTEql845CrLdHKCUWQdqiWqPW2npvozs8HmsT1UTdorf9eleotC2wnx4G6LlitUyJXAEiE3a6Y1Cd6_mf9dP-yDs4S4izpi0NUyQolj_Ut9GUNGuc-0mmFoUuH7S2GsgLpf2QMP4LwaaidkfvWi7KNpiOnS3GDjTbDSCcg3AWYO3lB8w8Fkl-lG9GgX8AiSzp6-uzoRBdiVF3W86R7eQlVkUXPVLXJ4GLZjzihtggWKmXVSnqDd3uwxxWRDFxQTRdbPFfT3dxnNuVl3OeXQHhe6okMq95uXwX5ot1BmP8v-bcC7viqFwdVLpYx9aKzz-EcReLeoX6GsxFOR92z0tHEQ6RnEYMfTLKW8zUUopr1HgUoE8gtWkR-KTS1a9XbT8wQoiUeMdoVL2zKzt1aQHxicP75d_kdHArqQBUsBNtcrvIAHFoEbHfeYNblnmaS-fwtBYY44dJW6hiddMmWrhBbla_vp-oh2EyPJSG_191xza-ja06GKWUs7IgZdRMzTsMdMIGJQbWKoWkbChEDllsZtjbNkoU4zSNvBbTkZR50Q-UXn78mWdB9B3RWm79Nogy6hFeFPtihYAtd1y7a4F8Idd_H2uM6mzmWrDIBSHrHjMZXyVqhDnPGVMqkmJjsgX462lS1ZIVdwlAfsQcbeZ0pX7u3SJ30y18eUHlVZoVMtXPQ2VkCtC85CdgURe6eHDqmX1zjTFHN41JeutUj3lIxELMszXIrQC_NNIrn8VL_mY9-3JROUyciUSJlyYv8MLvn5Ecvc77GmN8IppMTZQU5hAb7C0E653MmTnQgDPfRr9ux07FTFJtafNmPEc_tSoh51qzfqBleElUV1Pgcg8eV5TRIEq5YHJbKuVK8zJOXCa2Zq4y8dOa7Z1_vKWjhVhuJuxG09WWSseEFZUZGxnojSAxa4eqd_MWt4zkuV7wyomcPGU6ZxskSvtb1XgMsj1VzVyn0isqOsK1fDszLWnreQz3tJtyYLkLkHa9UjikfAWLTN5hB_k1BPMWPcVCqW43O4E-iu154CmWtE10axfOCOaRyR-oypkZIi8Gy2J6IKAihVh2a8dHnuCppu1y7OjU-F43PbbHkEJ8Uwr2S57GN-5cDRMoMXFNuPzGJRrLUEg8cmnNXQqr_qT2FGac6-mGyCmHTQNDQm35viOKUowvcZTH0oCGRUtMgFgd3Gohb29UNHj9bzjevS5TCZC7vegMCBuscBM42nGyphrmvopasasMwAN5aspoN_t3y8W0GjVj7c7C_ec_V2cfkKIWPsZutKlRQtOD_wfDZD6uiTnGOV1gN0zRKOxCj8wUWrs9O2YI7s-QZVVdNnDK23KJc0ZSqe4t9PZjO7R1805d4lHq7lOClQo8_tpN5TJ0WDiNI2s-xSIfLROW-cd4DsUkDyhaiX_Cpz3h6welBIhEpg7xlnheFn7x3TkPkVP8eU5ZnQWUcCq0DsnKSc0u03DGm5GSgn5gDciXXbnRcII4gb0-QXrQu8RoDV74JFAHmiZATZNUhnkth39YU6TGjbJC4PlyKcd8kOJ92sJKNkXHv1h3CP_AGYGQxZqrSLYqDyrYqM4szeGf_Q9Hz_Y-IGiLbSYu7EQHKsjfqnuZiFSu4ssZ9galTcPpJ-IU8gmSWhdQMr696UYdR0kkLA_TqoEy3He1-EFh4VCRcgZo6lX5OS1ZGWxdlSrM-azTMon01VihIz1Nawlh7sYCUCHrJuaaB2tUFn-eXfM25-xiuibKtYD11fO6LLNpj122FdFon0zuwjC1p5LBJzul6iCVX1ghGXeOAeDPnxU_8gm1SVLAuO8WFnlQT3CT7rtQ0BO4PbjaPNrdAreT-NvNOXU0xrZf4oTyK650n3gr8tNz8qGeWlu5wZtfCMab3hU-ARWuGIrmvvyme4XcrE4vQPXAujKoiwPssdQntWLjcxpXQezq86zr2ScoOo_jJnqKNtwaygN4Pu4NywYzbulfoFZJ_EBbWFtxPbJyE4_qOSde3JmhMx1w3BOXWwdHbjQsKhqtfYOC8uNc2RPKFHGeaV7TkTg7Xelw4MC-STapmEyqlA0Gx29eXQFNuzgZNmqshN4eVIYqH6VncdqojPw2tug-4Uzy3r3tVsLSrNoKlKBheJTcPVApJ67jXAJAFibJMRdMwQHH8FYfTow8OZQlWEli9B3etlAFCGD_UNXFvdN-xJiahT0NBgeLiAXWg7P8vNvcm3l66bbVDlrioRZErRJgZyE0Fy3F6c5EPnYFc782QDMPgB900dJfvzbjQMfekLBZrkB1OYg== \ No newline at end of file +gAAAAABeFfK7-mxro6ICv7wzwXEvXf3OJv275q8u4BNeWjZaIJCtC6vEV7wXGA8XgO0Q8DiWqPdbJHR3hhgL1iVFSCIXbRHvG8524V6f-FUjZhR7gGBUu8PYuc-Mf3wDKKAkMrewXF3h2PG6BpfRVOA1UiydjGrZXh_H3cQC6Ppauult1oy2XsodqgeMGyr_8lYVk2Eg8vt1D3pEh3XIQzv5QpBYLJ5y6PaVMbpZP8kXKbv8_ltKm2mgsc9Nyv7OLhw920bbA2J4Ky7_IMEOXyD2wGJ2T4Skjf7rIpOdlkMjfpZt_PmZaCD3pr1G2f0VHar71FAWVG2cVtusngjh6hiqQhQz4fsRp55xA1ssn-NtUc6TUh5aXWv2M3DdSWnX7T-L9y7xtjOH15PvB_POMRo7z6LgFzuJe4BbeCGaQFUFvyTNkmN7kuFHTL-_-j-akPY6ObpQDQfio9ieyOStBhw1a5gpwxcDGRPavCuWYUitZfuE5v958C9qmRiha57F9bv2wIVHVUiQKsM9O5ktVXcI0biRXqCV9xYzyNNMI_IjA0njngSBRqfwwizDHleoUxaXnYcEn06r3eAPRPs-dD5AVO4dPEgPinVLEcZ2XuVyIORmRmu9S41T1CDGzQR4zo3MMl4Ung7DD0XsAckYREMwtnLr3fTccrzFzEmkaxkgNxfcA7ss149nf5zBVowsgkC080EquWZ9Fl1rZ4rcn8b-EdgdM30nuzubkHY1Iw7d1NyhAPL66PLxExnWPeDknDVCA0Mgt1ZxGj6ndJqnujgdVe5X_YlBiN1FAS7TauGnVsnXBHy5EdxvmHamhiYrfxT22vI2WO8D5b2V6WB1ieqYhlfSthfiURCs6k2Fu6gh7hs9bOJt1JoO4xTdTMngP1DIimFc2btwVH_lFUc_C2WN-Us918BRlhdw84LAMEJs9PlTUllPIvCUZqxpKxUlKaq7g1FgDehD1PWFsRZieaik35_y42l7hZmYX4fGqR1t9X2vCZYMDF5x8_lJ5YLxR5-LRc8pJj-csnuKCFlk0oWDRBDzGhHniUDsOyANAncFXZ3FVcZ0RDryTISoByVxRlI3s6XyL2TwG5-LAs_mIjsJjoxxeD0BJkEQo2A2YrqRNbrXBCs7ruyo4qfzjYFAkc2wGdZHan7T9IQWE51m8e11AQgcjMFuG5ZvXH8IIBY3b1b8phEJeJwl3VSQexsK7D9ZZkY2z8ci0Hg_K0xI6GD4_kMk8_4-9r7zbS8Nt13zXx11DciJH_3xFQQBfXTxhSKqjOYbFqDpKtH081UyCa0-kqKMj4NC9GOOlGfRmcE3OCznhaj_OaqlDujKngLesJQ0J-K2higJ5XWWwhgdSJ2BoICwkJkJ-_LELGOTnJs-n6ThsQ_i0R7tIWkVHDkC5DjKAaK3OL_uDX4DYzlhysVNk4F8epzCHC2ts3_LoDjx_rciqT9a5MOxa4MmoT2FdPsaYJssEeJ7mm9JcQSBoOOO5ADqCwFpKctxQ_xiLYWIJd1x_ZPJsDa5SBodJqsDjNZnX-ue320mIIhjUlt3af7_hLlW02V6CVz2ITvrBKqZJaaXUE2KFVW4jcT4S1vSjZa9cSyjep_nGaH7W3guWOLcEnL4eeBZ8vn8K5jrpAefWTD_U5TslwnG9CFKPAHNDpDAY1tXHO0QrIZwoLldlf1p3ighKi-k0_60pG3-A-Xvl_B2iJk4i0QDr9h7ykKAP-DrDhdXNSEIjsy9Un3magCfD1Ce_sl7qsvPQJi53qQzL-gnDz_lD9azSMTyWb-6rVFLgf1csT5f8z5h3LD59JIlIqAzq8VhWoU3LpzOvyUIbbVqEvrC9kXK9ffvrfqRFOy2cDiUgJfymCBt8CRg-P8mfg9Z5oJreQbSI2YmL2dRq6hAHjYvo0GxBIacDJA8saJPaz-Hgi6LhHO-5f8HSPvFCk78musIR27_YB_eibDgj0pMZEexzmn_z2IH5T6hMcnmQVb9Is8ixHC0QWZcx7wfLDl7oKxVlgIbpIpKexei5Oy0GXT7gSfBk_VWlELhflPrjjdIFYjcRyq9x6PMto4FTMJwpbbBTQXZdYJF0PuIOnFwjDwq2XfwxZRE-jSmP_HBxIRZFHpLNcw-0TQB71YzqxAQivfsvUKbZY61wXDV4umqbXKlQfRTEql845CrLdHKCUWQdqiWqPW2npvozs8HmsT1UTdorf9eleotC2wnx4G6LlitUyJXAEiE3a6Y1Cd6_mf9dP-yDs4S4izpi0NUyQolj_Ut9GUNGuc-0mmFoUuH7S2GsgLpf2QMP4LwaaidkfvWi7KNpiOnS3GDjTbDSCcg3AWYO3lB8w8Fkl-lG9GgX8AiSzp6-uzoRBdiVF3W86R7eQlVkUXPVLXJ4GLZjzihtggWKmXVSnqDd3uwxxWRDFxQTRdbPFfT3dxnNuVl3OeXQHhe6okMq95uXwX5ot1BmP8v-bcC7viqFwdVLpYx9aKzz-EcReLeoX6GsxFOR92z0tHEQ6RnEYMfTLKW8zUUopr1HgUoE8gtWkR-KTS1a9XbT8wQoiUeMdoVL2zKzt1aQHxicP75d_kdHArqQBUsBNtcrvIAHFoEbHfeYNblnmaS-fwtBYY44dJW6hiddMmWrhBbla_vp-oh2EyPJSG_191xza-ja06GKWUs7IgZdRMzTsMdMIGJQbWKoWkbChEDllsZtjbNkoU4zSNvBbTkZR50Q-UXn78mWdB9B3RWm79Nogy6hFeFPtihYAtd1y7a4F8Idd_H2uM6mzmWrDIBSHrHjMZXyVqhDnPGVMqkmJjsgX462lS1ZIVdwlAfsQcbeZ0pX7u3SJ30y18eUHlVZoVMtXPQ2VkCtC85CdgURe6eHDqmX1zjTFHN41JeutUj3lIxELMszXIrQC_NNIrn8VL_mY9-3JROUyciUSJlyYv8MLvn5Ecvc77GmN8IppMTZQU5hAb7C0E653MmTnQgDPfRr9ux07FTFJtafNmPEc_tSoh51qzfqBleElUV1Pgcg8eV5TRIEq5YHJbKuVK8zJOXCa2Zq4y8dOa7Z1_vKWjhVhuJuxG09WWSseEFZUZGxnojSAxa4eqd_MWt4zkuV7wyomcPGU6ZxskSvtb1XgMsj1VzVyn0isqOsK1fDszLWnreQz3tJtyYLkLkHa9UjikfAWLTN5hB_k1BPMWPcVCqW43O4E-iu154CmWtE10axfOCOaRyR-oypkZIi8Gy2J6IKAihVh2a8dHnuCppu1y7OjU-F43PbbHkEJ8Uwr2S57GN-5cDRMoMXFNuPzGJRrLUEg8cmnNXQqr_qT2FGac6-mGyCmHTQNDQm35viOKUowvcZTH0oCGRUtMgFgd3Gohb29UNHj9bzjevS5TCZC7vegMCBuscBM42nGyphrmvopasasMwAN5aspoN_t3y8W0GjVj7c7C_ec_V2cfkKIWPsZutKlRQtOD_wfDZD6uiTnGOV1gN0zRKOxCj8wUWrs9O2YI7s-QZVVdNnDK23KJc0ZSqe4t9PZjO7R1805d4lHq7lOClQo8_tpN5TJ0WDiNI2s-xSIfLROW-cd4DsUkDyhaiX_Cpz3h6welBIhEpg7xlnheFn7x3TkPkVP8eU5ZnQWUcCq0DsnKSc0u03DGm5GSgn5gDciXXbnRcII4gb0-QXrQu8RoDV74JFAHmiZATZNUhnkth39YU6TGjbJC4PlyKcd8kOJ92sJKNkXHv1h3CP_AGYGQxZqrSLYqDyrYqM4szeGf_Q9Hz_Y-IGiLbSYu7EQHKsjfqnuZiFSu4ssZ9galTcPpJ-IU8gmSWhdQMr696UYdR0kkLA_TqoEy3He1-EFh4VCRcgZo6lX5OS1ZGWxdlSrM-azTMon01VihIz1Nawlh7sYCUCHrJuaaB2tUFn-eXfM25-xiuibKtYD11fO6LLNpj122FdFon0zuwjC1p5LBJzul6iCVX1ghGXeOAeDPnxU_8gm1SVLAuO8WFnlQT3CT7rtQ0BO4PbjaPNrdAreT-NvNOXU0xrZf4oTyK650n3gr8tNz8qGeWlu5wZtfCMab3hU-ARWuGIrmvvyme4XcrE4vQPXAujKoiwPssdQntWLjcxpXQezq86zr2ScoOo_jJnqKNtwaygN4Pu4NywYzbulfoFZJ_EBbWFtxPbJyE4_qOSde3JmhMx1w3BOXWwdHbjQsKhqtfYOC8uNc2RPKFHGeaV7TkTg7Xelw4MC-STapmEyqlA0Gx29eXQFNuzgZNmqshN4eVIYqH6VncdqojPw2tug-4Uzy3r3tVsLSrNoKlKBheJTcPVApJ67jXAJAFibJMRdMwQHH8FYfTow8OZQlWEli9B3etlAFCGD_UNXFvdN-xJiahT0NBgeLiAXWg7P8vNvcm3l66bbVDlrioRZErRJgZyE0Fy3F6c5EPnYFc782QDMPgB900dJfvzbjQMfekLBZrkB1OYg== diff --git a/guides/ACT_Roadmap.pdf b/guides/ACT_Roadmap_1.pdf similarity index 100% rename from guides/ACT_Roadmap.pdf rename to guides/ACT_Roadmap_1.pdf diff --git a/guides/ACT_Roadmap_2.pdf b/guides/ACT_Roadmap_2.pdf new file mode 100644 index 0000000000..951c11acf5 Binary files /dev/null and b/guides/ACT_Roadmap_2.pdf differ diff --git a/guides/GUIDE_V2.rst b/guides/GUIDE_V2.rst new file mode 100644 index 0000000000..f276012691 --- /dev/null +++ b/guides/GUIDE_V2.rst @@ -0,0 +1,78 @@ +=========================== +ACT Version 2 Release Guide +=========================== + +In preparation for version 2.0.0 of ACT, codes were standardized for consistency purposes as further defined in the `Contributor's Guide `_. These changes will break some users code as the API has changed. This guide will detail the changes for each module. + +Discovery +========= +Functionality has not changed but the naming of the API have changed for all discovery scripts to be more consistent and streamlined in their naming. + ++------------------------------+------------------------------+ +|Existing Function | New Function | ++==============================+==============================+ +| get_armfiles.download_data | arm.download_arm_data | ++------------------------------+------------------------------+ +| get_armfiles.get_arm_doi | arm.get_arm_doi | ++------------------------------+------------------------------+ +| get_asos.get_asos | asos.get_asos_data | ++------------------------------+------------------------------+ +| get_airnow.* | airnow.* Func Names Same | ++------------------------------+------------------------------+ +| get_cropscape.croptype | cropscape.get_crop_type | ++------------------------------+------------------------------+ +| get_noaapsl. | noaapsl. | +| download_noaa_psl_data | download_noaa_psl_data | ++------------------------------+------------------------------+ +| get_neon.get_site_products | neon.get_neon_site_products | ++------------------------------+------------------------------+ +| get_neon.get_product_avail | neon.get_neon_product_avail | ++------------------------------+------------------------------+ +| get_neon.download_neon_data | neon.download_neon_data | ++------------------------------+------------------------------+ +| get_surfrad.download_surfrad | surfrad.download_surfrad_data| ++------------------------------+------------------------------+ + +IO +== +Similar to the discovery module, functionality has not changed but the naming convention has for similar reasoning. + ++------------------------------+------------------------------+ +|Existing Function | New Function | ++==============================+==============================+ +| armfiles | act.io.arm | ++------------------------------+------------------------------+ +| armfiles.read_netcdf() | arm.read_arm_netcdf | ++------------------------------+------------------------------+ +| armfiles.read_mmcr | arm.read_arm_mmcr | ++------------------------------+------------------------------+ +| csvfiles | csv | ++------------------------------+------------------------------+ + +Plotting +======== +A major change to how secondary y-axes are handled was implemented in the TimeSeriesDisplay and DistributionDisplay modules. Currently, those plotting routines return a 1-D array of display axes. This has always made the secondary y-axis more difficult to configure and use. In the new version, it will return a 2-D array of display axes [[left axes, right axes]] to make it simpler to utilize. + +HistogramDisplay is being renamed to DistributionDisplay to be more inclusive of the variety of visualization types that are housed there. Additionally there are changes to two of the plot names to be more consistent with the others. + ++------------------------------+------------------------------+ +|Existing Function | New Function | ++==============================+==============================+ +| HistogramDisplay. | DistributionDisplay. | +| plot_stacked_bar_graph | plot_stacked_bar | ++------------------------------+------------------------------+ +| HistogramDisplay. | DistributionDisplay. | +| plot_stairstep_graph | plot_stairstep | ++------------------------------+------------------------------+ + +Stamen maps for the GeoographicPlotDisplay are being retired. Those maps will no longer be availabe at the end of October 2023. The function was updated so that users can pass an image tile in. + +QC +== +* The default behaviour for act.qc.qcfilter.datafilter is changing so that del_qc_var=False. Previously, the default was to delete the QC variable after applying the QC. Going forward it will not default to deleting the QC variables. + +* ARM DQR webservice is being upgraded and the corresponding function will be upgraded to utilize this new webservice. + +Tests +===== +Test data that have been historically stored in the act/tests/data area will be moved to a separate repository in order to reduce the package install size. diff --git a/guides/act_cheatsheet.pdf b/guides/act_cheatsheet.pdf index 127b9f5ad7..8608275c4f 100644 Binary files a/guides/act_cheatsheet.pdf and b/guides/act_cheatsheet.pdf differ diff --git a/guides/act_cheatsheet.tex b/guides/act_cheatsheet.tex index 9d9e8530f5..819bc7a6bd 100644 --- a/guides/act_cheatsheet.tex +++ b/guides/act_cheatsheet.tex @@ -85,7 +85,7 @@ %---------------------------------------------------------------- {\bf\textsc{ACT Cheat Sheet}\vspace{0.5em}} % Poster title {\textsc{\ A C T \ \ \ \ \ C h e a t \ \ \ \ \ S h e e t\ \hspace{12pt}}} -{\textsc{Learn More About ACT at https://arm-doe.github.io/ACT/ \hspace{12pt}}} +{\textsc{Learn More About ACT at https://arm-doe.github.io/ACT/ \hspace{12pt}}} %------------------------------------------------ @@ -93,16 +93,21 @@ %------------------------------------------------ \headerbox{ACT Introduction}{name=introduction,column=0,row=0,span=1}{ \begin{flushleft} -The Atmospheric Commutity Toolkit (ACT) is a package for connecting Atmospheric data users to -the data. Has the ability to download, read, and visualize multi-file datasets from multiple -data sources. Currently, multi-panel timeseries plots are supported. +The Atmospheric data Community Toolkit (ACT) is an open source Python +toolkit for working with atmospheric time-series datasets of varying +dimensions. The toolkit has functions for every part of the scientific +process; discovery, IO, quality control, corrections, retrievals, +visualization, and analysis. It is a community platform for sharing +code with the goal of reducing duplication of effort and better +connecting the science community with programs such as the Atmospheric +Radiation Measurement (ARM) User Facility. \end{flushleft} } %------------------------------------------------ % Installation %------------------------------------------------ -\headerbox{Installation}{name=installation,column=0,row=.124,span=1}{ +\headerbox{Installation}{name=installation,column=0,row=.177,span=1}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} @@ -116,12 +121,20 @@ \\ \-\hspace{0.1cm} \$ git clone https://github.com/ARM-DOE/ACT.git\\ \\ -\-\hspace{0.1cm} $\bullet$ To install in your home directory, use:\\ -\-\hspace{0.1cm} \$ python setup.py install --user\\ +\-\hspace{0.1cm} $\bullet$ To install, use:\\ +\-\hspace{0.1cm} \$ python setup.py install\\ \\ -\-\hspace{0.1cm} $\bullet$ To install for all users on Unix/Linux:\\ -\-\hspace{0.1cm} \$ python setup.py build\\ -\-\hspace{0.1cm} \$ sudo python setup.py install\\ +To install ACT using Anaconda or Miniconda, create\\ +an environment and activate it:\\ +\\ +\-\hspace{0.4cm} $\bullet$ Then create a conda environment:\\ +\-\hspace{0.4cm} \$ conda create -n act python=3.9\\ +\\ +\-\hspace{0.4cm} $\bullet$ Activate the ACT environment:\\ +\-\hspace{0.4cm} \$ conda activate act\\ +\\ +\-\hspace{0.4cm} $\bullet$ Then install ACT:\\ +\-\hspace{0.4cm} \$ conda install -c conda-forge act-atmos\\ \\ \end{tabular} @@ -131,7 +144,7 @@ %------------------------------------------------ % Contact Information %------------------------------------------------ -\headerbox{Contact Information}{name=contact information,column=0,row=.395,span=1}{ +\headerbox{Contact Information}{name=contact information,column=0,row=.537,span=1}{ \begin{flushleft} \textbf{ACT GitHub Issues Forum:} @@ -142,6 +155,8 @@ \textbf{Email:} \\ \-\hspace{0.4cm} atheisen@anl.gov\\ +\-\hspace{0.4cm} mgrover@anl.gov\\ +\-\hspace{0.4cm} zsherman@anl.gov\\ \-\hspace{0.4cm} rjackson@anl.gov\\ \end{flushleft} } @@ -149,7 +164,7 @@ %------------------------------------------------ % Contributing %------------------------------------------------ -\headerbox{Contributing}{name=contributing,column=0,row=.52,span=1}{ +\headerbox{Contributing}{name=contributing,column=0,row=.674,span=1}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} @@ -178,12 +193,13 @@ % Getting Started %------------------------------------------------ -\headerbox{Getting Started}{name=getting started,column=0,row=.765}{ +\headerbox{Getting Started}{name=getting started,column=0,row=.906}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} $>$$>$$>$ import act & To import ACT.\\ -$>$$>$$>$ print(act.\_\_version\_\_) & Check version. +$>$$>$$>$ print(act.\_\_version\_\_) & Check version.\\ +\\ \end{tabular} \end{flushleft} } @@ -192,16 +208,26 @@ % Corrections %------------------------------------------------ -\headerbox{Corrections}{name=corrections,column=0,row=.845}{ +\headerbox{Corrections}{name=corrections,column=1,row=0}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} -$>$$>$$>$ obj = act.corrections.ceil.correct\_ciel(obj)\\ -\-\hspace{0.2cm} $\bullet$ This procedure corrects celiometer data by filling\\ -\-\hspace{0.5cm} all zero and negative values of backscatter with\\ -\-\hspace{0.5cm} fill\_value and then converting the backscatter\\ -\-\hspace{0.5cm} data into logarithmic space.\\ +$>$$>$$>$ obj = act.corrections.correct\_ceil(obj)\\ +\-\hspace{0.2cm} $\bullet$ This procedure corrects celiometer data.\\ +\\ +$>$$>$$>$ obj = act.corrections.correct\_dl(obj)\\ +\-\hspace{0.2cm} $\bullet$ This procedure corrects doppler lidar data.\\ \\ +$>$$>$$>$ obj = act.corrections.correct\_mpl(obj)\\ +\-\hspace{0.2cm} $\bullet$ This procedure corrects MPL data.\\ +\\ +$>$$>$$>$ obj = act.corrections.correct\_rl(obj)\\ +\-\hspace{0.2cm} $\bullet$ This procedure corrects raman lidar data.\\ +\\ +$>$$>$$>$ obj = act.corrections.correct\_wind(obj)\\ +\-\hspace{0.2cm} $\bullet$ This procedure corrects wind speed and direction.\\ +\-\hspace{0.5cm} for ship motion based on equations from NOAA\\ +\-\hspace{0.5cm} tech.\\ \\ \end{tabular} \end{flushleft} @@ -212,12 +238,12 @@ % Discovery %------------------------------------------------ -\headerbox{Discovery}{name=discovery,column=1,row=0}{ +\headerbox{Discovery}{name=discovery,column=1,row=.26}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} $>$$>$$>$ act.discovery.download\_data(\\ \-\hspace{1.2cm} username, token, datastream, startdate,\\ -\-\hspace{1.2cm} enddate, output=None)\\ +\-\hspace{1.2cm} enddate[,...])\\ \-\hspace{0.2cm} $\bullet$ This programmatic interface allows users to query\\ \-\hspace{0.5cm} and automate machine-to-machine downloads of\\ \-\hspace{0.5cm} ARM data. This tool uses a REST URL and\\ @@ -229,12 +255,46 @@ \\ \-\hspace{0.2cm} $\bullet$ This will also eliminate the manual step of\\ \-\hspace{0.5cm} following a link in an email to download data.\\ -\-\hspace{0.5cm} More information about the REST API and tools +\-\hspace{0.5cm} More information about the REST API and tools\\ \-\hspace{0.5cm} can be found on ARM Live:\\ \-\hspace{0.5cm} https://adc.arm.gov/armlive/\#scripts\\ \\ \-\hspace{0.2cm} $\bullet$ To login/register for an access token:\\ \-\hspace{0.5cm} https://adc.arm.gov/armlive/livedata/home\\ +\\ +$>$$>$$>$ act.discovery.croptype(lat, lon, year)\\ +\-\hspace{0.2cm} $\bullet$ Function for working with the CropScape\\ +\-\hspace{0.5cm} API to get a crop type based on the lat,lon, and\\ +\-\hspace{0.5cm} year entered.\\ +\\ +$>$$>$$>$ act.discovery.download\_noaa\_psl\_data(\\ +\-\hspace{1.5cm} site, instrument[, ...])\\ +\-\hspace{0.2cm} $\bullet$ Function to download data from the NOAA\\ +\-\hspace{0.5cm} PSL Profiler Network Data Library\\ +\-\hspace{0.5cm} https://psl.noaa.gov/data/obs/datadisplay/\\ +\\ +$>$$>$$>$ act.discovery.get\_airnow\_forecast(token[,...])\\ +\-\hspace{0.2cm} $\bullet$ This tool will get current or historical\\ +\-\hspace{0.5cm} AQI values and categories for a reporting area\\ +\-\hspace{0.5cm} by either Zip code or Lat/Lon coordinate.\\ +\\ +$>$$>$$>$ act.discovery.get\_airnow\_obs(token[,...])\\ +\-\hspace{0.2cm} $\bullet$ This tool will get current or historical obs\\ +\-\hspace{0.5cm} AQI values and categories for a reporting area\\ +\-\hspace{0.5cm} by either Zip code or Lat/Lon coordinate.\\ +\\ +$>$$>$$>$ act.discovery.get\_asos(time\_window[,...])\\ +\-\hspace{0.2cm} $\bullet$ Returns all of the station observations from\\ +\-\hspace{0.5cm} the Iowa Mesonet from either a given latitude\\ +\-\hspace{0.5cm} and longitude window or a given station code.\\ +\\ +$>$$>$$>$ act.discovery.get\_airnow\_bounded\_obs(\\ +\-\hspace{1.5cm} token[,...])\\ +\-\hspace{0.2cm} $\bullet$ Get AQI values or data concentrations\\ +\-\hspace{0.5cm} for a specific date and time range and set of\\ +\-\hspace{0.5cm} parameters within a geographic area of intrest\\ +\-\hspace{0.5cm} https://docs.airnowapi.org/\\ +\\ \end{tabular} \end{flushleft} @@ -244,70 +304,113 @@ % Input and Output Data %------------------------------------------------ -\headerbox{Input and Output Data}{name=input and output data,column=1,row=.295}{ +\headerbox{Input and Output Data}{name=input and output data,column=2,row=0}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} -$>$$>$$>$ act\_obj = act.io.armfiles.read\_netcdf(\\ -\-\hspace{1.2cm} filenames, concat\_dim='time',\\ -\-\hspace{1.2cm} return\_None=False, **kwargs)\\ -\-\hspace{0.2cm} $\bullet$ Returns xarray.Dataset with stored data and\\ -\-\hspace{0.5cm} metadata from a user-defined query of ARM-\\ -\-\hspace{0.5cm} standard netCDF files from a single datastream.\\ +$>$$>$$>$ act\_obj = act.io.create\_obj\_from\_arm\_dod(\\ +\-\hspace{1.5cm} proc, set\_dims[,...])\\ +\-\hspace{0.2cm} $\bullet$ Queries the ARM DOD api and builds an\\ +\-\hspace{0.5cm} object based on the ARM DOD and the\\ +\-\hspace{0.5cm} dimension sizes that are passed in.\\ \\ -$>$$>$$>$ flag = act.io.armfiles.check\_arm\_standards(\\ -\-\hspace{1.2cm} act\_obj)\\ +$>$$>$$>$ flag = act.io.check\_arm\_standards(act\_obj)\\ \-\hspace{0.2cm} $\bullet$ Checks to see if an xarray dataset conforms\\ \-\hspace{0.5cm} to ARM standards.\\ \\ -$>$$>$$>$ act.io.dataset.ACTAccessor(act\_obj)\\ -\-\hspace{0.2cm} $\bullet$ The xarray accessor for ACT data structures. This\\ -\-\hspace{0.5cm} adds functionality that includes storing the times\\ -\-\hspace{0.5cm} and names of each file in the dataset. In addition,\\ -\-\hspace{0.5cm} the datastream can be given a name and a site.\\ +$>$$>$$>$ act\_obj = act.io.read\_netcdf(filenames[,...])\\ +\-\hspace{0.2cm} $\bullet$ Returns xarray.Dataset with stored data and\\ +\-\hspace{0.5cm} metadata from a user-defined query of ARM-\\ +\-\hspace{0.5cm} standard netCDF files from a single datastream.\\ \\ -$>$$>$$>$ act.io.csvfiles.read\_csv(\\ -\-\hspace{1.2cm} filename, sep=', ', engine='python',\\ -\-\hspace{1.2cm} column\_names=None, skipfooter=0,\\ -\-\hspace{1.2cm} **kwargs)\\ +$>$$>$$>$ act.io.read\_csv(filename[,...])\\ \-\hspace{0.2cm} $\bullet$ Returns an xarray.Dataset with stored data and\\ \-\hspace{0.5cm} metadata from user-defined query of CSV files.\\ \\ -$>$$>$$>$ clean\_dataset = act.io.clean.CleanDataset(\\ -\-\hspace{1.2cm} act\_obj)\\ -\-\hspace{0.2cm} $\bullet$ Class containing functions for cleaning\\ -\-\hspace{0.5cm} dataset. More on the functions below after\\ -\-\hspace{0.5cm} defining the clean dataset object.\\ -$>$$>$$>$ clean\_dataset.clean\_arm\_qc(\\ -\-\hspace{1.2cm} override\_cf\_flag=True,\\ -\-\hspace{1.2cm} clean\_units\_string=True,\\ -\-\hspace{1.2cm} correct\_valid\_min\_max=True)\\ -\-\hspace{0.2cm} $\bullet$ Function to clean up xarray object QC variables.\\ -$>$$>$$>$ clean\_dataset.clean\_arm\_state\_variables(\\ -\-\hspace{1.2cm} variables, override\_cf\_flag=True,\\ -\-\hspace{1.2cm} clean\_units\_string=True, integer\_flag=True\\ -\-\hspace{0.2cm} $\bullet$ Function to clean up state variables to use\\ -\-\hspace{0.5cm} more CF style.\\ -$>$$>$$>$ clean\_dataset.cleanup(\\ -\-\hspace{1.2cm} cleanup\_arm\_qc=True,\\ -\-\hspace{1.2cm} clean\_arm\_state\_vars=None,\\ -\-\hspace{1.2cm} handle\_missing\_value=True,\\ -\-\hspace{1.2cm} link\_qc\_variables=True, **kwargs\\ -\-\hspace{0.2cm} $\bullet$ Wrapper method to automatically call all the\\ -\-\hspace{0.5cm} standard methods for obj cleanup.\\ +$>$$>$$>$ act.io.read\_sigma\_mplv5(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Returns xarray.Dataset with stored data and\\ +\-\hspace{0.5cm} metadata from a user-defined SIGMA MPL V5\\ +\-\hspace{0.5cm} files.\\ +\\ +$>$$>$$>$ act.io.read\_gml(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to call or guess what reading NOAA\\ +\-\hspace{0.5cm} GML daga routine to use.\\ \\ +$>$$>$$>$ act.io.read\_gml\_co2(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to read carbon dioxide data from NOAA\\ +\-\hspace{0.5cm} GML.\\ \\ +$>$$>$$>$ act.io.read\_gml\_halo(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to read Halocarbon data from NOAA\\ +\-\hspace{0.5cm} GML.\\ +\\ +$>$$>$$>$ act.io.read\_gml\_met(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to read meteorological data from\\ +\-\hspace{0.5cm} NOAA GML.\\ +\\ +$>$$>$$>$ act.io.read\_gml\_ozone(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to read ozone data from NOAA GML.\\ +\\ +$>$$>$$>$ act.io.read\_gml\_radiation(filename)\\ +\-\hspace{0.2cm} $\bullet$ Function to read radiation data from NOAA GML.\\ +\\ +$>$$>$$>$ act.io.read\_hk\_file(filename)\\ +\-\hspace{0.2cm} $\bullet$ This procedure will read in an SP2 housekeeping\\ +\-\hspace{0.5cm} file\\ +\\ +$>$$>$$>$ act.io.read\_psl\_parsivel(filename)\\ +\-\hspace{0.2cm} $\bullet$ Returns xarray.Dataset with stored data and\\ +\-\hspace{0.5cm} metadata from a defined NOAA PSL parsivel.\\ +\\ +$>$$>$$>$ act.io.read\_psl\_wind\_profiler(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Returns xarray.Dataset with stored data and\\ +\-\hspace{0.5cm} metadata from a user-defined NOAA PSL\\ +\-\hspace{0.5cm} wind profiler file.\\ +\\ +$>$$>$$>$ act.io.read\_psl\_wind\_profiler\_temperature(\\ +\-\hspace{1.5cm} filename)\\ +\-\hspace{0.2cm} $\bullet$ Returns xarray.Dataset with stored data and\\ +\-\hspace{0.5cm} metadata from a user-defined NOAA PSL\\ +\-\hspace{0.5cm} wind profiler temperature file.\\ +\\ +$>$$>$$>$ act.io.read\_sp2(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ Loads a binary SP2 raw data file and returns all\\ +\-\hspace{0.5cm} of the wave forms into an xarray Dataset.\\ +\\ +$>$$>$$>$ act.io.read\_sp2\_dat(filename[,...])\\ +\-\hspace{0.2cm} $\bullet$ This reads the .dat files that generate the\\ +\-\hspace{0.5cm} intermediate parameters used by the Igor\\ +\-\hspace{0.5cm} processing. Wildcards are supported.\\ \\ \end{tabular} \end{flushleft} } +\end{poster} +\newpage + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%% SECOND PAGE %%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{poster} +{ +headerborder=closed, colspacing=0.8em, bgColorOne=white, bgColorTwo=white, borderColor=lightblue, headerColorOne=black, headerColorTwo=lightblue, +headerFontColor=white, boxColorOne=white, textborder=roundedleft, eyecatcher=true, headerheight=0.06\textheight, headershape=roundedright, headerfont=\Large\bf\textsc, linewidth=2pt +} +%---------------------------------------------------------------- +% Title +%---------------------------------------------------------------- +{\bf\textsc{ACT Cheat Sheet}\vspace{0.5em}} % Poster title +{\textsc{\ A C T \ \ \ \ \ C h e a t \ \ \ \ \ S h e e t\ \hspace{12pt}}} +{\textsc{Learn More About ACT at https://arm-doe.github.io/ACT/ \hspace{12pt}}} + %------------------------------------------------ % Plotting %------------------------------------------------ -\headerbox{Plotting}{name=plotting,column=2,span=1,row=0}{ +\headerbox{Plotting}{name=plotting,column=0,span=1,row=0}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} @@ -343,16 +446,16 @@ This subclass contains routines that are specific to\\ plotting time series plots from data.\\ \\ -$>$$>$$>$ dis = act.plotting.TimeSeriesDisplay(\\ +$>$$>$$>$ display = act.plotting.TimeSeriesDisplay(\\ \-\hspace{1.2cm} obj, subplot\_shape=(1, ), ds\_name=None,\\ \-\hspace{1.2cm} **kwargs)\\ \\ -$>$$>$$>$ dis.plot(field[, ...])\\ +$>$$>$$>$ display.plot(field[, ...])\\ \-\hspace{0.2cm} $\bullet$ Makes a timeseries plot.\\ $>$$>$$>$ display.plot\_barbs\_from\_spd\_dir(dir\_field[, ...]\\ \-\hspace{0.2cm} $\bullet$ This procedure will make a wind barb plot\\ \-\hspace{0.5cm} timeseries.\\ -$>$$>$$>$ dis.plot\_barbs\_from\_u\_v(u\_field, v\_field\\ +$>$$>$$>$ display.plot\_barbs\_from\_u\_v(u\_field, v\_field\\ \-\hspace{1.2cm} [, ...])\\ \-\hspace{0.2cm} $\bullet$ This function will plot a wind barb timeseries\\ \-\hspace{0.5cm} from u and v wind data. If pres\_field is given, a\\ @@ -363,8 +466,8 @@ \-\hspace{0.2cm} $\bullet$ This will plot a time-height cross section\\ \-\hspace{0.5cm} from 1D datasets using nearest neighbor\\ \-\hspace{0.5cm} interpolation on a regular time by height grid.\\ -$>$$>$$>$ dis.time\_height\_scatter(\\ -\-\hspace{1.2cm} data\_field=None[, ...])\\ +$>$$>$$>$ display.time\_height\_scatter(\\ +\-\hspace{1.2cm} data\_field, dsname[, ...])\\ \-\hspace{0.2cm} $\bullet$ Create a time series plot of altitude and data\\ \-\hspace{0.5cm} variable with color also indicating value with a\\ \-\hspace{0.5cm} color bar.\\ @@ -380,61 +483,29 @@ \-\hspace{1.2cm} obj, subplot\_shape=(1, ), ds\_name=None,\\ \-\hspace{1.2cm} **kwargs)\\ \\ -$>$$>$$>$ display.add\_subplots(\\ -\-\hspace{1.2cm} subplot\_shape=(1, ), **kwargs)\\ -\-\hspace{0.2cm} $\bullet$ Adds subplots to the Display object. The\\ -\-\hspace{0.5cm} current figure in the object will be deleted\\ -\-\hspace{0.5cm} and overwritten.\\ $>$$>$$>$ display.plot\_from\_spd\_and\_dir(\\ \-\hspace{1.2cm} spd\_field, dir\_field, p\_field, t\_field,\\ \-\hspace{1.2cm} td\_field[, ...])\\ \-\hspace{0.2cm} $\bullet$ This plot will make a sounding plot from wind\\ \-\hspace{0.5cm} data that is given in speed and direction.\\ - +\\ +$>$$>$$>$ display.plot\_from\_u\_and\_v(\\ +\-\hspace{1.2cm} u\_field, v\_field, p\_field, t\_field,\\ +\-\hspace{1.2cm} td\_field[, ...])\\ +\-\hspace{0.2cm} $\bullet$ This function will plot a Skew-T from a sounding\\ +\-\hspace{0.5cm} dataset. The wind data must be given in u and v.\\ +\\ \end{tabular} \end{flushleft} - -} - -\end{poster} -\newpage - -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -%%%%%%%%%%%%%%%%%% SECOND PAGE %%%%%%%%%%%%%%%%%%%%% -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - -\begin{poster} -{ -headerborder=closed, colspacing=0.8em, bgColorOne=white, bgColorTwo=white, borderColor=lightblue, headerColorOne=black, headerColorTwo=lightblue, -headerFontColor=white, boxColorOne=white, textborder=roundedleft, eyecatcher=true, headerheight=0.06\textheight, headershape=roundedright, headerfont=\Large\bf\textsc, linewidth=2pt } -%---------------------------------------------------------------- -% Title -%---------------------------------------------------------------- -{\bf\textsc{ACT Cheat Sheet}\vspace{0.5em}} % Poster title -{\textsc{\ A C T \ \ \ \ \ C h e a t \ \ \ \ \ S h e e t\ \hspace{12pt}}} -{\textsc{Learn More About ACT at https://arm-doe.github.io/ACT/ \hspace{12pt}}} - %------------------------------------------------ % Plotting Continued %------------------------------------------------ -\headerbox{Plotting}{name=plotting,column=0,span=1,row=0}{ +\headerbox{Plotting Continued}{name=plotting,column=1,span=1,row=0}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} -\multicolumn{2}{l}{\cellcolor[HTML]{DDFFFF}\bf SkewTDisplay Continued}\\ -\\ -$>$$>$$>$ display.plot\_from\_u\_and\_v(\\ -\-\hspace{1.2cm} u\_field, v\_field, p\_field, t\_field,\\ -\-\hspace{1.2cm} td\_field[, ...])\\ -\-\hspace{0.2cm} $\bullet$ This function will plot a Skew-T from a\\ -\-\hspace{0.5cm} sounding dataset. The wind data must be given\\ -\-\hspace{0.5cm} in u and v. -\end{tabular} -\\ -\begin{tabular}{@{}ll@{}} -\\ \multicolumn{2}{l}{\cellcolor[HTML]{DDFFFF}\bf WindRoseDisplay} \\ \\ A class for handing wind rose plots..\\ @@ -445,6 +516,10 @@ \\ $>$$>$$>$ display.plot(dir\_field, spd\_field[, ...])\\ \-\hspace{0.2cm} $\bullet$ Makes the wind rose plot from the given dataset.\\ +\\ +$>$$>$$>$ display.plot\_data(dir\_field, spd\_field, data\_field)\\ +\-\hspace{0.2cm} $\bullet$ Makes a data rose plot in line or boxplot\\ +\-\hspace{0.5cm} form from the given data.\\ \end{tabular} \begin{tabular}{@{}ll@{}} @@ -459,32 +534,146 @@ \\ $>$$>$$>$ display.plot\_xsection(dsname, varname[, ...])\\ \-\hspace{0.2cm} $\bullet$ This function plots a cross section whose x and\\ -\-\hspace{0.5cm} y coordinates are specified by the variable names\\ -\-\hspace{0.5cm} either provided by the user or automatically\\ -\-\hspace{0.5cm} detected by xarray.\\ +\-\hspace{0.5cm} y coordinates are specified by the variable names.\\ +\\ $>$$>$$>$ display.plot\_xsection\_map(\\ \-\hspace{1.2cm} dsname, varname[, ...])\\ \-\hspace{0.2cm} $\bullet$ Plots a cross section of 2D data on a geographical\\ \-\hspace{0.5cm} map.\\ \end{tabular} +\begin{tabular}{@{}ll@{}} +\\ +\multicolumn{2}{l}{\cellcolor[HTML]{DDFFFF}\bf GeographicPlotDisplay} \\ +\\ +A class for making geographic tracer plot of aircraft,\\ +ship or other moving platform plot.\\ +\\ +$>$$>$$>$ display = act.plotting.GeographicPlotDisplay(\\ +\-\hspace{1.2cm} obj, ds\_name=None, **kwargs)\\ +\\ +$>$$>$$>$ display.geoplot(data\_field[, ...])\\ +\-\hspace{0.2cm} $\bullet$ Creates a latitude and longitude plot of a time\\ +\-\hspace{0.5cm} series data set with data values indicated by color.\\ +\end{tabular} + +\begin{tabular}{@{}ll@{}} +\\ +\multicolumn{2}{l}{\cellcolor[HTML]{DDFFFF}\bf DistributionDisplay} \\ +\\ +Class used to make histogram plots.\\ +\\ +$>$$>$$>$ display = act.plotting.DistributionDisplay(\\ +\-\hspace{1.2cm} obj, subplot\_shape=(1, ), ds\_name=None,\\ +\-\hspace{1.2cm} **kwargs)\\ +\\ +$>$$>$$>$ display.plot\_heatmap(x\_field, y\_field[, ...])\\ +\-\hspace{0.2cm} $\bullet$ This procedure will plot a heatmap of a histogram\\ +\-\hspace{0.5cm} from 2 variables.\\ +\\ +$>$$>$$>$ display.plot\_stacked\_bar\_graph(field[, ...])\\ +\-\hspace{0.2cm} $\bullet$ This procedure will plot a stacked bar graph of a\\ +\-\hspace{0.5cm} histogram.\\ +\\ +$>$$>$$>$ display.plot\_stairstep\_graph(field[, ...])\\ +\-\hspace{0.2cm} $\bullet$ This procedure will plot a stairstep plot of a\\ +\-\hspace{0.5cm} histogram.\\ +\end{tabular} + \end{flushleft} +} +%------------------------------------------------ +% QC +%------------------------------------------------ + +\headerbox{QC}{name=qc,column=1,span=1,row=.85}{ +\begin{flushleft} +\begin{tabular}{@{}ll@{}} +$>$$>$$>$ act.qc.add\_dqr\_to\_qc(obj[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to query the ARM DQR web service\\ +\-\hspace{0.5cm} control test for reports and add as a new quality\\ +\-\hspace{0.5cm} to ancillary quality control variable.\\ +\\ +$>$$>$$>$ act.qc.apply\_supplemental\_qc(obj[,...])\\ +\-\hspace{0.2cm} $\bullet$ Apply flagging from supplemental QC file\\ +\-\hspace{0.5cm} by adding new QC tests.\\ +\\ +\end{tabular} +\end{flushleft} +} + +%------------------------------------------------ +% QC Continued +%------------------------------------------------ + +\headerbox{QC Continued}{name=qc,column=2,span=1,row=0}{ +\begin{flushleft} +\begin{tabular}{@{}ll@{}} +Classes listed in blue have functions that can be\\ +found in ACT's documentation:\\ +https://arm-doe.github.io/ACT/API/index.html\\ +\\ +\multicolumn{2}{l}{\cellcolor[HTML]{DDFFFF}\bf CleanDataset} \\ +\\ +Class for cleaning up QC variables to standard\\ +cf-compliance.\\ +\\ +$>$$>$$>$ act.qc.CleanDataset(obj)\\ +\\ +\multicolumn{2}{l}{\cellcolor[HTML]{DDFFFF}\bf QCFilter} \\ +\\ +Class for building quality control variables containing\\ +arrays for filtering data based on a set of test condition\\ +typically based on the values in the data fields.\\ +\\ +$>$$>$$>$ act.qc.QCFilter(obj)\\ +\\ +\multicolumn{2}{l}{\cellcolor[HTML]{DDFFFF}\bf QCTests} \\ +\\ +Method to perform a time series comparison test\\ +between two Xarray Datasets to detect a shift in\\ +time based on two similar variables.\\ +\\ +$>$$>$$>$ act.qc.QCTests(obj)\\ +\\ +\end{tabular} +\end{flushleft} } %------------------------------------------------ % Retrievals %------------------------------------------------ -\headerbox{Retrievals}{name=retrievals,column=0,span=1,row=.527}{ +\headerbox{Retrievals}{name=retrievals,column=2,span=1,row=.386}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} -$>$$>$$>$ ds = act.retrievals.calculate\_stability\_indicies(\\ -\-\hspace{1.2cm} ds, temp\_name='temperature',\\ -\-\hspace{1.2cm} td\_name='dewpoint\_temperature',\\ -\-\hspace{1.2cm} p\_name='pressure', moving\_ave\_window=0)\\ +$>$$>$$>$ act.retrievals.calculate\_stability\_indicies(\\ +\-\hspace{1.2cm} ds[,...])\\ \-\hspace{0.2cm} $\bullet$ Calculates stability indices and adds it\\ \-\hspace{0.5cm} to the data set. +\\ +$>$$>$$>$ act.retrievals.aeri2irt(\\ +\-\hspace{1.2cm} aeri\_ds[,...])\\ +\-\hspace{0.2cm} $\bullet$ This function will integrate over the correct\\ +\-\hspace{0.5cm} wavenumber values to produce the effective IRT\\ +\-\hspace{0.5cm} temperature.\\ +\\ +$>$$>$$>$ act.retrievals.calculate\_pbl\_liu\_liang(\\ +\-\hspace{1.2cm} ds[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function for calculating the PBL height from a\\ +\-\hspace{0.5cm} radiosonde profile using the Liu-Liang 2010\\ +\-\hspace{0.5cm} technique.\\ +\\ +$>$$>$$>$ act.retrievals.calc\_sp2\_diams\_masses(\\ +\-\hspace{1.2cm} ds[,...])\\ +\-\hspace{0.2cm} $\bullet$ Calculates the scattering and incandescence\\ +\-\hspace{0.5cm} diameters/BC masses for each particle.\\ +\\ +$>$$>$$>$ act.retrievals.calculate\_precipitable\_water(\\ +\-\hspace{1.2cm} ds[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to calculate precipitable water\\ +\-\hspace{0.5cm} vapor from ARM sondewnpn b1 data.\\ \end{tabular} \end{flushleft} @@ -494,33 +683,26 @@ % Utilities %------------------------------------------------ -\headerbox{Utilities}{name=utilities,column=0,span=1,row=0.65}{ +\headerbox{Utilities}{name=utilities,column=2,span=1,row=0.746}{ \begin{flushleft} \begin{tabular}{@{}ll@{}} -$>$$>$$>$ dates = act.utils.datetime\_utils.dates\_between(\\ -\-\hspace{1.2cm} sdate, edate)\\ -\-\hspace{0.2cm} $\bullet$ Ths procedure returns all of the dates between\\ -\-\hspace{0.5cm} sdate and edate.\\ -\\ -$>$$>$$>$ time, data = act.utils.data\_utils.add\_in\_nan(\\ -\-\hspace{1.2cm} time, data)\\ -\-\hspace{0.2cm} $\bullet$ This procedure adds in NaNs for given time\\ -\-\hspace{0.5cm} periods in time when there is no corresponding\\ -\-\hspace{0.5cm} data available. This is useful for timeseries that\\ -\-\hspace{0.5cm} have irregular gaps in data.\\ -\\ -$>$$>$$>$ val = act.utils.data\_utils.get\_missing\_value(\\ -\-\hspace{1.2cm} variable, default=-9999,\\ -\-\hspace{1.2cm} add\_if\_missing\_in\_obj=False,\\ -\-\hspace{1.2cm} use\_FillValue=False, nodefault=False)\\ -\-\hspace{0.2cm} $\bullet$ Method to get missing value from missing\_value\\ -\-\hspace{0.5cm} or \_FillValue attribute.\\ -\\ -$>$$>$$>$ ds = act.utils.data\_utils.assign\_coordinates(\\ -\-\hspace{1.2cm} ds, coord\_list)\\ -\-\hspace{0.2cm} $\bullet$ This procedure will create a new ACT dataset\\ -\-\hspace{0.5cm} whose coordinates are designated to be the\\ -\-\hspace{0.5cm} variables in a given list. +$>$$>$$>$ ds = act.utils.create\_pyart\_obj(obj)\\ +\-\hspace{0.2cm} $\bullet$ Produces a Py-ART object from an ACT object.\\ +\\ +$>$$>$$>$ ds = act.utils.calculate\_dqr\_times(obj[,...])\\ +\-\hspace{0.2cm} $\bullet$ Function to retrieve start and end times of\\ +\-\hspace{0.5cm} missing or bad data.\\ +\\ +$>$$>$$>$ ds = act.utils.height\_adjusted\_pressure(obj[,...])\\ +\-\hspace{0.2cm} $\bullet$ Converts pressure for change in height.\\ +\\ +$>$$>$$>$ ds = act.utils.convert\_units(data, in\_units\\ +\-\hspace{1.5cm} out\_units)\\ +\-\hspace{0.2cm} $\bullet$ Converts units of a data array.\\ +\\ +$>$$>$$>$ ds = act.utils.accumulate\_precip(obj, variable)\\ +\-\hspace{0.2cm} $\bullet$ Accumulate rain rates from an act object and\\ +\-\hspace{0.5cm} insert variable back into act object. \end{tabular} \end{flushleft} diff --git a/guides/baposter.cls b/guides/baposter.cls index b72fa7a4f1..576605a905 100644 --- a/guides/baposter.cls +++ b/guides/baposter.cls @@ -11,11 +11,11 @@ %% Copyright (C) 2007-2011 Brian Amberg %% Copyright (C) 2011 Reinhold Kainhofer %% -%% 29. September 2011: -%% - Finally fixed confusion with paper size handling and landscape. This required seperate handling of papersizes +%% 29. September 2011: +%% - Finally fixed confusion with paper size handling and landscape. This required seperate handling of papersizes %% known to the geometry package and other packages. %% 26. September 2011: -%% - Reverted drawing of faded borders to manual method, as the current result does not work with evince, +%% - Reverted drawing of faded borders to manual method, as the current result does not work with evince, %% and produced spurious colored boxes with okular and acroread. %% - Added one more example due to popular request %% 16. September 2011: @@ -156,7 +156,6 @@ %\RequirePackage[l2tabu, orthodox]{nag} \usetikzlibrary{decorations} \usetikzlibrary{fadings} -\usetikzlibrary{snakes} \usetikzlibrary{calc} @@ -281,7 +280,7 @@ bmargin=\baposter@basemargin, lmargin=\baposter@basemarginleft, rmargin=\baposter@basemarginright, - ]{geometry} + ]{geometry} \usepackage{pgfpages} \if@landscape diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000000..06353c6682 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,8 @@ +[tool.black] +line-length = 100 +target-version = ['py38'] +skip-string-normalization = true +ignore = ["act/io/arm.py"] + +[tool.check-manifest] +ignore = ["docs/*", "ci/*"] diff --git a/act/tests/pytest.ini b/pytest.ini similarity index 91% rename from act/tests/pytest.ini rename to pytest.ini index b2ee972e6f..221a865ed1 100644 --- a/act/tests/pytest.ini +++ b/pytest.ini @@ -1,3 +1,3 @@ [pytest] -markers = +markers = mpl_image_compare: Just registering the third party marker test so pytest stops issuing a warning. diff --git a/requirements-dev.txt b/requirements-dev.txt index 8ba29aa1af..e6b9ede8f9 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -11,3 +11,4 @@ matplotlib numpydoc sphinx-copybutton sphinx_rtd_theme +pre-commit diff --git a/requirements.txt b/requirements.txt index 3530f5e642..9098993baf 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,15 +1,21 @@ -# List required packages in this file, one per line. -pyproj -numpy -pandas -matplotlib -scipy -xarray -dask -distributed -pint -requests -six -skyfield -cftime -netcdf4 +# List required packages in this file, one per line. +pyproj +numpy +pandas +matplotlib +scipy +xarray +dask +distributed +pint +requests +six +skyfield +cftime +netcdf4 +lazy_loader +fsspec +metpy +lxml +cmweather +aiohttp>=3.9.0b1 \ No newline at end of file diff --git a/scripts/ads.py b/scripts/ads.py new file mode 100644 index 0000000000..5a61ff51fb --- /dev/null +++ b/scripts/ads.py @@ -0,0 +1,910 @@ +""" +ARM Data Surveyor (ADS) +Command line wrapper around ACT. Not all +features of ACT are included as options in ADS. +Please see the examples.txt for examples on how +to use ADS. + +Author: Jason Hemedinger + +""" + +import argparse +import re +import json +import glob +import ast +import pathlib +import matplotlib.pyplot as plt +import numpy as np +import act + +try: + import cartopy.crs as ccrs + CARTOPY_AVAILABLE = True +except ImportError: + CARTOPY_AVAILABLE = False + + +def option_error_check(args, error_fields, check_all=False): + ''' + This will check the args object for keys to see if they are set. If + at least one key is not set will or all keys wiht check_all set + will print error message and exit. + ''' + + if not isinstance(error_fields, (list, tuple)): + error_fields = [error_fields] + + print_error = False + how_many = 'one' + if check_all is False and not any([vars(args)[ii] for ii in error_fields]): + print_error = True + + if check_all is True and not all([vars(args)[ii] for ii in error_fields]): + print_error = True + how_many = 'all' + + if print_error: + prepend = '--' + for ii, value in enumerate(error_fields): + if not value.startswith(prepend): + error_fields[ii] = prepend + value + + print(f"\n{pathlib.Path(__file__).name}: error: {how_many} of the arguments " + f"{' '.join(error_fields)} is requried\n") + exit() + + +def find_drop_vars(args): + ''' + This will check if more than one file is to be read. If so read one file + and get list of variables to not read based on the fields arguments and + corresponding QC or dimention variables. This will significantly speed up + the reading time for reading many files. + ''' + files = glob.glob(args.file_path) + drop_vars = [] + if len(files) > 1: + ds = act.io.arm.read_arm_netcdf(files[0]) + ds.clean.cleanup() + drop_vars = set(ds.data_vars) + keep_vars = ['latitude', 'longitude'] + if args.field is not None: + keep_vars.append(args.field) + + if args.fields is not None: + keep_vars.extend(set(args.fields)) + + if args.wind_fields is not None: + keep_vars.extend(set(args.wind_fields)) + + if args.station_fields is not None: + keep_vars.extend(set(args.station_fields)) + + if args.latitude is not None: + keep_vars.append(args.latitude) + + if args.longitude is not None: + keep_vars.append(args.longitude) + + if args.x_field is not None: + keep_vars.append(args.x_field) + + if args.y_field is not None: + keep_vars.append(args.y_field) + + if args.u_wind is not None: + keep_vars.append(args.u_wind) + + if args.v_wind is not None: + keep_vars.append(args.v_wind) + + if args.p_field is not None: + keep_vars.append(args.p_field) + + if args.t_field is not None: + keep_vars.append(args.t_field) + + if args.td_field is not None: + keep_vars.append(args.td_field) + + if args.spd_field is not None: + keep_vars.append(args.spd_field) + + if args.dir_field is not None: + keep_vars.append(args.dir_field) + + keep_vars_additional = [] + for var_name in keep_vars: + qc_var_name = ds.qcfilter.check_for_ancillary_qc( + var_name, add_if_missing=False, cleanup=False) + if qc_var_name is not None: + keep_vars_additional.append(qc_var_name) + + try: + keep_vars_additional.extend(ds[var_name].dims) + except KeyError: + pass + + drop_vars = drop_vars - set(keep_vars) - set(keep_vars_additional) + + return drop_vars + + +def geodisplay(args): + ds = act.io.arm.read_arm_netcdf(args.file_path) + + dsname = args.dsname + if dsname == _default_dsname: + try: + dsname = ds.attrs['datastream'] + except KeyError: + pass + + display = act.plotting.GeographicPlotDisplay({dsname: ds}, + figsize=args.figsize) + + display.geoplot(data_field=args.field, lat_field=args.latitude, + lon_field=args.longitude, dsname=dsname, + cbar_label=args.cb_label, title=args.set_title, + plot_buffer=args.plot_buffer, stamen=args.stamen, + tile=args.tile, cartopy_feature=args.cfeatures, + cmap=args.cmap, text=args.text, gridlines=args.gridlines, + projection=args.projection, **args.kwargs) + + plt.savefig(args.out_path) + plt.show() + plt.close(display.fig) + + ds.close() + + +def skewt(args): + ds = act.io.arm.read_arm_netcdf(args.file_path) + + subplot_index = args.subplot_index + + dsname = args.dsname + if dsname == _default_dsname: + try: + dsname = ds.attrs['datastream'] + except KeyError: + pass + + display = act.plotting.SkewTDisplay({dsname: ds}, figsize=args.figsize) + + if args.from_u_and_v: + display.plot_from_u_and_v(u_field=args.u_wind, v_field=args.v_wind, + p_field=args.p_field, t_field=args.t_field, + td_field=args.td_field, + subplot_index=subplot_index, + dsname=dsname, show_parcel=args.show_parcel, + p_levels_to_plot=args.plevels_plot, + shade_cape=args.shade_cape, + shade_cin=args.shade_cin, + set_title=args.set_title, + plot_barbs_kwargs=args.plot_barbs_kwargs, + plot_kwargs=args.plot_kwargs) + + if args.from_spd_and_dir: + display.plot_from_spd_and_dir(spd_field=args.spd_field, + dir_field=args.dir_field, + p_field=args.p_field, + t_field=args.t_field, + td_field=args.td_field, + dsname=dsname, + **args.kwargs) + + plt.savefig(args.out_path) + plt.show() + plt.close(display.fig) + + ds.close() + + +def xsection(args): + ds = act.io.arm.read_arm_netcdf(args.file_path) + + subplot_index = args.subplot_index + + dsname = args.dsname + if dsname == _default_dsname: + try: + dsname = ds.attrs['datastream'] + except KeyError: + pass + + display = act.plotting.XSectionDisplay({dsname: ds}, figsize=args.figsize) + + if args.plot_xsection: + display.plot_xsection(dsname=dsname, varname=args.field, + x=args.x_field, y=args.y_field, + subplot_index=subplot_index, + sel_kwargs=args.sel_kwargs, + isel_kwargs=args.isel_kwargs, **args.kwargs) + + if args.xsection_map: + display.plot_xsection_map(dsname=dsname, varname=args.field, + subplot_index=subplot_index, + coastlines=args.coastlines, + background=args.background, + **args.kwargs) + + plt.savefig(args.out_path) + plt.show() + plt.close(display.fig) + + ds.close() + + +def wind_rose(args): + + drop_vars = find_drop_vars(args) + + ds = act.io.arm.read_arm_netcdf(args.file_path, drop_variables=drop_vars) + + subplot_index = args.subplot_index + + dsname = args.dsname + if dsname == _default_dsname: + try: + dsname = ds.attrs['datastream'] + except KeyError: + pass + + display = act.plotting.WindRoseDisplay({dsname: ds}, + figsize=args.figsize) + + display.plot(dir_field=args.dir_field, spd_field=args.spd_field, + subplot_index=subplot_index, + dsname=dsname, cmap=args.cmap, + set_title=args.set_title, + num_dirs=args.num_dir, spd_bins=args.spd_bins, + tick_interval=args.tick_interval, **args.kwargs) + plt.savefig(args.out_path) + plt.show() + plt.close(display.fig) + + ds.close() + + +def timeseries(args): + + drop_vars = find_drop_vars(args) + + ds = act.io.arm.read_arm_netcdf(args.file_path, drop_variables=drop_vars) + + if args.cleanup: + ds.clean.cleanup() + + subplot_shape = args.subplot_shape + subplot_index = args.subplot_index + + dsname = args.dsname + if dsname == _default_dsname: + try: + dsname = ds.attrs['datastream'] + except KeyError: + pass + + display = act.plotting.TimeSeriesDisplay( + {dsname: ds}, figsize=args.figsize, + subplot_shape=subplot_shape) + + options = ['plot', 'barbs_spd_dir', 'barbs_u_v', 'xsection_from_1d', + 'time_height_scatter', 'qc', 'fill_between', 'multi_panel'] + option_error_check(args, options) + + if args.plot: + option_error_check(args, 'field') + if args.set_yrange is not None: + yrange = list(map(float, args.set_yrange)) + else: + yrange = args.set_yrange + display.plot( + field=args.field, dsname=dsname, cmap=args.cmap, + set_title=args.set_title, add_nan=args.add_nan, + subplot_index=subplot_index, + use_var_for_y=args.var_y, + day_night_background=args.day_night, + invert_y_axis=args.invert_y_axis, + abs_limits=args.abs_limits, time_rng=args.time_rng, + assessment_overplot=args.assessment_overplot, + assessment_overplot_category=args.overplot_category, + assessment_overplot_category_color=args.category_color, + force_line_plot=args.force_line_plot, labels=args.labels, + cbar_label=args.cb_label, secondary_y=args.secondary_y, + y_rng=yrange, + **args.kwargs) + + if args.barbs_spd_dir: + display.plot_barbs_from_spd_dir( + dir_field=args.dir_field, + spd_field=args.spd_field, + pres_field=args.p_field, + dsname=dsname, + **args.kwargs) + + if args.barbs_u_v: + display.plot_barbs_from_u_v( + u_field=args.u_wind, v_field=args.v_wind, + pres_field=args.p_field, dsname=dsname, + set_title=args.set_title, + invert_y_axis=args.invert_y_axis, + day_night_background=args.day_night, + num_barbs_x=args.num_barb_x, + num_barbs_y=args.num_barb_y, + use_var_for_y=args.var_y, + subplot_index=subplot_index, + **args.kwargs) + + if args.xsection_from_1d: + option_error_check(args, 'field') + + display.plot_time_height_xsection_from_1d_data( + data_field=args.field, pres_field=args.p_field, + dsname=dsname, set_title=args.set_title, + day_night_background=args.day_night, + num_time_periods=args.num_time_periods, + num_y_levels=args.num_y_levels, + invert_y_axis=args.invert_y_axis, + subplot_index=subplot_index, + cbar_label=args.cb_label, + **args.kwargs) + + if args.time_height_scatter: + option_error_check(args, 'field') + + display.time_height_scatter( + data_field=args.field, dsname=dsname, + cmap=args.cmap, alt_label=args.alt_label, + alt_field=args.alt_field, cb_label=args.cb_label, + **args.kwargs) + + if args.qc: + option_error_check(args, 'field') + display.qc_flag_block_plot( + data_field=args.field, dsname=dsname, + subplot_index=subplot_index, + time_rng=args.time_rng, + assessment_color=args.assessment_color, + **args.kwargs) + + if args.fill_between: + option_error_check(args, 'field') + + display.fill_between( + field=args.field, dsname=dsname, + subplot_index=subplot_index, + set_title=args.set_title, + secondary_y=args.secondary_y, + **args.kwargs) + + if args.multi_panel: + option_error_check(args, ['fields', 'plot_type'], check_all=True) + + for i, j, k in zip(args.fields, subplot_index, args.plot_type): + if k == 'plot': + display.plot( + field=i, dsname=dsname, cmap=args.cmap, + set_title=args.set_title, add_nan=args.add_nan, + subplot_index=j, + use_var_for_y=args.var_y, + day_night_background=args.day_night, + invert_y_axis=args.invert_y_axis, + abs_limits=args.abs_limits, time_rng=args.time_rng, + assessment_overplot=args.assessment_overplot, + assessment_overplot_category=args.overplot_category, + assessment_overplot_category_color=args.category_color, + force_line_plot=args.force_line_plot, labels=args.labels, + cbar_label=args.cb_label, secondary_y=args.secondary_y, + **args.kwargs) + + if k == 'qc': + display.qc_flag_block_plot( + data_field=i, dsname=dsname, + subplot_index=j, + time_rng=args.time_rng, + assessment_color=args.assessment_color, + **args.kwargs) + + plt.savefig(args.out_path) + plt.show() + plt.close(display.fig) + + ds.close() + + +def histogram(args): + + drop_vars = find_drop_vars(args) + + ds = act.io.arm.read_arm_netcdf(args.file_path, drop_variables=drop_vars) + + subplot_shape = args.subplot_shape + subplot_index = args.subplot_index + + dsname = args.dsname + if dsname == _default_dsname: + try: + dsname = ds.attrs['datastream'] + except KeyError: + pass + + display = act.plotting.DistributionDisplay( + {dsname: ds}, figsize=args.figsize, + subplot_shape=subplot_shape) + + if args.stacked_bar_graph: + display.plot_stacked_bar_graph( + field=args.field, dsname=dsname, + bins=args.bins, density=args.density, + sortby_field=args.sortby_field, + sortby_bins=args.sortby_bins, + set_title=args.set_title, + subplot_index=subplot_index, + **args.kwargs) + + if args.size_dist: + display.plot_size_distribution( + field=args.field, bins=args.bin_field, + time=args.time, dsname=dsname, + set_title=args.set_title, + subplot_index=subplot_index, + **args.kwargs) + + if args.stairstep: + display.plot_stairstep_graph( + field=args.field, dsname=dsname, + bins=args.bins, density=args.density, + sortby_field=args.sortby_field, + sortby_bins=args.sortby_bins, + set_title=args.set_title, + subplot_index=subplot_index, + **args.kwargs) + + if args.heatmap: + display.plot_heatmap( + x_field=args.x_field, y_field=args.y_field, + dsname=dsname, x_bins=args.x_bins, + y_bins=args.y_bins, set_title=args.set_title, + density=args.density, + subplot_index=subplot_index, **args.kwargs) + + plt.savefig(args.out_path) + plt.show() + plt.close(display.fig) + + ds.close() + + +def contour(args): + files = glob.glob(args.file_path) + files.sort() + + time = args.time + data = {} + fields = {} + wind_fields = {} + station_fields = {} + for f in files: + ds = act.io.arm.read_arm_netcdf(f) + data.update({f: ds}) + fields.update({f: args.fields}) + wind_fields.update({f: args.wind_fields}) + station_fields.update({f: args.station_fields}) + + display = act.plotting.ContourDisplay(data, figsize=args.figsize) + + if args.create_contour: + display.create_contour(fields=fields, time=time, function=args.function, + grid_delta=args.grid_delta, + grid_buffer=args.grid_buffer, + subplot_index=args.subplot_index, + **args.kwargs) + + if args.contourf: + display.contourf(x=args.x, y=args.y, z=args.z, + subplot_index=args.subplot_index, + **args.kwargs) + + if args.plot_contour: + display.contour(x=args.x, y=args.y, z=args.z, + subplot_index=args.subplot_index, + **args.kwargs) + + if args.vectors_spd_dir: + display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, + mesh=args.mesh, function=args.function, + grid_delta=args.grid_delta, + grid_buffer=args.grid_buffer, + subplot_index=args.subplot_index, + **args.kwargs) + + if args.barbs: + display.barbs(x=args.x, y=args.y, u=args.u, v=args.v, + subplot_index=args.subplot_index, + **args.kwargs) + + if args.plot_station: + display.plot_station(fields=station_fields, time=time, + text_color=args.text_color, + subplot_index=args.subplot_index, + **args.kwargs) + + plt.savefig(args.out_path) + plt.show() + plt.close(display.fig) + + ds.close() + + +# Define new funciton for argparse to allow specific rules for +# parsing files containing arguments. This works by this function being +# called for each line in the configuration file. +def convert_arg_line_to_args(line): + for arg in line.split(): + if not arg.strip(): # If empty line or only white space skip + continue + if arg.startswith('#'): # If line starts with comment skip + break + yield arg + + +def main(): + prefix_char = '@' + parser = argparse.ArgumentParser( + description=(f'Create plot from a data file. Can use command line opitons ' + f'or point to a configuration file using {prefix_char} character.')) + + # Allow user to reference a file by using the @ symbol for a specific + # argument value + parser = argparse.ArgumentParser(fromfile_prefix_chars=prefix_char) + + # Update the file parsing logic to skip commented lines + parser.convert_arg_line_to_args = convert_arg_line_to_args + + parser.add_argument('-f', '--file_path', type=str, required=True, + help=('Required: Full path to file for creating Plot. For multiple ' + 'files use terminal syntax for matching muliple files. ' + 'For example "sgpmetE13.b1.202007*.*.nc" will match all files ' + 'for the month of July in 2020. Need to use double quotes ' + 'to stop terminal from expanding the search, and let the ' + 'python program perform search.')) + out_path_default = 'image.png' + parser.add_argument('-o', '--out_path', type=str, default=out_path_default, + help=("Full path filename to use for saving image. " + "Default is '{out_path_default}'. If only a path is given " + "will use that path with image name '{out_path_default}', " + "else will use filename given.")) + parser.add_argument('-fd', '--field', type=str, default=None, + help='Name of the field to plot') + parser.add_argument('-fds', '--fields', nargs='+', + type=str, default=None, + help='Name of the fields to use to plot') + parser.add_argument('-wfs', '--wind_fields', nargs='+', + type=str, default=None, + help='Wind field names used to plot') + parser.add_argument('-sfs', '--station_fields', nargs='+', + type=str, default=None, + help='Station field names to plot sites') + default = 'lat' + parser.add_argument('-lat', '--latitude', type=str, default=default, + help=f"Name of latitude variable in file. Default is '{default}'") + default = 'lon' + parser.add_argument('-lon', '--longitude', type=str, default=default, + help=f"Name of longitude variable in file. Default is '{default}'") + parser.add_argument('-xf', '--x_field', type=str, default=None, + help='Name of variable to plot on x axis') + parser.add_argument('-yf', '--y_field', type=str, default=None, + help='Name of variable to plot on y axis') + parser.add_argument('-x', type=np.array, + help='x coordinates or grid for z') + parser.add_argument('-y', type=np.array, + help='y coordinates or grid for z') + parser.add_argument('-z', type=np.array, + help='Values over which to contour') + default = 'u_wind' + parser.add_argument('-u', '--u_wind', type=str, default=default, + help=f"File variable name for u_wind wind component. Default is '{default}'") + default = 'v_wind' + parser.add_argument('-v', '--v_wind', type=str, default=default, + help=f"File variable name for v_wind wind compenent. Default is '{default}'") + default = 'pres' + parser.add_argument('-pf', '--p_field', type=str, default=default, + help=f"File variable name for pressure. Default is '{default}'") + default = 'tdry' + parser.add_argument('-tf', '--t_field', type=str, default=default, + help=f"File variable name for temperature. Default is '{default}'") + default = 'dp' + parser.add_argument('-tdf', '--td_field', type=str, default=default, + help=f"File variable name for dewpoint temperature. Default is '{default}'") + default = 'wspd' + parser.add_argument('-sf', '--spd_field', type=str, default=default, + help=f"File variable name for wind speed. Default is '{default}'") + default = 'deg' + parser.add_argument('-df', '--dir_field', type=str, default=default, + help=f"File variable name for wind direction. Default is '{default}'") + parser.add_argument('-al', '--alt_label', type=str, default=None, + help='Altitude axis label') + default = 'alt' + parser.add_argument('-af', '--alt_field', type=str, default=default, + help=f"File variable name for altitude. Default is '{default}'") + global _default_dsname + _default_dsname = 'act_datastream' + parser.add_argument('-ds', '--dsname', type=str, default=_default_dsname, + help=f"Name of datastream to plot. Default is '{_default_dsname}'") + default = '(0, )' + parser.add_argument('-si', '--subplot_index', type=ast.literal_eval, + default=default, + help=f'Index of the subplot via tuple syntax. ' + f'Example for two plots is "(0,), (1,)". ' + f"Default is '{default}'") + default = (1, ) + parser.add_argument('-ss', '--subplot_shape', nargs='+', type=int, + default=default, + help=(f'The number of (rows, columns) ' + f'for the subplots in the display. ' + f'Default is {default}')) + plot_type_options = ['plot', 'qc'] + parser.add_argument('-pt', '--plot_type', nargs='+', type=str, + help=f'Type of plot to make. Current options include: ' + f'{plot_type_options}') + parser.add_argument('-vy', '--var_y', type=str, default=None, + help=('Set this to the name of a data variable in ' + 'the Dataset to use as the y-axis variable ' + 'instead of the default dimension.')) + parser.add_argument('-plp', '--plevels_plot', + type=np.array, default=None, + help='Pressure levels to plot the wind barbs on.') + parser.add_argument('-cbl', '--cb_label', type=str, default=None, + help='Colorbar label to use') + parser.add_argument('-st', '--set_title', type=str, default=None, + help='Title for the plot') + default = 0.08 + parser.add_argument('-pb', '--plot_buffer', type=float, default=default, + help=(f'Buffer to add around data on plot in lat ' + f'and lon dimension. Default is {default}')) + default = 'terrain-background' + parser.add_argument('-sm', '--stamen', type=str, default=default, + help=f"Dataset to use for background image. Default is '{default}'") + default = 8 + parser.add_argument('-tl', '--tile', type=int, default=default, + help=f'Tile zoom to use with background image. Default is {default}') + parser.add_argument('-cfs', '--cfeatures', nargs='+', type=str, default=None, + help='Cartopy feature to add to plot') + parser.add_argument('-txt', '--text', type=json.loads, default=None, + help=('Dictionary of {text:[lon,lat]} to add to plot. ' + 'Can have more than one set of text to add.')) + default = 'rainbow' + parser.add_argument('-cm', '--cmap', default=default, + help=f"colormap to use. Defaut is '{default}'") + parser.add_argument('-abl', '--abs_limits', nargs='+', type=float, + default=(None, None), + help=('Sets the bounds on plot limits even if data ' + 'values exceed those limits. Y axis limits. Default is no limits.')) + parser.add_argument('-tr', '--time_rng', nargs='+', type=float, default=None, + help=('List or tuple with (min,max) values to set the ' + 'x-axis range limits')) + default = 20 + parser.add_argument('-nd', '--num_dir', type=int, default=default, + help=(f'Number of directions to splot the wind rose into. ' + f'Default is {default}')) + parser.add_argument('-sb', '--spd_bins', nargs='+', type=float, default=None, + help='Bin boundaries to sort the wind speeds into') + default = 3 + parser.add_argument('-ti', '--tick_interval', type=int, default=default, + help=(f'Interval (in percentage) for the ticks ' + f'on the radial axis. Default is {default}')) + parser.add_argument('-ac', '--assessment_color', type=json.loads, + default=None, + help=('dictionary lookup to override default ' + 'assessment to color')) + default = False + parser.add_argument('-ao', '--assessment_overplot', + default=default, action='store_true', + help=(f'Option to overplot quality control colored ' + f'symbols over plotted data using ' + f'flag_assessment categories. Default is {default}')) + default = {'Incorrect': ['Bad', 'Incorrect'], + 'Suspect': ['Indeterminate', 'Suspect']} + parser.add_argument('-oc', '--overplot_category', type=json.loads, default=default, + help=(f'Look up to categorize assessments into groups. ' + f'This allows using multiple terms for the same ' + f'quality control level of failure. ' + f'Also allows adding more to the defaults. Default is {default}')) + default = {'Incorrect': 'red', 'Suspect': 'orange'} + parser.add_argument('-co', '--category_color', type=json.loads, + default=default, + help=(f'Lookup to match overplot category color to ' + f'assessment grouping. Default is {default}')) + parser.add_argument('-flp', '--force_line_plot', default=False, + action='store_true', + help='Option to plot 2D data as 1D line plots') + parser.add_argument('-l', '--labels', nargs='+', default=False, + type=str, + help=('Option to overwrite the legend labels. ' + 'Must have same dimensions as number of ' + 'lines plottes.')) + parser.add_argument('-sy', '--secondary_y', default=False, action='store_true', + help='Option to plot on secondary y axis') + if CARTOPY_AVAILABLE: + default = ccrs.PlateCarree() + parser.add_argument('-prj', '--projection', type=str, + default=default, + help=f"Projection to use on plot. Default is {default}") + default = 20 + parser.add_argument('-bx', '--num_barb_x', type=int, default=default, + help=f'Number of wind barbs to plot in the x axis. Default is {default}') + default = 20 + parser.add_argument('-by', '--num_barb_y', type=int, default=default, + help=f"Number of wind barbs to plot in the y axis. Default is {default}") + default = 20 + parser.add_argument('-tp', '--num_time_periods', type=int, default=default, + help=f'Set how many time periods. Default is {default}') + parser.add_argument('-bn', '--bins', nargs='+', type=int, default=None, + help='histogram bin boundaries to use') + parser.add_argument('-bf', '--bin_field', type=str, default=None, + help=('name of the field that stores the ' + 'bins for the spectra')) + parser.add_argument('-xb', '--x_bins', nargs='+', type=int, default=None, + help='Histogram bin boundaries to use for x axis variable') + parser.add_argument('-yb', '--y_bins', nargs='+', type=int, default=None, + help='Histogram bin boundaries to use for y axis variable') + parser.add_argument('-t', '--time', type=str, default=None, + help='Time period to be plotted') + parser.add_argument('-sbf', '--sortby_field', type=str, default=None, + help='Sort histograms by a given field parameter') + parser.add_argument('-sbb', '--sortby_bins', nargs='+', type=int, + default=None, + help='Bins to sort the histograms by') + default = 20 + parser.add_argument('-nyl', '--num_y_levels', type=int, default=default, + help=f'Number of levels in the y axis to use. Default is {default}') + parser.add_argument('-sk', '--sel_kwargs', type=json.loads, default=None, + help=('The keyword arguments to pass into ' + ':py:func:`xarray.DataArray.sel`')) + parser.add_argument('-ik', '--isel_kwargs', type=json.loads, default=None, + help=('The keyword arguments to pass into ' + ':py:func:`xarray.DataArray.sel`')) + default = 'cubic' + parser.add_argument('-fn', '--function', type=str, default=default, + help=(f'Defaults to cubic function for interpolation. ' + f'See scipy.interpolate.Rbf for additional options. ' + f'Default is {default}')) + default = 0.1 + parser.add_argument('-gb', '--grid_buffer', type=float, default=default, + help=f'Buffer to apply to grid. Default is {default}') + default = (0.01, 0.01) + parser.add_argument('-gd', '--grid_delta', nargs='+', + type=float, default=default, + help=f'X and Y deltas for creating grid. Default is {default}') + parser.add_argument('-fg', '--figsize', nargs='+', type=float, + default=None, + help='Width and height in inches of figure') + default = 'white' + parser.add_argument('-tc', '--text_color', type=str, default=default, + help=f"Color of text. Default is '{default}'") + parser.add_argument('-kwargs', type=json.loads, default=dict(), + help='keyword arguments to use in plotting function') + parser.add_argument('-pk', '--plot_kwargs', type=json.loads, default=dict(), + help=("Additional keyword arguments to pass " + "into MetPy's SkewT.plot")) + parser.add_argument('-pbk', '--plot_barbs_kwargs', type=json.loads, + default=dict(), + help=("Additional keyword arguments to pass " + "into MetPy's SkewT.plot_barbs")) + default = True + parser.add_argument('-cu', '--cleanup', default=default, action='store_false', + help=f'Turn off standard methods for obj cleanup. Default is {default}') + parser.add_argument('-gl', '--gridlines', default=False, action='store_true', + help='Use latitude and lingitude gridlines.') + parser.add_argument('-cl', '--coastlines', default=False, action='store_true', + help='Plot coastlines on geographical map') + parser.add_argument('-bg', '--background', default=False, action='store_true', + help='Plot a stock image background') + parser.add_argument('-nan', '--add_nan', default=False, action='store_true', + help='Fill in data gaps with NaNs') + parser.add_argument('-dn', '--day_night', default=False, action='store_true', + help=("Fill in color coded background according " + "to time of day.")) + parser.add_argument('-yr', '--set_yrange', default=None, nargs=2, + help=("Set the yrange for the specific plot")) + parser.add_argument('-iya', '--invert_y_axis', default=False, + action='store_true', + help='Invert y axis') + parser.add_argument('-sp', '--show_parcel', default=False, action='store_true', + help='set to true to plot the parcel path.') + parser.add_argument('-cape', '--shade_cape', default=False, + action='store_true', + help='set to true to shade regions of cape.') + parser.add_argument('-cin', '--shade_cin', default=False, action='store_true', + help='set to true to shade regions of cin.') + parser.add_argument('-d', '--density', default=False, action='store_true', + help='Plot a p.d.f. instead of a frequency histogram') + parser.add_argument('-m', '--mesh', default=False, action='store_true', + help=('Set to True to interpolate u and v to ' + 'grid and create wind barbs')) + parser.add_argument('-uv', '--from_u_and_v', default=False, action='store_true', + help='Create SkewTPLot with u and v wind') + parser.add_argument('-sd', '--from_spd_and_dir', default=False, action='store_true', + help='Create SkewTPlot with wind speed and direction') + parser.add_argument('-px', '--plot_xsection', default=False, action='store_true', + help='plots a cross section whose x and y coordinates') + parser.add_argument('-pxm', '--xsection_map', default=False, action='store_true', + help='plots a cross section of 2D data on a geographical map') + parser.add_argument('-p', '--plot', default=False, action='store_true', + help='Makes a time series plot') + parser.add_argument('-mp', '--multi_panel', default=False, + action='store_true', + help='Makes a 2 panel timeseries plot') + parser.add_argument('-qc', '--qc', default=False, action='store_true', + help='Create time series plot of embedded quality control values') + parser.add_argument('-fb', '--fill_between', default=False, action='store_true', + help='makes a fill betweem plot based on matplotlib') + parser.add_argument('-bsd', '--barbs_spd_dir', default=False, action='store_true', + help=('Makes time series plot of wind barbs ' + 'using wind speed and dir.')) + parser.add_argument('-buv', '--barbs_u_v', default=False, action='store_true', + help=('Makes time series plot of wind barbs ' + 'using u and v wind components.')) + parser.add_argument('-pxs', '--xsection_from_1d', default=False, + action='store_true', + help='Will plot a time-height cross section from 1D dataset') + parser.add_argument('-ths', '--time_height_scatter', + default=False, action='store_true', + help='Create a scatter time series plot') + parser.add_argument('-sbg', '--stacked_bar_graph', + default=False, action='store_true', + help='Create stacked bar graph histogram') + parser.add_argument('-psd', '--size_dist', default=False, action='store_true', + help='Plots a stairstep plot of size distribution') + parser.add_argument('-sg', '--stairstep', default=False, action='store_true', + help='Plots stairstep plot of a histogram') + parser.add_argument('-hm', '--heatmap', default=False, action='store_true', + help='Plot a heatmap histogram from 2 variables') + parser.add_argument('-cc', '--create_contour', default=False, action='store_true', + help='Extracts, grids, and creates a contour plot') + parser.add_argument('-cf', '--contourf', default=False, action='store_true', + help=('Base function for filled contours if user ' + 'already has data gridded')) + parser.add_argument('-ct', '--plot_contour', default=False, action='store_true', + help=('Base function for contours if user ' + 'already has data gridded')) + parser.add_argument('-vsd', '--vectors_spd_dir', default=False, action='store_true', + help='Extracts, grids, and creates a contour plot.') + parser.add_argument('-b', '--barbs', default=False, action='store_true', + help='Base function for wind barbs.') + parser.add_argument('-ps', '--plot_station', default=False, action='store_true', + help='Extracts, grids, and creates a contour plot') + + # The mutually exclusive but one requried group + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument('-gp', '--geodisplay', dest='action', action='store_const', + const=geodisplay, help='Set to genereate a geographic plot') + group.add_argument('-skt', '--skewt', dest='action', action='store_const', + const=skewt, help='Set to genereate a skew-t plot') + group.add_argument('-xs', '--xsection', dest='action', action='store_const', + const=xsection, help='Set to genereate a XSection plot') + group.add_argument('-wr', '--wind_rose', dest='action', action='store_const', + const=wind_rose, help='Set to genereate a wind rose plot') + group.add_argument('-ts', '--timeseries', dest='action', action='store_const', + const=timeseries, help='Set to genereate a timeseries plot') + group.add_argument('-c', '--contour', dest='action', action='store_const', + const=contour, help='Set to genereate a contour plot') + group.add_argument('-hs', '--histogram', dest='action', action='store_const', + const=histogram, help='Set to genereate a histogram plot') + + args = parser.parse_args() + + # Check if a path but no file name is given. If so use a default name. + out_path = pathlib.Path(args.out_path) + if out_path.is_dir(): + args.out_path = str(pathlib.Path(out_path, out_path_default)) + + args.action(args) + + +if __name__ == '__main__': + main() diff --git a/scripts/ads_examples.rst b/scripts/ads_examples.rst new file mode 100644 index 0000000000..2ced590bee --- /dev/null +++ b/scripts/ads_examples.rst @@ -0,0 +1,19 @@ +======================= +ARM Data Surveyor (ADS) +======================= + +Given the shear number of functions supported in ADS, these examples are not exhaustive. They +are meant to search as a starting point. A full list of options can be found by executing:: + + python ads.py -h + +EXAMPLES: +~~~~~~~~~ + +Plot a simple timeseries plot:: + + python ads.py -f ../act/tests/data/sgpmetE13.b1.20190101.000000.cdf -o ./image.png -fd temp_mean -ts --plot + +Plot a simple timeseries plot with the QC block plot in a second plot:: + + python ads.py -f ../act/tests/data/sgpmetE13.b1.20190101.000000.cdf -o ./image.png -fds temp_mean temp_mean -pt plot qc -mp -ts -si "(0,), (1,)" -ss 2 diff --git a/setup.cfg b/setup.cfg index 58f5b37648..09382c0d37 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,3 +1,27 @@ +[flake8] +exclude = act/tests/data/ docs *__init__.py* setup.cfg +ignore = E203,E266,E501,W503,E722,E402,C901,E731,F401 +max-line-length = 100 +max-complexity = 18 +extend-exclude = docs *__init__.py* +extend-ignore = E203,E266,E501,W503,E722,E402,C901,E731,F401 + +[isort] +profile = black +known_first_party=act +known_third_party= +multi_line_output=3 +include_trailing_comma=True +force_grid_wrap=0 +combine_as_imports=True +line_length=100 +skip= + docs/source/conf.py + setup.py + +[tool:pytest] +addopts = --cov=./ --cov-report=xml --verbose + [versioneer] VCS = git style = pep440-post diff --git a/setup.py b/setup.py index e340c380e3..3e6c4bff89 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,4 @@ +import glob from os import path from setuptools import setup, find_packages import sys @@ -10,8 +11,8 @@ min_version = (3, 6) if sys.version_info < min_version: error = """ -act does not support Python {0}.{1}. -Python {2}.{3} and above is required. Check your Python version like so: +act does not support Python {}.{}. +Python {}.{} and above is required. Check your Python version like so: python3 --version @@ -19,7 +20,9 @@ Upgrade pip like so: pip install --upgrade pip -""".format(*sys.version_info[:2], *min_version) +""".format( + *sys.version_info[:2], *min_version + ) sys.exit(error) here = path.abspath(path.dirname(__file__)) @@ -29,26 +32,28 @@ with open(path.join(here, 'requirements.txt')) as requirements_file: # Parse requirements.txt, ignoring any commented-out lines. - requirements = [line for line in requirements_file.read().splitlines() - if not line.startswith('#')] + requirements = [ + line for line in requirements_file.read().splitlines() if not line.startswith('#') + ] setup( name='act-atmos', version=versioneer.get_version(), cmdclass=versioneer.get_cmdclass(), - description="Package for working with atmospheric time series datasets", + description='Package for working with atmospheric time series datasets', long_description=readme, long_description_content_type='text/x-rst', - author="Adam Theisen", + author='Adam Theisen', author_email='atheisen@anl.gov', url='https://github.com/ARM-DOE/ACT', packages=find_packages(exclude=['docs']), entry_points={'console_scripts': []}, include_package_data=True, package_data={'act': []}, + scripts=glob.glob("scripts/*"), install_requires=requirements, - license="BSD (3-clause)", + license='BSD (3-clause)', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Natural Language :: English', diff --git a/tests/corrections/test_ceil.py b/tests/corrections/test_ceil.py new file mode 100644 index 0000000000..b50fd85e2e --- /dev/null +++ b/tests/corrections/test_ceil.py @@ -0,0 +1,20 @@ +import numpy as np +import xarray as xr + +import act + + +def test_correct_ceil(): + # Make a fake ARM dataset to test with, just an array with 1e-7 for half + # of it + fake_data = 10 * np.ones((300, 20)) + fake_data[:, 10:] = -1 + arm_ds = {} + arm_ds['backscatter'] = xr.DataArray(fake_data) + arm_ds = act.corrections.ceil.correct_ceil(arm_ds) + assert np.all(arm_ds['backscatter'].data[:, 10:] == -7) + assert np.all(arm_ds['backscatter'].data[:, 1:10] == 1) + + arm_ds['backscatter'].attrs['units'] = 'dummy' + arm_ds = act.corrections.ceil.correct_ceil(arm_ds) + assert arm_ds['backscatter'].units == 'log(dummy)' diff --git a/tests/corrections/test_doppler_lidar.py b/tests/corrections/test_doppler_lidar.py new file mode 100644 index 0000000000..6a7cb12f11 --- /dev/null +++ b/tests/corrections/test_doppler_lidar.py @@ -0,0 +1,19 @@ +import numpy as np + +import act + + +def test_correct_dl(): + # Test the DL correction script on a PPI dataset eventhough it will + # mostlikely be used on FPT scans. Doing this to save space with only + # one datafile in the repo. + files = act.tests.sample_files.EXAMPLE_DLPPI + ds = act.io.arm.read_arm_netcdf(files) + + new_ds = act.corrections.doppler_lidar.correct_dl(ds, fill_value=np.nan) + data = new_ds['attenuated_backscatter'].values + np.testing.assert_almost_equal(np.nansum(data), -186479.83, decimal=0.1) + + new_ds = act.corrections.doppler_lidar.correct_dl(ds, range_normalize=False) + data = new_ds['attenuated_backscatter'].values + np.testing.assert_almost_equal(np.nansum(data), -200886.0, decimal=0.1) diff --git a/tests/corrections/test_mpl_corrections.py b/tests/corrections/test_mpl_corrections.py new file mode 100644 index 0000000000..a6ab821fe7 --- /dev/null +++ b/tests/corrections/test_mpl_corrections.py @@ -0,0 +1,54 @@ +import numpy as np + +import act + + +def test_correct_mpl(): + # Make a fake ARM dataset to test with, just an array with 1e-7 for half + # of it + test_data = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_MPL_1SAMPLE) + ds = act.corrections.mpl.correct_mpl(test_data) + sig_cross_pol = ds['signal_return_cross_pol'].values[1, 10:15] + sig_co_pol = ds['signal_return_co_pol'].values[1, 10:15] + height = ds['height'].values[0:10] + overlap0 = ds['overlap_correction'].values[1, 0, 0:5] + overlap1 = ds['overlap_correction'].values[1, 1, 0:5] + overlap2 = ds['overlap_correction'].values[1, 2, 0:5] + np.testing.assert_allclose(overlap0, [0.0, 0.0, 0.0, 0.0, 0.0]) + np.testing.assert_allclose(overlap1, [754.338, 754.338, 754.338, 754.338, 754.338]) + np.testing.assert_allclose(overlap2, [181.9355, 181.9355, 181.9355, 181.9355, 181.9355]) + np.testing.assert_allclose( + sig_cross_pol, + [-0.5823283, -1.6066532, -1.7153032, -2.520143, -2.275405], + rtol=4e-06, + ) + np.testing.assert_allclose( + sig_co_pol, [12.5631485, 11.035495, 11.999875, 11.09393, 11.388968], rtol=1e-6 + ) + np.testing.assert_allclose( + height, + [ + 0.00749012, + 0.02247084, + 0.03745109, + 0.05243181, + 0.06741206, + 0.08239277, + 0.09737302, + 0.11235374, + 0.12733398, + 0.14231472, + ], + rtol=1e-6, + ) + assert ds['signal_return_co_pol'].attrs['units'] == '10 * log10(count/us)' + assert ds['signal_return_cross_pol'].attrs['units'] == '10 * log10(count/us)' + assert ds['cross_co_ratio'].attrs['long_name'] == 'Cross-pol / Co-pol ratio * 100' + assert ds['cross_co_ratio'].attrs['units'] == '1' + assert 'description' not in ds['cross_co_ratio'].attrs.keys() + assert 'ancillary_variables' not in ds['cross_co_ratio'].attrs.keys() + assert np.all(np.round(ds['cross_co_ratio'].data[0, 500]) == 34.0) + assert np.all(np.round(ds['signal_return_co_pol'].data[0, 11]) == 11) + assert np.all(np.round(ds['signal_return_co_pol'].data[0, 500]) == -6) + test_data.close() + ds.close() diff --git a/tests/corrections/test_raman_lidar.py b/tests/corrections/test_raman_lidar.py new file mode 100644 index 0000000000..0fda57d7f5 --- /dev/null +++ b/tests/corrections/test_raman_lidar.py @@ -0,0 +1,18 @@ +import numpy as np + +import act + + +def test_correct_rl(): + # Using ceil data in RL place to save memory + files = act.tests.sample_files.EXAMPLE_RL1 + ds = act.io.arm.read_arm_netcdf(files) + + ds = act.corrections.raman_lidar.correct_rl(ds, range_normalize_log_values=True) + np.testing.assert_almost_equal(np.max(ds['depolarization_counts_high'].values), 9.91, decimal=2) + np.testing.assert_almost_equal( + np.min(ds['depolarization_counts_high'].values), -7.00, decimal=2 + ) + np.testing.assert_almost_equal( + np.mean(ds['depolarization_counts_high'].values), -1.45, decimal=2 + ) diff --git a/tests/corrections/test_ship.py b/tests/corrections/test_ship.py new file mode 100644 index 0000000000..fb50b779be --- /dev/null +++ b/tests/corrections/test_ship.py @@ -0,0 +1,16 @@ +import xarray as xr + +import act + + +def test_correct_wind(): + nav = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_NAV) + nav = act.utils.ship_utils.calc_cog_sog(nav) + + aosmet = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_AOSMET) + + ds = xr.merge([nav, aosmet], compat='override') + ds = act.corrections.ship.correct_wind(ds) + + assert round(ds['wind_speed_corrected'].values[800]) == 5.0 + assert round(ds['wind_direction_corrected'].values[800]) == 92.0 diff --git a/tests/discovery/test_airnow.py b/tests/discovery/test_airnow.py new file mode 100644 index 0000000000..eabc454f36 --- /dev/null +++ b/tests/discovery/test_airnow.py @@ -0,0 +1,53 @@ +import os + +import numpy as np + +import act + + +def test_get_airnow(): + token = os.getenv('AIRNOW_API') + if token is not None: + if len(token) == 0: + return + results = act.discovery.get_airnow_forecast(token, '2022-05-01', zipcode=60108, distance=50) + assert results['CategoryName'].values[0] == 'Good' + assert results['AQI'].values[2] == -1 + assert results['ReportingArea'].values[3] == 'Aurora and Elgin' + + results = act.discovery.get_airnow_forecast( + token, '2022-05-01', distance=50, latlon=[41.958, -88.12] + ) + assert results['CategoryName'].values[3] == 'Good' + assert results['AQI'].values[2] == -1 + assert results['ReportingArea'][3] == 'Aurora and Elgin' + + results = act.discovery.get_airnow_obs(token, date='2022-05-01', zipcode=60108, distance=50) + assert results['AQI'].values[0] == 26 + assert results['ParameterName'].values[1] == 'PM2.5' + assert results['CategoryName'].values[0] == 'Good' + + results = act.discovery.get_airnow_obs(token, zipcode=60108, distance=50) + assert results['ReportingArea'].values[0] == 'Aurora and Elgin' + results = act.discovery.get_airnow_obs(token, latlon=[41.958, -88.12], distance=50) + assert results['StateCode'].values[0] == 'IL' + + with np.testing.assert_raises(NameError): + results = act.discovery.get_airnow_obs(token) + with np.testing.assert_raises(NameError): + results = act.discovery.get_airnow_forecast(token, '2022-05-01') + + results = act.discovery.get_airnow_obs( + token, date='2022-05-01', distance=50, latlon=[41.958, -88.12] + ) + assert results['AQI'].values[0] == 26 + assert results['ParameterName'].values[1] == 'PM2.5' + assert results['CategoryName'].values[0] == 'Good' + + lat_lon = '-88.245401,41.871346,-87.685099,42.234359' + results = act.discovery.get_airnow_bounded_obs( + token, '2022-05-01T00', '2022-05-01T12', lat_lon, 'OZONE,PM25', data_type='B' + ) + assert results['PM2.5'].values[-1, 0] == 1.8 + assert results['OZONE'].values[0, 0] == 37.0 + assert len(results['time'].values) == 13 diff --git a/tests/discovery/test_arm_discovery.py b/tests/discovery/test_arm_discovery.py new file mode 100644 index 0000000000..d8c7a6b6bc --- /dev/null +++ b/tests/discovery/test_arm_discovery.py @@ -0,0 +1,115 @@ +import glob +import os + +import numpy as np + +import act + + +def test_download_armdata(): + if not os.path.isdir(os.getcwd() + '/data/'): + os.makedirs(os.getcwd() + '/data/') + + # Place your username and token here + username = os.getenv('ARM_USERNAME') + token = os.getenv('ARM_PASSWORD') + + if username is not None and token is not None: + if len(username) == 0 and len(token) == 0: + return + datastream = 'sgpmetE13.b1' + startdate = '2020-01-01' + enddate = startdate + outdir = os.getcwd() + '/data/' + + results = act.discovery.arm.download_arm_data( + username, token, datastream, startdate, enddate, output=outdir + ) + files = glob.glob(outdir + datastream + '*20200101*cdf') + if len(results) > 0: + assert files is not None + assert 'sgpmetE13' in files[0] + + if files is not None: + if len(files) > 0: + os.remove(files[0]) + + datastream = 'sgpmeetE13.b1' + act.discovery.arm.download_arm_data( + username, token, datastream, startdate, enddate, output=outdir + ) + files = glob.glob(outdir + datastream + '*20200101*cdf') + assert len(files) == 0 + + with np.testing.assert_raises(ConnectionRefusedError): + act.discovery.arm.download_arm_data( + username, token + '1234', datastream, startdate, enddate, output=outdir + ) + + datastream = 'sgpmetE13.b1' + results = act.discovery.arm.download_arm_data( + username, token, datastream, startdate, enddate + ) + assert len(results) == 1 + + +def test_download_armdata_hourly(): + if not os.path.isdir(os.getcwd() + '/data/'): + os.makedirs(os.getcwd() + '/data/') + + # Place your username and token here + username = os.getenv('ARM_USERNAME') + token = os.getenv('ARM_PASSWORD') + + if username is not None and token is not None: + if len(username) == 0 and len(token) == 0: + return + datastream = 'sgpmetE13.b1' + startdate = '2020-01-01T00:00:00' + enddate = '2020-01-01T12:00:00' + outdir = os.getcwd() + '/data/' + + results = act.discovery.arm.download_arm_data( + username, token, datastream, startdate, enddate, output=outdir + ) + files = glob.glob(outdir + datastream + '*20200101*cdf') + if len(results) > 0: + assert files is not None + assert 'sgpmetE13' in files[0] + + if files is not None: + if len(files) > 0: + os.remove(files[0]) + + datastream = 'sgpmeetE13.b1' + act.discovery.arm.download_arm_data( + username, token, datastream, startdate, enddate, output=outdir + ) + files = glob.glob(outdir + datastream + '*20200101*cdf') + assert len(files) == 0 + + with np.testing.assert_raises(ConnectionRefusedError): + act.discovery.arm.download_arm_data( + username, token + '1234', datastream, startdate, enddate, output=outdir + ) + + datastream = 'sgpmetE13.b1' + results = act.discovery.arm.download_arm_data( + username, token, datastream, startdate, enddate + ) + assert len(results) == 1 + + +def test_arm_doi(): + datastream = 'sgpmetE13.b1' + startdate = '2022-01-01' + enddate = '2022-12-31' + doi = act.discovery.get_arm_doi(datastream, startdate, enddate) + + assert len(doi) > 10 + assert isinstance(doi, str) + assert 'doi' in doi + assert 'Kyrouac' in doi + + doi = act.discovery.get_arm_doi('test', startdate, enddate) + assert 'No DOI Found' in doi diff --git a/tests/discovery/test_asos.py b/tests/discovery/test_asos.py new file mode 100644 index 0000000000..e0f44842df --- /dev/null +++ b/tests/discovery/test_asos.py @@ -0,0 +1,27 @@ +from datetime import datetime + +import numpy as np + +import act + + +def test_get_ord(): + time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 12, 10, 0)] + my_asoses = act.discovery.get_asos_data(time_window, station='ORD') + assert 'ORD' in my_asoses.keys() + assert np.all( + np.equal( + my_asoses['ORD']['sknt'].values[:10], + np.array([13.0, 11.0, 14.0, 14.0, 13.0, 11.0, 14.0, 13.0, 13.0, 13.0]), + ) + ) + + +def test_get_region(): + my_keys = ['MDW', 'IGQ', 'ORD', '06C', 'PWK', 'LOT', 'GYY'] + time_window = [datetime(2020, 2, 4, 2, 0), datetime(2020, 2, 12, 10, 0)] + lat_window = (41.8781 - 0.5, 41.8781 + 0.5) + lon_window = (-87.6298 - 0.5, -87.6298 + 0.5) + my_asoses = act.discovery.get_asos_data(time_window, lat_range=lat_window, lon_range=lon_window) + asos_keys = list(my_asoses.keys()) + assert asos_keys == my_keys diff --git a/tests/discovery/test_cropscape.py b/tests/discovery/test_cropscape.py new file mode 100644 index 0000000000..3d594cc35d --- /dev/null +++ b/tests/discovery/test_cropscape.py @@ -0,0 +1,20 @@ +import act + + +def test_croptype(): + year = 2018 + lat = 37.15 + lon = -98.362 + # Try for when the cropscape API is not working + try: + crop = act.discovery.cropscape.get_crop_type(lat, lon, year) + crop2 = act.discovery.cropscape.get_crop_type(lat, lon) + except Exception: + return + + # print(crop, crop2) + if crop is not None: + assert crop == 'Dbl Crop WinWht/Sorghum' + if crop2 is not None: + # assert crop2 == 'Sorghum' + assert crop2 == 'Soybeans' diff --git a/tests/discovery/test_neon_discovery.py b/tests/discovery/test_neon_discovery.py new file mode 100644 index 0000000000..d58edbca2c --- /dev/null +++ b/tests/discovery/test_neon_discovery.py @@ -0,0 +1,30 @@ +import os + +import act + + +def test_neon(): + site_code = 'BARR' + result = act.discovery.get_neon_site_products(site_code, print_to_screen=True) + assert 'DP1.00002.001' in result + assert result['DP1.00003.001'] == 'Triple aspirated air temperature' + + product_code = 'DP1.00002.001' + result = act.discovery.get_neon_product_avail(site_code, product_code, print_to_screen=True) + assert '2017-09' in result + assert '2022-11' in result + + output_dir = os.path.join(os.getcwd(), site_code + '_' + product_code) + result = act.discovery.download_neon_data( + site_code, product_code, '2022-10', output_dir=output_dir + ) + assert len(result) == 20 + assert any('readme' in r for r in result) + assert any('sensor_position' in r for r in result) + + result = act.discovery.download_neon_data( + site_code, product_code, '2022-09', end_date='2022-10', output_dir=output_dir + ) + assert len(result) == 40 + assert any('readme' in r for r in result) + assert any('sensor_position' in r for r in result) diff --git a/tests/discovery/test_noaapsl_discovery.py b/tests/discovery/test_noaapsl_discovery.py new file mode 100644 index 0000000000..3369371f91 --- /dev/null +++ b/tests/discovery/test_noaapsl_discovery.py @@ -0,0 +1,59 @@ +import numpy as np + +import act + + +def test_noaa_psl(): + result = act.discovery.download_noaa_psl_data( + site='ctd', + instrument='Parsivel', + startdate='20211231', + enddate='20220101', + output='./data/', + ) + assert len(result) == 48 + + result = act.discovery.download_noaa_psl_data( + site='ctd', instrument='Pressure', startdate='20220101', hour='00' + ) + assert len(result) == 1 + + result = act.discovery.download_noaa_psl_data( + site='ctd', instrument='GpsTrimble', startdate='20220104', hour='00' + ) + assert len(result) == 6 + + types = [ + 'Radar S-band Moment', + 'Radar S-band Bright Band', + '449RWP Bright Band', + '449RWP Wind', + '449RWP Sub-Hour Wind', + '449RWP Sub-Hour Temp', + '915RWP Wind', + '915RWP Temp', + '915RWP Sub-Hour Wind', + '915RWP Sub-Hour Temp', + ] + for t in types: + result = act.discovery.download_noaa_psl_data( + site='ctd', instrument=t, startdate='20220601', hour='01' + ) + assert len(result) == 1 + + types = ['Radar FMCW Moment', 'Radar FMCW Bright Band'] + files = [3, 1] + for i, t in enumerate(types): + result = act.discovery.download_noaa_psl_data( + site='bck', instrument=t, startdate='20220101', hour='01' + ) + assert len(result) == files[i] + + with np.testing.assert_raises(ValueError): + result = act.discovery.download_noaa_psl_data( + instrument='Parsivel', startdate='20220601', hour='01' + ) + with np.testing.assert_raises(ValueError): + result = act.discovery.download_noaa_psl_data( + site='ctd', instrument='dongle', startdate='20220601', hour='01' + ) diff --git a/tests/discovery/test_surfrad.py b/tests/discovery/test_surfrad.py new file mode 100644 index 0000000000..dcebe06ae9 --- /dev/null +++ b/tests/discovery/test_surfrad.py @@ -0,0 +1,9 @@ +import act + + +def test_download_surfrad(): + results = act.discovery.download_surfrad_data( + site='tbl', startdate='20230601', enddate='20230602' + ) + assert len(results) == 2 + assert 'tbl23152.dat' in results[0] diff --git a/tests/io/test_arm.py b/tests/io/test_arm.py new file mode 100644 index 0000000000..1fc9c85dfa --- /dev/null +++ b/tests/io/test_arm.py @@ -0,0 +1,295 @@ +import tempfile +from pathlib import Path + +import numpy as np + +import act +from act.tests import sample_files + + +def test_read_arm_netcdf(): + ds = act.io.arm.read_arm_netcdf([act.tests.EXAMPLE_MET1]) + assert 'temp_mean' in ds.variables.keys() + assert 'rh_mean' in ds.variables.keys() + assert ds.attrs['_arm_standards_flag'] == (1 << 0) + + with np.testing.assert_raises(OSError): + ds = act.io.arm.read_arm_netcdf([]) + + ds = act.io.arm.read_arm_netcdf([], return_None=True) + assert ds is None + ds = act.io.arm.read_arm_netcdf(['./randomfile.nc'], return_None=True) + assert ds is None + + ds = act.io.arm.read_arm_netcdf([act.tests.EXAMPLE_MET_TEST1]) + assert 'time' in ds + + ds = act.io.arm.read_arm_netcdf([act.tests.EXAMPLE_MET_TEST2]) + assert ds['time'].values[10].astype('datetime64[ms]') == np.datetime64( + '2019-01-01T00:10:00', 'ms' + ) + + ds = act.io.arm.read_arm_netcdf( + act.tests.EXAMPLE_MET1, use_base_time=True, drop_variables='time' + ) + assert 'time' in ds + assert np.issubdtype(ds['time'].dtype, np.datetime64) + assert ds['time'].values[10].astype('datetime64[ms]') == np.datetime64( + '2019-01-01T00:10:00', 'ms' + ) + + del ds + + +def test_keep_variables(): + var_names = [ + 'temp_mean', + 'rh_mean', + 'wdir_vec_mean', + 'tbrg_precip_total_corr', + 'atmos_pressure', + 'wspd_vec_mean', + 'pwd_pw_code_inst', + 'pwd_pw_code_15min', + 'pwd_mean_vis_10min', + 'logger_temp', + 'pwd_precip_rate_mean_1min', + 'pwd_cumul_snow', + 'pwd_mean_vis_1min', + 'pwd_pw_code_1hr', + 'org_precip_rate_mean', + 'tbrg_precip_total', + 'pwd_cumul_rain', + ] + var_names = var_names + ['qc_' + ii for ii in var_names] + drop_variables = act.io.arm.keep_variables_to_drop_variables(act.tests.EXAMPLE_MET1, var_names) + + expected_drop_variables = [ + 'wdir_vec_std', + 'base_time', + 'alt', + 'qc_wspd_arith_mean', + 'pwd_err_code', + 'logger_volt', + 'temp_std', + 'lon', + 'qc_logger_volt', + 'time_offset', + 'wspd_arith_mean', + 'lat', + 'vapor_pressure_std', + 'vapor_pressure_mean', + 'rh_std', + 'qc_vapor_pressure_mean', + ] + assert drop_variables.sort() == expected_drop_variables.sort() + + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_MET1, keep_variables='temp_mean') + assert list(ds.data_vars) == ['temp_mean'] + del ds + + var_names = ['temp_mean', 'qc_temp_mean'] + ds = act.io.arm.read_arm_netcdf( + act.tests.EXAMPLE_MET1, keep_variables=var_names, drop_variables='nonsense' + ) + assert list(ds.data_vars).sort() == var_names.sort() + del ds + + var_names = ['temp_mean', 'qc_temp_mean', 'alt', 'lat', 'lon'] + ds = act.io.arm.read_arm_netcdf( + act.tests.EXAMPLE_MET_WILDCARD, keep_variables=var_names, drop_variables=['lon'] + ) + var_names = list(set(var_names) - {'lon'}) + assert list(ds.data_vars).sort() == var_names.sort() + del ds + + filenames = list(Path(file) for file in act.tests.EXAMPLE_MET_WILDCARD) + var_names = ['temp_mean', 'qc_temp_mean', 'alt', 'lat', 'lon'] + ds = act.io.arm.read_arm_netcdf(filenames, keep_variables=var_names) + assert list(ds.data_vars).sort() == var_names.sort() + del ds + + +def test_read_arm_netcdf_mfdataset(): + met_ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_MET_WILDCARD) + met_ds.load() + assert 'temp_mean' in met_ds.variables.keys() + assert 'rh_mean' in met_ds.variables.keys() + assert len(met_ds.attrs['_file_times']) == 7 + assert met_ds.attrs['_arm_standards_flag'] == (1 << 0) + met_ds.close() + del met_ds + + met_ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_MET_WILDCARD, cleanup_qc=True) + met_ds.load() + var_name = 'temp_mean' + qc_var_name = 'qc_' + var_name + attr_names = [ + 'long_name', + 'units', + 'flag_masks', + 'flag_meanings', + 'flag_assessments', + 'fail_min', + 'fail_max', + 'fail_delta', + 'standard_name', + ] + assert var_name in met_ds.variables.keys() + assert qc_var_name in met_ds.variables.keys() + assert sorted(attr_names) == sorted(list(met_ds[qc_var_name].attrs.keys())) + assert met_ds[qc_var_name].attrs['flag_masks'] == [1, 2, 4, 8] + assert met_ds[qc_var_name].attrs['flag_assessments'] == ['Bad', 'Bad', 'Bad', 'Indeterminate'] + met_ds.close() + del met_ds + + +def test_io_dod(): + dims = {'time': 1440, 'drop_diameter': 50} + + try: + ds = act.io.arm.create_ds_from_arm_dod( + 'vdis.b1', dims, version='1.2', scalar_fill_dim='time' + ) + assert 'moment1' in ds + assert len(ds['base_time'].values) == 1440 + assert len(ds['drop_diameter'].values) == 50 + with np.testing.assert_warns(UserWarning): + ds2 = act.io.arm.create_ds_from_arm_dod('vdis.b1', dims, scalar_fill_dim='time') + assert 'moment1' in ds2 + assert len(ds2['base_time'].values) == 1440 + assert len(ds2['drop_diameter'].values) == 50 + with np.testing.assert_raises(ValueError): + ds = act.io.arm.create_ds_from_arm_dod('vdis.b1', {}, version='1.2') + ds = act.io.arm.create_ds_from_arm_dod( + sample_files.EXAMPLE_DOD, dims, version=1.2, scalar_fill_dim='time', local_file=True + ) + assert 'moment1' in ds + assert len(ds['base_time'].values) == 1440 + assert len(ds['drop_diameter'].values) == 50 + except Exception: + return + ds.close() + ds2.close() + + +def test_io_write(): + sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) + sonde_ds.clean.cleanup() + + with tempfile.TemporaryDirectory() as tmpdirname: + write_file = Path(tmpdirname, Path(sample_files.EXAMPLE_SONDE1).name) + keep_vars = ['tdry', 'qc_tdry', 'dp', 'qc_dp'] + for var_name in list(sonde_ds.data_vars): + if var_name not in keep_vars: + del sonde_ds[var_name] + sonde_ds.write.write_netcdf(path=write_file, FillValue=-9999) + + sonde_ds_read = act.io.arm.read_arm_netcdf(str(write_file)) + assert list(sonde_ds_read.data_vars) == keep_vars + assert isinstance(sonde_ds_read['qc_tdry'].attrs['flag_meanings'], str) + assert sonde_ds_read['qc_tdry'].attrs['flag_meanings'].count('__') == 21 + for attr in ['qc_standards_version', 'qc_method', 'qc_comment']: + assert attr not in list(sonde_ds_read.attrs) + sonde_ds_read.close() + del sonde_ds_read + + sonde_ds.close() + + sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_EBBR1) + sonde_ds.clean.cleanup() + assert 'fail_min' in sonde_ds['qc_home_signal_15'].attrs + assert 'standard_name' in sonde_ds['qc_home_signal_15'].attrs + assert 'flag_masks' in sonde_ds['qc_home_signal_15'].attrs + + with tempfile.TemporaryDirectory() as tmpdirname: + cf_convention = 'CF-1.8' + write_file = Path(tmpdirname, Path(sample_files.EXAMPLE_EBBR1).name) + sonde_ds.write.write_netcdf( + path=write_file, + make_copy=False, + join_char='_', + cf_compliant=True, + cf_convention=cf_convention, + ) + + sonde_ds_read = act.io.arm.read_arm_netcdf(str(write_file)) + + assert cf_convention in sonde_ds_read.attrs['Conventions'].split() + assert sonde_ds_read.attrs['FeatureType'] == 'timeSeries' + global_att_keys = [ii for ii in sonde_ds_read.attrs.keys() if not ii.startswith('_')] + assert global_att_keys[-1] == 'history' + assert sonde_ds_read['alt'].attrs['axis'] == 'Z' + assert sonde_ds_read['alt'].attrs['positive'] == 'up' + + sonde_ds_read.close() + del sonde_ds_read + + sonde_ds.close() + + ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_CEIL1) + with tempfile.TemporaryDirectory() as tmpdirname: + cf_convention = 'CF-1.8' + write_file = Path(tmpdirname, Path(sample_files.EXAMPLE_CEIL1).name) + ds.write.write_netcdf( + path=write_file, + make_copy=False, + join_char='_', + cf_compliant=True, + cf_convention=cf_convention, + ) + + ds_read = act.io.arm.read_arm_netcdf(str(write_file)) + + assert cf_convention in ds_read.attrs['Conventions'].split() + assert ds_read.attrs['FeatureType'] == 'timeSeriesProfile' + assert len(ds_read.dims) > 1 + + ds_read.close() + del ds_read + + +def test_clean_cf_qc(): + with tempfile.TemporaryDirectory() as tmpdirname: + ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1, cleanup_qc=True) + ds.load() + var_name = 'temp_mean' + qc_var_name = 'qc_' + var_name + ds.qcfilter.remove_test(var_name, test_number=4) + ds.qcfilter.remove_test(var_name, test_number=3) + ds.qcfilter.remove_test(var_name, test_number=2) + ds[qc_var_name].attrs['flag_masks'] = ds[qc_var_name].attrs['flag_masks'][0] + flag_meanings = ds[qc_var_name].attrs['flag_meanings'][0] + ds[qc_var_name].attrs['flag_meanings'] = flag_meanings.replace(' ', '__') + flag_meanings = ds[qc_var_name].attrs['flag_assessments'][0] + ds[qc_var_name].attrs['flag_assessments'] = flag_meanings.replace(' ', '__') + + write_file = str(Path(tmpdirname, Path(sample_files.EXAMPLE_MET1).name)) + ds.write.write_netcdf(path=write_file, cf_compliant=True) + ds.close() + del ds + + read_ds = act.io.arm.read_arm_netcdf(write_file, cleanup_qc=True) + read_ds.load() + + assert type(read_ds[qc_var_name].attrs['flag_masks']).__module__ == 'numpy' + assert read_ds[qc_var_name].attrs['flag_masks'].size == 1 + assert read_ds[qc_var_name].attrs['flag_masks'][0] == 1 + assert isinstance(read_ds[qc_var_name].attrs['flag_meanings'], list) + assert len(read_ds[qc_var_name].attrs['flag_meanings']) == 1 + assert isinstance(read_ds[qc_var_name].attrs['flag_assessments'], list) + assert len(read_ds[qc_var_name].attrs['flag_assessments']) == 1 + assert read_ds[qc_var_name].attrs['flag_assessments'] == ['Bad'] + assert read_ds[qc_var_name].attrs['flag_meanings'] == ['Value is equal to missing_value.'] + + read_ds.close() + del read_ds + + +def test_read_mmcr(): + results = act.tests.EXAMPLE_MMCR + ds = act.io.arm.read_arm_mmcr(results) + assert 'MeanDopplerVelocity_PR' in ds + assert 'SpectralWidth_BL' in ds + np.testing.assert_almost_equal(ds['Reflectivity_GE'].mean(), -34.62, decimal=2) + np.testing.assert_almost_equal(ds['MeanDopplerVelocity_Receiver1'].max(), 9.98, decimal=2) diff --git a/tests/io/test_hysplit.py b/tests/io/test_hysplit.py new file mode 100644 index 0000000000..6a889a2f42 --- /dev/null +++ b/tests/io/test_hysplit.py @@ -0,0 +1,17 @@ +import act +import matplotlib.pyplot as plt + +from act.tests import sample_files + + +def test_read_hysplit(): + filename = sample_files.EXAMPLE_HYSPLIT + ds = act.io.read_hysplit(filename) + assert 'lat' in ds.variables.keys() + assert 'lon' in ds.variables.keys() + assert 'alt' in ds.variables.keys() + assert 'PRESSURE' in ds.variables.keys() + assert ds.dims["num_grids"] == 8 + assert ds.dims["num_trajectories"] == 1 + assert ds.dims['time'] == 121 + assert ds['age'].min() == -120 diff --git a/tests/io/test_icartt.py b/tests/io/test_icartt.py new file mode 100644 index 0000000000..253dfd0cb8 --- /dev/null +++ b/tests/io/test_icartt.py @@ -0,0 +1,14 @@ +import numpy as np +import pytest + +import act + + +@pytest.mark.skipif(not act.io.icartt._ICARTT_AVAILABLE, reason='ICARTT is not installed.') +def test_read_icartt(): + result = act.io.icartt.read_icartt(act.tests.EXAMPLE_AAF_ICARTT) + assert 'pitch' in result + assert len(result['time'].values) == 14087 + assert result['true_airspeed'].units == 'm/s' + assert 'Revision' in result.attrs + np.testing.assert_almost_equal(result['static_pressure'].mean(), 708.75, decimal=2) diff --git a/tests/io/test_mpl.py b/tests/io/test_mpl.py new file mode 100644 index 0000000000..115070adc0 --- /dev/null +++ b/tests/io/test_mpl.py @@ -0,0 +1,24 @@ +import act + + +def test_io_mpldataset(): + try: + mpl_ds = act.io.mpl.read_sigma_mplv5(act.tests.EXAMPLE_SIGMA_MPLV5) + except Exception: + return + + # Tests fields + assert 'channel_1' in mpl_ds.variables.keys() + assert 'temp_0' in mpl_ds.variables.keys() + assert mpl_ds.channel_1.values.shape == (102, 1000) + + # Tests coordinates + assert 'time' in mpl_ds.coords.keys() + assert 'range' in mpl_ds.coords.keys() + assert mpl_ds.coords['time'].values.shape == (102,) + assert mpl_ds.coords['range'].values.shape == (1000,) + assert '_arm_standards_flag' in mpl_ds.attrs.keys() + + # Tests attributes + assert '_datastream' in mpl_ds.attrs.keys() + mpl_ds.close() diff --git a/tests/io/test_neon.py b/tests/io/test_neon.py new file mode 100644 index 0000000000..504146646f --- /dev/null +++ b/tests/io/test_neon.py @@ -0,0 +1,23 @@ +import glob + +import act + + +def test_read_neon(): + data_file = glob.glob(act.tests.EXAMPLE_NEON) + variable_file = glob.glob(act.tests.EXAMPLE_NEON_VARIABLE) + position_file = glob.glob(act.tests.EXAMPLE_NEON_POSITION) + + ds = act.io.neon.read_neon_csv(data_file) + assert len(ds['time'].values) == 17280 + assert 'time' in ds + assert 'tempSingleMean' in ds + assert ds['tempSingleMean'].values[0] == -0.6003 + + ds = act.io.neon.read_neon_csv( + data_file, variable_files=variable_file, position_files=position_file + ) + assert ds['northOffset'].values == -5.79 + assert ds['tempSingleMean'].attrs['units'] == 'celsius' + assert 'lat' in ds + assert ds['lat'].values == 71.282425 diff --git a/tests/io/test_noaagml.py b/tests/io/test_noaagml.py new file mode 100644 index 0000000000..8484073f07 --- /dev/null +++ b/tests/io/test_noaagml.py @@ -0,0 +1,130 @@ +import numpy as np + +import act +from act.io import read_gml +from act.tests import sample_files + + +def test_read_gml(): + # Test Radiation + ds = read_gml(sample_files.EXAMPLE_GML_RADIATION, datatype='RADIATION') + assert np.isclose(np.nansum(ds['solar_zenith_angle']), 1725.28) + assert np.isclose(np.nansum(ds['upwelling_infrared_case_temp']), 4431.88) + assert ( + ds['upwelling_infrared_case_temp'].attrs['ancillary_variables'] + == 'qc_upwelling_infrared_case_temp' + ) + assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_values'] == [0, 1, 2] + assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_meanings'] == [ + 'Not failing any tests', + 'Knowingly bad value', + 'Should be used with scrutiny', + ] + assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_assessments'] == [ + 'Good', + 'Bad', + 'Indeterminate', + ] + assert ds['time'].values[-1] == np.datetime64('2021-01-01T00:17:00') + + ds = read_gml(sample_files.EXAMPLE_GML_RADIATION, convert_missing=False) + assert np.isclose(np.nansum(ds['solar_zenith_angle']), 1725.28) + assert np.isclose(np.nansum(ds['upwelling_infrared_case_temp']), 4431.88) + assert ( + ds['upwelling_infrared_case_temp'].attrs['ancillary_variables'] + == 'qc_upwelling_infrared_case_temp' + ) + assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_values'] == [0, 1, 2] + assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_meanings'] == [ + 'Not failing any tests', + 'Knowingly bad value', + 'Should be used with scrutiny', + ] + assert ds['qc_upwelling_infrared_case_temp'].attrs['flag_assessments'] == [ + 'Good', + 'Bad', + 'Indeterminate', + ] + assert ds['time'].values[-1] == np.datetime64('2021-01-01T00:17:00') + + # Test MET + ds = read_gml(sample_files.EXAMPLE_GML_MET, datatype='MET') + assert np.isclose(np.nansum(ds['wind_speed'].values), 148.1) + assert ds['wind_speed'].attrs['units'] == 'm/s' + assert np.isnan(ds['wind_speed'].attrs['_FillValue']) + assert np.sum(np.isnan(ds['preciptation_intensity'].values)) == 20 + assert ds['preciptation_intensity'].attrs['units'] == 'mm/hour' + assert ds['time'].values[0] == np.datetime64('2020-01-01T00:00:00') + + ds = read_gml(sample_files.EXAMPLE_GML_MET, convert_missing=False) + assert np.isclose(np.nansum(ds['wind_speed'].values), 148.1) + assert ds['wind_speed'].attrs['units'] == 'm/s' + assert np.isclose(ds['wind_speed'].attrs['_FillValue'], -999.9) + assert np.sum(ds['preciptation_intensity'].values) == -1980 + assert ds['preciptation_intensity'].attrs['units'] == 'mm/hour' + assert ds['time'].values[0] == np.datetime64('2020-01-01T00:00:00') + + # Test Ozone + ds = read_gml(sample_files.EXAMPLE_GML_OZONE, datatype='OZONE') + assert np.isclose(np.nansum(ds['ozone'].values), 582.76) + assert ds['ozone'].attrs['long_name'] == 'Ozone' + assert ds['ozone'].attrs['units'] == 'ppb' + assert np.isnan(ds['ozone'].attrs['_FillValue']) + assert ds['time'].values[0] == np.datetime64('2020-12-01T00:00:00') + + ds = read_gml(sample_files.EXAMPLE_GML_OZONE) + assert np.isclose(np.nansum(ds['ozone'].values), 582.76) + assert ds['ozone'].attrs['long_name'] == 'Ozone' + assert ds['ozone'].attrs['units'] == 'ppb' + assert np.isnan(ds['ozone'].attrs['_FillValue']) + assert ds['time'].values[0] == np.datetime64('2020-12-01T00:00:00') + + # Test Carbon Dioxide + ds = read_gml(sample_files.EXAMPLE_GML_CO2, datatype='co2') + assert np.isclose(np.nansum(ds['co2'].values), 2307.630) + assert ( + ds['qc_co2'].values == np.array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], dtype=int) + ).all() + assert ds['co2'].attrs['units'] == 'ppm' + assert np.isnan(ds['co2'].attrs['_FillValue']) + assert ds['qc_co2'].attrs['flag_assessments'] == ['Bad', 'Indeterminate'] + assert ds['latitude'].attrs['standard_name'] == 'latitude' + + ds = read_gml(sample_files.EXAMPLE_GML_CO2, convert_missing=False) + assert np.isclose(np.nansum(ds['co2'].values), -3692.3098) + assert ds['co2'].attrs['_FillValue'] == -999.99 + assert ( + ds['qc_co2'].values == np.array([1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], dtype=int) + ).all() + assert ds['co2'].attrs['units'] == 'ppm' + assert np.isclose(ds['co2'].attrs['_FillValue'], -999.99) + assert ds['qc_co2'].attrs['flag_assessments'] == ['Bad', 'Indeterminate'] + assert ds['latitude'].attrs['standard_name'] == 'latitude' + + # Test Halocarbon + ds = read_gml(sample_files.EXAMPLE_GML_HALO, datatype='HALO') + assert np.isclose(np.nansum(ds['CCl4'].values), 1342.65) + assert ds['CCl4'].attrs['units'] == 'ppt' + assert ds['CCl4'].attrs['long_name'] == 'Carbon Tetrachloride (CCl4) daily median' + assert np.isnan(ds['CCl4'].attrs['_FillValue']) + assert ds['time'].values[0] == np.datetime64('1998-06-16T00:00:00') + + ds = read_gml(sample_files.EXAMPLE_GML_HALO) + assert np.isclose(np.nansum(ds['CCl4'].values), 1342.65) + assert ds['CCl4'].attrs['units'] == 'ppt' + assert ds['CCl4'].attrs['long_name'] == 'Carbon Tetrachloride (CCl4) daily median' + assert np.isnan(ds['CCl4'].attrs['_FillValue']) + assert ds['time'].values[0] == np.datetime64('1998-06-16T00:00:00') + + +def test_read_surfrad(): + url = ['https://gml.noaa.gov/aftp/data/radiation/surfrad/Boulder_CO/2023/tbl23008.dat'] + ds = act.io.noaagml.read_surfrad(url) + + assert 'qc_pressure' in ds + assert 'time' in ds + assert ds['wind_speed'].attrs['units'] == 'ms^-1' + assert len(ds) == 48 + assert ds['temperature'].values[0] == 2.0 + assert 'standard_name' in ds['temperature'].attrs + assert ds['temperature'].attrs['standard_name'] == 'air_temperature' diff --git a/tests/io/test_noaapsl.py b/tests/io/test_noaapsl.py new file mode 100644 index 0000000000..35326ea592 --- /dev/null +++ b/tests/io/test_noaapsl.py @@ -0,0 +1,143 @@ +import numpy as np +import pytest + +import act +from act.io import read_psl_surface_met, read_psl_wind_profiler_temperature +from act.tests import sample_files + + +def test_read_psl_wind_profiler(): + test_ds_low, test_ds_hi = act.io.noaapsl.read_psl_wind_profiler( + act.tests.EXAMPLE_NOAA_PSL, transpose=False + ) + # test dimensions + assert 'time' and 'HT' in test_ds_low.dims.keys() + assert 'time' and 'HT' in test_ds_hi.dims.keys() + assert test_ds_low.dims['time'] == 4 + assert test_ds_hi.dims['time'] == 4 + assert test_ds_low.dims['HT'] == 49 + assert test_ds_hi.dims['HT'] == 50 + + # test coordinates + assert (test_ds_low.coords['HT'][0:5] == np.array([0.151, 0.254, 0.356, 0.458, 0.561])).all() + assert ( + test_ds_low.coords['time'][0:2] + == np.array( + ['2021-05-05T15:00:01.000000000', '2021-05-05T15:15:49.000000000'], + dtype='datetime64[ns]', + ) + ).all() + + # test attributes + assert test_ds_low.attrs['site_identifier'] == 'CTD' + assert test_ds_low.attrs['data_type'] == 'WINDS' + assert test_ds_low.attrs['revision_number'] == '5.1' + assert test_ds_low.attrs['latitude'] == 34.66 + assert test_ds_low.attrs['longitude'] == -87.35 + assert test_ds_low.attrs['elevation'] == 187.0 + assert ( + test_ds_low.attrs['beam_azimuth'] == np.array([38.0, 38.0, 308.0], dtype='float32') + ).all() + assert ( + test_ds_low.attrs['beam_elevation'] == np.array([90.0, 74.7, 74.7], dtype='float32') + ).all() + assert test_ds_low.attrs['consensus_average_time'] == 24 + assert test_ds_low.attrs['oblique-beam_vertical_correction'] == 0 + assert test_ds_low.attrs['number_of_beams'] == 3 + assert test_ds_low.attrs['number_of_range_gates'] == 49 + assert test_ds_low.attrs['number_of_gates_oblique'] == 49 + assert test_ds_low.attrs['number_of_gates_vertical'] == 49 + assert test_ds_low.attrs['number_spectral_averages_oblique'] == 50 + assert test_ds_low.attrs['number_spectral_averages_vertical'] == 50 + assert test_ds_low.attrs['pulse_width_oblique'] == 708 + assert test_ds_low.attrs['pulse_width_vertical'] == 708 + assert test_ds_low.attrs['inner_pulse_period_oblique'] == 50 + assert test_ds_low.attrs['inner_pulse_period_vertical'] == 50 + assert test_ds_low.attrs['full_scale_doppler_value_oblique'] == 20.9 + assert test_ds_low.attrs['full_scale_doppler_value_vertical'] == 20.9 + assert test_ds_low.attrs['delay_to_first_gate_oblique'] == 4000 + assert test_ds_low.attrs['delay_to_first_gate_vertical'] == 4000 + assert test_ds_low.attrs['spacing_of_gates_oblique'] == 708 + assert test_ds_low.attrs['spacing_of_gates_vertical'] == 708 + + # test fields + assert test_ds_low['RAD1'].shape == (4, 49) + assert test_ds_hi['RAD1'].shape == (4, 50) + assert (test_ds_low['RAD1'][0, 0:5] == np.array([0.2, 0.1, 0.1, 0.0, -0.1])).all() + assert (test_ds_hi['RAD1'][0, 0:5] == np.array([0.1, 0.1, -0.1, 0.0, -0.2])).all() + + assert test_ds_low['SPD'].shape == (4, 49) + assert test_ds_hi['SPD'].shape == (4, 50) + assert (test_ds_low['SPD'][0, 0:5] == np.array([2.5, 3.3, 4.3, 4.3, 4.8])).all() + assert (test_ds_hi['SPD'][0, 0:5] == np.array([3.7, 4.6, 6.3, 5.2, 6.8])).all() + + # test transpose + test_ds_low, test_ds_hi = act.io.noaapsl.read_psl_wind_profiler( + act.tests.EXAMPLE_NOAA_PSL, transpose=True + ) + assert test_ds_low['RAD1'].shape == (49, 4) + assert test_ds_hi['RAD1'].shape == (50, 4) + assert test_ds_low['SPD'].shape == (49, 4) + assert test_ds_hi['SPD'].shape == (50, 4) + test_ds_low.close() + + +def test_read_psl_wind_profiler_temperature(): + ds = read_psl_wind_profiler_temperature(act.tests.EXAMPLE_NOAA_PSL_TEMPERATURE) + + assert ds.attrs['site_identifier'] == 'CTD' + assert ds.attrs['elevation'] == 600.0 + assert ds.T.values[0] == 33.2 + + +def test_read_psl_surface_met(): + ds = read_psl_surface_met(sample_files.EXAMPLE_NOAA_PSL_SURFACEMET) + assert ds.time.size == 2 + assert np.isclose(np.sum(ds['Pressure'].values), 1446.9) + assert np.isclose(ds['lat'].values, 38.972425) + assert ds['lat'].attrs['units'] == 'degree_N' + assert ds['Upward_Longwave_Irradiance'].attrs['long_name'] == 'Upward Longwave Irradiance' + assert ds['Upward_Longwave_Irradiance'].dtype.str == '= np.datetime64('2019-01-01 06:00:00') + ) + ds = ds.sel({'time': index}) + + index = (ds.time.values <= np.datetime64('2019-01-01 18:34:00')) | ( + ds.time.values >= np.datetime64('2019-01-01 19:06:00') + ) + ds = ds.sel({'time': index}) + + index = (ds.time.values <= np.datetime64('2019-01-01 12:30:00')) | ( + ds.time.values >= np.datetime64('2019-01-01 12:40:00') + ) + ds = ds.sel({'time': index}) + + display = TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(1,)) + display.plot('temp_mean', subplot_index=(0,), add_nan=True, day_night_background=True) + ds.close() + + try: + return display.fig + finally: + matplotlib.pyplot.close(display.fig) + + +@pytest.mark.mpl_image_compare(tolerance=30) +def test_timeseries_invert(): + ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_IRT25m20s) + display = TimeSeriesDisplay(ds, figsize=(10, 8)) + display.plot('inst_sfc_ir_temp', invert_y_axis=True) + ds.close() + return display.fig + + +def test_plot_time_rng(): + # Test if setting the xrange can be done with pandas or datetime datatype + # eventhough the data is numpy. Check for correctly converting xrange values + # before setting and not causing an exception. + met = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) + + # Plot data + xrng = [datetime(2019, 1, 1, 0, 0), datetime(2019, 1, 2, 0, 0)] + display = TimeSeriesDisplay(met) + display.plot('temp_mean', time_rng=xrng) + + xrng = [pd.to_datetime('2019-01-01'), pd.to_datetime('2019-01-02')] + display = TimeSeriesDisplay(met) + display.plot('temp_mean', time_rng=xrng) + + +@pytest.mark.mpl_image_compare(tolerance=30) +def test_match_ylimits_plot(): + files = sample_files.EXAMPLE_MET_WILDCARD + ds = act.io.arm.read_arm_netcdf(files) + display = act.plotting.TimeSeriesDisplay(ds, figsize=(10, 8), subplot_shape=(2, 2)) + groupby = display.group_by('day') + groupby.plot_group('plot', None, field='temp_mean', marker=' ') + groupby.display.set_yrng([-20, 20], match_axes_ylimits=True) + ds.close() + return display.fig + + +@pytest.mark.mpl_image_compare(tolerance=30) +def test_xlim_correction_plot(): + ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) + + # Plot data + xrng = [datetime(2019, 1, 1, 0, 0, 0), datetime(2019, 1, 1, 0, 0, 0)] + display = TimeSeriesDisplay(ds) + display.plot('temp_mean', time_rng=xrng) + + ds.close() + + return display.fig diff --git a/tests/plotting/test_windrosedisplay.py b/tests/plotting/test_windrosedisplay.py new file mode 100644 index 0000000000..b332e806ee --- /dev/null +++ b/tests/plotting/test_windrosedisplay.py @@ -0,0 +1,156 @@ +import matplotlib +import numpy as np +import pytest + +import act +from act.plotting import WindRoseDisplay +from act.tests import sample_files + +matplotlib.use('Agg') + + +@pytest.mark.mpl_image_compare(tolerance=30) +def test_wind_rose(): + sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_TWP_SONDE_WILDCARD) + + WindDisplay = WindRoseDisplay(sonde_ds, figsize=(10, 10)) + WindDisplay.plot( + 'deg', + 'wspd', + spd_bins=np.linspace(0, 20, 10), + num_dirs=30, + tick_interval=2, + cmap='viridis', + ) + WindDisplay.set_thetarng(trng=(0.0, 360.0)) + WindDisplay.set_rrng((0.0, 14)) + + sonde_ds.close() + + try: + return WindDisplay.fig + finally: + matplotlib.pyplot.close(WindDisplay.fig) + + +@pytest.mark.mpl_image_compare(tolerance=30) +def test_plot_datarose(): + files = sample_files.EXAMPLE_MET_WILDCARD + ds = act.io.arm.read_arm_netcdf(files) + display = act.plotting.WindRoseDisplay(ds, subplot_shape=(2, 3), figsize=(16, 10)) + display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='line', + subplot_index=(0, 0), + ) + display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='line', + subplot_index=(0, 1), + line_plot_calc='median', + ) + display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='line', + subplot_index=(0, 2), + line_plot_calc='stdev', + ) + display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='contour', + subplot_index=(1, 0), + ) + display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='contour', + contour_type='mean', + num_data_bins=10, + clevels=21, + cmap='rainbow', + vmin=-5, + vmax=20, + subplot_index=(1, 1), + ) + display.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='boxplot', + subplot_index=(1, 2), + ) + + display2 = act.plotting.WindRoseDisplay( + {'ds1': ds, 'ds2': ds}, subplot_shape=(2, 3), figsize=(16, 10) + ) + with np.testing.assert_raises(ValueError): + display2.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + dsname='ds1', + num_dirs=12, + plot_type='line', + line_plot_calc='T', + subplot_index=(0, 0), + ) + with np.testing.assert_raises(ValueError): + display2.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='line', + subplot_index=(0, 0), + ) + with np.testing.assert_raises(ValueError): + display2.plot_data( + 'wdir_vec_mean', + 'wspd_vec_mean', + 'temp_mean', + num_dirs=12, + plot_type='groovy', + subplot_index=(0, 0), + ) + + return display.fig + + +@pytest.mark.mpl_image_compare(tolerance=30) +def test_groupby_plot(): + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_MET_WILDCARD) + + # Create Plot Display + display = WindRoseDisplay(ds, figsize=(15, 15), subplot_shape=(3, 3)) + groupby = display.group_by('day') + groupby.plot_group( + 'plot_data', + None, + dir_field='wdir_vec_mean', + spd_field='wspd_vec_mean', + data_field='temp_mean', + num_dirs=12, + plot_type='line', + ) + + # Set theta tick markers for each axis inside display to be inside the polar axes + for i in range(3): + for j in range(3): + display.axes[i, j].tick_params(pad=-20) + ds.close() + return display.fig diff --git a/tests/plotting/test_xsectiondisplay.py b/tests/plotting/test_xsectiondisplay.py new file mode 100644 index 0000000000..29d460a729 --- /dev/null +++ b/tests/plotting/test_xsectiondisplay.py @@ -0,0 +1,77 @@ +import matplotlib +import numpy as np +import pytest + +import act +from act.plotting import XSectionDisplay +from act.tests import sample_files + +try: + import cartopy + + CARTOPY_AVAILABLE = True +except ImportError: + CARTOPY_AVAILABLE = False + +matplotlib.use('Agg') + + +def test_xsection_errors(): + ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_CEIL1) + + display = XSectionDisplay(ds, figsize=(10, 8), subplot_shape=(2,)) + display.axes = None + with np.testing.assert_raises(RuntimeError): + display.set_yrng([0, 10]) + with np.testing.assert_raises(RuntimeError): + display.set_xrng([-40, 40]) + + display = XSectionDisplay(ds, figsize=(10, 8), subplot_shape=(1,)) + with np.testing.assert_raises(RuntimeError): + display.plot_xsection(None, 'backscatter', x='time', cmap='HomeyerRainbow') + + ds.close() + matplotlib.pyplot.close(fig=display.fig) + + +@pytest.mark.mpl_image_compare(tolerance=31) +def test_xsection_plot(): + visst_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_CEIL1) + + xsection = XSectionDisplay(visst_ds, figsize=(10, 8)) + xsection.plot_xsection( + None, 'backscatter', x='time', y='range', cmap='coolwarm', vmin=0, vmax=320 + ) + visst_ds.close() + + try: + return xsection.fig + finally: + matplotlib.pyplot.close(xsection.fig) + + +@pytest.mark.skipif(not CARTOPY_AVAILABLE, reason='Cartopy is not installed.') +@pytest.mark.mpl_image_compare(tolerance=30) +def test_xsection_plot_map(): + radar_ds = act.io.arm.read_arm_netcdf( + sample_files.EXAMPLE_VISST, combine='nested', concat_dim='time' + ) + try: + xsection = XSectionDisplay(radar_ds, figsize=(15, 8)) + xsection.plot_xsection_map( + None, + 'ir_temperature', + vmin=220, + vmax=300, + cmap='Greys', + x='longitude', + y='latitude', + isel_kwargs={'time': 0}, + ) + radar_ds.close() + try: + return xsection.fig + finally: + matplotlib.pyplot.close(xsection.fig) + except Exception: + pass diff --git a/tests/qc/test_add_supplemental_qc.py b/tests/qc/test_add_supplemental_qc.py new file mode 100644 index 0000000000..b90c475189 --- /dev/null +++ b/tests/qc/test_add_supplemental_qc.py @@ -0,0 +1,79 @@ +from pathlib import Path + +import numpy as np + +from act.io.arm import read_arm_netcdf +from act.qc.add_supplemental_qc import apply_supplemental_qc, read_yaml_supplemental_qc +from act.tests import EXAMPLE_MET1, EXAMPLE_MET_YAML + + +def test_read_yaml_supplemental_qc(): + ds = read_arm_netcdf( + EXAMPLE_MET1, keep_variables=['temp_mean', 'qc_temp_mean'], cleanup_qc=True + ) + + result = read_yaml_supplemental_qc(ds, EXAMPLE_MET_YAML) + assert isinstance(result, dict) + assert len(result.keys()) == 3 + + result = read_yaml_supplemental_qc( + ds, + Path(EXAMPLE_MET_YAML).parent, + variables='temp_mean', + assessments=['Bad', 'Incorrect', 'Suspect'], + ) + assert len(result.keys()) == 2 + assert sorted(result['temp_mean'].keys()) == ['Bad', 'Suspect'] + + result = read_yaml_supplemental_qc(ds, 'sgpmetE13.b1.yaml', quiet=True) + assert result is None + + apply_supplemental_qc(ds, EXAMPLE_MET_YAML) + assert ds['qc_temp_mean'].attrs['flag_masks'] == [1, 2, 4, 8, 16, 32, 64, 128, 256] + assert ds['qc_temp_mean'].attrs['flag_assessments'] == [ + 'Bad', + 'Bad', + 'Bad', + 'Indeterminate', + 'Bad', + 'Bad', + 'Suspect', + 'Good', + 'Bad', + ] + assert ds['qc_temp_mean'].attrs['flag_meanings'][0] == 'Value is equal to missing_value.' + assert ds['qc_temp_mean'].attrs['flag_meanings'][-1] == 'Values are bad for all' + assert ds['qc_temp_mean'].attrs['flag_meanings'][-2] == 'Values are good' + assert np.sum(ds['qc_temp_mean'].values) == 81344 + assert np.count_nonzero(ds['qc_temp_mean'].values) == 1423 + + del ds + + ds = read_arm_netcdf( + EXAMPLE_MET1, keep_variables=['temp_mean', 'qc_temp_mean'], cleanup_qc=True + ) + apply_supplemental_qc(ds, Path(EXAMPLE_MET_YAML).parent, apply_all=False) + assert ds['qc_temp_mean'].attrs['flag_masks'] == [1, 2, 4, 8, 16, 32, 64, 128] + + ds = read_arm_netcdf(EXAMPLE_MET1, cleanup_qc=True) + apply_supplemental_qc(ds, Path(EXAMPLE_MET_YAML).parent, exclude_all_variables='temp_mean') + assert ds['qc_rh_mean'].attrs['flag_masks'] == [1, 2, 4, 8, 16, 32, 64, 128] + assert 'Values are bad for all' in ds['qc_rh_mean'].attrs['flag_meanings'] + assert 'Values are bad for all' not in ds['qc_temp_mean'].attrs['flag_meanings'] + + del ds + + ds = read_arm_netcdf(EXAMPLE_MET1, keep_variables=['temp_mean', 'rh_mean']) + apply_supplemental_qc( + ds, + Path(EXAMPLE_MET_YAML).parent, + exclude_all_variables='temp_mean', + assessments='Bad', + quiet=True, + ) + assert ds['qc_rh_mean'].attrs['flag_assessments'] == ['Bad'] + assert ds['qc_temp_mean'].attrs['flag_assessments'] == ['Bad', 'Bad'] + assert np.sum(ds['qc_rh_mean'].values) == 124 + assert np.sum(ds['qc_temp_mean'].values) == 2840 + + del ds diff --git a/tests/qc/test_arm_qc.py b/tests/qc/test_arm_qc.py new file mode 100644 index 0000000000..e118648706 --- /dev/null +++ b/tests/qc/test_arm_qc.py @@ -0,0 +1,33 @@ +import numpy as np + +from act.io.arm import read_arm_netcdf +from act.qc.arm import add_dqr_to_qc +from act.tests import EXAMPLE_ENA_MET, EXAMPLE_OLD_QC + + +def test_scalar_dqr(): + # Test DQR Webservice using known DQR + ds = read_arm_netcdf(EXAMPLE_ENA_MET) + + # DQR webservice does go down, so ensure it + # properly runs first before testing + try: + ds = add_dqr_to_qc(ds) + ran = True + except ValueError: + ran = False + + if ran: + assert 'qc_lat' in ds + assert np.size(ds['qc_lon'].values) == 1 + assert np.size(ds['qc_lat'].values) == 1 + assert np.size(ds['qc_alt'].values) == 1 + assert np.size(ds['base_time'].values) == 1 + + +def test_get_attr_info(): + ds = read_arm_netcdf(EXAMPLE_OLD_QC, cleanup_qc=True) + assert 'flag_assessments' in ds['qc_lv'].attrs + assert 'fail_min' in ds['qc_lv'].attrs + assert ds['qc_lv'].attrs['flag_assessments'][0] == 'Bad' + assert ds['qc_lv'].attrs['flag_masks'][-1] == 4 diff --git a/tests/qc/test_bsrn_tests.py b/tests/qc/test_bsrn_tests.py new file mode 100644 index 0000000000..c83d1c65db --- /dev/null +++ b/tests/qc/test_bsrn_tests.py @@ -0,0 +1,279 @@ +import copy + +import dask.array as da +import numpy as np +import xarray as xr + +from act.io.arm import read_arm_netcdf +from act.qc.bsrn_tests import _calculate_solar_parameters +from act.tests import EXAMPLE_BRS + + +def test_bsrn_limits_test(): + for use_dask in [False, True]: + ds = read_arm_netcdf(EXAMPLE_BRS) + var_names = list(ds.data_vars) + # Remove QC variables to make testing easier + for var_name in var_names: + if var_name.startswith('qc_'): + del ds[var_name] + + # Add atmospheric temperature fake data + ds['temp_mean'] = xr.DataArray( + data=np.full(ds.time.size, 13.5), + dims=['time'], + attrs={'long_name': 'Atmospheric air temperature', 'units': 'degC'}, + ) + + # Make a short direct variable since BRS does not have one + ds['short_direct'] = copy.deepcopy(ds['short_direct_normal']) + ds['short_direct'].attrs['ancillary_variables'] = 'qc_short_direct' + ds['short_direct'].attrs['long_name'] = 'Shortwave direct irradiance, pyrheliometer' + _, _ = _calculate_solar_parameters(ds, 'lat', 'lon', 1360.8) + ds['short_direct'].data = ds['short_direct'].data * 0.5 + + # Make up long variable since BRS does not have values + ds['up_long_hemisp'].data = copy.deepcopy(ds['down_long_hemisp_shaded'].data) + data = copy.deepcopy(ds['down_short_hemisp'].data) + ds['up_short_hemisp'].data = data + + # Test that nothing happens when no variable names are provided + ds.qcfilter.bsrn_limits_test() + + # Mess with data to get tests to trip + data = ds['down_short_hemisp'].values + data[200:300] -= 10 + data[800:850] += 330 + data[1340:1380] += 600 + ds['down_short_hemisp'].data = da.from_array(data) + + data = ds['down_short_diffuse_hemisp'].values + data[200:250] = data[200:250] - 1.9 + data[250:300] = data[250:300] - 3.9 + data[800:850] += 330 + data[1340:1380] += 600 + ds['down_short_diffuse_hemisp'].data = da.from_array(data) + + data = ds['short_direct_normal'].values + data[200:250] = data[200:250] - 1.9 + data[250:300] = data[250:300] - 3.9 + data[800:850] += 600 + data[1340:1380] += 800 + ds['short_direct_normal'].data = da.from_array(data) + + data = ds['short_direct'].values + data[200:250] = data[200:250] - 1.9 + data[250:300] = data[250:300] - 3.9 + data[800:850] += 300 + data[1340:1380] += 800 + ds['short_direct'].data = da.from_array(data) + + data = ds['down_long_hemisp_shaded'].values + data[200:250] = data[200:250] - 355 + data[250:300] = data[250:300] - 400 + data[800:850] += 200 + data[1340:1380] += 400 + ds['down_long_hemisp_shaded'].data = da.from_array(data) + + data = ds['up_long_hemisp'].values + data[200:250] = data[200:250] - 355 + data[250:300] = data[250:300] - 400 + data[800:850] += 300 + data[1340:1380] += 500 + ds['up_long_hemisp'].data = da.from_array(data) + + ds.qcfilter.bsrn_limits_test( + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', + glb_SW_up_name='up_short_hemisp', + glb_LW_dn_name='down_long_hemisp_shaded', + glb_LW_up_name='up_long_hemisp', + direct_SW_dn_name='short_direct', + use_dask=use_dask, + ) + + assert ds['qc_down_short_hemisp'].attrs['flag_masks'] == [1, 2] + assert ( + ds['qc_down_short_hemisp'].attrs['flag_meanings'][-2] + == 'Value less than BSRN physically possible limit of -4.0 W/m^2' + ) + assert ( + ds['qc_down_short_hemisp'].attrs['flag_meanings'][-1] + == 'Value greater than BSRN physically possible limit' + ) + + assert ds['qc_down_short_diffuse_hemisp'].attrs['flag_masks'] == [1, 2] + assert ds['qc_down_short_diffuse_hemisp'].attrs['flag_assessments'] == ['Bad', 'Bad'] + + assert ds['qc_short_direct'].attrs['flag_masks'] == [1, 2] + assert ds['qc_short_direct'].attrs['flag_assessments'] == ['Bad', 'Bad'] + assert ds['qc_short_direct'].attrs['flag_meanings'] == [ + 'Value less than BSRN physically possible limit of -4.0 W/m^2', + 'Value greater than BSRN physically possible limit', + ] + + assert ds['qc_short_direct_normal'].attrs['flag_masks'] == [1, 2] + assert ( + ds['qc_short_direct_normal'].attrs['flag_meanings'][-1] + == 'Value greater than BSRN physically possible limit' + ) + + assert ds['qc_down_short_hemisp'].attrs['flag_masks'] == [1, 2] + assert ( + ds['qc_down_short_hemisp'].attrs['flag_meanings'][-1] + == 'Value greater than BSRN physically possible limit' + ) + + assert ds['qc_up_short_hemisp'].attrs['flag_masks'] == [1, 2] + assert ( + ds['qc_up_short_hemisp'].attrs['flag_meanings'][-1] + == 'Value greater than BSRN physically possible limit' + ) + + assert ds['qc_up_long_hemisp'].attrs['flag_masks'] == [1, 2] + assert ( + ds['qc_up_long_hemisp'].attrs['flag_meanings'][-1] + == 'Value greater than BSRN physically possible limit of 900.0 W/m^2' + ) + + ds.qcfilter.bsrn_limits_test( + test='Extremely Rare', + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', + glb_SW_up_name='up_short_hemisp', + glb_LW_dn_name='down_long_hemisp_shaded', + glb_LW_up_name='up_long_hemisp', + direct_SW_dn_name='short_direct', + use_dask=use_dask, + ) + + assert ds['qc_down_short_hemisp'].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds['qc_down_short_diffuse_hemisp'].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds['qc_short_direct'].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds['qc_short_direct_normal'].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds['qc_up_short_hemisp'].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds['qc_up_long_hemisp'].attrs['flag_masks'] == [1, 2, 4, 8] + + assert ( + ds['qc_up_long_hemisp'].attrs['flag_meanings'][-1] + == 'Value greater than BSRN extremely rare limit of 700.0 W/m^2' + ) + + assert ( + ds['qc_down_long_hemisp_shaded'].attrs['flag_meanings'][-1] + == 'Value greater than BSRN extremely rare limit of 500.0 W/m^2' + ) + + # down_short_hemisp + result = ds.qcfilter.get_qc_test_mask('down_short_hemisp', test_number=1) + assert np.sum(result) == 100 + result = ds.qcfilter.get_qc_test_mask('down_short_hemisp', test_number=2) + assert np.sum(result) == 26 + result = ds.qcfilter.get_qc_test_mask('down_short_hemisp', test_number=3) + assert np.sum(result) == 337 + result = ds.qcfilter.get_qc_test_mask('down_short_hemisp', test_number=4) + assert np.sum(result) == 66 + + # down_short_diffuse_hemisp + result = ds.qcfilter.get_qc_test_mask('down_short_diffuse_hemisp', test_number=1) + assert np.sum(result) == 50 + result = ds.qcfilter.get_qc_test_mask('down_short_diffuse_hemisp', test_number=2) + assert np.sum(result) == 56 + result = ds.qcfilter.get_qc_test_mask('down_short_diffuse_hemisp', test_number=3) + assert np.sum(result) == 100 + result = ds.qcfilter.get_qc_test_mask('down_short_diffuse_hemisp', test_number=4) + assert np.sum(result) == 90 + + # short_direct_normal + result = ds.qcfilter.get_qc_test_mask('short_direct_normal', test_number=1) + assert np.sum(result) == 46 + result = ds.qcfilter.get_qc_test_mask('short_direct_normal', test_number=2) + assert np.sum(result) == 26 + result = ds.qcfilter.get_qc_test_mask('short_direct_normal', test_number=3) + assert np.sum(result) == 94 + result = ds.qcfilter.get_qc_test_mask('short_direct_normal', test_number=4) + assert np.sum(result) == 38 + + # short_direct_normal + result = ds.qcfilter.get_qc_test_mask('short_direct', test_number=1) + assert np.sum(result) == 41 + result = ds.qcfilter.get_qc_test_mask('short_direct', test_number=2) + assert np.sum(result) == 607 + result = ds.qcfilter.get_qc_test_mask('short_direct', test_number=3) + assert np.sum(result) == 89 + result = ds.qcfilter.get_qc_test_mask('short_direct', test_number=4) + assert np.sum(result) == 79 + + # down_long_hemisp_shaded + result = ds.qcfilter.get_qc_test_mask('down_long_hemisp_shaded', test_number=1) + assert np.sum(result) == 50 + result = ds.qcfilter.get_qc_test_mask('down_long_hemisp_shaded', test_number=2) + assert np.sum(result) == 40 + result = ds.qcfilter.get_qc_test_mask('down_long_hemisp_shaded', test_number=3) + assert np.sum(result) == 89 + result = ds.qcfilter.get_qc_test_mask('down_long_hemisp_shaded', test_number=4) + assert np.sum(result) == 90 + + # up_long_hemisp + result = ds.qcfilter.get_qc_test_mask('up_long_hemisp', test_number=1) + assert np.sum(result) == 50 + result = ds.qcfilter.get_qc_test_mask('up_long_hemisp', test_number=2) + assert np.sum(result) == 40 + result = ds.qcfilter.get_qc_test_mask('up_long_hemisp', test_number=3) + assert np.sum(result) == 89 + result = ds.qcfilter.get_qc_test_mask('up_long_hemisp', test_number=4) + assert np.sum(result) == 90 + + # Change data values to trip tests + ds['down_short_diffuse_hemisp'].values[0:100] = ( + ds['down_short_diffuse_hemisp'].values[0:100] + 100 + ) + ds['up_long_hemisp'].values[0:100] = ds['up_long_hemisp'].values[0:100] - 200 + + ds.qcfilter.bsrn_comparison_tests( + [ + 'Global over Sum SW Ratio', + 'Diffuse Ratio', + 'SW up', + 'LW down to air temp', + 'LW up to air temp', + 'LW down to LW up', + ], + gbl_SW_dn_name='down_short_hemisp', + glb_diffuse_SW_dn_name='down_short_diffuse_hemisp', + direct_normal_SW_dn_name='short_direct_normal', + glb_SW_up_name='up_short_hemisp', + glb_LW_dn_name='down_long_hemisp_shaded', + glb_LW_up_name='up_long_hemisp', + air_temp_name='temp_mean', + test_assessment='Indeterminate', + lat_name='lat', + lon_name='lon', + use_dask=use_dask, + ) + + # Ratio of Global over Sum SW + result = ds.qcfilter.get_qc_test_mask('down_short_hemisp', test_number=5) + assert np.sum(result) == 190 + + # Diffuse Ratio + result = ds.qcfilter.get_qc_test_mask('down_short_hemisp', test_number=6) + assert np.sum(result) == 47 + + # Shortwave up comparison + result = ds.qcfilter.get_qc_test_mask('up_short_hemisp', test_number=5) + assert np.sum(result) == 226 + + # Longwave up to air temperature comparison + result = ds.qcfilter.get_qc_test_mask('up_long_hemisp', test_number=5) + assert np.sum(result) == 290 + + # Longwave down to air temperature compaison + result = ds.qcfilter.get_qc_test_mask('down_long_hemisp_shaded', test_number=5) + assert np.sum(result) == 976 + + # Lonwave down to longwave up comparison + result = ds.qcfilter.get_qc_test_mask('down_long_hemisp_shaded', test_number=6) + assert np.sum(result) == 100 diff --git a/tests/qc/test_clean.py b/tests/qc/test_clean.py new file mode 100644 index 0000000000..add485b3d9 --- /dev/null +++ b/tests/qc/test_clean.py @@ -0,0 +1,156 @@ +import numpy as np + +from act.io.arm import read_arm_netcdf +from act.tests import EXAMPLE_CEIL1, EXAMPLE_CO2FLX4M, EXAMPLE_MET1 + + +def test_global_qc_cleanup(): + ds = read_arm_netcdf(EXAMPLE_MET1) + ds.load() + ds.clean.cleanup() + + assert ds['qc_wdir_vec_mean'].attrs['flag_meanings'] == [ + 'Value is equal to missing_value.', + 'Value is less than the fail_min.', + 'Value is greater than the fail_max.', + ] + assert ds['qc_wdir_vec_mean'].attrs['flag_masks'] == [1, 2, 4] + assert ds['qc_wdir_vec_mean'].attrs['flag_assessments'] == [ + 'Bad', + 'Bad', + 'Bad', + ] + + assert ds['qc_temp_mean'].attrs['flag_meanings'] == [ + 'Value is equal to missing_value.', + 'Value is less than the fail_min.', + 'Value is greater than the fail_max.', + 'Difference between current and previous values exceeds fail_delta.', + ] + assert ds['qc_temp_mean'].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds['qc_temp_mean'].attrs['flag_assessments'] == [ + 'Bad', + 'Bad', + 'Bad', + 'Indeterminate', + ] + + ds.close() + del ds + + +def test_clean(): + # Read test data + ceil_ds = read_arm_netcdf([EXAMPLE_CEIL1]) + # Cleanup QC data + ceil_ds.clean.cleanup(clean_arm_state_vars=['detection_status']) + + # Check that global attribures are removed + global_attributes = [ + 'qc_bit_comment', + 'qc_bit_1_description', + 'qc_bit_1_assessment', + 'qc_bit_2_description', + 'qc_bit_2_assessment' 'qc_bit_3_description', + 'qc_bit_3_assessment', + ] + + for glb_att in global_attributes: + assert glb_att not in ceil_ds.attrs.keys() + + # Check that CF attributes are set including new flag_assessments + var_name = 'qc_first_cbh' + for attr_name in ['flag_masks', 'flag_meanings', 'flag_assessments']: + assert attr_name in ceil_ds[var_name].attrs.keys() + assert isinstance(ceil_ds[var_name].attrs[attr_name], list) + + # Check that the flag_mask values are set correctly + assert ceil_ds['qc_first_cbh'].attrs['flag_masks'] == [1, 2, 4] + + # Check that the flag_meanings values are set correctly + assert ceil_ds['qc_first_cbh'].attrs['flag_meanings'] == [ + 'Value is equal to missing_value.', + 'Value is less than the fail_min.', + 'Value is greater than the fail_max.', + ] + + # Check the value of flag_assessments is as expected + assert ceil_ds['qc_first_cbh'].attrs['flag_assessments'] == ['Bad', 'Bad', 'Bad'] + + # Check that ancillary varibles is being added + assert 'qc_first_cbh' in ceil_ds['first_cbh'].attrs['ancillary_variables'].split() + + # Check that state field is updated to CF + assert 'flag_values' in ceil_ds['detection_status'].attrs.keys() + assert isinstance(ceil_ds['detection_status'].attrs['flag_values'], list) + assert ceil_ds['detection_status'].attrs['flag_values'] == [0, 1, 2, 3, 4, 5] + + assert 'flag_meanings' in ceil_ds['detection_status'].attrs.keys() + assert isinstance(ceil_ds['detection_status'].attrs['flag_meanings'], list) + assert ceil_ds['detection_status'].attrs['flag_meanings'] == [ + 'No significant backscatter', + 'One cloud base detected', + 'Two cloud bases detected', + 'Three cloud bases detected', + 'Full obscuration determined but no cloud base detected', + 'Some obscuration detected but determined to be transparent', + ] + + assert 'flag_0_description' not in ceil_ds['detection_status'].attrs.keys() + assert 'detection_status' in ceil_ds['first_cbh'].attrs['ancillary_variables'].split() + + ceil_ds.close() + + +def test_qc_remainder(): + ds = read_arm_netcdf(EXAMPLE_MET1) + assert ds.clean.get_attr_info(variable='bad_name') is None + del ds.attrs['qc_bit_comment'] + assert isinstance(ds.clean.get_attr_info(), dict) + ds.attrs['qc_flag_comment'] = 'testing' + ds.close() + + ds = read_arm_netcdf(EXAMPLE_MET1) + ds.clean.cleanup(normalize_assessment=True) + ds['qc_atmos_pressure'].attrs['units'] = 'testing' + del ds['qc_temp_mean'].attrs['units'] + del ds['qc_temp_mean'].attrs['flag_masks'] + ds.clean.handle_missing_values() + ds.close() + + ds = read_arm_netcdf(EXAMPLE_MET1) + ds.attrs['qc_bit_1_comment'] = 'tesing' + data = ds['qc_atmos_pressure'].values.astype(np.int64) + data[0] = 2**32 + ds['qc_atmos_pressure'].values = data + ds.clean.get_attr_info(variable='qc_atmos_pressure') + ds.clean.clean_arm_state_variables('testname') + ds.clean.cleanup() + ds['qc_atmos_pressure'].attrs['standard_name'] = 'wrong_name' + ds.clean.link_variables() + assert ds['qc_atmos_pressure'].attrs['standard_name'] == 'quality_flag' + ds.close() + + +def test_qc_flag_description(): + """ + This will check if the cleanup() method will correctly convert convert + flag_#_description to CF flag_masks and flag_meanings. + + """ + + ds = read_arm_netcdf(EXAMPLE_CO2FLX4M) + ds.clean.cleanup() + qc_var_name = ds.qcfilter.check_for_ancillary_qc( + 'momentum_flux', add_if_missing=False, cleanup=False + ) + + assert isinstance(ds[qc_var_name].attrs['flag_masks'], list) + assert isinstance(ds[qc_var_name].attrs['flag_meanings'], list) + assert isinstance(ds[qc_var_name].attrs['flag_assessments'], list) + assert ds[qc_var_name].attrs['standard_name'] == 'quality_flag' + + assert len(ds[qc_var_name].attrs['flag_masks']) == 9 + unique_flag_assessments = list({'Acceptable', 'Indeterminate', 'Bad'}) + for f in list(set(ds[qc_var_name].attrs['flag_assessments'])): + assert f in unique_flag_assessments diff --git a/tests/qc/test_comparison_tests.py b/tests/qc/test_comparison_tests.py new file mode 100644 index 0000000000..98b8149420 --- /dev/null +++ b/tests/qc/test_comparison_tests.py @@ -0,0 +1,97 @@ +import copy + +import numpy as np + +from act.io.arm import read_arm_netcdf +from act.tests import EXAMPLE_MET1 + + +def test_compare_time_series_trends(): + drop_vars = [ + 'base_time', + 'time_offset', + 'atmos_pressure', + 'qc_atmos_pressure', + 'temp_std', + 'rh_mean', + 'qc_rh_mean', + 'rh_std', + 'vapor_pressure_mean', + 'qc_vapor_pressure_mean', + 'vapor_pressure_std', + 'wspd_arith_mean', + 'qc_wspd_arith_mean', + 'wspd_vec_mean', + 'qc_wspd_vec_mean', + 'wdir_vec_mean', + 'qc_wdir_vec_mean', + 'wdir_vec_std', + 'tbrg_precip_total', + 'qc_tbrg_precip_total', + 'tbrg_precip_total_corr', + 'qc_tbrg_precip_total_corr', + 'org_precip_rate_mean', + 'qc_org_precip_rate_mean', + 'pwd_err_code', + 'pwd_mean_vis_1min', + 'qc_pwd_mean_vis_1min', + 'pwd_mean_vis_10min', + 'qc_pwd_mean_vis_10min', + 'pwd_pw_code_inst', + 'qc_pwd_pw_code_inst', + 'pwd_pw_code_15min', + 'qc_pwd_pw_code_15min', + 'pwd_pw_code_1hr', + 'qc_pwd_pw_code_1hr', + 'pwd_precip_rate_mean_1min', + 'qc_pwd_precip_rate_mean_1min', + 'pwd_cumul_rain', + 'qc_pwd_cumul_rain', + 'pwd_cumul_snow', + 'qc_pwd_cumul_snow', + 'logger_volt', + 'qc_logger_volt', + 'logger_temp', + 'qc_logger_temp', + 'lat', + 'lon', + 'alt', + ] + ds = read_arm_netcdf(EXAMPLE_MET1, drop_variables=drop_vars) + ds.clean.cleanup() + ds2 = copy.deepcopy(ds) + + var_name = 'temp_mean' + qc_var_name = ds.qcfilter.check_for_ancillary_qc( + var_name, add_if_missing=False, cleanup=False, flag_type=False + ) + ds.qcfilter.compare_time_series_trends( + var_name=var_name, + time_shift=60, + comp_var_name=var_name, + comp_dataset=ds2, + time_qc_threshold=60 * 10, + ) + + test_description = ( + 'Time shift detected with Minimum Difference test. Comparison of ' + 'temp_mean with temp_mean off by 0 seconds exceeding absolute ' + 'threshold of 600 seconds.' + ) + assert ds[qc_var_name].attrs['flag_meanings'][-1] == test_description + + time = ds2['time'].values + np.timedelta64(1, 'h') + time_attrs = ds2['time'].attrs + ds2 = ds2.assign_coords({'time': time}) + ds2['time'].attrs = time_attrs + + ds.qcfilter.compare_time_series_trends( + var_name=var_name, comp_dataset=ds2, time_step=60, time_match_threshhold=50 + ) + + test_description = ( + 'Time shift detected with Minimum Difference test. Comparison of ' + 'temp_mean with temp_mean off by 3600 seconds exceeding absolute ' + 'threshold of 900 seconds.' + ) + assert ds[qc_var_name].attrs['flag_meanings'][-1] == test_description diff --git a/tests/qc/test_qcfilter.py b/tests/qc/test_qcfilter.py new file mode 100644 index 0000000000..01a0adf643 --- /dev/null +++ b/tests/qc/test_qcfilter.py @@ -0,0 +1,469 @@ +import copy +from datetime import datetime + +import dask.array as da +import numpy as np +import pandas as pd +import pytest +import xarray as xr + +from act.io.arm import read_arm_netcdf +from act.qc.arm import add_dqr_to_qc +from act.qc.qcfilter import parse_bit, set_bit, unset_bit +from act.tests import EXAMPLE_MET1, EXAMPLE_METE40, EXAMPLE_IRT25m20s + +try: + import scikit_posthocs + + SCIKIT_POSTHOCS_AVAILABLE = True +except ImportError: + SCIKIT_POSTHOCS_AVAILABLE = False + + +def test_qc_test_errors(): + ds = read_arm_netcdf(EXAMPLE_MET1) + var_name = 'temp_mean' + + assert ds.qcfilter.add_less_test(var_name, None) is None + assert ds.qcfilter.add_greater_test(var_name, None) is None + assert ds.qcfilter.add_less_equal_test(var_name, None) is None + assert ds.qcfilter.add_equal_to_test(var_name, None) is None + assert ds.qcfilter.add_not_equal_to_test(var_name, None) is None + + +def test_arm_qc(): + # Test DQR Webservice using known DQR + variable = 'wspd_vec_mean' + ds = read_arm_netcdf(EXAMPLE_METE40) + ds_org = copy.deepcopy(ds) + qc_variable = ds.qcfilter.check_for_ancillary_qc(variable) + + # DQR webservice does go down, so ensure it properly runs first before testing + try: + ds = add_dqr_to_qc(ds) + + except ValueError: + return + + assert 'Suspect' not in ds[qc_variable].attrs['flag_assessments'] + assert 'Incorrect' not in ds[qc_variable].attrs['flag_assessments'] + assert 'Bad' in ds[qc_variable].attrs['flag_assessments'] + assert 'Indeterminate' in ds[qc_variable].attrs['flag_assessments'] + + # Check that defualt will update all variables in DQR + for var_name in ['wdir_vec_mean', 'wdir_vec_std', 'wspd_arith_mean', 'wspd_vec_mean']: + qc_var = ds.qcfilter.check_for_ancillary_qc(var_name) + assert ds[qc_var].attrs['flag_meanings'][-1].startswith('D190529.4') + + # Check that variable keyword works as expected. + ds = copy.deepcopy(ds_org) + add_dqr_to_qc(ds, variable=variable) + qc_var = ds.qcfilter.check_for_ancillary_qc(variable) + assert ds[qc_var].attrs['flag_meanings'][-1].startswith('D190529.4') + qc_var = ds.qcfilter.check_for_ancillary_qc('wdir_vec_std') + assert len(ds[qc_var].attrs['flag_masks']) == 0 + + # Check that include and exclude keywords work as expected + ds = copy.deepcopy(ds_org) + add_dqr_to_qc(ds, variable=variable, exclude=['D190529.4']) + assert len(ds[qc_variable].attrs['flag_meanings']) == 4 + add_dqr_to_qc(ds, variable=variable, include=['D400101.1']) + assert len(ds[qc_variable].attrs['flag_meanings']) == 4 + add_dqr_to_qc(ds, variable=variable, include=['D190529.4']) + assert len(ds[qc_variable].attrs['flag_meanings']) == 5 + add_dqr_to_qc(ds, variable=variable, assessment='Incorrect') + assert len(ds[qc_variable].attrs['flag_meanings']) == 5 + + # Test additional keywords + add_dqr_to_qc( + ds, + variable=variable, + assessment='Suspect', + cleanup_qc=False, + dqr_link=True, + skip_location_vars=True, + ) + assert len(ds[qc_variable].attrs['flag_meanings']) == 6 + + # Default is to normalize assessment terms. Check that we can turn off. + add_dqr_to_qc(ds, variable=variable, normalize_assessment=False) + assert 'Suspect' in ds[qc_variable].attrs['flag_assessments'] + + # Test that an error is raised when no datastream global attributes + with np.testing.assert_raises(ValueError): + ds4 = copy.deepcopy(ds) + del ds4.attrs['datastream'] + del ds4.attrs['_datastream'] + add_dqr_to_qc(ds4, variable=variable) + + +def test_qcfilter(): + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + var_name = 'inst_up_long_dome_resist' + expected_qc_var_name = 'qc_' + var_name + + ds.qcfilter.check_for_ancillary_qc( + var_name, add_if_missing=True, cleanup=False, flag_type=False + ) + assert expected_qc_var_name in list(ds.keys()) + del ds[expected_qc_var_name] + + # Perform adding of quality control variables to Xarray dataset + result = ds.qcfilter.add_test(var_name, test_meaning='Birds!') + assert isinstance(result, dict) + qc_var_name = result['qc_variable_name'] + assert qc_var_name == expected_qc_var_name + + # Check that new linking and describing attributes are set + assert ds[qc_var_name].attrs['standard_name'] == 'quality_flag' + assert ds[var_name].attrs['ancillary_variables'] == qc_var_name + + # Check that CF attributes are set including new flag_assessments + assert 'flag_masks' in ds[qc_var_name].attrs.keys() + assert 'flag_meanings' in ds[qc_var_name].attrs.keys() + assert 'flag_assessments' in ds[qc_var_name].attrs.keys() + + # Check that the values of the attributes are set correctly + assert ds[qc_var_name].attrs['flag_assessments'][0] == 'Bad' + assert ds[qc_var_name].attrs['flag_meanings'][0] == 'Birds!' + assert ds[qc_var_name].attrs['flag_masks'][0] == 1 + + # Set some test values + index = [0, 1, 2, 30] + ds.qcfilter.set_test(var_name, index=index, test_number=result['test_number']) + + # Add a new test and set values + index2 = [6, 7, 8, 50] + ds.qcfilter.add_test( + var_name, + index=index2, + test_number=9, + test_meaning='testing high number', + test_assessment='Suspect', + ) + + # Retrieve data from Xarray dataset as numpy masked array. Count number of masked + # elements and ensure equal to size of index array. + data = ds.qcfilter.get_masked_data(var_name, rm_assessments='Bad') + assert np.ma.count_masked(data) == len(index) + + data = ds.qcfilter.get_masked_data(var_name, rm_assessments='Suspect', return_nan_array=True) + assert np.sum(np.isnan(data)) == len(index2) + + data = ds.qcfilter.get_masked_data( + var_name, rm_assessments=['Bad', 'Suspect'], ma_fill_value=np.nan + ) + assert np.ma.count_masked(data) == len(index + index2) + + # Test internal function for returning the index array of where the + # tests are set. + assert ( + np.sum( + ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + - np.array(index, dtype=int) + ) + == 0 + ) + + # Test adding QC for length-1 variables + ds['west'] = ('west', ['W']) + ds['avg_wind_speed'] = ('west', [20]) + + # Should not fail the test + ds.qcfilter.add_test( + 'avg_wind_speed', + index=ds.avg_wind_speed.data > 100, + test_meaning='testing bool flag: false', + test_assessment='Suspect', + ) + assert ds.qc_avg_wind_speed.data == 0 + + # Should fail the test + ds.qcfilter.add_test( + 'avg_wind_speed', + index=ds.avg_wind_speed.data < 100, + test_meaning='testing bool flag: true', + test_assessment='Suspect', + ) + assert ds.qc_avg_wind_speed.data == 2 + + # Should fail the test + ds.qcfilter.add_test( + 'avg_wind_speed', + index=[0], + test_meaning='testing idx flag: true', + test_assessment='Suspect', + ) + assert ds.qc_avg_wind_speed.data == 6 + + # Should not fail the test + ds.qcfilter.add_test( + 'avg_wind_speed', + test_meaning='testing idx flag: false', + test_assessment='Suspect', + ) + assert ds.qc_avg_wind_speed.data == 6 + + # Unset a test + ds.qcfilter.unset_test(var_name, index=0, test_number=result['test_number']) + # Remove the test + ds.qcfilter.remove_test(var_name, test_number=33) + + # Ensure removal works when flag_masks is a numpy array + ds['qc_' + var_name].attrs['flag_masks'] = np.array(ds['qc_' + var_name].attrs['flag_masks']) + ds.qcfilter.remove_test(var_name, test_number=result['test_number']) + pytest.raises(ValueError, ds.qcfilter.add_test, var_name) + pytest.raises(ValueError, ds.qcfilter.remove_test, var_name) + + ds.close() + + assert np.all(parse_bit([257]) == np.array([1, 9], dtype=np.int32)) + pytest.raises(ValueError, parse_bit, [1, 2]) + pytest.raises(ValueError, parse_bit, -1) + + assert set_bit(0, 16) == 32768 + data = range(0, 4) + assert isinstance(set_bit(list(data), 2), list) + assert isinstance(set_bit(tuple(data), 2), tuple) + assert isinstance(unset_bit(list(data), 2), list) + assert isinstance(unset_bit(tuple(data), 2), tuple) + + # Fill in missing tests + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + del ds[var_name].attrs['long_name'] + # Test creating a qc variable + ds.qcfilter.create_qc_variable(var_name) + # Test creating a second qc variable and of flag type + ds.qcfilter.create_qc_variable(var_name, flag_type=True) + result = ds.qcfilter.add_test( + var_name, + index=[1, 2, 3], + test_number=9, + test_meaning='testing high number', + flag_value=True, + ) + ds.qcfilter.set_test(var_name, index=5, test_number=9, flag_value=True) + data = ds.qcfilter.get_masked_data(var_name) + assert np.isclose(np.sum(data), 42674.766, 0.01) + data = ds.qcfilter.get_masked_data(var_name, rm_assessments='Bad') + assert np.isclose(np.sum(data), 42643.195, 0.01) + + ds.qcfilter.unset_test(var_name, test_number=9, flag_value=True) + ds.qcfilter.unset_test(var_name, index=1, test_number=9, flag_value=True) + assert ds.qcfilter.available_bit(result['qc_variable_name']) == 10 + assert ds.qcfilter.available_bit(result['qc_variable_name'], recycle=True) == 1 + ds.qcfilter.remove_test(var_name, test_number=9, flag_value=True) + + ds.qcfilter.update_ancillary_variable(var_name) + # Test updating ancillary variable if does not exist + ds.qcfilter.update_ancillary_variable('not_a_variable_name') + # Change ancillary_variables attribute to test if add correct qc variable correctly + ds[var_name].attrs['ancillary_variables'] = 'a_different_name' + ds.qcfilter.update_ancillary_variable(var_name, qc_var_name=expected_qc_var_name) + assert expected_qc_var_name in ds[var_name].attrs['ancillary_variables'] + + # Test flag QC + var_name = 'inst_sfc_ir_temp' + qc_var_name = 'qc_' + var_name + ds.qcfilter.create_qc_variable(var_name, flag_type=True) + assert qc_var_name in list(ds.data_vars) + assert 'flag_values' in ds[qc_var_name].attrs.keys() + assert 'flag_masks' not in ds[qc_var_name].attrs.keys() + del ds[qc_var_name] + + qc_var_name = ds.qcfilter.check_for_ancillary_qc( + var_name, add_if_missing=True, cleanup=False, flag_type=True + ) + assert qc_var_name in list(ds.data_vars) + assert 'flag_values' in ds[qc_var_name].attrs.keys() + assert 'flag_masks' not in ds[qc_var_name].attrs.keys() + del ds[qc_var_name] + + ds.qcfilter.add_missing_value_test(var_name, flag_value=True, prepend_text='arm') + ds.qcfilter.add_test( + var_name, + index=list(range(0, 20)), + test_number=2, + test_meaning='Testing flag', + flag_value=True, + test_assessment='Suspect', + ) + assert qc_var_name in list(ds.data_vars) + assert 'flag_values' in ds[qc_var_name].attrs.keys() + assert 'flag_masks' not in ds[qc_var_name].attrs.keys() + assert 'standard_name' in ds[qc_var_name].attrs.keys() + assert ds[qc_var_name].attrs['flag_values'] == [1, 2] + assert ds[qc_var_name].attrs['flag_assessments'] == ['Bad', 'Suspect'] + + ds.close() + + +@pytest.mark.skipif(not SCIKIT_POSTHOCS_AVAILABLE, reason='scikit_posthocs is not installed.') +def test_qcfilter2(): + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + var_name = 'inst_up_long_dome_resist' + expected_qc_var_name = 'qc_' + var_name + + data = ds[var_name].values + data[0:4] = data[0:4] + 30.0 + data[1000:1024] = data[1000:1024] + 30.0 + ds[var_name].values = data + + coef = 1.4 + ds.qcfilter.add_iqr_test(var_name, coef=1.4, test_assessment='Bad', prepend_text='arm') + assert np.sum(ds[expected_qc_var_name].values) == 28 + assert ds[expected_qc_var_name].attrs['flag_masks'] == [1] + assert ds[expected_qc_var_name].attrs['flag_meanings'] == [ + f'arm: Value outside of interquartile range test range with a coefficient of {coef}' + ] + + ds.qcfilter.add_iqr_test(var_name, test_number=3, prepend_text='ACT') + assert np.sum(ds[expected_qc_var_name].values) == 140 + assert ds[expected_qc_var_name].attrs['flag_masks'] == [1, 4] + assert ds[expected_qc_var_name].attrs['flag_meanings'][-1] == ( + 'ACT: Value outside of interquartile range test range with a coefficient of 1.5' + ) + + ds.qcfilter.add_gesd_test(var_name, test_assessment='Bad') + assert np.sum(ds[expected_qc_var_name].values) == 204 + assert ds[expected_qc_var_name].attrs['flag_masks'] == [1, 4, 8] + assert ds[expected_qc_var_name].attrs['flag_meanings'][-1] == ( + 'Value failed generalized Extreme Studentized Deviate test with an alpha of 0.05' + ) + + ds.qcfilter.add_gesd_test(var_name, alpha=0.1) + assert np.sum(ds[expected_qc_var_name].values) == 332 + assert ds[expected_qc_var_name].attrs['flag_masks'] == [1, 4, 8, 16] + assert ds[expected_qc_var_name].attrs['flag_meanings'][-1] == ( + 'Value failed generalized Extreme Studentized Deviate test with an alpha of 0.1' + ) + assert ds[expected_qc_var_name].attrs['flag_assessments'] == [ + 'Bad', + 'Indeterminate', + 'Bad', + 'Indeterminate', + ] + + +def test_qcfilter3(): + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + var_name = 'inst_up_long_dome_resist' + result = ds.qcfilter.add_test(var_name, index=range(0, 100), test_meaning='testing') + qc_var_name = result['qc_variable_name'] + assert ds[qc_var_name].values.dtype.kind in np.typecodes['AllInteger'] + + ds[qc_var_name].values = ds[qc_var_name].values.astype(np.float32) + assert ds[qc_var_name].values.dtype.kind not in np.typecodes['AllInteger'] + + result = ds.qcfilter.get_qc_test_mask(var_name=var_name, test_number=1, return_index=False) + assert np.sum(result) == 100 + result = ds.qcfilter.get_qc_test_mask(var_name=var_name, test_number=1, return_index=True) + assert np.sum(result) == 4950 + + # Test where QC variables are not integer type + ds = ds.resample(time='5min').mean(keep_attrs=True) + ds.qcfilter.add_test(var_name, index=range(0, ds.time.size), test_meaning='Testing float') + assert np.sum(ds[qc_var_name].values) == 582 + + ds[qc_var_name].values = ds[qc_var_name].values.astype(np.float32) + ds.qcfilter.remove_test(var_name, test_number=2) + assert np.sum(ds[qc_var_name].values) == 6 + + +def test_qc_speed(): + """ + This tests the speed of the QC module to ensure changes do not significantly + slow down the module's processing. + """ + + n_variables = 100 + n_samples = 100 + + time = pd.date_range(start='2022-02-17 00:00:00', end='2022-02-18 00:00:00', periods=n_samples) + + # Create data variables with random noise + np.random.seed(42) + noisy_data_mapping = {f'data_var_{i}': np.random.random(time.shape) for i in range(n_variables)} + + ds = xr.Dataset( + data_vars={name: ('time', data) for name, data in noisy_data_mapping.items()}, + coords={'time': time}, + ) + + start = datetime.utcnow() + for name, var in noisy_data_mapping.items(): + failed_qc = var > 0.75 # Consider data above 0.75 as bad. Negligible time here. + ds.qcfilter.add_test(name, index=failed_qc, test_meaning='Value above threshold') + + time_diff = datetime.utcnow() - start + assert time_diff.seconds <= 4 + + +def test_datafilter(): + ds = read_arm_netcdf(EXAMPLE_MET1, drop_variables=['base_time', 'time_offset']) + ds.clean.cleanup() + + data_var_names = list(ds.data_vars) + qc_var_names = [var_name for var_name in ds.data_vars if var_name.startswith('qc_')] + data_var_names = list(set(data_var_names) - set(qc_var_names)) + data_var_names.sort() + qc_var_names.sort() + + var_name = 'atmos_pressure' + + ds_1 = ds.mean() + + ds.qcfilter.add_less_test(var_name, 99, test_assessment='Bad') + ds_filtered = copy.deepcopy(ds) + ds_filtered.qcfilter.datafilter(rm_assessments='Bad') + ds_2 = ds_filtered.mean() + assert np.isclose(ds_1[var_name].values, 98.86, atol=0.01) + assert np.isclose(ds_2[var_name].values, 99.15, atol=0.01) + assert isinstance(ds_1[var_name].data, da.core.Array) + assert 'act.qc.datafilter' in ds_filtered[var_name].attrs['history'] + + ds_filtered = copy.deepcopy(ds) + ds_filtered.qcfilter.datafilter(rm_assessments='Bad', variables=var_name, del_qc_var=True) + ds_2 = ds_filtered.mean() + assert np.isclose(ds_2[var_name].values, 99.15, atol=0.01) + expected_var_names = sorted(list(set(data_var_names + qc_var_names) - {'qc_' + var_name})) + assert sorted(list(ds_filtered.data_vars)) == expected_var_names + + ds_filtered = copy.deepcopy(ds) + ds_filtered.qcfilter.datafilter(rm_assessments='Bad', del_qc_var=True) + assert sorted(list(ds_filtered.data_vars)) == data_var_names + + ds.close() + del ds + + +def test_qc_data_type(): + drop_vars = [ + 'base_time', + 'time_offset', + 'inst_up_long_case_resist', + 'inst_up_long_hemisp_tp', + 'inst_up_short_hemisp_tp', + 'inst_sfc_ir_temp', + 'lat', + 'lon', + 'alt', + ] + ds = read_arm_netcdf(EXAMPLE_IRT25m20s, drop_variables=drop_vars) + var_name = 'inst_up_long_dome_resist' + expected_qc_var_name = 'qc_' + var_name + ds.qcfilter.check_for_ancillary_qc(var_name, add_if_missing=True) + del ds[expected_qc_var_name].attrs['flag_meanings'] + del ds[expected_qc_var_name].attrs['flag_assessments'] + ds[expected_qc_var_name] = ds[expected_qc_var_name].astype(np.int8) + ds.qcfilter.add_test(var_name, index=[1], test_number=9, test_meaning='First test') + + assert ds[expected_qc_var_name].attrs['flag_masks'][0].dtype == np.uint32 + assert ds[expected_qc_var_name].dtype == np.int16 + ds.qcfilter.add_test(var_name, index=[1], test_number=17, test_meaning='Second test') + assert ds[expected_qc_var_name].dtype == np.int32 + ds.qcfilter.add_test(var_name, index=[1], test_number=33, test_meaning='Third test') + assert ds[expected_qc_var_name].dtype == np.int64 + assert ds[expected_qc_var_name].attrs['flag_masks'][0].dtype == np.uint64 + + ds.qcfilter.add_test(var_name, index=[1], test_meaning='Fourth test', recycle=True) diff --git a/tests/qc/test_qctests.py b/tests/qc/test_qctests.py new file mode 100644 index 0000000000..332f88cdc8 --- /dev/null +++ b/tests/qc/test_qctests.py @@ -0,0 +1,384 @@ +import dask.array as da +import numpy as np + +from act.io.arm import read_arm_netcdf +from act.tests import EXAMPLE_MET1, EXAMPLE_IRT25m20s + + +def test_qctests(): + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + var_name = 'inst_up_long_dome_resist' + + # Add in one missing value and test for that missing value + data = ds[var_name].values + data[0] = np.nan + ds[var_name].data = da.from_array(data) + result = ds.qcfilter.add_missing_value_test(var_name) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert data.mask[0] + + result = ds.qcfilter.add_missing_value_test(var_name, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert data == np.array([0]) + ds.qcfilter.remove_test(var_name, test_number=result['test_number']) + + # less than min test + limit_value = 6.8 + result = ds.qcfilter.add_less_test( + var_name, limit_value, prepend_text='arm', limit_attr_name='fail_min' + ) + + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 54 + assert 'fail_min' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['fail_min'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['fail_min'], limit_value) + + result = ds.qcfilter.add_less_test(var_name, limit_value, test_assessment='Suspect') + assert 'warn_min' in ds[result['qc_variable_name']].attrs.keys() + + limit_value = 8 + result = ds.qcfilter.add_less_test(var_name, limit_value) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 2911939 + result = ds.qcfilter.add_less_test(var_name, limit_value, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 2911939 + + # greator than max test + limit_value = 12.7 + result = ds.qcfilter.add_greater_test( + var_name, limit_value, prepend_text='arm', limit_attr_name='fail_max' + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 61 + assert 'fail_max' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['fail_max'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['fail_max'], limit_value) + + result = ds.qcfilter.add_greater_test(var_name, limit_value, test_assessment='Suspect') + assert 'warn_max' in ds[result['qc_variable_name']].attrs.keys() + + result = ds.qcfilter.add_greater_test(var_name, limit_value, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 125458 + result = ds.qcfilter.add_greater_test(var_name, limit_value) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 125458 + + # less than or equal test + limit_value = 6.9 + result = ds.qcfilter.add_less_equal_test( + var_name, + limit_value, + test_assessment='Suspect', + prepend_text='arm', + limit_attr_name='warn_min', + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 149 + assert 'warn_min' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['warn_min'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['warn_min'], limit_value) + + result = ds.qcfilter.add_less_equal_test(var_name, limit_value) + assert 'fail_min' in ds[result['qc_variable_name']].attrs.keys() + + result = ds.qcfilter.add_less_equal_test(var_name, limit_value, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 601581 + result = ds.qcfilter.add_less_equal_test(var_name, limit_value) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 601581 + + # greater than or equal test + result = ds.qcfilter.add_greater_equal_test(var_name, None) + limit_value = 12 + result = ds.qcfilter.add_greater_equal_test( + var_name, + limit_value, + test_assessment='Suspect', + prepend_text='arm', + limit_attr_name='warn_max', + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 606 + assert 'warn_max' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['warn_max'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['warn_max'], limit_value) + + result = ds.qcfilter.add_greater_equal_test(var_name, limit_value) + assert 'fail_max' in ds[result['qc_variable_name']].attrs.keys() + + result = ds.qcfilter.add_greater_equal_test(var_name, limit_value, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 1189873 + result = ds.qcfilter.add_greater_equal_test(var_name, limit_value) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 1189873 + + # equal to test + limit_value = 7.6705 + result = ds.qcfilter.add_equal_to_test( + var_name, limit_value, prepend_text='arm', limit_attr_name='fail_equal_to' + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 2 + assert 'fail_equal_to' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['fail_equal_to'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['fail_equal_to'], limit_value) + + result = ds.qcfilter.add_equal_to_test(var_name, limit_value, test_assessment='Indeterminate') + assert 'warn_equal_to' in ds[result['qc_variable_name']].attrs.keys() + + result = ds.qcfilter.add_equal_to_test(var_name, limit_value, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 8631 + result = ds.qcfilter.add_equal_to_test(var_name, limit_value) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 8631 + + # not equal to test + limit_value = 7.6705 + result = ds.qcfilter.add_not_equal_to_test( + var_name, + limit_value, + test_assessment='Indeterminate', + prepend_text='arm', + limit_attr_name='warn_not_equal_to', + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 4318 + assert 'warn_not_equal_to' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['warn_not_equal_to'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['warn_not_equal_to'], limit_value) + + result = ds.qcfilter.add_not_equal_to_test(var_name, limit_value) + assert 'fail_not_equal_to' in ds[result['qc_variable_name']].attrs.keys() + + result = ds.qcfilter.add_not_equal_to_test(var_name, limit_value, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 9320409 + result = ds.qcfilter.add_not_equal_to_test(var_name, limit_value) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 9320409 + + # outside range test + limit_value1 = 6.8 + limit_value2 = 12.7 + result = ds.qcfilter.add_outside_test( + var_name, + limit_value1, + limit_value2, + prepend_text='arm', + limit_attr_names=['fail_lower_range', 'fail_upper_range'], + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 115 + assert 'fail_lower_range' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['fail_lower_range'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['fail_lower_range'], limit_value1) + assert 'fail_upper_range' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['fail_upper_range'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['fail_upper_range'], limit_value2) + + result = ds.qcfilter.add_outside_test( + var_name, limit_value1, limit_value2, test_assessment='Indeterminate' + ) + assert 'warn_lower_range' in ds[result['qc_variable_name']].attrs.keys() + assert 'warn_upper_range' in ds[result['qc_variable_name']].attrs.keys() + + result = ds.qcfilter.add_outside_test(var_name, limit_value1, limit_value2, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 342254 + result = ds.qcfilter.add_outside_test( + var_name, + limit_value1, + limit_value2, + ) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 342254 + + # Starting to run out of space for tests. Remove some tests. + for ii in range(16, 30): + ds.qcfilter.remove_test(var_name, test_number=ii) + + # inside range test + limit_value1 = 7 + limit_value2 = 8 + result = ds.qcfilter.add_inside_test( + var_name, + limit_value1, + limit_value2, + prepend_text='arm', + limit_attr_names=['fail_lower_range_inner', 'fail_upper_range_inner'], + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 479 + assert 'fail_lower_range_inner' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['fail_lower_range_inner'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose( + ds[result['qc_variable_name']].attrs['fail_lower_range_inner'], + limit_value1, + ) + assert 'fail_upper_range_inner' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['fail_upper_range_inner'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose( + ds[result['qc_variable_name']].attrs['fail_upper_range_inner'], + limit_value2, + ) + + result = ds.qcfilter.add_inside_test( + var_name, limit_value1, limit_value2, test_assessment='Indeterminate' + ) + assert 'warn_lower_range_inner' in ds[result['qc_variable_name']].attrs.keys() + assert 'warn_upper_range_inner' in ds[result['qc_variable_name']].attrs.keys() + + result = ds.qcfilter.add_inside_test(var_name, limit_value1, limit_value2, use_dask=True) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 1820693 + result = ds.qcfilter.add_inside_test( + var_name, + limit_value1, + limit_value2, + ) + data = ds.qcfilter.get_qc_test_mask(var_name, result['test_number'], return_index=True) + assert np.sum(data) == 1820693 + + # delta test + test_limit = 0.05 + result = ds.qcfilter.add_delta_test( + var_name, test_limit, prepend_text='arm', limit_attr_name='warn_delta' + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert np.ma.count_masked(data) == 175 + assert 'warn_delta' in ds[result['qc_variable_name']].attrs.keys() + assert ( + ds[result['qc_variable_name']].attrs['warn_delta'].dtype + == ds[result['variable_name']].values.dtype + ) + assert np.isclose(ds[result['qc_variable_name']].attrs['warn_delta'], test_limit) + + data = ds.qcfilter.get_masked_data(var_name, rm_assessments=['Suspect', 'Bad']) + assert np.ma.count_masked(data) == 1355 + + result = ds.qcfilter.add_delta_test(var_name, test_limit, test_assessment='Bad') + assert 'fail_delta' in ds[result['qc_variable_name']].attrs.keys() + + comp_ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + with np.testing.assert_raises(ValueError): + result = ds.qcfilter.add_difference_test(var_name, 'test') + + with np.testing.assert_raises(ValueError): + result = ds.qcfilter.add_difference_test( + var_name, + {comp_ds.attrs['datastream']: comp_ds}, + var_name, + diff_limit=None, + ) + + assert ds.qcfilter.add_difference_test(var_name, set_test_regardless=False) is None + + result = ds.qcfilter.add_difference_test( + var_name, + {comp_ds.attrs['datastream']: comp_ds}, + var_name, + diff_limit=1, + prepend_text='arm', + ) + data = ds.qcfilter.get_masked_data(var_name, rm_tests=result['test_number']) + assert 'arm' in result['test_meaning'] + assert not (data.mask).all() + + comp_ds.close() + ds.close() + + +def test_qctests_dos(): + ds = read_arm_netcdf(EXAMPLE_IRT25m20s) + var_name = 'inst_up_long_dome_resist' + + # persistence test + data = ds[var_name].values + data[1000:2400] = data[1000] + data = np.around(data, decimals=3) + ds[var_name].values = data + result = ds.qcfilter.add_persistence_test(var_name) + qc_var_name = result['qc_variable_name'] + test_meaning = ( + 'Data failing persistence test. Standard Deviation over a ' + 'window of 10 values less than 0.0001.' + ) + assert ds[qc_var_name].attrs['flag_meanings'][-1] == test_meaning + # There is a precision issue with GitHub testing that makes the number of tests + # tripped off. This isclose() option is to account for that. + assert np.isclose(np.sum(ds[qc_var_name].values), 1399, atol=2) + + ds.qcfilter.add_persistence_test(var_name, window=10000, prepend_text='DQO') + test_meaning = ( + 'DQO: Data failing persistence test. Standard Deviation over a window of ' + '4320 values less than 0.0001.' + ) + assert ds[qc_var_name].attrs['flag_meanings'][-1] == test_meaning + + +def test_add_atmospheric_pressure_test(): + ds = read_arm_netcdf(EXAMPLE_MET1, cleanup_qc=True) + ds.load() + + variable = 'atmos_pressure' + qc_variable = 'qc_' + variable + + data = ds[variable].values + data[200:250] = data[200:250] + 5 + data[500:550] = data[500:550] - 4.6 + ds[variable].values = data + result = ds.qcfilter.add_atmospheric_pressure_test(variable) + assert isinstance(result, dict) + assert np.sum(ds[qc_variable].values) == 1600 + + del ds[qc_variable] + ds.qcfilter.add_atmospheric_pressure_test(variable, use_dask=True) + assert np.sum(ds[qc_variable].values) == 100 + + ds.close + del ds diff --git a/tests/qc/test_radiometer_tests.py b/tests/qc/test_radiometer_tests.py new file mode 100644 index 0000000000..b58ae5d97c --- /dev/null +++ b/tests/qc/test_radiometer_tests.py @@ -0,0 +1,13 @@ +import numpy as np + +from act.io.arm import read_arm_netcdf +from act.qc.radiometer_tests import fft_shading_test +from act.tests import EXAMPLE_MFRSR + + +def test_fft_shading_test(): + ds = read_arm_netcdf(EXAMPLE_MFRSR) + ds.clean.cleanup() + ds = fft_shading_test(ds) + qc_data = ds['qc_diffuse_hemisp_narrowband_filter4'] + assert np.nansum(qc_data.values) == 7164 diff --git a/tests/qc/test_sp2.py b/tests/qc/test_sp2.py new file mode 100644 index 0000000000..6d5eea49a9 --- /dev/null +++ b/tests/qc/test_sp2.py @@ -0,0 +1,46 @@ +import numpy as np +import pytest + +from act.qc.sp2 import PYSP2_AVAILABLE, SP2ParticleCriteria + + +@pytest.mark.skipif(not PYSP2_AVAILABLE, reason='PySP2 is not installed.') +def test_sp2_particle_config(): + particle_config_ds = SP2ParticleCriteria() + assert particle_config_ds.ScatMaxPeakHt1 == 60000 + assert particle_config_ds.ScatMinPeakHt1 == 250 + assert particle_config_ds.ScatMaxPeakHt2 == 60000 + assert particle_config_ds.ScatMinPeakHt2 == 250 + assert particle_config_ds.ScatMinWidth == 10 + assert particle_config_ds.ScatMaxWidth == 90 + assert particle_config_ds.ScatMinPeakPos == 20 + assert particle_config_ds.ScatMaxPeakPos == 90 + assert particle_config_ds.IncanMinPeakHt1 == 200 + assert particle_config_ds.IncanMinPeakHt2 == 200 + assert particle_config_ds.IncanMaxPeakHt1 == 60000 + assert particle_config_ds.IncanMaxPeakHt2 == 60000 + assert particle_config_ds.IncanMinWidth == 5 + assert particle_config_ds.IncanMaxWidth == np.inf + assert particle_config_ds.IncanMinPeakPos == 20 + assert particle_config_ds.IncanMaxPeakPos == 90 + assert particle_config_ds.IncanMinPeakRatio == 0.1 + assert particle_config_ds.IncanMaxPeakRatio == 25 + assert particle_config_ds.IncanMaxPeakOffset == 11 + assert particle_config_ds.c0Mass1 == 0 + assert particle_config_ds.c1Mass1 == 0.0001896 + assert particle_config_ds.c2Mass1 == 0 + assert particle_config_ds.c3Mass1 == 0 + assert particle_config_ds.c0Mass2 == 0 + assert particle_config_ds.c1Mass2 == 0.0016815 + assert particle_config_ds.c2Mass2 == 0 + assert particle_config_ds.c3Mass2 == 0 + assert particle_config_ds.c0Scat1 == 0 + assert particle_config_ds.c1Scat1 == 78.141 + assert particle_config_ds.c2Scat1 == 0 + assert particle_config_ds.c0Scat2 == 0 + assert particle_config_ds.c1Scat2 == 752.53 + assert particle_config_ds.c2Scat2 == 0 + assert particle_config_ds.densitySO4 == 1.8 + assert particle_config_ds.densityBC == 1.8 + assert particle_config_ds.TempSTP == 273.15 + assert particle_config_ds.PressSTP == 1013.25 diff --git a/tests/retrievals/test_aeri.py b/tests/retrievals/test_aeri.py new file mode 100644 index 0000000000..88adfadce7 --- /dev/null +++ b/tests/retrievals/test_aeri.py @@ -0,0 +1,17 @@ +import numpy as np + +import act + + +def test_aeri2irt(): + aeri_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_AERI) + aeri_ds = act.retrievals.aeri.aeri2irt(aeri_ds) + assert np.round(np.nansum(aeri_ds['aeri_irt_equiv_temperature'].values)).astype(int) == 17372 + np.testing.assert_almost_equal( + aeri_ds['aeri_irt_equiv_temperature'].values[7], 286.081, decimal=3 + ) + np.testing.assert_almost_equal( + aeri_ds['aeri_irt_equiv_temperature'].values[-10], 285.366, decimal=3 + ) + aeri_ds.close() + del aeri_ds diff --git a/tests/retrievals/test_cbh.py b/tests/retrievals/test_cbh.py new file mode 100644 index 0000000000..33947a8c96 --- /dev/null +++ b/tests/retrievals/test_cbh.py @@ -0,0 +1,19 @@ +import act + + +def test_generic_sobel_cbh(): + ceil = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_CEIL1) + + ceil = ceil.resample(time='1min').nearest() + ceil = act.retrievals.cbh.generic_sobel_cbh( + ceil, + variable='backscatter', + height_dim='range', + var_thresh=1000.0, + fill_na=0.0, + edge_thresh=5, + ) + cbh = ceil['cbh_sobel_backscatter'].values + assert cbh[500] == 615.0 + assert cbh[1000] == 555.0 + ceil.close() diff --git a/tests/retrievals/test_doppler_lidar_retrievals.py b/tests/retrievals/test_doppler_lidar_retrievals.py new file mode 100644 index 0000000000..9e430b8a8c --- /dev/null +++ b/tests/retrievals/test_doppler_lidar_retrievals.py @@ -0,0 +1,23 @@ +import numpy as np + +import act + + +def test_doppler_lidar_winds(): + # Process a single file + dl_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_DLPPI) + result = act.retrievals.doppler_lidar.compute_winds_from_ppi(dl_ds, intensity_name='intensity') + assert np.round(np.nansum(result['wind_speed'].values)).astype(int) == 1570 + assert np.round(np.nansum(result['wind_direction'].values)).astype(int) == 32635 + assert result['wind_speed'].attrs['units'] == 'm/s' + assert result['wind_direction'].attrs['units'] == 'degree' + assert result['height'].attrs['units'] == 'm' + dl_ds.close() + + # Process multiple files + dl_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_DLPPI_MULTI) + del dl_ds['range'].attrs['units'] + result = act.retrievals.doppler_lidar.compute_winds_from_ppi(dl_ds) + assert np.round(np.nansum(result['wind_speed'].values)).astype(int) == 2854 + assert np.round(np.nansum(result['wind_direction'].values)).astype(int) == 64986 + dl_ds.close() diff --git a/tests/retrievals/test_irt.py b/tests/retrievals/test_irt.py new file mode 100644 index 0000000000..681ac63e0d --- /dev/null +++ b/tests/retrievals/test_irt.py @@ -0,0 +1,12 @@ +import numpy as np + +import act + + +def test_sst(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_IRTSST) + ds = act.retrievals.irt.sst_from_irt(ds) + np.testing.assert_almost_equal(ds['sea_surface_temperature'].values[0], 278.901, decimal=3) + np.testing.assert_almost_equal(ds['sea_surface_temperature'].values[-1], 279.291, decimal=3) + assert np.round(np.nansum(ds['sea_surface_temperature'].values)).astype(int) == 6699 + ds.close() diff --git a/tests/retrievals/test_radiation.py b/tests/retrievals/test_radiation.py new file mode 100644 index 0000000000..fa8357efd2 --- /dev/null +++ b/tests/retrievals/test_radiation.py @@ -0,0 +1,47 @@ +import numpy as np +import xarray as xr + +import act + + +def test_calculate_sirs_variable(): + sirs_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_SIRS) + met_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET1) + + ds = act.retrievals.radiation.calculate_dsh_from_dsdh_sdn(sirs_ds) + assert np.isclose(np.nansum(ds['derived_down_short_hemisp'].values), 61157.71, atol=0.1) + + ds = act.retrievals.radiation.calculate_irradiance_stats( + ds, + variable='derived_down_short_hemisp', + variable2='down_short_hemisp', + threshold=60, + ) + + assert np.isclose(np.nansum(ds['diff_derived_down_short_hemisp'].values), 1335.12, atol=0.1) + assert np.isclose(np.nansum(ds['ratio_derived_down_short_hemisp'].values), 400.31, atol=0.1) + + ds = act.retrievals.radiation.calculate_net_radiation(ds, smooth=30) + assert np.ceil(np.nansum(ds['net_radiation'].values)) == 21915 + assert np.ceil(np.nansum(ds['net_radiation_smoothed'].values)) == 22316 + + ds = act.retrievals.radiation.calculate_longwave_radiation( + ds, + temperature_var='temp_mean', + vapor_pressure_var='vapor_pressure_mean', + met_ds=met_ds, + ) + assert np.ceil(ds['monteith_clear'].values[25]) == 239 + assert np.ceil(ds['monteith_cloudy'].values[30]) == 318 + assert np.ceil(ds['prata_clear'].values[35]) == 234 + + new_ds = xr.merge([sirs_ds, met_ds], compat='override') + ds = act.retrievals.radiation.calculate_longwave_radiation( + new_ds, temperature_var='temp_mean', vapor_pressure_var='vapor_pressure_mean' + ) + assert np.ceil(ds['monteith_clear'].values[25]) == 239 + assert np.ceil(ds['monteith_cloudy'].values[30]) == 318 + assert np.ceil(ds['prata_clear'].values[35]) == 234 + + sirs_ds.close() + met_ds.close() diff --git a/tests/retrievals/test_sonde.py b/tests/retrievals/test_sonde.py new file mode 100644 index 0000000000..f31a2507de --- /dev/null +++ b/tests/retrievals/test_sonde.py @@ -0,0 +1,134 @@ +import numpy as np + +import act + + +def test_get_stability_indices(): + sonde_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_SONDE1) + sonde_ds = act.retrievals.calculate_stability_indicies( + sonde_ds, temp_name='tdry', td_name='dp', p_name='pres' + ) + np.testing.assert_allclose( + sonde_ds['parcel_temperature'].values[0:5], + [269.85, 269.745276, 269.678006, 269.622444, 269.572331], + rtol=1e-5, + ) + assert sonde_ds['parcel_temperature'].attrs['units'] == 'kelvin' + np.testing.assert_almost_equal(sonde_ds['surface_based_cape'], 0.96, decimal=2) + assert sonde_ds['surface_based_cape'].attrs['units'] == 'J/kg' + assert sonde_ds['surface_based_cape'].attrs['long_name'] == 'Surface-based CAPE' + np.testing.assert_almost_equal(sonde_ds['surface_based_cin'], 0.000, decimal=3) + assert sonde_ds['surface_based_cin'].attrs['units'] == 'J/kg' + assert sonde_ds['surface_based_cin'].attrs['long_name'] == 'Surface-based CIN' + np.testing.assert_almost_equal(sonde_ds['most_unstable_cape'], 0.000, decimal=3) + assert sonde_ds['most_unstable_cape'].attrs['units'] == 'J/kg' + assert sonde_ds['most_unstable_cape'].attrs['long_name'] == 'Most unstable CAPE' + np.testing.assert_almost_equal(sonde_ds['most_unstable_cin'], 0.000, decimal=3) + assert sonde_ds['most_unstable_cin'].attrs['units'] == 'J/kg' + assert sonde_ds['most_unstable_cin'].attrs['long_name'] == 'Most unstable CIN' + + np.testing.assert_almost_equal(sonde_ds['lifted_index'], 28.4, decimal=1) + assert sonde_ds['lifted_index'].attrs['units'] == 'kelvin' + assert sonde_ds['lifted_index'].attrs['long_name'] == 'Lifted index' + np.testing.assert_equal(sonde_ds['level_of_free_convection'], np.array(np.nan)) + assert sonde_ds['level_of_free_convection'].attrs['units'] == 'hectopascal' + assert sonde_ds['level_of_free_convection'].attrs['long_name'] == 'Level of free convection' + np.testing.assert_almost_equal( + sonde_ds['lifted_condensation_level_temperature'], -8.07, decimal=2 + ) + assert sonde_ds['lifted_condensation_level_temperature'].attrs['units'] == 'degree_Celsius' + assert ( + sonde_ds['lifted_condensation_level_temperature'].attrs['long_name'] + == 'Lifted condensation level temperature' + ) + np.testing.assert_almost_equal(sonde_ds['lifted_condensation_level_pressure'], 927.1, decimal=1) + assert sonde_ds['lifted_condensation_level_pressure'].attrs['units'] == 'hectopascal' + assert ( + sonde_ds['lifted_condensation_level_pressure'].attrs['long_name'] + == 'Lifted condensation level pressure' + ) + sonde_ds.close() + + +def test_calculate_precipitable_water(): + sonde_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_SONDE1) + assert sonde_ds['tdry'].units == 'C', 'Temperature must be in Celsius' + assert sonde_ds['rh'].units == '%', 'Relative Humidity must be a percentage' + assert sonde_ds['pres'].units == 'hPa', 'Pressure must be in hPa' + pwv_data = act.retrievals.calculate_precipitable_water( + sonde_ds, temp_name='tdry', rh_name='rh', pres_name='pres' + ) + np.testing.assert_almost_equal(pwv_data, 0.8028, decimal=3) + sonde_ds.close() + + +def test_calculate_pbl_liu_liang(): + files = act.tests.sample_files.EXAMPLE_TWP_SONDE_20060121.copy() + files2 = act.tests.sample_files.EXAMPLE_SONDE1 + files.append(files2) + files.sort() + + pblht = [] + pbl_regime = [] + for file in files: + ds = act.io.arm.read_arm_netcdf(file) + ds['tdry'].attrs['units'] = 'degree_Celsius' + ds = act.retrievals.sonde.calculate_pbl_liu_liang(ds, smooth_height=10) + pblht.append(float(ds['pblht_liu_liang'].values)) + pbl_regime.append(ds['pblht_regime_liu_liang'].values) + + assert pbl_regime == ['NRL', 'NRL', 'NRL', 'NRL', 'NRL'] + np.testing.assert_array_almost_equal(pblht, [1038.4, 1079.0, 282.0, 314.0, 643.0], decimal=1) + + ds = act.io.arm.read_arm_netcdf(files[1]) + ds['tdry'].attrs['units'] = 'degree_Celsius' + ds = act.retrievals.sonde.calculate_pbl_liu_liang(ds, land_parameter=False) + np.testing.assert_almost_equal(ds['pblht_liu_liang'].values, 784, decimal=1) + + ds = act.io.arm.read_arm_netcdf(files[-2:]) + ds['tdry'].attrs['units'] = 'degree_Celsius' + with np.testing.assert_raises(ValueError): + ds = act.retrievals.sonde.calculate_pbl_liu_liang(ds) + + ds = act.io.arm.read_arm_netcdf(files[0]) + ds['tdry'].attrs['units'] = 'degree_Celsius' + temp = ds['tdry'].values + temp[10:20] = 19.0 + temp[0:10] = -10 + ds['tdry'].values = temp + ds = act.retrievals.sonde.calculate_pbl_liu_liang(ds, land_parameter=False) + assert ds['pblht_regime_liu_liang'].values == 'SBL' + + with np.testing.assert_raises(ValueError): + ds2 = ds.where(ds['alt'].load() < 1000.0, drop=True) + ds2 = act.retrievals.sonde.calculate_pbl_liu_liang(ds2, smooth_height=15) + + with np.testing.assert_raises(ValueError): + ds2 = ds.where(ds['pres'].load() < 200.0, drop=True) + ds2 = act.retrievals.sonde.calculate_pbl_liu_liang(ds2, smooth_height=15) + + with np.testing.assert_raises(ValueError): + temp[0:5] = -40 + ds['tdry'].values = temp + ds = act.retrievals.sonde.calculate_pbl_liu_liang(ds) + + ds = act.io.arm.read_arm_netcdf(files[0]) + ds['tdry'].attrs['units'] = 'degree_Celsius' + temp = ds['tdry'].values + temp[20:50] = 100.0 + ds['tdry'].values = temp + with np.testing.assert_raises(ValueError): + ds = act.retrievals.sonde.calculate_pbl_liu_liang(ds) + + +def test_calculate_heffter_pbl(): + files = act.tests.sample_files.EXAMPLE_TWP_SONDE_20060121.copy() + files.sort() + ds = act.io.arm.read_arm_netcdf(files[2]) + ds['tdry'].attrs['units'] = 'degree_Celsius' + ds = act.retrievals.sonde.calculate_pbl_heffter(ds) + assert ds['pblht_heffter'].values == 960.0 + np.testing.assert_almost_equal(ds['atm_pres_ss'].values[1], 994.9, 1) + np.testing.assert_almost_equal(ds['potential_temperature_ss'].values[4], 298.4, 1) + assert np.sum(ds['bottom_inversion'].values) == 7426 + assert np.sum(ds['top_inversion'].values) == 7903 diff --git a/tests/retrievals/test_sp2_retrievals.py b/tests/retrievals/test_sp2_retrievals.py new file mode 100644 index 0000000000..e22db09722 --- /dev/null +++ b/tests/retrievals/test_sp2_retrievals.py @@ -0,0 +1,34 @@ +import numpy as np +import pytest + +import act + +try: + import pysp2 + + PYSP2_AVAILABLE = True +except ImportError: + PYSP2_AVAILABLE = False + + +@pytest.mark.skipif(not PYSP2_AVAILABLE, reason='PySP2 is not installed.') +def test_sp2_waveform_stats(): + my_sp2b = act.io.read_sp2(act.tests.EXAMPLE_SP2B) + my_ini = act.tests.EXAMPLE_INI + my_binary = act.qc.get_waveform_statistics(my_sp2b, my_ini, parallel=False) + assert my_binary.PkHt_ch1.max() == 62669.4 + np.testing.assert_almost_equal(np.nanmax(my_binary.PkHt_ch0.values), 98708.92915295, decimal=1) + np.testing.assert_almost_equal(np.nanmax(my_binary.PkHt_ch4.values), 65088.39598033, decimal=1) + + +@pytest.mark.skipif(not PYSP2_AVAILABLE, reason='PySP2 is not installed.') +def test_sp2_psds(): + my_sp2b = act.io.read_sp2(act.tests.EXAMPLE_SP2B) + my_ini = act.tests.EXAMPLE_INI + my_binary = act.qc.get_waveform_statistics(my_sp2b, my_ini, parallel=False) + my_hk = act.io.read_hk_file(act.tests.EXAMPLE_HK) + my_binary = act.retrievals.calc_sp2_diams_masses(my_binary) + scatrejectkey = my_binary['ScatRejectKey'].values + assert np.nanmax(my_binary['ScatDiaBC50'].values[scatrejectkey == 0]) < 1000.0 + my_psds = act.retrievals.process_sp2_psds(my_binary, my_hk, my_ini) + np.testing.assert_almost_equal(my_psds['NumConcIncan'].max(), 0.95805343) diff --git a/tests/utils/test_data_utils.py b/tests/utils/test_data_utils.py new file mode 100644 index 0000000000..bf10076164 --- /dev/null +++ b/tests/utils/test_data_utils.py @@ -0,0 +1,457 @@ +import importlib + +import numpy as np +import pytest +import xarray as xr +from numpy.testing import assert_almost_equal + +import act +from act.utils.data_utils import DatastreamParserARM as DatastreamParser + +spec = importlib.util.find_spec('pyart') +if spec is not None: + PYART_AVAILABLE = True +else: + PYART_AVAILABLE = False + + +def test_add_in_nan(): + # Make a 1D array of 10 minute data + time = np.arange('2019-01-01T01:00', '2019-01-01T01:10', dtype='datetime64[m]') + time = time.astype('datetime64[us]') + time = np.delete(time, range(3, 8)) + data = np.linspace(0.0, 8.0, time.size) + + time_filled, data_filled = act.utils.add_in_nan(xr.DataArray(time), xr.DataArray(data)) + assert isinstance(time_filled, xr.core.dataarray.DataArray) + assert isinstance(data_filled, xr.core.dataarray.DataArray) + + time_filled, data_filled = act.utils.add_in_nan(time, data) + assert isinstance(time_filled, np.ndarray) + assert isinstance(data_filled, np.ndarray) + + assert time_filled[3] == np.datetime64('2019-01-01T01:05:00') + assert time_filled[4] == np.datetime64('2019-01-01T01:08:00') + assert np.isnan(data_filled[3]) + assert data_filled[4] == 6.0 + + time_filled, data_filled = act.utils.add_in_nan(time[0], data[0]) + assert time_filled == time[0] + assert data_filled == data[0] + + # Check for multiple instances of missing data periods + time = np.arange('2019-01-01T01:00', '2019-01-01T02:00', dtype='datetime64[m]') + time = np.delete(time, range(3, 8)) + time = np.delete(time, range(33, 36)) + data = np.linspace(0.0, 10.0, time.size) + + time_filled, data_filled = act.utils.add_in_nan(time, data) + assert time_filled.size == 54 + assert data_filled.size == 54 + index = np.where(time_filled == np.datetime64('2019-01-01T01:37'))[0] + assert index[0] == 33 + assert np.isclose(data_filled[33], 6.27450) + index = np.where(time_filled == np.datetime64('2019-01-01T01:38'))[0] + assert index.size == 0 + index = np.where(time_filled == np.datetime64('2019-01-01T01:39'))[0] + assert index[0] == 34 + assert np.isnan(data_filled[34]) + index = np.where(time_filled == np.datetime64('2019-01-01T01:40'))[0] + assert index.size == 0 + + # Test for 2D data + time = np.arange('2019-01-01T01:00', '2019-01-01T02:00', dtype='datetime64[m]') + data = np.random.random((len(time), 25)) + + time = np.delete(time, range(3, 8)) + data = np.delete(data, range(3, 8), axis=0) + time_filled, data_filled = act.utils.add_in_nan(time, data) + + assert np.count_nonzero(np.isnan(data_filled[3, :])) == 25 + assert len(time_filled) == len(time) + 2 + + +def test_get_missing_value(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) + missing = act.utils.data_utils.get_missing_value( + ds, 'latent_heat_flux', use_FillValue=True, add_if_missing_in_ds=True + ) + assert missing == -9999 + + ds['latent_heat_flux'].attrs['missing_value'] = -9998 + missing = act.utils.data_utils.get_missing_value(ds, 'latent_heat_flux') + assert missing == -9998 + + +def test_convert_units(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) + data = ds['soil_temp_1'].values + in_units = ds['soil_temp_1'].attrs['units'] + r_data = act.utils.data_utils.convert_units(data, in_units, 'K') + assert np.ceil(r_data[0]) == 285 + + data = act.utils.data_utils.convert_units(r_data, 'K', 'C') + assert np.ceil(data[0]) == 12 + + try: + ds.utils.change_units() + except ValueError as error: + assert str(error) == "Need to provide 'desired_unit' keyword for .change_units() method" + + desired_unit = 'degF' + skip_vars = [ii for ii in ds.data_vars if ii.startswith('qc_')] + ds.utils.change_units( + variables=None, + desired_unit=desired_unit, + skip_variables=skip_vars, + skip_standard=True, + ) + units = [] + for var_name in ds.data_vars: + try: + units.append(ds[var_name].attrs['units']) + except KeyError: + pass + indices = [i for i, x in enumerate(units) if x == desired_unit] + assert indices == [0, 2, 4, 6, 8, 32, 34, 36, 38, 40] + + var_name = 'home_signal_15' + desired_unit = 'V' + ds.utils.change_units(var_name, desired_unit, skip_variables='lat') + assert ds[var_name].attrs['units'] == desired_unit + + var_names = ['home_signal_15', 'home_signal_30'] + ds.utils.change_units(var_names, desired_unit) + for var_name in var_names: + assert ds[var_name].attrs['units'] == desired_unit + + ds.close() + del ds + + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_CEIL1) + var_name = 'range' + desired_unit = 'km' + ds = ds.utils.change_units(var_name, desired_unit) + assert ds[var_name].attrs['units'] == desired_unit + assert np.isclose(np.sum(ds[var_name].values), 952.56, atol=0.01) + + ds.close() + del ds + + +def test_ts_weighted_average(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET_WILDCARD) + cf_ds = { + 'sgpmetE13.b1': { + 'variable': [ + 'tbrg_precip_total', + 'org_precip_rate_mean', + 'pwd_precip_rate_mean_1min', + ], + 'weight': [0.8, 0.15, 0.05], + 'ds': ds, + } + } + data = act.utils.data_utils.ts_weighted_average(cf_ds) + + np.testing.assert_almost_equal(np.sum(data), 84.9, decimal=1) + + +def test_accum_precip(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET_WILDCARD) + + ds = act.utils.accumulate_precip(ds, 'tbrg_precip_total') + dmax = round(np.nanmax(ds['tbrg_precip_total_accumulated'])) + assert np.isclose(dmax, 13.0, atol=0.01) + + ds = act.utils.accumulate_precip(ds, 'tbrg_precip_total', time_delta=60) + dmax = round(np.nanmax(ds['tbrg_precip_total_accumulated'])) + assert np.isclose(dmax, 13.0, atol=0.01) + + ds['tbrg_precip_total'].attrs['units'] = 'mm/hr' + ds = act.utils.accumulate_precip(ds, 'tbrg_precip_total') + dmax = np.round(np.nanmax(ds['tbrg_precip_total_accumulated']), 2) + assert np.isclose(dmax, 0.22, atol=0.01) + + +@pytest.mark.skipif(not PYART_AVAILABLE, reason='Py-ART is not installed.') +def test_create_pyart_obj(): + try: + ds = act.io.mpl.read_sigma_mplv5(act.tests.EXAMPLE_SIGMA_MPLV5) + except Exception: + return + + radar = act.utils.create_pyart_obj(ds, range_var='range') + variables = list(radar.fields) + assert 'nrb_copol' in variables + assert 'nrb_crosspol' in variables + assert radar.sweep_start_ray_index['data'][-1] == 67 + assert radar.sweep_end_ray_index['data'][-1] == 101 + assert radar.fixed_angle['data'] == 2.0 + assert radar.scan_type == 'ppi' + assert radar.sweep_mode['data'] == 'ppi' + np.testing.assert_allclose(radar.sweep_number['data'][-3:], [1.0, 1.0, 1.0]) + np.testing.assert_allclose(radar.sweep_number['data'][0:3], [0.0, 0.0, 0.0]) + + # coordinates + np.testing.assert_allclose(radar.azimuth['data'][0:5], [-95.0, -92.5, -90.0, -87.5, -85.0]) + np.testing.assert_allclose(radar.elevation['data'][0:5], [2.0, 2.0, 2.0, 2.0, 2.0]) + np.testing.assert_allclose( + radar.range['data'][0:5], + [14.98962308, 44.96886923, 74.94811538, 104.92736153, 134.90660768], + ) + gate_lat = radar.gate_latitude['data'][0, 0:5] + gate_lon = radar.gate_longitude['data'][0, 0:5] + gate_alt = radar.gate_altitude['data'][0, 0:5] + np.testing.assert_allclose( + gate_lat, [38.95293483, 38.95291135, 38.95288786, 38.95286437, 38.95284089] + ) + np.testing.assert_allclose( + gate_lon, [-76.8363515, -76.83669666, -76.83704182, -76.83738699, -76.83773215] + ) + np.testing.assert_allclose( + gate_alt, [62.84009906, 63.8864653, 64.93293721, 65.9795148, 67.02619806] + ) + ds.close() + del radar + + +def test_convert_to_potential_temp(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET1) + + temp_var_name = 'temp_mean' + press_var_name = 'atmos_pressure' + temp = act.utils.data_utils.convert_to_potential_temp( + ds, temp_var_name, press_var_name=press_var_name + ) + assert np.isclose(np.nansum(temp), -4240.092, rtol=0.001, atol=0.001) + temp = act.utils.data_utils.convert_to_potential_temp( + temperature=ds[temp_var_name].values, + pressure=ds[press_var_name].values, + temp_var_units=ds[temp_var_name].attrs['units'], + press_var_units=ds[press_var_name].attrs['units'], + ) + assert np.isclose(np.nansum(temp), -4240.092, rtol=0.001, atol=0.0011) + + with np.testing.assert_raises(ValueError): + temp = act.utils.data_utils.convert_to_potential_temp( + temperature=ds[temp_var_name].values, + pressure=ds[press_var_name].values, + temp_var_units=ds[temp_var_name].attrs['units'], + ) + + with np.testing.assert_raises(ValueError): + temp = act.utils.data_utils.convert_to_potential_temp( + temperature=ds[temp_var_name].values, + pressure=ds[press_var_name].values, + press_var_units=ds[press_var_name].attrs['units'], + ) + + +def test_height_adjusted_temperature(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET1) + + temp_var_name = 'temp_mean' + press_var_name = 'atmos_pressure' + temp = act.utils.data_utils.height_adjusted_temperature( + ds, + temp_var_name, + height_difference=100, + height_units='m', + press_var_name=press_var_name, + ) + assert np.isclose(np.nansum(temp), -6834.291, rtol=0.001, atol=0.001) + + temp = act.utils.data_utils.height_adjusted_temperature( + ds, temp_var_name=temp_var_name, height_difference=-900, height_units='feet' + ) + assert np.isclose(np.nansum(temp), -1904.7257, rtol=0.001, atol=0.001) + + temp = act.utils.data_utils.height_adjusted_temperature( + ds, + temp_var_name, + height_difference=-200, + height_units='m', + press_var_name=press_var_name, + pressure=102.325, + press_var_units='kPa', + ) + assert np.isclose(np.nansum(temp), -2871.5435, rtol=0.001, atol=0.001) + + temp = act.utils.data_utils.height_adjusted_temperature( + height_difference=25.2, + height_units='m', + temperature=ds[temp_var_name].values, + temp_var_units=ds[temp_var_name].attrs['units'], + pressure=ds[press_var_name].values, + press_var_units=ds[press_var_name].attrs['units'], + ) + assert np.isclose(np.nansum(temp), -5847.511, rtol=0.001, atol=0.001) + + with np.testing.assert_raises(ValueError): + temp = act.utils.data_utils.height_adjusted_temperature( + height_difference=25.2, + height_units='m', + temperature=ds[temp_var_name].values, + temp_var_units=None, + pressure=ds[press_var_name].values, + press_var_units=ds[press_var_name].attrs['units'], + ) + + +def test_height_adjusted_pressure(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET1) + + press_var_name = 'atmos_pressure' + temp = act.utils.data_utils.height_adjusted_pressure( + ds=ds, press_var_name=press_var_name, height_difference=20, height_units='m' + ) + assert np.isclose(np.nansum(temp), 142020.83, rtol=0.001, atol=0.001) + + temp = act.utils.data_utils.height_adjusted_pressure( + height_difference=-100, + height_units='ft', + pressure=ds[press_var_name].values, + press_var_units=ds[press_var_name].attrs['units'], + ) + assert np.isclose(np.nansum(temp), 142877.69, rtol=0.001, atol=0.001) + + with np.testing.assert_raises(ValueError): + temp = act.utils.data_utils.height_adjusted_pressure( + height_difference=-100, + height_units='ft', + pressure=ds[press_var_name].values, + press_var_units=None, + ) + + +def test_datastreamparser(): + pytest.raises(ValueError, DatastreamParser, 123) + + fn_obj = DatastreamParser() + pytest.raises(ValueError, fn_obj.set_datastream, None) + + fn_obj = DatastreamParser() + assert fn_obj.site is None + assert fn_obj.datastream_class is None + assert fn_obj.facility is None + assert fn_obj.level is None + assert fn_obj.datastream is None + assert fn_obj.date is None + assert fn_obj.time is None + assert fn_obj.ext is None + del fn_obj + + fn_obj = DatastreamParser('/data/sgp/sgpmetE13.b1/sgpmetE13.b1.20190501.024254.nc') + assert fn_obj.site == 'sgp' + assert fn_obj.datastream_class == 'met' + assert fn_obj.facility == 'E13' + assert fn_obj.level == 'b1' + assert fn_obj.datastream == 'sgpmetE13.b1' + assert fn_obj.date == '20190501' + assert fn_obj.time == '024254' + assert fn_obj.ext == 'nc' + + fn_obj.set_datastream('nsatwrC1.a0.19991230.233451.cdf') + assert fn_obj.site == 'nsa' + assert fn_obj.datastream_class == 'twr' + assert fn_obj.facility == 'C1' + assert fn_obj.level == 'a0' + assert fn_obj.datastream == 'nsatwrC1.a0' + assert fn_obj.date == '19991230' + assert fn_obj.time == '233451' + assert fn_obj.ext == 'cdf' + + fn_obj = DatastreamParser('nsaitscomplicatedX1.00.991230.2334.txt') + assert fn_obj.site == 'nsa' + assert fn_obj.datastream_class == 'itscomplicated' + assert fn_obj.facility == 'X1' + assert fn_obj.level == '00' + assert fn_obj.datastream == 'nsaitscomplicatedX1.00' + assert fn_obj.date == '991230' + assert fn_obj.time == '2334' + assert fn_obj.ext == 'txt' + + fn_obj = DatastreamParser('sgpmetE13.b1') + assert fn_obj.site == 'sgp' + assert fn_obj.datastream_class == 'met' + assert fn_obj.facility == 'E13' + assert fn_obj.level == 'b1' + assert fn_obj.datastream == 'sgpmetE13.b1' + assert fn_obj.date is None + assert fn_obj.time is None + assert fn_obj.ext is None + + fn_obj = DatastreamParser('sgpmetE13') + assert fn_obj.site == 'sgp' + assert fn_obj.datastream_class == 'met' + assert fn_obj.facility == 'E13' + assert fn_obj.level is None + assert fn_obj.datastream is None + assert fn_obj.date is None + assert fn_obj.time is None + assert fn_obj.ext is None + + fn_obj = DatastreamParser('sgpmet') + assert fn_obj.site == 'sgp' + assert fn_obj.datastream_class == 'met' + assert fn_obj.facility is None + assert fn_obj.level is None + assert fn_obj.datastream is None + assert fn_obj.date is None + assert fn_obj.time is None + assert fn_obj.ext is None + + fn_obj = DatastreamParser('sgp') + assert fn_obj.site == 'sgp' + assert fn_obj.datastream_class is None + assert fn_obj.facility is None + assert fn_obj.level is None + assert fn_obj.datastream is None + assert fn_obj.date is None + assert fn_obj.time is None + assert fn_obj.ext is None + + fn_obj = DatastreamParser('sg') + assert fn_obj.site is None + assert fn_obj.datastream_class is None + assert fn_obj.facility is None + assert fn_obj.level is None + assert fn_obj.datastream is None + assert fn_obj.date is None + assert fn_obj.time is None + assert fn_obj.ext is None + del fn_obj + + +def test_arm_site_location_search(): + # Test for many facilities + test_dict_many = act.utils.arm_site_location_search(site_code='sgp', facility_code=None) + assert len(test_dict_many) > 30 + assert list(test_dict_many)[0] == 'sgp A1' + assert list(test_dict_many)[2] == 'sgp A3' + + assert_almost_equal(test_dict_many[list(test_dict_many)[0]]['latitude'], 37.843058) + assert_almost_equal(test_dict_many[list(test_dict_many)[0]]['longitude'], -97.020569) + assert_almost_equal(test_dict_many[list(test_dict_many)[2]]['latitude'], 37.626) + assert_almost_equal(test_dict_many[list(test_dict_many)[2]]['longitude'], -96.882) + + # Test for one facility + test_dict_one = act.utils.arm_site_location_search(site_code='sgp', facility_code='I5') + assert len(test_dict_one) == 1 + assert list(test_dict_one)[0] == 'sgp I5' + assert_almost_equal(test_dict_one[list(test_dict_one)[0]]['latitude'], 36.491178) + assert_almost_equal(test_dict_one[list(test_dict_one)[0]]['longitude'], -97.593936) + + # Test for a facility with no latitude and longitude information + test_dict_no_coord = act.utils.arm_site_location_search(site_code='sgp', facility_code='A6') + assert list(test_dict_no_coord)[0] == 'sgp A6' + assert test_dict_no_coord[list(test_dict_no_coord)[0]]['latitude'] is None + assert test_dict_no_coord[list(test_dict_no_coord)[0]]['longitude'] is None + + # Test for another site + test_dict_nsa = act.utils.arm_site_location_search(site_code='nsa', facility_code=None) + assert len(test_dict_nsa) > 5 + assert list(test_dict_nsa)[0] == 'nsa C1' + assert test_dict_nsa[list(test_dict_nsa)[0]]['latitude'] == 71.323 + assert test_dict_nsa[list(test_dict_nsa)[0]]['longitude'] == -156.615 diff --git a/tests/utils/test_datetime_utils.py b/tests/utils/test_datetime_utils.py new file mode 100644 index 0000000000..ce03f21a83 --- /dev/null +++ b/tests/utils/test_datetime_utils.py @@ -0,0 +1,83 @@ +from datetime import datetime + +import numpy as np +import pandas as pd + +import act + + +def test_dates_between(): + start_date = '20191201' + end_date = '20201201' + date_list = act.utils.dates_between(start_date, end_date) + start_string = datetime.strptime(start_date, '%Y%m%d').strftime('%Y-%m-%d') + end_string = datetime.strptime(end_date, '%Y%m%d').strftime('%Y-%m-%d') + answer = np.arange(start_string, end_string, dtype='datetime64[D]') + answer = np.append(answer, answer[-1] + 1) + answer = answer.astype('datetime64[s]').astype(int) + answer = [datetime.utcfromtimestamp(ii) for ii in answer] + + assert date_list == answer + + +def test_datetime64_to_datetime(): + time_datetime = [ + datetime(2019, 1, 1, 1, 0), + datetime(2019, 1, 1, 1, 1), + datetime(2019, 1, 1, 1, 2), + datetime(2019, 1, 1, 1, 3), + datetime(2019, 1, 1, 1, 4), + ] + + time_datetime64 = [ + np.datetime64(datetime(2019, 1, 1, 1, 0)), + np.datetime64(datetime(2019, 1, 1, 1, 1)), + np.datetime64(datetime(2019, 1, 1, 1, 2)), + np.datetime64(datetime(2019, 1, 1, 1, 3)), + np.datetime64(datetime(2019, 1, 1, 1, 4)), + ] + + time_datetime64_to_datetime = act.utils.datetime_utils.datetime64_to_datetime(time_datetime64) + assert time_datetime == time_datetime64_to_datetime + + +def test_reduce_time_ranges(): + time = pd.date_range(start='2020-01-01T00:00:00', freq='1min', periods=100) + time = time.to_list() + time = time[0:50] + time[60:] + result = act.utils.datetime_utils.reduce_time_ranges(time) + assert len(result) == 2 + assert result[1][1].minute == 39 + + result = act.utils.datetime_utils.reduce_time_ranges(time, broken_barh=True) + assert len(result) == 2 + + +def test_date_parser(): + datestring = '20111001' + output_format = '%Y/%m/%d' + + test_string = act.utils.date_parser(datestring, output_format, return_datetime=False) + assert test_string == '2011/10/01' + + test_datetime = act.utils.date_parser(datestring, output_format, return_datetime=True) + assert test_datetime == datetime(2011, 10, 1) + + +def test_date_parser_minute_second(): + date_string = '2020-01-01T12:00:00' + parsed_date = act.utils.date_parser(date_string, return_datetime=True) + assert parsed_date == datetime(2020, 1, 1, 12, 0, 0) + + output_format = parsed_date.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z' + assert output_format == '2020-01-01T12:00:00.000Z' + + +def test_adjust_timestamp(): + file = act.tests.sample_files.EXAMPLE_EBBR1 + ds = act.io.arm.read_arm_netcdf(file) + ds = act.utils.datetime_utils.adjust_timestamp(ds) + assert ds['time'].values[0] == np.datetime64('2019-11-24T23:30:00.000000000') + + ds = act.utils.datetime_utils.adjust_timestamp(ds, offset=-60 * 60) + assert ds['time'].values[0] == np.datetime64('2019-11-24T22:30:00.000000000') diff --git a/tests/utils/test_geo_utils.py b/tests/utils/test_geo_utils.py new file mode 100644 index 0000000000..f49dccd568 --- /dev/null +++ b/tests/utils/test_geo_utils.py @@ -0,0 +1,179 @@ +from datetime import datetime + +import numpy as np +import pytest +import pytz + +import act + + +def test_destination_azimuth_distance(): + lat = 37.1509 + lon = -98.362 + lat2, lon2 = act.utils.destination_azimuth_distance(lat, lon, 180.0, 100) + + np.testing.assert_almost_equal(lat2, 37.150, decimal=3) + np.testing.assert_almost_equal(lon2, -98.361, decimal=3) + + +def test_add_solar_variable(): + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_NAV) + new_ds = act.utils.geo_utils.add_solar_variable(ds) + + assert 'sun_variable' in list(new_ds.keys()) + assert new_ds['sun_variable'].values[10] == 1 + assert np.sum(new_ds['sun_variable'].values) >= 598 + + new_ds = act.utils.geo_utils.add_solar_variable(ds, dawn_dusk=True) + assert 'sun_variable' in list(new_ds.keys()) + assert new_ds['sun_variable'].values[10] == 1 + assert np.sum(new_ds['sun_variable'].values) >= 1234 + + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_MET1) + new_ds = act.utils.geo_utils.add_solar_variable(ds, dawn_dusk=True) + assert np.sum(new_ds['sun_variable'].values) >= 1046 + + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_IRTSST) + ds = ds.fillna(0) + new_ds = act.utils.geo_utils.add_solar_variable(ds) + assert np.sum(new_ds['sun_variable'].values) >= 12 + + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_IRTSST) + ds.drop_vars('lat') + pytest.raises(ValueError, act.utils.geo_utils.add_solar_variable, ds) + + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_IRTSST) + ds.drop_vars('lon') + pytest.raises(ValueError, act.utils.geo_utils.add_solar_variable, ds) + ds.close() + new_ds.close() + + +def test_solar_azimuth_elevation(): + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_NAV) + + elevation, azimuth, distance = act.utils.geo_utils.get_solar_azimuth_elevation( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + time=ds['time'].values, + library='skyfield', + temperature_C='standard', + pressure_mbar='standard', + ) + assert np.isclose(np.nanmean(elevation), 10.5648, atol=0.001) + assert np.isclose(np.nanmean(azimuth), 232.0655, atol=0.001) + assert np.isclose(np.nanmean(distance), 0.985, atol=0.001) + + +def test_get_sunrise_sunset_noon(): + ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_NAV) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + date=ds['time'].values[0], + library='skyfield', + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) + assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) + assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + date=ds['time'].values[0], + library='skyfield', + timezone=True, + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32, tzinfo=pytz.UTC) + assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4, tzinfo=pytz.UTC) + assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10, tzinfo=pytz.UTC) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + date='20180201', + library='skyfield', + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) + assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) + assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + date=['20180201'], + library='skyfield', + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) + assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) + assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + date=datetime(2018, 2, 1), + library='skyfield', + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) + assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) + assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + date=datetime(2018, 2, 1, tzinfo=pytz.UTC), + library='skyfield', + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) + assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) + assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=ds['lat'].values[0], + longitude=ds['lon'].values[0], + date=[datetime(2018, 2, 1)], + library='skyfield', + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 1, 31, 22, 36, 32) + assert sunset[0].replace(microsecond=0) == datetime(2018, 2, 1, 17, 24, 4) + assert noon[0].replace(microsecond=0) == datetime(2018, 2, 1, 8, 2, 10) + + sunrise, sunset, noon = act.utils.geo_utils.get_sunrise_sunset_noon( + latitude=85.0, longitude=-140.0, date=[datetime(2018, 6, 1)], library='skyfield' + ) + assert sunrise[0].replace(microsecond=0) == datetime(2018, 3, 30, 10, 48, 48) + assert sunset[0].replace(microsecond=0) == datetime(2018, 9, 12, 8, 50, 14) + assert noon[0].replace(microsecond=0) == datetime(2018, 6, 1, 21, 17, 52) + + +def test_is_sun_visible(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) + result = act.utils.geo_utils.is_sun_visible( + latitude=ds['lat'].values, + longitude=ds['lon'].values, + date_time=ds['time'].values, + ) + assert len(result) == 48 + assert sum(result) == 20 + + result = act.utils.geo_utils.is_sun_visible( + latitude=ds['lat'].values, + longitude=ds['lon'].values, + date_time=ds['time'].values[0], + ) + assert result == [False] + + result = act.utils.geo_utils.is_sun_visible( + latitude=ds['lat'].values, + longitude=ds['lon'].values, + date_time=[datetime(2019, 11, 25, 13, 30, 00)], + ) + assert result == [True] + + result = act.utils.geo_utils.is_sun_visible( + latitude=ds['lat'].values, + longitude=ds['lon'].values, + date_time=datetime(2019, 11, 25, 13, 30, 00), + ) + assert result == [True] diff --git a/tests/utils/test_inst_utils.py b/tests/utils/test_inst_utils.py new file mode 100644 index 0000000000..465e41f834 --- /dev/null +++ b/tests/utils/test_inst_utils.py @@ -0,0 +1,22 @@ +import numpy as np + +import act + + +def test_decode_present_weather(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET1) + ds = act.utils.decode_present_weather(ds, variable='pwd_pw_code_inst') + + data = ds['pwd_pw_code_inst_decoded'].values + result = 'No significant weather observed' + assert data[0] == result + assert data[100] == result + assert data[600] == result + + np.testing.assert_raises(ValueError, act.utils.inst_utils.decode_present_weather, ds) + np.testing.assert_raises( + ValueError, + act.utils.inst_utils.decode_present_weather, + ds, + variable='temp_temp', + ) diff --git a/tests/utils/test_io_utils.py b/tests/utils/test_io_utils.py new file mode 100644 index 0000000000..89cfee6ef6 --- /dev/null +++ b/tests/utils/test_io_utils.py @@ -0,0 +1,282 @@ +import glob +import os +import random +import shutil +import tempfile +from os import PathLike, chdir, getcwd +from pathlib import Path +from string import ascii_letters + +import numpy as np +import pytest +from arm_test_data import locate as test_data_locate + +import act +from act.tests import sample_files + +try: + import moviepy.video.io.ImageSequenceClip + + MOVIEPY_AVAILABLE = True +except ImportError: + MOVIEPY_AVAILABLE = False + + +def test_read_netcdf_gztarfiles(): + with tempfile.TemporaryDirectory() as tmpdirname: + met_files = list(Path(file) for file in act.tests.EXAMPLE_MET_WILDCARD) + filename = act.utils.io_utils.pack_tar(met_files, write_directory=tmpdirname) + filename = act.utils.io_utils.pack_gzip(filename, write_directory=tmpdirname, remove=True) + ds = act.io.arm.read_arm_netcdf(filename) + ds.clean.cleanup() + + assert 'temp_mean' in ds.data_vars + + with tempfile.TemporaryDirectory() as tmpdirname: + met_files = sample_files.EXAMPLE_MET1 + filename = act.utils.io_utils.pack_gzip(met_files, write_directory=tmpdirname, remove=False) + ds = act.io.arm.read_arm_netcdf(filename) + ds.clean.cleanup() + + assert 'temp_mean' in ds.data_vars + + +def test_read_netcdf_tarfiles(): + with tempfile.TemporaryDirectory() as tmpdirname: + met_files = list(Path(file) for file in act.tests.EXAMPLE_MET_WILDCARD) + filename = act.utils.io_utils.pack_tar(met_files, write_directory=tmpdirname) + ds = act.io.arm.read_arm_netcdf(filename) + ds.clean.cleanup() + + assert 'temp_mean' in ds.data_vars + + +def test_unpack_tar(): + with tempfile.TemporaryDirectory() as tmpdirname: + tar_file = Path(tmpdirname, 'tar_file_dir') + output_dir = Path(tmpdirname, 'output_dir') + tar_file.mkdir(parents=True, exist_ok=True) + output_dir.mkdir(parents=True, exist_ok=True) + + for tar_file_name in ['test_file1.tar', 'test_file2.tar']: + filenames = [] + for value in range(0, 10): + filename = ''.join(random.choices(list(ascii_letters), k=15)) + filename = Path(tar_file, f'{filename}.nc') + filename.touch() + filenames.append(filename) + act.utils.io_utils.pack_tar( + filenames, write_filename=Path(tar_file, tar_file_name), remove=True + ) + + tar_files = list(tar_file.glob('*.tar')) + result = act.utils.io_utils.unpack_tar(tar_files[0], write_directory=output_dir) + assert isinstance(result, list) + assert len(result) == 10 + for file in result: + assert isinstance(file, (str, PathLike)) + + files = list(output_dir.glob('*')) + assert len(files) == 1 + assert files[0].is_dir() + act.utils.io_utils.cleanup_files(dirname=output_dir) + files = list(output_dir.glob('*')) + assert len(files) == 0 + + # Check not returing file but directory + result = act.utils.io_utils.unpack_tar( + tar_files[0], write_directory=output_dir, return_files=False + ) + assert isinstance(result, str) + files = list(Path(result).glob('*')) + assert len(files) == 10 + act.utils.io_utils.cleanup_files(result) + files = list(Path(output_dir).glob('*')) + assert len(files) == 0 + + # Test temporary directory + result = act.utils.io_utils.unpack_tar(tar_files[0], temp_dir=True) + assert isinstance(result, list) + assert len(result) == 10 + for file in result: + assert isinstance(file, (str, PathLike)) + + act.utils.io_utils.cleanup_files(files=result) + + # Test removing TAR file + result = act.utils.io_utils.unpack_tar(tar_files, write_directory=output_dir, remove=True) + assert isinstance(result, list) + assert len(result) == 20 + for file in result: + assert isinstance(file, (str, PathLike)) + + tar_files = list(tar_file.glob('*.tar')) + assert len(tar_files) == 0 + + act.utils.io_utils.cleanup_files(files=result) + files = list(Path(output_dir).glob('*')) + assert len(files) == 0 + + not_a_tar_file = Path(tar_file, 'not_a_tar_file.tar') + not_a_tar_file.touch() + result = act.utils.io_utils.unpack_tar(not_a_tar_file, Path(output_dir, 'another_dir')) + assert result == [] + + act.utils.io_utils.cleanup_files() + + not_a_directory = '/asasfdlkjsdfjioasdflasdfhasd/not/a/directory' + act.utils.io_utils.cleanup_files(dirname=not_a_directory) + + not_a_file = Path(not_a_directory, 'not_a_file.nc') + act.utils.io_utils.cleanup_files(files=not_a_file) + + act.utils.io_utils.cleanup_files(files=output_dir) + + dir_names = list(Path(tmpdirname).glob('*')) + for dir_name in [tar_file, output_dir]: + assert dir_name, dir_name in dir_names + + filename = ''.join(random.choices(list(ascii_letters), k=15)) + filename = Path(tar_file, f'{filename}.nc') + filename.touch() + result = act.utils.io_utils.pack_tar( + filename, write_filename=Path(tar_file, 'test_file_single'), remove=True + ) + assert Path(filename).is_file() is False + assert Path(result).is_file() + assert result.endswith('.tar') + + +def test_gunzip(): + with tempfile.TemporaryDirectory() as tmpdirname: + filenames = [] + for value in range(0, 10): + filename = ''.join(random.choices(list(ascii_letters), k=15)) + filename = Path(tmpdirname, f'{filename}.nc') + filename.touch() + filenames.append(filename) + + filename = act.utils.io_utils.pack_tar(filenames, write_directory=tmpdirname, remove=True) + files = list(Path(tmpdirname).glob('*')) + assert len(files) == 1 + assert files[0].name == 'created_tarfile.tar' + assert Path(filename).name == 'created_tarfile.tar' + + gzip_file = act.utils.io_utils.pack_gzip(filename=filename) + files = list(Path(tmpdirname).glob('*')) + assert len(files) == 2 + files = list(Path(tmpdirname).glob('*.gz')) + assert files[0].name == 'created_tarfile.tar.gz' + assert Path(gzip_file).name == 'created_tarfile.tar.gz' + + unpack_filename = act.utils.io_utils.unpack_gzip(filename=gzip_file) + files = list(Path(tmpdirname).glob('*')) + assert len(files) == 2 + assert Path(unpack_filename).name == 'created_tarfile.tar' + + result = act.utils.io_utils.unpack_tar(unpack_filename, return_files=True, randomize=True) + files = list(Path(Path(result[0]).parent).glob('*')) + assert len(result) == 10 + assert len(files) == 10 + for file in result: + assert file.endswith('.nc') + + with tempfile.TemporaryDirectory() as tmpdirname: + filenames = [] + for value in range(0, 10): + filename = ''.join(random.choices(list(ascii_letters), k=15)) + filename = Path(tmpdirname, f'{filename}.nc') + filename.touch() + filenames.append(filename) + + filename = act.utils.io_utils.pack_tar(filenames, write_directory=tmpdirname, remove=True) + files = list(Path(tmpdirname).glob('*')) + assert len(files) == 1 + files = list(Path(tmpdirname).glob('*.tar')) + assert files[0].name == 'created_tarfile.tar' + assert Path(filename).name == 'created_tarfile.tar' + + gzip_file = act.utils.io_utils.pack_gzip( + filename=filename, write_directory=Path(filename).parent, remove=False + ) + files = list(Path(tmpdirname).glob('*')) + assert len(files) == 2 + files = list(Path(tmpdirname).glob('*gz')) + assert files[0].name == 'created_tarfile.tar.gz' + assert Path(gzip_file).name == 'created_tarfile.tar.gz' + + unpack_filename = act.utils.io_utils.unpack_gzip( + filename=gzip_file, write_directory=Path(filename).parent, remove=False + ) + files = list(Path(tmpdirname).glob('*')) + assert len(files) == 2 + assert Path(unpack_filename).name == 'created_tarfile.tar' + + result = act.utils.io_utils.unpack_tar( + unpack_filename, return_files=True, randomize=False, remove=True + ) + files = list(Path(Path(result[0]).parent).glob('*.nc')) + assert len(result) == 10 + assert len(files) == 10 + for file in result: + assert file.endswith('.nc') + + assert Path(unpack_filename).is_file() is False + + +@pytest.mark.skipif(not MOVIEPY_AVAILABLE, reason='MoviePy is not installed.') +def test_generate_movie(): + files = [ + 'https://github.com/ARM-DOE/ACT/blob/main/tests/plotting/baseline/test_contour.png?raw=true', + 'https://github.com/ARM-DOE/ACT/blob/main/tests/plotting/baseline/test_contour2.png?raw=true', + 'https://github.com/ARM-DOE/ACT/blob/main/tests/plotting/baseline/test_contourf.png?raw=true', + 'https://github.com/ARM-DOE/ACT/blob/main/tests/plotting/baseline/test_contourf2.png?raw=true', + ] + cwd = Path.cwd() + with tempfile.TemporaryDirectory() as tmpdirname: + try: + chdir(tmpdirname) + + # Test URL path for making movie + result = act.utils.generate_movie(files, fps=5) + assert Path(result).name == 'movie.mp4' + + # Test list of files for making movie + files = [ + 'test_contour.png', + 'test_contour2.png', + 'test_contourf.png', + 'test_contourf2.png', + ] + basepath = Path(Path(__file__).parents[1], 'plotting', 'baseline') + files = [Path(basepath, fl) for fl in files] + write_filename = Path(tmpdirname, 'one', 'two', 'three', 'movie_filename_testing.mp4') + result = act.utils.generate_movie(files, write_filename=write_filename) + assert result == str(write_filename) + assert np.isclose(Path(write_filename).stat().st_size, 173189, 1000) + + # Test PosixPath generator for making movie + file_generator = basepath.glob('test_contour[!_]*.png') + result = act.utils.generate_movie(file_generator, write_filename=write_filename) + assert result == str(write_filename) + assert np.isclose(Path(write_filename).stat().st_size, 173189, 1000) + + # Test passing path to directory of images + dir_path = Path(tmpdirname, 'images') + dir_path.mkdir() + for fl in files: + shutil.copy(fl, Path(dir_path, Path(fl).name)) + + files = dir_path.glob('*.*') + result = act.utils.generate_movie(dir_path) + assert Path(result).name == 'movie.mp4' + assert np.isclose(Path(result).stat().st_size, 173189, 1000) + + # Test converting movie format + write_filename = 'movie2.mp4' + result = act.utils.generate_movie(result, write_filename=write_filename) + assert Path(result).name == write_filename + assert np.isclose(Path(result).stat().st_size, 173189, 1000) + + finally: + chdir(cwd) diff --git a/tests/utils/test_qc_utils.py b/tests/utils/test_qc_utils.py new file mode 100644 index 0000000000..9c9183202d --- /dev/null +++ b/tests/utils/test_qc_utils.py @@ -0,0 +1,46 @@ +import tempfile +from pathlib import Path + +import act + + +def test_calculate_dqr_times(): + ebbr1_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) + ebbr2_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_EBBR2) + brs_ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_BRS) + ebbr1_result = act.utils.calculate_dqr_times(ebbr1_ds, variable=['soil_temp_1'], threshold=2) + ebbr2_result = act.utils.calculate_dqr_times( + ebbr2_ds, variable=['rh_bottom_fraction'], qc_bit=3, threshold=2 + ) + ebbr3_result = act.utils.calculate_dqr_times( + ebbr2_ds, variable=['rh_bottom_fraction'], qc_bit=3 + ) + brs_result = act.utils.calculate_dqr_times( + brs_ds, variable='down_short_hemisp_min', qc_bit=2, threshold=30 + ) + assert ebbr1_result == [('2019-11-25 02:00:00', '2019-11-25 04:30:00')] + assert ebbr2_result == [('2019-11-30 00:00:00', '2019-11-30 11:00:00')] + assert brs_result == [('2019-07-05 01:57:00', '2019-07-05 11:07:00')] + assert ebbr3_result is None + with tempfile.TemporaryDirectory() as tmpdirname: + write_file = Path(tmpdirname) + brs_result = act.utils.calculate_dqr_times( + brs_ds, + variable='down_short_hemisp_min', + qc_bit=2, + threshold=30, + txt_path=str(write_file), + ) + + brs_result = act.utils.calculate_dqr_times( + brs_ds, + variable='down_short_hemisp_min', + qc_bit=2, + threshold=30, + return_missing=False, + ) + assert len(brs_result[0]) == 2 + + ebbr1_ds.close() + ebbr2_ds.close() + brs_ds.close() diff --git a/tests/utils/test_radiance_utils.py b/tests/utils/test_radiance_utils.py new file mode 100644 index 0000000000..e7d0b5c006 --- /dev/null +++ b/tests/utils/test_radiance_utils.py @@ -0,0 +1,14 @@ +import numpy as np + +import act + + +def test_planck_converter(): + wnum = 1100 + temp = 300 + radiance = 81.5 + result = act.utils.radiance_utils.planck_converter(wnum=wnum, temperature=temp) + np.testing.assert_almost_equal(result, radiance, decimal=1) + result = act.utils.radiance_utils.planck_converter(wnum=wnum, radiance=radiance) + assert np.ceil(result) == temp + np.testing.assert_raises(ValueError, act.utils.radiance_utils.planck_converter) diff --git a/tests/utils/test_ship_utils.py b/tests/utils/test_ship_utils.py new file mode 100644 index 0000000000..1d1acb388b --- /dev/null +++ b/tests/utils/test_ship_utils.py @@ -0,0 +1,20 @@ +import numpy as np + +import act + + +def test_calc_cog_sog(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_NAV) + + ds = act.utils.calc_cog_sog(ds) + + cog = ds['course_over_ground'].values + sog = ds['speed_over_ground'].values + + np.testing.assert_almost_equal(cog[10], 170.987, decimal=3) + np.testing.assert_almost_equal(sog[15], 0.448, decimal=3) + + ds = ds.rename({'lat': 'latitude', 'lon': 'longitude'}) + ds = act.utils.calc_cog_sog(ds) + np.testing.assert_almost_equal(cog[10], 170.987, decimal=3) + np.testing.assert_almost_equal(sog[15], 0.448, decimal=3) diff --git a/versioneer.py b/versioneer.py index 64fea1c892..ba73f7fe6b 100644 --- a/versioneer.py +++ b/versioneer.py @@ -1,4 +1,3 @@ - # Version: 0.18 """The Versioneer - like a rocketeer, but for versions. @@ -276,7 +275,6 @@ """ -from __future__ import print_function try: import configparser except ImportError: @@ -300,19 +298,21 @@ def get_root(): 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") + 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") + 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').") + 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 @@ -325,8 +325,10 @@ def get_root(): 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)) + print( + 'Warning: build in %s is using versioneer.py from %s' + % (os.path.dirname(me), versioneer_py) + ) except NameError: pass return root @@ -338,26 +340,27 @@ def get_config_from_root(root): # 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 + setup_cfg = os.path.join(root, 'setup.cfg') + parser = configparser.ConfigParser() + with open(setup_cfg) as f: + parser.read_file(f) + VCS = parser.get('versioneer', 'VCS') # mandatory def get(parser, name): - if parser.has_option("versioneer", name): - return parser.get("versioneer", 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") + 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") + cfg.tag_prefix = '' + cfg.parentdir_prefix = get(parser, 'parentdir_prefix') + cfg.verbose = get(parser, 'verbose') return cfg @@ -372,17 +375,18 @@ class NotThisMethod(Exception): 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): +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 @@ -390,35 +394,40 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, 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)) + p = subprocess.Popen( + [c] + args, + cwd=cwd, + env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr else None), + ) break - except EnvironmentError: + except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: - print("unable to run %s" % dispcmd) + print('unable to run %s' % dispcmd) print(e) return None, None else: if verbose: - print("unable to find command, tried %s" % (commands,)) + print(f'unable to find command, tried {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) + print('unable to run %s (error)' % dispcmd) + print('stdout was %s' % stdout) return None, p.returncode return stdout, p.returncode -LONG_VERSION_PY['git'] = ''' +LONG_VERSION_PY[ + 'git' +] = r''' # 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 @@ -941,7 +950,7 @@ def get_versions(): ''' -@register_vcs_handler("git", "get_keywords") +@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 @@ -950,32 +959,32 @@ def git_get_keywords(versionfile_abs): # _version.py. keywords = {} try: - f = open(versionfile_abs, "r") + f = open(versionfile_abs) for line in f.readlines(): - if line.strip().startswith("git_refnames ="): + 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 ="): + 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 ="): + keywords['full'] = mo.group(1) + if line.strip().startswith('git_date ='): mo = re.search(r'=\s*"(.*)"', line) if mo: - keywords["date"] = mo.group(1) + keywords['date'] = mo.group(1) f.close() - except EnvironmentError: + except OSError: pass return keywords -@register_vcs_handler("git", "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") + 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 @@ -983,17 +992,17 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # 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"): + 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(",")]) + print('keywords are unexpanded, not using') + raise NotThisMethod('unexpanded keywords, not a git-archive tarball') + refs = {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)]) + TAG = 'tag: ' + tags = {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 @@ -1002,30 +1011,37 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # 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)]) + tags = {r for r in refs if re.search(r'\d', r)} if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) + print("discarding '%s', no digits" % ','.join(refs - tags)) if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) + 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):] + 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} + 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} + 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") +@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. @@ -1033,56 +1049,63 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): 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"] + 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) + 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) + 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) + 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) + 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 + 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 + dirty = git_describe.endswith('-dirty') + pieces['dirty'] = dirty if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] + git_describe = git_describe[: git_describe.rindex('-dirty')] # now we have TAG-NUM-gHEX or HEX - if "-" in git_describe: + 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) + pieces['error'] = "unable to parse git-describe output: '%s'" % describe_out return pieces # tag @@ -1091,28 +1114,28 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): 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)) + pieces['error'] = "tag '{}' doesn't start with prefix '{}'".format( + full_tag, + tag_prefix, + ) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] + pieces['closest-tag'] = full_tag[len(tag_prefix) :] # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) + pieces['distance'] = int(mo.group(2)) # commit: short hex revision ID - pieces["short"] = mo.group(3) + 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 + 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) + date = run_command(GITS, ['show', '-s', '--format=%ci', 'HEAD'], cwd=root)[0].strip() + pieces['date'] = date.strip().replace(' ', 'T', 1).replace(' ', '', 1) return pieces @@ -1123,36 +1146,36 @@ def do_vcs_install(manifest_in, versionfile_source, ipy): 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"] + 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" + 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" + versioneer_file = 'versioneer.py' files.append(versioneer_file) present = False try: - f = open(".gitattributes", "r") + f = open('.gitattributes') for line in f.readlines(): if line.strip().startswith(versionfile_source): - if "export-subst" in line.strip().split()[1:]: + if 'export-subst' in line.strip().split()[1:]: present = True f.close() - except EnvironmentError: + except OSError: pass if not present: - f = open(".gitattributes", "a+") - f.write("%s export-subst\n" % versionfile_source) + f = open('.gitattributes', 'a+') + f.write('%s export-subst\n' % versionfile_source) f.close() - files.append(".gitattributes") - run_command(GITS, ["add", "--"] + files) + files.append('.gitattributes') + run_command(GITS, ['add', '--'] + files) def versions_from_parentdir(parentdir_prefix, root, verbose): @@ -1167,16 +1190,22 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): 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} + 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)) + print( + 'Tried directories %s but none started with prefix %s' + % (str(rootdirs), parentdir_prefix) + ) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @@ -1203,34 +1232,31 @@ def versions_from_file(filename): 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) + except OSError: + 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) + 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") + 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: + 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"])) + print("set {} to '{}'".format(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 "+" + if '+' in pieces.get('closest-tag', ''): + return '.' + return '+' def render_pep440(pieces): @@ -1242,19 +1268,18 @@ def render_pep440(pieces): 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"]: + 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" + 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" + rendered = '0+untagged.%d.g%s' % (pieces['distance'], pieces['short']) + if pieces['dirty']: + rendered += '.dirty' return rendered @@ -1264,13 +1289,13 @@ def render_pep440_pre(pieces): Exceptions: 1: no tags. 0.post.devDISTANCE """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] + 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"] + rendered = '0.post.dev%d' % pieces['distance'] return rendered @@ -1284,20 +1309,20 @@ def render_pep440_post(pieces): 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" + 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"] + rendered += 'g%s' % pieces['short'] else: # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] + rendered = '0.post%d' % pieces['distance'] + if pieces['dirty']: + rendered += '.dev0' + rendered += '+g%s' % pieces['short'] return rendered @@ -1309,17 +1334,17 @@ def render_pep440_old(pieces): 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" + 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" + rendered = '0.post%d' % pieces['distance'] + if pieces['dirty']: + rendered += '.dev0' return rendered @@ -1331,15 +1356,15 @@ def render_git_describe(pieces): 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"]) + 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" + rendered = pieces['short'] + if pieces['dirty']: + rendered += '-dirty' return rendered @@ -1352,47 +1377,53 @@ def render_git_describe_long(pieces): 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"]) + 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" + 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": + 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": + elif style == 'pep440-pre': rendered = render_pep440_pre(pieces) - elif style == "pep440-post": + elif style == 'pep440-post': rendered = render_pep440_post(pieces) - elif style == "pep440-old": + elif style == 'pep440-old': rendered = render_pep440_old(pieces) - elif style == "git-describe": + elif style == 'git-describe': rendered = render_git_describe(pieces) - elif style == "git-describe-long": + 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")} + return { + 'version': rendered, + 'full-revisionid': pieces['long'], + 'dirty': pieces['dirty'], + 'error': None, + 'date': pieces.get('date'), + } class VersioneerBadRootError(Exception): @@ -1404,20 +1435,19 @@ def get_versions(verbose=False): Returns dict with two keys: 'version' and 'full'. """ - if "versioneer" in sys.modules: + if 'versioneer' in sys.modules: # see the discussion in cmdclass.py:get_cmdclass() - del sys.modules["versioneer"] + 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" + 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" + 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) @@ -1427,14 +1457,14 @@ def get_versions(verbose=False): # 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") + 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) + print('got version from expanded keyword %s' % ver) return ver except NotThisMethod: pass @@ -1442,18 +1472,18 @@ def get_versions(verbose=False): try: ver = versions_from_file(versionfile_abs) if verbose: - print("got version from file %s %s" % (versionfile_abs, ver)) + print(f'got version from file {versionfile_abs} {ver}') return ver except NotThisMethod: pass - from_vcs_f = handlers.get("pieces_from_vcs") + 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) + print('got version from VCS %s' % ver) return ver except NotThisMethod: pass @@ -1462,28 +1492,32 @@ def get_versions(verbose=False): if cfg.parentdir_prefix: ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) if verbose: - print("got version from parentdir %s" % ver) + print('got version from parentdir %s' % ver) return ver except NotThisMethod: pass if verbose: - print("unable to compute version") + print('unable to compute version') - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, "error": "unable to compute version", - "date": None} + 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"] + 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"] + 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 @@ -1503,7 +1537,7 @@ def get_cmdclass(): from distutils.core import Command class cmd_version(Command): - description = "report generated version string" + description = 'report generated version string' user_options = [] boolean_options = [] @@ -1515,13 +1549,14 @@ def finalize_options(self): 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 + 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 # @@ -1539,7 +1574,7 @@ def run(self): # setup.py egg_info -> ? # we override different "build_py" commands for both environments - if "setuptools" in sys.modules: + 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 @@ -1553,14 +1588,15 @@ def 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) + 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? + 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=[{ @@ -1574,22 +1610,26 @@ def run(self): cfg = get_config_from_root(root) versions = get_versions() target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) + 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: + 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"] + 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: @@ -1603,24 +1643,28 @@ def run(self): cfg = get_config_from_root(root) versions = get_versions() target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) + 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: + 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 + 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: + if 'setuptools' in sys.modules: from setuptools.command.sdist import sdist as _sdist else: from distutils.command.sdist import sdist as _sdist @@ -1631,7 +1675,7 @@ def run(self): self._versioneer_generated_versions = versions # unless we update this, the command will keep using the old # version - self.distribution.metadata.version = versions["version"] + self.distribution.metadata.version = versions['version'] return _sdist.run(self) def make_release_tree(self, base_dir, files): @@ -1642,10 +1686,10 @@ def make_release_tree(self, base_dir, files): # (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 + print('UPDATING %s' % target_versionfile) + write_to_version_file(target_versionfile, self._versioneer_generated_versions) + + cmds['sdist'] = cmd_sdist return cmds @@ -1699,40 +1743,41 @@ def do_setup(): root = get_root() try: cfg = get_config_from_root(root) - except (EnvironmentError, configparser.NoSectionError, - configparser.NoOptionError) as e: + except (OSError, 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: + 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: + 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") + 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: + with open(ipy) as f: old = f.read() - except EnvironmentError: - old = "" + except OSError: + old = '' if INIT_PY_SNIPPET not in old: - print(" appending to %s" % ipy) - with open(ipy, "a") as f: + print(' appending to %s' % ipy) + with open(ipy, 'a') as f: f.write(INIT_PY_SNIPPET) else: - print(" %s unmodified" % ipy) + print(' %s unmodified' % ipy) else: print(" %s doesn't exist, ok" % ipy) ipy = None @@ -1741,33 +1786,32 @@ def do_setup(): # (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") + manifest_in = os.path.join(root, 'MANIFEST.in') simple_includes = set() try: - with open(manifest_in, "r") as f: + with open(manifest_in) as f: for line in f: - if line.startswith("include "): + if line.startswith('include '): for include in line.split()[1:]: simple_includes.add(include) - except EnvironmentError: + except OSError: 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: + 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") + 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) + 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") + 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 @@ -1781,41 +1825,41 @@ def scan_setup_py(): found = set() setters = False errors = 0 - with open("setup.py", "r") as f: + with open('setup.py') 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: + 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: + 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("") + 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("") + print('now lives in setup.cfg, and should be removed from setup.py') + print('') errors += 1 return errors -if __name__ == "__main__": +if __name__ == '__main__': cmd = sys.argv[1] - if cmd == "setup": + if cmd == 'setup': errors = do_setup() errors += scan_setup_py() if errors: