diff --git a/.github/ISSUE_TEMPLATE/release.md b/.github/ISSUE_TEMPLATE/release.md index 0c9400ffe..d80e78520 100644 --- a/.github/ISSUE_TEMPLATE/release.md +++ b/.github/ISSUE_TEMPLATE/release.md @@ -3,7 +3,7 @@ name: Release Request about: Request a release for this package title: '[Release]: ' labels: release, high-priority -assignees: 'pilotchute' +assignees: 'anissa111' --- ## For Package Leader diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index 86f76aea8..6803096ce 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -8,13 +8,13 @@ apply to this PR, comment it out or delete it. --> **General** - [ ] Make an issue if one doesn't already exist - [ ] Link the issue this PR resolves by adding `closes #XXX` to the PR description where XXX is the number of the issue. -- [ ] Add a brief summary of changes to `docs/release-notes.rst` +- [ ] Add a brief summary of changes to `docs/release-notes.rst` in a relevant section for the next unreleased release. Possible sections include: Documentation, New Features, Bug Fixes, Internal Changes, Breaking Changes/Deprecated - [ ] Add appropriate labels to this PR - [ ] Make your changes in a forked repository rather than directly in this repo - [ ] Open this PR as a draft if it is not ready for review - [ ] Convert this PR from a draft to a full PR before requesting reviewers -- [ ] Request `@NCAR/geocat` for reviews - [ ] Passes `precommit`. To set up on your local, run `pre-commit install` from the top level of the repository. To manually run pre-commits, use `pre-commit run --all-files` and re-add any changed files before committing again and pushing. +- [ ] If needed, squash and merge PR commits into a single commit to clean up commit history **Functionality** - [ ] Function is in appropriate module file @@ -25,7 +25,7 @@ apply to this PR, comment it out or delete it. --> - [ ] Tests cover all possible logical paths in your function **Documentation** -- [ ] Docstrings have been added to all new functions ([Documentation Standards](https://geocat.ucar.edu/pages/contributing.html#422-documentation)) +- [ ] Docstrings have been added to all new functions ([Documentation Standards](https://geocat-comp.readthedocs.io/en/stable/contrib.html#docstrings)) - [ ] Docstrings have updated with any function changes - [ ] Internal functions have a preceding underscore (`_`) and have been added to `docs/internal_api/index.rst` - [ ] User facing functions have been added to `docs/user_api/index.rst` under their module @@ -41,7 +41,7 @@ apply to this PR, comment it out or delete it. --> Thank you so much for your PR! To help us review your contribution, please consider the following points: -- A development guide is available at https://geocat.ucar.edu/pages/contributing.html. +- A development guide is available at https://geocat-comp.readthedocs.io/en/stable/contrib.html - Fork this repository and open the PR from your fork. Do not directly work on the NCAR/geocat-comp repository. @@ -54,6 +54,11 @@ consider the following points: in detail (Why is this change required? What problem does it solve?) and link to any relevant issues. +- The summary in `docs/release-notes.rst` should be written as " 'Summary of changes' + by `FirstName LastName`_ in (:pr:`PR#`) ". For first time contributors, add your new + name and GitHub link to bottom of `docs/release-notes.rst` as _`FirstName LastName` + :https://github.com/githubUsername + **PR Etiquette Reminders** - This PR should be listed as a draft PR until you are ready to request reviewers diff --git a/.github/workflows/asv-benchmarking.yml b/.github/workflows/asv-benchmarking.yml new file mode 100644 index 000000000..d8ba18414 --- /dev/null +++ b/.github/workflows/asv-benchmarking.yml @@ -0,0 +1,76 @@ +name: ASV Benchmarking + +on: + push: + branches: + - main + workflow_dispatch: + +jobs: + benchmark: + runs-on: ubuntu-latest + env: + CONDA_ENV_FILE: ./build_envs/asv-bench.yml + ASV_DIR: ./benchmarks + + steps: + - name: Checkout geocat-comp + uses: actions/checkout@v4 + with: + repository: NCAR/geocat-comp + fetch-depth: 0 + - name: Checkout geocat-comp-asv + uses: actions/checkout@v4 + with: + repository: NCAR/geocat-comp-asv + persist-credentials: false + fetch-depth: 0 + ref: main + path: geocat-comp-asv + - name: Set environment variables + run: | + echo "TODAY=$(date +'%Y-%m-%d')" >> $GITHUB_ENV + + - name: Set up conda environment + uses: mamba-org/setup-micromamba@v1 + with: + environment-file: ./build_envs/asv-bench.yml + environment-name: asv-bench + cache-environment: true + cache-environment-key: "benchmark-${{runner.os}}-${{runner.arch}}-${{env.TODAY}}" + + - name: Copy existing results + run: | + if [ -d "geocat-comp-asv/results" ]; then + cp -r geocat-comp-asv/results benchmarks/ + fi + + - name: Run benchmarks + shell: bash -l {0} + id: benchmark + run: | + cd benchmarks + asv machine --machine GH-Actions --os ubuntu-latest --arch x64 --cpu "2-core unknown" --ram 7GB + asv run v2023.02.0..main --skip-existing --parallel || true + + - name: Commit and push benchmark results + run: | + if [ -d "geocat-comp-asv/results" ]; then + rm -r geocat-comp-asv/results + fi + cp -r benchmarks/results/ geocat-comp-asv/ + cd geocat-comp-asv + git config --local user.email "anissaz@ucar.edu" + git config --local user.name "anissa111" + git add results + git commit -m "[🤖] Update benchmark results" + + - name: Push to geocat-comp-asv + if: github.ref == 'refs/heads/main' && github.repository == 'NCAR/geocat-comp' + uses: ad-m/github-push-action@master + with: + github_token: ${{ secrets.COMP_ASV_PAT }} + branch: main + force: true + repository: NCAR/geocat-comp-asv + directory: geocat-comp-asv diff --git a/.github/workflows/ci-release.yml b/.github/workflows/ci-release.yml index 24435b291..b0e0cf6ef 100644 --- a/.github/workflows/ci-release.yml +++ b/.github/workflows/ci-release.yml @@ -15,15 +15,15 @@ jobs: strategy: fail-fast: false matrix: - os: [ "ubuntu-latest", "macos-latest"] + os: [ "ubuntu-latest", "macos-latest", "windows-latest" ] python-version: ["3.9", "3.10", "3.11"] steps: - name: Cancel previous runs - uses: styfle/cancel-workflow-action@0.11.0 + uses: styfle/cancel-workflow-action@0.12.0 with: access_token: ${{ github.token }} - name: checkout - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: token: ${{ github.token }} - name: conda_setup diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a4a947853..01f06c988 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,15 +21,15 @@ jobs: strategy: fail-fast: false matrix: - os: [ "ubuntu-latest", "macos-latest"] + os: ["ubuntu-latest", "macos-latest", "windows-latest" ] python-version: ["3.9", "3.10", "3.11"] steps: - name: Cancel previous runs - uses: styfle/cancel-workflow-action@0.11.0 + uses: styfle/cancel-workflow-action@0.12.0 with: access_token: ${{ github.token }} - name: checkout - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: token: ${{ github.token }} - name: conda_setup @@ -43,25 +43,28 @@ jobs: - name: Install geocat-comp run: | - python -m pip install . --no-deps + python -m pip install --no-deps -e . - name: conda list run: | conda list - - name: Run Namespace Tests - run: | - python -m pytest test + - name: Run Tests + run: python -m pytest test -v + --cov=./geocat/comp + --cov-report=xml + --junitxml=pytest.xml - - name: Run Coverage Tests - run: | - python -m pytest test -v --cov=./geocat/comp --cov-report=xml + - name: Upload test results + uses: actions/upload-artifact@v3 + with: + name: Test results for ${{ runner.os }}-${{ matrix.python-version }} + path: pytest.xml - name: Upload code coverage to Codecov uses: codecov/codecov-action@v3.1.4 with: file: ./coverage.xml - flags: unittests env_vars: OS,PYTHON name: codecov-umbrella fail_ci_if_error: false @@ -73,7 +76,7 @@ jobs: shell: bash -l {0} steps: - name: checkout - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: token: ${{ github.token }} - name: conda_setup diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index ff3408824..dc1996fd5 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -10,6 +10,6 @@ jobs: pre-commit: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - uses: actions/setup-python@v4.6.1 + - uses: actions/checkout@v4 + - uses: actions/setup-python@v4.7.1 - uses: pre-commit/action@v3.0.0 diff --git a/.github/workflows/pypi.yaml b/.github/workflows/pypi.yaml index ff82c36ab..ce0f32e59 100644 --- a/.github/workflows/pypi.yaml +++ b/.github/workflows/pypi.yaml @@ -7,9 +7,9 @@ jobs: if: github.repository == 'NCAR/geocat-comp' runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python - uses: actions/setup-python@v4.6.1 + uses: actions/setup-python@v4.7.1 with: python-version: '3.10' - name: Install dependencies @@ -29,9 +29,9 @@ jobs: if: startsWith(github.ref, 'refs/tags') runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python - uses: actions/setup-python@v4.6.1 + uses: actions/setup-python@v4.7.1 with: python-version: '3.10' - name: Install dependencies @@ -47,7 +47,7 @@ jobs: python -m twine check dist/* - name: Publish package to PyPI - uses: pypa/gh-action-pypi-publish@v1.8.6 + uses: pypa/gh-action-pypi-publish@v1.8.10 with: user: __token__ password: ${{ secrets.PYPI_PASSWORD }} diff --git a/.github/workflows/upstream-dev-ci.yml b/.github/workflows/upstream-dev-ci.yml index 43d7a08b5..42dc09b76 100644 --- a/.github/workflows/upstream-dev-ci.yml +++ b/.github/workflows/upstream-dev-ci.yml @@ -14,11 +14,11 @@ jobs: steps: - name: Cancel previous runs - uses: styfle/cancel-workflow-action@0.11.0 + uses: styfle/cancel-workflow-action@0.12.0 with: access_token: ${{ github.token }} - name: checkout - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: token: ${{ github.token }} - name: conda_setup diff --git a/.gitignore b/.gitignore index d10ea2958..df02d8add 100644 --- a/.gitignore +++ b/.gitignore @@ -312,3 +312,9 @@ test/dask-worker-space/ .vscode/ generated/ docs/notebook-examples.txt + +# asv environments +.asv +benchmarks/env +benchmarks/results +benchmarks/html diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..53f2bd4b9 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,54 @@ +# Code of Conduct + +## Our Pledge + +We, as contributors, creators, stewards, and maintainers (participants), of GeoCAT-comp pledge to make participation in our software, system or hardware project and community a safe, productive, welcoming and inclusive experience for everyone. All participants are required to abide by this Code of Conduct. This includes respectful treatment of everyone regardless of age, body size, disability, ethnicity, gender identity or expression, level of experience, nationality, political affiliation, veteran status, pregnancy, genetic information, physical appearance, race, religion, or sexual orientation, as well as any other characteristic protected under applicable US federal or state law. + +## Our Standards + +Examples of behaviors that contribute to a positive environment include: + +- All participants are treated with respect and consideration, valuing a diversity of views and opinions +- Be considerate, respectful, and collaborative +- Communicate openly with respect for others, critiquing ideas rather than individuals and gracefully accepting criticism +- Acknowledging the contributions of others +- Avoid personal attacks directed toward other participants +- Be mindful of your surroundings and of your fellow participants +- Alert project administrators if you notice a dangerous situation or someone in distress +- Respect the rules and policies of the project and venue + +Examples of unacceptable behavior include, but are not limited to: + +- Harassment, intimidation, or discrimination in any form +- Physical, verbal, or written abuse by anyone to anyone, including repeated use of pronouns other than those requested +- Unwelcome sexual attention or advances +- Personal attacks directed at other guests, members, participants, etc. +- Publishing others’ private information, such as a physical or electronic address, without explicit permission +- Alarming, intimidating, threatening, or hostile comments or conduct +- Inappropriate use of nudity and/or sexual images +- Threatening or stalking anyone, including a participant +- Other conduct which could reasonably be considered inappropriate in a professional setting + +## Scope + +This Code of Conduct applies to all spaces managed by GeoCAT-comp whether they be physical, online or face-to-face. This includes project code, code repository, associated web pages, documentation, mailing lists, project websites and wiki pages, issue tracker, meetings, telecons, events, project social media accounts, and any other forums created by the project team which the community uses for communication. In addition, violations of this Code of Conduct outside these spaces may affect a person's ability to participate within them. Representation of a project may be further defined and clarified by project maintainers. + +## Community Responsibilities + +Everyone in the community is empowered to respond to people who are showing unacceptable behavior. They can talk to them privately or publicly. Anyone requested to stop unacceptable behavior is expected to comply immediately. If the behavior continues concerns may be brought to the project administrators or to any other party listed in the Reporting section below. + +## Project Administrator Responsibilities + +Project administrators are responsible for clarifying the standards of acceptable behavior and are encouraged to model appropriate behavior and provide support when people in the community point out inappropriate behavior. Project administrator(s) are normally the ones that would be tasked to carry out the actions in the Consequences section below. + +## Reporting + +Instances of unacceptable behavior can be brought to the attention of the project administrator(s) who may take any action as outlined in the Consequences section below. However, making a report to a project administrator is not considered an ‘official report’ to UCAR. + +## Consequences + +Upon receipt of a complaint, the project administrator(s) may take any action deemed necessary and appropriate under the circumstances. Such action can include things such as: removing, editing, or rejecting comments, commits, code, wiki edits, email, issues, and other contributions that are not aligned to this Code of Conduct, or banning temporarily or permanently any contributor for other behaviors that are deemed inappropriate, threatening, offensive, or harmful. Project administrators also have the right to report violations to UCAR HR and/or UCAR’s Office of Diversity, Equity and Inclusion (ODEI), as well as a participant’s home institution and/or law enforcement. In the event an incident is reported to UCAR, UCAR will follow its Harassment Reporting and Complaint Procedure. + +## Attribution + +This Code of Conduct was originally adapted from the Contributor Covenant, version 1.4. We then aligned it with the UCAR Participant Code of Conduct, which also borrows from the American Geophysical Union (AGU) Code of Conduct. The UCAR Participant Code of Conduct applies to both UCAR employees as well as participants in activities run by UCAR. The original version of this for all software projects that have strong management from UCAR or UCAR staff is available on the UCAR website at [https://doi.org/10.5065/6w2c-a132](https://doi.org/10.5065/6w2c-a132). The date that it was adopted by this project was 11 September 2023. When responding to complaints, UCAR HR and ODEI will do so based on the latest published version. Therefore, any project-specific changes should follow the Process for Changes section above. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 3055607d3..c30937f84 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,73 +1 @@ -Please first refer to [GeoCAT Contributor's Guide](https://geocat.ucar.edu/pages/contributing.html) for overall -contribution guidelines (such as detailed description of GeoCAT structure, forking, repository cloning, -branching, etc.). Once you determine that a function should be contributed under this repo, please refer to the -following contribution guidelines: - -# Adding new functions to the Geocat-comp repo - -1. For a new function or family of functions that handle similar computations, create a new Python file in -`$GEOCATCOMP/geocat/comp/`. - -2. For implementation guidelines (such as Xarray and Dask usage), please refer to: - - Previously implemented functionality as examples, - e.g. [polynomial.py](https://github.com/NCAR/geocat-comp/blob/main/geocat/comp/polynomial.py) or others. - - [GeoCAT Contributor's Guide](https://geocat.ucar.edu/pages/contributing.html) for further information. - -3. In any Python script under `$GEOCATCOMP/geocat/comp/`, there may be user API functions, which are -supposed to be included in the `geocat.comp` namespace, and internal API functions, which are used by the -user API functions as helpers, preferably starts with an underscore ("_") in their names, as well as are -not included in the `geocat.comp` namespace. - -4. The user API functions should be imported in `$GEOCATCOMP/geocat/comp/__init__.py` to be included in -the namespace. - -5. For appropriate documentation, each user API and internal API function should be listed in the -`$GEOCATCOMP/docs/user_api/index.rst` and `$GEOCATCOMP/docs/internal_api/index.rst`, respectively. - -# Adding unit tests - -All new computational functions need to include unit testing. For that purpose, please refer to the following -guideline: - -1. Unit tests of each function (or function family of similar purposes) should be implemented as a separate -test file under the `$GEOCATCOMP/test` folder. - -2. The [pytest](https://docs.pytest.org/en/stable/contents.html) testing framework is used as a “runner” for the tests. -For further information about `pytest`, see: [pytest documentation](https://docs.pytest.org/en/stable/contents.html). - - Test scripts themselves are not intended to use `pytest` through implementation. Instead, `pytest` should be used - only for running test scripts as follows: - - `pytest .py` - - - Not using `pytest` for implementation allows the unit tests to be also run by using: - - `python -m unittest .py` - -3. Python’s unit testing framework [unittest](https://docs.python.org/3/library/unittest.html) is used for -implementation of the test scripts. For further information about `unittest`, -see: [unittest documentation](https://docs.python.org/3/library/unittest.html). - -4. Recommended but not mandatory implementation approach is as follows: - - - Common data structures, variables and functions, as well as - expected outputs, which could be used by multiple test methods throughout - the test script, are defined either under a base test class or in the very - beginning of the test script for being used by multiple unit test cases. - - - Only applies to functions that are replicated from NCL: For the sake - of having reference results (i.e. expected output or ground truth for not - all but the most cases), an NCL test script can be written under - `\test\ncl_tests` folder and its output can be used for each testing - scenario. - - - Any group of testing functions dedicated to testing a particular - phenomenon (e.g. a specific edge case, data structure, etc.) is - implemented by a class, which inherits `TestCase` from Python's - `unittest` and likely the base test class implemented for the purpose - mentioned above. - - - Assertions are used for testing various cases such as array comparison. - - - Please see previously implemented test cases for reference of the - recommended testing approach, - e.g. [test_polynomial.py](https://github.com/NCAR/geocat-comp/blob/main/test/test_polynomial.py) +GeoCAT-comp's contributor guidelines [can be found in our online documentation](https://geocat-comp.readthedocs.io/en/stable/contrib.html). diff --git a/README.md b/README.md index b5ce47a5f..d75fc55c7 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -| CI | [![GitHub Workflow Status][github-ci-badge]][github-ci-link] [![GitHub Workflow Status][github-upstream-ci-badge]][github-upstream-ci-link] [![Code Coverage Status][codecov-badge]][codecov-link] | +| CI | [![GitHub Workflow Status][github-ci-badge]][github-ci-link] [![GitHub Workflow Status][github-upstream-ci-badge]][github-upstream-ci-link] [![Code Coverage Status][codecov-badge]][codecov-link] [![asv-badge]][asv-link] | | :----------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | | **Docs** | [![Documentation Status][rtd-badge]][rtd-link] | | **Package** | [![Conda][conda-badge]][conda-link] [![PyPI][pypi-badge]][pypi-link] | @@ -7,18 +7,18 @@ -GeoCAT-comp is both the whole computational component of the [GeoCAT](https://geocat.ucar.edu/) -project and a single Github repository as described here. As the computational component of -[GeoCAT](https://geocat.ucar.edu/), GeoCAT-comp provides implementations of computational functions for operating -on geosciences data. Many of these functions originated in NCL and were translated into Python with the help of GeoCAT-comp; -however, developers are welcome to come up with novel computational functions for geosciences data. +GeoCAT-comp is the computational component of the +[GeoCAT](https://geocat.ucar.edu/) project. GeoCAT-comp provides computational +functions for operating on geosciences data. Many of these functions originated +in NCL and were translated into Python in GeoCAT-comp; however, developers are +welcome to suggest novel computational functions for geosciences data. # Documentation [GeoCAT Homepage](https://geocat.ucar.edu/) -[GeoCAT Contributor's Guide](https://geocat.ucar.edu/pages/contributing.html) +[GeoCAT Contributor's Guide](https://github.com/NCAR/geocat-comp/blob/main/CONTRIBUTING.md) [GeoCAT-comp documentation on Read the Docs](https://geocat-comp.readthedocs.io) @@ -41,6 +41,8 @@ https://geocat-comp.readthedocs.io/en/latest/citation.html) page. [github-upstream-ci-link]: https://github.com/NCAR/geocat-comp/actions/workflows/upstream-dev-ci.yml [codecov-badge]: https://img.shields.io/codecov/c/github/NCAR/geocat-comp.svg?logo=codecov&style=for-the-badge&color=brightgreen [codecov-link]: https://codecov.io/gh/NCAR/geocat-comp/coverage.yml +[asv-badge]: https://img.shields.io/badge/benchmarked%20by-asv-green.svg?style=for-the-badge +[asv-link]: https://ncar.github.io/geocat-comp-asv/ [rtd-badge]: https://img.shields.io/readthedocs/geocat-comp/latest.svg?style=for-the-badge [rtd-link]: https://geocat-comp.readthedocs.io/en/latest/?badge=latest [pypi-badge]: https://img.shields.io/pypi/v/geocat-comp?logo=pypi&style=for-the-badge diff --git a/benchmarks/__init__.py b/benchmarks/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/benchmarks/asv.conf.json b/benchmarks/asv.conf.json new file mode 100644 index 000000000..2980fd801 --- /dev/null +++ b/benchmarks/asv.conf.json @@ -0,0 +1,188 @@ +{ + // The version of the config file format. Do not change, unless + // you know what you are doing. + "version": 1, + + // The name of the project being benchmarked + "project": "geocat-comp", + + // The project's homepage + "project_url": "https://geocat-comp.readthedocs.io", + + // The URL or local path of the source code repository for the + // project being benchmarked + "repo": "..", + + // The Python project's subdirectory in your repo. If missing or + // the empty string, the project is assumed to be located at the root + // of the repository. + // "repo_subdir": "", + + // Customizable commands for building the project. + // See asv.conf.json documentation. + // To build the package using pyproject.toml (PEP518), uncomment the following lines + // "build_command": [ + // "python -m pip install build", + // "python -m build", + // "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}" + // ], + // To build the package using setuptools and a setup.py file, uncomment the following lines + // "build_command": [ + // "python setup.py build", + // "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}" + // ], + + // Customizable commands for installing and uninstalling the project. + // See asv.conf.json documentation. + // "install_command": ["in-dir={env_dir} python -mpip install {wheel_file}"], + // "uninstall_command": ["return-code=any python -mpip uninstall -y {project}"], + + // List of branches to benchmark. If not provided, defaults to "master" + // (for git) or "default" (for mercurial). + "branches": ["main"], // for git + // "branches": ["default"], // for mercurial + + // The DVCS being used. If not set, it will be automatically + // determined from "repo" by looking at the protocol in the URL + // (if remote), or by looking for special directories, such as + // ".git" (if local). + "dvcs": "git", + + // The tool to use to create environments. May be "conda", + // "virtualenv", "mamba" (above 3.8) + // or other value depending on the plugins in use. + // If missing or the empty string, the tool will be automatically + // determined by looking for tools on the PATH environment + // variable. + "environment_type": "conda", + + // timeout in seconds for installing any dependencies in environment + // defaults to 10 min + "install_timeout": 600, + + // the base URL to show a commit for the project. + "show_commit_url": "http://github.com/NCAR/geocat-comp/commit/", + + // The Pythons you'd like to test against. If not provided, defaults + // to the current version of Python used to run `asv`. + "pythons": ["3.10"], + + // The list of conda channel names to be searched for benchmark + // dependency packages in the specified order + "conda_channels": ["conda-forge"], + + // A conda environment file that is used for environment creation. + "conda_environment_file": "../build_envs/asv-bench.yml", + + // The matrix of dependencies to test. Each key of the "req" + // requirements dictionary is the name of a package (in PyPI) and + // the values are version numbers. An empty list or empty string + // indicates to just test against the default (latest) + // version. null indicates that the package is to not be + // installed. If the package to be tested is only available from + // PyPi, and the 'environment_type' is conda, then you can preface + // the package name by 'pip+', and the package will be installed + // via pip (with all the conda available packages installed first, + // followed by the pip installed packages). + // + // The ``@env`` and ``@env_nobuild`` keys contain the matrix of + // environment variables to pass to build and benchmark commands. + // An environment will be created for every combination of the + // cartesian product of the "@env" variables in this matrix. + // Variables in "@env_nobuild" will be passed to every environment + // during the benchmark phase, but will not trigger creation of + // new environments. A value of ``null`` means that the variable + // will not be set for the current combination. + // + "matrix": { + "python": [""], + }, + + // Combinations of libraries/python versions can be excluded/included + // from the set to test. Each entry is a dictionary containing additional + // key-value pairs to include/exclude. + // + // An exclude entry excludes entries where all values match. The + // values are regexps that should match the whole string. + // + // An include entry adds an environment. Only the packages listed + // are installed. The 'python' key is required. The exclude rules + // do not apply to includes. + // + // In addition to package names, the following keys are available: + // + // - python + // Python version, as in the *pythons* variable above. + // - environment_type + // Environment type, as above. + // - sys_platform + // Platform, as in sys.platform. Possible values for the common + // cases: 'linux2', 'win32', 'cygwin', 'darwin'. + // - req + // Required packages + // - env + // Environment variables + // - env_nobuild + // Non-build environment variables + // + // "exclude": [ + // {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows + // {"environment_type": "conda", "req": {"six": null}}, // don't run without six on conda + // {"env": {"ENV_VAR_1": "val2"}}, // skip val2 for ENV_VAR_1 + // ], + // + // "include": [ + // // additional env for python2.7 + // {"python": "2.7", "req": {"numpy": "1.8"}, "env_nobuild": {"FOO": "123"}}, + // // additional env if run on windows+conda + // {"platform": "win32", "environment_type": "conda", "python": "2.7", "req": {"libpython": ""}}, + // ], + + // The directory (relative to the current directory) that benchmarks are + // stored in. If not provided, defaults to "benchmarks" + "benchmark_dir": ".", + + // The directory (relative to the current directory) to cache the Python + // environments in. If not provided, defaults to "env" + // "env_dir": "env", + + // The directory (relative to the current directory) that raw benchmark + // results are stored in. If not provided, defaults to "results". + // "results_dir": "results", + + // The directory (relative to the current directory) that the html tree + // should be written to. If not provided, defaults to "html". + // "html_dir": "html", + + // The number of characters to retain in the commit hashes. + // "hash_length": 8, + + // `asv` will cache results of the recent builds in each + // environment, making them faster to install next time. This is + // the number of builds to keep, per environment. + // "build_cache_size": 2, + + // The commits after which the regression search in `asv publish` + // should start looking for regressions. Dictionary whose keys are + // regexps matching to benchmark names, and values corresponding to + // the commit (exclusive) after which to start looking for + // regressions. The default is to start from the first commit + // with results. If the commit is `null`, regression detection is + // skipped for the matching benchmark. + // + // "regressions_first_commits": { + // "some_benchmark": "352cdf", // Consider regressions only after this commit + // "another_benchmark": null, // Skip regression detection altogether + // }, + + // The thresholds for relative change in results, after which `asv + // publish` starts reporting regressions. Dictionary of the same + // form as in ``regressions_first_commits``, with values + // indicating the thresholds. If multiple entries match, the + // maximum is taken. If no entry matches, the default is 5%. + // + // "regressions_thresholds": { + // "some_benchmark": 0.01, // Threshold of 1% + // "another_benchmark": 0.5, // Threshold of 50% + // }, +} diff --git a/benchmarks/import.py b/benchmarks/import.py new file mode 100644 index 000000000..17dcb1ec5 --- /dev/null +++ b/benchmarks/import.py @@ -0,0 +1,5 @@ +class Import: + """Benchmark importing geocat-comp.""" + + def timeraw_import_geocat_comp(self): + return "import geocat.comp" diff --git a/build_envs/asv-bench.yml b/build_envs/asv-bench.yml new file mode 100644 index 000000000..e0ac53e6b --- /dev/null +++ b/build_envs/asv-bench.yml @@ -0,0 +1,22 @@ +name: asv-bench +channels: + - conda-forge +dependencies: + - python=3.10 + - cf_xarray + - cftime + - cython + - eofs + - metpy + - scipy + - numpy + - netcdf4 + - pint + - setuptools + - setuptools_scm + - xarray + - xskillscore + - pip + - pip: + - asv + - -e ../ diff --git a/build_envs/docs.yml b/build_envs/docs.yml index 888405f81..8c90628ca 100644 --- a/build_envs/docs.yml +++ b/build_envs/docs.yml @@ -6,7 +6,7 @@ dependencies: - pre_commit - geocat-datafiles - geocat-viz - - xarray<=2023.02.0 #pin per issue #381 + - xarray - netcdf4 - pint - ipykernel diff --git a/build_envs/environment.yml b/build_envs/environment.yml index 31ea64a5c..993a47897 100644 --- a/build_envs/environment.yml +++ b/build_envs/environment.yml @@ -10,9 +10,9 @@ dependencies: - eofs - metpy - numba - - numpy<1.24 # 1.24 not yet fully compatible with numba + - numpy - pint - - xarray<=2023.02.0 #pin per issue #381 + - xarray - xskillscore # Packages listed below are for testing - geocat-datafiles diff --git a/build_envs/upstream-dev-environment.yml b/build_envs/upstream-dev-environment.yml index 6aea3e26b..19fee7ce0 100644 --- a/build_envs/upstream-dev-environment.yml +++ b/build_envs/upstream-dev-environment.yml @@ -2,7 +2,6 @@ name: geocat_comp_upstream channels: - conda-forge dependencies: - - python>=3.9 - cftime - eofs - geocat-datafiles # for tests diff --git a/docs/_static/thumbnails/fft.png b/docs/_static/thumbnails/fft.png new file mode 100644 index 000000000..925ff0a39 Binary files /dev/null and b/docs/_static/thumbnails/fft.png differ diff --git a/docs/conf.py b/docs/conf.py index 44b94ac92..4592c0178 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -111,8 +111,8 @@ def __getattr__(cls, name): } # allows us to easily link PRs and issues in the change log extlinks = { - "issue": ("https://github.com/NCAR/geocat-comp/issues/%s", "GH"), - "pr": ("https://github.com/NCAR/geocat-comp/pull/%s", "PR"), + "issue": ("https://github.com/NCAR/geocat-comp/issues/%s", "GH%s"), + "pr": ("https://github.com/NCAR/geocat-comp/pull/%s", "PR%s"), } # napoleon settings diff --git a/docs/contrib.rst b/docs/contrib.rst new file mode 100644 index 000000000..406aa0b8b --- /dev/null +++ b/docs/contrib.rst @@ -0,0 +1,467 @@ +.. _contributing: + +=========================== +Contributing to geocat-comp +=========================== + +************ +Introduction +************ + +Thank you for considering making a contribution to ``geocat-comp``! There are +many ways to contribute to this project, including reporting bugs, requesting +additional or new functionality, improving our documentation, or contributing +your own code and we appreciate all of them. + +If you have any questions, please feel free to reach out to us on `GitHub +Discussions `__. You can also +reach us by email at geocat@ucar.edu. + +************** +Where to start +************** + +Look through our open issues and see if there is anything you would like to take +on! We recommend working with core developers to implement new functionality. We +can help you get started and make sure your code is consistent with the rest of +the project. + +Also check out any beginner-friendly issues we have tagged with `good first +issue `__. + +We do not officially "assign" issues to contributors, but if you are interested +in working on an issue, please comment on the issue to let us know you are +working on it. This will help us avoid duplicate work. + +The code for ``geocat-comp`` is hosted on GitHub. If you do not have one, you +will need to create a `free GitHub account `__. +The `GitHub Quickstart Guide +`__ is a great place to get +started with git and GitHub. + +************** +Reporting bugs +************** + +Something not working as expected? We would love to hear about it! Please report +any bugs you find by opening an issue on GitHub. See our `bug report template +`__ +to get started. + +When reporting a bug, please include as much information as possible. This will +help us reproduce the bug and fix it efficiently. For more information on how to +write a good bug report, see this stackoverflow post on `how to make a good bug +report `__. + +*********************** +Requesting new features +*********************** + +Have an idea for a new feature? Want to know how to do something in Python that +you used to do in NCL? See our `feature request template +`__ +to get started. + +You can also use our `Feature Request Form +`__ to submit a feature request. + + +*********************** +Improving Documentation +*********************** + +We are always looking for ways to improve our documentation. If you find +something that is unclear or confusing, please let us know by opening an issue. +To contribute to our documentation yourself, see the `Documentation`_ section of +this guide. + +***************************** +Development workflow overview +***************************** + +This is a brief overview of the development workflow we use for ``geocat-comp``. +A more detailed description of each step is provided in following sections. + +**Get set up to develop on your local machine** + +#. `Fork and clone the repository`_. +#. `Create a development environment`_. +#. `Create a branch for your changes`_. +#. `Install pre-commit hooks`_. + +**Make your changes** + +#. `Understanding the codebase`_. +#. `Write and run tests`_. +#. :ref:`Generate ` and :ref:`check ` the documentation. + +**Contribute your code** + +#. `Push your changes to your fork`_. +#. `Open a pull request`_. +#. `Address feedback`_. +#. Wait for your pull request to be merged. +#. `Delete your branch`_. + +******************************************* +Get set up to develop on your local machine +******************************************* + +Fork and clone the repository +----------------------------- + +Get started by forking the NCAR/geocat-comp repository on GitHub. To do this, +find the "Fork" button near the top of the page and click it. This will create a +copy of the project under your personal github account. + +Next, clone your forked copy to your local machine. + +.. code-block:: bash + + git clone https://github.com/your-user-name/geocat-comp.git + + +Enter the project folder and set the upstream remote to the NCAR/geocat-comp +repository. This will allow you to keep your fork up to date with the main +repository. + +.. code-block:: bash + + cd geocat-comp git remote add upstream https://github.com/NCAR/geocat-comp.git + +For more information, see the `GitHub quickstart section on forking a repository +`__. + +Create a development environment +-------------------------------- + +To run and test any changes you make in ``geocat-comp``, you will need to create +a development environment. We recommend installing and using `conda +`__ +and/or `mamba +`__. + +Use the following commands to create a new conda environment to develop +``geocat-comp`` in. + +.. code-block:: bash + + # Create a new conda environment + conda create -c conda-forge -n geocat_comp_build python=3.10 + + # Use the environment file to populate the environment with the required dependencies + conda env update -f build_envs/environment.yml + + # Activate your new environment + conda activate geocat_comp_build + + # Install your local copy of geocat-comp in interactive mode + pip install -e . + +To test your new install, open a python session and try importing +``geocat.comp``. You can also try printing the version number, which should be +unique to the latest commit on your fork. + +.. code-block:: python + + >>> import geocat.comp as gc + >>> gc.__version__ + '2023.5.1.dev8+g3f0ee48.d20230605' + +You can follow a similar process to create our documentation environment, +``gc-docs`` from the ``build_envs/docs.yml`` file. + +See the `conda documentation +`__ for more information. + + +Create a branch for your changes +-------------------------------- + +We highly recommend creating a new branch on your fork for each new feature or +bug that you work on. + +To create and check out a new branch, use the following command: + +.. code-block:: bash + + git checkout -b + +You can see a list of all branches in your local repository by running: + +.. code-block:: bash + + git branch + +For more information on branching, check out this `learn git branching +`__ interactive tool. + +Install pre-commit hooks +------------------------ + +``geocat-comp`` uses pre-commit hooks to ensure a standardized base-level code +formatting and style. + +The ``pre-commit`` package is installed by default when using the +``build_envs/environment.yml`` file. To set up the pre-commit hooks, run the +following command from the root of the repository: + +.. code-block:: bash + + pre-commit install + +Now, whenever you commit changes, the pre-commit hooks will run and may make +small modifications to your code. If the pre-commit hooks make any changes, you +will need to re-add the files and commit them again in order to successfully make +the commit. + +To manually run the pre-commit hooks, use the following command: + +.. code-block:: bash + + pre-commit run --all-files + +You can skip the pre-commit hooks by adding the ``--no-verify`` flag to your +commit command like this: + +.. code-block:: bash + + git commit -m "your commit message" --no-verify + +For more information on pre-commit hooks, see the `pre-commit documentation `__. + + +***************** +Make your changes +***************** + +After you're all set up to develop ``geocat-comp``, you can start making your +changes. This section describes where, how, and what to change to add your +contributions to the ``geocat-comp`` codebase. + + +Understanding the codebase +-------------------------- + +The ``geocat-comp`` top-level directory is organized as follows: + +.. code-block:: bash + + geocat-comp + ├── build_envs + ├── docs + ├── geocat + │ └── comp + └── test + + +* The ``build_envs`` directory contains the ``environment.yml`` file used to + create your development environment. It also contains additional environment + files used for testing and building the documentation. + +* The ``docs`` directory contains the ``sphinx`` documentation for + ``geocat-comp``. + +* The ``geocat/comp`` directory, contains the code for the ``geocat.comp`` + package. This is the place to add new functionality. The ``geocat.comp`` code + is organized into modules, each of which is contained in its own file. It is + recommended that you add new functionality to an existing file, though it may + be appropriate to make a new file. + +* The ``test`` directory contains the unit tests for ``geocat-comp``. Each + module in ``geocat.comp`` has a corresponding test module in the ``test`` + directory. + + +When adding new functionality, there are multiple auxiliary files that you may +need to modify to incorporate your code into the package. These include: + +* ``geocat/comp/__init__.py``: This file imports all of the functions intended + for the public API. + +* ``docs/internal_api/index.rst`` and ``docs/user_api/index.rst``: These files + are used to generate the API documentation from docstrings. + +* ``docs/release-notes.rst``: This file documents changes to the codebase that + we add to in the same PR as the code changes. + +* ``tests/test_.py``: This file contains the unit tests for the module + you are adding to. It is highly encouraged to add unit tests for any new + functionality you add to ``geocat-comp``. + + +Write and run tests +------------------- + +``geocat-comp`` uses `pytest `__ for unit tests. Currently, +we have unit tests written in both ``pytest`` and ``unittest``. We are in the +process of converting all of our tests to ``pytest`` and we encourage you to +write new tests using ``pytest``. + +To run the tests locally, use the following command from the root of the +repository: + +.. code-block:: bash + + pytest + +To run a specific test, use the following command: + +.. code-block:: bash + + pytest tests/test_mod.py::test_func + +These tests will also run automatically when you open a pull request using +GitHub Actions and the ``.github/workflows/ci.yml`` file. + +See the `pytest documentation `__ for more information. + + +************* +Documentation +************* + +``geocat-comp`` uses `sphinx `__ and +`ReadTheDocs `__ to build and host the +documentation. + + +Docstrings +---------- + +The most common situation in which you will need to add to the documentation is +through docstrings. + +``geocat-comp`` uses `numpydoc +`__ style docstrings. See +`sphinx's example numpydoc docstring +`__. + +To include your docstring documentation in the API reference, you will need to +add it to either the ``docs/internal_api/index.rst`` or +``docs/user_api/index.rst`` file, depending on whether the function is intended +for internal or external use. + +Editing other documentation files +--------------------------------- + +We welcome changes and improvements to all parts of our documentation (including +this guide)! You can find these files in the ``docs`` directory. + +These files are mainly written in `reStructuredText +`__, +but additional file types such as ``.md`` and ``.ipynb`` are also used. + +Important documentation files to know about include: + +* ``docs/index.rst``: This file is the main page of the documentation. Files + added to ``toctree`` blocks in this file will be included in the documentation + as top-level subpages. + +* ``docs/contrib.rst``: This file is the source for this guide! + +* ``docs/conf.py``: This file contains the configuration for building the documentation. + +* ``docs/examples/*.ipynb``, ``docs/examples.rst``, and ``docs/gallery.yml``: + These files are used to generate the jupyter notebook examples in the + documentation. Notebooks in the ``docs/examples/`` directory are added to the + documentation by adding them to the ``toctree`` in ``docs/examples.rst`` and + linked to their cover picture by adding them to the ``docs/gallery.yml`` + file. + +See the `sphinx documentation `__ for +more information about writing sphinx documentation. + +.. _generate-docs: + +Generate the documentation locally +---------------------------------- + +To generate the documentation locally, follow the steps below. + +#. Create and activate the ``gc-docs`` conda environment using the ``build_envs/docs.yml`` file. +#. Enter the ``docs`` directory. +#. Run ``make html`` or to build the documentation. +#. Open ``docs/_build/html/index.html`` in your browser to view the documentation. + +.. _check-docs: + +Check the documentation +----------------------- + +As well as checking local documentation generation, you should also check the +preview documentation generated as part of a PR. To do this, scroll down to the +"checks" section of the PR and click on the "Details" link next to the +"docs/readthedocs.org:geocat-comp" check. This will take you to the +corresponding build on ReadTheDocs, where you can view the documentation built +from your PR and see any warnings or errors on your build. + +******************** +Contribute your code +******************** + +Once you have prepared your changes and are ready for them to be reviewed by the +GeoCAT team, you can open a pull request. This section describes how to open a +pull request and what to expect after you open it. + +Push your changes to your fork +------------------------------ + +Once you have made your changes locally, you will need to push them to your +branch on your fork on GitHub. To do this, use the following command: + +.. code-block:: bash + + git push + +From here, you can request that your changes be merged into the main repository in the form of a pull request. + +Open a pull request +------------------- + +GitHub has extensive `pull request guides and documentation +`__ that we recommend. This section +describes the basics for our workflow. + +From your branch on your fork, open the "Pull requests" tab and click the "New +pull request" button. Make sure the "base repository" is "NCAR/geocat-comp" and +the "base" branch is set to "main", with the "head repository" and "compare" +branch set to your fork and prepared branch, respectively. + +From this page, you can see a view of the changes you have made in your branch. + +We recommend adding a short, descriptive title to your pull request. The body of +the pull request should autofill with our pull request template, which has it's +own set of directions. Please fill out the relevant sections of the template, +including adding a more detailed description of your changes. + +Once you have filled out the template, click the "Create pull request" button. +This will open your pull request on the ``geocat-comp`` repository. + +If you want to open a pull request but are not ready for it to be reviewed, you +can open the pull request as a draft. This is also a good way to get feedback on +your work that might not be ready to contribute yet. + +Address feedback +---------------- + +After you open your pull request, the GeoCAT team will review it and +may provide feedback like asking for changes or suggesting improvements. You can +address this feedback by making changes to your branch and pushing them to your +fork. The pull request will automatically update with your changes. + +The GeoCAT team appreciates your contributions and the interactive process of +reviewing pull requests, and will do our best to review your pull request in a +timely manner. It is totally normal to have to make several rounds of changes to +your pull request before it is ready to be merged, especially if you are new to +the project. + +Once your pull request is approved by a core maintainer and passes the relevant +checks, it will be merged into the main repository! + + +Delete your branch +------------------ + +We recommend deleting your branch after your pull request is merged. This will +help keep your fork clean and organized, but is not required. diff --git a/docs/examples.rst b/docs/examples.rst index 48a5857a2..470927be1 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -16,3 +16,4 @@ Here's some examples of how to use geocat-comp. examples/calendar_average.ipynb examples/climatology_average.ipynb examples/vimfc.ipynb + examples/fourier_filter.ipynb diff --git a/docs/examples/fourier_filter.ipynb b/docs/examples/fourier_filter.ipynb new file mode 100644 index 000000000..52adc5201 --- /dev/null +++ b/docs/examples/fourier_filter.ipynb @@ -0,0 +1,404 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e3e2395f-3ee2-40cd-8a9b-3b7e8278a1a5", + "metadata": {}, + "source": [ + "# Fourier Filter\n", + "\n", + "In this example we'll demonstrate using geocat-comp's [`fourier_filter`](https://geocat-comp.readthedocs.io/en/stable/user_api/generated/geocat.comp.fourier_filters.fourier_filter.html#geocat.comp.fourier_filters.fourier_filter) function to remove high amplitude frequency components from a dataset to allow for visualization of low amplitude signals." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "231b1d31-96c3-41fa-9e58-fedf9fb02475", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import xarray as xr\n", + "\n", + "import geocat.datafiles as gdf\n", + "from geocat.comp import fourier_filter" + ] + }, + { + "cell_type": "markdown", + "id": "cedc92e1-62f7-499d-84d4-bca30c275024", + "metadata": {}, + "source": [ + "## Read in data\n", + "\n", + "We will get the data from the [`geocat-datafiles`](https://github.com/NCAR/geocat-datafiles) package. This package contains example data used in many of the examples for geocat packages.\n", + "\n", + "Then, we use pandas's [`read_csv`](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html) function to read the data into an xarray [`DataArray`](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.html), then extract just the part we want to graph, the sea surface hight of Point Reyes just outside of San Francisco Bay, measured every 6 minutes." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2141a860-b02e-410e-888f-3dbf5f52ecb1", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = xr.DataArray(pd.read_csv(\n", + " gdf.get(\"ascii_files/CO-OPS_9415020_wl.csv\")))\n", + "xr_data = dataset.loc[:, 'Verified (ft)']\n" + ] + }, + { + "cell_type": "markdown", + "id": "5253309e-e424-49c4-ac77-f6787c6b7603", + "metadata": {}, + "source": [ + "# Set up variables to use later\n", + "\n", + "We should record a few useful values that reflect our dataset, and the elements in our dataset that we will interact with.\n", + "\n", + "In this example we shall record the frequency at which our data is recorded, and the two primary tidal frequencies that we would like to remove from our data.\n", + "\n", + "We are also preemtively calculating the resolution of our dataset's eventual fast fourier transform, using a relatively simple calculation." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "16489a49-15ca-4cd4-aeb7-a20c51609235", + "metadata": {}, + "outputs": [], + "source": [ + "# Set points per hour\n", + "data_freq = 10\n", + "\n", + "# Set tide cycle and frequency resolution\n", + "tide_freq1 = 1 / (1 * 12.4206)\n", + "tide_freq2 = 1 / (2 * 12.4206)\n", + "res = data_freq / (len(xr_data))" + ] + }, + { + "cell_type": "markdown", + "id": "958b4d12-a763-45d8-9b7f-1491cae78029", + "metadata": {}, + "source": [ + "# Determine our bounds\n", + "\n", + "A tidal signal is a natural signal and will thus have some frequency spread away from the \"true\" value due to things like bay resonance, the oceanic M2 tidal resonance, and other less easy to explain sources of signal drift.\n", + "\n", + "So we will set some cutoff bounds above and below the center of the signals we want to remove, so that we catch most of those signal components as well." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "471d95d7-c50c-4173-9b46-34badad0cf80", + "metadata": {}, + "outputs": [], + "source": [ + "# Define cutoff_frequency_low and cutoff_frequency_high based on tide frequency\n", + "cflow1 = tide_freq1 - res * 5\n", + "cfhigh1 = tide_freq1 + res * 5\n", + "cflow2 = tide_freq2 - res * 5\n", + "cfhigh2 = tide_freq2 + res * 5" + ] + }, + { + "cell_type": "markdown", + "id": "639b25fd-416c-4b8a-b34a-b84e90f93a03", + "metadata": {}, + "source": [ + "# Check our bounds\n", + "\n", + "We can plot the FFT of our data, and the bounds we are considering using to remove the tidal signal.\n", + "\n", + "The lower signal bound set are shown in by red '+' symbols, and the higher set by orange '+' markers." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "a9b88c7a-92a0-4891-92f4-65f752ff8365", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate figure with 2 by 1 subplots and set its size (width, height) in inches\n", + "fig, axs = plt.subplots(2, 1, dpi=100, figsize=(8, 4), constrained_layout=True)\n", + "\n", + "# Plot the real set of data utilizing NumPy's Fourier Transform function using both\n", + "# the original data and the fourier_filter applied to the second set of cutoffs\n", + "axs[0].set_title('real')\n", + "axs[0].plot(np.real(np.fft.fft(xr_data)[1:100]))\n", + "axs[0].scatter([cflow1/res,cfhigh1/res],[0,0], color = 'orange', marker='+', s=200)\n", + "axs[0].scatter([cflow2/res,cfhigh2/res],[0,0], color = 'red', marker='+', s=200)\n", + "\n", + "# Plot the imaginary set of data utilizing NumPy's Fourier Transform function using both\n", + "# the original data and the fourier_filter applied to the second set of cutoffs\n", + "axs[1].set_title('imag')\n", + "axs[1].plot(np.imag(np.fft.fft(xr_data)[1:100]))\n", + "axs[1].scatter([cflow1/res,cfhigh1/res],[0,0], color = 'orange', marker='+', s=200)\n", + "axs[1].scatter([cflow2/res,cfhigh2/res],[0,0], color = 'red', marker='+', s=200)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f6586051-2e5c-4473-b656-b17b1ecb0b65", + "metadata": {}, + "source": [ + "# Starting the removal\n", + "\n", + "We start by ploting a punch in of the raw signal, where we can see the interaction of the two tidal frequencies, and how they dominate the data." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "e4e5c9c2-8567-4ccb-98ec-868a0bde2120", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate figure with 1 subplot and set its size (width, height) in inches\n", + "fig, ax = plt.subplots(1, 1, dpi=100, figsize=(8, 4), constrained_layout=True)\n", + "\n", + "# Load signal data and plot it\n", + "no_tide = xr_data\n", + "ax.plot(no_tide) #[2000:3000])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bce195b0-9541-451b-8c6e-d178e7627d31", + "metadata": {}, + "source": [ + "# Remove the first tidal component\n", + "\n", + "Here we use the fourier filter to remove the first tidal component of 1/12.4206 hours.\n", + "\n", + "And we can see that only one high amplitude frequency remains." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "ec3e9429-b7dc-4a6c-82e7-8c5a0f4977a5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate figure with 1 subplot and set its size (width, height) in inches\n", + "fig, ax = plt.subplots(1, 1, dpi=100, figsize=(8, 4), constrained_layout=True)\n", + "\n", + "# Plot filtered signal data using fourier_filter for the first set of cutoffs\n", + "no_tide = fourier_filter(no_tide,\n", + " data_freq,\n", + " cutoff_frequency_low=cflow1,\n", + " cutoff_frequency_high=cfhigh1,\n", + " band_block=True)\n", + "ax.plot(no_tide) #[2000:3000])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "76d1b2fd-825a-4e0a-9ae9-873a272f60de", + "metadata": {}, + "source": [ + "# Remove the second tidal component\n", + "\n", + "Here we use the fourier filter to remove the second tidal component of 1/24.8412 hours.\n", + "\n", + "And we can see that no high amplitude frequency remains, while the sea hight, and other signals from wind, and other enviromental forces remain." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "579da2ee-971d-4540-8931-d71eee9fa541", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate figure with 1 subplot and set its size (width, height) in inches\n", + "fig, ax = plt.subplots(1, 1, dpi=100, figsize=(8, 4), constrained_layout=True)\n", + "\n", + "# Plot filtered signal data using fourier_filter for the second set of cutoffs\n", + "no_tide = fourier_filter(no_tide,\n", + " data_freq,\n", + " cutoff_frequency_low=cflow2,\n", + " cutoff_frequency_high=cfhigh2,\n", + " band_block=True)\n", + "ax.plot(no_tide) #[2000:3000])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "adbbe4e6-0385-4044-8e2b-74e22870fe1e", + "metadata": {}, + "source": [ + "# Plot them all together\n", + "\n", + "We can now check our work by plotting the signals simultaniously, to show that they are all the same data, and that our filter hasn't done anything unexpected or undesired." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "07f3da0d-f242-4715-b475-7059906b326e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Generate figure with 1 subplot and set its size (width, height) in inches\n", + "fig, ax = plt.subplots(1, 1, dpi=100, figsize=(8, 4), constrained_layout=True)\n", + "\n", + "no_tide = xr_data\n", + "ax.plot(no_tide) #[2000:3000])\n", + "\n", + "no_tide = fourier_filter(no_tide,\n", + " data_freq,\n", + " cutoff_frequency_low=cflow1,\n", + " cutoff_frequency_high=cfhigh1,\n", + " band_block=True)\n", + "ax.plot(no_tide) #[2000:3000])\n", + "\n", + "no_tide = fourier_filter(no_tide,\n", + " data_freq,\n", + " cutoff_frequency_low=cflow2,\n", + " cutoff_frequency_high=cfhigh2,\n", + " band_block=True)\n", + "ax.plot(no_tide) #[2000:3000])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "629ece58-23fa-4bd5-b1bf-5ed42ffe2919", + "metadata": {}, + "source": [ + "# Plot the FFT\n", + "\n", + "Here we will plot the FFT of the final result against the FFT of the raw signal, to show that we have successfully removed the tidal signals by looking at the frequency space of the signal." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "e9137f8a-d042-4654-ae47-e5f755c5c2bc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate figure with 2 by 1 subplots and set its size (width, height) in inches\n", + "fig, axs = plt.subplots(2, 1, dpi=100, figsize=(8, 4), constrained_layout=True)\n", + "\n", + "# Plot the real set of data utilizing NumPy's Fourier Transform function using both\n", + "# the original data and the fourier_filter applied to the second set of cutoffs\n", + "axs[0].set_title('real')\n", + "axs[0].plot(np.real(np.fft.fft(xr_data)[1:100]))\n", + "axs[0].plot(np.real(np.fft.fft(no_tide)[1:100]))\n", + "\n", + "# Plot the imaginary set of data utilizing NumPy's Fourier Transform function using both\n", + "# the original data and the fourier_filter applied to the second set of cutoffs\n", + "axs[1].set_title('imag')\n", + "axs[1].plot(np.imag(np.fft.fft(xr_data)[1:100]))\n", + "axs[1].plot(np.imag(np.fft.fft(no_tide)[1:100]))\n", + "\n", + "# Show figure\n", + "plt.show()" + ] + } + ], + "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.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/gallery.yml b/docs/gallery.yml index a9cde76c8..3c8ad8b6f 100644 --- a/docs/gallery.yml +++ b/docs/gallery.yml @@ -9,3 +9,7 @@ - title: Vertically Integrated Moisture Flux Convergence path: examples/vimfc.ipynb thumbnail: _static/thumbnails/vimfc.png + +- title: Fourier Filter + path: examples/fourier_filter.ipynb + thumbnail: _static/thumbnails/fft.png diff --git a/docs/index.rst b/docs/index.rst index 264a41560..f9346eb7a 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -90,7 +90,7 @@ novel computational functions for geosciences data. :caption: For Developers Release Notes - Contributor's Guide + Contributor's Guide Roadmap .. toctree:: diff --git a/docs/installation.rst b/docs/installation.rst index ed2af83c6..dd5ba8a92 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -6,8 +6,8 @@ Installation ============ This installation guide includes only the GeoCAT-comp installation and build instructions. -Please refer to `GeoCAT Contributor's Guide `__ for installation of -the whole GeoCAT project. + +Please refer to the relevant project documentation for how to install other GeoCAT packages. Installing GeoCAT-comp via Conda in a New Environment ----------------------------------------------------- diff --git a/docs/release-notes.rst b/docs/release-notes.rst index 572c23354..8eb343c4e 100644 --- a/docs/release-notes.rst +++ b/docs/release-notes.rst @@ -5,6 +5,91 @@ Release Notes ============= + + +v2023.11.0 (unreleased) +----------------------- +This release ... + +Internal Changes +^^^^^^^^^^^^^^^^ +* Remove unnecessary tag publish trigger for ASV benchmarking CI by `Anissa Zacharias`_ in (:pr:`509`) + +Bug Fixes +^^^^^^^^^ +* Unpin xarray in enviroment builds with changes to interpolation.py (specify dims in xr.DataArray) and climatologies.py (replace loffset with to_offset) by `Cora Schneck`_ in (:pr:`492`) +* Fixes for Windows tests when EOF throws different signs by `Cora Schneck`_ in (:pr:`516`) +* Fix `extlinks` for Sphinx 6 compatibility by `Anissa Zacharias`_ in (:pr:`520`) + +Maintenance +^^^^^^^^^^^ +* Remove no longer needed numpy version pin by `Katelyn FitzGerald`_ in (:pr:`515`) + +Documentation +^^^^^^^^^^^ +* Transferred fourier filter example from Geocat-examples by `Julia Kent`_ in (:pr:`511`) +* Updated documentation links by `Anissa Zacharias`_ in (:pr:`518`) + +v2023.10.1 +---------- +This release includes minor changes to documentation, a full conversion to +pytest from unittest, and is the first release to include automated +benchmarking. + +Maintenance +^^^^^^^^^^^ +* Convert Unittest to Pytest by `Cora Schneck`_ in (:pr:`462`) + +Documentation +^^^^^^^^^^^^^ +* Updated office hours link by `Anissa Zacharias`_ in (:pr:`495`) +* Added benchmark badge to README by `Anissa Zacharias`_ in (:pr:`497`) + +Bug Fixes +^^^^^^^^^ +* Fix Python version in upstream CI by `Philip Chmielowiec`_ in (:pr:`436`) + +Internal Changes +^^^^^^^^^^^^^^^^ +* Add benchmarking to commits to main and tagged releases by `Anissa Zacharias`_ in (:pr:`496`) +* Fix benchmarking workflow failures by `Anissa Zacharias`_ in (:pr:`499`) + + +v2023.10.0 (Oct 3, 2023) +----------------------- +This release adds a code of conduct, minor edits to our contributor's guide, and +sets up some structure for future ASV benchmarking + +Internal Changes +^^^^^^^^^^^^^^^^ +* Sets up ASV for benchmarking by `Anissa Zacharias`_ in (:pr:`474`) + +Documentation +^^^^^^^^^^^^^ +* New Code of Conduct by `Cora Schneck`_ in (:pr:`461`) +* Updated Pull Request Template by `Cora Schneck`_ in (:pr:`455`) +* Fixes for Contributing Geocat-Comp Contributing by `Cora Schneck`_ in (:pr:`476`) + +v2023.09.0 (Sept 8, 2023) +------------------------- +This release adds `custom_seasons` to ``climatology_average`` and adds a new +Contributor's Guide to the documentation. + +New Features +^^^^^^^^^^^^ +* User-defined seasonal boundaries, `custom_seasons`, enabled for + ``climatology_average`` by `Julia Kent`_ in (:pr:`441`) + +Bug Fixes +^^^^^^^^^ +* Fix codecov coverage reporting issue by `Anissa Zacharias`_ in (:pr:`446`) +* Fix xarray inconsistent pinning issue by `Anissa Zacharias`_ in (:pr:`458`) + +Documentation +^^^^^^^^^^^^^ +* New Contributor's Guide by `Anissa Zacharias`_ in (:pr:`450`) + + v2023.06.1 (June 23, 2023) -------------------------- This releases fixes the unintentional limitation of the 2023.06.0 release to python 3.11.0 @@ -223,3 +308,5 @@ Maintenance .. _`Mario Rodriguez`: https://github.com/marodrig .. _`Julia Kent`: https://github.com/jukent .. _`Katelyn FitzGerald`: https://github.com/kafitzgerald +.. _`Cora Schneck`: https://github.com/cyschneck +.. _`Philip Chmielowiec`: https://github.com/philipc2 diff --git a/docs/support.rst b/docs/support.rst index 52fa3b55d..8bcb85917 100644 --- a/docs/support.rst +++ b/docs/support.rst @@ -19,7 +19,7 @@ to request features. Earth System Data Science (ESDS) Office Hours --------------------------------------------- -If you are affiliated with UCAR, you can `schedule an appointment `__ +If you are affiliated with UCAR, you can `schedule an appointment `__ with a member of the ESDS office hours team to get one-on-one support. Be sure to schedule with a GeoCAT team member for GeoCAT specific questions. For more info about NCAR's Earth System Data Science Initiative, check out their `homepage `__. diff --git a/geocat/comp/climatologies.py b/geocat/comp/climatologies.py index f15336df3..7f9e9c1eb 100644 --- a/geocat/comp/climatologies.py +++ b/geocat/comp/climatologies.py @@ -1,8 +1,10 @@ import cf_xarray import cftime import numpy as np +import pandas as pd import typing import xarray as xr +import warnings _FREQUENCIES = {"day", "month", "year", "season"} @@ -11,8 +13,8 @@ def _contains_datetime_like_objects(d_arr): """Check if a variable contains datetime like objects (either np.datetime64, or cftime.datetime)""" return np.issubdtype( - d_arr.dtype, - np.datetime64) or xr.core.common.contains_cftime_datetimes(d_arr) + d_arr.dtype, np.datetime64) or xr.core.common.contains_cftime_datetimes( + d_arr.variable) def _validate_freq(freq): @@ -182,7 +184,7 @@ def climate_anomaly( } if freq not in freq_dict: - raise KeyError( + raise ValueError( f"Received bad period {freq!r}. Expected one of {list(freq_dict.keys())!r}" ) format, frequency = freq_dict[freq] @@ -190,7 +192,10 @@ def climate_anomaly( if freq == 'year': clim = calendar_average(dset, freq, time_dim, keep_attrs) else: - clim = climatology_average(dset, freq, time_dim, keep_attrs) + clim = climatology_average(dset, + freq=freq, + time_dim=time_dim, + keep_attrs=keep_attrs) if freq == 'season': anom = dset.groupby(f"{time_dim}.season") - clim return anom.assign_attrs(attrs) @@ -265,7 +270,7 @@ def month_to_season( raise ValueError( f"The {time_coord_name} axis length must be a multiple of {mod}.") - seasons_pd = { + seasons_dict = { "DJF": ([12, 1, 2], 'QS-DEC'), "JFM": ([1, 2, 3], 'QS-JAN'), "FMA": ([2, 3, 4], 'QS-FEB'), @@ -280,10 +285,10 @@ def month_to_season( "NDJ": ([11, 12, 1], 'QS-NOV'), } try: - (months, quarter) = seasons_pd[season] - except KeyError: - raise KeyError( - f"contributed: month_to_season: bad season: SEASON = {season}. Valid seasons include: {list(seasons_pd.keys())}" + (months, quarter) = seasons_dict[season] + except ValueError: + raise ValueError( + f"contributed: month_to_season: bad season: SEASON = {season}. Valid seasons include: {list(seasons_dict.keys())}" ) # Filter data to only contain the months of interest @@ -298,7 +303,19 @@ def month_to_season( # Group the months into three and take the mean means = data_filter.resample({ time_coord_name: quarter - }, loffset='MS').mean(keep_attrs=keep_attrs) + }).mean(keep_attrs=keep_attrs) + # Set offset for supported array formats + if isinstance(means.indexes[time_coord_name], + xr.coding.cftimeindex.CFTimeIndex): + means[time_coord_name] = means.indexes[ + time_coord_name] + xr.coding.cftime_offsets.to_offset(freq="MS") + elif isinstance(means.indexes[time_coord_name], pd.DatetimeIndex): + means[time_coord_name] = means.indexes[ + time_coord_name] + pd.tseries.frequencies.to_offset(freq="MS") + else: + raise ValueError( + f"unsupported array type - {type(means.indexes[time_coord_name])}. Valid types include: (xr.coding.cftimeindex.CFTimeIndex, pandas.core.indexes.datetimes.DatetimeIndex)" + ) # The line above tries to take the mean for all quarters even if there is not data for some of them # Therefore, we must filter out the NaNs @@ -370,7 +387,7 @@ def calendar_average( } if freq not in freq_dict: - raise KeyError( + raise ValueError( f"Received bad period {freq!r}. Expected one of {list(freq_dict.keys())!r}" ) @@ -430,6 +447,7 @@ def calendar_average( def climatology_average( dset: typing.Union[xr.DataArray, xr.Dataset], freq: str, + custom_seasons: typing.Union[list, str] = None, time_dim: str = None, keep_attrs: bool = None) -> typing.Union[xr.DataArray, xr.Dataset]: """This function calculates long term hourly, daily, monthly, or seasonal @@ -447,7 +465,26 @@ def climatology_average( - `hour`: for hourly averages - `day`: for daily averages - `month`: for monthly averages - - `season`: for meteorological seasonal averages (DJF, MAM, JJA, and SON) + - `season`: for meteorological seasonal averages (default: DJF, JJA, MAM, and SON) + + custom_seasons : list[str], str, optional + The list of 3-months season aliases or a single seaonal alias string. + Analysis is done on the provided seasons. + This parameter will be ignored if the `freq` is not set to `season`. + Accepted alias: + + - `DJF` : for a season of December, January, and February + - `JFM` : for a season of January, February, and March + - `FMA` : for a season of February, March, and April + - `MAM` : for a season of March, April, and May + - `AMJ` : for a season of April, May, ad June + - `MJJ` : for a season of May, June, and July + - `JJA` : for a season of June, July, and August + - `JAS` : for a season of July, August, and September + - `ASO` : for a season of August, September, and October + - `SON` : for a season of September, October, and November + - `OND` : for a season of October, November, and December + - `NDJ` : for a season of November, December, and January time_dim : str, optional Name of the time coordinate for `xarray` objects. Defaults to ``None`` and @@ -488,7 +525,6 @@ def climatology_average( `clmMonTLLL `__, `month_to_season `__ """ - # TODO: add functionality for users to select specific seasons or hours for climatologies freq_dict = { 'hour': ('%m-%d %H', 'H'), 'day': ('%m-%d', 'D'), @@ -496,11 +532,31 @@ def climatology_average( 'season': (None, 'QS-DEC') } + seasons_dict = { + "DJF": [12, 1, 2], + "JFM": [1, 2, 3], + "FMA": [2, 3, 4], + "MAM": [3, 4, 5], + "AMJ": [4, 5, 6], + "MJJ": [5, 6, 7], + "JJA": [6, 7, 8], + "JAS": [7, 8, 9], + "ASO": [8, 9, 10], + "SON": [9, 10, 11], + "OND": [10, 11, 12], + "NDJ": [11, 12, 1], + } + if freq not in freq_dict: - raise KeyError( + raise ValueError( f"Received bad period {freq!r}. Expected one of {list(freq_dict.keys())!r}" ) + if custom_seasons and freq != 'season': + warnings.warn( + "You have specified `custom_seasons` without specifying seasonal climatology. Your `custom_seasons` will be ignored." + ) + # If freq is 'season', key is set to monthly in order to calculate monthly # averages which are then used to calculate seasonal averages key = 'month' if freq == 'season' else freq @@ -518,24 +574,49 @@ def climatology_average( # Retrieve calendar name calendar = _infer_calendar_name(dset[time_dim]) + attrs = {} + if keep_attrs in {True, None}: + attrs = dset.attrs + if freq == 'season': - attrs = {} - if keep_attrs or keep_attrs is None: - attrs = dset.attrs - if xr.infer_freq(dset[time_dim]) != 'MS': + seasons = ['DJF', 'JJA', 'MAM', 'SON'] + if custom_seasons: + seasons = custom_seasons + if isinstance(seasons, str): + seasons = [seasons] + + invalid_seasons = [s for s in seasons if s not in seasons_dict] + if invalid_seasons: + raise ValueError( + f"contributed: climatology_average: bad season(s): {invalid_seasons}. Valid seasons include: {list(seasons_dict.keys())}" + ) + + seasonal_climates = [] + for season in seasons: + + # Grab the months for each season + months = seasons_dict[season] + + # Filter data to only contain the months of interest + dset_filter = dset.sel( + {time_dim: dset[time_dim].dt.month.isin(months)}) + # Calculate monthly average before calculating seasonal climatologies - dset = dset.resample({ + dset_filter = dset_filter.resample({ time_dim: frequency }).mean(keep_attrs=keep_attrs).dropna(time_dim) - # Compute the weights for the months in each season so that the - # seasonal averages account for months being of different lengths - month_length = dset[time_dim].dt.days_in_month.groupby( - f"{time_dim}.season") - weights = month_length / month_length.sum(keep_attrs=keep_attrs) - dset = (dset * weights).groupby(f"{time_dim}.season") - dset = dset.sum(dim=time_dim, keep_attrs=keep_attrs) + # Compute the weights for the months in each season so that the + # seasonal averages account for months being of different lengths + month_length = dset_filter[time_dim].dt.days_in_month + weights = month_length / month_length.sum() + climatology = (dset_filter * weights).sum(dim=time_dim) + + seasonal_climates.append(climatology) + dset = xr.concat(seasonal_climates, dim='season') + dset.coords['season'] = np.array(seasons).astype(object) return dset.assign_attrs(attrs) + else: # Retrieve floor of median year median_yr = np.median(dset[time_dim].dt.year.values) diff --git a/geocat/comp/interpolation.py b/geocat/comp/interpolation.py index 6c4d5dc6f..52dc4aeac 100644 --- a/geocat/comp/interpolation.py +++ b/geocat/comp/interpolation.py @@ -593,9 +593,9 @@ def interp_sigma_to_hybrid(data: xr.DataArray, output = data_stacked[:, :len(hyam)].copy() for idx, (d, s) in enumerate(zip(data_stacked, sigma_stacked)): - output[idx, :] = xr.DataArray( - _vertical_remap(func_interpolate, s.data, sig_coords.data, - d.data)) + output[idx, :] = xr.DataArray(_vertical_remap( + func_interpolate, s.data, sig_coords.data, d.data), + dims=[lev_dim]) # Make output shape same as data shape output = output.unstack().transpose(*data.dims) @@ -603,9 +603,9 @@ def interp_sigma_to_hybrid(data: xr.DataArray, h_coords = sigma output = data[:len(hyam)].copy() - output[:len(hyam)] = xr.DataArray( - _vertical_remap(func_interpolate, sigma.data, sig_coords.data, - data.data)) + output[:len(hyam)] = xr.DataArray(_vertical_remap( + func_interpolate, sigma.data, sig_coords.data, data.data), + dims=[lev_dim]) # Set output dims and coords output = output.rename({lev_dim: 'hlev'}) diff --git a/requirements.txt b/requirements.txt index c56a3d2f9..070f91182 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,6 +9,6 @@ eofs metpy numpy scipy -xarray<=2023.02.0 #pin per issue #381 +xarray xskillscore packaging diff --git a/test/test_climatologies.py b/test/test_climatologies.py index bf40c1b09..4adbc5887 100644 --- a/test/test_climatologies.py +++ b/test/test_climatologies.py @@ -1,10 +1,9 @@ import sys -import unittest import cftime import numpy as np import pandas as pd +import pytest import xarray.testing -from parameterized import parameterized import xarray as xr from geocat.comp import climate_anomaly, month_to_season, calendar_average, climatology_average @@ -75,10 +74,10 @@ def _get_dummy_data(start_date, ##### End Helper Functions ##### -class test_climate_anomaly(unittest.TestCase): +class Test_Climate_Anomaly: daily = _get_dummy_data('2020-01-01', '2021-12-31', 'D', 1, 1) - def test_daily_anomaly(self): + def test_daily_anomaly(self) -> None: expected_anom = np.concatenate([ np.full(59, -183), [0], np.full(306, -182.5), @@ -102,7 +101,7 @@ def test_daily_anomaly(self): anom = climate_anomaly(self.daily, 'day') xarray.testing.assert_allclose(anom, expected_anom) - def test_monthly_anomaly(self): + def test_monthly_anomaly(self) -> None: expected_anom = np.concatenate([ np.arange(-198, -167), np.arange(-193.54386, -165), @@ -146,7 +145,7 @@ def test_monthly_anomaly(self): anom = climate_anomaly(self.daily, 'month') xarray.testing.assert_allclose(anom, expected_anom) - def test_seasonal_anomaly(self): + def test_seasonal_anomaly(self) -> None: expected_anom = np.concatenate([ np.arange(-320.9392265, -261), np.arange(-228, -136), @@ -180,7 +179,7 @@ def test_seasonal_anomaly(self): anom = climate_anomaly(self.daily, 'season') xarray.testing.assert_allclose(anom, expected_anom) - def test_yearly_anomaly(self): + def test_yearly_anomaly(self) -> None: expected_anom = np.concatenate( [np.arange(-182.5, 183), np.arange(-182, 183)]) @@ -201,23 +200,25 @@ def test_yearly_anomaly(self): anom = climate_anomaly(self.daily, 'year') xarray.testing.assert_allclose(anom, expected_anom) - @parameterized.expand([('daily, "month", None', daily, 'month', None), - ('daily, "month", True', daily, 'month', True), - ('daily, "month", False', daily, 'month', False), - ('daily, "season", None', daily, 'season', None), - ('daily, "season", True', daily, 'season', True), - ('daily, "season", False', daily, 'season', False), - ('daily, "year", None', daily, 'year', None), - ('daily, "year", True', daily, 'year', True), - ('daily, "year", False', daily, 'year', False)]) - def test_keep_attrs(self, name, dset, freq, keep_attrs): + @pytest.mark.parametrize( + "name, dset, freq, keep_attrs", + [('daily, "month", None', daily, 'month', None), + ('daily, "month", True', daily, 'month', True), + ('daily, "month", False', daily, 'month', False), + ('daily, "season", None', daily, 'season', None), + ('daily, "season", True', daily, 'season', True), + ('daily, "season", False', daily, 'season', False), + ('daily, "year", None', daily, 'year', None), + ('daily, "year", True', daily, 'year', True), + ('daily, "year", False', daily, 'year', False)]) + def test_keep_attrs(self, name, dset, freq, keep_attrs) -> None: result = climate_anomaly(dset, freq, keep_attrs=keep_attrs) if keep_attrs or keep_attrs == None: assert result.attrs == dset.attrs elif not keep_attrs: assert result.attrs == {} - def test_custom_time_dim(self): + def test_custom_time_dim(self) -> None: time_dim = 'my_time' expected_anom = np.concatenate([ np.arange(-198, -167), @@ -266,7 +267,7 @@ def test_custom_time_dim(self): xr.testing.assert_allclose(anom, expected_anom) -class test_month_to_season(unittest.TestCase): +class Test_Month_to_Season: ds1 = get_fake_dataset(start_month="2000-01", nmonths=12, nlats=1, nlons=1) # Create another dataset for the year 2001. @@ -298,49 +299,58 @@ class test_month_to_season(unittest.TestCase): nlats=10, nlons=10) - @parameterized.expand([('None', None), ('True', True), ('False', False)]) - def test_month_to_season_keep_attrs(self, name, keep_attrs): + @pytest.mark.parametrize("name, keep_attrs", [('None', None), + ('True', True), + ('False', False)]) + def test_month_to_season_keep_attrs(self, name, keep_attrs) -> None: season_ds = month_to_season(self.ds1, 'JFM', keep_attrs=keep_attrs) if keep_attrs or keep_attrs == None: assert season_ds.attrs == self.ds1.attrs elif not keep_attrs: assert season_ds.attrs == {} - @parameterized.expand([('ds1, JFM', ds1, 'JFM', 2.0), - ('ds2, JAA', ds1, 'JJA', 7.0)]) + @pytest.mark.parametrize("name, dset, season, expected", + [('ds1, JFM', ds1, 'JFM', 2.0), + ('ds2, JAA', ds1, 'JJA', 7.0)]) def test_month_to_season_returns_middle_month_value(self, name, dset, - season, expected): + season, + expected) -> None: season_ds = month_to_season(dset, season) np.testing.assert_equal(season_ds["my_var"].data, expected) - def test_month_to_season_bad_season_exception(self): - with self.assertRaises(KeyError): + def test_month_to_season_bad_season_exception(self) -> None: + with pytest.raises(KeyError): month_to_season(self.ds1, "TEST") - def test_month_to_season_partial_years_exception(self): - with self.assertRaises(ValueError): + def test_month_to_season_partial_years_exception(self) -> None: + with pytest.raises(ValueError): month_to_season(self.partial_year_dataset, "JFM") - def test_month_to_season_final_season_returns_2month_average(self): + def test_month_to_season_final_season_returns_2month_average(self) -> None: season_ds = month_to_season(self.ds1, 'NDJ') np.testing.assert_equal(season_ds["my_var"].data, 11.5) - @parameterized.expand([('DJF', 'DJF'), ('JFM', 'JFM'), ('FMA', 'FMA'), - ('MAM', 'MAM'), ('AMJ', 'AMJ'), ('MJJ', 'MJJ'), - ('JJA', 'JJA'), ('JAS', 'JAS'), ('ASO', 'ASO'), - ('SON', 'SON'), ('OND', 'OND'), ('NDJ', 'NDJ')]) - def test_month_to_season_returns_one_point_per_year(self, name, season): + @pytest.mark.parametrize("name, season", [('DJF', 'DJF'), ('JFM', 'JFM'), + ('FMA', 'FMA'), ('MAM', 'MAM'), + ('AMJ', 'AMJ'), ('MJJ', 'MJJ'), + ('JJA', 'JJA'), ('JAS', 'JAS'), + ('ASO', 'ASO'), ('SON', 'SON'), + ('OND', 'OND'), ('NDJ', 'NDJ')]) + def test_month_to_season_returns_one_point_per_year(self, name, + season) -> None: nyears_of_data = self.ds3.sizes["time"] / 12 season_ds = month_to_season(self.ds3, season) assert season_ds["my_var"].size == nyears_of_data - @parameterized.expand([ - ('custom_time_dataset', custom_time_dataset, "my_time", "my_var", 2.0), - ('ds4', ds4.isel(x=110, y=200), None, "Tair", [-10.56, -8.129, -7.125]), - ]) + @pytest.mark.parametrize( + "name, dataset, time_coordinate, var_name, expected", + [('custom_time_dataset', custom_time_dataset, "my_time", "my_var", 2.0), + ('ds4', ds4.isel(x=110, y=200), None, "Tair", [-10.56, -8.129, -7.125]) + ]) def test_month_to_season_custom_time_coordinate(self, name, dataset, time_coordinate, var_name, - expected): + expected) -> None: + season_ds = month_to_season(dataset, "JFM", time_coord_name=time_coordinate) @@ -349,7 +359,7 @@ def test_month_to_season_custom_time_coordinate(self, name, dataset, decimal=1) -class test_calendar_average(unittest.TestCase): +class Test_Calendar_Average(): minute = _get_dummy_data('2020-01-01', '2021-12-31 23:30:00', '30min', 1, 1) hourly = _get_dummy_data('2020-01-01', '2021-12-31 23:00:00', 'H', 1, 1) daily = _get_dummy_data('2020-01-01', '2021-12-31', 'D', 1, 1) @@ -526,24 +536,26 @@ class test_calendar_average(unittest.TestCase): 'lon': [-180.0] }) - @parameterized.expand([('daily, "month", None', daily, 'month', None), - ('daily, "month", True', daily, 'month', True), - ('daily, "month", False', daily, 'month', False), - ('monthly, "season", None', monthly, 'season', None), - ('monthly, "season", True', monthly, 'season', True), - ('monthly, "season", False', monthly, 'season', - False), - ('monthly, "year", None', monthly, 'year', None), - ('monthly, "year", True', monthly, 'year', True), - ('monthly, "year", False', monthly, 'year', False)]) - def test_calendar_average_keep_attrs(self, name, dset, freq, keep_attrs): + @pytest.mark.parametrize( + "name, dset, freq, keep_attrs", + [('daily, "month", None', daily, 'month', None), + ('daily, "month", True', daily, 'month', True), + ('daily, "month", False', daily, 'month', False), + ('monthly, "season", None', monthly, 'season', None), + ('monthly, "season", True', monthly, 'season', True), + ('monthly, "season", False', monthly, 'season', False), + ('monthly, "year", None', monthly, 'year', None), + ('monthly, "year", True', monthly, 'year', True), + ('monthly, "year", False', monthly, 'year', False)]) + def test_calendar_average_keep_attrs(self, name, dset, freq, + keep_attrs) -> None: result = calendar_average(dset, freq, keep_attrs=keep_attrs) if keep_attrs or keep_attrs == None: assert result.attrs == dset.attrs elif not keep_attrs: assert result.attrs == {} - def test_30min_to_hourly_calendar_average(self): + def test_30min_to_hourly_calendar_average(self) -> None: hour_avg = np.arange(0.5, 35088.5, 2).reshape((365 + 366) * 24, 1, 1) hour_avg_time = xr.cftime_range('2020-01-01 00:30:00', '2021-12-31 23:30:00', @@ -559,7 +571,7 @@ def test_30min_to_hourly_calendar_average(self): result = calendar_average(self.minute, freq='hour') xr.testing.assert_equal(result, min_2_hour_avg) - def test_hourly_to_daily_calendar_average(self): + def test_hourly_to_daily_calendar_average(self) -> None: day_avg = np.arange(11.5, 17555.5, 24).reshape(366 + 365, 1, 1) day_avg_time = xr.cftime_range('2020-01-01 12:00:00', '2021-12-31 12:00:00', @@ -574,7 +586,7 @@ def test_hourly_to_daily_calendar_average(self): result = calendar_average(self.hourly, freq='day') xr.testing.assert_equal(result, hour_2_day_avg) - def test_daily_to_monthly_calendar_average(self): + def test_daily_to_monthly_calendar_average(self) -> None: month_avg = np.array([ 15, 45, 75, 105.5, 136, 166.5, 197, 228, 258.5, 289, 319.5, 350, 381, 410.5, 440, 470.5, 501, 531.5, 562, 593, 623.5, 654, 684.5, 715 @@ -595,64 +607,67 @@ def test_daily_to_monthly_calendar_average(self): result = calendar_average(self.daily, freq='month') xr.testing.assert_equal(result, day_2_month_avg) - @parameterized.expand([('daily to seasonal', daily, day_2_season_avg), - ('monthly to seasonal', monthly, month_2_season_avg)] - ) + @pytest.mark.parametrize( + "name, dset, expected", + [('daily to seasonal', daily, day_2_season_avg), + ('monthly to seasonal', monthly, month_2_season_avg)]) def test_daily_monthly_to_seasonal_calendar_average(self, name, dset, - expected): + expected) -> None: result = calendar_average(dset, freq='season') xr.testing.assert_allclose(result, expected) - @parameterized.expand([('daily to yearly', daily, day_2_year_avg), - ('monthly to yearly', monthly, month_2_year_avg)]) + @pytest.mark.parametrize("name, dset, expected", + [('daily to yearly', daily, day_2_year_avg), + ('monthly to yearly', monthly, month_2_year_avg)]) def test_daily_monthly_to_yearly_calendar_average(self, name, dset, - expected): + expected) -> None: result = calendar_average(dset, freq='year') xr.testing.assert_allclose(result, expected) - @parameterized.expand([('freq=TEST', 'TEST'), ('freq=None', None)]) - def test_invalid_freq_calendar_average(self, name, freq): - with self.assertRaises(KeyError): + @pytest.mark.parametrize("name, freq", [('freq=TEST', 'TEST'), + ('freq=None', None)]) + def test_invalid_freq_calendar_average(self, name, freq) -> None: + with pytest.raises(ValueError): calendar_average(self.monthly, freq=freq) - def test_custom_time_coord_calendar_average(self): + def test_custom_time_coord_calendar_average(self) -> None: result = calendar_average(self.custom_time, freq='month', time_dim=self.time_dim) xr.testing.assert_allclose(result, self.custom_time_expected) - def test_xr_DataArray_support_calendar_average(self): + def test_xr_DataArray_support_calendar_average(self) -> None: array = self.daily['data'] array_expected = self.day_2_month_avg['data'] result = calendar_average(array, freq='month') xr.testing.assert_equal(result, array_expected) - def test_non_datetime_like_objects_calendar_average(self): + def test_non_datetime_like_objects_calendar_average(self) -> None: dset_encoded = xr.tutorial.open_dataset("air_temperature", decode_cf=False) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): calendar_average(dset_encoded, 'month') - def test_non_uniformly_spaced_data_calendar_average(self): + def test_non_uniformly_spaced_data_calendar_average(self) -> None: time = pd.to_datetime(['2020-01-01', '2020-01-02', '2020-01-04']) non_uniform = xr.Dataset(data_vars={'data': (('time'), np.arange(3))}, coords={'time': time}) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): calendar_average(non_uniform, freq='day') - @parameterized.expand([ - ('julian_calendar', julian_daily, julian_day_2_month_avg), - ('no_leap_calendar', noleap_daily, noleap_day_2_month_avg), - ('all_leap_calendar', all_leap_daily, all_leap_day_2_month_avg), - ('day_360_calendar', day_360_daily, day_360_leap_day_2_month_avg) - ]) + @pytest.mark.parametrize( + "name, dset, expected", + [('julian_calendar', julian_daily, julian_day_2_month_avg), + ('no_leap_calendar', noleap_daily, noleap_day_2_month_avg), + ('all_leap_calendar', all_leap_daily, all_leap_day_2_month_avg), + ('day_360_calendar', day_360_daily, day_360_leap_day_2_month_avg)]) def test_non_standard_calendars_calendar_average(self, name, dset, - expected): + expected) -> None: result = calendar_average(dset, freq='month') xr.testing.assert_equal(result, expected) -class test_climatology_average(unittest.TestCase): +class Test_Climatology_Average(): minute = _get_dummy_data('2020-01-01', '2021-12-31 23:30:00', '30min', 1, 1) hourly = _get_dummy_data('2020-01-01', '2021-12-31 23:00:00', 'H', 1, 1) @@ -711,7 +726,7 @@ class test_climatology_average(unittest.TestCase): day_2_season_clim = xr.Dataset( data_vars={'data': (('season', 'lat', 'lon'), season_clim)}, coords={ - 'season': season_clim_time, + 'season': np.array(season_clim_time).astype(object), 'lat': [-90.0], 'lon': [-180.0] }) @@ -720,7 +735,7 @@ class test_climatology_average(unittest.TestCase): month_2_season_clim = xr.Dataset( data_vars={'data': (('season', 'lat', 'lon'), season_clim)}, coords={ - 'season': season_clim_time, + 'season': np.array(season_clim_time).astype(object), 'lat': [-90.0], 'lon': [-180.0] }) @@ -828,46 +843,67 @@ class test_climatology_average(unittest.TestCase): 'lon': [-180.0] }) - @parameterized.expand([('daily, "month", None', daily, 'month', None), - ('daily, "month", True', daily, 'month', True), - ('daily, "month", False', daily, 'month', False), - ('monthly, "season", None', monthly, 'season', None), - ('monthly, "season", True', monthly, 'season', True), - ('monthly, "season", False', monthly, 'season', - False)]) - def test_climatology_average_keep_attrs(self, name, dset, freq, keep_attrs): - result = climatology_average(dset, freq, keep_attrs=keep_attrs) + @pytest.mark.parametrize( + "name, dset, freq, custom_seasons, keep_attrs", + [('daily, "month", None', daily, 'month', [], None), + ('daily, "month", True', daily, 'month', [], True), + ('daily, "month", False', daily, 'month', [], False), + ('monthly, "season", None', monthly, 'season', [], None), + ('monthly, "season", True', monthly, 'season', [], True), + ('monthly, "season", False', monthly, 'season', [], False), + ('monthly, "season", None', monthly, 'season', + ['DJF', 'MAM', 'JJA', 'SON'], None), + ('monthly, "season", True', monthly, 'season', + ['DJF', 'MAM', 'JJA', 'SON'], True), + ('monthly, "season", False', monthly, 'season', + ['DJF', 'MAM', 'JJA', 'SON'], False)]) + def test_climatology_average_keep_attrs(self, name, dset, freq, + custom_seasons, keep_attrs) -> None: + result = climatology_average(dset, + freq=freq, + custom_seasons=custom_seasons, + keep_attrs=keep_attrs) if keep_attrs or keep_attrs == None: assert result.attrs == dset.attrs elif not keep_attrs: assert result.attrs == {} - def test_30min_to_hourly_climatology_average(self): + def test_30min_to_hourly_climatology_average(self) -> None: result = climatology_average(self.minute, freq='hour') xr.testing.assert_allclose(result, self.min_2_hourly_clim) - def test_hourly_to_daily_climatology_average(self): + def test_hourly_to_daily_climatology_average(self) -> None: result = climatology_average(self.hourly, freq='day') xr.testing.assert_equal(result, self.hour_2_day_clim) - def test_daily_to_monthly_climatology_average(self): + def test_daily_to_monthly_climatology_average(self) -> None: result = climatology_average(self.daily, freq='month') xr.testing.assert_allclose(result, self.day_2_month_clim) - @parameterized.expand([('daily to seasonal', daily, day_2_season_clim), - ('monthly to seasonal', monthly, month_2_season_clim) - ]) + def test_custom_season_climatology_average(self) -> None: + result = climatology_average( + self.monthly, + freq='season', + custom_seasons=['DJF', 'JJA', 'MAM', 'SON']) + expected = climatology_average(self.monthly, freq='season') + xr.testing.assert_equal(result, expected) + + @pytest.mark.parametrize( + "name, dset, expected", + [('daily to seasonal', daily, day_2_season_clim), + ('monthly to seasonal', monthly, month_2_season_clim)]) def test_daily_monthly_to_seasonal_climatology_average( - self, name, dset, expected): + self, name, dset, expected) -> None: result = climatology_average(dset, freq='season') xr.testing.assert_allclose(result, expected) - @parameterized.expand([('freq=TEST', 'TEST'), ('freq=None', None)]) - def test_invalid_freq_climatology_average(self, name, freq): - with self.assertRaises(KeyError): + @pytest.mark.parametrize("name, freq", [('freq=TEST', 'TEST'), + ('freq=None', None)]) + def test_invalid_freq_climatology_average(self, name, freq) -> None: + with pytest.raises(ValueError): climatology_average(self.monthly, freq=freq) - def test_custom_time_coord_climatology_average(self): + def test_custom_time_coord_climatology_average(self) -> None: time_dim = 'my_time' custom_time = self.daily.rename({'time': time_dim}) @@ -878,33 +914,33 @@ def test_custom_time_coord_climatology_average(self): time_dim=time_dim) xr.testing.assert_allclose(result, custom_time_expected) - def test_xr_DataArray_support_climatology_average(self): + def test_xr_DataArray_support_climatology_average(self) -> None: array = self.daily['data'] array_expected = self.day_2_month_clim['data'] result = climatology_average(array, freq='month') xr.testing.assert_allclose(result, array_expected) - def test_non_datetime_like_objects_climatology_average(self): + def test_non_datetime_like_objects_climatology_average(self) -> None: dset_encoded = xr.tutorial.open_dataset("air_temperature", decode_cf=False) - with self.assertRaises(ValueError): - climatology_average(dset_encoded, 'month') + with pytest.raises(ValueError): + climatology_average(dset_encoded, freq='month') - def test_non_uniformly_spaced_data_climatology_average(self): + def test_non_uniformly_spaced_data_climatology_average(self) -> None: time = pd.to_datetime(['2020-01-01', '2020-01-02', '2020-01-04']) non_uniform = xr.Dataset(data_vars={'data': (('time'), np.arange(3))}, coords={'time': time}) - with self.assertRaises(ValueError): + with pytest.raises(ValueError): climatology_average(non_uniform, freq='day') - @parameterized.expand([ - ('julian_calendar', julian_daily, julian_day_2_month_clim), - ('no_leap_calendar', noleap_daily, noleap_day_2_month_clim), - ('all_leap_calendar', all_leap_daily, all_leap_day_2_month_clim), - ('day_360_calendar', day_360_daily, day_360_leap_day_2_month_clim) - ]) + @pytest.mark.parametrize( + "name, dset, expected", + [('julian_calendar', julian_daily, julian_day_2_month_clim), + ('no_leap_calendar', noleap_daily, noleap_day_2_month_clim), + ('all_leap_calendar', all_leap_daily, all_leap_day_2_month_clim), + ('day_360_calendar', day_360_daily, day_360_leap_day_2_month_clim)]) def test_non_standard_calendars_climatology_average(self, name, dset, - expected): + expected) -> None: result = climatology_average(dset, freq='month') xr.testing.assert_allclose(result, expected) diff --git a/test/test_fourier_filters.py b/test/test_fourier_filters.py index e30b29041..4e1d1c3c6 100644 --- a/test/test_fourier_filters.py +++ b/test/test_fourier_filters.py @@ -1,178 +1,191 @@ import math as m import sys - import numpy as np import xarray as xr from geocat.comp import (fourier_band_block, fourier_band_pass, fourier_high_pass, fourier_low_pass) -freq = 1000 -t = np.arange(1000) / freq -t_data = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + - np.sin(20 * t * m.tau) / 2 + np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - - -def test_one_low_pass(): - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau)) - t_result = fourier_low_pass(t_data, freq, 15) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_one_high_pass(): - t_expected_result = (np.sin(20 * t * m.tau) / 2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_result = fourier_high_pass(t_data, freq, 15) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_one_band_pass(): - t_expected_result = (np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + - np.sin(20 * t * m.tau) / 2) - t_result = fourier_band_pass(t_data, freq, 3, 30) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_one_band_block(): - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_result = fourier_band_block(t_data, freq, 3, 30) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -freq = 1000 -t = np.arange(1000) / freq -t = t[:, None] + t -t_data = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + - np.sin(20 * t * m.tau) / 2 + np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - -def test_two_low_pass(): - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau)) - t_result = fourier_low_pass(t_data, freq, 15, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_two_high_pass(): - t_expected_result = (np.sin(20 * t * m.tau) / 2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_result = fourier_high_pass(t_data, freq, 15, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_two_band_pass(): - t_expected_result = (np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + - np.sin(20 * t * m.tau) / 2) - t_result = fourier_band_pass(t_data, freq, 3, 30, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_two_band_block(): - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_result = fourier_band_block(t_data, freq, 3, 30, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -freq = 200 -t = np.arange(200) / freq -t = t[:, None] + t -t = t[:, :, None] + t -t_data = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + - np.sin(20 * t * m.tau) / 2 + np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - - -def test_three_low_pass(): - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau)) - t_result = fourier_low_pass(t_data, freq, 15, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_three_high_pass(): - t_expected_result = (np.sin(20 * t * m.tau) / 2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_result = fourier_high_pass(t_data, freq, 15, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_three_band_pass(): - t_expected_result = (np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + - np.sin(20 * t * m.tau) / 2) - t_result = fourier_band_pass(t_data, freq, 3, 30, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_three_band_block(): - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_result = fourier_band_block(t_data, freq, 3, 30, time_axis=0) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_three_band_block_t1(): - t_data_ = np.swapaxes(t_data, 1, 0) - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_expected_result = np.swapaxes(t_expected_result, 1, 0) - t_result = fourier_band_block(t_data_, freq, 3, 30, time_axis=1) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_three_band_block_t2(): - t_data_ = np.swapaxes(t_data, 2, 0) - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_expected_result = np.swapaxes(t_expected_result, 2, 0) - t_result = fourier_band_block(t_data_, freq, 3, 30, time_axis=2) - np.testing.assert_almost_equal(t_result, t_expected_result) - - -def test_three_band_block_xr(): - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_data_ = xr.DataArray(t_data) - t_expected_result = xr.DataArray(t_expected_result) - t_result = fourier_band_block(t_data_, freq, 3, 30, time_axis=0) - np.testing.assert_almost_equal(t_result.data, t_expected_result) - - -def test_three_band_block_t1_xr(): - t_data_ = np.swapaxes(t_data, 1, 0) - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_expected_result = np.swapaxes(t_expected_result, 1, 0) - t_data_ = xr.DataArray(t_data_) - t_expected_result = xr.DataArray(t_expected_result) - t_result = fourier_band_block(t_data_, freq, 3, 30, time_axis=1) - np.testing.assert_almost_equal(t_result.data, t_expected_result) - - -def test_three_band_block_t2_xr(): - t_data_ = np.swapaxes(t_data, 2, 0) - t_expected_result = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + - np.sin(50 * t * m.tau) / 5 + - np.sin(100 * t * m.tau) / 10) - t_expected_result = np.swapaxes(t_expected_result, 2, 0) - t_data_ = xr.DataArray(t_data_) - t_expected_result = xr.DataArray(t_expected_result) - t_result = fourier_band_block(t_data_, freq, 3, 30, time_axis=2) - np.testing.assert_almost_equal(t_result.data, t_expected_result) +class Test_Fourier_One_Bands_Pass: + + freq = 1000 + t = np.arange(1000) / freq + t_data = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + + np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + + np.sin(20 * t * m.tau) / 2 + np.sin(50 * t * m.tau) / 5 + + np.sin(100 * t * m.tau) / 10) + + def test_one_low_pass(self) -> None: + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(5 * self.t * m.tau) / 0.5 + + np.sin(10 * self.t * m.tau)) + t_result = fourier_low_pass(self.t_data, self.freq, 15) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_one_high_pass(self) -> None: + t_expected_result = (np.sin(20 * self.t * m.tau) / 2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_result = fourier_high_pass(self.t_data, self.freq, 15) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_one_band_pass(self) -> None: + t_expected_result = (np.sin(5 * self.t * m.tau) / 0.5 + + np.sin(10 * self.t * m.tau) + + np.sin(20 * self.t * m.tau) / 2) + t_result = fourier_band_pass(self.t_data, self.freq, 3, 30) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_one_band_block(self) -> None: + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_result = fourier_band_block(self.t_data, self.freq, 3, 30) + np.testing.assert_almost_equal(t_result, t_expected_result) + + +class Test_Fourier_Two_Bands_Pass: + freq = 1000 + t = np.arange(1000) / freq + t = t[:, None] + t + t_data = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + + np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + + np.sin(20 * t * m.tau) / 2 + np.sin(50 * t * m.tau) / 5 + + np.sin(100 * t * m.tau) / 10) + + def test_two_low_pass(self) -> None: + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(5 * self.t * m.tau) / 0.5 + + np.sin(10 * self.t * m.tau)) + t_result = fourier_low_pass(self.t_data, self.freq, 15, time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_two_high_pass(self) -> None: + t_expected_result = (np.sin(20 * self.t * m.tau) / 2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_result = fourier_high_pass(self.t_data, self.freq, 15, time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_two_band_pass(self) -> None: + t_expected_result = (np.sin(5 * self.t * m.tau) / 0.5 + + np.sin(10 * self.t * m.tau) + + np.sin(20 * self.t * m.tau) / 2) + t_result = fourier_band_pass(self.t_data, self.freq, 3, 30, time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_two_band_block(self) -> None: + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_result = fourier_band_block(self.t_data, + self.freq, + 3, + 30, + time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + +class Test_Fourier_Three_Bands_Pass: + + freq = 200 + t = np.arange(200) / freq + t = t[:, None] + t + t = t[:, :, None] + t + t_data = (np.sin(t * m.tau) / 0.1 + np.sin(2 * t * m.tau) / 0.2 + + np.sin(5 * t * m.tau) / 0.5 + np.sin(10 * t * m.tau) + + np.sin(20 * t * m.tau) / 2 + np.sin(50 * t * m.tau) / 5 + + np.sin(100 * t * m.tau) / 10) + + def test_three_low_pass(self) -> None: + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(5 * self.t * m.tau) / 0.5 + + np.sin(10 * self.t * m.tau)) + t_result = fourier_low_pass(self.t_data, self.freq, 15, time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_three_high_pass(self) -> None: + t_expected_result = (np.sin(20 * self.t * m.tau) / 2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_result = fourier_high_pass(self.t_data, self.freq, 15, time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_three_band_pass(self) -> None: + t_expected_result = (np.sin(5 * self.t * m.tau) / 0.5 + + np.sin(10 * self.t * m.tau) + + np.sin(20 * self.t * m.tau) / 2) + t_result = fourier_band_pass(self.t_data, self.freq, 3, 30, time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_three_band_block(self) -> None: + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_result = fourier_band_block(self.t_data, + self.freq, + 3, + 30, + time_axis=0) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_three_band_block_t1(self) -> None: + t_data_ = np.swapaxes(self.t_data, 1, 0) + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_expected_result = np.swapaxes(t_expected_result, 1, 0) + t_result = fourier_band_block(t_data_, self.freq, 3, 30, time_axis=1) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_three_band_block_t2(self) -> None: + t_data_ = np.swapaxes(self.t_data, 2, 0) + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_expected_result = np.swapaxes(t_expected_result, 2, 0) + t_result = fourier_band_block(t_data_, self.freq, 3, 30, time_axis=2) + np.testing.assert_almost_equal(t_result, t_expected_result) + + def test_three_band_block_xr(self) -> None: + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_data_ = xr.DataArray(self.t_data) + t_expected_result = xr.DataArray(t_expected_result) + t_result = fourier_band_block(t_data_, self.freq, 3, 30, time_axis=0) + np.testing.assert_almost_equal(t_result.data, t_expected_result) + + def test_three_band_block_t1_xr(self) -> None: + t_data_ = np.swapaxes(self.t_data, 1, 0) + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_expected_result = np.swapaxes(t_expected_result, 1, 0) + t_data_ = xr.DataArray(t_data_) + t_expected_result = xr.DataArray(t_expected_result) + t_result = fourier_band_block(t_data_, self.freq, 3, 30, time_axis=1) + np.testing.assert_almost_equal(t_result.data, t_expected_result) + + def test_three_band_block_t2_xr(self) -> None: + t_data_ = np.swapaxes(self.t_data, 2, 0) + t_expected_result = (np.sin(self.t * m.tau) / 0.1 + + np.sin(2 * self.t * m.tau) / 0.2 + + np.sin(50 * self.t * m.tau) / 5 + + np.sin(100 * self.t * m.tau) / 10) + t_expected_result = np.swapaxes(t_expected_result, 2, 0) + t_data_ = xr.DataArray(t_data_) + t_expected_result = xr.DataArray(t_expected_result) + t_result = fourier_band_block(t_data_, self.freq, 3, 30, time_axis=2) + np.testing.assert_almost_equal(t_result.data, t_expected_result) diff --git a/test/test_gradient.py b/test/test_gradient.py index 701c5ac5b..3e8cc63a1 100644 --- a/test/test_gradient.py +++ b/test/test_gradient.py @@ -1,5 +1,5 @@ import sys -import unittest +import pytest import numpy as np import xarray as xr @@ -7,185 +7,91 @@ from geocat.comp import gradient -class Test_Gradient(unittest.TestCase): - test_data_xr = None - test_data_np = None - test_data_dask = None - test_results_lon = None - test_results_lat = None - test_coords_1d_lon = None - test_coords_1d_lat = None - test_coords_2d_lon_np = None - test_coords_2d_lat_np = None - test_coords_1d_lat_np = None - test_coords_1d_lon_np = None +class Test_Gradient: - results = None - results_lon = None - results_lat = None - - @classmethod - def setUpClass(cls): - cls.test_data_xr = xr.load_dataset( + @pytest.fixture(scope="class") + def test_data_xr(self): + return xr.load_dataset( 'test/gradient_test_data.nc').to_array().squeeze() - cls.test_data_xr_nocoords = xr.DataArray(cls.test_data_xr, coords={}) - cls.test_data_np = cls.test_data_xr.values - cls.test_data_dask = cls.test_data_xr.chunk(10) - cls.test_results_lon = xr.load_dataset( - 'test/gradient_test_results_longitude.nc').to_array().squeeze() - cls.test_results_lat = xr.load_dataset( - 'test/gradient_test_results_latitude.nc').to_array().squeeze() - cls.test_coords_1d_lon = cls.test_data_xr.coords['lon'] - cls.test_coords_1d_lat = cls.test_data_xr.coords['lat'] - cls.test_coords_2d_lon_np, cls.test_coords_2d_lat_np = np.meshgrid( - cls.test_coords_1d_lon, cls.test_coords_1d_lat) - cls.test_data_xr_2d_coords = xr.DataArray( - cls.test_data_xr, - dims=['x', 'y'], - coords=dict( - lon=(['x', 'y'], cls.test_coords_2d_lon_np), - lat=(['x', 'y'], cls.test_coords_2d_lat_np), - ), - ) - cls.test_coords_1d_lon_np = cls.test_coords_1d_lon.values - cls.test_coords_1d_lat_np = cls.test_coords_1d_lat.values - - def test_gradient_axis0_xr(self): - self.results = gradient(self.test_data_xr) - self.results_axis0 = self.results[0] - np.testing.assert_almost_equal( - self.results_axis0.values, - self.test_results_lon.values, - decimal=3, - ) - - def test_gradient_axis1_xr(self): - self.results = gradient(self.test_data_xr) - self.results_axis1 = self.results[1] - np.testing.assert_almost_equal( - self.results_axis1.values, - self.test_results_lat.values, - decimal=3, - ) - - def test_gradient_axis0_dask(self): - self.results = gradient(self.test_data_dask) - self.results_axis0 = self.results[0] - np.testing.assert_almost_equal( - self.results_axis0.values, - self.test_results_lon.values, - decimal=3, - ) - - def test_gradient_axis1_dask(self): - self.results = gradient(self.test_data_dask) - self.results_axis1 = self.results[1] - np.testing.assert_almost_equal( - self.results_axis1.values, - self.test_results_lat.values, - decimal=3, - ) - - def test_gradient_axis0_xr_1d_nocoords(self): - self.results = gradient(self.test_data_xr_nocoords, - lon=self.test_coords_1d_lon, - lat=self.test_coords_1d_lat) - self.results_axis0 = self.results[0] - np.testing.assert_almost_equal( - self.results_axis0.values, - self.test_results_lon.values, - decimal=3, - ) - - def test_gradient_axis1_xr_1d_nocoords(self): - self.results = gradient(self.test_data_xr_nocoords, - lon=self.test_coords_1d_lon, - lat=self.test_coords_1d_lat) - self.results_axis1 = self.results[1] - np.testing.assert_almost_equal( - self.results_axis1.values, - self.test_results_lat.values, - decimal=3, - ) - - def test_gradient_axis0_xr_2d_nocoords(self): - self.results = gradient(self.test_data_xr_nocoords, - self.test_coords_2d_lon_np, - self.test_coords_2d_lat_np) - self.results_axis0 = self.results[0] - np.testing.assert_almost_equal( - self.results_axis0.values, - self.test_results_lon.values, - decimal=3, - ) - - def test_gradient_axis1_xr_2d_nocoords(self): - self.results = gradient(self.test_data_xr_nocoords, - self.test_coords_2d_lon_np, - self.test_coords_2d_lat_np) - self.results_axis1 = self.results[1] - np.testing.assert_almost_equal( - self.results_axis1.values, - self.test_results_lat.values, - decimal=3, - ) - - def test_gradient_axis0_xr_2d_coords(self): - self.results = gradient(self.test_data_xr_2d_coords) - self.results_axis0 = self.results[0] - np.testing.assert_almost_equal( - self.results_axis0.values, - self.test_results_lon.values, - decimal=3, - ) - def test_gradient_axis1_xr_2d_coords(self): - self.results = gradient(self.test_data_xr_2d_coords) - self.results_axis1 = self.results[1] - np.testing.assert_almost_equal( - self.results_axis1.values, - self.test_results_lat.values, - decimal=3, + @pytest.fixture(scope="class") + def expected_results(self): + return [ + xr.load_dataset( + 'test/gradient_test_results_longitude.nc').to_array().squeeze(), + xr.load_dataset( + 'test/gradient_test_results_latitude.nc').to_array().squeeze() + ] + + @pytest.fixture(scope="class") + def lat_lon_meshgrid(self, test_data_xr): + return np.meshgrid(test_data_xr.coords["lon"], + test_data_xr.coords["lat"]) + + def test_gradient_xr(self, test_data_xr, expected_results) -> None: + actual_result = gradient(test_data_xr) + np.testing.assert_almost_equal(np.array(actual_result), + np.array(expected_results), + decimal=3) + + def test_gradient_dask(self, test_data_xr, expected_results) -> None: + actual_result = gradient(test_data_xr.chunk(10)) + np.testing.assert_almost_equal(np.array(actual_result), + np.array(expected_results), + decimal=3) + + def test_gradient_xr_1d_nocoords(self, test_data_xr, + expected_results) -> None: + actual_result = gradient(xr.DataArray(test_data_xr, coords={}), + lon=test_data_xr.coords["lon"], + lat=test_data_xr.coords["lat"]) + np.testing.assert_almost_equal(np.array(actual_result), + np.array(expected_results), + decimal=3) + + def test_gradient_xr_2d_nocoords(self, test_data_xr, expected_results, + lat_lon_meshgrid) -> None: + (lon_2d, lat_2d) = lat_lon_meshgrid + actual_result = gradient( + xr.DataArray(test_data_xr, coords={}), + lon=lon_2d, + lat=lat_2d, ) - - def test_gradient_axis0_np_1d_nocoords(self): - self.results = gradient(self.test_data_np, - lon=self.test_coords_1d_lon_np, - lat=self.test_coords_1d_lat_np) - self.results_axis0 = self.results[0] - np.testing.assert_almost_equal( - self.results_axis0, - self.test_results_lon.values, - decimal=3, - ) - - def test_gradient_axis1_np_1d_nocoords(self): - self.results = gradient(self.test_data_np, - lon=self.test_coords_1d_lon_np, - lat=self.test_coords_1d_lat_np) - self.results_axis1 = self.results[1] - np.testing.assert_almost_equal( - self.results_axis1, - self.test_results_lat.values, - decimal=3, - ) - - def test_gradient_axis0_np_2d_nocoords(self): - self.results = gradient(self.test_data_np, self.test_coords_2d_lon_np, - self.test_coords_2d_lat_np) - self.results_axis0 = self.results[0] - np.testing.assert_almost_equal( - self.results_axis0, - self.test_results_lon.values, - decimal=3, + np.testing.assert_almost_equal(np.array(actual_result), + np.array(expected_results), + decimal=3) + + def test_gradient_xr_2d_coords(self, test_data_xr, expected_results, + lat_lon_meshgrid) -> None: + test_data_xr_2d_coords = xr.DataArray( + test_data_xr, + dims=["x", "y"], + coords=dict( + lon=(["x", "y"], lat_lon_meshgrid[0]), + lat=(["x", "y"], lat_lon_meshgrid[1]), + ), ) - - def test_gradient_axis1_np_2d_nocoords(self): - self.results = gradient(self.test_data_np, self.test_coords_2d_lon_np, - self.test_coords_2d_lat_np) - self.results_axis1 = self.results[1] - np.testing.assert_almost_equal( - self.results_axis1, - self.test_results_lat.values, - decimal=3, + actual_result = gradient(test_data_xr_2d_coords) + np.testing.assert_almost_equal(np.array(actual_result), + np.array(expected_results), + decimal=3) + + def test_gradient_np_1d_nocoords(self, test_data_xr, + expected_results) -> None: + actual_result = gradient( + test_data_xr.values, + lon=test_data_xr.coords["lon"].values, + lat=test_data_xr.coords["lat"].values, ) + np.testing.assert_almost_equal(actual_result, + np.array(expected_results), + decimal=3) + + def test_gradient_np_2d_nocoords(self, test_data_xr, expected_results, + lat_lon_meshgrid) -> None: + (lon_2d, lat_2d) = lat_lon_meshgrid + actual_result = gradient(test_data_xr.values, lon_2d, lat_2d) + + np.testing.assert_almost_equal(actual_result, + np.array(expected_results), + decimal=3) diff --git a/test/test_interpolation.py b/test/test_interpolation.py index c2db9e02c..279ddb66c 100644 --- a/test/test_interpolation.py +++ b/test/test_interpolation.py @@ -1,11 +1,10 @@ import sys -import unittest -from unittest import TestCase import geocat.datafiles as gdf import numpy as np import numpy.testing as nt import xarray as xr +import pytest from geocat.comp import interp_multidim, interp_hybrid_to_pressure, interp_sigma_to_hybrid @@ -23,27 +22,26 @@ _p0 = 1000. * 100 # Pa -class Test_interp_hybrid_to_pressure(TestCase): +class Test_interp_hybrid_to_pressure: + + # Expected output from above sample input + @pytest.fixture(scope="class") + def ds_out(self): + try: + return xr.open_dataset( + "vinth2p_output.nc" + ) # Generated by running ncl_tests/vinth2p_test_conwomap_5.ncl on + # atmos.nc + except: + return xr.open_dataset("test/vinth2p_output.nc") + # Sample input data data = ds_atmos.U[0, :, :, :] ps = ds_atmos.PS pres3d = np.asarray([1000, 950, 800, 700, 600, 500, 400, 300, 200]) # mb pres3d = pres3d * 100 # mb to Pa - # Expected output from above sample input - - try: - ds_out = xr.open_dataset( - "vinth2p_output.nc" - ) # Generated by running ncl_tests/vinth2p_test_conwomap_5.ncl on - # atmos.nc - except: - ds_out = xr.open_dataset("test/vinth2p_output.nc") - - uzon_expected = ds_out.uzon # Expected output - u_int_expected = ds_out.u_int # Expected output - - def test_interp_hybrid_to_pressure_atmos(self): + def test_interp_hybrid_to_pressure_atmos(self, ds_out) -> None: u_int = interp_hybrid_to_pressure(self.data, self.ps[0, :, :], _hyam, @@ -54,9 +52,9 @@ def test_interp_hybrid_to_pressure_atmos(self): uzon = u_int.mean(dim='lon') - nt.assert_array_almost_equal(self.uzon_expected, uzon, 5) + nt.assert_array_almost_equal(ds_out.uzon, uzon, 5) - def test_interp_hybrid_to_pressure_atmos_4d(self): + def test_interp_hybrid_to_pressure_atmos_4d(self, ds_out) -> None: data_t = self.data.expand_dims("time") u_int = interp_hybrid_to_pressure(data_t, @@ -69,11 +67,11 @@ def test_interp_hybrid_to_pressure_atmos_4d(self): uzon = u_int.mean(dim='lon') - uzon_expected_t = self.uzon_expected.expand_dims("time") + uzon_expected_t = ds_out.uzon.expand_dims("time") nt.assert_array_almost_equal(uzon_expected_t, uzon, 5) - def test_interp_hybrid_to_pressure_atmos_wrong_method(self): - with nt.assert_raises(ValueError): + def test_interp_hybrid_to_pressure_atmos_wrong_method(self) -> None: + with pytest.raises(ValueError): u_int = interp_hybrid_to_pressure(self.data, self.ps[0, :, :], _hyam, @@ -82,7 +80,7 @@ def test_interp_hybrid_to_pressure_atmos_wrong_method(self): new_levels=self.pres3d, method="wrong_method") - def test_interp_hybrid_to_pressure_atmos_dask(self): + def test_interp_hybrid_to_pressure_atmos_dask(self, ds_out) -> None: ps_dask = self.ps.chunk() data_dask = self.data.chunk() @@ -97,392 +95,420 @@ def test_interp_hybrid_to_pressure_atmos_dask(self): uzon = u_int.mean(dim='lon') - nt.assert_array_almost_equal(self.uzon_expected, uzon, 5) - - -class Test_interp_hybrid_to_pressure_extrapolate(TestCase): - # Open the netCDF data file with the input data - try: - ds_ccsm = xr.open_dataset( - gdf.get("netcdf_files/ccsm35.h0.0021-01.demo.nc"), - decode_times=False) - except: - ds_ccsm = xr.open_dataset("test/ccsm35.h0.0021-01.demo.nc", - decode_times=False) - - # Open the netCDF file with the output data from running vinth2p_ecmwf.ncl - try: - ds_out = xr.open_dataset("test/vinth2p_ecmwf_output.nc", - decode_times=False) - except: - ds_out = xr.open_dataset("vinth2p_ecmwf_output.nc", decode_times=False) - - # Pull out inputs - _hyam = ds_ccsm.hyam - _hybm = ds_ccsm.hybm - temp_in = ds_ccsm.T[:, :, 10:15, 20:25] - t_bot = ds_ccsm.TS[:, 10:15, 20:25] - geopotential_in = ds_ccsm.Z3[:, :, 10:15, 20:25] - humidity_in = ds_ccsm.Q[:, :, 10:15, 20:25] * 1000 # g/kg - press_in = ds_ccsm.PS[:, 10:15, 20:25] - phis = ds_ccsm.PHIS[:, 10:15, 20:25] - - temp_interp_expected = ds_out.Tp.rename(lev_p='plev') - temp_extrap_expected = ds_out.Tpx.rename(lev_p='plev') - geopotential_extrap_expected = ds_out.Zpx.rename(lev_p='plev') - humidity_extrap_expected = ds_out.Qpx.rename(lev_p='plev') + nt.assert_array_almost_equal(ds_out.uzon, uzon, 5) + + +class Test_interp_hybrid_to_pressure_extrapolate: + + @pytest.fixture(scope="class") + def ds_ccsm(self): + # Open the netCDF data file with the input data + try: + return xr.open_dataset( + gdf.get("netcdf_files/ccsm35.h0.0021-01.demo.nc"), + decode_times=False) + except: + return xr.open_dataset("test/ccsm35.h0.0021-01.demo.nc", + decode_times=False) + + @pytest.fixture(scope="class") + def ds_out(self): + # Open the netCDF file with the output data from running vinth2p_ecmwf.ncl + try: + return xr.open_dataset("test/vinth2p_ecmwf_output.nc", + decode_times=False) + except: + return xr.open_dataset("vinth2p_ecmwf_output.nc", + decode_times=False) + + @pytest.fixture(scope="class") + def _hyam(self, ds_ccsm): + return ds_ccsm.hyam + + @pytest.fixture(scope="class") + def _hybm(self, ds_ccsm): + return ds_ccsm.hybm + + @pytest.fixture(scope="class") + def temp_in(self, ds_ccsm): + return ds_ccsm.T[:, :, :3, :2] + + @pytest.fixture(scope="class") + def t_bot(self, ds_ccsm): + return ds_ccsm.TS[:, :3, :2] + + @pytest.fixture(scope="class") + def geopotential_in(self, ds_ccsm): + return ds_ccsm.Z3[:, :, :3, :2] + + @pytest.fixture(scope="class") + def humidity_in(self, ds_ccsm): + return ds_ccsm.Q[:, :, :3, :2] * 1000 # g/kg + + @pytest.fixture(scope="class") + def press_in(self, ds_ccsm): + return ds_ccsm.PS[:, :3, :2] + + @pytest.fixture(scope="class") + def phis(self, ds_ccsm): + return ds_ccsm.PHIS[:, :3, :2] new_levels = np.asarray([500, 925, 950, 1000]) new_levels *= 100 # new levels in Pa _p0 = 1000 * 100 # reference pressure in Pa - def test_interp_hybrid_to_pressure_interp_temp(self): - result = interp_hybrid_to_pressure(self.temp_in, - self.press_in, - self._hyam, - self._hybm, + def test_interp_hybrid_to_pressure_interp_temp(self, temp_in, press_in, + _hyam, _hybm, + ds_out) -> None: + result = interp_hybrid_to_pressure(temp_in, + press_in, + _hyam, + _hybm, p0=self._p0, new_levels=self.new_levels, method="linear") result = result.transpose('time', 'plev', 'lat', 'lon') result = result.assign_coords(dict(plev=self.new_levels / 100)) - xr.testing.assert_allclose(self.temp_interp_expected, result) - - def test_interp_hybrid_to_pressure_extrap_temp(self): - result = interp_hybrid_to_pressure(self.temp_in, - self.press_in, - self._hyam, - self._hybm, + temp_interp_expected = ds_out.Tp.rename(lev_p='plev') + xr.testing.assert_allclose(temp_interp_expected, result) + + def test_interp_hybrid_to_pressure_extrap_temp(self, temp_in, press_in, + _hyam, _hybm, t_bot, phis, + ds_out) -> None: + result = interp_hybrid_to_pressure(temp_in, + press_in, + _hyam, + _hybm, p0=self._p0, new_levels=self.new_levels, method="linear", extrapolate=True, variable='temperature', - t_bot=self.t_bot, - phi_sfc=self.phis) + t_bot=t_bot, + phi_sfc=phis) result = result.transpose('time', 'plev', 'lat', 'lon') result = result.assign_coords(dict(plev=self.new_levels / 100)) - xr.testing.assert_allclose(self.temp_extrap_expected, result) - - def test_interp_hybrid_to_pressure_extrap_geopotential(self): - result = interp_hybrid_to_pressure(self.geopotential_in, - self.press_in, - self._hyam, - self._hybm, + temp_extrap_expected = ds_out.Tpx.rename(lev_p='plev') + xr.testing.assert_allclose(temp_extrap_expected, result) + + def test_interp_hybrid_to_pressure_extrap_geopotential( + self, geopotential_in, press_in, _hyam, _hybm, t_bot, phis, + ds_out) -> None: + result = interp_hybrid_to_pressure(geopotential_in, + press_in, + _hyam, + _hybm, p0=self._p0, new_levels=self.new_levels, method="linear", extrapolate=True, variable='geopotential', - t_bot=self.t_bot, - phi_sfc=self.phis) + t_bot=t_bot, + phi_sfc=phis) result = result.transpose('time', 'plev', 'lat', 'lon') result = result.assign_coords(dict(plev=self.new_levels / 100)) - xr.testing.assert_allclose(self.geopotential_extrap_expected, result) - - def test_interp_hybrid_to_pressure_extrap_other(self): - result = interp_hybrid_to_pressure(self.humidity_in, - self.press_in, - self._hyam, - self._hybm, + geopotential_extrap_expected = ds_out.Zpx.rename(lev_p='plev') + xr.testing.assert_allclose(geopotential_extrap_expected, result) + + def test_interp_hybrid_to_pressure_extrap_other(self, humidity_in, press_in, + _hyam, _hybm, t_bot, phis, + ds_out) -> None: + result = interp_hybrid_to_pressure(humidity_in, + press_in, + _hyam, + _hybm, p0=self._p0, new_levels=self.new_levels, method="linear", extrapolate=True, variable='other', - t_bot=self.t_bot, - phi_sfc=self.phis) + t_bot=t_bot, + phi_sfc=phis) result = result.transpose('time', 'plev', 'lat', 'lon') result = result.assign_coords(dict(plev=self.new_levels / 100)) - xr.testing.assert_allclose(self.humidity_extrap_expected, result) - - def test_interp_hybrid_to_pressure_extrap_kwargs(self): - self.assertRaises(ValueError, - interp_hybrid_to_pressure, - self.humidity_in, - self.press_in, - self._hyam, - self._hybm, - p0=self._p0, - new_levels=self.new_levels, - method="linear", - extrapolate=True) - - def test_interp_hybrid_to_pressure_extrap_invalid_var(self): - self.assertRaises(ValueError, - interp_hybrid_to_pressure, - self.humidity_in, - self.press_in, - self._hyam, - self._hybm, - p0=self._p0, - new_levels=self.new_levels, - method="linear", - extrapolate=True, - variable=' ', - t_bot=self.t_bot, - phi_sfc=self.phis) - - -class Test_interp_sigma_to_hybrid(TestCase): + humidity_extrap_expected = ds_out.Qpx.rename(lev_p='plev') + xr.testing.assert_allclose(humidity_extrap_expected, result) + + def test_interp_hybrid_to_pressure_extrap_kwargs(self, humidity_in, + press_in, _hyam, + _hybm) -> None: + with pytest.raises(ValueError): + interp_hybrid_to_pressure(humidity_in, + press_in, + _hyam, + _hybm, + p0=self._p0, + new_levels=self.new_levels, + method="linear", + extrapolate=True) + + def test_interp_hybrid_to_pressure_extrap_invalid_var( + self, humidity_in, press_in, _hyam, _hybm, t_bot, phis) -> None: + with pytest.raises(ValueError): + interp_hybrid_to_pressure(humidity_in, + press_in, + _hyam, + _hybm, + p0=self._p0, + new_levels=self.new_levels, + method="linear", + extrapolate=True, + variable=' ', + t_bot=t_bot, + phi_sfc=phis) + + +class Test_interp_sigma_to_hybrid: + + @pytest.fixture(scope="class") + def ds_u(self): + # Open the netCDF data file "u.89335.1.nc" and read in input data + try: + return xr.open_dataset( + gdf.get("netcdf_files/u.89335.1_subset_time361.nc"), + decode_times=False) + except: + return xr.open_dataset("test/u.89335.1_subset_time361.nc", + decode_times=False) + + @pytest.fixture(scope="class") + def ds_ps(self): + # Open the netCDF data file "ps.89335.1.nc" and read in additional input + # data + try: + return xr.open_dataset(gdf.get("netcdf_files/ps.89335.1.nc"), + decode_times=False) + except: + return xr.open_dataset("test/ps.89335.1.nc", decode_times=False) + + @pytest.fixture(scope="class") + def ds_out(self): + # Expected output from above sample input + try: + return xr.open_dataset( + "sigma2hybrid_output.nc" + ) # Generated by running ncl_tests/test_sigma2hybrid.ncl + except: + return xr.open_dataset("test/sigma2hybrid_output.nc") + hyam = xr.DataArray([0.0108093, 0.0130731, 0.03255911, 0.0639471]) hybm = xr.DataArray([0.0108093, 0.0173664, 0.06069280, 0.1158237]) - # Open the netCDF data file "u.89335.1.nc" and read in input data - try: - ds_u = xr.open_dataset( - gdf.get("netcdf_files/u.89335.1_subset_time361.nc"), - decode_times=False) - except: - ds_u = xr.open_dataset("test/u.89335.1_subset_time361.nc", - decode_times=False) + @pytest.fixture(scope="class") + def u(self, ds_u): + return ds_u.u[:, 0:3, 0:2] - u = ds_u.u[:, 0:3, 0:2] + @pytest.fixture(scope="class") + def ps(self, ds_ps): + return ds_ps.ps[361, 0:3, 0:2] * 100 # Pa - # Open the netCDF data file "ps.89335.1.nc" and read in additional input - # data - try: - ds_ps = xr.open_dataset(gdf.get("netcdf_files/ps.89335.1.nc"), - decode_times=False) - except: - ds_ps = xr.open_dataset("test/ps.89335.1.nc", decode_times=False) + @pytest.fixture(scope="class") + def sigma(self, ds_ps): + return ds_ps.sigma - ps = ds_ps.ps[361, 0:3, 0:2] * 100 # Pa - sigma = ds_ps.sigma + @pytest.fixture(scope="class") + def xh_expected(self, ds_out): + return ds_out.xh.transpose("ncl3", "ncl1", "ncl2") # Expected output - # Expected output from above sample input - try: - ds_out = xr.open_dataset( - "sigma2hybrid_output.nc" - ) # Generated by running ncl_tests/test_sigma2hybrid.ncl - except: - ds_out = xr.open_dataset("test/sigma2hybrid_output.nc") - - xh_expected = ds_out.xh.transpose("ncl3", "ncl1", "ncl2") # Expected output - - def test_interp_sigma_to_hybrid_1d(self): - xh = interp_sigma_to_hybrid(self.u[:, 0, 0], - self.sigma, - self.ps[0, 0], + def test_interp_sigma_to_hybrid_1d(self, u, sigma, ps, xh_expected) -> None: + xh = interp_sigma_to_hybrid(u[:, 0, 0], + sigma, + ps[0, 0], self.hyam, self.hybm, p0=_p0, method="linear") - nt.assert_array_almost_equal(self.xh_expected[:, 0, 0], xh, 5) + nt.assert_array_almost_equal(xh_expected[:, 0, 0], xh, 5) - def test_interp_sigma_to_hybrid_3d(self): - xh = interp_sigma_to_hybrid(self.u, - self.sigma, - self.ps, + def test_interp_sigma_to_hybrid_3d(self, u, sigma, ps, xh_expected) -> None: + xh = interp_sigma_to_hybrid(u, + sigma, + ps, self.hyam, self.hybm, p0=_p0, method="linear") - nt.assert_array_almost_equal(self.xh_expected, xh, 5) + nt.assert_array_almost_equal(xh_expected, xh, 5) - def test_interp_sigma_to_hybrid_3d_transposed(self): - xh = interp_sigma_to_hybrid(self.u.transpose('ycoord', 'sigma', - 'xcoord'), - self.sigma, - self.ps.transpose('ycoord', 'xcoord'), + def test_interp_sigma_to_hybrid_3d_transposed(self, u, sigma, ps, + xh_expected) -> None: + xh = interp_sigma_to_hybrid(u.transpose('ycoord', 'sigma', 'xcoord'), + sigma, + ps.transpose('ycoord', 'xcoord'), self.hyam, self.hybm, p0=_p0, method="linear") nt.assert_array_almost_equal( - self.xh_expected.transpose('ncl2', 'ncl3', 'ncl1'), xh, 5) + xh_expected.transpose('ncl2', 'ncl3', 'ncl1'), xh, 5) - def test_interp_sigma_to_hybrid_3d_dask(self): + def test_interp_sigma_to_hybrid_3d_dask(self, ps, u, sigma, + xh_expected) -> None: - ps_dask = self.ps.chunk() - u_dask = self.u.chunk() + ps_dask = ps.chunk() + u_dask = u.chunk() xh = interp_sigma_to_hybrid(u_dask, - self.sigma, + sigma, ps_dask, self.hyam, self.hybm, p0=_p0, method="linear") - nt.assert_array_almost_equal(self.xh_expected, xh, 5) + nt.assert_array_almost_equal(xh_expected, xh, 5) - def test_interp_sigma_to_hybrid_wrong_method(self): - with nt.assert_raises(ValueError): - xh = interp_sigma_to_hybrid(self.u, - self.sigma, - self.ps, + def test_interp_sigma_to_hybrid_wrong_method(self, u, sigma, ps) -> None: + with pytest.raises(ValueError): + xh = interp_sigma_to_hybrid(u, + sigma, + ps, self.hyam, self.hybm, p0=_p0, method="wrong_method") -class Test_interp_manually_calc(unittest.TestCase): +class Test_interp_manually_calc: - @classmethod - def setUpClass(cls): - cls.test_input = xr.load_dataset( + @pytest.fixture(scope="class") + def test_input(self): + return xr.load_dataset( gdf.get("netcdf_files/interpolation_test_input_data.nc")) - cls.test_output = xr.load_dataset( + @pytest.fixture(scope="class") + def test_output(self): + return xr.load_dataset( gdf.get("netcdf_files/interpolation_test_output_data.nc")) - cls.data_in = cls.test_input['normal'] - cls.data_out = cls.test_output['normal'] - - cls.lat_in = cls.data_in['lat'].values - cls.lat_out = cls.data_out['lat'].values - cls.lon_in = cls.data_in['lon'].values - cls.lon_out = cls.data_out['lon'].values - - cls.data_in_nan = cls.test_input['nan'] - cls.data_out_nan = cls.test_output['nan'] - - cls.data_in_nan_2 = cls.test_input['nan_2'] - cls.data_out_nan_2 = cls.test_output['nan_2'] - - cls.data_in_missing = cls.test_input['missing'] - cls.data_out_missing = cls.test_output['missing'] - - cls.data_in_mask = cls.test_input['mask'] - cls.data_out_mask = cls.test_output['mask'] - - def test_float32(self): + def test_float32(self, test_input, test_output) -> None: np.testing.assert_almost_equal( - self.data_out.values.astype(np.float32), - interp_multidim(xr.DataArray(self.data_in.values.astype(np.float32), - dims=['lat', 'lon'], - coords={ - 'lat': self.lat_in, - 'lon': self.lon_in, - }), - self.lat_out, - self.lon_out, + test_output['normal'].values.astype(np.float32), + interp_multidim(xr.DataArray( + test_input['normal'].values.astype(np.float32), + dims=['lat', 'lon'], + coords={ + 'lat': test_input['normal']['lat'].values, + 'lon': test_input['normal']['lon'].values, + }), + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, cyclic=True).values, decimal=7) - def test_float64(self): + def test_float64(self, test_input, test_output) -> None: np.testing.assert_almost_equal( - self.data_out.values.astype(np.float64), + test_output['normal'].values.astype(np.float64), interp_multidim( - xr.DataArray(self.data_in.values.astype(np.float64), + xr.DataArray(test_input['normal'].values.astype(np.float64), dims=['lat', 'lon'], coords={ - 'lat': self.lat_in, - 'lon': self.lon_in, + 'lat': test_input['normal']['lat'].values, + 'lon': test_input['normal']['lon'].values, }), - self.lat_out, - self.lon_out, + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, cyclic=True, ).values, decimal=8, ) - def test_missing(self): + def test_missing(self, test_input, test_output) -> None: np.testing.assert_almost_equal( - self.data_out_missing, + test_output['missing'], interp_multidim( - self.data_in_missing, - self.lat_out, - self.lon_out, + test_input['missing'], + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, cyclic=True, ).values, decimal=8, ) - def test_nan(self): + def test_nan(self, test_input, test_output) -> None: np.testing.assert_almost_equal( - self.data_out_nan, + test_output['nan'], interp_multidim( - self.data_in_nan, - self.lat_out, - self.lon_out, + test_input['nan'], + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, cyclic=True, ).values, decimal=8, ) - def test_mask(self): + def test_mask(self, test_input, test_output) -> None: np.testing.assert_almost_equal( - self.data_out_mask, + test_output['mask'], interp_multidim( - self.data_in_mask, - self.lat_out, - self.lon_out, + test_input['mask'], + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, cyclic=True, ).values, decimal=8, ) - def test_2_nans(self): + def test_2_nans(self, test_input, test_output) -> None: np.testing.assert_almost_equal( - self.data_out_nan_2, + test_output['nan_2'], interp_multidim( - self.data_in_nan_2, - self.lat_out, - self.lon_out, + test_input['nan_2'], + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, cyclic=True, ).values, decimal=8, ) - def test_numpy(self): - np.testing.assert_almost_equal(self.data_out.values, - interp_multidim( - self.data_in.values, - self.lat_out, - self.lon_out, - lat_in=self.lat_in, - lon_in=self.lon_in, - cyclic=True, - ), - decimal=8) + def test_numpy(self, test_input, test_output) -> None: + np.testing.assert_almost_equal( + test_output['normal'].values, + interp_multidim( + test_input['normal'].values, + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, + lat_in=test_input['normal']['lat'].values, + lon_in=test_input['normal']['lon'].values, + cyclic=True, + ), + decimal=8) - def test_extrapolate(self): - np.testing.assert_almost_equal(self.data_out.values, + def test_extrapolate(self, test_input, test_output) -> None: + np.testing.assert_almost_equal(test_output['normal'].values, interp_multidim( - self.data_in, - self.lat_out, - self.lon_out, + test_input['normal'], + test_output['normal']['lat'].values, + test_output['normal']['lon'].values, cyclic=True, fill_value='extrapolate', ), decimal=8) -class Test_interp_larger_dataset(unittest.TestCase): - test_input = None - test_output = None - test_lat_output = None - test_lon_output = None - test_data_chunked = None +class Test_interp_larger_dataset: - @classmethod - def setUpClass(cls): - cls.test_input = xr.load_dataset( + @pytest.fixture(scope="class") + def test_input(self): + return xr.load_dataset( gdf.get("netcdf_files/spherical_noise_input.nc"))['spherical_noise'] - cls.test_output = xr.load_dataset( - gdf.get( - "netcdf_files/spherical_noise_output.nc"))['spherical_noise'] + @pytest.fixture(scope="class") + def test_output(self): + return xr.load_dataset(gdf.get( + "netcdf_files/spherical_noise_output.nc"))['spherical_noise'] - cls.test_data_chunked = cls.test_input.chunk(2) - - def test_10x(self): - data_xr = interp_multidim(self.test_input, - self.test_output.coords['lat'], - self.test_output.coords['lon']) + def test_10x(self, test_input, test_output) -> None: + data_xr = interp_multidim(test_input, test_output.coords['lat'], + test_output.coords['lon']) np.testing.assert_almost_equal( - self.test_output, + test_output, data_xr.values, decimal=8, ) - def test_chunked(self): - data_xr = interp_multidim(self.test_data_chunked, - self.test_output.coords['lat'], - self.test_output.coords['lon']) + def test_chunked(self, test_input, test_output) -> None: + data_xr = interp_multidim(test_input.chunk(2), + test_output.coords['lat'], + test_output.coords['lon']) - np.testing.assert_almost_equal(self.test_output, - data_xr.values, - decimal=8) + np.testing.assert_almost_equal(test_output, data_xr.values, decimal=8) diff --git a/test/test_meteorology.py b/test/test_meteorology.py index 1c91c66d3..e57e60461 100644 --- a/test/test_meteorology.py +++ b/test/test_meteorology.py @@ -1,5 +1,5 @@ import sys -import unittest +import pytest import dask.array import dask.distributed as dd @@ -16,246 +16,243 @@ saturation_vapor_pressure, saturation_vapor_pressure_slope, delta_pressure) -class Test_dewtemp(unittest.TestCase): +@pytest.fixture(scope="module") +def client() -> None: + # dask client reference for all subsequent tests + client = dd.Client() + yield client + client.close() - @classmethod - def setUpClass(cls): - # set up ground truths - cls.t_def = [ - 29.3, 28.1, 23.5, 20.9, 18.4, 15.9, 13.1, 10.1, 6.7, 3.1, -0.5, - -4.5, -9.0, -14.8, -21.5, -29.7, -40.0, -52.4 - ] - cls.rh_def = [ - 75.0, 60.0, 61.1, 76.7, 90.5, 89.8, 78.3, 76.5, 46.0, 55.0, 63.8, - 53.2, 42.9, 41.7, 51.0, 70.6, 50.0, 50.0 - ] +class Test_dewtemp: - cls.dt_1 = 6.3 + # ground truths + t_def = [ + 29.3, 28.1, 23.5, 20.9, 18.4, 15.9, 13.1, 10.1, 6.7, 3.1, -0.5, -4.5, + -9.0, -14.8, -21.5, -29.7, -40.0, -52.4 + ] - cls.dt_2 = [ - 24.38342, 19.55563, 15.53281, 16.64218, 16.81433, 14.22482, - 9.401337, 6.149719, -4.1604, -5.096619, -6.528168, -12.61957, - -19.38332, -25.00714, -28.9841, -33.34853, -46.51273, -58.18289 - ] + rh_def = [ + 75.0, 60.0, 61.1, 76.7, 90.5, 89.8, 78.3, 76.5, 46.0, 55.0, 63.8, 53.2, + 42.9, 41.7, 51.0, 70.6, 50.0, 50.0 + ] - # make dask client to reference in subsequent tests - cls.client = dd.Client() + dt_1 = 6.3 - def test_float_input(self): - tk = 18. + 273.15 + dt_2 = [ + 24.38342, 19.55563, 15.53281, 16.64218, 16.81433, 14.22482, 9.401337, + 6.149719, -4.1604, -5.096619, -6.528168, -12.61957, -19.38332, + -25.00714, -28.9841, -33.34853, -46.51273, -58.18289 + ] + + def test_float_input(self) -> None: + tk = 18.0 + 273.15 rh = 46.5 assert np.allclose(dewtemp(tk, rh) - 273.15, self.dt_1, 0.1) - def test_list_input(self): + def test_list_input(self) -> None: tk = (np.asarray(self.t_def) + 273.15).tolist() assert np.allclose(dewtemp(tk, self.rh_def) - 273.15, self.dt_2, 0.1) - def test_numpy_input(self): + def test_numpy_input(self) -> None: tk = np.asarray(self.t_def) + 273.15 rh = np.asarray(self.rh_def) assert np.allclose(dewtemp(tk, rh) - 273.15, self.dt_2, 0.1) - def test_xarray_input(self): + def test_xarray_input(self) -> None: tk = xr.DataArray(np.asarray(self.t_def) + 273.15) rh = xr.DataArray(self.rh_def) assert np.allclose(dewtemp(tk, rh) - 273.15, self.dt_2, 0.1) - def test_dims_error(self): - self.assertRaises(ValueError, dewtemp, self.t_def[:10], self.rh_def[:8]) + def test_dims_error(self) -> None: + with pytest.raises(ValueError): + dewtemp(self.t_def[:10], self.rh_def[:8]) - def test_xarray_type_error(self): - self.assertRaises(TypeError, dewtemp, self.t_def, - xr.DataArray(self.rh_def)) + def test_xarray_type_error(self) -> None: + with pytest.raises(TypeError): + dewtemp(self.t_def, xr.DataArray(self.rh_def)) - def test_dask_compute(self): + def test_dask_compute(self) -> None: tk = xr.DataArray(np.asarray(self.t_def) + 273.15).chunk(6) rh = xr.DataArray(self.rh_def).chunk(6) assert np.allclose(dewtemp(tk, rh) - 273.15, self.dt_2, atol=0.1) - def test_dask_lazy(self): + def test_dask_lazy(self) -> None: tk = xr.DataArray(np.asarray(self.t_def) + 273.15).chunk(6) rh = xr.DataArray(self.rh_def).chunk(6) assert isinstance((dewtemp(tk, rh) - 273.15).data, dask.array.Array) -class Test_heat_index(unittest.TestCase): - - @classmethod - def setUpClass(cls): - # set up ground truths - cls.ncl_gt_1 = [ - 137.36142, 135.86795, 104.684456, 131.25621, 105.39449, 79.78999, - 83.57511, 59.965, 30. - ] - cls.ncl_gt_2 = [ - 68.585, 76.13114, 75.12854, 99.43573, 104.93261, 93.73293, - 104.328705, 123.23398, 150.34001, 106.87023 - ] +class Test_heat_index: - cls.t1 = np.array([104, 100, 92, 92, 86, 80, 80, 60, 30]) - cls.rh1 = np.array([55, 65, 60, 90, 90, 40, 75, 90, 50]) + # set up ground truths + ncl_gt_1 = [ + 137.36142, 135.86795, 104.684456, 131.25621, 105.39449, 79.78999, + 83.57511, 59.965, 30. + ] + ncl_gt_2 = [ + 68.585, 76.13114, 75.12854, 99.43573, 104.93261, 93.73293, 104.328705, + 123.23398, 150.34001, 106.87023 + ] - cls.t2 = np.array([70, 75, 80, 85, 90, 95, 100, 105, 110, 115]) - cls.rh2 = np.array([10, 75, 15, 80, 65, 25, 30, 40, 50, 5]) + t1 = np.array([104, 100, 92, 92, 86, 80, 80, 60, 30]) + rh1 = np.array([55, 65, 60, 90, 90, 40, 75, 90, 50]) - # make client to reference in subsequent tests - cls.client = dd.Client() + t2 = np.array([70, 75, 80, 85, 90, 95, 100, 105, 110, 115]) + rh2 = np.array([10, 75, 15, 80, 65, 25, 30, 40, 50, 5]) - def test_numpy_input(self): + def test_numpy_input(self) -> None: assert np.allclose(heat_index(self.t1, self.rh1, False), self.ncl_gt_1, atol=0.005) - def test_multi_dimensional_input(self): + def test_multi_dimensional_input(self) -> None: assert np.allclose(heat_index(self.t2.reshape(2, 5), self.rh2.reshape(2, 5), True), np.asarray(self.ncl_gt_2).reshape(2, 5), atol=0.005) - def test_alt_coef(self): + def test_alt_coef(self) -> None: assert np.allclose(heat_index(self.t2, self.rh2, True), self.ncl_gt_2, atol=0.005) - def test_xarray_alt_coef(self): + def test_xarray_alt_coef(self) -> None: assert np.allclose(heat_index(xr.DataArray(self.t2), xr.DataArray(self.rh2), True), self.ncl_gt_2, atol=0.005) - def test_float_input(self): + def test_float_input(self) -> None: assert np.allclose(heat_index(80, 75), 83.5751, atol=0.005) - def test_list_input(self): + def test_list_input(self) -> None: assert np.allclose(heat_index(self.t1.tolist(), self.rh1.tolist()), self.ncl_gt_1, atol=0.005) - def test_xarray_input(self): + def test_xarray_input(self) -> None: t = xr.DataArray(self.t1) rh = xr.DataArray(self.rh1) assert np.allclose(heat_index(t, rh), self.ncl_gt_1, atol=0.005) - def test_alternate_xarray_tag(self): + def test_alternate_xarray_tag(self) -> None: t = xr.DataArray([15, 20]) rh = xr.DataArray([15, 20]) out = heat_index(t, rh) assert out.tag == "NCL: heat_index_nws; (Steadman+t)*0.5" - def test_rh_warning(self): - self.assertWarns(UserWarning, heat_index, [50, 80, 90], [0.1, 0.2, 0.5]) + def test_rh_warning(self) -> None: + with pytest.warns(UserWarning): + heat_index([50, 80, 90], [0.1, 0.2, 0.5]) - def test_rh_valid(self): - self.assertRaises(ValueError, heat_index, [50, 80, 90], [-1, 101, 50]) + def test_rh_valid(self) -> None: + with pytest.raises(ValueError): + heat_index([50, 80, 90], [-1, 101, 50]) - def test_xarray_rh_warning(self): - self.assertWarns(UserWarning, heat_index, [50, 80, 90], [0.1, 0.2, 0.5]) + def test_xarray_rh_warning(self) -> None: + with pytest.warns(UserWarning): + heat_index([50, 80, 90], [0.1, 0.2, 0.5]) - def test_xarray_rh_valid(self): - self.assertRaises(ValueError, heat_index, xr.DataArray([50, 80, 90]), - xr.DataArray([-1, 101, 50])) + def test_xarray_rh_valid(self) -> None: + with pytest.raises(ValueError): + heat_index(xr.DataArray([50, 80, 90]), xr.DataArray([-1, 101, 50])) - def test_xarray_type_error(self): - self.assertRaises(TypeError, heat_index, self.t1, - xr.DataArray(self.rh1)) + def test_xarray_type_error(self) -> None: + with pytest.raises(TypeError): + heat_index(self.t1, xr.DataArray(self.rh1)) - def test_dims_error(self): - self.assertRaises(ValueError, heat_index, self.t1[:10], self.rh1[:8]) + def test_dims_error(self) -> None: + with pytest.raises(ValueError): + heat_index(self.t1[:10], self.rh1[:8]) - def test_dask_compute(self): + def test_dask_compute(self) -> None: t = xr.DataArray(self.t1).chunk(3) rh = xr.DataArray(self.rh1).chunk(3) assert np.allclose(heat_index(t, rh), self.ncl_gt_1, atol=0.005) - def test_dask_lazy(self): + def test_dask_lazy(self) -> None: t = xr.DataArray(self.t1).chunk(3) rh = xr.DataArray(self.rh1).chunk(3) assert isinstance((heat_index(t, rh)).data, dask.array.Array) -class Test_relhum(unittest.TestCase): - - @classmethod - def setUpClass(cls): - # set up ground truths - cls.p_def = [ - 100800, 100000, 95000, 90000, 85000, 80000, 75000, 70000, 65000, - 60000, 55000, 50000, 45000, 40000, 35000, 30000, 25000, 20000, - 17500, 15000, 12500, 10000, 8000, 7000, 6000, 5000, 4000, 3000, - 2500, 2000 - ] +class Test_relhum: - cls.t_def = [ - 302.45, 301.25, 296.65, 294.05, 291.55, 289.05, 286.25, 283.25, - 279.85, 276.25, 272.65, 268.65, 264.15, 258.35, 251.65, 243.45, - 233.15, 220.75, 213.95, 206.65, 199.05, 194.65, 197.15, 201.55, - 206.45, 211.85, 216.85, 221.45, 222.45, 225.65 - ] + # set up ground truths + p_def = [ + 100800, 100000, 95000, 90000, 85000, 80000, 75000, 70000, 65000, 60000, + 55000, 50000, 45000, 40000, 35000, 30000, 25000, 20000, 17500, 15000, + 12500, 10000, 8000, 7000, 6000, 5000, 4000, 3000, 2500, 2000 + ] - cls.q_def = [ - 0.02038, 0.01903, 0.01614, 0.01371, 0.01156, 0.0098, 0.00833, - 0.00675, 0.00606, 0.00507, 0.00388, 0.00329, 0.00239, 0.0017, 0.001, - 0.0006, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 - ] + t_def = [ + 302.45, 301.25, 296.65, 294.05, 291.55, 289.05, 286.25, 283.25, 279.85, + 276.25, 272.65, 268.65, 264.15, 258.35, 251.65, 243.45, 233.15, 220.75, + 213.95, 206.65, 199.05, 194.65, 197.15, 201.55, 206.45, 211.85, 216.85, + 221.45, 222.45, 225.65 + ] - cls.rh_gt_1 = 46.4 + q_def = [ + 0.02038, 0.01903, 0.01614, 0.01371, 0.01156, 0.0098, 0.00833, 0.00675, + 0.00606, 0.00507, 0.00388, 0.00329, 0.00239, 0.0017, 0.001, 0.0006, + 0.0002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + ] - cls.rh_gt_2 = [ - 79.8228, 79.3578, 84.1962, 79.4898, 73.989, 69.2401, 66.1896, - 61.1084, 64.21, 63.8305, 58.0412, 60.8194, 57.927, 62.3734, 62.9706, - 73.8184, 62.71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 - ] + rh_gt_1 = 46.4 - # make dask client to reference in subsequent tests - cls.client = dd.Client() + rh_gt_2 = [ + 79.8228, 79.3578, 84.1962, 79.4898, 73.989, 69.2401, 66.1896, 61.1084, + 64.21, 63.8305, 58.0412, 60.8194, 57.927, 62.3734, 62.9706, 73.8184, + 62.71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + ] - def test_float_input(self): - p = 1000. * 100 - t = 18. + 273.15 - q = 6. / 1000. + def test_float_input(self) -> None: + p = 1000.0 * 100 + t = 18.0 + 273.15 + q = 6.0 / 1000.0 assert np.allclose(relhum(t, q, p), self.rh_gt_1, atol=0.1) - def test_list_input(self): + def test_list_input(self) -> None: assert np.allclose(relhum(self.t_def, self.q_def, self.p_def), self.rh_gt_2, atol=0.1) - def test_numpy_input(self): + def test_numpy_input(self) -> None: p = np.asarray(self.p_def) t = np.asarray(self.t_def) q = np.asarray(self.q_def) assert np.allclose(relhum(t, q, p), self.rh_gt_2, atol=0.1) - def test_dims_error(self): - self.assertRaises(ValueError, relhum, self.t_def[:10], self.q_def[:10], - self.p_def[:9]) + def test_dims_error(self) -> None: + with pytest.raises(ValueError): + relhum(self.t_def[:10], self.q_def[:10], self.p_def[:9]) - def test_xarray_type_error(self): - self.assertRaises(TypeError, relhum, self.t_def, - xr.DataArray(self.q_def), self.p_def) + def test_xarray_type_error(self) -> None: + with pytest.raises(TypeError): + relhum(self.t_def, xr.DataArray(self.q_def), self.p_def) - def test_dask_compute(self): + def test_dask_compute(self, client) -> None: p = xr.DataArray(self.p_def).chunk(10) t = xr.DataArray(self.t_def).chunk(10) q = xr.DataArray(self.q_def).chunk(10) assert np.allclose(relhum(t, q, p), self.rh_gt_2, atol=0.1) - def test_dask_lazy(self): + def test_dask_lazy(self, client) -> None: p = xr.DataArray(self.p_def).chunk(10) t = xr.DataArray(self.t_def).chunk(10) q = xr.DataArray(self.q_def).chunk(10) @@ -263,95 +260,89 @@ def test_dask_lazy(self): assert isinstance(relhum(t, q, p).data, dask.array.Array) -class Test_relhum_water(unittest.TestCase): +class Test_relhum_water: rh_gt_1 = 46.3574 - def test_float_input(self): - p = 1000. * 100 - t = 18. + 273.15 - q = 6. / 1000. + def test_float_input(self) -> None: + p = 1000.0 * 100 + t = 18.0 + 273.15 + q = 6.0 / 1000.0 assert np.allclose(relhum_water(t, q, p), self.rh_gt_1, atol=0.1) -class Test_relhum_ice(unittest.TestCase): +class Test_relhum_ice: rh_gt_1 = 147.8802 - def test_float_input(self): - tc = -5. + def test_float_input(self) -> None: + tc = -5.0 tk = tc + 273.15 - w = 3.7 / 1000. - p = 1000. * 100. + w = 3.7 / 1000.0 + p = 1000.0 * 100.0 assert np.allclose(relhum_ice(tk, w, p), self.rh_gt_1, atol=0.1) -class Test_actual_saturation_vapor_pressure(unittest.TestCase): +class Test_actual_saturation_vapor_pressure: - @classmethod - def setUpClass(cls): + # set up ground truths + temp_gt = np.arange(1, 101, 1) + @pytest.fixture(scope="class") + def ncl_gt(self): # get ground truth from ncl run netcdf file try: - ncl_xr_gt = xr.open_dataarray( + return xr.open_dataarray( "satvpr_tdew_fao56_output.nc" - ) # Generated by running ncl_tests/test_satvpr_tdew_fao56.ncl + ).values # Generated by running ncl_tests/test_satvpr_tdew_fao56.ncl except: - ncl_xr_gt = xr.open_dataarray("test/satvpr_tdew_fao56_output.nc") - - # set up ground truths - cls.ncl_gt = np.asarray(ncl_xr_gt) - - cls.temp_gt = np.arange(1, 101, 1) + return xr.open_dataarray("test/satvpr_tdew_fao56_output.nc").values - # make client to reference in subsequent tests - cls.client = dd.Client() - - def test_numpy_input(self): + def test_numpy_input(self, ncl_gt) -> None: assert np.allclose(actual_saturation_vapor_pressure( self.temp_gt, tfill=1.0000000e+20), - self.ncl_gt, + ncl_gt, atol=0.005) - def test_float_input(self): + def test_float_input(self) -> None: degf = 59 expected = 1.70535 assert np.allclose(actual_saturation_vapor_pressure(degf), expected, atol=0.005) - def test_list_input(self): + def test_list_input(self, ncl_gt) -> None: assert np.allclose(actual_saturation_vapor_pressure( self.temp_gt.tolist(), tfill=1.0000000e+20), - self.ncl_gt.tolist(), + ncl_gt.tolist(), atol=0.005) - def test_multi_dimensional_input(self): + def test_multi_dimensional_input(self, ncl_gt) -> None: assert np.allclose(actual_saturation_vapor_pressure( self.temp_gt.reshape(2, 50), tfill=1.0000000e+20), - self.ncl_gt.reshape(2, 50), + ncl_gt.reshape(2, 50), atol=0.005) - def test_xarray_input(self): + def test_xarray_input(self, ncl_gt) -> None: tempf = xr.DataArray(self.temp_gt) - expected = xr.DataArray(self.ncl_gt) + expected = xr.DataArray(ncl_gt) assert np.allclose(actual_saturation_vapor_pressure( tempf, tfill=1.0000000e+20), expected, atol=0.005) - def test_dask_compute(self): + def test_dask_compute(self, ncl_gt, client) -> None: tempf = xr.DataArray(self.temp_gt).chunk(10) assert np.allclose(actual_saturation_vapor_pressure( tempf, tfill=1.0000000e+20), - self.ncl_gt, + ncl_gt, atol=0.005) - def test_dask_lazy(self): + def test_dask_lazy(self, client) -> None: tempf = xr.DataArray(self.temp_gt).chunk(10) assert isinstance( @@ -359,207 +350,188 @@ def test_dask_lazy(self): dask.array.Array) -class Test_max_daylight(unittest.TestCase): +class Test_max_daylight: - @classmethod - def setUpClass(cls): + # set up ground truths + jday_gt = np.linspace(1, 365, num=365) + lat_gt = np.linspace(-66, 66, num=133) + @pytest.fixture(scope="class") + def ncl_gt(self): # get ground truth from ncl run netcdf file try: - ncl_xr_gt = xr.open_dataarray( + return xr.open_dataarray( "max_daylight_test.nc" - ) # Generated by running ncl_tests/test_max_daylight.ncl + ).values # Generated by running ncl_tests/test_max_daylight.ncl except: - ncl_xr_gt = xr.open_dataarray("test/max_daylight_test.nc") - - # set up ground truths - cls.ncl_gt = np.asarray(ncl_xr_gt) - - cls.jday_gt = np.linspace(1, 365, num=365) - cls.lat_gt = np.linspace(-66, 66, num=133) + return xr.open_dataarray("test/max_daylight_test.nc").values - # make client to reference in subsequent tests - cls.client = dd.Client() - - def test_numpy_input(self): + def test_numpy_input(self, ncl_gt) -> None: assert np.allclose(max_daylight(self.jday_gt, self.lat_gt), - self.ncl_gt, + ncl_gt, atol=0.005) - def test_float_input(self): + def test_float_input(self) -> None: assert np.allclose(max_daylight(246, -20.0), 11.66559, atol=0.005) - def test_list_input(self): + def test_list_input(self, ncl_gt) -> None: assert np.allclose(max_daylight(self.jday_gt.tolist(), self.lat_gt.tolist()), - self.ncl_gt, + ncl_gt, atol=0.005) - def test_xarray_input(self): + def test_xarray_input(self, ncl_gt) -> None: jday = xr.DataArray(self.jday_gt) lat = xr.DataArray(self.lat_gt) - assert np.allclose(max_daylight(jday, lat), self.ncl_gt, atol=0.005) + assert np.allclose(max_daylight(jday, lat), ncl_gt, atol=0.005) - def test_dask_unchunked_input(self): + def test_dask_unchunked_input(self, ncl_gt, client) -> None: jday = dask.array.from_array(self.jday_gt) lat = dask.array.from_array(self.lat_gt) - out = self.client.submit(max_daylight, jday, lat).result() + out = client.submit(max_daylight, jday, lat).result() - assert np.allclose(out, self.ncl_gt, atol=0.005) + assert np.allclose(out, ncl_gt, atol=0.005) - def test_dask_chunked_input(self): + def test_dask_chunked_input(self, ncl_gt, client) -> None: jday = dask.array.from_array(self.jday_gt, chunks='auto') lat = dask.array.from_array(self.lat_gt, chunks='auto') - out = self.client.submit(max_daylight, jday, lat).result() + out = client.submit(max_daylight, jday, lat).result() - assert np.allclose(out, self.ncl_gt, atol=0.005) + assert np.allclose(out, ncl_gt, atol=0.005) - def test_input_dim(self): - self.assertRaises(ValueError, max_daylight, - np.arange(4).reshape(2, 2), - np.arange(4).reshape(2, 2)) + def test_input_dim(self) -> None: + with pytest.raises(ValueError): + max_daylight(np.arange(4).reshape(2, 2), np.arange(4).reshape(2, 2)) - def test_lat_bound_warning(self): - self.assertWarns(UserWarning, max_daylight, 10, 56) + def test_lat_bound_warning(self) -> None: + with pytest.warns(UserWarning): + max_daylight(10, 56) - def test_lat_bound_second_warning(self): - self.assertWarns(UserWarning, max_daylight, 10, 67) + def test_lat_bound_second_warning(self) -> None: + with pytest.warns(UserWarning): + max_daylight(10, 67) -class Test_psychrometric_constant(unittest.TestCase): +class Test_psychrometric_constant: - @classmethod - def setUpClass(cls): + # set up ground truths + pressure_gt = np.arange(1, 101, 1) + @pytest.fixture(scope="class") + def ncl_gt(self): # get ground truth from ncl run netcdf file try: - ncl_xr_gt = xr.open_dataarray( + return xr.open_dataarray( "psychro_fao56_output.nc" - ) # Generated by running ncl_tests/test_psychro_fao56.ncl + ).values # Generated by running ncl_tests/test_psychro_fao56.ncl except: - ncl_xr_gt = xr.open_dataarray("test/psychro_fao56_output.nc") - - # set up ground truths - cls.ncl_gt = np.asarray(ncl_xr_gt) + return xr.open_dataarray("test/psychro_fao56_output.nc").values - cls.pressure_gt = np.arange(1, 101, 1) - - # make client to reference in subsequent tests - cls.client = dd.Client() - - def test_numpy_input(self): + def test_numpy_input(self, ncl_gt) -> None: assert np.allclose(psychrometric_constant(self.pressure_gt), - self.ncl_gt, + ncl_gt, atol=0.005) - def test_float_input(self): + def test_float_input(self) -> None: pressure = 81.78 expected = 0.05434634 assert np.allclose(psychrometric_constant(pressure), expected, atol=0.005) - def test_list_input(self): + def test_list_input(self, ncl_gt) -> None: assert np.allclose(psychrometric_constant(self.pressure_gt.tolist()), - self.ncl_gt.tolist(), + ncl_gt.tolist(), atol=0.005) - def test_multi_dimensional_input(self): + def test_multi_dimensional_input(self, ncl_gt) -> None: assert np.allclose(psychrometric_constant( self.pressure_gt.reshape(2, 50)), - self.ncl_gt.reshape(2, 50), + ncl_gt.reshape(2, 50), atol=0.005) - def test_xarray_input(self): + def test_xarray_input(self, ncl_gt) -> None: pressure = xr.DataArray(self.pressure_gt) - expected = xr.DataArray(self.ncl_gt) + expected = xr.DataArray(ncl_gt) assert np.allclose(psychrometric_constant(pressure), expected, atol=0.005) - def test_dask_compute(self): + def test_dask_compute(self, ncl_gt, client) -> None: pressure = xr.DataArray(self.pressure_gt).chunk(10) - assert np.allclose(psychrometric_constant(pressure), - self.ncl_gt, - atol=0.005) + assert np.allclose(psychrometric_constant(pressure), ncl_gt, atol=0.005) - def test_dask_lazy(self): + def test_dask_lazy(self, client) -> None: pressure = xr.DataArray(self.pressure_gt).chunk(10) assert isinstance((psychrometric_constant(pressure)).data, dask.array.Array) -class Test_saturation_vapor_pressure(unittest.TestCase): +class Test_saturation_vapor_pressure: - @classmethod - def setUpClass(cls): + # set up ground truths + temp_gt = np.arange(1, 101, 1) + @pytest.fixture(scope="class") + def ncl_gt(self): # get ground truth from ncl run netcdf file try: - ncl_xr_gt = xr.open_dataarray( + return xr.open_dataarray( "satvpr_temp_fao56_output.nc" - ) # Generated by running ncl_tests/test_satvpr_temp_fao56.ncl + ).values # Generated by running ncl_tests/test_satvpr_temp_fao56.ncl except: - ncl_xr_gt = xr.open_dataarray("test/satvpr_temp_fao56_output.nc") - - # set up ground truths - cls.ncl_gt = np.asarray(ncl_xr_gt) + return xr.open_dataarray("test/satvpr_temp_fao56_output.nc").values - cls.temp_gt = np.arange(1, 101, 1) - - # make client to reference in subsequent tests - cls.client = dd.Client() - - def test_numpy_input(self): + def test_numpy_input(self, ncl_gt) -> None: assert np.allclose(saturation_vapor_pressure(self.temp_gt, tfill=1.0000000e+20), - self.ncl_gt, + ncl_gt, atol=0.005) - def test_float_input(self): + def test_float_input(self) -> None: degf = 59 expected = 1.70535 assert np.allclose(saturation_vapor_pressure(degf), expected, atol=0.005) - def test_list_input(self): + def test_list_input(self, ncl_gt) -> None: assert np.allclose(saturation_vapor_pressure(self.temp_gt.tolist(), tfill=1.0000000e+20), - self.ncl_gt.tolist(), + ncl_gt.tolist(), atol=0.005) - def test_multi_dimensional_input(self): + def test_multi_dimensional_input(self, ncl_gt) -> None: assert np.allclose(saturation_vapor_pressure(self.temp_gt.reshape( 2, 50), tfill=1.0000000e+20), - self.ncl_gt.reshape(2, 50), + ncl_gt.reshape(2, 50), atol=0.005) - def test_xarray_input(self): + def test_xarray_input(self, ncl_gt) -> None: tempf = xr.DataArray(self.temp_gt) - expected = xr.DataArray(self.ncl_gt) + expected = xr.DataArray(ncl_gt) assert np.allclose(saturation_vapor_pressure(tempf, tfill=1.0000000e+20), expected, atol=0.005) - def test_dask_compute(self): + def test_dask_compute(self, ncl_gt) -> None: tempf = xr.DataArray(self.temp_gt).chunk(10) assert np.allclose(saturation_vapor_pressure(tempf, tfill=1.0000000e+20), - self.ncl_gt, + ncl_gt, atol=0.005) - def test_dask_lazy(self): + def test_dask_lazy(self) -> None: tempf = xr.DataArray(self.temp_gt).chunk(10) assert isinstance((saturation_vapor_pressure(tempf, @@ -567,166 +539,163 @@ def test_dask_lazy(self): dask.array.Array) -class Test_saturation_vapor_pressure_slope(unittest.TestCase): +class Test_saturation_vapor_pressure_slope: - @classmethod - def setUpClass(cls): + # set up ground truths + temp_gt = np.arange(1, 101, 1) + @pytest.fixture(scope="class") + def ncl_gt(self): # get ground truth from ncl run netcdf file try: - ncl_xr_gt = xr.open_dataarray( + return xr.open_dataarray( "satvpr_slope_fao56_output.nc" - ) # Generated by running ncl_tests/test_satvpr_slope_fao56.ncl + ).values # Generated by running ncl_tests/test_satvpr_slope_fao56.ncl except: - ncl_xr_gt = xr.open_dataarray("test/satvpr_slope_fao56_output.nc") - - # set up ground truths - cls.ncl_gt = np.asarray(ncl_xr_gt) - - cls.temp_gt = np.arange(1, 101, 1) - - # make client to reference in subsequent tests - cls.client = dd.Client() + return xr.open_dataarray("test/satvpr_slope_fao56_output.nc").values - def test_numpy_input(self): + def test_numpy_input(self, ncl_gt) -> None: assert np.allclose(saturation_vapor_pressure_slope(self.temp_gt), - self.ncl_gt, + ncl_gt, equal_nan=True) - def test_float_input(self): + def test_float_input(self) -> None: degf = 67.55 expected = 0.142793 assert np.allclose(saturation_vapor_pressure_slope(degf), expected, atol=0.005) - def test_list_input(self): + def test_list_input(self, ncl_gt) -> None: assert np.allclose(saturation_vapor_pressure_slope( self.temp_gt.tolist()), - self.ncl_gt.tolist(), + ncl_gt.tolist(), equal_nan=True) - def test_multi_dimensional_input(self): + def test_multi_dimensional_input(self, ncl_gt) -> None: assert np.allclose(saturation_vapor_pressure_slope( self.temp_gt.reshape(2, 50)), - self.ncl_gt.reshape(2, 50), + ncl_gt.reshape(2, 50), atol=0.005, equal_nan=True) - def test_xarray_input(self): + def test_xarray_input(self, ncl_gt) -> None: tempf = xr.DataArray(self.temp_gt) - expected = xr.DataArray(self.ncl_gt) + expected = xr.DataArray(ncl_gt) assert np.allclose(saturation_vapor_pressure_slope(tempf), expected, atol=0.005, equal_nan=True) - def test_dask_compute(self): + def test_dask_compute(self, ncl_gt, client) -> None: tempf = xr.DataArray(self.temp_gt).chunk(10) assert np.allclose(saturation_vapor_pressure_slope(tempf), - self.ncl_gt, + ncl_gt, atol=0.005, equal_nan=True) - def test_dask_lazy(self): + def test_dask_lazy(self, client) -> None: tempf = xr.DataArray(self.temp_gt).chunk(10) assert isinstance((saturation_vapor_pressure_slope(tempf)).data, dask.array.Array) -class TestDeltaPressure(unittest.TestCase): - - @classmethod - def setUpClass(cls): - cls.pressure_lev = np.array([1, 5, 100, 1000]) - cls.pressure_lev_da = xr.DataArray(cls.pressure_lev) - cls.pressure_lev_da.attrs = { - "long name": "pressure level", - "units": "hPa", - "direction": "descending" - } - - cls.surface_pressure_scalar = 1018 - cls.surface_pressure_1D = np.array([1018, 1019]) - cls.surface_pressure_2D = np.array([[1018, 1019], [1017, 1019.5]]) - cls.surface_pressure_3D = np.array([[[1018, 1019], [1017, 1019.5]], - [[1019, 1020], [1018, 1020.5]]]) - - coords = {'time': [1, 2], 'lat': [3, 4], 'lon': [5, 6]} - dims = ["time", "lat", "lon"] - attrs = {"long name": "surface pressure", "units": "hPa"} - cls.surface_pressure_3D_da = xr.DataArray(cls.surface_pressure_3D, - coords=coords, - dims=dims, - attrs=attrs) - - def test_delta_pressure1D(self): +class Test_Delta_Pressure: + + pressure_lev = np.array([1, 5, 100, 1000]) + pressure_lev_da = xr.DataArray(pressure_lev) + pressure_lev_da.attrs = { + "long name": "pressure level", + "units": "hPa", + "direction": "descending" + } + + surface_pressure_scalar = 1018 + surface_pressure_1D = np.array([1018, 1019]) + surface_pressure_2D = np.array([[1018, 1019], [1017, 1019.5]]) + surface_pressure_3D = np.array([[[1018, 1019], [1017, 1019.5]], + [[1019, 1020], [1018, 1020.5]]]) + + surface_pressure_3D_da = xr.DataArray( + surface_pressure_3D, + coords={ + "time": [1, 2], + "lat": [3, 4], + "lon": [5, 6] + }, + dims=["time", "lat", "lon"], + attrs={ + "long name": "surface pressure", + "units": "hPa" + }, + ) + + def test_delta_pressure1D(self) -> None: pressure_lev = [float(i) for i in self.pressure_lev] pressure_top = min(pressure_lev) delta_p = delta_pressure(pressure_lev, self.surface_pressure_scalar) - self.assertEqual(sum(delta_p), - self.surface_pressure_scalar - pressure_top) + assert sum(delta_p) == (self.surface_pressure_scalar - pressure_top) - def test_negative_pressure_warning(self): + def test_negative_pressure_warning(self) -> None: pressure_lev_negative = self.pressure_lev.copy() pressure_lev_negative[0] = -5 - with self.assertWarns(Warning): + with pytest.warns(UserWarning): delta_p = delta_pressure(pressure_lev_negative, self.surface_pressure_scalar) - def test_relative_pressure_warning(self): + def test_relative_pressure_warning(self) -> None: surface_pressure_low = 0.5 - with self.assertWarns(Warning): + with pytest.warns(UserWarning): delta_p = delta_pressure(self.pressure_lev, surface_pressure_low) - def test_output_type(self): + def test_output_type(self) -> None: delta_pressure_da = delta_pressure(self.pressure_lev_da, self.surface_pressure_3D_da) - self.assertIsInstance(delta_pressure_da, xr.DataArray) + assert isinstance(delta_pressure_da, xr.DataArray) delta_pressure_np = delta_pressure(self.pressure_lev, self.surface_pressure_3D) - self.assertIsInstance(delta_pressure_np, np.ndarray) + assert isinstance(delta_pressure_np, np.ndarray) - def test_output_dimensions(self): + def test_output_dimensions(self) -> None: delta_pressure_scalar = delta_pressure(self.pressure_lev, self.surface_pressure_scalar) - self.assertEqual(delta_pressure_scalar.shape, (4,)) + assert delta_pressure_scalar.shape == (4,) delta_pressure_1D = delta_pressure(self.pressure_lev, self.surface_pressure_1D) - self.assertEqual(delta_pressure_1D.shape, (2, 4)) + assert delta_pressure_1D.shape == (2, 4) delta_pressure_2D = delta_pressure(self.pressure_lev, self.surface_pressure_2D) - self.assertEqual(delta_pressure_2D.shape, (2, 2, 4)) + assert delta_pressure_2D.shape == (2, 2, 4) delta_pressure_3D = delta_pressure(self.pressure_lev, self.surface_pressure_3D) - self.assertEqual(delta_pressure_3D.shape, (2, 2, 2, 4)) + assert delta_pressure_3D.shape == (2, 2, 2, 4) - def test_output_attrs(self): + def test_output_attrs(self) -> None: delta_pressure_da = delta_pressure(self.pressure_lev_da, self.surface_pressure_3D_da) for item in self.pressure_lev_da.attrs: - self.assertIn(item, delta_pressure_da.attrs) + assert item in delta_pressure_da.attrs - def test_output_coords(self): + def test_output_coords(self) -> None: delta_pressure_da = delta_pressure(self.pressure_lev_da, self.surface_pressure_3D_da) for item in self.surface_pressure_3D_da.coords: - self.assertIn(item, delta_pressure_da.coords) + assert item in delta_pressure_da.coords for item in self.pressure_lev_da.coords: - self.assertIn(item, delta_pressure_da.coords) + assert item in delta_pressure_da.coords - def test_mismatch_input_types(self): + def test_mismatch_input_types(self) -> None: delta_pressure_da = delta_pressure(self.pressure_lev, self.surface_pressure_3D_da) - self.assertIsInstance(delta_pressure_da, xr.DataArray) + assert isinstance(delta_pressure_da, xr.DataArray) delta_pressure_np = delta_pressure(self.pressure_lev_da, self.surface_pressure_3D) - self.assertIsInstance(delta_pressure_np, np.ndarray) + assert isinstance(delta_pressure_np, np.ndarray) diff --git a/test/test_spherical.py b/test/test_spherical.py index 4fe2d82b1..7f9fbb761 100644 --- a/test/test_spherical.py +++ b/test/test_spherical.py @@ -1,6 +1,6 @@ import math as ma import sys -import unittest +import pytest import numpy as np import scipy.special as ss @@ -9,72 +9,70 @@ from geocat.comp import decomposition, recomposition, scale_voronoi -class Test_Spherical(unittest.TestCase): +class Test_Spherical: - @classmethod - def setUpClass(cls): - max_harm = 23 - num_phi = 90 - num_theta = 180 + max_harm = 23 + num_phi = 90 + num_theta = 180 - theta = np.linspace(0, ma.tau - ma.tau / num_theta, num_theta) - phi = np.linspace( - ma.pi / (2 * num_phi), - ma.pi - ma.pi / (2 * num_phi), - num_phi, - ) - cls.theta_np, cls.phi_np = np.meshgrid(theta, phi) - cls.theta_xr = xr.DataArray(cls.theta_np, dims=['lat', 'lon']) - cls.phi_xr = xr.DataArray(cls.phi_np, dims=['lat', 'lon']) - cls.test_scale_np = np.sin(cls.phi_np) - cls.test_scale_xr = xr.DataArray( - cls.test_scale_np, - dims=['lat', 'lon'], - ).compute() + theta = np.linspace(0, ma.tau - ma.tau / num_theta, num_theta) + phi = np.linspace( + ma.pi / (2 * num_phi), + ma.pi - ma.pi / (2 * num_phi), + num_phi, + ) + theta_np, phi_np = np.meshgrid(theta, phi) + theta_xr = xr.DataArray(theta_np, dims=['lat', 'lon']) + phi_xr = xr.DataArray(phi_np, dims=['lat', 'lon']) + test_scale_np = np.sin(phi_np) + test_scale_xr = xr.DataArray( + test_scale_np, + dims=['lat', 'lon'], + ).compute() - test_data = np.zeros(cls.theta_np.shape) - test_results = [] - test_harmonics = [] - for n in range(max_harm + 1): - for m in range(n + 1): - test_harmonics.append([m, n]) - test_results.append(0) - if n in [0, 2, 3, 5, 7, 11, 13, 17, 19, 23 - ] and m in [0, 2, 3, 5, 7, 11, 13, 17, 19, 23]: - if m in [2, 5, 11, 17, 23]: - test_data += ss.sph_harm( - m, - n, - cls.theta_np, - cls.phi_np, - ).imag - test_results[-1] = 1j - else: - test_data += ss.sph_harm( - m, - n, - cls.theta_np, - cls.phi_np, - ).real - test_results[-1] = 1 + test_data = np.zeros(theta_np.shape) + test_results = [] + test_harmonics = [] + for n in range(max_harm + 1): + for m in range(n + 1): + test_harmonics.append([m, n]) + test_results.append(0) + if n in [0, 2, 3, 5, 7, 11, 13, 17, 19, 23 + ] and m in [0, 2, 3, 5, 7, 11, 13, 17, 19, 23]: + if m in [2, 5, 11, 17, 23]: + test_data += ss.sph_harm( + m, + n, + theta_np, + phi_np, + ).imag + test_results[-1] = 1j + else: + test_data += ss.sph_harm( + m, + n, + theta_np, + phi_np, + ).real + test_results[-1] = 1 - cls.test_harmonics_np = np.array(test_harmonics) - cls.test_harmonics_xr = xr.DataArray( - cls.test_harmonics_np, - dims=['har', 'm,n'], - ).compute() - cls.test_data_np = test_data - cls.test_data_xr = xr.DataArray( - cls.test_data_np, - dims=['lat', 'lon'], - ).compute() - cls.test_results_np = np.array(test_results) - cls.test_results_xr = xr.DataArray( - cls.test_results_np, - dims=['har'], - ).compute() + test_harmonics_np = np.array(test_harmonics) + test_harmonics_xr = xr.DataArray( + test_harmonics_np, + dims=['har', 'm,n'], + ).compute() + test_data_np = test_data + test_data_xr = xr.DataArray( + test_data_np, + dims=['lat', 'lon'], + ).compute() + test_results_np = np.array(test_results) + test_results_xr = xr.DataArray( + test_results_np, + dims=['har'], + ).compute() - def test_decomposition_np(self): + def test_decomposition_np(self) -> None: results_np = decomposition( self.test_data_np, self.test_scale_np, @@ -87,7 +85,7 @@ def test_decomposition_np(self): decimal=2, ) - def test_decomposition_xr(self): + def test_decomposition_xr(self) -> None: results_xr = decomposition( self.test_data_xr, self.test_scale_xr, @@ -100,7 +98,7 @@ def test_decomposition_xr(self): decimal=2, ) - def test_recomposition_np(self): + def test_recomposition_np(self) -> None: data_np = recomposition( self.test_results_np, self.theta_np, @@ -111,7 +109,7 @@ def test_recomposition_np(self): self.test_data_np, ) - def test_recomposition_xr(self): + def test_recomposition_xr(self) -> None: data_xr = recomposition( self.test_results_xr, self.theta_xr, @@ -122,7 +120,7 @@ def test_recomposition_xr(self): self.test_data_xr.to_numpy(), ) - def test_scale_voronoi_np(self): + def test_scale_voronoi_np(self) -> None: scale_np = scale_voronoi( self.theta_np, self.phi_np, @@ -132,7 +130,7 @@ def test_scale_voronoi_np(self): self.test_scale_np / np.sum(self.test_scale_np, axis=(0, 1)), ) - def test_scale_voronoi_xr(self): + def test_scale_voronoi_xr(self) -> None: scale_xr = scale_voronoi( self.theta_xr, self.phi_xr, diff --git a/test/test_stats.py b/test/test_stats.py index 61d61fc35..d7f645288 100644 --- a/test/test_stats.py +++ b/test/test_stats.py @@ -1,8 +1,8 @@ -from unittest import TestCase import sys from abc import ABCMeta import numpy as np import xarray as xr +import pytest from geocat.comp.stats import eofunc, eofunc_eofs, eofunc_pcs, eofunc_ts, pearson_r @@ -47,11 +47,6 @@ class BaseEOFTestClass(metaclass=ABCMeta): # _sample_data[ 4 ] _sample_data_eof.append(np.arange(64, dtype='int64').reshape((4, 4, 4))) - try: - _nc_ds = xr.open_dataset("eofunc_dataset.nc") - except: - _nc_ds = xr.open_dataset("test/eofunc_dataset.nc") - _num_attrs = 4 expected_output = np.full((1, 4, 4), 0.25) @@ -60,9 +55,9 @@ class BaseEOFTestClass(metaclass=ABCMeta): expected_eigen_val_time_dim_0 = 6826.66667 -class Test_eof(TestCase, BaseEOFTestClass): +class Test_eof(BaseEOFTestClass): - def test_eof_00(self): + def test_eof_00(self) -> None: data = self._sample_data_eof[0] results = eofunc_eofs(data, neofs=1, time_dim=2) @@ -71,14 +66,17 @@ def test_eof_00(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) np.testing.assert_almost_equal(self.expected_eigen_val_time_dim_2, attrs['eigenvalues'].values[0], 5) - def test_eof_deprecated(self): + def test_eof_deprecated(self) -> None: data = self._sample_data_eof[0] results = eofunc(data, neval=1) @@ -87,14 +85,17 @@ def test_eof_deprecated(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) np.testing.assert_almost_equal(self.expected_eigen_val_time_dim_2, attrs['eigenvalues'].values[0], 5) - def test_eof_01(self): + def test_eof_01(self) -> None: data = self._sample_data_eof[1] results = eofunc_eofs(data, neofs=1, time_dim=2) @@ -103,14 +104,17 @@ def test_eof_01(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) np.testing.assert_almost_equal(self.expected_eigen_val_time_dim_2, attrs['eigenvalues'].values[0], 5) - def test_eof_02(self): + def test_eof_02(self) -> None: data = self._sample_data_eof[1] results = eofunc_eofs(data, neofs=1, time_dim=2) @@ -119,14 +123,17 @@ def test_eof_02(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) np.testing.assert_almost_equal(self.expected_eigen_val_time_dim_2, attrs['eigenvalues'].values[0], 5) - def test_eof_14(self): + def test_eof_14(self) -> None: data = self._sample_data_eof[4] results = eofunc_eofs(data, neofs=1, time_dim=2) @@ -135,14 +142,17 @@ def test_eof_14(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) np.testing.assert_almost_equal(self.expected_eigen_val_time_dim_2, attrs['eigenvalues'].values[0], 5) - def test_eof_15(self): + def test_eof_15(self) -> None: data = np.asarray(self._sample_data_eof[0]) data = np.transpose(data, axes=(2, 1, 0)) @@ -163,7 +173,10 @@ def test_eof_15(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) @@ -174,7 +187,7 @@ def test_eof_15(self): np.testing.assert_equal(False, ("prop2" in attrs)) # TODO: Maybe revisited to add time_dim support for Xarray in addition to numpy inputs - # def test_eof_15_time_dim(self): + # def test_eof_15_time_dim(self) -> None: # # data = np.asarray(self._sample_data_eof[0]) # @@ -195,7 +208,9 @@ def test_eof_15(self): # # np.testing.assert_equal(self.expected_output.shape, results.shape) # - # np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + # np.testing.assert_array_almost_equal(np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + # + # np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) # # np.testing.assert_equal(self._num_attrs + 2, len(attrs)) # @@ -207,7 +222,7 @@ def test_eof_15(self): # self.assertFalse("prop1" in attrs) # self.assertFalse("prop2" in attrs) - def test_eof_16(self): + def test_eof_16(self) -> None: data = np.asarray(self._sample_data_eof[0]) data = np.transpose(data, axes=(2, 1, 0)) @@ -227,7 +242,10 @@ def test_eof_16(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs + 2, len(attrs)) @@ -239,7 +257,7 @@ def test_eof_16(self): np.testing.assert_equal("prop1", attrs["prop1"]) np.testing.assert_equal(2, attrs["prop2"]) - def test_eof_n_01(self): + def test_eof_n_01(self) -> None: data = self._sample_data_eof[1] results = eofunc_eofs(data, neofs=1, time_dim=1) @@ -248,14 +266,17 @@ def test_eof_n_01(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) np.testing.assert_almost_equal(self.expected_eigen_val_time_dim_1, attrs['eigenvalues'].values[0], 5) - def test_eof_n_03(self): + def test_eof_n_03(self) -> None: data = self._sample_data_eof[1] results = eofunc_eofs(data, 1, time_dim=0) @@ -264,14 +285,17 @@ def test_eof_n_03(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) np.testing.assert_almost_equal(self.expected_eigen_val_time_dim_0, attrs['eigenvalues'].values[0], 5) - def test_eof_n_03_1(self): + def test_eof_n_03_1(self) -> None: data = self._sample_data_eof[1] results = eofunc_eofs(data, 1, time_dim=0) @@ -280,7 +304,10 @@ def test_eof_n_03_1(self): np.testing.assert_equal(self.expected_output.shape, results.shape) - np.testing.assert_array_almost_equal(self.expected_output, eof, 5) + np.testing.assert_array_almost_equal( + np.linalg.norm(self.expected_output), np.linalg.norm(eof), 5) + + np.testing.assert_array_almost_equal(self.expected_output, abs(eof), 5) np.testing.assert_equal(self._num_attrs, len(attrs)) @@ -288,12 +315,19 @@ def test_eof_n_03_1(self): attrs['eigenvalues'].values[0], 5) -class Test_eof_ts(TestCase, BaseEOFTestClass): +class Test_eof_ts(BaseEOFTestClass): + + @pytest.fixture(scope="class") + def _nc_ds(self): + try: + return xr.open_dataset("eofunc_dataset.nc") + except: + return xr.open_dataset("test/eofunc_dataset.nc") - def test_01(self): - sst = self._nc_ds.sst - evec = self._nc_ds.evec - expected_tsout = self._nc_ds.tsout + def test_01(self, _nc_ds) -> None: + sst = _nc_ds.sst + evec = _nc_ds.evec + expected_tsout = _nc_ds.tsout actual_tsout = eofunc_pcs(sst, npcs=5) @@ -302,10 +336,10 @@ def test_01(self): np.testing.assert_array_almost_equal(actual_tsout, expected_tsout.data, 3) - def test_01_deprecated(self): - sst = self._nc_ds.sst - evec = self._nc_ds.evec - expected_tsout = self._nc_ds.tsout + def test_01_deprecated(self, _nc_ds) -> None: + sst = _nc_ds.sst + evec = _nc_ds.evec + expected_tsout = _nc_ds.tsout actual_tsout = eofunc_ts(sst, evec, time_dim=0) @@ -314,10 +348,10 @@ def test_01_deprecated(self): np.testing.assert_array_almost_equal(actual_tsout, expected_tsout.data, 3) - def test_02(self): - sst = self._nc_ds.sst - evec = self._nc_ds.evec - expected_tsout = self._nc_ds.tsout + def test_02(self, _nc_ds) -> None: + sst = _nc_ds.sst + evec = _nc_ds.evec + expected_tsout = _nc_ds.tsout actual_tsout = eofunc_pcs(sst, npcs=5, meta=True) @@ -330,70 +364,69 @@ def test_02(self): sst.coords["time"].data) -class Test_pearson_r(TestCase): - - @classmethod - def setUpClass(cls): - # Coordinates - times = xr.cftime_range(start='2022-08-01', end='2022-08-05', freq='D') - lats = np.linspace(start=-45, stop=45, num=3, dtype='float32') - lons = np.linspace(start=-180, stop=180, num=4, dtype='float32') - - # Create data variables - x, y, z = np.meshgrid(lons, lats, times) - np.random.seed(0) - cls.a = np.random.random_sample((len(lats), len(lons), len(times))) - cls.b = np.power(cls.a, 2) - cls.weights = np.cos(np.deg2rad(y)) - cls.ds = xr.Dataset(data_vars={ - 'a': (('lat', 'lon', 'time'), cls.a), - 'b': (('lat', 'lon', 'time'), cls.b), - 'weights': (('lat', 'lon', 'time'), cls.weights) - }, - coords={ - 'lat': lats, - 'lon': lons, - 'time': times - }, - attrs={'description': 'Test data'}) - - cls.unweighted_r = 0.963472086 - cls.unweighted_r_skipnan = 0.96383798 - cls.weighted_r = 0.963209755 - cls.weighted_r_lat = [ - [0.995454445, 0.998450821, 0.99863877, 0.978765291, 0.982350092], - [0.99999275, 0.995778831, 0.998994355, 0.991634937, 0.999868279], - [0.991344899, 0.998632079, 0.99801552, 0.968517489, 0.985215828], - [0.997034735, 0.99834464, 0.987382522, 0.99646236, 0.989222738] - ] +class Test_pearson_r: + + # Coordinates + times = xr.cftime_range(start='2022-08-01', end='2022-08-05', freq='D') + lats = np.linspace(start=-45, stop=45, num=3, dtype='float32') + lons = np.linspace(start=-180, stop=180, num=4, dtype='float32') + + # Create data variables + x, y, z = np.meshgrid(lons, lats, times) + np.random.seed(0) + a = np.random.random_sample((len(lats), len(lons), len(times))) + b = np.power(a, 2) + weights = np.cos(np.deg2rad(y)) + ds = xr.Dataset(data_vars={ + 'a': (('lat', 'lon', 'time'), a), + 'b': (('lat', 'lon', 'time'), b), + 'weights': (('lat', 'lon', 'time'), weights) + }, + coords={ + 'lat': lats, + 'lon': lons, + 'time': times + }, + attrs={'description': 'Test data'}) + + unweighted_r = 0.963472086 + unweighted_r_skipnan = 0.96383798 + weighted_r = 0.963209755 + weighted_r_lat = [ + [0.995454445, 0.998450821, 0.99863877, 0.978765291, 0.982350092], + [0.99999275, 0.995778831, 0.998994355, 0.991634937, 0.999868279], + [0.991344899, 0.998632079, 0.99801552, 0.968517489, 0.985215828], + [0.997034735, 0.99834464, 0.987382522, 0.99646236, 0.989222738] + ] # Testing numpy inputs - def test_np_inputs(self): + def test_np_inputs(self) -> None: a = self.a b = self.b result = pearson_r(a, b) assert np.allclose(self.unweighted_r, result) - def test_np_inputs_weighted(self): + def test_np_inputs_weighted(self) -> None: a = self.a b = self.b w = self.weights result = pearson_r(a, b, weights=w) assert np.allclose(self.weighted_r, result) - def test_np_inputs_warn(self): + def test_np_inputs_warn(self) -> None: a = self.a b = self.b - self.assertWarns(Warning, pearson_r, a, b, dim='lat', axis=0) + with pytest.warns(UserWarning): + pearson_r(a, b, dim='lat', axis=0) - def test_np_inputs_across_lats(self): + def test_np_inputs_across_lats(self) -> None: a = self.a b = self.b w = self.weights result = pearson_r(a, b, weights=w, axis=0) assert np.allclose(self.weighted_r_lat, result) - def test_np_inputs_skipna(self): + def test_np_inputs_skipna(self) -> None: # deep copy to prevent adding nans to the test data for other tests a = self.a.copy() a[0] = np.nan @@ -402,32 +435,33 @@ def test_np_inputs_skipna(self): assert np.allclose(self.unweighted_r_skipnan, result) # Testing xarray inputs - def test_xr_inputs(self): + def test_xr_inputs(self) -> None: a = self.ds.a b = self.ds.b result = pearson_r(a, b) assert np.allclose(self.unweighted_r, result) - def test_xr_inputs_weighted(self): + def test_xr_inputs_weighted(self) -> None: a = self.ds.a b = self.ds.b w = self.ds.weights result = pearson_r(a, b, weights=w) assert np.allclose(self.weighted_r, result) - def test_xr_inputs_warn(self): + def test_xr_inputs_warn(self) -> None: a = self.ds.a b = self.ds.b - self.assertWarns(Warning, pearson_r, a, b, dim='lat', axis=0) + with pytest.warns(UserWarning): + pearson_r(a, b, dim='lat', axis=0) - def test_xr_inputs_across_lats(self): + def test_xr_inputs_across_lats(self) -> None: a = self.ds.a b = self.ds.b w = self.ds.weights[:, 0, 0] result = pearson_r(a, b, weights=w, dim='lat') assert np.allclose(self.weighted_r_lat, result) - def test_xr_inputs_skipna(self): + def test_xr_inputs_skipna(self) -> None: # deep copy to prevent adding nans to the test data for other tests a = self.ds.a.copy(deep=True) a[0] = np.nan @@ -435,7 +469,7 @@ def test_xr_inputs_skipna(self): result = pearson_r(a, b, skipna=True) assert np.allclose(self.unweighted_r_skipnan, result) - def test_keep_attrs(self): + def test_keep_attrs(self) -> None: a = self.ds.a b = self.ds.b a.attrs.update({'Description': 'Test Data'})