diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000000..d15c975eac --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,10 @@ +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" + groups: + actions: + patterns: + - "*" diff --git a/.github/workflows/antivirus.yml b/.github/workflows/antivirus.yml index 25b1d9bf84..b2a306e249 100644 --- a/.github/workflows/antivirus.yml +++ b/.github/workflows/antivirus.yml @@ -7,7 +7,7 @@ jobs: runs-on: ubuntu-latest name: AV scan steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Git AV Scan uses: djdefi/gitavscan@main with: diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml index c4329ad51c..1a63a7bdd3 100644 --- a/.github/workflows/build-docs.yml +++ b/.github/workflows/build-docs.yml @@ -20,7 +20,7 @@ jobs: run: shell: bash -l {0} steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 # Install dependencies - name: Setup Conda Environment @@ -44,7 +44,7 @@ jobs: AIRNOW_API: ${{ secrets.AIRNOW_API }} # Push the book's HTML to github-pages - name: GitHub Pages action - uses: peaceiris/actions-gh-pages@v3.8.0 + uses: peaceiris/actions-gh-pages@v4.0.0 if: github.ref == 'refs/heads/main' with: github_token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b478c72225..68c2d8e77f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,6 +1,9 @@ name: Run Unit Tests CI on: + schedule: + # Runs at 09Z (2am CDT) + - cron: "0 9 * * *" push: branches: [ main ] pull_request: @@ -38,7 +41,7 @@ jobs: platform: [x64] steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Setup Conda Environment uses: mamba-org/setup-micromamba@v1 @@ -64,10 +67,12 @@ jobs: python -m pytest -v --mpl --cov=./ --cov-report=xml - name: Upload code coverage to Codecov - uses: codecov/codecov-action@v2.1.0 + uses: codecov/codecov-action@v4 with: file: ./coverage.xml flags: unittests env_vars: OS,PYTHON name: codecov-umbrella fail_ci_if_error: false + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index c2fb38c867..77cd91b23a 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -42,11 +42,11 @@ jobs: steps: - name: Checkout repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@v1 + uses: github/codeql-action/init@v3 with: languages: ${{ matrix.language }} # If you wish to specify custom queries, you can do so here or in a config file. @@ -57,7 +57,7 @@ jobs: # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). # If this step fails, then you should remove it and run the build manually (see below) - name: Autobuild - uses: github/codeql-action/autobuild@v1 + uses: github/codeql-action/autobuild@v3 # ℹ️ Command-line programs to run using the OS shell. # 📚 https://git.io/JvXDl @@ -71,4 +71,4 @@ jobs: # make release - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@v1 + uses: github/codeql-action/analyze@v3 diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml new file mode 100644 index 0000000000..cd7d332a71 --- /dev/null +++ b/.github/workflows/linting.yml @@ -0,0 +1,33 @@ +name: linting + +on: + push: + pull_request: + workflow_dispatch: + +jobs: + pre-job: + runs-on: ubuntu-latest + outputs: + should_skip: ${{ steps.skip_check.outputs.should_skip }} + steps: + - id: skip_check + uses: fkirc/skip-duplicate-actions@master + with: + concurrent_skipping: 'same_content' + skip_after_successful_duplicate: 'false' + do_not_skip: '["workflow_dispatch", "schedule"]' + linting: + needs: pre-job + runs-on: ubuntu-latest + if: ${{ needs.pre-job.outputs.should_skip != 'true' }} + steps: + - name: Cancel Previous Runs + uses: styfle/cancel-workflow-action@0.12.1 + with: + access_token: ${{ github.token }} + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.10' + - uses: pre-commit/action@v3.0.1 diff --git a/.github/workflows/pypi-release.yml b/.github/workflows/pypi-release.yml index a427a4b024..9f45e5d358 100644 --- a/.github/workflows/pypi-release.yml +++ b/.github/workflows/pypi-release.yml @@ -9,10 +9,10 @@ jobs: runs-on: ubuntu-latest if: github.repository == 'ARM-DOE/ACT' steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: fetch-depth: 0 - - uses: actions/setup-python@v4 + - uses: actions/setup-python@v5 name: Install Python with: python-version: 3.11 @@ -36,7 +36,7 @@ jobs: else echo "✅ Looks good" fi - - uses: actions/upload-artifact@v3 + - uses: actions/upload-artifact@v4 with: name: releases path: dist @@ -45,11 +45,11 @@ jobs: needs: build-artifacts runs-on: ubuntu-latest steps: - - uses: actions/setup-python@v4 + - uses: actions/setup-python@v5 name: Install Python with: python-version: "3.x" - - uses: actions/download-artifact@v3 + - uses: actions/download-artifact@v4 with: name: releases path: dist @@ -62,12 +62,12 @@ jobs: if: github.event_name == 'release' runs-on: ubuntu-latest steps: - - uses: actions/download-artifact@v3 + - uses: actions/download-artifact@v4 with: name: releases path: dist - name: Publish package to PyPI - uses: pypa/gh-action-pypi-publish@v1.8.10 + uses: pypa/gh-action-pypi-publish@v1.9.0 with: user: __token__ password: ${{ secrets.PYPI_TOKEN }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 16784b30d8..a0f1f3dc22 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -7,7 +7,6 @@ repos: - id: check-docstring-first - id: check-json - id: check-yaml - - id: double-quote-string-fixer - id: debug-statements - id: mixed-line-ending @@ -24,12 +23,8 @@ repos: - id: black - id: black-jupyter - - repo: https://github.com/PyCQA/flake8 - rev: 6.0.0 + - repo: https://github.com/charliermarsh/ruff-pre-commit + rev: 'v0.0.239' hooks: - - id: flake8 - - - repo: https://github.com/PyCQA/isort - rev: 5.12.0 - hooks: - - id: isort + - id: ruff + args: [ "--fix" ] diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 1c131a7c9d..c0dd6b1ead 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -247,39 +247,22 @@ An example: Code Style ---------- -ACT follows PEP8 coding standards. To make sure your code follows the -PEP8 style, you can use a variety of tools that can check for you. Two -popular PEP8 check modules are flake8 and pylint. (Note: ACT's continuous -integration uses flake8). +Py-ART uses pre-commit for linting, which applies a variety of pep8 and other +code style rules. For more on pep8 style: - https://www.python.org/dev/peps/pep-0008/ -To install flake8:: +To install pre-commit hooks for the Py-ART repo:: - conda install -c conda-forge flake8 + pre-commit install -To use flake8:: +Afterwards, pre-commit will run on every commit to the repository. It will +re-format files as neccessary. - flake8 path/to/code/to/check.py - -To install pylint:: - - conda install pylint - -To use pylint:: - - pylint path/to/code/to/check.py - -Both of these tools are highly configurable to suit a user's taste. Refer to -the tools documentation for details on this process. - -- https://flake8.pycqa.org/en/latest/ -- https://www.pylint.org/ - -Naming Convenction ----------------------------------------- +Naming Convention +----------------- Discovery ~~~~~~~~~ diff --git a/MANIFEST.in b/MANIFEST.in index df46685ecd..0dbcb3a227 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -7,9 +7,9 @@ include LICENSE.txt recursive-exclude * __pycache__ recursive-exclude * *.py[co] -recursive-include act/plotting *.txt -recursive-include act/tests * +recursive-include act/plotting *.txt +recursive-include tests *.py *.png recursive-include docs *.rst conf.py Makefile make.bat include versioneer.py diff --git a/README.rst b/README.rst index d828e20b3c..aaa6e33a2c 100644 --- a/README.rst +++ b/README.rst @@ -4,7 +4,7 @@ Atmospheric data Community Toolkit (ACT) |AnacondaCloud| |CodeCovStatus| |Build| |Docs| -|CondaDownloads| |Zenodo| |ARM| +|CondaDownloads| |PyPiDownloads| |Zenodo| |ARM| .. |AnacondaCloud| image:: https://anaconda.org/conda-forge/act-atmos/badges/version.svg :target: https://anaconda.org/conda-forge/act-atmos @@ -12,6 +12,9 @@ Atmospheric data Community Toolkit (ACT) .. |CondaDownloads| image:: https://anaconda.org/conda-forge/act-atmos/badges/downloads.svg :target: https://anaconda.org/conda-forge/act-atmos/files +.. |PyPiDownloads| image:: https://img.shields.io/pypi/dm/act_atmos.svg + :target: https://pypi.org/project/act-atmos/ + .. |Zenodo| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.3855537.svg :target: https://doi.org/10.5281/zenodo.3855537 @@ -38,16 +41,14 @@ Please report any issues or feature requests by sumitting an `Issue `_ has been provided that explains the changes and how to work with the new syntax. -To test out the release candidate 2.0.0-rc.0 of ACT, use:: - - pip install git+https://github.com/ARM-DOE/ACT.git@v2.0.0-rc.0 +The new release is available on both PyPI and conda-forge. -Please report any bugs of the release candidate to the Issue Tracker mentioned in +Please report any bugs of the 2.0 release to the Issue Tracker mentioned in the Important Links section below. Important Links @@ -144,18 +145,14 @@ the source code or use git to checkout the repository:: git clone https://github.com/ARM-DOE/ACT.git -To install in your home directory, use:: - - python setup.py install --user +Once you have the directory locally, you can install ACT in +development mode using:: -To install for all users on Unix/Linux:: - - python setup.py build - sudo python setup.py install + pip install -e . -Development install using pip from within the ACT directory:: +If you want to install the repository directly, you can use:: - pip install -e . + pip install git+https://github.com/ARM-DOE/ACT.git Contributing ~~~~~~~~~~~~ diff --git a/act/__init__.py b/act/__init__.py index 81ae36fd04..56ee9cb5be 100644 --- a/act/__init__.py +++ b/act/__init__.py @@ -14,7 +14,7 @@ register_matplotlib_converters() # Import early so these classes are available to the object -from .qc import QCFilter, QCTests, clean +from .qc import QCFilter, QCTests, clean # noqa # Import the lazy loaded modules submodules = [ diff --git a/act/corrections/mpl.py b/act/corrections/mpl.py index 73e2616df1..e0601817f3 100644 --- a/act/corrections/mpl.py +++ b/act/corrections/mpl.py @@ -141,8 +141,8 @@ def correct_mpl( x_data = x_data - x_ap # R-Squared Correction - co_data = co_data * height ** 2 - x_data = x_data * height ** 2 + co_data = co_data * height**2 + x_data = x_data * height**2 # Overlap Correction for j in range(ds[range_bins_var_name].size): diff --git a/act/discovery/__init__.py b/act/discovery/__init__.py index c0a5fab10d..8159f8f4d3 100644 --- a/act/discovery/__init__.py +++ b/act/discovery/__init__.py @@ -8,14 +8,15 @@ __getattr__, __dir__, __all__ = lazy.attach( __name__, - submodules=['arm', 'cropscape', 'airnow', 'noaapsl', 'neon', 'surfrad'], + submodules=['arm', 'asos', 'airnow', 'cropscape', 'improve', 'noaapsl', 'neon', 'surfrad'], submod_attrs={ 'arm': ['download_arm_data', 'get_arm_doi'], 'asos': ['get_asos_data'], 'airnow': ['get_airnow_bounded_obs', 'get_airnow_obs', 'get_airnow_forecast'], 'cropscape': ['get_crop_type'], + 'improve': ['get_improve_data'], 'noaapsl': ['download_noaa_psl_data'], 'neon': ['get_neon_site_products', 'get_neon_product_avail', 'download_neon_data'], - 'surfrad': ['download_surfrad_data'] + 'surfrad': ['download_surfrad_data'], }, ) diff --git a/act/discovery/airnow.py b/act/discovery/airnow.py index 7b458e780c..97ec5f1cca 100644 --- a/act/discovery/airnow.py +++ b/act/discovery/airnow.py @@ -38,7 +38,7 @@ def get_airnow_forecast(token, date, zipcode=None, latlon=None, distance=25): """ # default beginning of the query url - query_url = ('https://airnowapi.org/aq/forecast/') + query_url = 'https://www.airnowapi.org/aq/forecast/' # checking is either a zipcode or latlon coordinate is defined # if neither is defined then error is raised @@ -46,17 +46,34 @@ def get_airnow_forecast(token, date, zipcode=None, latlon=None, distance=25): raise NameError("Zipcode or latlon must be defined") if zipcode: - url = (query_url + ('zipcode/?' + 'format=text/csv' + '&zipCode=' - + str(zipcode) + '&date=' + str(date) - + '&distance=' + str(distance) - + '&API_KEY=' + str(token))) + url = query_url + ( + 'zipCode/?' + + 'format=text/csv' + + '&zipCode=' + + str(zipcode) + + '&date=' + + str(date) + + '&distance=' + + str(distance) + + '&API_KEY=' + + str(token) + ) if latlon: - url = (query_url + ('latLong/?' + 'format=text/csv' - + '&latitude=' + str(latlon[0]) + '&longitude=' - + str(latlon[1]) + '&date=' + str(date) - + '&distance=' + str(distance) - + '&API_KEY=' + str(token))) + url = query_url + ( + 'latLong/?' + + 'format=text/csv' + + '&latitude=' + + str(latlon[0]) + + '&longitude=' + + str(latlon[1]) + + '&date=' + + str(date) + + '&distance=' + + str(distance) + + '&API_KEY=' + + str(token) + ) df = pd.read_csv(url) @@ -103,7 +120,7 @@ def get_airnow_obs(token, date=None, zipcode=None, latlon=None, distance=25): """ # default beginning of the query url - query_url = ('https://www.airnowapi.org/aq/observation/') + query_url = 'https://www.airnowapi.org/aq/observation/' # checking is either a zipcode or latlon coordinate is defined # if neither is defined then error is raised @@ -114,26 +131,67 @@ def get_airnow_obs(token, date=None, zipcode=None, latlon=None, distance=25): if date is None: obs_type = 'current' if zipcode: - url = (query_url + ('zipCode/' + str(obs_type) + '/?' + 'format=text/csv' - + '&zipCode=' + str(zipcode) + '&distance=' + str(distance) - + '&API_KEY=' + str(token))) + url = query_url + ( + 'zipCode/' + + str(obs_type) + + '/?' + + 'format=text/csv' + + '&zipCode=' + + str(zipcode) + + '&distance=' + + str(distance) + + '&API_KEY=' + + str(token) + ) if latlon: - url = (query_url + ('latLong/' + str(obs_type) + '/?' + 'format=text/csv' - + '&latitude=' + str(latlon[0]) - + '&longitude=' + str(latlon[1]) + '&distance=' - + str(distance) + '&API_KEY=' + str(token))) + url = query_url + ( + 'latLong/' + + str(obs_type) + + '/?' + + 'format=text/csv' + + '&latitude=' + + str(latlon[0]) + + '&longitude=' + + str(latlon[1]) + + '&distance=' + + str(distance) + + '&API_KEY=' + + str(token) + ) else: obs_type = 'historical' if zipcode: - url = (query_url + ('zipCode/' + str(obs_type) + '/?' + 'format=text/csv' - + '&zipCode=' + str(zipcode) + '&date=' + str(date) - + 'T00-0000&distance=' + str(distance) + '&API_KEY=' + str(token))) + url = query_url + ( + 'zipCode/' + + str(obs_type) + + '/?' + + 'format=text/csv' + + '&zipCode=' + + str(zipcode) + + '&date=' + + str(date) + + 'T00-0000&distance=' + + str(distance) + + '&API_KEY=' + + str(token) + ) if latlon: - url = (query_url + ('latLong/' + str(obs_type) + '/?' + 'format=text/csv' - + '&latitude=' + str(latlon[0]) - + '&longitude=' + str(latlon[1]) + '&date=' - + str(date) + 'T00-0000&distance=' + str(distance) - + '&API_KEY=' + str(token))) + url = query_url + ( + 'latLong/' + + str(obs_type) + + '/?' + + 'format=text/csv' + + '&latitude=' + + str(latlon[0]) + + '&longitude=' + + str(latlon[1]) + + '&date=' + + str(date) + + 'T00-0000&distance=' + + str(distance) + + '&API_KEY=' + + str(token) + ) df = pd.read_csv(url) @@ -143,8 +201,9 @@ def get_airnow_obs(token, date=None, zipcode=None, latlon=None, distance=25): return ds -def get_airnow_bounded_obs(token, start_date, end_date, latlon_bnds, parameters='OZONE,PM25', data_type='B', - mon_type=0): +def get_airnow_bounded_obs( + token, start_date, end_date, latlon_bnds, parameters='OZONE,PM25', data_type='B', mon_type=0 +): """ Get AQI values or data concentrations for a specific date and time range and set of parameters within a geographic area of intrest @@ -184,16 +243,44 @@ def get_airnow_bounded_obs(token, start_date, end_date, latlon_bnds, parameters= verbose = 1 inc_raw_con = 1 - url = ('https://www.airnowapi.org/aq/data/?startDate=' + str(start_date) - + '&endDate=' + str(end_date) + '¶meters=' + str(parameters) - + '&BBOX=' + str(latlon_bnds) + '&dataType=' + str(data_type) - + '&format=text/csv' + '&verbose=' + str(verbose) - + '&monitorType=' + str(mon_type) + '&includerawconcentrations=' - + str(inc_raw_con) + '&API_KEY=' + str(token)) + url = ( + 'https://www.airnowapi.org/aq/data/?startDate=' + + str(start_date) + + '&endDate=' + + str(end_date) + + '¶meters=' + + str(parameters) + + '&BBOX=' + + str(latlon_bnds) + + '&dataType=' + + str(data_type) + + '&format=text/csv' + + '&verbose=' + + str(verbose) + + '&monitorType=' + + str(mon_type) + + '&includerawconcentrations=' + + str(inc_raw_con) + + '&API_KEY=' + + str(token) + ) # Set Column names - names = ['latitude', 'longitude', 'time', 'parameter', 'concentration', 'unit', - 'raw_concentration', 'AQI', 'category', 'site_name', 'site_agency', 'aqs_id', 'full_aqs_id'] + names = [ + 'latitude', + 'longitude', + 'time', + 'parameter', + 'concentration', + 'unit', + 'raw_concentration', + 'AQI', + 'category', + 'site_name', + 'site_agency', + 'aqs_id', + 'full_aqs_id', + ] # Read data into CSV df = pd.read_csv(url, names=names) @@ -211,12 +298,9 @@ def get_airnow_bounded_obs(token, start_date, end_date, latlon_bnds, parameters= data_vars={ 'latitude': (['sites'], latitude), 'longitude': (['sites'], longitude), - 'aqs_id': (['sites'], aqs_id) + 'aqs_id': (['sites'], aqs_id), }, - coords={ - 'time': (['time'], times), - 'sites': (['sites'], sites) - } + coords={'time': (['time'], times), 'sites': (['sites'], sites)}, ) # Set up emtpy data with nans @@ -233,7 +317,11 @@ def get_airnow_bounded_obs(token, start_date, end_date, latlon_bnds, parameters= data[v, t, s] = list(result[variables[v]])[0] atts = {'units': ''} else: - result = df.loc[(df['time'] == times[t]) & (df['site_name'] == sites[s]) & (df['parameter'] == variables[v])] + result = df.loc[ + (df['time'] == times[t]) + & (df['site_name'] == sites[s]) + & (df['parameter'] == variables[v]) + ] if len(result['concentration']) > 0: data[v, t, s] = list(result['concentration'])[0] atts = {'units': list(result['unit'])[0]} diff --git a/act/discovery/arm.py b/act/discovery/arm.py index ab831771b0..1fda756913 100644 --- a/act/discovery/arm.py +++ b/act/discovery/arm.py @@ -3,14 +3,11 @@ """ -import argparse import json import os -import sys from datetime import timedelta import requests import textwrap -import warnings try: from urllib.request import urlopen @@ -163,7 +160,9 @@ def download_arm_data(username, token, datastream, startdate, enddate, time=None open_bytes_file.write(data) file_names.append(output_file) # Get ARM DOI and print it out - doi = get_arm_doi(datastream, start_datetime.strftime('%Y-%m-%d'), end_datetime.strftime('%Y-%m-%d')) + doi = get_arm_doi( + datastream, start_datetime.strftime('%Y-%m-%d'), end_datetime.strftime('%Y-%m-%d') + ) print('\nIf you use these data to prepare a publication, please cite:\n') print(textwrap.fill(doi, width=80)) print('') @@ -197,7 +196,11 @@ def get_arm_doi(datastream, startdate, enddate): """ # Get the DOI information - doi_url = 'https://adc.arm.gov/citationservice/citation/datastream?id=' + datastream + '&citationType=apa' + doi_url = ( + 'https://adc.arm.gov/citationservice/citation/datastream?id=' + + datastream + + '&citationType=apa' + ) doi_url += '&startDate=' + startdate doi_url += '&endDate=' + enddate try: diff --git a/act/discovery/asos.py b/act/discovery/asos.py index 5f5ae27534..0d37e18d8b 100644 --- a/act/discovery/asos.py +++ b/act/discovery/asos.py @@ -10,8 +10,7 @@ import numpy as np import pandas as pd -import xarray as xr -from six import StringIO +from io import StringIO try: from urllib.request import urlopen diff --git a/act/discovery/cropscape.py b/act/discovery/cropscape.py index 07308929f9..e50b4ff52b 100644 --- a/act/discovery/cropscape.py +++ b/act/discovery/cropscape.py @@ -89,10 +89,9 @@ def get_crop_type(lat=None, lon=None, year=None): # Add year, lat, and lon as parameters params = {'year': str(year), 'x': str(x), 'y': str(y)} - # Perform the request. Note, verify set to False until - # server SSL errors can be worked out + # Perform the request. try: - req = requests.get(url, params=params, verify=False, timeout=1) + req = requests.get(url, params=params, timeout=1) except Exception: return diff --git a/act/discovery/improve.py b/act/discovery/improve.py new file mode 100644 index 0000000000..677f51df38 --- /dev/null +++ b/act/discovery/improve.py @@ -0,0 +1,404 @@ +""" +Script for downloading data from the IMPROVE network + +""" + +import pandas as pd +import numpy as np +import xarray as xr + + +def get_improve_data(site_id=None, parameter_id=None, start_date=None, end_date=None): + """ + Retrieve IMPROVE data for the given site and variable ids and store it in an + xarray dataset. Documentation on the IMPROVE data can be found at + https://vista.cira.colostate.edu/Improve/data-user-guide/ + + Also adds in metadata from the site summary page to the global attributes + https://views.cira.colostate.edu/adms/Pub/SiteSummary.aspx?dsidse=10001&siidse=244 + + Parameters + ---------- + site_id : str + Site id number which can be retrieved from the IMPROVE page for each site such as + https://views.cira.colostate.edu/adms/Pub/SiteSummary.aspx?dsidse=10001&siidse=244 + parameter_id : list + List of parameter id values to retrieve from the API. + start_date : str + Start date formatted as M/D/YEAR such as 1/31/2022 + end_date : str + End date formatted as M/D/YEAR such as 1/31/2022 + + Returns + ------- + ds : xarray.Dataset + Returns an Xarray dataset object + + Example + ------- + act.discovery.get_improve_data(site_id='244') + + """ + + # Build URL + base_url = 'https://views.cira.colostate.edu/fed/svc/DataSvc.aspx?action=getqueryresults&cmdfileid=ServiceSqlCommandFile&cmdid=BasicDataQuery1_Codes' + + if site_id is None: + raise ValueError('Please provide a site_id') + else: + base_url += '&dsidse=10001&siidse=' + str(site_id) + + if parameter_id is None: + base_url += '&paidse=101,136,907,900,102,104,105,115,116,117,114,3778,142,143,144,145,3016,146,3699,141,3779,3217,108,109,112,113,301,304,303,3716,3717,3718,3719,3720,3721,3722,3730,3731,3732,3733,3734,3735,3736,3694,121,3723,3724,3725,3726,3727,3728,3729,3737,3738,3739,3740,3741,3742,3743,118,148,128,130,132,941,127,903,910,3744,3745,3746,3747,3748,3749,3750,3751,3752,3753,3754,3755,3756,3757,131,138,139,133,3704,3705,3706,3707,3708,3709,3710,3711,3712,3713,3714,3715,147,124,150,3695,3014,153,154,134,911,158,156,151,202,159,160,162,163' + else: + base_url += '&paidse=' + ','.join(parameter_id) + + if start_date is None: + raise ValueError('Please provide a start date') + else: + base_url += '&sd=' + start_date + if end_date is None: + raise ValueError('Please provide an end date') + else: + base_url += '&ed=' + end_date + + # Read data and get variables + df = pd.read_html(base_url)[0] + variables = np.unique(df.Param) + + # Print out proper acknowledgement + print("Please use the following acknowledgment when using IMPROVE data:\n") + + print( + "IMPROVE is a collaborative association of state, tribal, and federal agencies, and international partners. US Environmental Protection Agency is the primary funding source, with contracting and research support from the National Park Service. The Air Quality Group at the University of California, Davis is the central analytical laboratory, with ion analysis provided by Research Triangle Institute, and carbon analysis provided by Desert Research Institute." + ) + + # Creat mapping of variable names to metadata + mapping = { + 'ALf': {'name': 'aluminum_fine', 'long_name': 'Aluminum (Fine)', 'epa_code': '88104'}, + 'ASf': {'name': 'arsenic_fine', 'long_name': 'Arsenic (Fine)', 'epa_code': '88103'}, + 'BRf': {'name': 'bromine_fine', 'long_name': 'Bromine (Fine)', 'epa_code': '88109'}, + 'CAf': {'name': 'calcium_fine', 'long_name': 'Calcium (Fine)', 'epa_code': '88111'}, + 'CLf': {'name': 'chlorine_fine', 'long_name': 'Chlorine (Fine)', 'epa_code': '88115'}, + 'CRf': {'name': 'chromium_fine', 'long_name': 'Chromium (Fine)', 'epa_code': '88112'}, + 'CUf': {'name': 'copper_fine', 'long_name': 'Copper (Fine)', 'epa_code': '88114'}, + 'FEf': {'name': 'iron_fine', 'long_name': 'Iron (Fine)', 'epa_code': '88126'}, + 'PBf': {'name': 'lead_fine', 'long_name': 'Lead (Fine)', 'epa_code': '88128'}, + 'MGf': {'name': 'magnesium_fine', 'long_name': 'Magnesium (Fine)', 'epa_code': '88140'}, + 'MNf': {'name': 'manganese_fine', 'long_name': 'Manganese (Fine)', 'epa_code': '88132'}, + 'NIf': {'name': 'nickel_fine', 'long_name': 'Nickel (Fine)', 'epa_code': '88136'}, + 'Pf': {'name': 'phosphorus_fine', 'long_name': 'Phosphorus (Fine)', 'epa_code': '88152'}, + 'Kf': {'name': 'potassium_fine', 'long_name': 'Potassium (Fine)', 'epa_code': '88180'}, + 'RBf': {'name': 'rubidium_fine', 'long_name': 'Rubidium (Fine)', 'epa_code': '88176'}, + 'SEf': {'name': 'selenium_fine', 'long_name': 'Selenium (Fine)', 'epa_code': '88154'}, + 'SIf': {'name': 'silicon_fine', 'long_name': 'Silicon (Fine)', 'epa_code': '88165'}, + 'NAf': {'name': 'sodium_fine', 'long_name': 'Sodium (Fine)', 'epa_code': '88184'}, + 'SRf': {'name': 'strontium_fine', 'long_name': 'Strontium (Fine)', 'epa_code': '88168'}, + 'Sf': {'name': 'sulfur_fine', 'long_name': 'Sulfur (Fine)', 'epa_code': '88169'}, + 'TIf': {'name': 'titanium_fine', 'long_name': 'Titanium (Fine)', 'epa_code': '88161'}, + 'Vf': {'name': 'vanadium_fine', 'long_name': 'Vanadium (Fine)', 'epa_code': '88164'}, + 'ZNf': {'name': 'zinc_fine', 'long_name': 'Zinc (Fine)', 'epa_code': '88167'}, + 'ZRf': {'name': 'zirconium_fine', 'long_name': 'Zirconium (Fine)', 'epa_code': '88185'}, + 'CHLf': {'name': 'chloride_fine', 'long_name': 'Chloride (Fine)', 'epa_code': '88203'}, + 'NO3f': {'name': 'nitrate_fine', 'long_name': 'Nitrate (Fine)', 'epa_code': '88306'}, + 'N2f': {'name': 'nitrite_fine', 'long_name': 'Nitrite (Fine)', 'epa_code': '88338'}, + 'SO4f': {'name': 'sulfate_fine', 'long_name': 'Sulfate (Fine)', 'epa_code': '88403'}, + 'OC1f': { + 'name': 'carbon_organic_fraction_1_fine', + 'long_name': 'Carbon, Organic Fraction 1 (Fine)', + 'comments': 'TOR, pure helium (>99.999%) atmosphere, temperature (T) = 140 °C', + 'epa_code': '88324', + }, + 'OC2f': { + 'name': 'carbon_organic_fraction_2_fine', + 'long_name': 'Carbon, Organic Fraction 2 (Fine)', + 'comments': 'TOR, pure helium (>99.999%) atmosphere, temperature (T) = 280 °C', + 'epa_code': '88325', + }, + 'OC3f': { + 'name': 'carbon_organic_fraction_3_fine', + 'long_name': 'Carbon, Organic Fraction 3 (Fine)', + 'comments': 'TOR, pure helium (>99.999%) atmosphere, temperature (T) = 480 °C', + 'epa_code': '88326', + }, + 'OC4f': { + 'name': 'carbon_organic_fraction_4_fine', + 'long_name': 'Carbon, Organic Fraction 4 (Fine)', + 'comments': 'TOR, pure helium (>99.999%) atmosphere, temperature (T) = 580 °C', + 'epa_code': '88327', + }, + 'OPf': { + 'name': 'carbon_organic_reflectance_fine', + 'long_name': 'Carbon, Organic Pyrolized (Fine) by Reflectance', + 'comments': 'TOR, carbon that is measured after the introduction of helium/oxygen atmosphere at °550 C but beforereflectance returns to initial value', + 'epa_code': '88328', + }, + 'OPTf': { + 'name': 'carbon_organic_transmittance_fine', + 'long_name': 'Carbon, Organic Pyrolized (Fine) by Transmittance', + 'comments': 'TOR, carbon that is measured after the introduction of helium/oxygen atmosphere at °550 C but beforetransmittance returns to initial value', + 'epa_code': '88336', + }, + 'OCf': { + 'name': 'carbon_organic_total_fine', + 'long_name': 'Carbon, Organic Total (Fine)', + 'comments': 'Organic carbon from TOR carbon fractions (OC1f+OC2f+OC3f+OC4f+OPf)', + 'epa_code': '88320', + }, + 'EC1f': { + 'name': 'carbon_elemental_fraction_1_fine', + 'long_name': 'Carbon, Elemental Fraction 1 (Fine)', + 'comments': 'TOR, 98% helium, 2% oxygen atmosphere, temperature (T) = 580° C.', + 'epa_code': '88329', + }, + 'EC2f': { + 'name': 'carbon_elemental_fraction_2_fine', + 'long_name': 'Carbon, Elemental Fraction 2 (Fine)', + 'comments': 'TOR, 98% helium, 2% oxygen atmosphere, temperature (T) = 740° C.', + 'epa_code': '88380', + }, + 'EC3f': { + 'name': 'carbon_elemental_fraction_3_fine', + 'long_name': 'Carbon, Elemental Fraction 3 (Fine)', + 'comments': 'TOR, 98% helium, 2% oxygen atmosphere, temperature (T) = 840° C.', + 'epa_code': '88331', + }, + 'ECf': { + 'name': 'carbon_elemental_total_fine', + 'long_name': 'Carbon, Elemental Total (Fine)', + 'comments': 'Elemental carbon from TOR carbon fractions (E1+E2+E3-OP)', + 'epa_code': '88321', + }, + 'fAbs': { + 'name': 'filter_absorption_coeff', + 'long_name': 'Filter Absorption Coefficient', + 'comments': 'A calibrated absorption coefficient measured from a Teflon filter using a hybrid integrating plate and sphere (HIPS) method', + 'epa_code': '63102', + }, + 'FlowRate': { + 'name': 'flow_rate', + 'long_name': 'Flow Rate', + 'comments': 'The rate of air flow through an air sampling instrument', + 'epa_code': '63102', + }, + 'MF': { + 'name': 'mass_pm2_5', + 'long_name': 'Mass, PM2.5 (Fine)', + 'comments': 'Gravimetric mass measurement for particles with aerodynamic diameters less than 2.5 um', + 'epa_code': '88101', + }, + 'MT': { + 'name': 'mass_pm10', + 'long_name': 'Mass, PM10 (Total)', + 'comments': 'Gravimetric mass measurement for particles with aerodynamic diameters less than 10 um', + 'epa_code': '85101', + }, + 'SampDur': { + 'name': 'sample_duration', + 'long_name': 'Sampling Duration', + 'comments': 'The duration of a given sampling period in minutes', + }, + 'ammNO3f': { + 'name': 'ammonium_nitrate_fine', + 'long_name': 'Ammonium Nitrate (Fine)', + 'comments': '1.29 x NO3f', + }, + 'ammSO4f': { + 'name': 'ammonium_sulfate_fine', + 'long_name': 'Ammonium Sulfate (Fine)', + 'comments': '1.375 x SO4f', + }, + 'OMCf': { + 'name': 'carbon_organic_mass_fine', + 'long_name': 'Carbon, Organic Mass (fine)(1.8*OC)', + 'comments': '1.8 X OCf', + }, + 'TCf': { + 'name': 'carbon_total_fine', + 'long_name': 'Carbon, Total (fine)', + 'comments': 'From TOR carbon fractions (OCf+ECf)', + }, + 'CM_calculated': { + 'name': 'CM_calculated', + 'long_name': 'Mass, PM10-PM2.5 (Coarse)', + 'comments': 'MT-MF', + }, + 'SeaSaltf': { + 'name': 'sea_salt_fine', + 'long_name': 'Sea Salt (Fine)', + 'comments': '1.8XCHLf', + }, + 'SOILf': { + 'name': 'soil_fine', + 'long_name': 'Soil (Fine)', + 'comments': '2.2 × ALf + 2.49 × SIf + 1.63 × CAf + 2.42 × FEf + 1.94 × TIf', + }, + 'RCFM': { + 'name': 'mass_pm2_5_reconstructed', + 'long_name': 'Mass, PM2.5 Reconstructed (Fine)', + 'comments': 'Sum of ammSO4f, ammNO3f, OMCf, ECf, soilf, and seasaltf.', + }, + 'RCTM': { + 'name': 'mass_pmi10_reconstructed', + 'long_name': 'Mass, PM10 Reconstructed (Total)', + 'comments': 'Sum of ammSO4f, ammNO3f, OMCf, ECf, soilf, seasaltf, and CM_calculated.', + }, + } + laser_vars = { + 'RefF': { + 'units': 'ratio', + 'comments': 'Final laser reflectance at ', + 'name': 'final_laser_reflectance_', + }, + 'TransF': { + 'units': 'ratio', + 'comments': 'Final laser transmittance at ', + 'name': 'final_laser_transmittance_', + }, + 'RefI': { + 'units': 'ratio', + 'comments': 'Initial laser reflectance at ', + 'name': 'initial_laser_reflectance_', + }, + 'TransI': { + 'units': 'ratio', + 'comments': 'Initial laser transmittance at ', + 'name': 'initial_laser_transmittance_', + }, + 'RefM': { + 'units': 'ratio', + 'comments': 'Minimum laser reflectance at ', + 'name': 'min_laser_reflectance_', + }, + 'TransM': { + 'units': 'ratio', + 'comments': ' Minimum laser transmittance at ', + 'name': 'min_laser_transmittance_', + }, + 'OP_TR': { + 'units': 'ug m-3', + 'comments': 'Organic Pyrolyzed Carbon by Reflectance at ', + 'name': 'organic_pyrolyzed_carbon_reflectance_', + }, + 'OP_TT': { + 'units': 'ug m-3', + 'comments': 'Organic Pyrolyzed Carbon by Transmittance at ', + 'name': 'organic_pyrolyzed_carbon_transmittance_', + }, + } + laser_wl = ['405', '445', '532', '635', '780', '808', '980'] + for v in laser_vars: + for wl in laser_wl: + name = laser_vars[v]['name'] + wl + if 'OP' not in v: + mapping['_'.join([v, wl])] = { + 'units': laser_vars[v]['units'], + 'name': name, + 'long_name': ' '.join([laser_vars[v]['comments'], wl]), + } + else: + var_name = wl.join(v.split('_')) + mapping[var_name] = { + 'units': laser_vars[v]['units'], + 'name': name, + 'long_name': ' '.join([laser_vars[v]['comments'], wl]), + } + + # Run through each variable in the dataframe and add it to a dataset + # along with the appropriate metadata + ct = 0 + site = np.unique(df.Site)[0] + attrs = {'url': base_url, 'datastream': site + ' IMPROVE'} + for v in variables: + # Find data for just the variable in question + poc_attrs = {'units': '1', 'long_name': 'Parameter Occurrence Code for ' + v} + df2 = df[df.Param == v] + + # Get metadata + unit = np.unique(df2.UnitAbbr) + if len(unit) > 1: + raise ValueError('Multiple types of units detected, using first one') + + sites = np.unique(df2.Site) + if len(sites) > 1: + raise ValueError('Multiple sites detected, please use only one') + + # Get time, POC, and data + time = pd.to_datetime(df2.FactDate) + poc = df2.POC + + data = df2.FactValue + + # Set up attributes + var_attrs = {'units': unit[0], 'long_name': mapping[v]['long_name'], '_FillValue': -999.0} + if 'comments' in mapping[v]: + var_attrs['comments'] = mapping[v]['comments'] + if 'epa_code' in mapping[v]: + var_attrs['epa_code'] = mapping[v]['epa_code'] + + # If the first variable, create the dataset and then add variables to it + if ct == 0: + ds = xr.Dataset( + data_vars={mapping[v]['name']: (['time'], data, var_attrs)}, + coords={'time': time}, + attrs=attrs, + ) + ds['poc_' + mapping[v]['name']] = xr.DataArray( + data=poc, dims=['time'], coords={'time': time}, attrs=poc_attrs + ) + ct += 1 + else: + ds[mapping[v]['name']] = xr.DataArray( + data=data, dims=['time'], coords={'time': time}, attrs=var_attrs + ) + ds['poc_' + mapping[v]['name']] = xr.DataArray( + data=poc, dims=['time'], coords={'time': time}, attrs=poc_attrs + ) + + # Add in metadata from site summary page + url = 'https://views.cira.colostate.edu/adms/Pub/SiteSummary.aspx?dsidse=10001&siidse=' + str( + site_id + ) + df = pd.read_html(url) + for i in df[0].index: + # Add lat/lon as variables + if df[0][0][i] == 'Latitude': + attrs = { + 'long_name': 'North latitude', + 'units': 'degree_N', + 'valid_min': -90.0, + 'valid_max': 90.0, + 'standard_name': 'latitude', + } + ds['lat'] = xr.DataArray( + data=float(df[0][1][i]), + dims=['time'], + coords={'time': ds['time'].values}, + attrs=attrs, + ) + elif df[0][0][i] == 'Longitude': + attrs = { + 'long_name': 'East longitude', + 'units': 'degree_E', + 'valid_min': -180.0, + 'valid_max': 180.0, + 'standard_name': 'longitude', + } + ds['lon'] = xr.DataArray( + data=float(df[0][1][i]), + dims=['time'], + coords={'time': ds['time'].values}, + attrs=attrs, + ) + else: + ds.attrs[df[0][0][i]] = df[0][1][i] + + # Add in problem information from the site summary page + problem = '' + for i in df[-1].index: + problem += '_'.join( + [df[-1]['EventDate'][i], df[-1]['EventType'][i], df[-1]['Notes'][i], '\n'] + ) + ds.attrs['site_problems'] = problem + + return ds diff --git a/act/discovery/neon.py b/act/discovery/neon.py index cfe3eff2c1..13251bd888 100644 --- a/act/discovery/neon.py +++ b/act/discovery/neon.py @@ -7,7 +7,6 @@ """ -import json import requests import os import shutil diff --git a/act/discovery/noaapsl.py b/act/discovery/noaapsl.py index 30b55ff2c2..3239731bf4 100644 --- a/act/discovery/noaapsl.py +++ b/act/discovery/noaapsl.py @@ -2,10 +2,8 @@ Function for downloading data from NOAA PSL Profiler Network """ -import json from datetime import datetime import pandas as pd -import numpy as np import os try: @@ -14,8 +12,9 @@ from urllib import urlopen -def download_noaa_psl_data(site=None, instrument=None, startdate=None, enddate=None, - hour=None, output=None): +def download_noaa_psl_data( + site=None, instrument=None, startdate=None, enddate=None, hour=None, output=None +): """ Function to download data from the NOAA PSL Profiler Network Data Library https://psl.noaa.gov/data/obs/datadisplay/ @@ -76,9 +75,18 @@ def download_noaa_psl_data(site=None, instrument=None, startdate=None, enddate=N url = 'https://downloads.psl.noaa.gov/psd2/data/realtime/' # Set list of strings that all point to the surface meteorology dataset - met_ds = ['Pressure', 'Datalogger', 'Net Radiation', 'Temp/RH', - 'Solar Radiation', 'Tipping Bucket', 'TBRG', 'Wind Speed', - 'Wind Direction', 'Wind Speed and Direction'] + met_ds = [ + 'Pressure', + 'Datalogger', + 'Net Radiation', + 'Temp/RH', + 'Solar Radiation', + 'Tipping Bucket', + 'TBRG', + 'Wind Speed', + 'Wind Direction', + 'Wind Speed and Direction', + ] # Add to the url depending on which instrument is requested if 'Parsivel' in instrument: @@ -153,8 +161,9 @@ def download_noaa_psl_data(site=None, instrument=None, startdate=None, enddate=N # Write each file out to a file with same name as online for f in files: if hour is not None: - if (str(doy).zfill(3) + str(hour)) not in f and\ - (str(doy).zfill(3) + '.' + str(hour)) not in f: + if (str(doy).zfill(3) + str(hour)) not in f and ( + str(doy).zfill(3) + '.' + str(hour) + ) not in f: continue output_file = os.path.join(output_dir, f) try: diff --git a/act/discovery/surfrad.py b/act/discovery/surfrad.py index c6ba6fd356..23f5e3e05a 100644 --- a/act/discovery/surfrad.py +++ b/act/discovery/surfrad.py @@ -3,13 +3,8 @@ NOAA Surface Radiation Budget network """ -import json from datetime import datetime -import pandas as pd -import numpy as np import os -import re -import requests try: from urllib.request import urlopen diff --git a/act/io/__init__.py b/act/io/__init__.py index 93a6b913ef..9e391d20f2 100644 --- a/act/io/__init__.py +++ b/act/io/__init__.py @@ -7,7 +7,18 @@ __getattr__, __dir__, __all__ = lazy.attach( __name__, - submodules=['arm', 'text', 'icartt', 'mpl', 'neon', 'noaagml', 'noaapsl', 'pysp2'], + submodules=[ + 'arm', + 'ameriflux', + 'text', + 'icartt', + 'mpl', + 'neon', + 'noaagml', + 'noaapsl', + 'pysp2', + 'hysplit', + ], submod_attrs={ 'arm': [ 'WriteDataset', @@ -17,6 +28,7 @@ 'check_if_tar_gz_file', 'read_arm_mmcr', ], + 'ameriflux': ['convert_to_ameriflux'], 'text': ['read_csv'], 'icartt': ['read_icartt'], 'mpl': ['proc_sigma_mplv5_read', 'read_sigma_mplv5'], @@ -39,5 +51,6 @@ ], 'pysp2': ['read_hk_file', 'read_sp2', 'read_sp2_dat'], 'sodar': ['read_mfas_sodar'], + 'hysplit': ['read_hysplit'], }, ) diff --git a/act/io/ameriflux.py b/act/io/ameriflux.py new file mode 100644 index 0000000000..0bfb63aa35 --- /dev/null +++ b/act/io/ameriflux.py @@ -0,0 +1,181 @@ +""" +This module contains I/O operations for the U.S. Department of Energy +AmeriFlux program (https://ameriflux.lbl.gov/). +""" + +import numpy as np +import pandas as pd +import warnings + + +def convert_to_ameriflux( + ds, + variable_mapping=None, + soil_mapping=None, + depth_profile=[2.5, 5, 10, 15, 20, 30, 35, 50, 75, 100], + include_missing_variables=False, + **kwargs, +): + """ + + Returns `xarray.Dataset` with stored data and metadata from a user-defined + query of ARM-standard netCDF files from a single datastream. Has some procedures + to ensure time is correctly fomatted in returned Dataset. + + Parameters + ---------- + ds : xarray.Dataset + Dataset of data to convert to AmeriFlux format + variable_mapping : dict + Dictionary of variables mappings. The key should be the name of the variable + in the Dataset with the values being dictionaries of the AmeriFlux name and units. + For example: + var_mapping = { + 'co2_flux': {'name': 'FC', 'units': 'umol/(m^2 s)'}, + } + soil_mapping : dict + Dictionary of soil variables mappings following the same formatting as variable_mapping. + It is understood that the AmeriFlux name may be the same for some variables. This + script attempts to automatically name these measurements. If a variable is not dimensioned + by a depth nor has a sensor_height attribute, it will automatically assume that it's + at the first depth in the depth_profile variable. + depth_profile : list + List of depths that the variables will be mapped to. If a depth is not in this list, + the index chosen will be the one closest to the depth value. + include_missing_variables : boolean + If there variables that are completely missing (-9999) chose whether or not to include + them in the DataFrame. + + Returns + ------- + df : pandas.DataFrame (or None) + Returns a pandas dataframe for easy writing to csv + + """ + # Use ARM variable mappings if none provided + if variable_mapping is None: + warnings.warn('Variable mapping was not provided, using default ARM mapping') + # Define variable mapping and units + # The key is the variable name in the data and the name in the dictionary + # is the AmeriFlux Name + var_mapping = { + 'co2_flux': {'name': 'FC', 'units': 'umol/(m^2 s)'}, + 'co2_molar_fraction': {'name': 'CO2', 'units': 'nmol/mol'}, + 'co2_mixing_ratio': {'name': 'CO2_MIXING_RATIO', 'units': 'umol/mol'}, + 'h2o_mole_fraction': {'name': 'H2O', 'units': 'mmol/mol'}, + 'h2o_mixing_ratio': {'name': 'H2O_MIXING_RATIO', 'units': 'mmol/mol'}, + 'ch4_mole_fraction': {'name': 'CH4', 'units': 'nmol/mol'}, + 'ch4_mixing_ratio': {'name': 'CH4_MIXING_RATIO', 'units': 'nmol/mol'}, + 'momentum_flux': {'name': 'TAU', 'units': 'kg/(m s^2)'}, + 'sensible_heat_flux': {'name': 'H', 'units': 'W/m^2'}, + 'latent_flux': {'name': 'LE', 'units': 'W/m^2'}, + 'air_temperature': {'name': 'TA', 'units': 'deg C'}, + 'air_pressure': {'name': 'PA', 'units': 'kPa'}, + 'relative_humidity': {'name': 'RH', 'units': '%'}, + 'sonic_temperature': {'name': 'T_SONIC', 'units': 'deg C'}, + 'water_vapor_pressure_defecit': {'name': 'VPD', 'units': 'hPa'}, + 'Monin_Obukhov_length': {'name': 'MO_LENGTH', 'units': 'm'}, + 'Monin_Obukhov_stability_parameter': {'name': 'ZL', 'units': ''}, + 'mean_wind': {'name': 'WS', 'units': 'm/s'}, + 'wind_direction_from_north': {'name': 'WD', 'units': 'deg'}, + 'friction_velocity': {'name': 'USTAR', 'units': 'm/s'}, + 'maximum_instantaneous_wind_speed': {'name': 'WS_MAX', 'units': 'm/s'}, + 'down_short_hemisp': {'name': 'SW_IN', 'units': 'W/m^2'}, + 'up_short_hemisp': {'name': 'SW_OUT', 'units': 'W/m^2'}, + 'down_long': {'name': 'LW_IN', 'units': 'W/m^2'}, + 'up_long': {'name': 'LW_OUT', 'units': 'W/m^2'}, + 'albedo': {'name': 'ALB', 'units': '%'}, + 'net_radiation': {'name': 'NETRAD', 'units': 'W/m^2'}, + 'par_inc': {'name': 'PPFD_IN', 'units': 'umol/(m^2 s)'}, + 'par_ref': {'name': 'PPFD_OUT', 'units': 'umol/(m^2 s)'}, + 'precip': {'name': 'P', 'units': 'mm'}, + } + + # Use ARM variable mappings if none provided + # Similar to the above. This has only been tested on the ARM + # ECOR, SEBS, STAMP, and AMC combined. The automated naming may + # not work for all cases + if soil_mapping is None: + warnings.warn('Soil variable mapping was not provided, using default ARM mapping') + soil_mapping = { + 'surface_soil_heat_flux': {'name': 'G', 'units': 'W/m^2'}, + 'soil_temp': {'name': 'TS', 'units': 'deg C'}, + 'temp': {'name': 'TS', 'units': 'deg C'}, + 'soil_moisture': {'name': 'SWC', 'units': '%'}, + 'soil_specific_water_content': {'name': 'SWC', 'units': '%'}, + 'vwc': {'name': 'SWC', 'units': '%'}, + } + + # Loop through variables and update units to the AmeriFlux standard + for v in ds: + if v in var_mapping: + ds = ds.utils.change_units(variables=v, desired_unit=var_mapping[v]['units']) + + # Get start/end time stamps + ts_start = ds['time'].dt.strftime('%Y%m%d%H%M').values + ts_end = [ + pd.to_datetime(t + np.timedelta64(30, 'm')).strftime('%Y%m%d%H%M') + for t in ds['time'].values + ] + data = {} + data['TIMESTAMP_START'] = ts_start + data['TIMESTAMP_END'] = ts_end + + # Loop through the variables in the var mapping dictionary and add data to dictionary + for v in var_mapping: + if v in ds: + if 'missing_value' not in ds[v].attrs: + ds[v].attrs['missing_value'] = -9999 + if np.all(ds[v].isnull()): + if include_missing_variables: + data[var_mapping[v]['name']] = ds[v].values + else: + data[var_mapping[v]['name']] = ds[v].values + else: + if include_missing_variables: + data[var_mapping[v]['name']] = np.full(ds['time'].shape, -9999) + + # Automated naming for the soil variables + # Again, this may not work for other cases. Careful review is needed. + prev_var = '' + for var in soil_mapping: + if soil_mapping[var]['name'] != prev_var: + h = 1 + r = 1 + prev_var = soil_mapping[var]['name'] + soil_vars = [ + v2 + for v2 in list(ds) + if (v2.startswith(var)) & ('std' not in v2) & ('qc' not in v2) & ('net' not in v2) + ] + for i, svar in enumerate(soil_vars): + vert = 1 + if ('avg' in svar) | ('average' in svar): + continue + soil_data = ds[svar].values + data_shape = soil_data.shape + if len(data_shape) > 1: + coords = ds[svar].coords + depth_name = list(coords)[-1] + depth_values = ds[depth_name].values + for depth_ind in range(len(depth_values)): + soil_data_depth = soil_data[:, depth_ind] + vert = np.where(depth_profile == depth_values[depth_ind])[0][0] + 1 + new_name = '_'.join([soil_mapping[var]['name'], str(h), str(vert), str(r)]) + data[new_name] = soil_data_depth + else: + if 'sensor_height' in ds[svar].attrs: + sensor_ht = ds[svar].attrs['sensor_height'].split(' ') + depth = abs(float(sensor_ht[0])) + units = sensor_ht[1] + if units == 'cm': + vert = np.argmin(np.abs(np.array(depth_profile) - depth)) + 1 + new_name = '_'.join([soil_mapping[var]['name'], str(h), str(vert), str(r)]) + data[new_name] = soil_data + h += 1 + + # Convert dictionary to dataframe and return + df = pd.DataFrame(data) + df = df.fillna(-9999.0) + + return df diff --git a/act/io/arm.py b/act/io/arm.py index 8f9aa38ed4..e501726a4d 100644 --- a/act/io/arm.py +++ b/act/io/arm.py @@ -248,7 +248,7 @@ def read_arm_netcdf( file_dates.append(pts[2]) file_times.append(pts[3]) else: - if ds['time'].size > 1: + if len(ds['time'].shape) > 0: dummy = ds['time'].values[0] else: dummy = ds['time'].values @@ -767,6 +767,9 @@ def write_netcdf( ] ) + if 'time_bounds' in encoding.keys(): + encoding['time_bounds']['dtype'] = 'float64' + if hasattr(write_ds, 'time_bounds') and not write_ds.time.encoding: write_ds.time.encoding.update(write_ds.time_bounds.encoding) diff --git a/act/io/hysplit.py b/act/io/hysplit.py new file mode 100644 index 0000000000..ebd53b001f --- /dev/null +++ b/act/io/hysplit.py @@ -0,0 +1,136 @@ +import xarray as xr +import numpy as np +import pandas as pd + +from datetime import datetime + + +def read_hysplit(filename, base_year=2000, skiprows=1): + """ + Reads an input HYSPLIT trajectory for plotting in ACT. + + Parameters + ---------- + filename: str + The input file name. + base_year: int + The first year of the century in which the data are contained. + skiprows: int + Skip this number of rows after the header when reading. + + Returns + ------- + ds: xarray Dataset + The ACT dataset containing the HYSPLIT trajectories + """ + + ds = xr.Dataset({}) + num_lines = 0 + with open(filename) as filebuf: + num_grids = int(filebuf.readline().split()[0]) + num_lines += 1 + grid_times = [] + grid_names = [] + forecast_hours = np.zeros(num_grids) + for i in range(num_grids): + data = filebuf.readline().split() + num_lines += 1 + grid_names.append(data[0]) + grid_times.append( + datetime( + year=(int(data[1]) + base_year), + month=int(data[2]), + day=int(data[3]), + hour=int(data[4]), + ) + ) + forecast_hours[i] = int(data[5]) + ds["grid_forecast_hour"] = xr.DataArray(forecast_hours, dims=["num_grids"]) + ds["grid_forecast_hour"].attrs["standard_name"] = "Grid forecast hour" + ds["grid_forecast_hour"].attrs["units"] = "Hour [UTC]" + ds["grid_times"] = xr.DataArray(np.array(grid_times), dims=["num_grids"]) + data_line = filebuf.readline().split() + num_lines += 1 + ds.attrs["trajectory_direction"] = data_line[1] + ds.attrs["vertical_motion_calculation_method"] = data_line[2] + num_traj = int(data_line[0]) + traj_times = [] + start_lats = np.zeros(num_traj) + start_lons = np.zeros(num_traj) + start_alt = np.zeros(num_traj) + for i in range(num_traj): + data = filebuf.readline().split() + num_lines += 1 + traj_times.append( + datetime( + year=(base_year + int(data[0])), + month=int(data[1]), + day=int(data[2]), + hour=int(data[3]), + ) + ) + start_lats[i] = float(data[4]) + start_lons[i] = float(data[5]) + start_alt[i] = float(data[6]) + + ds["start_latitude"] = xr.DataArray(start_lats, dims=["num_trajectories"]) + ds["start_latitude"].attrs["long_name"] = "Trajectory start latitude" + ds["start_latitude"].attrs["units"] = "degree" + ds["start_longitude"] = xr.DataArray(start_lats, dims=["num_trajectories"]) + ds["start_longitude"].attrs["long_name"] = "Trajectory start longitude" + ds["start_longitude"].attrs["units"] = "degree" + ds["start_altitude"] = xr.DataArray(start_alt, dims=["num_trajectories"]) + ds["start_altitude"].attrs["long_name"] = "Trajectory start altitude" + ds["start_altitude"].attrs["units"] = "degree" + data = filebuf.readline().split() + num_lines += 1 + var_list = [ + "trajectory_number", + "grid_number", + "year", + "month", + "day", + "hour", + "minute", + "forecast_hour", + "age", + "lat", + "lon", + "alt", + ] + for variable in data[1:]: + var_list.append(variable) + + input_df = pd.read_csv( + filebuf, sep=r'\s+', index_col=False, names=var_list, skiprows=skiprows + ) # noqa W605 + input_df['year'] = base_year + input_df['year'] + input_df['year'] = input_df['year'].astype(int) + input_df['month'] = input_df['month'].astype(int) + input_df['day'] = input_df['day'].astype(int) + input_df['hour'] = input_df['hour'].astype(int) + input_df['minute'] = input_df['minute'].astype(int) + input_df['time'] = pd.to_datetime( + input_df[["year", "month", "day", "hour", "minute"]], format='%y%m%d%H%M' + ) + input_df = input_df.set_index("time") + del input_df["year"] + del input_df["month"] + del input_df["day"] + del input_df["hour"] + del input_df["minute"] + ds = ds.merge(input_df.to_xarray()) + ds.attrs['datastream'] = 'hysplit' + ds["trajectory_number"].attrs["standard_name"] = "Trajectory number" + ds["trajectory_number"].attrs["units"] = "1" + ds["grid_number"].attrs["standard_name"] = "Grid number" + ds["grid_number"].attrs["units"] = "1" + ds["age"].attrs["standard_name"] = "Grid number" + ds["age"].attrs["units"] = "1" + ds["lat"].attrs["standard_name"] = "Latitude" + ds["lat"].attrs["units"] = "degree" + ds["lon"].attrs["standard_name"] = "Longitude" + ds["lon"].attrs["units"] = "degree" + ds["alt"].attrs["standard_name"] = "Altitude" + ds["alt"].attrs["units"] = "meter" + return ds diff --git a/act/io/icartt.py b/act/io/icartt.py index 6f4911dca6..8e434b311b 100644 --- a/act/io/icartt.py +++ b/act/io/icartt.py @@ -7,7 +7,6 @@ - https://www.earthdata.nasa.gov/s3fs-public/imported/ESDS-RFC-029v2.pdf """ -import numpy as np import xarray as xr import datetime import warnings @@ -16,6 +15,7 @@ try: import icartt + _ICARTT_AVAILABLE = True _format = icartt.Formats.FFI1001 except ImportError: @@ -23,8 +23,7 @@ _format = None -def read_icartt(filename, format=_format, - return_None=False, **kwargs): +def read_icartt(filename, format=_format, return_None=False, **kwargs): """ Returns `xarray.Dataset` with stored data and metadata from a user-defined @@ -60,8 +59,7 @@ def read_icartt(filename, format=_format, """ if not _ICARTT_AVAILABLE: - raise ImportError( - "ICARTT is required to use to read ICARTT files but is not installed") + raise ImportError("ICARTT is required to use to read ICARTT files but is not installed") ds = None @@ -82,8 +80,7 @@ def read_icartt(filename, format=_format, return None # If requested return None for File not found error - if (type(exception).__name__ == 'OSError' - and exception.args[0] == 'no files to open'): + if type(exception).__name__ == 'OSError' and exception.args[0] == 'no files to open': return None # Define the Uncertainty for each variable. Note it may not be calculated. @@ -110,9 +107,7 @@ def read_icartt(filename, format=_format, key2 = 'quality_flag' else: key2 = key - da = xr.DataArray(ict.data[key], - coords=dict(time=ict.times), - name=key2, dims=['time']) + da = xr.DataArray(ict.data[key], coords=dict(time=ict.times), name=key2, dims=['time']) # Assume if Uncertainity does not match the number of variables, # values were not set within the file. Needs to be string! if len(uncertainty) != len(ict.variables): diff --git a/act/io/neon.py b/act/io/neon.py index 86d9bbd3eb..a5d1befa54 100644 --- a/act/io/neon.py +++ b/act/io/neon.py @@ -2,9 +2,7 @@ Modules for reading in NOAA PSL data. """ -import datetime as dt -import numpy as np import pandas as pd import xarray as xr @@ -84,9 +82,18 @@ def read_neon_csv(files, variable_files=None, position_files=None): dloc = loc_df.loc[loc_df['HOR.VER'] == hor_loc + '.' + ver_loc] idx = dloc.index.values if len(idx) > 0: - ds['lat'] = xr.DataArray(data=float(loc_df['referenceLatitude'].values[idx])) - ds['lon'] = xr.DataArray(data=float(loc_df['referenceLongitude'].values[idx])) - ds['alt'] = xr.DataArray(data=float(loc_df['referenceElevation'].values[idx])) + if len(loc_df['referenceLatitude'].values) > 1: + ds['lat'] = xr.DataArray(data=float(loc_df['referenceLatitude'].values[idx][0])) + ds['lon'] = xr.DataArray( + data=float(loc_df['referenceLongitude'].values[idx][0]) + ) + ds['alt'] = xr.DataArray( + data=float(loc_df['referenceElevation'].values[idx][0]) + ) + else: + ds['lat'] = xr.DataArray(data=float(loc_df['referenceLatitude'].values[idx])) + ds['lon'] = xr.DataArray(data=float(loc_df['referenceLongitude'].values[idx])) + ds['alt'] = xr.DataArray(data=float(loc_df['referenceElevation'].values[idx])) variables = [ 'xOffset', 'yOffset', @@ -100,7 +107,10 @@ def read_neon_csv(files, variable_files=None, position_files=None): 'yAzimuth', ] for v in variables: - ds[v] = xr.DataArray(data=float(loc_df[v].values[idx])) + if len(loc_df[v].values) > 1: + ds[v] = xr.DataArray(data=float(loc_df[v].values[idx][0])) + else: + ds[v] = xr.DataArray(data=float(loc_df[v].values[idx])) multi_ds.append(ds) ds = xr.merge(multi_ds) diff --git a/act/io/noaapsl.py b/act/io/noaapsl.py index a5e2da5e46..8fb4099514 100644 --- a/act/io/noaapsl.py +++ b/act/io/noaapsl.py @@ -188,7 +188,7 @@ def _parse_psl_wind_lines(filepath, lines, line_offset=0): beam_elevation = np.array([beam_elevation1, beam_elevation2, beam_elevation3], dtype='float32') # Read in the data table section using pandas - df = pd.read_csv(filepath, skiprows=line_offset + 10, delim_whitespace=True) + df = pd.read_csv(filepath, skiprows=line_offset + 10, sep=r'\s+') # Only read in the number of rows for a given set of gates df = df.iloc[: int(number_of_range_gates)] @@ -326,7 +326,7 @@ def _parse_psl_temperature_lines(filepath, lines, line_offset=0): beam_azimuth, beam_elevation = filter_list(lines[8].split(' ')).astype(float) # Read in the data table section using pandas - df = pd.read_csv(filepath, skiprows=line_offset + 10, delim_whitespace=True) + df = pd.read_csv(filepath, skiprows=line_offset + 10, sep=r'\s+') # Only read in the number of rows for a given set of gates df = df.iloc[: int(number_of_gates)] @@ -1115,7 +1115,7 @@ def _parse_psl_radar_moments(files): f, skiprows=[0, 1, 2], nrows=int(data['n_gates']['data'][-1]) - 1, - delim_whitespace=True, + sep=r'\s+', names=list(names.keys()), ) index2 = 0 @@ -1143,7 +1143,7 @@ def _parse_psl_radar_moments(files): f, skiprows=list(range(index2 + 1)), nrows=int(data['n_gates']['data'][-1]) - 1, - delim_whitespace=True, + sep=r'\s+', names=list(names.keys()), ) diff --git a/act/io/sodar.py b/act/io/sodar.py index 15dc238f45..ec5c83f70c 100644 --- a/act/io/sodar.py +++ b/act/io/sodar.py @@ -74,11 +74,9 @@ def read_mfas_sodar(filepath): # Parse data to a dataframe skipping rows that aren't data. # tmp_columns is used to removed '#' column that causes # columns to move over by one. - df = pd.read_table(filepath, - sep=r'\s+', - skiprows=skip_full_ind, - names=tmp_columns, - usecols=columns) + df = pd.read_table( + filepath, sep=r'\s+', skiprows=skip_full_ind, names=tmp_columns, usecols=columns + ) df = df[~df['W'].isin(['dir'])].reset_index(drop=True) @@ -158,7 +156,7 @@ def _metadata_retrieval(lines): file_type_ind = np.argwhere(line_array == '# file type')[0][0] # Index the section of file information. - file_def = line_array[file_info_ind + 2:file_type_ind - 1] + file_def = line_array[file_info_ind + 2 : file_type_ind - 1] # Create a dictionary of file information to be plugged in later to the xarray # dataset attributes. @@ -179,7 +177,7 @@ def _metadata_retrieval(lines): data_ind = np.argwhere(line_array == '# beginning of data block')[0][0] # Index the section of variable information. - variable_def = line_array[variable_info_ind + 2 :data_ind - 1] + variable_def = line_array[variable_info_ind + 2 : data_ind - 1] # Create a dictionary of variable information to be plugged in later to the xarray # variable attributes. Skipping error code as it does not have metadata similar to diff --git a/act/plotting/__init__.py b/act/plotting/__init__.py index 68547a9a3c..1e8bad1732 100644 --- a/act/plotting/__init__.py +++ b/act/plotting/__init__.py @@ -17,10 +17,10 @@ import lazy_loader as lazy # Load colormaps -import cmweather +import cmweather # noqa # Eagerly load in common -from . import common +from . import common # noqa __getattr__, __dir__, __all__ = lazy.attach( __name__, @@ -45,6 +45,6 @@ 'timeseriesdisplay': ['TimeSeriesDisplay'], 'windrosedisplay': ['WindRoseDisplay'], 'xsectiondisplay': ['XSectionDisplay'], - 'distributiondisplay' : ['DistributionDisplay'], + 'distributiondisplay': ['DistributionDisplay'], }, ) diff --git a/act/plotting/distributiondisplay.py b/act/plotting/distributiondisplay.py index 0dec535c43..5cb967b265 100644 --- a/act/plotting/distributiondisplay.py +++ b/act/plotting/distributiondisplay.py @@ -5,7 +5,7 @@ import xarray as xr import pandas as pd -from ..utils import datetime_utils as dt_utils +from ..utils import datetime_utils as dt_utils, calculate_percentages from .plot import Display @@ -184,7 +184,8 @@ def plot_stacked_bar( ydata.values.flatten(), density=density, bins=[bins, sortby_bins], - **hist_kwargs) + **hist_kwargs, + ) x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 self.axes[subplot_index].bar( x_inds, @@ -202,8 +203,9 @@ def plot_stacked_bar( ) self.axes[subplot_index].legend() else: - my_hist, bins = np.histogram(xdata.values.flatten(), bins=bins, - density=density, **hist_kwargs) + my_hist, bins = np.histogram( + xdata.values.flatten(), bins=bins, density=density, **hist_kwargs + ) x_inds = (bins[:-1] + bins[1:]) / 2.0 self.axes[subplot_index].bar(x_inds, my_hist) @@ -322,7 +324,9 @@ def plot_size_distribution( ) if time is not None: t = pd.Timestamp(time) - set_title += ''.join([' at ', ':'.join([str(t.hour), str(t.minute), str(t.second)])]) + set_title += ''.join( + [' at ', ':'.join([str(t.hour), str(t.minute), str(t.second)])] + ) self.axes[subplot_index].set_title(set_title) self.axes[subplot_index].step(bins.values, xdata.values, **kwargs) self.axes[subplot_index].set_xlabel(xtitle) @@ -425,7 +429,7 @@ def plot_stairstep( ydata.values.flatten(), density=density, bins=[bins, sortby_bins], - **hist_kwargs + **hist_kwargs, ) x_inds = (x_bins[:-1] + x_bins[1:]) / 2.0 self.axes[subplot_index].step( @@ -443,8 +447,9 @@ def plot_stairstep( ) self.axes[subplot_index].legend() else: - my_hist, bins = np.histogram(xdata.values.flatten(), bins=bins, - density=density, **hist_kwargs) + my_hist, bins = np.histogram( + xdata.values.flatten(), bins=bins, density=density, **hist_kwargs + ) x_inds = (bins[:-1] + bins[1:]) / 2.0 self.axes[subplot_index].step(x_inds, my_hist, **kwargs) @@ -575,15 +580,15 @@ def plot_heatmap( if x_bins is None: my_hist, x_bins, y_bins = np.histogram2d( - xdata.values.flatten(), ydata.values.flatten(), density=density, - **hist_kwargs) + xdata.values.flatten(), ydata.values.flatten(), density=density, **hist_kwargs + ) else: my_hist, x_bins, y_bins = np.histogram2d( xdata.values.flatten(), ydata.values.flatten(), density=density, bins=[x_bins, y_bins], - **hist_kwargs + **hist_kwargs, ) # Adding in the ability to threshold the heatmaps if threshold is not None: @@ -616,7 +621,7 @@ def plot_heatmap( return return_dict - def set_ratio_line(self, subplot_index=(0, )): + def set_ratio_line(self, subplot_index=(0,)): """ Sets the 1:1 ratio line. @@ -633,16 +638,17 @@ def set_ratio_line(self, subplot_index=(0, )): ratio = np.linspace(xlims, xlims[-1]) self.axes[subplot_index].plot(ratio, ratio, 'k--') - def plot_scatter(self, - x_field, - y_field, - m_field=None, - dsname=None, - cbar_label=None, - set_title=None, - subplot_index=(0,), - **kwargs, - ): + def plot_scatter( + self, + x_field, + y_field, + m_field=None, + dsname=None, + cbar_label=None, + set_title=None, + subplot_index=(0,), + **kwargs, + ): """ This procedure will produce a scatter plot from 2 variables. @@ -745,18 +751,19 @@ def plot_scatter(self, return self.axes[subplot_index] - def plot_violin(self, - field, - positions=None, - dsname=None, - vert=True, - showmeans=True, - showmedians=True, - showextrema=True, - subplot_index=(0,), - set_title=None, - **kwargs, - ): + def plot_violin( + self, + field, + positions=None, + dsname=None, + vert=True, + showmeans=True, + showmedians=True, + showextrema=True, + subplot_index=(0,), + set_title=None, + **kwargs, + ): """ This procedure will produce a violin plot for the selected field (or fields). @@ -819,14 +826,15 @@ def plot_violin(self, axtitle = field # Display the scatter plot, pass keyword args for unspecified attributes - scc = self.axes[subplot_index].violinplot(ndata, - positions=positions, - vert=vert, - showmeans=showmeans, - showmedians=showmedians, - showextrema=showextrema, - **kwargs - ) + scc = self.axes[subplot_index].violinplot( + ndata, + positions=positions, + vert=vert, + showmeans=showmeans, + showmedians=showmedians, + showextrema=showextrema, + **kwargs, + ) if showmeans is True: scc['cmeans'].set_edgecolor('red') scc['cmeans'].set_label('mean') @@ -855,3 +863,98 @@ def plot_violin(self, self.axes[subplot_index].set_yticks([]) return self.axes[subplot_index] + + def plot_pie_chart( + self, + fields, + time=None, + time_slice=None, + threshold=None, + fill_value=0.0, + dsname=None, + subplot_index=(0,), + set_title=None, + autopct='%1.1f%%', + **kwargs, + ): + """ + This procedure will produce a pie chart for the selected fields. + + Parameters + ---------- + fields : list + The list of fields to calculate percentages on for the pie chart. + time : datetime + A single datetime to be passed into the act.utils.calculate percentages function + if desired. Default is None and all data will be included. + time_slice : tuple + A tuple of two datetimes to grab all data between those two datetimes for + act.utils.calculate_percentages. Default is None and all data will be included. + threshold : float + Threshold in which anything below will be considered invalid. + Default is None. + fill_value : float + Fill value for invalid data. Only used if a threshold is provided. + dsname : str or None + The name of the datastream the field is contained in. Set + to None to let ACT automatically determine this. + subplot_index : tuple + The subplot index to place the plot in + set_title : str + The title of the plot. + autopct : str + Format string for the percentages. Default is float with one + decimal place. If this parameter is set to None, no percentage + string values are displayed. + **kwargs : keywords + Keywords to pass through to :func:`matplotlib.pyplot.pie`. + + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle of the plot + + """ + if dsname is None and len(self._ds.keys()) > 1: + raise ValueError( + 'You must choose a datastream when there are 2 ' + + 'or more datasets in the DistributionDisplay ' + + 'object.' + ) + elif dsname is None: + dsname = list(self._ds.keys())[0] + + # Get the current plotting axis + if self.fig is None: + self.fig = plt.figure() + if self.axes is None: + self.axes = np.array([plt.axes()]) + self.fig.add_axes(self.axes[0]) + + # Set Title + if set_title is None: + set_title = ' '.join( + [ + dsname, + 'on', + dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + ] + ) + self.axes[subplot_index].set_title(set_title) + + percentages = calculate_percentages( + self._ds[dsname], + fields, + time=time, + time_slice=time_slice, + threshold=threshold, + fill_value=fill_value, + ) + + self.axes[subplot_index].pie( + [percentages[field] for field in percentages.keys()], + labels=percentages.keys(), + autopct=autopct, + **kwargs, + ) + return self.axes[subplot_index] diff --git a/act/plotting/geodisplay.py b/act/plotting/geodisplay.py index b01d425b43..297689e2b4 100644 --- a/act/plotting/geodisplay.py +++ b/act/plotting/geodisplay.py @@ -3,7 +3,6 @@ """ -import warnings import matplotlib import matplotlib.pyplot as plt @@ -122,6 +121,11 @@ def geoplot( is made. See the matplotlib documentation for further details on what keyword arguments are available. + Returns + ------- + ax : matplotlib axis handle + The matplotlib axis handle of the plot. + """ if dsname is None and len(self._ds.keys()) > 1: raise ValueError( diff --git a/act/plotting/plot.py b/act/plotting/plot.py index 0d5a31eca1..9dfc15c5de 100644 --- a/act/plotting/plot.py +++ b/act/plotting/plot.py @@ -71,8 +71,7 @@ class with this set to None will create a new figure handle. See the """ - def __init__(self, ds, subplot_shape=(1,), ds_name=None, subplot_kw=None, - **kwargs): + def __init__(self, ds, subplot_shape=(1,), ds_name=None, subplot_kw=None, **kwargs): if isinstance(ds, xr.Dataset): if 'datastream' in ds.attrs.keys() is not None: self._ds = {ds.attrs['datastream']: ds} @@ -122,8 +121,7 @@ def __init__(self, ds, subplot_shape=(1,), ds_name=None, subplot_kw=None, if subplot_shape is not None: self.add_subplots(subplot_shape, subplot_kw=subplot_kw, **kwargs) - def add_subplots(self, subplot_shape=(1,), secondary_y=False, subplot_kw=None, - **kwargs): + def add_subplots(self, subplot_shape=(1,), secondary_y=False, subplot_kw=None, **kwargs): """ Adds subplots to the Display object. The current figure in the object will be deleted and overwritten. @@ -235,8 +233,9 @@ def assign_to_figure_axis(self, fig, ax): self.fig = fig self.axes = np.array([ax]) - def add_colorbar(self, mappable, title=None, subplot_index=(0,), pad=None, - width=None, **kwargs): + def add_colorbar( + self, mappable, title=None, subplot_index=(0,), pad=None, width=None, **kwargs + ): """ Adds a colorbar to the plot. @@ -301,7 +300,7 @@ def group_by(self, units): return DisplayGroupby(self, units) -class DisplayGroupby(object): +class DisplayGroupby: def __init__(self, display, units): """ @@ -348,8 +347,7 @@ def plot_group(self, func_name, dsname=None, **kwargs): func = getattr(self.display, func_name) if not callable(func): - raise RuntimeError("The specified string is not a function of " - "the Display object.") + raise RuntimeError("The specified string is not a function of " "the Display object.") subplot_shape = self.display.axes.shape i = 0 @@ -382,18 +380,25 @@ def plot_group(self, func_name, dsname=None, **kwargs): days_in_year = 365 year_diff = ds1.time.dt.year - first_year time_diff = np.array( - [np.timedelta64(x * days_in_year, 'D') for x in year_diff.values]) + [np.timedelta64(x * days_in_year, 'D') for x in year_diff.values] + ) ds1['time'] = ds1.time - time_diff self.display._ds[key + '%d_%d' % (k, yr)] = ds1 func(dsname=key + '%d_%d' % (k, yr), label=str(yr), **kwargs) self.mapping[key + '%d_%d' % (k, yr)] = subplot_index - self.xlims[key + '%d_%d' % (k, yr)] = (ds1.time.values.min(), ds1.time.values.max()) + self.xlims[key + '%d_%d' % (k, yr)] = ( + ds1.time.values.min(), + ds1.time.values.max(), + ) del self.display._ds[key + '_%d' % k] else: func(dsname=key + '_%d' % k, **kwargs) self.mapping[key + '_%d' % k] = subplot_index if self.isTimeSeriesDisplay: - self.xlims[key + '_%d' % k] = (ds.time.values.min(), ds.time.values.max()) + self.xlims[key + '_%d' % k] = ( + ds.time.values.min(), + ds.time.values.max(), + ) i = i + 1 if wrap_around is False and i < np.prod(subplot_shape): diff --git a/act/plotting/skewtdisplay.py b/act/plotting/skewtdisplay.py index 36190cf457..6fab52ce42 100644 --- a/act/plotting/skewtdisplay.py +++ b/act/plotting/skewtdisplay.py @@ -3,7 +3,6 @@ """ -import warnings from copy import deepcopy import matplotlib.pyplot as plt @@ -56,8 +55,7 @@ def __init__(self, ds, subplot_shape=(1,), subplot=None, ds_name=None, set_fig=N # We want to use our routine to handle subplot adding, not the main # one new_kwargs = kwargs.copy() - super().__init__(ds, None, ds_name, subplot_kw=dict(projection='skewx'), - **new_kwargs) + super().__init__(ds, None, ds_name, subplot_kw=dict(projection='skewx'), **new_kwargs) # Make a SkewT object for each subplot self.add_subplots(subplot_shape, set_fig=set_fig, subplot=subplot, **kwargs) @@ -354,7 +352,9 @@ def plot_from_u_and_v( if not all(p[i] <= p[i + 1] for i in range(len(p) - 1)): if 'time' in self._ds: self._ds[dsname][p_field] = ( - self._ds[dsname][p_field].rolling(time=smooth_p, min_periods=1, center=True).mean() + self._ds[dsname][p_field] + .rolling(time=smooth_p, min_periods=1, center=True) + .mean() ) p = self._ds[dsname][p_field] @@ -450,7 +450,9 @@ def plot_from_u_and_v( self.SkewT[subplot_index].plot_dry_adiabats(pressure=plp, t0=t0, **dry_adiabats_kwargs) if plot_moist_adiabats: - self.SkewT[subplot_index].plot_moist_adiabats(t0=t0, pressure=plp, **moist_adiabats_kwargs) + self.SkewT[subplot_index].plot_moist_adiabats( + t0=t0, pressure=plp, **moist_adiabats_kwargs + ) if plot_mixing_lines: self.SkewT[subplot_index].plot_mixing_lines(pressure=plp, **mixing_lines_kwargs) @@ -458,7 +460,7 @@ def plot_from_u_and_v( # Set Title if set_title is None: if 'time' in self._ds[dsname]: - title_time = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), + title_time = (dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]),) elif '_file_dates' in self._ds[dsname].attrs: title_time = self._ds[dsname].attrs['_file_dates'][0] else: diff --git a/act/plotting/timeseriesdisplay.py b/act/plotting/timeseriesdisplay.py index 70aee57dce..45f321aa08 100644 --- a/act/plotting/timeseriesdisplay.py +++ b/act/plotting/timeseriesdisplay.py @@ -151,7 +151,9 @@ def day_night_background(self, dsname=None, subplot_index=(0,)): for value, name in zip(lat_lon_list, ['Latitude', 'Longitude']): if not np.isfinite(value): - warnings.warn(f"{name} value in dataset equal to '{value}' is not finite. ", RuntimeWarning) + warnings.warn( + f"{name} value in dataset equal to '{value}' is not finite. ", RuntimeWarning + ) return lat = lat_lon_list[0] @@ -196,7 +198,7 @@ def day_night_background(self, dsname=None, subplot_index=(0,)): for ii in noon: ax.axvline(x=ii, linestyle='--', color='y', zorder=1) - def set_xrng(self, xrng, subplot_index=(0, 0)): + def set_xrng(self, xrng, subplot_index=(0,)): """ Sets the x range of the plot. @@ -215,15 +217,20 @@ def set_xrng(self, xrng, subplot_index=(0, 0)): # This is to catch that and expand the range so we avoid the warning. if xrng[0] == xrng[1]: if isinstance(xrng[0], np.datetime64): - print(f'\nAttempting to set xlim range to single value {xrng[0]}. ' - 'Expanding range by 2 seconds.\n') + print( + f'\nAttempting to set xlim range to single value {xrng[0]}. ' + 'Expanding range by 2 seconds.\n' + ) xrng[0] -= np.timedelta64(1, 's') xrng[1] += np.timedelta64(1, 's') elif isinstance(xrng[0], dt.datetime): - print(f'\nAttempting to set xlim range to single value {xrng[0]}. ' - 'Expanding range by 2 seconds.\n') + print( + f'\nAttempting to set xlim range to single value {xrng[0]}. ' + 'Expanding range by 2 seconds.\n' + ) xrng[0] -= dt.timedelta(seconds=1) xrng[1] += dt.timedelta(seconds=1) + self.axes[subplot_index].set_xlim(xrng) # Make sure that the xrng value is a numpy array not pandas @@ -312,7 +319,7 @@ def plot( cbar_h_adjust=None, y_axis_flag_meanings=False, colorbar_labels=None, - cb_friendly=False, + cvd_friendly=False, match_line_label_color=False, **kwargs, ): @@ -405,8 +412,8 @@ def plot( 1: {'text': 'Liquid', 'color': 'green'}, 2: {'text': 'Ice', 'color': 'blue'}, 3: {'text': 'Mixed phase', 'color': 'purple'}} - cb_friendly : boolean - Set to true if you want to use the integrated colorblind friendly + cvd_friendly : boolean + Set to true if you want to use the integrated color vision deficiency (CVD) friendly colors for green/red based on the Homeyer colormap. match_line_label_color : boolean Will set the y label to match the line color in the plot. This @@ -433,12 +440,24 @@ def plot( if y_axis_flag_meanings: kwargs['linestyle'] = '' - if cb_friendly: + if cvd_friendly: cmap = 'HomeyerRainbow' - assessment_overplot_category_color['Bad'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) - assessment_overplot_category_color['Incorrect'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) - assessment_overplot_category_color['Not Failing'] = (0.0, 0.4240129715562796, 0.4240129715562796), - assessment_overplot_category_color['Acceptable'] = (0.0, 0.4240129715562796, 0.4240129715562796), + assessment_overplot_category_color['Bad'] = ( + 0.9285714285714286, + 0.7130901016453677, + 0.7130901016453677, + ) + assessment_overplot_category_color['Incorrect'] = ( + 0.9285714285714286, + 0.7130901016453677, + 0.7130901016453677, + ) + assessment_overplot_category_color['Not Failing'] = ( + (0.0, 0.4240129715562796, 0.4240129715562796), + ) + assessment_overplot_category_color['Acceptable'] = ( + (0.0, 0.4240129715562796, 0.4240129715562796), + ) # Get data and dimensions data = self._ds[dsname][field] @@ -633,9 +652,7 @@ def plot( ] ) else: - date_result = search( - r'\d{4}-\d{1,2}-\d{1,2}', self._ds[dsname].time.attrs['units'] - ) + date_result = search(r'\d{4}-\d{1,2}-\d{1,2}', self._ds[dsname].time.attrs['units']) if date_result is not None: set_title = ' '.join([dsname, field, 'on', date_result.group(0)]) else: @@ -833,6 +850,8 @@ def plot_barbs_from_u_v( invert_y_axis=True, num_barbs_x=20, num_barbs_y=20, + barb_step_x=None, + barb_step_y=None, use_var_for_y=None, **kwargs, ): @@ -866,6 +885,12 @@ def plot_barbs_from_u_v( The number of wind barbs to plot in the x axis. num_barbs_y : int The number of wind barbs to plot in the y axis. + barb_step_x : int + Step between each wind barb to plot. If set, will override + values given for num_barbs_x + barb_step_y : int + Step between each wind barb to plot. If set, will override + values given for num_barbs_y cmap : matplotlib.colors.LinearSegmentedColormap A color map to use with wind barbs. If this is set the plt.barbs routine will be passed the C parameter scaled as sqrt of sum of the @@ -902,8 +927,9 @@ def plot_barbs_from_u_v( v = self._ds[dsname][v_field].values dim = list(self._ds[dsname][u_field].dims) xdata = self._ds[dsname][dim[0]].values - num_x = xdata.shape[-1] - barb_step_x = round(num_x / num_barbs_x) + if barb_step_x is None: + num_x = xdata.shape[-1] + barb_step_x = round(num_x / num_barbs_x) if barb_step_x == 0: barb_step_x = 1 @@ -920,8 +946,9 @@ def plot_barbs_from_u_v( else: units = '' ytitle = ''.join(['(', units, ')']) - num_y = ydata.shape[0] - barb_step_y = round(num_y / num_barbs_y) + if barb_step_y is None: + num_y = ydata.shape[0] + barb_step_y = round(num_y / num_barbs_y) if barb_step_y == 0: barb_step_y = 1 @@ -1183,9 +1210,7 @@ def plot_time_height_xsection_from_1d_data( ax = self.axes[subplot_index] - mesh = ax.pcolormesh( - x_times, y_levels, np.transpose(data), shading=set_shading, **kwargs - ) + mesh = ax.pcolormesh(x_times, y_levels, np.transpose(data), shading=set_shading, **kwargs) if day_night_background is True: self.day_night_background(subplot_index=subplot_index, dsname=dsname) @@ -1263,7 +1288,7 @@ def time_height_scatter( cb_label=None, subplot_index=(0,), plot_alt_field=False, - cb_friendly=False, + cvd_friendly=False, day_night_background=False, set_title=None, **kwargs, @@ -1294,7 +1319,7 @@ def time_height_scatter( The index of the subplot to set the x range of. plot_alt_field : boolean Set to true to plot the altitude field on the secondary y-axis - cb_friendly : boolean + cvd_friendly : boolean If set to True will use the Homeyer colormap day_night_background : boolean If set to True will plot the day_night_background @@ -1324,7 +1349,7 @@ def time_height_scatter( self.axes = np.array([plt.axes()]) self.fig.add_axes(self.axes[0]) - if cb_friendly: + if cvd_friendly: cmap = 'HomeyerRainbow' ax = self.axes[subplot_index] @@ -1366,9 +1391,7 @@ def time_height_scatter( ] ) else: - date_result = search( - r'\d{4}-\d{1,2}-\d{1,2}', self._ds[dsname].time.attrs['units'] - ) + date_result = search(r'\d{4}-\d{1,2}-\d{1,2}', self._ds[dsname].time.attrs['units']) if date_result is not None: set_title = ' '.join([dsname, data_field, 'on', date_result.group(0)]) else: @@ -1423,7 +1446,7 @@ def qc_flag_block_plot( assessment_color=None, edgecolor='face', set_shading='auto', - cb_friendly=False, + cvd_friendly=False, **kwargs, ): """ @@ -1452,8 +1475,8 @@ def qc_flag_block_plot( set_shading : string Option to to set the matplotlib.pcolormesh shading parameter. Default to 'auto' - cb_friendly : boolean - Set to true if you want to use the integrated colorblind friendly + cvd_friendly : boolean + Set to true if you want to use the integrated color vision deficiency (CVD) friendly colors for green/red based on the Homeyer colormap **kwargs : keyword arguments The keyword arguments for :func:`plt.broken_barh`. @@ -1469,7 +1492,7 @@ def qc_flag_block_plot( 'Not Failing': 'green', 'Acceptable': 'green', } - if cb_friendly: + if cvd_friendly: color_lookup['Bad'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) color_lookup['Incorrect'] = (0.9285714285714286, 0.7130901016453677, 0.7130901016453677) color_lookup['Not Failing'] = (0.0, 0.4240129715562796, 0.4240129715562796) @@ -1594,7 +1617,6 @@ def qc_flag_block_plot( yvalues = self._ds[dsname][dims[1]].values cMap = mplcolors.ListedColormap(plot_colors) - print(plot_colors) mesh = ax.pcolormesh( xvalues, yvalues, @@ -1646,7 +1668,6 @@ def qc_flag_block_plot( ) else: - test_nums = [] for ii, assess in enumerate(flag_assessments): if assess not in color_lookup: @@ -1664,9 +1685,7 @@ def qc_flag_block_plot( # Get test number from flag_mask bitpacked number test_nums.append(parse_bit(flag_masks[ii])) # Get masked array data to use mask for finding if/where test is set - data = self._ds[dsname].qcfilter.get_masked_data( - data_field, rm_tests=test_nums[-1] - ) + data = self._ds[dsname].qcfilter.get_masked_data(data_field, rm_tests=test_nums[-1]) if np.any(data.mask): # Get time ranges from time and masked data barh_list = reduce_time_ranges( diff --git a/act/plotting/windrosedisplay.py b/act/plotting/windrosedisplay.py index ef128c2ccc..fe99f41c62 100644 --- a/act/plotting/windrosedisplay.py +++ b/act/plotting/windrosedisplay.py @@ -36,8 +36,7 @@ class and has therefore has the same attributes as that class. """ def __init__(self, ds, subplot_shape=(1,), ds_name=None, **kwargs): - super().__init__(ds, subplot_shape, ds_name, subplot_kw=dict(projection='polar'), - **kwargs) + super().__init__(ds, subplot_shape, ds_name, subplot_kw=dict(projection='polar'), **kwargs) def set_thetarng(self, trng=(0.0, 360.0), subplot_index=(0,)): """ @@ -223,18 +222,14 @@ def plot( **kwargs, ) ) - ax.legend( - loc=legend_loc, bbox_to_anchor=legend_bbox, title=legend_title - ) + ax.legend(loc=legend_loc, bbox_to_anchor=legend_bbox, title=legend_title) ax.set_theta_zero_location('N') ax.set_theta_direction(-1) # Add an annulus with text stating % of time calm pct_calm = np.sum(spd_data <= calm_threshold) / len(spd_data) * 100 ax.set_rorigin(-2.5) - ax.annotate( - '%3.2f%%\n calm' % pct_calm, xy=(0, -2.5), ha='center', va='center' - ) + ax.annotate('%3.2f%%\n calm' % pct_calm, xy=(0, -2.5), ha='center', va='center') # Set the ticks to be nice numbers tick_max = tick_interval * round(np.nanmax(np.cumsum(wind_hist, axis=1)) / tick_interval) @@ -353,10 +348,10 @@ def plot_data( for i, d in enumerate(dir_bins_mid): if i < len(dir_bins_mid) - 1: idx = np.where((dir_data > d) & (dir_data <= dir_bins_mid[i + 1]))[0] - bins.append(d + (dir_bins_mid[i + 1] - d) / 2.) + bins.append(d + (dir_bins_mid[i + 1] - d) / 2.0) else: - idx = np.where((dir_data > d) & (dir_data <= 360.))[0] - bins.append(d + (360. - d) / 2.) + idx = np.where((dir_data > d) & (dir_data <= 360.0))[0] + bins.append(d + (360.0 - d) / 2.0) if plot_type == 'line': if line_plot_calc == 'mean': @@ -398,8 +393,12 @@ def plot_data( ) hist = np.insert(hist, -1, hist[0], axis=0) cplot = self.axes[subplot_index].contourf( - np.deg2rad(xedges), yedges[0:-1], np.transpose(hist), - cmap=cmap, levels=clevels, **kwargs + np.deg2rad(xedges), + yedges[0:-1], + np.transpose(hist), + cmap=cmap, + levels=clevels, + **kwargs, ) plot_type_str = 'Heatmap of' cbar = self.fig.colorbar(cplot, ax=self.axes[subplot_index]) @@ -447,8 +446,13 @@ def plot_data( clevels = np.linspace(vmin, vmax, clevels) cplot = self.axes[subplot_index].contourf( - np.deg2rad(bins), spd_bins, np.transpose(mean_data), - cmap=cmap, levels=clevels, extend='both', **kwargs + np.deg2rad(bins), + spd_bins, + np.transpose(mean_data), + cmap=cmap, + levels=clevels, + extend='both', + **kwargs, ) plot_type_str = 'Mean of' cbar = self.fig.colorbar(cplot, ax=self.axes[subplot_index]) @@ -461,8 +465,8 @@ def plot_data( self.axes[subplot_index].set_theta_direction(-1) # Set Title - sdate = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]), - edate = dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[-1]), + sdate = (dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[0]),) + edate = (dt_utils.numpy_to_arm_date(self._ds[dsname].time.values[-1]),) if sdate == edate: date_str = 'on ' + sdate[0] @@ -474,13 +478,7 @@ def plot_data( units = '' if set_title is None: set_title = ' '.join( - [ - plot_type_str, - data_field + ' (' + units + ')', - 'by\n', - dir_field, - date_str - ] + [plot_type_str, data_field + ' (' + units + ')', 'by\n', dir_field, date_str] ) self.axes[subplot_index].set_title(set_title) plt.tight_layout(h_pad=1.05) diff --git a/act/plotting/xsectiondisplay.py b/act/plotting/xsectiondisplay.py index d989594c0c..0538e8d08d 100644 --- a/act/plotting/xsectiondisplay.py +++ b/act/plotting/xsectiondisplay.py @@ -75,6 +75,7 @@ def __init__(self, ds, subplot_shape=(1,), ds_name=None, **kwargs): super().__init__(ds, subplot_shape, ds_name, **kwargs) def set_subplot_to_map(self, subplot_index): + self.fig.delaxes(self.axes[subplot_index]) total_num_plots = self.axes.shape if len(total_num_plots) == 2: @@ -235,9 +236,9 @@ def plot_xsection( yc = y if x is None: - ax = my_dataarray.plot(ax=self.axes[subplot_index], **kwargs) + my_dataarray.plot(ax=self.axes[subplot_index], **kwargs) else: - ax = my_dataarray.plot(ax=self.axes[subplot_index], x=xc, y=yc, **kwargs) + my_dataarray.plot(ax=self.axes[subplot_index], x=xc, y=yc, **kwargs) the_coords = [the_keys for the_keys in my_dataarray.coords.keys()] if x is None: @@ -255,7 +256,7 @@ def plot_xsection( yrng = self.axes[subplot_index].get_ylim() self.set_yrng(yrng, subplot_index) del temp_ds - return ax + return self.axes[subplot_index] def plot_xsection_map( self, dsname, varname, subplot_index=(0,), coastlines=True, background=False, **kwargs @@ -290,7 +291,6 @@ def plot_xsection_map( raise ImportError( 'Cartopy needs to be installed in order to plot ' + 'cross sections on maps!' ) - self.set_subplot_to_map(subplot_index) self.plot_xsection(dsname, varname, subplot_index=subplot_index, **kwargs) xlims = self.xrng[subplot_index].flatten() diff --git a/act/qc/__init__.py b/act/qc/__init__.py index df8a866305..2b043494fd 100644 --- a/act/qc/__init__.py +++ b/act/qc/__init__.py @@ -12,8 +12,10 @@ 'add_supplemental_qc', 'arm', 'bsrn_tests', + 'clean', 'comparison_tests', 'qcfilter', + 'qc_summary', 'qctests', 'radiometer_tests', 'sp2', @@ -26,9 +28,11 @@ 'set_bit', 'unset_bit', ], + 'qc_summary': ['QCSummary'], 'qctests': [ 'QCTests', ], + 'clean': ['CleanDataset'], 'radiometer_tests': [ 'fft_shading_test', 'fft_shading_test_process', diff --git a/act/qc/add_supplemental_qc.py b/act/qc/add_supplemental_qc.py index 2d94f15a2d..21e463bc94 100644 --- a/act/qc/add_supplemental_qc.py +++ b/act/qc/add_supplemental_qc.py @@ -2,7 +2,6 @@ import numpy as np from pathlib import Path from dateutil import parser -from os import environ # Example of the YAML file and how to construct. # The times are set as inclusive start to inclusive end time. @@ -66,9 +65,8 @@ def read_yaml_supplemental_qc( datetime64=True, time_delim=(';', ',', '|', r'\t'), none_if_empty=True, - quiet=False + quiet=False, ): - """ Returns a dictionary converstion of YAML file for flagging data. The dictionary will contain variable names as first key, assessents as second keys containing @@ -136,7 +134,8 @@ def read_yaml_supplemental_qc( except KeyError: raise RuntimeError( 'Unable to determine datastream name from Dataset. Need to set global attribute ' - '_datastream in Dataset or provided full path to flag file.') + '_datastream in Dataset or provided full path to flag file.' + ) flag_file = list(Path(fullpath).glob(f'{datastream}.yml')) flag_file.extend(list(Path(fullpath).glob(f'{datastream}.yaml'))) @@ -164,7 +163,7 @@ def read_yaml_supplemental_qc( assessments = [ii.capitalize() for ii in assessments] # Read YAML file - with open(flag_file, "r") as fp: + with open(flag_file) as fp: try: data_dict = yaml.load(fp, Loader=yaml.FullLoader) except AttributeError: @@ -230,9 +229,8 @@ def apply_supplemental_qc( assessments=None, apply_all=True, exclude_all_variables=None, - quiet=False + quiet=False, ): - """ Apply flagging from supplemental QC file by adding new QC tests. @@ -284,7 +282,8 @@ def apply_supplemental_qc( exclude_vars.extend(exclude_all_variables) flag_dict = read_yaml_supplemental_qc( - ds, fullpath, variables=variables, assessments=assessments, quiet=quiet) + ds, fullpath, variables=variables, assessments=assessments, quiet=quiet + ) if flag_dict is None: return @@ -301,7 +300,8 @@ def apply_supplemental_qc( indexes = np.array([], dtype=np.int32) for vals in times: ind = np.argwhere( - (ds['time'].values >= vals[0]) & (ds['time'].values <= vals[1])) + (ds['time'].values >= vals[0]) & (ds['time'].values <= vals[1]) + ) if len(ind) > 0: indexes = np.append(indexes, ind) @@ -311,7 +311,8 @@ def apply_supplemental_qc( var_name, index=indexes, test_meaning=description, - test_assessment=asses_name) + test_assessment=asses_name, + ) var_name = '_all' if apply_all and var_name in flag_dict.keys(): @@ -325,7 +326,8 @@ def apply_supplemental_qc( indexes = np.array([], dtype=np.int32) for vals in times: ind = np.argwhere( - (ds['time'].values >= vals[0]) & (ds['time'].values <= vals[1])) + (ds['time'].values >= vals[0]) & (ds['time'].values <= vals[1]) + ) if ind.size > 0: indexes = np.append(indexes, np.ndarray.flatten(ind)) @@ -347,4 +349,5 @@ def apply_supplemental_qc( all_var_name, index=indexes, test_meaning=description, - test_assessment=asses_name) + test_assessment=asses_name, + ) diff --git a/act/qc/arm.py b/act/qc/arm.py index 0fb84597d4..bf323e77ac 100644 --- a/act/qc/arm.py +++ b/act/qc/arm.py @@ -93,8 +93,10 @@ def add_dqr_to_qc( raise ValueError('Dataset does not have datastream attribute') if datastream == DEFAULT_DATASTREAM_NAME: - raise ValueError("'datastream' name required for DQR service set to default value " - f"{datastream}. Unable to perform DQR service query.") + raise ValueError( + "'datastream' name required for DQR service set to default value " + f"{datastream}. Unable to perform DQR service query." + ) # Clean up QC to conform to CF conventions if cleanup_qc: @@ -163,8 +165,10 @@ def add_dqr_to_qc( } if dqr_link: - print(f"{dqr_number} - {quality_category.lower().capitalize()}: " - f"https://adc.arm.gov/ArchiveServices/DQRService?dqrid={dqr_number}") + print( + f"{dqr_number} - {quality_category.lower().capitalize()}: " + f"https://adc.arm.gov/ArchiveServices/DQRService?dqrid={dqr_number}" + ) # Check to ensure variable is list if variable and not isinstance(variable, (list, tuple)): @@ -173,7 +177,6 @@ def add_dqr_to_qc( loc_vars = ['lat', 'lon', 'alt', 'latitude', 'longitude', 'altitude'] for key, value in dqr_results.items(): for var_name in value['variables']: - # Do not process on location variables if skip_location_vars and var_name in loc_vars: continue @@ -182,12 +185,21 @@ def add_dqr_to_qc( if variable is not None and var_name not in variable: continue + # Do not process quality control variables as this will create a new + # quality control variable for the quality control varible. + try: + if ds[var_name].attrs['standard_name'] == 'quality_flag': + continue + except KeyError: + pass + try: ds.qcfilter.add_test( var_name, index=np.unique(value['index']), test_meaning=value['test_meaning'], - test_assessment=value['test_assessment']) + test_assessment=value['test_assessment'], + ) except KeyError: # Variable name not in Dataset continue diff --git a/act/qc/bsrn_tests.py b/act/qc/bsrn_tests.py index c585d01770..1e3c5e4ef4 100644 --- a/act/qc/bsrn_tests.py +++ b/act/qc/bsrn_tests.py @@ -45,11 +45,12 @@ def _calculate_solar_parameters(ds, lat_name, lon_name, solar_constant): # Calculate solar parameters elevation, _, solar_distance = get_solar_azimuth_elevation( - latitude=latitude, longitude=longitude, time=ds['time'].values) + latitude=latitude, longitude=longitude, time=ds['time'].values + ) solar_distance = np.nanmean(solar_distance) Sa = solar_constant / solar_distance**2 - sza = 90. - elevation + sza = 90.0 - elevation return (sza, Sa) @@ -117,9 +118,8 @@ def bsrn_limits_test( solar_constant=1366, lat_name='lat', lon_name='lon', - use_dask=False + use_dask=False, ): - """ Method to apply BSRN limits test and add results to ancillary quality control variable. Need to provide variable name for each measurement for the test to be performed. If no @@ -188,71 +188,88 @@ def bsrn_limits_test( test = test.lower() test_names = [ii.lower() for ii in test_names_org] if test not in test_names: - raise ValueError(f"Value of '{test}' in keyword 'test' not recognized. " - f"Must a single value in options {test_names_org}") + raise ValueError( + f"Value of '{test}' in keyword 'test' not recognized. " + f"Must a single value in options {test_names_org}" + ) sza, Sa = _calculate_solar_parameters(self._ds, lat_name, lon_name, solar_constant) if test == test_names[0]: if sw_min_limit is None: - sw_min_limit = -4. + sw_min_limit = -4.0 if lw_min_dn_limit is None: - lw_min_dn_limit = 40. + lw_min_dn_limit = 40.0 if lw_min_up_limit is None: - lw_min_up_limit = 40. + lw_min_up_limit = 40.0 if lw_max_dn_limit is None: - lw_max_dn_limit = 700. + lw_max_dn_limit = 700.0 if lw_max_up_limit is None: - lw_max_up_limit = 900. + lw_max_up_limit = 900.0 elif test == test_names[1]: if sw_min_limit is None: - sw_min_limit = -2. + sw_min_limit = -2.0 if lw_min_dn_limit is None: - lw_min_dn_limit = 60. + lw_min_dn_limit = 60.0 if lw_min_up_limit is None: - lw_min_up_limit = 60. + lw_min_up_limit = 60.0 if lw_max_dn_limit is None: - lw_max_dn_limit = 500. + lw_max_dn_limit = 500.0 if lw_max_up_limit is None: - lw_max_up_limit = 700. + lw_max_up_limit = 700.0 # Global Shortwave downwelling min and max tests if gbl_SW_dn_name is not None: cos_sza = np.cos(np.radians(sza)) - cos_sza[sza > 90.] = 0. + cos_sza[sza > 90.0] = 0.0 if test == test_names[0]: - sw_max_limit = Sa * 1.5 * cos_sza**1.2 + 100. + sw_max_limit = Sa * 1.5 * cos_sza**1.2 + 100.0 elif test == test_names[1]: - sw_max_limit = Sa * 1.2 * cos_sza**1.2 + 50. + sw_max_limit = Sa * 1.2 * cos_sza**1.2 + 50.0 - index_min, index_max = _find_indexes(self._ds, gbl_SW_dn_name, sw_min_limit, sw_max_limit, use_dask) + index_min, index_max = _find_indexes( + self._ds, gbl_SW_dn_name, sw_min_limit, sw_max_limit, use_dask + ) self._ds.qcfilter.add_test( - gbl_SW_dn_name, index=index_min, test_assessment='Bad', - test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + gbl_SW_dn_name, + index=index_min, + test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2", + ) self._ds.qcfilter.add_test( - gbl_SW_dn_name, index=index_max, test_assessment='Bad', - test_meaning=f"Value greater than BSRN {test.lower()} limit") + gbl_SW_dn_name, + index=index_max, + test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit", + ) # Diffuse Shortwave downwelling min and max tests if glb_diffuse_SW_dn_name is not None: with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=RuntimeWarning) if test == test_names[0]: - sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza))**1.2 + 50. + sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza)) ** 1.2 + 50.0 elif test == test_names[1]: - sw_max_limit = Sa * 0.75 * np.cos(np.radians(sza))**1.2 + 30. + sw_max_limit = Sa * 0.75 * np.cos(np.radians(sza)) ** 1.2 + 30.0 - index_min, index_max = _find_indexes(self._ds, glb_diffuse_SW_dn_name, sw_min_limit, - sw_max_limit, use_dask) + index_min, index_max = _find_indexes( + self._ds, glb_diffuse_SW_dn_name, sw_min_limit, sw_max_limit, use_dask + ) self._ds.qcfilter.add_test( - glb_diffuse_SW_dn_name, index=index_min, test_assessment='Bad', - test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + glb_diffuse_SW_dn_name, + index=index_min, + test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2", + ) self._ds.qcfilter.add_test( - glb_diffuse_SW_dn_name, index=index_max, test_assessment='Bad', - test_meaning=f"Value greater than BSRN {test.lower()} limit") + glb_diffuse_SW_dn_name, + index=index_max, + test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit", + ) # Direct Normal Shortwave downwelling min and max tests if direct_normal_SW_dn_name is not None: @@ -261,17 +278,24 @@ def bsrn_limits_test( if test == test_names[0]: sw_max_limit = Sa elif test == test_names[1]: - sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza))**0.2 + 10. + sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza)) ** 0.2 + 10.0 - index_min, index_max = _find_indexes(self._ds, direct_normal_SW_dn_name, - sw_min_limit, sw_max_limit, use_dask) + index_min, index_max = _find_indexes( + self._ds, direct_normal_SW_dn_name, sw_min_limit, sw_max_limit, use_dask + ) self._ds.qcfilter.add_test( - direct_normal_SW_dn_name, index=index_min, test_assessment='Bad', - test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + direct_normal_SW_dn_name, + index=index_min, + test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2", + ) self._ds.qcfilter.add_test( - direct_normal_SW_dn_name, index=index_max, test_assessment='Bad', - test_meaning=f"Value greater than BSRN {test.lower()} limit") + direct_normal_SW_dn_name, + index=index_max, + test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit", + ) # Direct Shortwave downwelling min and max tests if direct_SW_dn_name is not None: @@ -280,64 +304,92 @@ def bsrn_limits_test( if test == test_names[0]: sw_max_limit = Sa * np.cos(np.radians(sza)) elif test == test_names[1]: - sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza))**1.2 + 10 + sw_max_limit = Sa * 0.95 * np.cos(np.radians(sza)) ** 1.2 + 10 - index_min, index_max = _find_indexes(self._ds, direct_SW_dn_name, - sw_min_limit, sw_max_limit, use_dask) + index_min, index_max = _find_indexes( + self._ds, direct_SW_dn_name, sw_min_limit, sw_max_limit, use_dask + ) self._ds.qcfilter.add_test( - direct_SW_dn_name, index=index_min, test_assessment='Bad', - test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + direct_SW_dn_name, + index=index_min, + test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2", + ) self._ds.qcfilter.add_test( - direct_SW_dn_name, index=index_max, test_assessment='Bad', - test_meaning=f"Value greater than BSRN {test.lower()} limit") + direct_SW_dn_name, + index=index_max, + test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit", + ) # Shortwave up welling min and max tests if glb_SW_up_name is not None: with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=RuntimeWarning) if test == test_names[0]: - sw_max_limit = Sa * 1.2 * np.cos(np.radians(sza))**1.2 + 50 + sw_max_limit = Sa * 1.2 * np.cos(np.radians(sza)) ** 1.2 + 50 elif test == test_names[1]: - sw_max_limit = Sa * np.cos(np.radians(sza))**1.2 + 50 + sw_max_limit = Sa * np.cos(np.radians(sza)) ** 1.2 + 50 - index_min, index_max = _find_indexes(self._ds, glb_SW_up_name, - sw_min_limit, sw_max_limit, use_dask) + index_min, index_max = _find_indexes( + self._ds, glb_SW_up_name, sw_min_limit, sw_max_limit, use_dask + ) self._ds.qcfilter.add_test( - glb_SW_up_name, index=index_min, test_assessment='Bad', - test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2") + glb_SW_up_name, + index=index_min, + test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {sw_min_limit} W/m^2", + ) self._ds.qcfilter.add_test( - glb_SW_up_name, index=index_max, test_assessment='Bad', - test_meaning=f"Value greater than BSRN {test.lower()} limit") + glb_SW_up_name, + index=index_max, + test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit", + ) # Longwave downwelling min and max tests if glb_LW_dn_name is not None: - index_min, index_max = _find_indexes(self._ds, glb_LW_dn_name, - lw_min_dn_limit, lw_max_dn_limit, use_dask) + index_min, index_max = _find_indexes( + self._ds, glb_LW_dn_name, lw_min_dn_limit, lw_max_dn_limit, use_dask + ) self._ds.qcfilter.add_test( - glb_LW_dn_name, index=index_min, test_assessment='Bad', - test_meaning=f"Value less than BSRN {test.lower()} limit of {lw_min_dn_limit} W/m^2") + glb_LW_dn_name, + index=index_min, + test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {lw_min_dn_limit} W/m^2", + ) self._ds.qcfilter.add_test( - glb_LW_dn_name, index=index_max, test_assessment='Bad', - test_meaning=f"Value greater than BSRN {test.lower()} limit of {lw_max_dn_limit} W/m^2") + glb_LW_dn_name, + index=index_max, + test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit of {lw_max_dn_limit} W/m^2", + ) # Longwave upwelling min and max tests if glb_LW_up_name is not None: - index_min, index_max = _find_indexes(self._ds, glb_LW_up_name, - lw_min_up_limit, lw_max_up_limit, use_dask) + index_min, index_max = _find_indexes( + self._ds, glb_LW_up_name, lw_min_up_limit, lw_max_up_limit, use_dask + ) self._ds.qcfilter.add_test( - glb_LW_up_name, index=index_min, test_assessment='Bad', - test_meaning=f"Value less than BSRN {test.lower()} limit of {lw_min_up_limit} W/m^2") + glb_LW_up_name, + index=index_min, + test_assessment='Bad', + test_meaning=f"Value less than BSRN {test.lower()} limit of {lw_min_up_limit} W/m^2", + ) self._ds.qcfilter.add_test( - glb_LW_up_name, index=index_max, test_assessment='Bad', - test_meaning=f"Value greater than BSRN {test.lower()} limit of {lw_max_up_limit} W/m^2") + glb_LW_up_name, + index=index_max, + test_assessment='Bad', + test_meaning=f"Value greater than BSRN {test.lower()} limit of {lw_max_up_limit} W/m^2", + ) def bsrn_comparison_tests( self, @@ -352,9 +404,9 @@ def bsrn_comparison_tests( test_assessment='Indeterminate', lat_name='lat', lon_name='lon', - LWdn_lt_LWup_component=25., - LWdn_gt_LWup_component=300., - use_dask=False + LWdn_lt_LWup_component=25.0, + LWdn_gt_LWup_component=300.0, + use_dask=False, ): """ Method to apply BSRN comparison tests and add results to ancillary quality control variable. @@ -418,23 +470,36 @@ def bsrn_comparison_tests( if isinstance(test, str): test = [test] - test_options = ['Global over Sum SW Ratio', 'Diffuse Ratio', 'SW up', 'LW down to air temp', - 'LW up to air temp', 'LW down to LW up'] + test_options = [ + 'Global over Sum SW Ratio', + 'Diffuse Ratio', + 'SW up', + 'LW down to air temp', + 'LW up to air temp', + 'LW down to LW up', + ] solar_constant = 1360.8 sza, Sa = _calculate_solar_parameters(self._ds, lat_name, lon_name, solar_constant) # Ratio of Global over Sum SW if test_options[0] in test: - if gbl_SW_dn_name is None or glb_diffuse_SW_dn_name is None or direct_normal_SW_dn_name is None: - raise ValueError('Must set keywords gbl_SW_dn_name, glb_diffuse_SW_dn_name, ' - f'direct_normal_SW_dn_name for {test_options[0]} test.') + if ( + gbl_SW_dn_name is None + or glb_diffuse_SW_dn_name is None + or direct_normal_SW_dn_name is None + ): + raise ValueError( + 'Must set keywords gbl_SW_dn_name, glb_diffuse_SW_dn_name, ' + f'direct_normal_SW_dn_name for {test_options[0]} test.' + ) with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=RuntimeWarning) if use_dask and isinstance(self._ds[glb_diffuse_SW_dn_name].data, da.Array): - sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].data - + self._ds[direct_normal_SW_dn_name].data * np.cos(np.radians(sza))) + sum_sw_down = self._ds[glb_diffuse_SW_dn_name].data + self._ds[ + direct_normal_SW_dn_name + ].data * np.cos(np.radians(sza)) sum_sw_down[sum_sw_down < 50] = np.nan ratio = self._ds[gbl_SW_dn_name].data / sum_sw_down index_a = sza < 75 @@ -445,8 +510,9 @@ def bsrn_comparison_tests( index_4 = da.where((ratio < 0.85) & index_b, True, False) index = (index_1 | index_2 | index_3 | index_4).compute() else: - sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].values - + self._ds[direct_normal_SW_dn_name].values * np.cos(np.radians(sza))) + sum_sw_down = self._ds[glb_diffuse_SW_dn_name].values + self._ds[ + direct_normal_SW_dn_name + ].values * np.cos(np.radians(sza)) sum_sw_down[sum_sw_down < 50] = np.nan ratio = self._ds[gbl_SW_dn_name].values / sum_sw_down index_a = sza < 75 @@ -458,18 +524,32 @@ def bsrn_comparison_tests( index = index_1 | index_2 | index_3 | index_4 test_meaning = "Ratio of Global over Sum shortwave larger than expected" - self._ds.qcfilter.add_test(gbl_SW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) - self._ds.qcfilter.add_test(glb_diffuse_SW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) - self._ds.qcfilter.add_test(direct_normal_SW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) + self._ds.qcfilter.add_test( + gbl_SW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) + self._ds.qcfilter.add_test( + glb_diffuse_SW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) + self._ds.qcfilter.add_test( + direct_normal_SW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) # Diffuse Ratio if test_options[1] in test: if gbl_SW_dn_name is None or glb_diffuse_SW_dn_name is None: - raise ValueError('Must set keywords gbl_SW_dn_name, glb_diffuse_SW_dn_name ' - f'for {test_options[1]} test.') + raise ValueError( + 'Must set keywords gbl_SW_dn_name, glb_diffuse_SW_dn_name ' + f'for {test_options[1]} test.' + ) with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=RuntimeWarning) @@ -482,7 +562,9 @@ def bsrn_comparison_tests( index_2 = da.where((ratio >= 1.10) & index_b, True, False) index = (index_1 | index_2).compute() else: - ratio = self._ds[glb_diffuse_SW_dn_name].values / self._ds[gbl_SW_dn_name].values + ratio = ( + self._ds[glb_diffuse_SW_dn_name].values / self._ds[gbl_SW_dn_name].values + ) ratio[self._ds[gbl_SW_dn_name].values < 50] = np.nan index_a = sza < 75 index_1 = (ratio >= 1.05) & index_a @@ -491,104 +573,180 @@ def bsrn_comparison_tests( index = index_1 | index_2 test_meaning = "Ratio of Diffuse Shortwave over Global Shortwave larger than expected" - self._ds.qcfilter.add_test(gbl_SW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) - self._ds.qcfilter.add_test(glb_diffuse_SW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) + self._ds.qcfilter.add_test( + gbl_SW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) + self._ds.qcfilter.add_test( + glb_diffuse_SW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) # Shortwave up comparison if test_options[2] in test: - if glb_SW_up_name is None or glb_diffuse_SW_dn_name is None or direct_normal_SW_dn_name is None: - raise ValueError('Must set keywords glb_SW_up_name, glb_diffuse_SW_dn_name, ' - f'direct_normal_SW_dn_name for {test_options[2]} test.') + if ( + glb_SW_up_name is None + or glb_diffuse_SW_dn_name is None + or direct_normal_SW_dn_name is None + ): + raise ValueError( + 'Must set keywords glb_SW_up_name, glb_diffuse_SW_dn_name, ' + f'direct_normal_SW_dn_name for {test_options[2]} test.' + ) with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=RuntimeWarning) if use_dask and isinstance(self._ds[glb_diffuse_SW_dn_name].data, da.Array): - sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].data - + self._ds[direct_normal_SW_dn_name].data * np.cos(np.radians(sza))) + sum_sw_down = self._ds[glb_diffuse_SW_dn_name].data + self._ds[ + direct_normal_SW_dn_name + ].data * np.cos(np.radians(sza)) sum_sw_down[sum_sw_down < 50] = np.nan - index = da.where(self._ds[glb_SW_up_name].data > sum_sw_down, True, False).compute() + index = da.where( + self._ds[glb_SW_up_name].data > sum_sw_down, True, False + ).compute() else: - sum_sw_down = (self._ds[glb_diffuse_SW_dn_name].values - + self._ds[direct_normal_SW_dn_name].values * np.cos(np.radians(sza))) + sum_sw_down = self._ds[glb_diffuse_SW_dn_name].values + self._ds[ + direct_normal_SW_dn_name + ].values * np.cos(np.radians(sza)) sum_sw_down[sum_sw_down < 50] = np.nan index = self._ds[glb_SW_up_name].values > sum_sw_down test_meaning = "Ratio of Shortwave Upwelling greater than Shortwave Sum" - self._ds.qcfilter.add_test(glb_SW_up_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) - self._ds.qcfilter.add_test(glb_diffuse_SW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) - self._ds.qcfilter.add_test(direct_normal_SW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) + self._ds.qcfilter.add_test( + glb_SW_up_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) + self._ds.qcfilter.add_test( + glb_diffuse_SW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) + self._ds.qcfilter.add_test( + direct_normal_SW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) # Longwave down to air temperature comparison if test_options[3] in test: if glb_LW_dn_name is None or air_temp_name is None: - raise ValueError('Must set keywords glb_LW_dn_name, air_temp_name ' - f' for {test_options[3]} test.') - - air_temp = convert_units(self._ds[air_temp_name].values, - self._ds[air_temp_name].attrs['units'], 'degK') + raise ValueError( + 'Must set keywords glb_LW_dn_name, air_temp_name ' + f' for {test_options[3]} test.' + ) + + air_temp = convert_units( + self._ds[air_temp_name].values, self._ds[air_temp_name].attrs['units'], 'degK' + ) if use_dask and isinstance(self._ds[glb_LW_dn_name].data, da.Array): air_temp = da.array(air_temp) conversion = da.array(Stefan_Boltzmann * air_temp**4) index_1 = (0.4 * conversion) > self._ds[glb_LW_dn_name].data - index_2 = (conversion + 25.) < self._ds[glb_LW_dn_name].data + index_2 = (conversion + 25.0) < self._ds[glb_LW_dn_name].data index = (index_1 | index_2).compute() else: conversion = Stefan_Boltzmann * air_temp**4 index_1 = (0.4 * conversion) > self._ds[glb_LW_dn_name].values - index_2 = (conversion + 25.) < self._ds[glb_LW_dn_name].values + index_2 = (conversion + 25.0) < self._ds[glb_LW_dn_name].values index = index_1 | index_2 - test_meaning = "Longwave downwelling comparison to air temperature out side of expected range" - self._ds.qcfilter.add_test(glb_LW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) + test_meaning = ( + "Longwave downwelling comparison to air temperature out side of expected range" + ) + self._ds.qcfilter.add_test( + glb_LW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) # Longwave up to air temperature comparison if test_options[4] in test: if glb_LW_up_name is None or air_temp_name is None: - raise ValueError('Must set keywords glb_LW_up_name, air_temp_name ' - f'for {test_options[3]} test.') - - air_temp = convert_units(self._ds[air_temp_name].values, - self._ds[air_temp_name].attrs['units'], 'degK') + raise ValueError( + 'Must set keywords glb_LW_up_name, air_temp_name ' + f'for {test_options[3]} test.' + ) + + air_temp = convert_units( + self._ds[air_temp_name].values, self._ds[air_temp_name].attrs['units'], 'degK' + ) if use_dask and isinstance(self._ds[glb_LW_up_name].data, da.Array): air_temp = da.array(air_temp) - index_1 = (Stefan_Boltzmann * (air_temp - 15)**4) > self._ds[glb_LW_up_name].data - index_2 = (Stefan_Boltzmann * (air_temp + 25)**4) < self._ds[glb_LW_up_name].data + index_1 = (Stefan_Boltzmann * (air_temp - 15) ** 4) > self._ds[glb_LW_up_name].data + index_2 = (Stefan_Boltzmann * (air_temp + 25) ** 4) < self._ds[glb_LW_up_name].data index = (index_1 | index_2).compute() else: - index_1 = (Stefan_Boltzmann * (air_temp - 15)**4) > self._ds[glb_LW_up_name].values - index_2 = (Stefan_Boltzmann * (air_temp + 25)**4) < self._ds[glb_LW_up_name].values + index_1 = (Stefan_Boltzmann * (air_temp - 15) ** 4) > self._ds[ + glb_LW_up_name + ].values + index_2 = (Stefan_Boltzmann * (air_temp + 25) ** 4) < self._ds[ + glb_LW_up_name + ].values index = index_1 | index_2 - test_meaning = "Longwave upwelling comparison to air temperature out side of expected range" - self._ds.qcfilter.add_test(glb_LW_up_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) + test_meaning = ( + "Longwave upwelling comparison to air temperature out side of expected range" + ) + self._ds.qcfilter.add_test( + glb_LW_up_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) # Lonwave down to longwave up comparison if test_options[5] in test: if glb_LW_dn_name is None or glb_LW_up_name is None: - raise ValueError('Must set keywords glb_LW_dn_name, glb_LW_up_name ' - f'for {test_options[3]} test.') + raise ValueError( + 'Must set keywords glb_LW_dn_name, glb_LW_up_name ' + f'for {test_options[3]} test.' + ) if use_dask and isinstance(self._ds[glb_LW_dn_name].data, da.Array): - index_1 = da.where(self._ds[glb_LW_dn_name].data - > (self._ds[glb_LW_up_name].data + LWdn_lt_LWup_component), True, False) - index_2 = da.where(self._ds[glb_LW_dn_name].data - < (self._ds[glb_LW_up_name].data - LWdn_gt_LWup_component), True, False) + index_1 = da.where( + self._ds[glb_LW_dn_name].data + > (self._ds[glb_LW_up_name].data + LWdn_lt_LWup_component), + True, + False, + ) + index_2 = da.where( + self._ds[glb_LW_dn_name].data + < (self._ds[glb_LW_up_name].data - LWdn_gt_LWup_component), + True, + False, + ) index = (index_1 | index_2).compute() else: - index_1 = self._ds[glb_LW_dn_name].values > (self._ds[glb_LW_up_name].values + LWdn_lt_LWup_component) - index_2 = self._ds[glb_LW_dn_name].values < (self._ds[glb_LW_up_name].values - LWdn_gt_LWup_component) + index_1 = self._ds[glb_LW_dn_name].values > ( + self._ds[glb_LW_up_name].values + LWdn_lt_LWup_component + ) + index_2 = self._ds[glb_LW_dn_name].values < ( + self._ds[glb_LW_up_name].values - LWdn_gt_LWup_component + ) index = index_1 | index_2 - test_meaning = "Lonwave downwelling compared to longwave upwelling outside of expected range" - self._ds.qcfilter.add_test(glb_LW_dn_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) - self._ds.qcfilter.add_test(glb_LW_up_name, index=index, test_assessment=test_assessment, - test_meaning=test_meaning) + test_meaning = ( + "Lonwave downwelling compared to longwave upwelling outside of expected range" + ) + self._ds.qcfilter.add_test( + glb_LW_dn_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) + self._ds.qcfilter.add_test( + glb_LW_up_name, + index=index, + test_assessment=test_assessment, + test_meaning=test_meaning, + ) diff --git a/act/qc/clean.py b/act/qc/clean.py index c84a30efef..2c0bb7baa7 100644 --- a/act/qc/clean.py +++ b/act/qc/clean.py @@ -91,6 +91,7 @@ def cleanup( link_qc_variables=True, normalize_assessment=False, cleanup_cf_qc=True, + cleanup_incorrect_qc_attributes=True, **kwargs, ): """ @@ -118,6 +119,9 @@ def cleanup( Option to clean up assessments to use the same terminology. Set to False for default because should only be an issue after adding DQRs and the function to add DQRs calls this method. + cleanup_incorrect_qc_attributes : bool + Fix incorrectly named quality control variable attributes before + converting to standardized QC. **kwargs : keywords Keyword arguments passed through to clean.clean_arm_qc method. @@ -131,6 +135,12 @@ def cleanup( ds.clean.cleanup() """ + # There are some QC variables with incorrect bit_#_description attribute names. + # This will check for the incorrect attribute names and correct to allow next + # process to work correctly + if cleanup_incorrect_qc_attributes: + self._ds.clean.fix_incorrect_variable_bit_description_attributes() + # Convert ARM QC to be more like CF state fields if cleanup_arm_qc: self._ds.clean.clean_arm_qc(**kwargs) @@ -198,7 +208,6 @@ def handle_missing_values(self, default_missing_value=np.int32(-9999)): np.dtype('float32'), np.dtype('float64'), ]: - # Look at units variable to see if this is the stupid way some # ARM products mix data and state variables. If the units are not # in the normal list of unitless type assume this is a data variable @@ -437,7 +446,7 @@ def get_attr_info(self, variable=None, flag=False): 'Value is equal to missing_value.', 'Value is less than the valid_min.', 'Value is greater than the valid_max.', - 'Difference between current and previous values exceeds valid_delta.' + 'Difference between current and previous values exceeds valid_delta.', ] return_dict['flag_tests'] = [1, 2, 3, 4] return_dict['flag_masks'] = [1, 2, 4, 8] @@ -452,7 +461,7 @@ def get_attr_info(self, variable=None, flag=False): 'bit_3_description', 'bit_3_assessment', 'bit_4_description', - 'bit_4_assessment' + 'bit_4_assessment', ] return return_dict @@ -493,10 +502,8 @@ def clean_arm_state_variables( for var in variables: flag_info = self.get_attr_info(variable=var, flag=integer_flag) if flag_info is not None: - # Add new attributes to variable for attr in ['flag_values', 'flag_meanings', 'flag_masks']: - if len(flag_info[attr]) > 0: # Only add if attribute does not exist. if attr in self._ds[var].attrs.keys() is False: @@ -582,10 +589,7 @@ def correct_valid_minmax(self, qc_variable): def link_variables(self): """ - Add some attributes to link and explain data - to QC data relationship. Will use non-CF standard_name - of quality_flag. Hopefully this will be added to the - standard_name table in the future. + Add some attributes to link and explain data to QC data relationship. """ for var in self._ds.data_vars: aa = re.match(r'^qc_(.+)', var) @@ -594,9 +598,10 @@ def link_variables(self): qc_variable = var except AttributeError: continue + # Skip data quality fields. try: - if not ('Quality check results on field:' in self._ds[var].attrs['long_name']): + if not self._ds[var].attrs["long_name"].startswith("Quality check results on"): continue except KeyError: pass @@ -610,7 +615,11 @@ def link_variables(self): # If the QC variable is not in ancillary_variables add if qc_variable not in ancillary_variables: ancillary_variables = qc_variable - self._ds[variable].attrs['ancillary_variables'] = copy.copy(ancillary_variables) + + try: + self._ds[variable].attrs['ancillary_variables'] = copy.copy(ancillary_variables) + except KeyError: + pass # Check if QC variable has correct standard_name and iff not fix it. correct_standard_name = 'quality_flag' @@ -626,7 +635,7 @@ def clean_arm_qc( clean_units_string=True, correct_valid_min_max=True, remove_unset_global_tests=True, - **kwargs + **kwargs, ): """ Method to clean up Xarray dataset QC variables. @@ -651,8 +660,8 @@ def clean_arm_qc( """ global_qc = self.get_attr_info() + qc_attributes = None for qc_var in self.matched_qc_variables: - # Clean up units attribute from unitless to udunits '1' try: if clean_units_string and self._ds[qc_var].attrs['units'] == 'unitless': @@ -719,7 +728,6 @@ def clean_arm_qc( flag_masks = self._ds[qc_var_name].attrs['flag_masks'] tests_to_remove = [] for ii, flag_meaning in enumerate(flag_meanings): - # Loop over usual test attribute names looking to see if they # are listed in test description. If so use that name for look up. test_attribute_limit_name = None @@ -754,13 +762,38 @@ def clean_arm_qc( qc_var_name=qc_var_name, test_number=test_to_remove ) + # If the QC was not cleaned up because it is not correctly formatted with SERI QC + # call the SERI QC method. + if global_qc is None and qc_attributes is None: + try: + DQMS = self._ds.attrs['qc_method'] == 'DQMS' + self._ds.attrs['comment'] + except KeyError: + try: + DQMS = 'sirs_seriqc' in self._ds.attrs['Command_Line'] + except KeyError: + DQMS = False + + if DQMS: + self._ds.clean.clean_seri_qc() + + # If the QC was not cleaned up because it is not correctly formatted with + # SWATS global attributes call the SWATS QC method. + try: + text = 'SWATS QC checks (bit values)' + SWATS_QC = text in self._ds.attrs['Mentor_QC_Field_Information'] + except KeyError: + SWATS_QC = False + + if SWATS_QC and global_qc is None and qc_attributes is None: + self._ds.clean.clean_swats_qc() + def normalize_assessment( self, variables=None, exclude_variables=None, qc_lookup={'Incorrect': 'Bad', 'Suspect': 'Indeterminate'}, ): - """ Method to clean up assessment terms used to be consistent between embedded QC and DQRs. @@ -902,3 +935,205 @@ def clean_cf_qc(self, variables=None, sep='__', **kwargs): except KeyError: pass + + def fix_incorrect_variable_bit_description_attributes(self): + """ + Method to correct incorrectly defined quality control variable attributes. + There are some datastreams with the attribute names incorrectly having 'qc_' + prepended to the attribute name. This will fix those attributes so the cleanqc + method can correctly read the attributes. + + If the variable long_name starts with the string "Quality check results on" + and a variable attribute follows the pattern qc_bit_#_description the 'qc_' part of + the variable attribute will be removed. + + """ + + attr_description_pattern = r'^qc_bit_([0-9]+)_description$' + attr_assessment_pattern = r'^qc_bit_([0-9]+)_assessment$' + + for var_name in self._ds.data_vars: + try: + if not self._ds[var_name].attrs['long_name'].startswith("Quality check results on"): + continue + except KeyError: + continue + + for attr, value in self._ds[var_name].attrs.copy().items(): + for pattern in [attr_description_pattern, attr_assessment_pattern]: + description = re.match(pattern, attr) + if description is not None: + new_attr = attr[3:] + self._ds[var_name].attrs[new_attr] = self._ds[var_name].attrs.pop(attr) + + def clean_seri_qc(self): + """ + Method to apply SERI QC to the quality control variables. The definition of the QC + is listed in a single global attribute and not easily parsable. This method will update + the quality control variable to correctly set the test descriptions for each of the + SERI QC tests defined in the global attributes. + + """ + for var_name in self._ds.data_vars: + if not self._ds[var_name].attrs['long_name'].startswith("Quality check results on"): + continue + + qc_var_name = var_name + var_name = var_name.replace('qc_', '') + qc_data = self._ds[qc_var_name].values.copy() + self._ds[qc_var_name] = xr.zeros_like(self._ds[qc_var_name], dtype=np.int32) + + if qc_var_name in [ + "qc_down_short_diffuse", + "qc_short_direct_normal", + "qc_down_short_hemisp", + ]: + value_number = [1, 2, 3, 6, 7, 8, 9, 94, 95, 96, 97] + test_number = list(range(2, len(value_number) + 2)) + test_description = [ + 'Passed 1-component test; data fall within max-min limits of Kt,Kn, or Kd', + 'Passed 2-component test; data fall within 0.03 of the Gompertz boundaries', + 'Passed 3-component test; data come within +/- 0.03 of satifying Kt=Kn+Kd', + 'Value estimated; passes all pertinent SERI QC tests', + 'Failed 1-component test; lower than allowed minimum', + 'Falied 1-component test; higher than allowed maximum', + 'Passed 3-component test but failed 2-component test by >0.05', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of 0.05 to 0.10.', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of 0.10 to 0.15.', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of 0.15 to 0.20.', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of >= 0.20.', + ] + test_assessment = [ + 'Not failing', + 'Not failing', + 'Not failing', + 'Not failing', + 'Bad', + 'Bad', + 'Indeterminate', + 'Bad', + 'Bad', + 'Bad', + 'Bad', + ] + elif qc_var_name in ["qc_up_long_hemisp", "qc_down_long_hemisp_shaded"]: + value_number = [1, 2, 7, 8, 31] + test_number = list(range(2, len(value_number) + 2)) + test_description = [ + 'Passed 1-component test; data fall within max-min limits of up_long_hemisp and down_long_hemisp_shaded, but short_direct_normal and down_short_hemisp or down_short_diffuse fail the SERI QC tests.', + 'Passed 2-component test; data fall within max-min limits of up_long_hemisp and down_long_hemisp_shaded, and short_direct_normal, or down_short_hemisp and down_short_diffuse pass the SERI QC tests while the difference between down_short_hemisp and down_short_diffuse is greater than 20 W/m2.', + 'Failed 1-component test; lower than allowed minimum', + 'Failed 1-component test; higher than allowed maximum', + 'Failed 2-component test', + ] + test_assessment = [ + 'Not failing', + 'Not failing', + 'Bad', + 'Bad', + 'Bad', + ] + elif qc_var_name in ["qc_up_short_hemisp"]: + value_number = [1, 2, 7, 8, 31] + test_number = list(range(2, len(value_number) + 2)) + test_description = [ + 'Passed 1-component test', + 'Passed 2-component test', + 'Failed 1-component test; lower than allowed minimum', + 'Failed 1-component test; higher than allowed maximum', + 'Failed 2-component test; solar zenith angle is less than 80 degrees and down_short_hemisp is 0 or missing', + ] + test_assessment = [ + 'Not failing', + 'Not failing', + 'Bad', + 'Bad', + 'Bad', + ] + + self._ds[var_name].attrs['ancillary_variables'] = qc_var_name + self._ds[qc_var_name].attrs['standard_name'] = 'quality_flag' + self._ds[qc_var_name].attrs['flag_masks'] = [] + self._ds[qc_var_name].attrs['flag_meanings'] = [] + self._ds[qc_var_name].attrs['flag_assessments'] = [] + + self._ds.qcfilter.add_missing_value_test(var_name) + + for ii, _ in enumerate(value_number): + index = qc_data == value_number[ii] + self._ds.qcfilter.add_test( + var_name, + index=index, + test_number=test_number[ii], + test_meaning=test_description[ii], + test_assessment=test_assessment[ii], + ) + + if qc_var_name in [ + "qc_down_short_diffuse", + "qc_short_direct_normal", + "qc_down_short_hemisp", + ]: + calculation = ((qc_data + 2) / 4.0) % 4 + calculation = calculation.astype(np.int16) + value_number = [0, 1, 2, 3] + test_description = [ + 'Parameter too low by 3-component test (Kt=Kn+Kd)', + 'Parameter too high by 3-component test (Kt=Kn+Kd)', + 'Parameter too low by 2-component test (Gompertz boundary)', + 'Parameter too high by 2-component test (Gompertz boundary)', + ] + test_assessment = ['Bad', 'Bad', 'Bad', 'Bad'] + for ii, _ in enumerate(value_number): + index = (qc_data >= 10) & (qc_data <= 93) & (calculation == value_number[ii]) + self._ds.qcfilter.add_test( + var_name, + index=index, + test_meaning=test_description[ii], + test_assessment=test_assessment[ii], + ) + + def clean_swats_qc(self, fix_data_units=True): + """ + Method to apply SWATS global attribute quality control definition to the + quality control variables. + + Parameters + ---------- + fix_data_units : bool + The units string for some data variables incorrectly defines degrees Celsius + as 'C' insted of the udunits 'degC'. When set to true those units strings + are updated. + + """ + + for var_name in self._ds.data_vars: + if fix_data_units: + try: + unit = self._ds[var_name].attrs['units'] + if unit == 'C': + self._ds[var_name].attrs['units'] = 'degC' + except KeyError: + pass + + if not self._ds[var_name].attrs['long_name'].startswith("Quality check results on"): + continue + + qc_var_name = var_name + self._ds[qc_var_name].attrs['flag_masks'] = [1, 2, 4, 8] + self._ds[qc_var_name].attrs['flag_meanings'] = [ + 'Value is set to missing_value.', + 'Data value less than valid_min.', + 'Data value greater than valid_max.', + 'Difference between current and previous values exceeds valid_delta.', + ] + self._ds[qc_var_name].attrs['flag_assessments'] = [ + 'Bad', + 'Bad', + 'Bad', + 'Indeterminate', + ] + + self._ds.clean.correct_valid_minmax(qc_var_name) + + del self._ds.attrs['Mentor_QC_Field_Information'] diff --git a/act/qc/comparison_tests.py b/act/qc/comparison_tests.py index 731eae0230..0ac88c3b34 100644 --- a/act/qc/comparison_tests.py +++ b/act/qc/comparison_tests.py @@ -3,7 +3,6 @@ """ import copy -import warnings import numpy as np import xarray as xr @@ -86,9 +85,9 @@ def compare_time_series_trends( sum_diff = np.array([], dtype=float) time_diff = np.array([], dtype=np.int32) for tm_shift in range(-1 * time_shift, time_shift + int(time_step), int(time_step)): - self_da_shifted = self_da.assign_coords( - time=self_da.time.values.astype('datetime64[s]') + tm_shift - ) + time = self_da.time.values.astype('datetime64[s]') + tm_shift + time = time.astype('datetime64[ns]') + self_da_shifted = self_da.assign_coords(time=time) data_matched, comp_data_matched = xr.align(self_da, comp_da) self_da_shifted = self_da_shifted.reindex( diff --git a/act/qc/qc_summary.py b/act/qc/qc_summary.py new file mode 100644 index 0000000000..ff6518dde0 --- /dev/null +++ b/act/qc/qc_summary.py @@ -0,0 +1,124 @@ +""" +Method for creating Quality Control Summary variables from the embedded +quality control varialbes. The summary variable is a simplified version of +quality control that uses flag integers instead of bit-packed masks. The +number of descriptions is simplified to consolidate all categories into one +description. + +""" + +import datetime + + +class QCSummary: + """ + This is a Mixins class used to allow using qcfilter class that is already + registered to the Xarray dataset. All the methods in this class will be added + to the qcfilter class. Doing this to make the code spread across more files + so it is more manageable and readable. + + """ + + def __init__(self, ds): + """initialize""" + self._ds = ds + + def create_qc_summary(self, cleanup_qc=False): + """ + Method to convert embedded quality control to summary QC that utilzes + flag values instead of flag masks and summarizes the assessments to only + a few states. Lowest level of quality control will be listed first with most + sever having higher integer numbers. Dataset is updated in place. + + cleanup_qc : boolean + Call clean.cleanup() method to convert to standardized ancillary quality control + variables. The quality control summary requires the current embedded quality + control variables to use ACT standards. + + Returns + ------- + return_ds : Xarray.dataset + ACT Xarray dataset with quality control variables converted to summary flag values. + + """ + + standard_assessments = [ + 'Suspect', + 'Indeterminate', + 'Incorrect', + 'Bad', + ] + standard_meanings = [ + "Data suspect, further analysis recommended", + "Data suspect, further analysis recommended", + "Data incorrect, use not recommended", + "Data incorrect, use not recommended", + ] + + if cleanup_qc: + self._ds.clean.cleanup() + + return_ds = self._ds.copy() + + added = False + for var_name in list(self._ds.data_vars): + qc_var_name = self.check_for_ancillary_qc(var_name, add_if_missing=False, cleanup=False) + + if qc_var_name is None: + continue + + added = True + + assessments = list(set(self._ds[qc_var_name].attrs['flag_assessments'])) + + import xarray as xr + + result = xr.zeros_like(return_ds[qc_var_name]) + for attr in ['flag_masks', 'flag_meanings', 'flag_assessments', 'flag_values']: + try: + del result.attrs[attr] + except KeyError: + pass + + return_ds[qc_var_name] = result + + return_ds.qcfilter.add_test( + var_name, + index=None, + test_number=0, + test_meaning='Not failing quality control tests', + test_assessment='Not failing', + flag_value=True, + ) + + for ii, assessment in enumerate(standard_assessments): + if assessment not in assessments: + continue + + qc_mask = self.get_masked_data( + var_name, rm_assessments=assessment, return_mask_only=True + ) + + # Do not really know how to handle scalars yet. + if qc_mask.ndim == 0: + continue + + return_ds.qcfilter.add_test( + var_name, + index=qc_mask, + test_meaning=standard_meanings[ii], + test_assessment=assessment, + flag_value=True, + ) + + self._ds.update({qc_var_name: return_ds[qc_var_name]}) + + if added: + history = return_ds.attrs['history'] + history += ( + " ; Quality control summary implemented by ACT at " + f"{datetime.datetime.utcnow().isoformat()} UTC." + ) + return_ds.attrs['history'] = history + + return return_ds diff --git a/act/qc/qcfilter.py b/act/qc/qcfilter.py index 6137db9f92..c8a64ca5e4 100644 --- a/act/qc/qcfilter.py +++ b/act/qc/qcfilter.py @@ -9,11 +9,11 @@ import numpy as np import xarray as xr -from act.qc import comparison_tests, qctests, bsrn_tests +from act.qc import comparison_tests, qctests, bsrn_tests, qc_summary @xr.register_dataset_accessor('qcfilter') -class QCFilter(qctests.QCTests, comparison_tests.QCTests, bsrn_tests.QCTests): +class QCFilter(qctests.QCTests, comparison_tests.QCTests, bsrn_tests.QCTests, qc_summary.QCSummary): """ A class for building quality control variables containing arrays for filtering data based on a set of test condition typically based on the @@ -26,13 +26,7 @@ def __init__(self, ds): """initialize""" self._ds = ds - def check_for_ancillary_qc( - self, - var_name, - add_if_missing=True, - cleanup=False, - flag_type=False - ): + def check_for_ancillary_qc(self, var_name, add_if_missing=True, cleanup=False, flag_type=False): """ Method to check if a quality control variable exist in the dataset and return the quality control varible name. @@ -119,10 +113,7 @@ def check_for_ancillary_qc( return qc_var_name def create_qc_variable( - self, var_name, - flag_type=False, - flag_values_set_value=0, - qc_var_name=None + self, var_name, flag_type=False, flag_values_set_value=0, qc_var_name=None ): """ Method to create a quality control variable in the dataset. @@ -206,9 +197,7 @@ def create_qc_variable( # Update if using flag_values and don't want 0 to be default value. if flag_type and flag_values_set_value != 0: - self._ds[qc_var_name].values = self._ds[qc_var_name].values + int( - flag_values_set_value - ) + self._ds[qc_var_name].values = self._ds[qc_var_name].values + int(flag_values_set_value) # Add requried variable attributes. if flag_type: @@ -260,7 +249,6 @@ def update_ancillary_variable(self, var_name, qc_var_name=None): try: ancillary_variables = self._ds[var_name].attrs['ancillary_variables'] if qc_var_name not in ancillary_variables: - ancillary_variables = ' '.join([ancillary_variables, qc_var_name]) except KeyError: ancillary_variables = qc_var_name @@ -551,7 +539,10 @@ def set_test(self, var_name, index=None, test_number=None, flag_value=False): if index is not None: if flag_value: - qc_variable[index] = test_number + if len(qc_variable.shape) == 0: + qc_variable = test_number + else: + qc_variable[index] = test_number else: if bool(np.shape(index)): qc_variable[index] = set_bit(qc_variable[index], test_number) @@ -804,8 +795,8 @@ def get_masked_data( return_nan_array=False, ma_fill_value=None, return_inverse=False, + return_mask_only=False, ): - """ Returns a numpy masked array containing data and mask or a numpy float array with masked values set to NaN. @@ -831,6 +822,8 @@ def get_masked_data( Invert the masked array mask or return data array where mask is set to False instead of True set to NaN. Useful for overplotting where failing. + return_mask_only : boolean + Return the boolean mask only as a numpy array. Returns ------- @@ -915,9 +908,21 @@ def get_masked_data( if variable.dtype in (np.float64, np.int64): nan_dtype = np.float64 - mask = np.zeros(variable.shape, dtype=bool) + try: + # Get shape of mask from QC variable since there is a chance it will + # be a different shape than data variable. + mask = np.zeros(self._ds[qc_var_name].shape, dtype=bool) + except KeyError: + # If there is no QC variable make mask from shape of data variable. + mask = np.zeros(self._ds[var_name].shape, dtype=bool) + for test in test_numbers: - mask = mask | self._ds.qcfilter.get_qc_test_mask(var_name, test, flag_value=flag_value) + qc_test_mask = self._ds.qcfilter.get_qc_test_mask(var_name, test, flag_value=flag_value) + mask = mask | qc_test_mask + + # If requested only return the mask. + if return_mask_only: + return mask # Convert data numpy array into masked array try: @@ -1030,25 +1035,25 @@ def datafilter( except KeyError: pass - print(f'No quality control variable for {var_name} found ' - f'in call to .qcfilter.datafilter()') + print( + f'No quality control variable for {var_name} found ' + f'in call to .qcfilter.datafilter()' + ) continue # Need to return data as Numpy array with NaN values. Setting the Dask array # to Numpy masked array does not work with other tools. data = self.get_masked_data( - var_name, - rm_assessments=rm_assessments, - rm_tests=rm_tests, - return_nan_array=True + var_name, rm_assessments=rm_assessments, rm_tests=rm_tests, return_nan_array=True ) # If data was orginally stored as Dask array return values to Dataset as Dask array # else set as Numpy array. try: self._ds[var_name].data = dask.array.from_array( - data, chunks=self._ds[var_name].data.chunksize) + data, chunks=self._ds[var_name].data.chunksize + ) except AttributeError: self._ds[var_name].values = data diff --git a/act/qc/qctests.py b/act/qc/qctests.py index 45bfb7d179..3b9916d1f8 100644 --- a/act/qc/qctests.py +++ b/act/qc/qctests.py @@ -1353,8 +1353,7 @@ def add_iqr_test( from scikit_posthocs import outliers_iqr except ImportError: raise ImportError( - 'scikit_posthocs needs to be installed on your system to ' - 'run add_iqr_test.' + 'scikit_posthocs needs to be installed on your system to ' 'run add_iqr_test.' ) if test_meaning is None: @@ -1452,8 +1451,7 @@ def add_gesd_test( from scikit_posthocs import outliers_gesd except ImportError: raise ImportError( - 'scikit_posthocs needs to be installed on your system to ' - 'run add_gesd_test.' + 'scikit_posthocs needs to be installed on your system to ' 'run add_gesd_test.' ) if test_meaning is None: @@ -1510,7 +1508,7 @@ def add_atmospheric_pressure_test( test_number=None, flag_value=False, prepend_text=None, - use_dask=False + use_dask=False, ): """ Method to perform a limit test on atmospheric pressure data using @@ -1592,8 +1590,10 @@ def add_atmospheric_pressure_test( upper_limit = upper_limit.magnitude if test_meaning is None: - test_meaning = ('Value outside of atmospheric pressure range test range: ' - f'{round(lower_limit, 2)} to {round(upper_limit, 2)} {data_units}') + test_meaning = ( + 'Value outside of atmospheric pressure range test range: ' + f'{round(lower_limit, 2)} to {round(upper_limit, 2)} {data_units}' + ) if prepend_text is not None: test_meaning = ': '.join((prepend_text, test_meaning)) @@ -1605,7 +1605,9 @@ def add_atmospheric_pressure_test( index2 = da.where(self._ds[var_name].data > upper_limit, True, False) index = (index1 | index2).compute() else: - index = (self._ds[var_name].values > upper_limit) | (self._ds[var_name].values < lower_limit) + index = (self._ds[var_name].values > upper_limit) | ( + self._ds[var_name].values < lower_limit + ) result = self._ds.qcfilter.add_test( var_name, diff --git a/act/qc/radiometer_tests.py b/act/qc/radiometer_tests.py index 34ba7687c2..6429aef15b 100644 --- a/act/qc/radiometer_tests.py +++ b/act/qc/radiometer_tests.py @@ -3,7 +3,6 @@ """ -import datetime import warnings import dask @@ -13,7 +12,7 @@ from scipy.fftpack import rfft, rfftfreq from act.utils.datetime_utils import determine_time_delta -from act.utils.geo_utils import get_sunrise_sunset_noon, is_sun_visible +from act.utils.geo_utils import is_sun_visible def fft_shading_test( diff --git a/act/qc/sp2.py b/act/qc/sp2.py index 9a67123e32..526405408e 100644 --- a/act/qc/sp2.py +++ b/act/qc/sp2.py @@ -119,7 +119,8 @@ def __init__(self): 'Attempting to use SP2ParticleCriteria without' 'PySP2 installed. SP2ParticleCriteria will' 'not have any functionality besides this' - 'warning message.', RuntimeWarning + 'warning message.', + RuntimeWarning, ) diff --git a/act/retrievals/cbh.py b/act/retrievals/cbh.py index dd7aa0c04f..f68f47e52c 100644 --- a/act/retrievals/cbh.py +++ b/act/retrievals/cbh.py @@ -16,7 +16,7 @@ def generic_sobel_cbh( fill_na=None, return_thresh=False, filter_type='uniform', - edge_thresh=5., + edge_thresh=5.0, ): """ Function for calculating cloud base height from lidar/radar data diff --git a/act/retrievals/doppler_lidar.py b/act/retrievals/doppler_lidar.py index 0e5dd85154..0998fa821f 100644 --- a/act/retrievals/doppler_lidar.py +++ b/act/retrievals/doppler_lidar.py @@ -103,6 +103,7 @@ def compute_winds_from_ppi( else: try: snr = ds[snr_name].values + var_name = snr_name except KeyError: intensity = ds['intensity'].values snr = intensity - 1 @@ -132,9 +133,16 @@ def compute_winds_from_ppi( task.append( dask.delayed(process_ppi_winds)( - time[scan_index], elevation[scan_index], azimuth[scan_index], snr[scan_index, :], - doppler[scan_index, :], rng, condition_limit, snr_threshold, remove_all_missing, - height_units + time[scan_index], + elevation[scan_index], + azimuth[scan_index], + snr[scan_index, :], + doppler[scan_index, :], + rng, + condition_limit, + snr_threshold, + remove_all_missing, + height_units, ) ) @@ -144,7 +152,9 @@ def compute_winds_from_ppi( results = [results[ii] for ii, value in enumerate(is_Dataset) if value is True] new_ds = xr.concat(results, 'time') - if isinstance(return_ds, xr.core.dataset.Dataset) and isinstance(new_ds, xr.core.dataset.Dataset): + if isinstance(return_ds, xr.core.dataset.Dataset) and isinstance( + new_ds, xr.core.dataset.Dataset + ): return_ds = xr.concat([return_ds, new_ds], dim='time') else: return_ds = new_ds @@ -152,8 +162,18 @@ def compute_winds_from_ppi( return return_ds -def process_ppi_winds(time, elevation, azimuth, snr, doppler, rng, condition_limit, - snr_threshold, remove_all_missing, height_units): +def process_ppi_winds( + time, + elevation, + azimuth, + snr, + doppler, + rng, + condition_limit, + snr_threshold, + remove_all_missing, + height_units, +): """ This function is for processing the winds using dask from the compute_winds_from_ppi function. This should not be used standalone. @@ -235,9 +255,7 @@ def process_ppi_winds(time, elevation, azimuth, snr, doppler, rng, condition_lim wdir = np.degrees(np.arctan2(u_wind, v_wind) + np.pi) wspd_err = np.sqrt((u_wind * u_err) ** 2 + (v_wind * v_err) ** 2) / wspd - wdir_err = np.degrees( - np.sqrt((u_wind * v_err) ** 2 + (v_wind * u_err) ** 2) / wspd**2 - ) + wdir_err = np.degrees(np.sqrt((u_wind * v_err) ** 2 + (v_wind * u_err) ** 2) / wspd**2) if remove_all_missing and np.isnan(wspd).all(): return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan diff --git a/act/retrievals/radiation.py b/act/retrievals/radiation.py index 4d1964ebdd..09c5d1ade3 100644 --- a/act/retrievals/radiation.py +++ b/act/retrievals/radiation.py @@ -7,7 +7,6 @@ import xarray as xr from scipy.constants import Stefan_Boltzmann -from act.utils.datetime_utils import datetime64_to_datetime from act.utils.geo_utils import get_solar_azimuth_elevation @@ -59,7 +58,7 @@ def calculate_dsh_from_dsdh_sdn( attrs={ 'long_name': 'Derived Downwelling Shortwave Hemispheric Irradiance', 'units': 'W/m^2', - } + }, ) return ds @@ -144,7 +143,6 @@ def calculate_net_radiation( dlhs='down_long_hemisp_shaded', smooth=None, ): - """ Function to calculate the net radiation from upwelling short and long-wave irradiance and @@ -207,7 +205,6 @@ def calculate_longwave_radiation( emiss_a=0.61, emiss_b=0.06, ): - """ Function to calculate longwave radiation during clear and cloudy sky conditions @@ -249,7 +246,6 @@ def calculate_longwave_radiation( """ if met_ds is not None: - T = met_ds[temperature_var] + 273.15 # C to K e = met_ds[vapor_pressure_var] * 10.0 # kpa to hpa else: diff --git a/act/retrievals/sonde.py b/act/retrievals/sonde.py index 242b7f9abb..01cf3ce045 100644 --- a/act/retrievals/sonde.py +++ b/act/retrievals/sonde.py @@ -3,9 +3,7 @@ """ -import warnings import numpy as np -import pandas as pd import xarray as xr from operator import itemgetter from itertools import groupby @@ -174,9 +172,7 @@ def calculate_stability_indicies( ds['parcel_temperature'].attrs['units'] = t_profile.units # Calculate CAPE, CIN, LCL - sbcape, sbcin = mpcalc.surface_based_cape_cin(p_sorted, - t_sorted, - td_sorted) + sbcape, sbcin = mpcalc.surface_based_cape_cin(p_sorted, t_sorted, td_sorted) lcl = mpcalc.lcl(p_sorted[0], t_sorted[0], td_sorted[0]) try: @@ -277,8 +273,14 @@ def calculate_pbl_liu_liang( """ # Preprocess the sonde data to ensure the same methods across all retrievals - ds2 = preprocess_sonde_data(ds, temperature=temperature, pressure=pressure, - height=height, smooth_height=smooth_height, base=5.) + ds2 = preprocess_sonde_data( + ds, + temperature=temperature, + pressure=pressure, + height=height, + smooth_height=smooth_height, + base=5.0, + ) pres = ds2[pressure].values wspd = ds2[windspeed].values @@ -417,7 +419,7 @@ def calculate_pbl_heffter( pressure='pres', height='alt', smooth_height=3, - base=5., + base=5.0, ): """ Function for calculating the PBL height from a radiosonde profile @@ -460,8 +462,14 @@ def calculate_pbl_heffter( """ # Preprocess the sonde data to ensure the same methods across all retrievals - ds2 = preprocess_sonde_data(ds, temperature=temperature, pressure=pressure, - height=height, smooth_height=smooth_height, base=base) + ds2 = preprocess_sonde_data( + ds, + temperature=temperature, + pressure=pressure, + height=height, + smooth_height=smooth_height, + base=base, + ) # Get data pres = ds2[pressure].values @@ -496,25 +504,25 @@ def calculate_pbl_heffter( # For each layer, calculate the difference in theta from # top and bottom of the layer. The lowest layer where the # difference is > 2 K is set as the PBL. - pbl = 0. + pbl = 0.0 theta_diff_layer = [] bottom_inversion = [] top_inversion = [] for r in ranges: - if agl[r[1]] > 4000.: + if agl[r[1]] > 4000.0: continue theta_diff = theta[r[1]] - theta[r[0]] theta_diff_layer.append(theta_diff) bottom_inversion.append(alt[r[0]]) top_inversion.append(alt[r[1]]) - if pbl == 0. and theta_diff > 2.0: + if pbl == 0.0 and theta_diff > 2.0: pbl = alt[r[0]] if len(theta_diff_layer) == 0: - pbl = -9999. + pbl = -9999.0 # If PBL is not set, set it to the layer with the max theta diff - if pbl == 0.: + if pbl == 0.0: idx = np.argmax(theta_diff_layer) pbl = bottom_inversion[idx] @@ -536,11 +544,21 @@ def calculate_pbl_heffter( ds['alt_ss'] = da atts = {'units': 'm', 'long_name': 'Bottom height of inversion layers'} - da = xr.DataArray(bottom_inversion, coords={'layers': list(range(len(bottom_inversion)))}, dims=['layers'], attrs=atts) + da = xr.DataArray( + bottom_inversion, + coords={'layers': list(range(len(bottom_inversion)))}, + dims=['layers'], + attrs=atts, + ) ds['bottom_inversion'] = da atts = {'units': 'm', 'long_name': 'Top height of inversion layers'} - da = xr.DataArray(top_inversion, coords={'layers': list(range(len(top_inversion)))}, dims=['layers'], attrs=atts) + da = xr.DataArray( + top_inversion, + coords={'layers': list(range(len(top_inversion)))}, + dims=['layers'], + attrs=atts, + ) ds['top_inversion'] = da return ds @@ -552,7 +570,7 @@ def preprocess_sonde_data( pressure='pres', height='alt', smooth_height=3, - base=5., + base=5.0, ): """ Function for processing the SONDE data for the PBL calculations. @@ -628,7 +646,7 @@ def preprocess_sonde_data( temp = ds2[temperature].values # Perform Pre-processing checks - if len(temp) == 0.: + if len(temp) == 0.0: raise ValueError('No data in profile') if np.nanmax(alt) < 1000.0: diff --git a/act/tests/__init__.py b/act/tests/__init__.py index 9ae16bd6a3..c41d4b7d83 100644 --- a/act/tests/__init__.py +++ b/act/tests/__init__.py @@ -55,12 +55,14 @@ 'EXAMPLE_INI', 'EXAMPLE_SP2B', 'EXAMPLE_MET_YAML', - 'EXAMPLE_CLOUDPHASE' - 'EXAMPLE_ECOR', + 'EXAMPLE_CLOUDPHASE' 'EXAMPLE_ECOR', 'EXAMPLE_SEBS', 'EXAMPLE_ENA_MET', 'EXAMPLE_CCN', 'EXAMPLE_OLD_QC', + 'EXAMPLE_AOSACSM', + 'EXAMPLE_SIRS_SIRI_QC', + 'EXAMPLE_SWATS', ] }, ) diff --git a/act/tests/sample_files.py b/act/tests/sample_files.py index 06adc4a4a2..47704a63e2 100644 --- a/act/tests/sample_files.py +++ b/act/tests/sample_files.py @@ -4,11 +4,11 @@ """ -import os from arm_test_data import DATASETS # Single files +EXAMPLE_MPEG = DATASETS.fetch('nsacamskyradmovieC1.a1.20240401.100300.mpg') EXAMPLE_MET1 = DATASETS.fetch('sgpmetE13.b1.20190101.000000.cdf') EXAMPLE_MET_SAIL = DATASETS.fetch('gucmetM1.b1.20230301.000000.cdf') EXAMPLE_MET_CSV = DATASETS.fetch('sgpmetE13.b1.20210401.000000.csv') @@ -27,13 +27,13 @@ EXAMPLE_AERI = DATASETS.fetch('sgpaerich1C1.b1.20190501.000342.nc') EXAMPLE_IRTSST = DATASETS.fetch('marirtsstM1.b1.20190320.000000.nc') EXAMPLE_MFRSR = DATASETS.fetch('sgpmfrsr7nchE11.b1.20210329.070000.nc') -EXAMPLE_SURFSPECALB1MLAWER = DATASETS.fetch( - 'nsasurfspecalb1mlawerC1.c1.20160609.080000.nc' -) +EXAMPLE_SURFSPECALB1MLAWER = DATASETS.fetch('nsasurfspecalb1mlawerC1.c1.20160609.080000.nc') EXAMPLE_SIGMA_MPLV5 = DATASETS.fetch('201509021500.bi') EXAMPLE_RL1 = DATASETS.fetch('sgprlC1.a0.20160131.000000.nc') EXAMPLE_CO2FLX4M = DATASETS.fetch('sgpco2flx4mC1.b1.20201007.001500.nc') +EXAMPLE_SWATS = DATASETS.fetch('sgpswatsE8.b1.20071229.000700.cdf') EXAMPLE_SIRS = DATASETS.fetch('sgpsirsE13.b1.20190101.000000.cdf') +EXAMPLE_SIRS_SIRI_QC = DATASETS.fetch('sgpsirsC1.b1.20040101.000000.cdf') EXAMPLE_GML_RADIATION = DATASETS.fetch('brw21001.dat') EXAMPLE_GML_MET = DATASETS.fetch('met_brw_insitu_1_obop_hour_2020.txt') EXAMPLE_GML_OZONE = DATASETS.fetch('brw_12_2020_hour.dat') @@ -49,88 +49,106 @@ EXAMPLE_MET_YAML = DATASETS.fetch('sgpmetE13.b1.yaml') EXAMPLE_CLOUDPHASE = DATASETS.fetch('nsacloudphaseC1.c1.20180601.000000.nc') EXAMPLE_AAF_ICARTT = DATASETS.fetch('AAFNAV_COR_20181104_R0.ict') -EXAMPLE_NEON = DATASETS.fetch('NEON.D18.BARR.DP1.00002.001.000.010.001.SAAT_1min.2022-10.expanded.20221107T205629Z.csv') +EXAMPLE_NEON = DATASETS.fetch( + 'NEON.D18.BARR.DP1.00002.001.000.010.001.SAAT_1min.2022-10.expanded.20221107T205629Z.csv' +) EXAMPLE_NEON_VARIABLE = DATASETS.fetch('NEON.D18.BARR.DP1.00002.001.variables.20221201T110553Z.csv') -EXAMPLE_NEON_POSITION = DATASETS.fetch('NEON.D18.BARR.DP1.00002.001.sensor_positions.20221107T205629Z.csv') +EXAMPLE_NEON_POSITION = DATASETS.fetch( + 'NEON.D18.BARR.DP1.00002.001.sensor_positions.20221107T205629Z.csv' +) EXAMPLE_DOD = DATASETS.fetch('vdis.b1') EXAMPLE_EBBR1 = DATASETS.fetch('sgp30ebbrE32.b1.20191125.000000.nc') EXAMPLE_EBBR2 = DATASETS.fetch('sgp30ebbrE32.b1.20191130.000000.nc') EXAMPLE_EBBR3 = DATASETS.fetch('sgp30ebbrE13.b1.20190601.000000.nc') EXAMPLE_ECOR = DATASETS.fetch('sgp30ecorE14.b1.20190601.000000.cdf') EXAMPLE_SEBS = DATASETS.fetch('sgpsebsE14.b1.20190601.000000.cdf') +EXAMPLE_SEBS_E39 = DATASETS.fetch('sgpsebsE39.b1.20230601.000000.cdf') +EXAMPLE_ECORSF_E39 = DATASETS.fetch('sgpecorsfE39.b1.20230601.000000.nc') +EXAMPLE_STAMP_E39 = DATASETS.fetch('sgpstampE39.b1.20230601.000000.nc') +EXAMPLE_STAMPPCP_E39 = DATASETS.fetch('sgpstamppcpE39.b1.20230601.000000.nc') +EXAMPLE_AMC_E39 = DATASETS.fetch('sgpamcE39.b1.20230601.000000.nc') EXAMPLE_MFAS_SODAR = DATASETS.fetch('sodar.20230404.mnd') EXAMPLE_ENA_MET = DATASETS.fetch('enametC1.b1.20221109.000000.cdf') EXAMPLE_CCN = DATASETS.fetch('sgpaosccn2colaE13.b1.20170903.000000.nc') EXAMPLE_OLD_QC = DATASETS.fetch('sgp30ecorE6.b1.20040705.000000.cdf') EXAMPLE_SONDE_WILDCARD = DATASETS.fetch('sgpsondewnpnC1.b1.20190101.053200.cdf') EXAMPLE_CEIL_WILDCARD = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') +EXAMPLE_HYSPLIT = DATASETS.fetch('houstonaug300.0summer2010080100') +EXAMPLE_AOSACSM = DATASETS.fetch('sgpaosacsmE13.b2.20230420.000109.nc') # Multiple files in a list -dlppi_multi_list = ['sgpdlppiC1.b1.20191015.120023.cdf', - 'sgpdlppiC1.b1.20191015.121506.cdf'] +dlppi_multi_list = ['sgpdlppiC1.b1.20191015.120023.cdf', 'sgpdlppiC1.b1.20191015.121506.cdf'] EXAMPLE_DLPPI_MULTI = [DATASETS.fetch(file) for file in dlppi_multi_list] -noaa_psl_list = ['ayp22199.21m', - 'ayp22200.00m'] +noaa_psl_list = ['ayp22199.21m', 'ayp22200.00m'] EXAMPLE_NOAA_PSL_SURFACEMET = [DATASETS.fetch(file) for file in noaa_psl_list] -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] EXAMPLE_MET_WILDCARD = [DATASETS.fetch(file) for file in met_wildcard_list] -met_contour_list = ['sgpmetE15.b1.20190508.000000.cdf', - 'sgpmetE31.b1.20190508.000000.cdf', - 'sgpmetE32.b1.20190508.000000.cdf', - 'sgpmetE33.b1.20190508.000000.cdf', - 'sgpmetE34.b1.20190508.000000.cdf', - 'sgpmetE35.b1.20190508.000000.cdf', - 'sgpmetE36.b1.20190508.000000.cdf', - 'sgpmetE37.b1.20190508.000000.cdf', - 'sgpmetE38.b1.20190508.000000.cdf', - 'sgpmetE39.b1.20190508.000000.cdf', - 'sgpmetE40.b1.20190508.000000.cdf', - 'sgpmetE9.b1.20190508.000000.cdf', - 'sgpmetE13.b1.20190508.000000.cdf'] +met_contour_list = [ + 'sgpmetE15.b1.20190508.000000.cdf', + 'sgpmetE31.b1.20190508.000000.cdf', + 'sgpmetE32.b1.20190508.000000.cdf', + 'sgpmetE33.b1.20190508.000000.cdf', + 'sgpmetE34.b1.20190508.000000.cdf', + 'sgpmetE35.b1.20190508.000000.cdf', + 'sgpmetE36.b1.20190508.000000.cdf', + 'sgpmetE37.b1.20190508.000000.cdf', + 'sgpmetE38.b1.20190508.000000.cdf', + 'sgpmetE39.b1.20190508.000000.cdf', + 'sgpmetE40.b1.20190508.000000.cdf', + 'sgpmetE9.b1.20190508.000000.cdf', + 'sgpmetE13.b1.20190508.000000.cdf', +] EXAMPLE_MET_CONTOUR = [DATASETS.fetch(file) for file in met_contour_list] -twp_sonde_wildcard_list = ['twpsondewnpnC3.b1.20060119.050300.custom.cdf', - 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', - 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', - 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', - 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', - 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', - 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', - 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', - 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', - 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', - 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', - 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', - 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', - 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', - 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', - 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', - 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', - 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', - 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', - 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', - 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', - 'twpsondewnpnC3.b1.20060124.231500.custom.cdf'] +twp_sonde_wildcard_list = [ + 'twpsondewnpnC3.b1.20060119.050300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', + 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', + 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', + 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', + 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', + 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', + 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', + 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', + 'twpsondewnpnC3.b1.20060124.231500.custom.cdf', +] EXAMPLE_TWP_SONDE_WILDCARD = [DATASETS.fetch(file) for file in twp_sonde_wildcard_list] -twp_sonde_20060121_list = ['twpsondewnpnC3.b1.20060121.051500.custom.cdf', - 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.231600.custom.cdf'] +twp_sonde_20060121_list = [ + 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', +] EXAMPLE_TWP_SONDE_20060121 = [DATASETS.fetch(file) for file in twp_sonde_20060121_list] -stamp_wildcard_list = ['sgpstampE13.b1.20200101.000000.nc', - 'sgpstampE31.b1.20200101.000000.nc', - 'sgpstampE32.b1.20200101.000000.nc', - 'sgpstampE33.b1.20200101.000000.nc', - 'sgpstampE34.b1.20200101.000000.nc', - 'sgpstampE9.b1.20200101.000000.nc'] +stamp_wildcard_list = [ + 'sgpstampE13.b1.20200101.000000.nc', + 'sgpstampE31.b1.20200101.000000.nc', + 'sgpstampE32.b1.20200101.000000.nc', + 'sgpstampE33.b1.20200101.000000.nc', + 'sgpstampE34.b1.20200101.000000.nc', + 'sgpstampE9.b1.20200101.000000.nc', +] EXAMPLE_STAMP_WILDCARD = [DATASETS.fetch(file) for file in stamp_wildcard_list] -mmcr_list = ['sgpmmcrC1.b1.1.cdf', - 'sgpmmcrC1.b1.2.cdf'] +mmcr_list = ['sgpmmcrC1.b1.1.cdf', 'sgpmmcrC1.b1.2.cdf'] EXAMPLE_MMCR = [DATASETS.fetch(file) for file in mmcr_list] diff --git a/act/utils/__init__.py b/act/utils/__init__.py index 035bf99de3..6e72622d50 100644 --- a/act/utils/__init__.py +++ b/act/utils/__init__.py @@ -7,7 +7,16 @@ __getattr__, __dir__, __all__ = lazy.attach( __name__, - submodules=['data_utils', 'datetime_utils', 'geo_utils', 'inst_utils', 'io_utils', 'qc_utils', 'radiance_utils', 'ship_utils'], + submodules=[ + 'data_utils', + 'datetime_utils', + 'geo_utils', + 'inst_utils', + 'io_utils', + 'qc_utils', + 'radiance_utils', + 'ship_utils', + ], submod_attrs={ 'data_utils': [ 'ChangeUnits', @@ -23,6 +32,8 @@ 'convert_to_potential_temp', 'arm_site_location_search', 'DatastreamParserARM', + 'calculate_percentages', + 'convert_2d_to_1d', ], 'datetime_utils': [ 'dates_between', @@ -31,7 +42,7 @@ 'numpy_to_arm_date', 'reduce_time_ranges', 'date_parser', - 'adjust_timestamp' + 'adjust_timestamp', ], 'geo_utils': [ 'add_solar_variable', @@ -44,13 +55,15 @@ 'qc_utils': ['calculate_dqr_times'], 'radiance_utils': ['planck_converter'], 'ship_utils': ['calc_cog_sog', 'proc_scog'], - 'io_utils': ['pack_tar', - 'unpack_tar', - 'cleanup_files', - 'is_gunzip_file', - 'pack_gzip', - 'unpack_gzip', - 'generate_movie' + 'io_utils': [ + 'pack_tar', + 'unpack_tar', + 'cleanup_files', + 'is_gunzip_file', + 'pack_gzip', + 'unpack_gzip', + 'generate_movie', + 'arm_standards_validator', ], }, ) diff --git a/act/utils/data_utils.py b/act/utils/data_utils.py index 5d499338dc..d8c98d10b2 100644 --- a/act/utils/data_utils.py +++ b/act/utils/data_utils.py @@ -15,6 +15,7 @@ from pathlib import Path import re import requests +from os import PathLike spec = importlib.util.find_spec('pyart') if spec is not None: @@ -35,7 +36,13 @@ def __init__(self, ds): self._ds = ds def change_units( - self, variables=None, desired_unit=None, skip_variables=None, skip_standard=True + self, + variables=None, + desired_unit=None, + skip_variables=None, + skip_standard=True, + verbose=False, + raise_error=False, ): """ Parameters @@ -51,6 +58,13 @@ def change_units( Flag indicating the QC variables that will not need changing are skipped. Makes the processing faster when processing all variables in dataset. + verbose : boolean + Option to print statement when an attempted conversion fails. Set to False + as default because many units strings are not udunits complient and when + trying to convert all varialbes of a type of units (eg temperature) the code + can print a lot of unecessary information. + raise_error : boolean + Raise an error if conversion is not successful. Returns ------- @@ -102,13 +116,21 @@ def change_units( pint.errors.UndefinedUnitError, np.core._exceptions.UFuncTypeError, ): - continue + if raise_error: + raise ValueError( + f"Unable to convert '{var_name}' to units of '{desired_unit}'." + ) + elif verbose: + print( + f"\n Unable to convert '{var_name}' to units of '{desired_unit}'. " + f"Skipping unit converstion for '{var_name}'.\n" + ) return self._ds # @xr.register_dataset_accessor('utils') -class DatastreamParserARM(object): +class DatastreamParserARM: ''' Class to parse ARM datastream names or filenames into its components. Will return None for each attribute if not extracted from the filename. @@ -144,6 +166,7 @@ class DatastreamParserARM(object): ''' + def __init__(self, ds=''): ''' Constructor that initializes datastream data member and runs @@ -154,11 +177,10 @@ def __init__(self, ds=''): The datastream or filename to parse ''' - - if isinstance(ds, str): + if isinstance(ds, (str, PathLike)): self.__datastream = Path(ds).name else: - raise ValueError('Datastream or filename name must be a string') + raise ValueError('Datastream or filename name must be a string or pathlib.PosixPath.') try: self.__parse_datastream() @@ -215,15 +237,17 @@ def __parse_datastream(self): match = True if not match: - m = re.search(r'(^[a-z]{3})(\w+)$', tempstring[0]) + m = re.search(r'(^[a-z]{3})([^A-Z]+)$', tempstring[0]) if m is not None: self.__site = m.group(1) self.__class = m.group(2) match = True if not match and len(tempstring[0]) == 3: - self.__site = tempstring[0] - match = True + m = re.search(r'(^[a-z]{3})', tempstring[0]) + if m is not None: + self.__site = m.group(1) + match = True if not match: raise ValueError(self.__datastream) @@ -246,8 +270,7 @@ def datastream(self): ''' try: - return ''.join((self.__site, self.__class, self.__facility, '.', - self.__level)) + return ''.join((self.__site, self.__class, self.__facility, '.', self.__level)) except TypeError: return None @@ -303,8 +326,7 @@ def datastream_standard(self): ''' try: - return ''.join((self.site, self.datastream_class, self.facility, - '.', self.level)) + return ''.join((self.site, self.datastream_class, self.facility, '.', self.level)) except TypeError: return None @@ -361,7 +383,7 @@ def assign_coordinates(ds, coord_list): if coord not in ds.variables.keys(): raise KeyError(coord + ' is not a variable in the Dataset.') - if ds.dims[coord_list[coord]] != len(ds.variables[coord]): + if ds.sizes[coord_list[coord]] != len(ds.variables[coord]): raise IndexError( coord + ' must have the same ' + 'value as length of ' + coord_list[coord] ) @@ -433,8 +455,14 @@ def add_in_nan(time, data): mode = stats.mode(diff, keepdims=True).mode[0] except TypeError: mode = stats.mode(diff).mode[0] + index = np.where(diff > (2.0 * mode)) + # If the data is not float time and we try to insert a NaN it will + # not auto upconvert the data. Need to convert before inserting NaN. + if len(index) > 0 and np.issubdtype(data.dtype, np.integer): + data = data.astype('float32') + offset = 0 for i in index[0]: corr_i = i + offset @@ -987,7 +1015,6 @@ def convert_to_potential_temp( temp_var_units=None, press_var_units=None, ): - """ Converts temperature to potential temperature. @@ -1257,9 +1284,7 @@ def arm_site_location_search(site_code='sgp', facility_code=None): "distinct_facility_code": { "terms": { "field": "facility_code.keyword", - "order": { - "_key": "asc" - }, + "order": {"_key": "asc"}, "size": 7000, }, "aggs": { @@ -1271,7 +1296,7 @@ def arm_site_location_search(site_code='sgp', facility_code=None): "facility_code", "location", ], - "size": 1 + "size": 1, }, }, }, @@ -1286,7 +1311,9 @@ def arm_site_location_search(site_code='sgp', facility_code=None): } # Uses requests to grab metadata from arm.gov. - response = requests.get('https://adc.arm.gov/elastic/metadata/_search', headers=headers, json=json_data) + response = requests.get( + 'https://adc.arm.gov/elastic/metadata/_search', headers=headers, json=json_data + ) # Loads the text to a dictionary response_dict = json.loads(response.text) @@ -1294,19 +1321,203 @@ def arm_site_location_search(site_code='sgp', facility_code=None): coord_dict = {} # Loop through each facility. for i in range(len(response_dict['aggregations']['distinct_facility_code']['buckets'])): - site_info = response_dict['aggregations']['distinct_facility_code']['buckets'][i]['hits']['hits']['hits'][0]['_source'] + site_info = response_dict['aggregations']['distinct_facility_code']['buckets'][i]['hits'][ + 'hits' + ]['hits'][0]['_source'] site = site_info['site_code'] facility = site_info['facility_code'] # Some sites do not contain coordinate information, return None if that is the case. if site_info['location'] is None: - coords = {'latitude': None, - 'longitude': None} + coords = {'latitude': None, 'longitude': None} else: lat, lon = site_info['location'].split(',') lat = float(lat) lon = float(lon) - coords = {'latitude': lat, - 'longitude': lon} + coords = {'latitude': lat, 'longitude': lon} coord_dict.setdefault(site + ' ' + facility, coords) return coord_dict + + +def calculate_percentages(ds, fields, time=None, time_slice=None, threshold=None, fill_value=0.0): + """ + This function calculates percentages of different fields of a dataset. + + Parameters + ---------- + ds : ACT Dataset + The ACT dataset to calculate the percentages on. + fields : list + A list of all the fields to use in the percentage calculations. + time : datetime + A single datetime to calculate percentages on if desired. Default + is None and all data will be included. + time_slice : tuple + A tuple of two datetimes to grab all data between those two datatimes. + Default is None and all data will be included. + threshold : float + Threshold in which anything below will be considered invalid. + Default is None. + fill_value : float + Fill value for invalid data. Only used if a threshold is provided. + + Returns + ------- + percentages : dict + A dictionary containing the fields provided and their corresponding + percentage that was calculated. + + """ + # Copy Dataset so we are not overriding the data. + ds_percent = ds.copy() + + # Check if any incorrect values based on a threshold and replace with a fill + # value. + if threshold is not None: + for field in fields: + ds_percent[field] = ds_percent[field].where(ds_percent[field] > threshold, fill_value) + + # Raise warning if negative values present in a field. + if threshold is None: + for field in fields: + res = np.all(ds_percent[field].values >= 0.0) + if not res: + warnings.warn( + f"{field} contains negatives values, consider using a threshold.", + UserWarning, + ) + + # Select the data based on time, multiple times within a slice, or + # a sample of times per a timestep. + if time is not None: + ds_percent = ds_percent.sel(time=time) + elif time_slice is not None: + ds_percent = ds_percent.sel(time=slice(time_slice[0], time_slice[1])) + else: + warnings.warn( + "No time parameter used, calculating a mean for each field for the whole dataset.", + UserWarning, + ) + + # Calculate concentration percentage of each field in the air. + values = [ds_percent[field].mean(skipna=True).values for field in fields] + total = sum(values) + percent_values = [(value / total) * 100 for value in values] + + # Create a dictionary of the fields and their percentages. + percentages = {} + for i, j in zip(fields, percent_values): + percentages[i] = j + ds_percent.close() + return percentages + + +def convert_2d_to_1d( + ds, + parse=None, + variables=None, + keep_name_if_one=False, + use_dim_value_in_name=False, + dim_labels=None, +): + """ + Function to convert a single 2D variable into multiple 1D + variables using the second dimension in the new variable name. + + Parameters + ---------- + ds: xarray.dataset + Object containing 2D variable to be converted + parse: str or None + Coordinate dimension name to parse along. If set to None will + guess the non-time dimension is the parse dimension. + variables: str or list of str + Variable name or names to parse. If not provided will attempt to + parse all two dimensional variables with the parse coordinate + dimension. + keep_name_if_one: boolean + Option to not modify the variable name if the coordinate dimension + has only one value. Essentially converting a 2D (i.e. (100,1) + variable into a 1D variable (i.e. (100)). + use_dim_value_in_name: boolean + Option to use value from the coordinate dimension in new variable + name instead of indexing number. Will use the value prepended + to the units of the dimension. + dim_labels: str or list of str + Allows for use of custom label to append to end of variable names + + Returns + ------- + A new object copied from input object with the multi-dimensional + variable split into multiple single-dimensional variables. + + Example + ------- + # This will get the name of the coordinate dimension so it does not need to + # be hard coded. + >>> parse_dim = (list(set(list(ds.dims)) - set(['time'])))[0] + + # Now use the parse_dim name to parse the variable and return new object. + >>> new_ds = convert_2d_to_1d(ds, parse=parse_dim) + + """ + # If no parse dimension name given assume it is the one not equal to 'time' + if parse is None: + parse = (list(set(list(ds.dims)) - {'time'}))[0] + + new_ds = ds.copy() + + if variables is not None and isinstance(variables, str): + variables = [variables] + + if variables is None: + variables = list(new_ds.variables) + + if dim_labels is not None and isinstance(dim_labels, (str,)): + dim_labels = [dim_labels] + + # Check if we want to keep the names the same if the second dimension + # is of size one. + num_dims = 1 + if keep_name_if_one: + num_dims = 2 + + parse_values = ds[parse].values + for var in variables: + if var == parse: + continue + # Check if the parse dimension is in the dimension tuple + if parse in new_ds[var].dims: + if len(new_ds[parse]) >= num_dims: + for i in range(0, new_ds.sizes[parse]): + if dim_labels is not None: + new_var_name = '_'.join([var, dim_labels[i]]) + elif use_dim_value_in_name: + level = str(parse_values[i]) + ds[parse].attrs['units'] + new_var_name = '_'.join([var, parse, level]) + else: + new_var_name = '_'.join([var, parse, str(i)]) + new_var = new_ds[var].copy() + new_ds[new_var_name] = new_var.isel(indexers={parse: i}) + + try: + ancillary_variables = new_ds[new_var_name].attrs['ancillary_variables'] + current_qc_var_name = ds.qcfilter.check_for_ancillary_qc( + var, add_if_missing=False + ) + if current_qc_var_name is not None: + ancillary_variables = ancillary_variables.replace( + current_qc_var_name, 'qc_' + new_var_name + ) + new_ds[new_var_name].attrs['ancillary_variables'] = ancillary_variables + except KeyError: + pass + + # Remove the old 2D variable after extracting + del new_ds[var] + + else: + # Keep the same name but remove the dimension equal to size 1 + new_ds[var] = new_ds[var].squeeze(dim=parse) + + return new_ds diff --git a/act/utils/datetime_utils.py b/act/utils/datetime_utils.py index e2e890bf9e..b65cfbec79 100644 --- a/act/utils/datetime_utils.py +++ b/act/utils/datetime_utils.py @@ -55,13 +55,15 @@ def numpy_to_arm_date(_date, returnTime=False): """ from dateutil.parser._parser import ParserError + from pandas._libs.tslibs.parsing import DateParseError + try: date = pd.to_datetime(str(_date)) if returnTime is False: date = date.strftime('%Y%m%d') else: date = date.strftime('%H%M%S') - except ParserError: + except (ParserError, DateParseError): date = None return date @@ -261,9 +263,12 @@ def adjust_timestamp(ds, time_bounds='time_bounds', align='left', offset=None): elif align == 'right': time_start = [np.datetime64(t[1]) for t in time_bounds] elif align == 'center': - time_start = [np.datetime64(t[0]) + (np.datetime64(t[0]) - np.datetime64(t[1])) / 2. for t in time_bounds] + time_start = [ + np.datetime64(t[0]) + (np.datetime64(t[0]) - np.datetime64(t[1])) / 2.0 + for t in time_bounds + ] else: - raise ValueError('Align should be set to one of [left, right, middle]') + raise ValueError('Align should be set to one of [left, right, center]') elif offset is not None: time = ds['time'].values @@ -271,6 +276,7 @@ def adjust_timestamp(ds, time_bounds='time_bounds', align='left', offset=None): else: raise ValueError('time_bounds variable is not available') + time_start = np.array(time_start).astype('datetime64[ns]') ds = ds.assign_coords({'time': time_start}) return ds diff --git a/act/utils/geo_utils.py b/act/utils/geo_utils.py index 27c2dac85c..b7361751e9 100644 --- a/act/utils/geo_utils.py +++ b/act/utils/geo_utils.py @@ -4,13 +4,10 @@ """ -import re from datetime import datetime, timedelta, timezone from pathlib import Path -import dateutil.parser import numpy as np -import pandas as pd import pytz from skyfield import almanac from skyfield.api import load, load_file, wgs84 diff --git a/act/utils/inst_utils.py b/act/utils/inst_utils.py index e48f95af0e..c97a40de87 100644 --- a/act/utils/inst_utils.py +++ b/act/utils/inst_utils.py @@ -140,6 +140,10 @@ def decode_present_weather(ds, variable=None, decoded_name=None): # Get data and fill nans with -9999 data = ds[variable] data = data.fillna(-9999) + data.values[data.values == 'ER'] = -9999 + + # Check if string codes instead of ints + data = data.astype('int64') # Get the weather type for each code wx_type = [weather[d] for d in data.values] diff --git a/act/utils/io_utils.py b/act/utils/io_utils.py index 839b7b8ae9..236f1beccb 100644 --- a/act/utils/io_utils.py +++ b/act/utils/io_utils.py @@ -1,20 +1,22 @@ +import act +import numpy as np +import pandas as pd from pathlib import Path import tarfile +from os import sep from os import PathLike from shutil import rmtree -import random -import string import gzip import shutil import tempfile -import numpy as np import types try: + import moviepy.editor as moviepy_editor import moviepy.video.io.ImageSequenceClip - from moviepy.video.io.VideoFileClip import VideoFileClip + MOVIEPY_AVAILABLE = True -except ImportError: +except (ImportError, RuntimeError): MOVIEPY_AVAILABLE = False @@ -23,8 +25,6 @@ def pack_tar(filenames, write_filename=None, write_directory=None, remove=False) Creates TAR file from list of filenames provided. Currently only works with all files existing in the same directory. - ... - Parameters ---------- filenames : str or list @@ -77,13 +77,12 @@ def pack_tar(filenames, write_filename=None, write_directory=None, remove=False) return str(write_filename) -def unpack_tar(tar_files, write_directory=None, temp_dir=False, randomize=True, - return_files=True, remove=False): +def unpack_tar( + tar_files, write_directory=None, temp_dir=False, randomize=True, return_files=True, remove=False +): """ Unpacks TAR file contents into provided base directory - ... - Parameters ---------- tar_files : str or list @@ -138,7 +137,7 @@ def unpack_tar(tar_files, write_directory=None, temp_dir=False, randomize=True, files.extend(result) tar.close() except tarfile.ReadError: - print(f"\nCould not extract files from {tar_file}") + print("Could not extract files from the tar_file") if return_files is False: files = str(out_dir) @@ -156,8 +155,6 @@ def cleanup_files(dirname=None, files=None): """ Cleans up files and directory possibly created from unpacking TAR files with unpack_tar() - ... - Parameters ---------- dirname : str, pathlib.Path, None @@ -210,8 +207,6 @@ def pack_gzip(filename, write_directory=None, remove=False): """ Creates a gunzip file from a filename path - ... - Parameters ---------- filename : str, pathlib.Path @@ -250,8 +245,6 @@ def unpack_gzip(filename, write_directory=None, remove=False): """ Extracts file from a gunzip file. - ... - Parameters ---------- filename : str, pathlib.Path @@ -291,8 +284,6 @@ def generate_movie(images, write_filename=None, fps=10, **kwargs): """ Creates a movie from a list of images or convert movie to different type - ... - Parameters ---------- images : list, PosixPath generator, path to a directory, single string/PosixPath to movie @@ -316,9 +307,7 @@ def generate_movie(images, write_filename=None, fps=10, **kwargs): """ if not MOVIEPY_AVAILABLE: - raise ImportError( - 'MoviePy needs to be installed on your system to make movies.' - ) + raise ImportError('MoviePy needs to be installed on your system to make movies.') # Set default movie name if write_filename is None: @@ -340,13 +329,227 @@ def generate_movie(images, write_filename=None, fps=10, **kwargs): write_directory.mkdir(parents=True, exist_ok=True) if IS_MOVIE: - with VideoFileClip(images) as clip: - # Not sure why but need to set the duration of the clip with subclip() to write - # the full file out. - clip = clip.subclip(t_start=clip.start, t_end=clip.end * clip.fps) - clip.write_videofile(str(write_filename), fps=fps, **kwargs) + with moviepy_editor.VideoFileClip(images) as clip: + # There can be an issue converting mpeg to other movie format because the + # duration parameter in the movie file is not set. So moviepy guesses and + # can get the duration wrong. This will find the correct duration (correct to 0.2 seconds) + # and set before writing. + if Path(images).suffix == '.mpg': + import numpy as np + import warnings + from collections import deque + + with warnings.catch_warnings(): + warnings.filterwarnings('ignore', category=UserWarning) + desired_len = 3 + frame_sums = deque() + duration = 0.0 # Duration of movie in seconds + while True: + result = clip.get_frame(duration) + frame_sums.append(np.sum(result)) + if len(frame_sums) > desired_len: + frame_sums.popleft() + + if len(set(frame_sums)) == 1: + break + + duration += 0.1 + + clip = clip.set_start(0) + clip = clip.set_duration(duration) + clip = clip.set_end(duration) + clip.write_videofile(str(write_filename), **kwargs) + + else: + clip.write_videofile(str(write_filename), **kwargs) + else: clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(images, fps=fps) clip.write_videofile(str(write_filename), **kwargs) return str(write_filename) + + +def arm_standards_validator(file=None, dataset=None, verbose=True): + """ + ARM Data Validator (ADV) - Checks to ensure that ARM standards are being followed + in the files or dataset passed to it. Note, this includes a minimal set of + standards that it checks against + + Parameters + ---------- + file : str + Filename to check against ARM standards. Do not pass in both a file and dataset + dataset : xarray.DataSet + Xarray dataset of an already read in file. + verbose : boolean + Defaults to print out errors in addition to returning a list of them + + Returns + ------- + err : list + List of errors in the data + + """ + + # Set up the error tracking list + err = [] + if file is not None and isinstance(file, str): + # Check file naming standards + if len(file.split(sep)[-1]) > 60.0: + err.append('Filename length exceeds 60 characters') + try: + f_obj = act.utils.data_utils.DatastreamParserARM(file) + except Exception as e: + print(e) + + if ( + (f_obj.site is None) + or (f_obj.datastream_class is None) + or (f_obj.level is None) + or (f_obj.facility is None) + or (f_obj.date is None) + or (f_obj.time is None) + or (f_obj.ext is None) + ): + err.append( + 'Filename does not follow the normal ARM convention: ' + + '(sss)(inst)(qualifier)(temporal)(Fn).(dl).(yyyymmdd).(hhmmss).nc' + ) + else: + if f_obj.level[0] not in ['0', 'a', 'b', 'c', 's', 'm']: + err.append(f_obj.level + ' is not a standard ARM data level') + + results = act.utils.arm_site_location_search( + site_code=f_obj.site, facility_code=f_obj.facility + ) + if len(results) == 0: + err.append('Site and facility are not ARM standard') + + # The ability to read a file from NetCDF to xarray will catch a lot of the + # problems with formatting. This would leave standard ARM checks + try: + if dataset is None and file is not None: + ds = act.io.read_arm_netcdf(file) + elif dataset is not None: + ds = dataset + else: + raise ValueError('File and dataset are both None') + except Exception as e: + return ['File is not in a standard format that is readable by xarray: ' + str(e)] + + # Review time variables for errors for conformance to standards + if 'time' not in list(ds.dims)[0]: + err.append('"time" is required to be the first dimension.') + + for c in list(ds.coords): + if c not in ds.dims: + err.append(c + ': Coordinate is not included in dimensions.') + + if any(np.isnan(ds['time'].values)): + err.append('Time must not include NaNs.') + + duplicates = sum(ds['time'].to_pandas().duplicated()) + if duplicates > 0: + err.append('Duplicate times present in the file') + + diff = ds['time'].diff('time') + idx = np.where(diff <= pd.Timedelta(0)) + if len(idx[0]) > 0: + err.append('Time is not in increasing order') + + if 'base_time' not in ds or 'time_offset' not in ds: + err.append('ARM requires base_time and time_offset variables.') + + # Check to make sure other coordinate variables don't have nans + # Also check to make sure coordinate variables are not decreasing + if len(list(ds.coords)) > 1: + for d in ds.coords: + if d == 'time': + continue + if any(np.isnan(ds[d].values)): + err.append('Coordinates must not include NaNs ' + d) + + diff = ds[d].diff(d) + idx = np.where(diff <= 0.0) + if len(idx[0]) > 0: + err.append(d + ' is not in increasing order') + if 'missing_value' in ds[d].encoding: + err.append(d + ' should not include missing value') + + # Verify that each variable has a long_name and units attributes + for v in ds: + if (len(ds[v].dims) > 0) and ('time' not in list(ds[v].dims)[0]) and ('bounds' not in v): + err.append(v + ': "time" is required to be the first dimension.') + if (ds[v].size == 1) and (len(ds[v].dims) > 0): + err.append(v + ': is not defined as a scalar.') + if 'long_name' not in ds[v].attrs: + err.append('Required attribute long_name not in ' + v) + else: + if not ds[v].attrs['long_name'][0].isupper(): + err.append(v + ' long_name attribute does not start with uppercase') + + if ( + ('qc_' not in v) + and (v not in ['time', 'time_offset', 'base_time', 'lat', 'lon', 'alt']) + and ('bounds' not in v) + ): + if ('missing_value' not in ds[v].encoding) and ('FillValue' not in ds[v].encoding): + err.append(v + ' does not include missing_value or FillValue attributes') + + # QC variable checks + if 'qc_' in v: + if v[3:] not in ds: + err.append('QC variable does not have a corresponding variable ' + v[3:]) + if 'ancillary_variables' not in ds[v[3:]].attrs: + err.append( + v[3:] + ' does not include ancillary_variable attribute pointing to ' + v + ) + if 'description' not in ds[v].attrs: + err.append(v + ' does not include description attribute') + if 'flag_method' not in ds[v].attrs: + err.append(v + ' does not include flag_method attribute') + + if (v not in ['base_time', 'time_offset']) and ('bounds' not in v): + if 'units' not in ds[v].attrs: + err.append('Required attribute units not in ' + v) + + # Lat/Lon/Alt Checks + if 'lat' not in ds: + err.append('ARM requires the latitude variable to be named lat') + else: + if 'standard_name' in ds['lat'].attrs: + if ds['lat'].attrs['standard_name'] != 'latitude': + err.append('ARM requires the lat standard_name to be latitude') + else: + err.append('"lat" variable does not have a standard_name attribute') + if 'lon' not in ds: + err.append('ARM requires the longitude variable to be named lon') + else: + if 'standard_name' in ds['lon'].attrs: + if ds['lon'].attrs['standard_name'] != 'longitude': + err.append('ARM requires the lon standard_name to be longitude') + else: + err.append('"long" variable does not have a standard_name attribute') + if 'alt' not in ds: + err.append('ARM requires the altitude variable to be named alt') + else: + if 'standard_name' in ds['alt'].attrs: + if ds['alt'].attrs['standard_name'] != 'altitude': + err.append('ARM requires the alt standard_name to be altitude') + else: + err.append('"alt" variable does not have a standard_name attribute') + + # Required global attributes + req_att = ['doi', 'sampling_interval', 'averaging_interval'] + for ra in req_att: + if ra not in ds.attrs: + err.append('Global attribute is missing: ' + ra) + + if verbose: + if len(err) > 0: + [print(e) for e in err] + else: + print('File is passing standards checks') + + return err diff --git a/continuous_integration/environment_actions.yml b/continuous_integration/environment_actions.yml index 0443eb0502..1351459a6f 100644 --- a/continuous_integration/environment_actions.yml +++ b/continuous_integration/environment_actions.yml @@ -24,11 +24,11 @@ dependencies: - coveralls - pandas - shapely - - pip - lazy_loader - cmweather - - arm-test-data - moviepy + - ruff + - pip - pip: - mpl2nc - metpy @@ -36,3 +36,4 @@ dependencies: - arm_pyart - icartt - aiohttp>=3.9.0b1 + - git+https://github.com/ARM-DOE/arm-test-data.git diff --git a/docs/environment_docs.yml b/docs/environment_docs.yml index a1c5c2a7e4..dd1089e231 100644 --- a/docs/environment_docs.yml +++ b/docs/environment_docs.yml @@ -18,14 +18,13 @@ dependencies: - scikit-posthocs - pip - shapely<1.8.3 - - arm-test-data - moviepy - pip: - mpl2nc - lazy_loader - metpy>=1.2 - arm-pyart - - sphinx + - sphinx<7.2 - sphinx_gallery - sphinx-copybutton - pydata-sphinx-theme<0.9.0 @@ -40,3 +39,4 @@ dependencies: - sphinxcontrib-htmlhelp==2.0.4 - sphinxcontrib-qthelp==1.0.6 - sphinxcontrib-serializinghtml==1.1.9 + - git+https://github.com/ARM-DOE/arm-test-data.git diff --git a/docs/source/blog_posts/2022/sail_campaign_arm_and_noaa.ipynb b/docs/source/blog_posts/2022/sail_campaign_arm_and_noaa.ipynb index ac8baad20b..dea412251c 100644 --- a/docs/source/blog_posts/2022/sail_campaign_arm_and_noaa.ipynb +++ b/docs/source/blog_posts/2022/sail_campaign_arm_and_noaa.ipynb @@ -76,9 +76,11 @@ "source": [ "# Download the NOAA KPS site files from 22:00 and 23:00\n", "result_22_kps = act.discovery.download_noaa_psl_data(\n", - " site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='22')\n", + " site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='22'\n", + ")\n", "result_23_kps = act.discovery.download_noaa_psl_data(\n", - " site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='23')" + " site='kps', instrument='Radar FMCW Moment', startdate='20220801', hour='23'\n", + ")" ] }, { @@ -94,8 +96,10 @@ "ds1_kps = act.io.noaapsl.read_psl_radar_fmcw_moment([result_22_kps[-1], result_23_kps[-1]])\n", "\n", "# Read in the parsivel files from NOAA's webpage.\n", - "url = ['https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221322_stats.txt',\n", - " 'https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221323_stats.txt']\n", + "url = [\n", + " 'https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221322_stats.txt',\n", + " 'https://downloads.psl.noaa.gov/psd2/data/realtime/DisdrometerParsivel/Stats/kps/2022/213/kps2221323_stats.txt',\n", + "]\n", "ds2_kps = act.io.noaapsl.read_psl_parsivel(url)" ] }, @@ -124,13 +128,23 @@ "# Create display object with both datasets\n", "display = act.plotting.TimeSeriesDisplay(\n", " {\"NOAA Site KPS PSL Radar FMCW\": kps_ds1, \"NOAA Site KPS Parsivel\": kps_ds2},\n", - " subplot_shape=(2,), figsize=(10, 10))\n", + " subplot_shape=(2,),\n", + " figsize=(10, 10),\n", + ")\n", "\n", "# Plot the subplots\n", - "display.plot('reflectivity_uncalibrated', dsname='NOAA Site KPS PSL Radar FMCW',\n", - " cmap='act_HomeyerRainbow', subplot_index=(0,))\n", - "display.plot('number_density_drops', dsname='NOAA Site KPS Parsivel',\n", - " cmap='act_HomeyerRainbow', subplot_index=(1,))\n", + "display.plot(\n", + " 'reflectivity_uncalibrated',\n", + " dsname='NOAA Site KPS PSL Radar FMCW',\n", + " cmap='act_HomeyerRainbow',\n", + " subplot_index=(0,),\n", + ")\n", + "display.plot(\n", + " 'number_density_drops',\n", + " dsname='NOAA Site KPS Parsivel',\n", + " cmap='act_HomeyerRainbow',\n", + " subplot_index=(1,),\n", + ")\n", "# Set limits\n", "display.axes[1].set_ylim([0, 10])\n", "plt.show()" @@ -154,8 +168,8 @@ "# Use arm username and token to retrieve files.\n", "# This is commented out as the files have already been downloaded.\n", "\n", - "#token = 'arm_token'\n", - "#username = 'arm_username'" + "# token = 'arm_token'\n", + "# username = 'arm_username'" ] }, { @@ -165,16 +179,16 @@ "metadata": {}, "outputs": [], "source": [ - "#Specify datastream and date range for KAZR data\n", + "# Specify datastream and date range for KAZR data\n", "ds_kazr = 'guckazrcfrgeM1.a1'\n", "startdate = '2022-08-01'\n", "enddate = '2022-08-01'\n", "\n", "# Data already retrieved, but showing code below on how to download the files.\n", - "#act.discovery.download_data(username, token, ds_kazr, startdate, enddate)\n", + "# act.discovery.download_data(username, token, ds_kazr, startdate, enddate)\n", "\n", "# Index last 2 files for the 22:00 and 23:00 timeframe.\n", - "kazr_files = glob.glob(''.join(['./',ds_kazr,'/*nc']))\n", + "kazr_files = glob.glob(''.join(['./', ds_kazr, '/*nc']))\n", "kazr_files[-2:]\n", "kazr_ds = act.io.arm.read_arm_netcdf(kazr_files[-2:])" ] @@ -186,16 +200,16 @@ "metadata": {}, "outputs": [], "source": [ - "#Specify datastream and date range for KAZR data\n", + "# Specify datastream and date range for KAZR data\n", "ds_ld = 'gucldM1.b1'\n", "startdate = '2022-08-01'\n", "enddate = '2022-08-01'\n", "\n", "# Data already retrieved, but showing code below on how to download the files.\n", - "#act.discovery.download_data(username, token, ds_ld, startdate, enddate)\n", + "# act.discovery.download_data(username, token, ds_ld, startdate, enddate)\n", "\n", "# Index last 2 files for the 22:00 and 23:00 timeframe.\n", - "ld_files = glob.glob(''.join(['./',ds_ld,'/*cdf']))\n", + "ld_files = glob.glob(''.join(['./', ds_ld, '/*cdf']))\n", "ld_ds = act.io.arm.read_arm_netcdf(ld_files[0])" ] }, @@ -233,22 +247,39 @@ "\n", "# Create a series display with all 4 datasets\n", "display = act.plotting.TimeSeriesDisplay(\n", - " {\"NOAA KPS PSL Radar FMCW\": kps_ds1, \"NOAA KPS Parsivel\": kps_ds2,\n", - " \"guckazrcfrgeM1.a1\": kazr_ds, 'gucldM1.b1': ld_ds},\n", - " subplot_shape=(2, 2), figsize=(22, 12))\n", + " {\n", + " \"NOAA KPS PSL Radar FMCW\": kps_ds1,\n", + " \"NOAA KPS Parsivel\": kps_ds2,\n", + " \"guckazrcfrgeM1.a1\": kazr_ds,\n", + " 'gucldM1.b1': ld_ds,\n", + " },\n", + " subplot_shape=(2, 2),\n", + " figsize=(22, 12),\n", + ")\n", "\n", "# Set custom 2 line title for space\n", "title = \"NOAA KPS PSL Radar FMCW\\n reflectivity_uncalibrated on 20220801\"\n", "\n", "# Plot the four subplots\n", - "display.plot('reflectivity_uncalibrated', dsname='NOAA KPS PSL Radar FMCW',\n", - " cmap='act_HomeyerRainbow', set_title=title, subplot_index=(0, 1))\n", - "display.plot('number_density_drops', dsname='NOAA KPS Parsivel',\n", - " cmap='act_HomeyerRainbow', subplot_index=(1, 1))\n", - "display.plot('reflectivity', dsname='guckazrcfrgeM1.a1',\n", - " cmap='act_HomeyerRainbow', subplot_index=(0, 0))\n", - "display.plot('number_density_drops', dsname='gucldM1.b1',\n", - " cmap='act_HomeyerRainbow', subplot_index=(1, 0))\n", + "display.plot(\n", + " 'reflectivity_uncalibrated',\n", + " dsname='NOAA KPS PSL Radar FMCW',\n", + " cmap='act_HomeyerRainbow',\n", + " set_title=title,\n", + " subplot_index=(0, 1),\n", + ")\n", + "display.plot(\n", + " 'number_density_drops',\n", + " dsname='NOAA KPS Parsivel',\n", + " cmap='act_HomeyerRainbow',\n", + " subplot_index=(1, 1),\n", + ")\n", + "display.plot(\n", + " 'reflectivity', dsname='guckazrcfrgeM1.a1', cmap='act_HomeyerRainbow', subplot_index=(0, 0)\n", + ")\n", + "display.plot(\n", + " 'number_density_drops', dsname='gucldM1.b1', cmap='act_HomeyerRainbow', subplot_index=(1, 0)\n", + ")\n", "\n", "# Update limits\n", "display.axes[1, 0].set_ylim([0, 10])\n", @@ -257,11 +288,11 @@ "\n", "\n", "display.axes[0, 0].set_ylim([0, 10000])\n", - "display.axes[0, 0].set_yticklabels(['0', '2', '4','6', '8', '10'])\n", + "display.axes[0, 0].set_yticklabels(['0', '2', '4', '6', '8', '10'])\n", "display.axes[0, 0].set_ylabel('km')\n", "\n", "display.axes[0, 1].set_ylim([0, 10000])\n", - "display.axes[0, 1].set_yticklabels(['0', '2', '4','6', '8', '10'])\n", + "display.axes[0, 1].set_yticklabels(['0', '2', '4', '6', '8', '10'])\n", "display.axes[0, 1].set_ylabel('km')\n", "\n", "plt.show()" @@ -282,13 +313,13 @@ "metadata": {}, "outputs": [], "source": [ - "#Specify datastream and date range for KAZR data\n", + "# Specify datastream and date range for KAZR data\n", "ds_dl = 'gucdlppiM1.b1'\n", "startdate = '2022-08-01'\n", "enddate = '2022-08-01'\n", "\n", - "#act.discovery.download_data(username, token, ds_dl, startdate, enddate)\n", - "dl_ppi_files = glob.glob(''.join(['./',ds_dl,'/*cdf']))" + "# act.discovery.download_data(username, token, ds_dl, startdate, enddate)\n", + "dl_ppi_files = glob.glob(''.join(['./', ds_dl, '/*cdf']))" ] }, { @@ -306,7 +337,8 @@ " ds = act.io.arm.read_arm_netcdf(file)\n", " # Calculate the winds for each gucdlppi dataset.\n", " wind_ds = act.retrievals.compute_winds_from_ppi(\n", - " ds, remove_all_missing=True, snr_threshold=0.008)\n", + " ds, remove_all_missing=True, snr_threshold=0.008\n", + " )\n", " multi_ds.append(wind_ds)\n", "\n", "wind_ds = xr.merge(multi_ds)" @@ -332,15 +364,20 @@ "source": [ "# Create a display object.\n", "display = act.plotting.TimeSeriesDisplay(\n", - " {\"GUC DLPPI Computed Winds over KAZR\": wind_ds,\n", - " \"guckazrcfrgeM1.a1\": kazr_ds,}, figsize=(20, 10))\n", + " {\n", + " \"GUC DLPPI Computed Winds over KAZR\": wind_ds,\n", + " \"guckazrcfrgeM1.a1\": kazr_ds,\n", + " },\n", + " figsize=(20, 10),\n", + ")\n", "\n", "# Plot the wind barbs overlayed on the KAZR reflectivity\n", - "display.plot('reflectivity', dsname='guckazrcfrgeM1.a1',\n", - " cmap='act_HomeyerRainbow', vmin=-20, vmax=30)\n", - "display.plot_barbs_from_spd_dir('wind_speed', 'wind_direction',\n", - " dsname='GUC DLPPI Computed Winds over KAZR',\n", - " invert_y_axis=False)\n", + "display.plot(\n", + " 'reflectivity', dsname='guckazrcfrgeM1.a1', cmap='act_HomeyerRainbow', vmin=-20, vmax=30\n", + ")\n", + "display.plot_barbs_from_spd_dir(\n", + " 'wind_speed', 'wind_direction', dsname='GUC DLPPI Computed Winds over KAZR', invert_y_axis=False\n", + ")\n", "\n", "# Update the x-limits to make sure both wind profiles are shown\n", "# Update the y-limits to show plotted winds\n", diff --git a/docs/source/blog_posts/2024/2024_Eclipse_SGP.ipynb b/docs/source/blog_posts/2024/2024_Eclipse_SGP.ipynb new file mode 100644 index 0000000000..064d4e47c3 --- /dev/null +++ b/docs/source/blog_posts/2024/2024_Eclipse_SGP.ipynb @@ -0,0 +1,392 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ba8afc29-c4e7-45d3-b161-df6130572294", + "metadata": {}, + "source": [ + "# April 8, 2024 Eclipse - Data from ARM's Southern Great Plains (SGP) Observatory" + ] + }, + { + "cell_type": "markdown", + "id": "3df58de5-b3d2-4946-bf31-abde776706c4", + "metadata": {}, + "source": [ + "The 2024 solar eclipse was an exciting event that saw roughly 90% coverage at ARM's SGP observatory. The large array of instrumentation at the site provides a unique view into the atmospheric impacts of the eclipse. This notebook gathers a few of the instruments together for a close look at the data during the event.\n", + "\n", + "## Step 1: Import our libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 316, + "id": "0ef46098-7491-4e17-875e-c724351a2b5b", + "metadata": {}, + "outputs": [], + "source": [ + "import act\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors" + ] + }, + { + "cell_type": "markdown", + "id": "df2a97fd-d79f-4e15-a0f7-fbda69c091b3", + "metadata": {}, + "source": [ + "## Step 2: Download data!\n", + "If you have not used the ARM Live webservice before, please take a moment to check it out and login (https://adc.arm.gov/armlive/). Please insert your own username and token after you log in below.\n", + "\n", + "For this case, we're going to look at a few different instruments and download the data using ACT.\n", + "\n", + "### Instruments\n", + "#### Doppler Lidar (DL)\n", + "The doppler lidar measures radial velocity and can be used to observe vertical air motion.\n", + "\n", + "#### Solar and Infrared Radiation Station (SIRS)\n", + "SIRS provides continuous measurements of broadband shortwave and longwave irradiances.\n", + "\n", + "#### Surface Meteorological Station (MET)\n", + "The MET system measures basic surface meteorology like air temperature and wind speeds.\n", + "\n", + "#### Eddy Correlation Flux Measurement System (ECOR)\n", + "The eddy correlation (ECOR) flux measurement system provides half-hour measurements of the surface turbulent fluxes of momentum, sensible heat, latent heat, and carbon dioxide.\n", + "\n", + "#### Radar Wind Profiler (RWP)\n", + "The RWP transmits electromagnetic energy into the atmosphere in as many as five directions (four tilted in opposing vertical planes and on vertical) and measures the strength and frequency of backscattered energy. Calculation of the Doppler shift of the returned signal allows calculation of the atmospheric wind profile.\n", + "\n", + "#### Ultrafine Condensation Particle Counter (CPCUF)\n", + "Depending on the CPC type, typical CPC instruments can count particles with sizes that range from 3 to 3000 nanometers (ultrafine CPC) or from 10 to 3000 nanometers (fine CPC). The CPC is part of the aerosol observing system (AOS).\n", + "\n", + "#### Scanning Mobility Particle Sizer\n", + "The scanning mobility particle sizer (SMPS) is a particle size spectrometer that measures the aerosol number size distribution by sizing particles based on their electrical mobility diameter using a differential mobility analyzer (DMA) and by counting particles using a condensation particle counter (CPC). \n", + "\n", + "* Some descriptions taken from the www.arm.gov instrument webpages." + ] + }, + { + "cell_type": "code", + "execution_count": 351, + "id": "3b417b83-d59d-4e69-a6e3-762cae8455ae", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[DOWNLOADING] sgpdlfptE13.b1.20240408.190019.cdf\n", + "[DOWNLOADING] sgpdlfptE13.b1.20240408.180018.cdf\n", + "[DOWNLOADING] sgpdlfptE13.b1.20240408.200019.cdf\n", + "[DOWNLOADING] sgpdlfptE13.b1.20240408.170018.cdf\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Newsom, R., Shi, Y., & Krishnamurthy, R. Doppler Lidar (DLFPT). Atmospheric\n", + "Radiation Measurement (ARM) User Facility. https://doi.org/10.5439/1025185\n", + "\n", + "[DOWNLOADING] sgpecorsfE14.b1.20240408.000000.nc\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Sullivan, R., Cook, D., Shi, Y., Keeler, E., & Pal, S. Eddy Correlation Flux\n", + "Measurement System (ECORSF). Atmospheric Radiation Measurement (ARM) User\n", + "Facility. https://doi.org/10.5439/1494128\n", + "\n", + "[DOWNLOADING] sgpmetE13.b1.20240408.000000.cdf\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Kyrouac, J., Shi, Y., & Tuftedal, M. Surface Meteorological Instrumentation\n", + "(MET). Atmospheric Radiation Measurement (ARM) User Facility.\n", + "https://doi.org/10.5439/1786358\n", + "\n", + "[DOWNLOADING] sgpsirsE13.b1.20240408.000000.cdf\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Shi, Y., Sengupta, M., Xie, Y., Jaker, S., Yang, J., Reda, I., Andreas, A., &\n", + "Habte, A. Solar and Infrared Radiation Station for Downwelling and Upwelling\n", + "Radiation (SIRS). Atmospheric Radiation Measurement (ARM) User Facility.\n", + "https://doi.org/10.5439/1475460\n", + "\n", + "[DOWNLOADING] sgpaoscpcufE13.b1.20240408.000000.nc\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Koontz, A., Bullard, R., Andrews, E., Kuang, C., Hayes, C., Singh, A., & Salwen,\n", + "C. Condensation Particle Counter (AOSCPCUF). Atmospheric Radiation Measurement\n", + "(ARM) User Facility. https://doi.org/10.5439/1378933\n", + "\n", + "[DOWNLOADING] sgpaossmpsE13.b1.20240408.000000.nc\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Kuang, C., Singh, A., Howie, J., Salwen, C., & Hayes, C. Scanning mobility\n", + "particle sizer (AOSSMPS). Atmospheric Radiation Measurement (ARM) User Facility.\n", + "https://doi.org/10.5439/1476898\n", + "\n", + "[DOWNLOADING] sgp915rwpwindmomloC1.a0.20240408.000011.nc\n", + "\n", + "If you use these data to prepare a publication, please cite:\n", + "\n", + "Muradyan, P., & Ermold, B. Radar Wind Profiler (915RWPWINDMOMLO). Atmospheric\n", + "Radiation Measurement (ARM) User Facility. https://doi.org/10.5439/1573768\n", + "\n" + ] + } + ], + "source": [ + "# Set your username and token here!\n", + "username = 'YourUserName'\n", + "token = 'YourToken'\n", + "\n", + "# Set the datastream and start/enddates for the DL data\n", + "datastream = 'sgpdlfptE13.b1'\n", + "startdate = '2024-04-08T17:00:00'\n", + "enddate = '2024-04-08T21:00:00'\n", + "\n", + "# Use ACT to easily download the data. Watch for the data citation! Show some support\n", + "# for ARM's instrument experts and cite their data if you use it in a publication\n", + "dl_files = act.discovery.download_arm_data(username, token, datastream, startdate, enddate)\n", + "ds_dl = act.io.read_arm_netcdf(dl_files)\n", + "ds_dl = ds_dl.where(ds_dl.range < 1500, drop=True)\n", + "\n", + "# Now download the rest of the data!\n", + "startdate = '2024-04-08'\n", + "enddate = '2024-04-08'\n", + "datastream = 'sgpecorsfE14.b1'\n", + "ecor_files = act.discovery.download_arm_data(username, token, datastream, startdate, enddate)\n", + "ds_ecor = act.io.read_arm_netcdf(ecor_files)\n", + "\n", + "datastream = 'sgpmetE13.b1'\n", + "met_files = act.discovery.download_arm_data(username, token, datastream, startdate, enddate)\n", + "ds_met = act.io.read_arm_netcdf(met_files)\n", + "\n", + "datastream = 'sgpsirsE13.b1'\n", + "sirs_files = act.discovery.download_arm_data(username, token, datastream, startdate, enddate)\n", + "ds_sirs = act.io.read_arm_netcdf(sirs_files)\n", + "\n", + "datastream = 'sgpaoscpcufE13.b1'\n", + "cpcuf_files = act.discovery.download_arm_data(username, token, datastream, startdate, enddate)\n", + "ds_cpcuf = act.io.read_arm_netcdf(cpcuf_files)\n", + "\n", + "datastream = 'sgpaossmpsE13.b1'\n", + "smps_files = act.discovery.download_arm_data(username, token, datastream, startdate, enddate)\n", + "ds_smps = act.io.read_arm_netcdf(smps_files)\n", + "\n", + "datastream = 'sgp915rwpwindmomloC1.a0'\n", + "rwp_files = act.discovery.download_arm_data(username, token, datastream, startdate, enddate)\n", + "ds_rwp = act.io.read_arm_netcdf(rwp_files)" + ] + }, + { + "cell_type": "markdown", + "id": "6f4952e5-3eff-4165-bbf3-badc74710801", + "metadata": {}, + "source": [ + "### Step 2.1: Transform the RWP dataset for easy plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 352, + "id": "43f0e132-9038-4c7c-bb6e-92b3e57e0f14", + "metadata": {}, + "outputs": [], + "source": [ + "# Select the first mode and beam to plot up\n", + "ds_rwp = ds_rwp.where(ds_rwp.beam_azimuth == 104)\n", + "ds_rwp = ds_rwp.where(ds_rwp.signal_to_noise_ratio > -10)" + ] + }, + { + "cell_type": "markdown", + "id": "58a7d0b3-d812-4dd6-a848-b9745c803658", + "metadata": {}, + "source": [ + "## Step 3: Visualize the Data\n", + "Let's plot out the data using ACT's built in functionality. It's easy to change variables around if you want to look at more data. Note that we are applying a day/night background and the vertical dashed line is local solar noon." + ] + }, + { + "cell_type": "code", + "execution_count": 353, + "id": "047dbd27-fc40-441d-af85-e36c9e5cb8cf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up the plot\n", + "display = act.plotting.TimeSeriesDisplay(\n", + " {\n", + " 'DL': ds_dl,\n", + " 'SIRS': ds_sirs,\n", + " 'MET': ds_met,\n", + " 'ECOR': ds_ecor,\n", + " 'CEIL': ds_ceil,\n", + " 'CPCUF': ds_cpcuf,\n", + " 'SMPS': ds_smps,\n", + " 'RWP': ds_rwp,\n", + " },\n", + " figsize=(10, 18),\n", + " subplot_shape=(7,),\n", + ")\n", + "\n", + "# Plot the direct solar radiation\n", + "display.plot(\n", + " 'short_direct_normal',\n", + " dsname='SIRS',\n", + " subplot_index=(0,),\n", + " set_title='SIRS Short Direct Normal Irradiance',\n", + ")\n", + "display.day_night_background(dsname='SIRS', subplot_index=(0,))\n", + "display.set_xrng(\n", + " [np.datetime64('2024-04-08T17:00:00.0'), np.datetime64('2024-04-08T21:00:00.0')],\n", + " subplot_index=(0,),\n", + ")\n", + "\n", + "# Plot up the surface temperature\n", + "display.plot('temp_mean', dsname='MET', subplot_index=(1,), set_title='Surface Temperature')\n", + "display.set_yrng([16, 22], subplot_index=(1,))\n", + "display.day_night_background(dsname='MET', subplot_index=(1,))\n", + "display.axes[1].sharex(display.axes[0])\n", + "\n", + "# Surface fluxes\n", + "display.plot('latent_flux', dsname='ECOR', subplot_index=(2,))\n", + "display.plot(\n", + " 'sensible_heat_flux',\n", + " dsname='ECOR',\n", + " subplot_index=(2,),\n", + " set_title='ECOR Latent, Sensible Heat, and CO2 Flux',\n", + ")\n", + "display.day_night_background(dsname='ECOR', subplot_index=(2,))\n", + "display.axes[2].sharex(display.axes[0])\n", + "ecor_ax = display.axes[2].twinx()\n", + "ecor_ax.plot(ds_ecor['time'], ds_ecor['co2_flux'], 'purple')\n", + "ecor_ax.set_ylabel('CO2 Flux (' + ds_ecor['co2_flux'].attrs['units'] + ')')\n", + "\n", + "# Plot the DL data and adjust the limits\n", + "display.plot(\n", + " 'radial_velocity',\n", + " dsname='DL',\n", + " vmin=-4,\n", + " vmax=4,\n", + " cmap='balance',\n", + " subplot_index=(3,),\n", + " set_title='DL Radial Velocity',\n", + ")\n", + "display.set_yrng([50, 1500], subplot_index=(3,))\n", + "display.axes[3].sharex(display.axes[0])\n", + "\n", + "# display.plot('radial_velocity_snr', dsname='RWP', cb_friendly=True, subplot_index=(4,))\n", + "display.plot(\n", + " 'signal_to_noise_ratio',\n", + " dsname='RWP',\n", + " cb_friendly=True,\n", + " subplot_index=(4,),\n", + " set_title='RWP Signal-to-Noise Ratio',\n", + ")\n", + "display.set_yrng([50, 1500], subplot_index=(4,))\n", + "display.axes[4].sharex(display.axes[0])\n", + "\n", + "\n", + "# Ultrafine CPC\n", + "display.plot('concentration', dsname='CPCUF', subplot_index=(5,), set_title='CPCUF Concentration')\n", + "display.day_night_background(dsname='CPCUF', subplot_index=(5,))\n", + "display.axes[5].sharex(display.axes[0])\n", + "\n", + "# SMPS\n", + "display.plot(\n", + " 'dN_dlogDp',\n", + " dsname='SMPS',\n", + " subplot_index=(6,),\n", + " cmap='nipy_spectral',\n", + " set_title='SMPS Size Distribution',\n", + " norm=colors.LogNorm(vmin=100.0, vmax=20000),\n", + ")\n", + "display.day_night_background(dsname='SMPS', subplot_index=(6,))\n", + "display.axes[6].sharex(display.axes[0])\n", + "display.axes[6].set_yscale('log')\n", + "display.axes[6].set_ylim([10, 500])\n", + "\n", + "plt.subplots_adjust(wspace=0, hspace=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "898a3fb5-ae07-4bed-a16d-bc724fa60ba8", + "metadata": {}, + "source": [ + "# Summary\n", + "\n", + "As expected, the direct solar radiation decreases during the eclipse to near 0 (panel 1). Not shown but visible in the [TSI video](https://plot.adc.arm.gov/PLOTS/sgp/sgptsiskycover/20240408/sgptsiskycoverC1.b1.tsimovie.20240408.mp4) is that there was a layer of clouds which impacted the radiation measurements as well.\n", + "\n", + "With less direct radiation reaching the surface ([10-meter IRT Surface IR Temperature](https://plot.adc.arm.gov/PLOTS/sgp/sgpirt10m/20240408/sgpirt10mC1.b1.irt_10m.20240408.png), the surface temperatures started to decrease (panel 2), reaching a minimum shortly after totality.\n", + "\n", + "There was also a noticeable drop in heat fluxes (panel 3) and a corresponding plant response with a drop in CO2 uptake (purple line) as noted by the mentor Ryan Sullivan.\n", + "\n", + "The doppler lidar (DL) measures radial velocity and there is a clear decrease in the thermals/vertical motion (panel 4). This corresponds with a lowering of the planetary bouldary layer height as observed in the radar wind profiler (RWP) data (panel 5).\n", + "\n", + "Data from the ultrafine condensation particle counter (CPCUF; panel 6) and the scanning mobility particle sizer (SMPS; panel 7) were included to see if there was a burst in new particle formation (NPF) once photochemical activity started back up. While there is a second peak in the size distribution post eclipse, it cannot be concluded that it was related. The mentor, Ashish Singh, had noted \"In springtime at SGP, there's a recurring and/or a particle burst, which appears to be regional (based on published papers). Typically, it initiates around 16:00 UTC or later consistently, coinciding with the timeframe of a solar eclipse (17:30-20:00 UTC and beyond) on April 08. Analyzing the data from nSMPS and SMPS size distribution timeseries, it's unclear whether the fluctuations in solar insolation during the eclipse are directly linked to the onset of the burst or formation event, especially concerning particles below 50 nm.\"\n", + "\n", + "There's a lot of interesting data to explore from the eclipse. You can learn more about ARM's instruments and data by visiting [ARM's website.](https://arm.gov/)\n", + "\n", + "Thank you to the ARM staff that helped contribute ideas and feedback to this blog post.\n", + "* Max Grover\n", + "* Ryan Sullivan\n", + "* Ashish Singh\n", + "* Janek Uin\n", + "* Paytsar Muradyan\n", + "* Jenni Kyrouac" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f5dc51b-c3af-4fdb-9e34-91f52582cedc", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "author": "Adam Theisen", + "date": "2024-04-15", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + }, + "tags": "eclipse,SGP,DL,RWP,MET,SIRS,ECOR,SMPS,CPCUF", + "title": "Exploration of data from the 2024 eclipse at SGP" + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/conf.py b/docs/source/conf.py index 8a2ac05536..d04bc24fb6 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -91,7 +91,7 @@ # |version| and |release|, also used in various other places throughout the # built documents. # -import act +import act # noqa # The short X.Y version. version = act.__version__ @@ -160,16 +160,16 @@ 'blog': [ 'search-field.html', 'sidebar-nav-bs.html', - 'postcard.html', - 'recentposts.html', - 'archives.html', + 'ablog/postcard.html', + 'ablog/recentposts.html', + 'ablog/archives.html', ], 'blog_posts/*/*': [ 'search-field.html', 'sidebar-nav-bs.html', - 'postcard.html', - 'recentposts.html', - 'archives.html', + 'ablog/postcard.html', + 'ablog/recentposts.html', + 'ablog/archives.html', ], } diff --git a/docs/source/userguide/usage.rst b/docs/source/userguide/usage.rst index 202cc22a18..1be2d2bea7 100644 --- a/docs/source/userguide/usage.rst +++ b/docs/source/userguide/usage.rst @@ -10,7 +10,7 @@ Start by importing Atmospheric data Community Toolkit. The Atmospheric data Community Toolkit comes with modules for loading ARM datasets. The main dataset object that is used in ACT is based off of an extension of -the `xarray.Dataset` +the `xarray.Dataset `_ object. In particular ACT adds a DatasetAccessor that stores the additional properties required by act in the .act property of a Dataset. For example, if we want to access the name of the datastream, we simply do: @@ -49,8 +49,14 @@ In addition, the figure and axes handles of each subplot are stored in the be used to modify the properties of each plot if the user desires further customization. -Finally, ACT is able to download data from the ARM archive given that a -user's username and token are provided. +Finally, ACT is able to download data from the ARM given that a +user's username and token are provided. To obtain an ARM username and token, +you must first create an `ARM account `_ +by providing an email and following the setup instructions. Once you +have an ARM account, you can receive your token associated with your account +by logging in `here `_ and clicking on the login +to receive your account access token button. Once you have your username and +token, you can provide them in the example code block below: .. code-block:: python diff --git a/examples/discovery/plot_improve.py b/examples/discovery/plot_improve.py new file mode 100644 index 0000000000..e2a90cb3d6 --- /dev/null +++ b/examples/discovery/plot_improve.py @@ -0,0 +1,30 @@ +""" +IMPROVE Data +----------- + +This example shows how to get IMPROVE data for the +system located at ARM's Southern Great Plains site. + +""" + +import act +import matplotlib.pyplot as plt + +# Pull the data using the site_id from IMPROVE +# https://views.cira.colostate.edu/adms/Pub/SiteSummary.aspx?dsidse=10001&siidse=244 +ds = act.discovery.get_improve_data(site_id='244', start_date='1/1/2023', end_date='12/31/2023') + +# Remove all data that's set to the FillValue +ds = ds.where(ds['aluminum_fine'] != ds['aluminum_fine'].attrs['_FillValue']) + +display = act.plotting.TimeSeriesDisplay(ds, figsize=(10, 6)) +display.plot('aluminum_fine') + +# Print out the known problems documented by IMPROVE +print(ds.attrs['site_problems']) + +# Write out the data to netCDF and csv +ds.to_netcdf('./sgpimprove.20230101.nc') +ds.to_dataframe().to_csv('sgpimprove.20230101.csv') + +plt.show() diff --git a/examples/discovery/plot_neon.py b/examples/discovery/plot_neon.py index 038fa62778..293e0d70b1 100644 --- a/examples/discovery/plot_neon.py +++ b/examples/discovery/plot_neon.py @@ -11,7 +11,6 @@ import os import glob import matplotlib.pyplot as plt -import numpy as np import act @@ -21,7 +20,9 @@ if token is not None and len(token) > 0: # Download ARM data if a username/token are set - files = act.discovery.download_arm_data(username, token, 'nsametC1.b1', '2022-10-01', '2022-10-07') + files = act.discovery.download_arm_data( + username, token, 'nsametC1.b1', '2022-10-01', '2022-10-07' + ) ds = act.io.arm.read_arm_netcdf(files) # Download NEON Data @@ -33,19 +34,23 @@ # A number of files are downloaded and further explained in the readme file that's downloaded. # These are the files we will need for reading 1 minute NEON data - file = glob.glob(os.path.join( - '.', - 'BARR_DP1.00002.001', - 'NEON.D18.BARR.DP1.00002.001.000.010.001.SAAT_1min.2022-10.expanded.*.csv', - )) - variable_file = glob.glob(os.path.join( - '.', 'BARR_DP1.00002.001', 'NEON.D18.BARR.DP1.00002.001.variables.*.csv' - )) - position_file = glob.glob(os.path.join( - '.', - 'BARR_DP1.00002.001', - 'NEON.D18.BARR.DP1.00002.001.sensor_positions.*.csv', - )) + file = glob.glob( + os.path.join( + '.', + 'BARR_DP1.00002.001', + 'NEON.D18.BARR.DP1.00002.001.000.010.001.SAAT_1min.2022-10.expanded.*.csv', + ) + ) + variable_file = glob.glob( + os.path.join('.', 'BARR_DP1.00002.001', 'NEON.D18.BARR.DP1.00002.001.variables.*.csv') + ) + position_file = glob.glob( + os.path.join( + '.', + 'BARR_DP1.00002.001', + 'NEON.D18.BARR.DP1.00002.001.sensor_positions.*.csv', + ) + ) # Read in the data using the ACT reader, passing with it the variable and position files # for added information in the dataset ds2 = act.io.read_neon_csv(file, variable_files=variable_file, position_files=position_file) diff --git a/examples/io/plot_convert_ameriflux.py b/examples/io/plot_convert_ameriflux.py new file mode 100644 index 0000000000..4517d6400d --- /dev/null +++ b/examples/io/plot_convert_ameriflux.py @@ -0,0 +1,123 @@ +""" +Convert Data to AmeriFlux Format +-------------------------------- + +This script shows how to convert ARM data to AmeriFlux format +using an ACT function, and write it out to csv. More information +on AmeriFlux and their file formats and naming conventions can be +found here: https://ameriflux.lbl.gov/ + +Author: Adam Theisen + +""" + +import act +import glob +import xarray as xr +import os +import matplotlib.pyplot as plt + +# Read in the ECOR data +files = glob.glob(act.tests.sample_files.EXAMPLE_ECORSF_E39) +ds_ecor = act.io.arm.read_arm_netcdf(files) + +# The ECOR time stamp as at the end of the Averaging period so adjusting +# it to be consistent with the other systems +ds_ecor = act.utils.datetime_utils.adjust_timestamp(ds_ecor) + +# Clean up and QC the data based on embedded QC and ARM DQRs +ds_ecor.clean.cleanup() +ds_ecor = act.qc.arm.add_dqr_to_qc(ds_ecor) +ds_ecor.qcfilter.datafilter( + del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect'] +) + +# Then we do this same thing for the other instruments +# SEBS +files = glob.glob(act.tests.sample_files.EXAMPLE_SEBS_E39) +ds_sebs = act.io.arm.read_arm_netcdf(files) +# SEBS does not have a time_bounds variable so we have to manually adjust it +ds_sebs = act.utils.datetime_utils.adjust_timestamp(ds_sebs, offset=-30 * 60) +ds_sebs.clean.cleanup() +ds_sebs = act.qc.arm.add_dqr_to_qc(ds_sebs) +ds_sebs.qcfilter.datafilter( + del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect'] +) + +# STAMP +files = glob.glob(act.tests.sample_files.EXAMPLE_STAMP_E39) +ds_stamp = act.io.arm.read_arm_netcdf(files) +ds_stamp.clean.cleanup() +ds_stamp = act.qc.arm.add_dqr_to_qc(ds_stamp) +ds_stamp.qcfilter.datafilter( + del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect'] +) + +# STAMP Precipitation +files = glob.glob(act.tests.sample_files.EXAMPLE_STAMPPCP_E39) +ds_stamppcp = act.io.arm.read_arm_netcdf(files) +ds_stamppcp.clean.cleanup() +ds_stamppcp = act.qc.arm.add_dqr_to_qc(ds_stamppcp) +ds_stamppcp.qcfilter.datafilter( + del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect'] +) +# These are minute data so we need to resample and sum up to 30 minutes +ds_stamppcp = ds_stamppcp['precip'].resample(time='30Min').sum() + +# AMC +files = glob.glob(act.tests.sample_files.EXAMPLE_AMC_E39) +ds_amc = act.io.arm.read_arm_netcdf(files) +ds_amc.clean.cleanup() +ds_amc = act.qc.arm.add_dqr_to_qc(ds_amc) +ds_amc.qcfilter.datafilter( + del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect'] +) + +# Merge these datasets together +ds = xr.merge([ds_ecor, ds_sebs, ds_stamp, ds_stamppcp, ds_amc], compat='override') + +# Convert the data to AmeriFlux format and get a DataFrame in return +# Note, this does not return an xarray Dataset as it's assumed the data +# will just be written out to csv format. +df = act.io.ameriflux.convert_to_ameriflux(ds) + +# Write the data out to file +site = 'US-A14' +directory = './' + site + 'mergedflux/' +if not os.path.exists(directory): + os.makedirs(directory) + +# Following the AmeriFlux file naming convention +filename = ( + site + + '_HH_' + + str(df['TIMESTAMP_START'].iloc[0]) + + '_' + + str(df['TIMESTAMP_END'].iloc[-1]) + + '.csv' +) +df.to_csv(directory + filename, index=False) + + +# Plot up merged data for visualization +display = act.plotting.TimeSeriesDisplay(ds, subplot_shape=(4,), figsize=(12, 10)) +display.plot('latent_flux', subplot_index=(0,)) +display.plot('co2_flux', subplot_index=(0,)) +display.plot('sensible_heat_flux', subplot_index=(0,)) +display.day_night_background(subplot_index=(0,)) + +display.plot('precip', subplot_index=(1,)) +display.day_night_background(subplot_index=(1,)) + +display.plot('surface_soil_heat_flux_1', subplot_index=(2,)) +display.plot('surface_soil_heat_flux_2', subplot_index=(2,)) +display.plot('surface_soil_heat_flux_3', subplot_index=(2,)) +display.day_night_background(subplot_index=(2,)) + +display.plot('soil_specific_water_content_west', subplot_index=(3,)) +display.axes[3].set_ylim(display.axes[3].get_ylim()[::-1]) + +display.day_night_background(subplot_index=(3,)) + +plt.subplots_adjust(hspace=0.35) +plt.show() diff --git a/examples/io/plot_create_arm_ds.py b/examples/io/plot_create_arm_ds.py index 9840680405..fc2fb1332d 100644 --- a/examples/io/plot_create_arm_ds.py +++ b/examples/io/plot_create_arm_ds.py @@ -37,7 +37,7 @@ 'command_line': 'python plot_create_arm_ds.py', 'process_version': '1.2.3', 'history': 'Processed with Jupyter Workbench', - 'random': '1234253sdgfadf' + 'random': '1234253sdgfadf', } for a in atts: if a in ds.attrs: diff --git a/examples/io/plot_hysplit.py b/examples/io/plot_hysplit.py new file mode 100644 index 0000000000..6e53009311 --- /dev/null +++ b/examples/io/plot_hysplit.py @@ -0,0 +1,23 @@ +""" +Read and plot a HYSPLIT trajectory file from a HYSPlIT run. +----------------------------------------------------------- + +This example shows how to read and plot a backtrajectory calculated by the NOAA +HYSPLIT model over Houston. + +Author: Robert Jackson +""" + +import act +import matplotlib.pyplot as plt + +from arm_test_data import DATASETS + +# Load the data +filename = DATASETS.fetch('houstonaug300.0summer2010080100') +ds = act.io.read_hysplit(filename) + +# Use the GeographicPlotDisplay object to make the plot +disp = act.plotting.GeographicPlotDisplay(ds) +disp.geoplot('PRESSURE', cartopy_feature=['STATES', 'OCEAN', 'LAND']) +plt.show() diff --git a/examples/io/plot_icartt.py b/examples/io/plot_icartt.py index 4e7bc22bc9..df76f95c24 100644 --- a/examples/io/plot_icartt.py +++ b/examples/io/plot_icartt.py @@ -11,7 +11,6 @@ from arm_test_data import DATASETS import matplotlib.pyplot as plt -import numpy as np import act from act.io.icartt import read_icartt diff --git a/examples/io/plot_sodar.py b/examples/io/plot_sodar.py index 0b6e0898fd..a240d5ff18 100644 --- a/examples/io/plot_sodar.py +++ b/examples/io/plot_sodar.py @@ -23,11 +23,11 @@ # Create an ACT TimeSeriesDisplay. display = act.plotting.TimeSeriesDisplay( - {'Shear, Wind Direction, and Speed at ANL ATMOS': ds}, - subplot_shape=(1,), figsize=(15, 5)) + {'Shear, Wind Direction, and Speed at ANL ATMOS': ds}, subplot_shape=(1,), figsize=(15, 5) +) # Plot shear with a wind barb overlay, while using a color vision # deficiency (CVD) colormap. -display.plot('shear', subplot_index=(0,), cb_friendly=True) +display.plot('shear', subplot_index=(0,), cvd_friendly=True) display.plot_barbs_from_spd_dir('speed', 'dir') plt.show() diff --git a/examples/io/plot_surfrad.py b/examples/io/plot_surfrad.py index 473185f24d..538700cc5d 100644 --- a/examples/io/plot_surfrad.py +++ b/examples/io/plot_surfrad.py @@ -19,7 +19,7 @@ # But it's easy enough to read form the URLs as well url = [ 'https://gml.noaa.gov/aftp/data/radiation/surfrad/Boulder_CO/2023/tbl23008.dat', - 'https://gml.noaa.gov/aftp/data/radiation/surfrad/Boulder_CO/2023/tbl23009.dat' + 'https://gml.noaa.gov/aftp/data/radiation/surfrad/Boulder_CO/2023/tbl23009.dat', ] ds = act.io.read_surfrad(url) diff --git a/examples/plotting/plot_ceil.py b/examples/plotting/plot_ceil.py index b24f810203..626b075d13 100644 --- a/examples/plotting/plot_ceil.py +++ b/examples/plotting/plot_ceil.py @@ -25,14 +25,16 @@ ceil_ds = act.io.arm.read_arm_netcdf(filename_ceil, engine='netcdf4') else: # Example to show how easy it is to download ARM data if a username/token are set - results = act.discovery.download_arm_data(username, token, 'sgpceilC1.b1', '2022-01-14', '2022-01-19') + results = act.discovery.download_arm_data( + username, token, 'sgpceilC1.b1', '2022-01-14', '2022-01-19' + ) ceil_ds = act.io.arm.read_arm_netcdf(results) # Adjust ceilometer data for plotting ceil_ds = act.corrections.ceil.correct_ceil(ceil_ds, -9999.0) -# Plot up ceilometer backscatter using HomeyerRainbow cb friendly colormap +# Plot up ceilometer backscatter using HomeyerRainbow CVD friendly colormap # The same could be done with keyword 'cmap='HomeyerRainbow' display = act.plotting.TimeSeriesDisplay(ceil_ds, subplot_shape=(1,), figsize=(15, 5)) -display.plot('backscatter', subplot_index=(0,), cb_friendly=True) +display.plot('backscatter', subplot_index=(0,), cvd_friendly=True) plt.show() diff --git a/examples/plotting/plot_contour.py b/examples/plotting/plot_contour.py index fba82cecfd..7a63750a01 100644 --- a/examples/plotting/plot_contour.py +++ b/examples/plotting/plot_contour.py @@ -9,26 +9,27 @@ """ -import glob from arm_test_data import DATASETS import matplotlib.pyplot as plt import act -met_contour_list = ['sgpmetE15.b1.20190508.000000.cdf', - 'sgpmetE31.b1.20190508.000000.cdf', - 'sgpmetE32.b1.20190508.000000.cdf', - 'sgpmetE33.b1.20190508.000000.cdf', - 'sgpmetE34.b1.20190508.000000.cdf', - 'sgpmetE35.b1.20190508.000000.cdf', - 'sgpmetE36.b1.20190508.000000.cdf', - 'sgpmetE37.b1.20190508.000000.cdf', - 'sgpmetE38.b1.20190508.000000.cdf', - 'sgpmetE39.b1.20190508.000000.cdf', - 'sgpmetE40.b1.20190508.000000.cdf', - 'sgpmetE9.b1.20190508.000000.cdf', - 'sgpmetE13.b1.20190508.000000.cdf'] +met_contour_list = [ + 'sgpmetE15.b1.20190508.000000.cdf', + 'sgpmetE31.b1.20190508.000000.cdf', + 'sgpmetE32.b1.20190508.000000.cdf', + 'sgpmetE33.b1.20190508.000000.cdf', + 'sgpmetE34.b1.20190508.000000.cdf', + 'sgpmetE35.b1.20190508.000000.cdf', + 'sgpmetE36.b1.20190508.000000.cdf', + 'sgpmetE37.b1.20190508.000000.cdf', + 'sgpmetE38.b1.20190508.000000.cdf', + 'sgpmetE39.b1.20190508.000000.cdf', + 'sgpmetE40.b1.20190508.000000.cdf', + 'sgpmetE9.b1.20190508.000000.cdf', + 'sgpmetE13.b1.20190508.000000.cdf', +] met_contour_filenames = [DATASETS.fetch(file) for file in met_contour_list] diff --git a/examples/plotting/plot_data_rose.py b/examples/plotting/plot_data_rose.py index 16166d83ee..a0f6361091 100644 --- a/examples/plotting/plot_data_rose.py +++ b/examples/plotting/plot_data_rose.py @@ -14,19 +14,20 @@ """ from arm_test_data import DATASETS -import numpy as np from matplotlib import pyplot as plt import act # Read in some data with wind speed/direction in the file -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] ds = act.io.arm.read_arm_netcdf(met_filenames) diff --git a/examples/plotting/plot_days.py b/examples/plotting/plot_days.py index 70af4b7c1f..bc7b790f33 100644 --- a/examples/plotting/plot_days.py +++ b/examples/plotting/plot_days.py @@ -10,26 +10,34 @@ from arm_test_data import DATASETS import matplotlib.pyplot as plt -import numpy as np import act # Read in the sample MET data -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] ds = act.io.arm.read_arm_netcdf(met_filenames) # Create Plot Display display = act.plotting.WindRoseDisplay(ds, figsize=(15, 15), subplot_shape=(3, 3)) groupby = display.group_by('day') -groupby.plot_group('plot_data', None, dir_field='wdir_vec_mean', spd_field='wspd_vec_mean', - data_field='temp_mean', num_dirs=12, plot_type='line') +groupby.plot_group( + 'plot_data', + None, + dir_field='wdir_vec_mean', + spd_field='wspd_vec_mean', + data_field='temp_mean', + num_dirs=12, + plot_type='line', +) # Set theta tick markers for each axis inside display to be inside the polar axes for i in range(3): diff --git a/examples/plotting/plot_daytime_averages.py b/examples/plotting/plot_daytime_averages.py index 117bf29a5e..ef77de0179 100644 --- a/examples/plotting/plot_daytime_averages.py +++ b/examples/plotting/plot_daytime_averages.py @@ -14,13 +14,15 @@ import act # Read in the sample MET data -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] ds = act.io.arm.read_arm_netcdf(met_filenames) @@ -31,7 +33,7 @@ ds = ds.where(ds['sun_variable'] == 1) # Take daily mean using xarray features -ds = ds.resample(time='1d', skipna=True, keep_attrs=True).mean() +ds = ds.resample(time='1d', skipna=True).mean() # Creat Plot Display display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10)) diff --git a/examples/plotting/plot_enhanced_skewt.py b/examples/plotting/plot_enhanced_skewt.py index 5223c6c3e4..f3258d5b64 100644 --- a/examples/plotting/plot_enhanced_skewt.py +++ b/examples/plotting/plot_enhanced_skewt.py @@ -9,13 +9,9 @@ """ -import glob from arm_test_data import DATASETS from matplotlib import pyplot as plt -import metpy -import numpy as np -import xarray as xr import act diff --git a/examples/plotting/plot_examples.py b/examples/plotting/plot_examples.py index 96a8fe21e6..c9cee8e55b 100644 --- a/examples/plotting/plot_examples.py +++ b/examples/plotting/plot_examples.py @@ -9,7 +9,6 @@ from arm_test_data import DATASETS import matplotlib.pyplot as plt -import xarray as xr import act diff --git a/examples/plotting/plot_heatmap.py b/examples/plotting/plot_heatmap.py index 86238424c8..9e15a1ceab 100644 --- a/examples/plotting/plot_heatmap.py +++ b/examples/plotting/plot_heatmap.py @@ -15,13 +15,15 @@ import act # Read MET data in from the test data area -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] ds = act.io.arm.read_arm_netcdf(met_filenames) @@ -31,8 +33,9 @@ # Plot a heatmap and scatter plot up of RH vs Temperature # Set the number of bins for the x-axis to 25 and y to 20 title = 'Heatmap of MET RH vs Temp' -display.plot_heatmap('temp_mean', 'rh_mean', x_bins=25, y_bins=20, - threshold=0, subplot_index=(0, 0), set_title=title) +display.plot_heatmap( + 'temp_mean', 'rh_mean', x_bins=25, y_bins=20, threshold=0, subplot_index=(0, 0), set_title=title +) # Plot the scatter plot and shade by wind_speed title = 'Scatter plot of MET RH vs Temp' diff --git a/examples/plotting/plot_hist_kwargs.py b/examples/plotting/plot_hist_kwargs.py index 063e19d280..9c153233d5 100644 --- a/examples/plotting/plot_hist_kwargs.py +++ b/examples/plotting/plot_hist_kwargs.py @@ -20,6 +20,5 @@ # Plot data hist_kwargs = {'range': (-10, 10)} histdisplay = act.plotting.DistributionDisplay(met_ds) -histdisplay.plot_stacked_bar('temp_mean', bins=np.arange(-40, 40, 5), - hist_kwargs=hist_kwargs) +histdisplay.plot_stacked_bar('temp_mean', bins=np.arange(-40, 40, 5), hist_kwargs=hist_kwargs) plt.show() diff --git a/examples/plotting/plot_multiple_column.py b/examples/plotting/plot_multiple_column.py index 1836277b3e..066f52d6e8 100644 --- a/examples/plotting/plot_multiple_column.py +++ b/examples/plotting/plot_multiple_column.py @@ -14,13 +14,15 @@ import act # Read in MET files. -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] met_filenames = [DATASETS.fetch(file) for file in met_wildcard_list] met_ds = act.io.arm.read_arm_netcdf(met_filenames) diff --git a/examples/plotting/plot_pie_chart.py b/examples/plotting/plot_pie_chart.py new file mode 100644 index 0000000000..c2f0a3a6c4 --- /dev/null +++ b/examples/plotting/plot_pie_chart.py @@ -0,0 +1,52 @@ +""" +Calculate and View Aerosol Percentages +-------------------------------------- + +Calculate the percentages of different aerosols in a Aerosol +Chemical Speciation (AOS) monitor dataset and view the percentages +in a pie chart. + +Written: Zach Sherman + +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act +from act.io.arm import read_arm_netcdf + +# Read an ARM AOS dataset +filename = DATASETS.fetch('sgpaosacsmE13.b2.20230420.000109.nc') +ds = read_arm_netcdf(filename) + +# Let us print out the fields in the dataset and see what it contains. +print(ds.data_vars.keys()) + +# Knowing what fields the dataset contains, let's create a list of fields +# to use in the plot. + +fields = ['sulfate', 'ammonium', 'nitrate', 'chloride'] + +# We also want to provide some keyword arguments to avoid invalid data such +# as negative values. +threshold = 0.0 +fill_value = 0.0 + +# Create a DistributionDisplay object to compare fields +display = act.plotting.DistributionDisplay(ds) + +# We can set one of the slices to explode and give it a nice shadow. +explode = (0, 0.1, 0, 0) +shadow = True + +# Create a pie chart using the fields list. The percentages of the +# fields will be calculated using act.utils.calculate_percentages. +display.plot_pie_chart( + fields, + threshold=threshold, + fill_value=fill_value, + explode=explode, + shadow=True, +) +plt.show() diff --git a/examples/plotting/plot_presentweathercode.py b/examples/plotting/plot_presentweathercode.py index dbec1e23d2..c30d72ed1f 100644 --- a/examples/plotting/plot_presentweathercode.py +++ b/examples/plotting/plot_presentweathercode.py @@ -9,7 +9,6 @@ """ from arm_test_data import DATASETS -import numpy as np from matplotlib.dates import DateFormatter from matplotlib.dates import num2date import matplotlib.pyplot as plt @@ -22,12 +21,12 @@ # Decode the Present Weather Codes # Pass it to the function to decode it along with the variable name -ds = act.utils.inst_utils.decode_present_weather(ds, - variable='pwd_pw_code_inst') +ds = act.utils.inst_utils.decode_present_weather(ds, variable='pwd_pw_code_inst') # Calculate Precipitation Accumulation -pre_accum = act.utils.accumulate_precip(ds.where(ds.qc_tbrg_precip_total == 0), - "tbrg_precip_total").tbrg_precip_total_accumulated.compute() +pre_accum = act.utils.accumulate_precip( + ds.where(ds.qc_tbrg_precip_total == 0), "tbrg_precip_total" +).tbrg_precip_total_accumulated.compute() # Add the Precipitation Accum to the MET DataSet ds['tbrg_accum'] = pre_accum @@ -46,8 +45,7 @@ # Assign the ACT display object to the matplotlib figure subplot display.assign_to_figure_axis(fig, ax) # Datastream Names are needed for plotting! -display.plot('tbrg_accum', - label='TBRG Accumualated Precip') +display.plot('tbrg_accum', label='TBRG Accumualated Precip') # Add a day/night background display.day_night_background() @@ -68,7 +66,10 @@ ndates = [num2date(x) for x in xticks] # Grab the PWD codes associated with those ticks -ncode = [ds['pwd_pw_code_inst_decoded'].sel(time=x.replace(tzinfo=None), method='nearest').data.tolist() for x in ndates] +ncode = [ + ds['pwd_pw_code_inst_decoded'].sel(time=x.replace(tzinfo=None), method='nearest').data.tolist() + for x in ndates +] pwd_code = ['\n'.join(x.split(' ')) if len(x) > 20 else x for x in ncode] # Display these select PWD codes as vertical texts along the x-axis @@ -77,11 +78,7 @@ # Plot the PWD code for i, key in enumerate(xticks): - ax.text(key, - ymin, - pwd_code[i], - rotation=90, - va='center') + ax.text(key, ymin, pwd_code[i], rotation=90, va='center') plt.subplots_adjust(bottom=0.20) diff --git a/examples/plotting/plot_rh_timeseries.py b/examples/plotting/plot_rh_timeseries.py index b4c7d65a2d..8dacfb4806 100644 --- a/examples/plotting/plot_rh_timeseries.py +++ b/examples/plotting/plot_rh_timeseries.py @@ -13,30 +13,32 @@ import act # Read in sonde files -twp_sonde_wildcard_list = ['twpsondewnpnC3.b1.20060119.050300.custom.cdf', - 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', - 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', - 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', - 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', - 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', - 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', - 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', - 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', - 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', - 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', - 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', - 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', - 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', - 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', - 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', - 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', - 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', - 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', - 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', - 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', - 'twpsondewnpnC3.b1.20060124.231500.custom.cdf'] +twp_sonde_wildcard_list = [ + 'twpsondewnpnC3.b1.20060119.050300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', + 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', + 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', + 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', + 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', + 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', + 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', + 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', + 'twpsondewnpnC3.b1.20060124.231500.custom.cdf', +] sonde_filenames = [DATASETS.fetch(file) for file in twp_sonde_wildcard_list] sonde_ds = act.io.arm.read_arm_netcdf(sonde_filenames) diff --git a/examples/plotting/plot_scatter.py b/examples/plotting/plot_scatter.py index dd9202f05d..e3a7fc14f4 100644 --- a/examples/plotting/plot_scatter.py +++ b/examples/plotting/plot_scatter.py @@ -27,57 +27,36 @@ display = act.plotting.DistributionDisplay(ds) # Compare aircraft ground speed with indicated airspeed -display.plot_scatter('true_airspeed', - 'ground_speed', - m_field='ambient_temp', - marker='x', - cbar_label='Ambient Temperature ($^\circ$C)' - ) +display.plot_scatter( + 'true_airspeed', + 'ground_speed', + m_field='ambient_temp', + marker='x', + cbar_label=r'Ambient Temperature ($^\circ$C)', # noqa W605 +) # Set the range of the field on the x-axis display.set_xrng((40, 140)) display.set_yrng((40, 140)) # Determine the best fit line -z = np.ma.polyfit(ds['true_airspeed'], - ds['ground_speed'], - 1 - ) +z = np.ma.polyfit(ds['true_airspeed'], ds['ground_speed'], 1) p = np.poly1d(z) # Plot the best fit line -display.axes[0].plot(ds['true_airspeed'], - p(ds['true_airspeed']), - 'r', - linewidth=2 - ) +display.axes[0].plot(ds['true_airspeed'], p(ds['true_airspeed']), 'r', linewidth=2) # Display the line equation -display.axes[0].text(45, - 135, - "y = %.3fx + (%.3f)" % (z[0], z[1]), - color='r', - fontsize=12 - ) +display.axes[0].text(45, 135, f"y = {z[0]:.3f}x + ({z[1]:.3f})", color='r', fontsize=12) # Calculate Pearson Correlation Coefficient -cc_conc = pearsonr(ds['true_airspeed'], - ds['ground_speed'] - ) +cc_conc = pearsonr(ds['true_airspeed'], ds['ground_speed']) # Display the Pearson CC -display.axes[0].text(45, - 130, - "Pearson CC: %.2f" % (cc_conc[0]), - fontsize=12 - ) +display.axes[0].text(45, 130, "Pearson CC: %.2f" % (cc_conc[0]), fontsize=12) # Display the total number of samples -display.axes[0].text(45, - 125, - "N = %.0f" % (ds['true_airspeed'].data.shape[0]), - fontsize=12 - ) +display.axes[0].text(45, 125, "N = %.0f" % (ds['true_airspeed'].data.shape[0]), fontsize=12) # Display the 1:1 ratio line display.set_ratio_line() diff --git a/examples/plotting/plot_secondary_y.py b/examples/plotting/plot_secondary_y.py index d6062857e9..a7193711eb 100644 --- a/examples/plotting/plot_secondary_y.py +++ b/examples/plotting/plot_secondary_y.py @@ -9,7 +9,6 @@ from arm_test_data import DATASETS import matplotlib.pyplot as plt -import xarray as xr import act diff --git a/examples/plotting/plot_skewt.py b/examples/plotting/plot_skewt.py index 69c3674da8..924a951623 100644 --- a/examples/plotting/plot_skewt.py +++ b/examples/plotting/plot_skewt.py @@ -8,7 +8,6 @@ """ from arm_test_data import DATASETS -import metpy import xarray as xr from matplotlib import pyplot as plt @@ -37,7 +36,15 @@ plt.show() # One could also add options like adiabats and mixing lines skewt = act.plotting.SkewTDisplay(sonde_ds, figsize=(15, 10)) -skewt.plot_from_u_and_v('u_wind', 'v_wind', 'pres', 'tdry', 'dp', plot_dry_adiabats=True, - plot_moist_adiabats=True, plot_mixing_lines=True) +skewt.plot_from_u_and_v( + 'u_wind', + 'v_wind', + 'pres', + 'tdry', + 'dp', + plot_dry_adiabats=True, + plot_moist_adiabats=True, + plot_mixing_lines=True, +) plt.show() sonde_ds.close() diff --git a/examples/plotting/plot_skewt_with_text.py b/examples/plotting/plot_skewt_with_text.py index d37bd8d483..5672ccfd91 100644 --- a/examples/plotting/plot_skewt_with_text.py +++ b/examples/plotting/plot_skewt_with_text.py @@ -11,7 +11,6 @@ from arm_test_data import DATASETS from matplotlib import pyplot as plt -import metpy import numpy as np import xarray as xr diff --git a/examples/plotting/plot_time_height_scatter.py b/examples/plotting/plot_time_height_scatter.py index 950b36d998..b36bd7b4cf 100644 --- a/examples/plotting/plot_time_height_scatter.py +++ b/examples/plotting/plot_time_height_scatter.py @@ -6,8 +6,6 @@ """ -import os -from arm_test_data import DATASETS import matplotlib.pyplot as plt import act from act.tests import sample_files @@ -18,7 +16,7 @@ # Create scatter plots of the sonde data display = act.plotting.TimeSeriesDisplay(ds, figsize=(7, 6), subplot_shape=(2,)) display.time_height_scatter('tdry', plot_alt_field=True, subplot_index=(0,)) -display.time_height_scatter('rh', subplot_index=(1,), cb_friendly=True, day_night_background=True) +display.time_height_scatter('rh', subplot_index=(1,), cvd_friendly=True, day_night_background=True) plt.tight_layout() ds.close() diff --git a/examples/plotting/plot_violin.py b/examples/plotting/plot_violin.py index ce343c8078..3176514dc3 100644 --- a/examples/plotting/plot_violin.py +++ b/examples/plotting/plot_violin.py @@ -25,14 +25,16 @@ display = act.plotting.DistributionDisplay(ds) # Compare aircraft ground speed with ambient temperature -display.plot_violin('ambient_temp', - positions=[1.0], - ) - -display.plot_violin('total_temp', - positions=[2.0], - set_title='Aircraft Temperatures 2018-11-04', - ) +display.plot_violin( + 'ambient_temp', + positions=[1.0], +) + +display.plot_violin( + 'total_temp', + positions=[2.0], + set_title='Aircraft Temperatures 2018-11-04', +) # Update the tick information display.axes[0].set_xticks([0.5, 1, 2, 2.5]) diff --git a/examples/plotting/plot_wind_rose.py b/examples/plotting/plot_wind_rose.py index 3e4eda965a..140e950024 100644 --- a/examples/plotting/plot_wind_rose.py +++ b/examples/plotting/plot_wind_rose.py @@ -14,30 +14,32 @@ import act # Read in sonde files -twp_sonde_wildcard_list = ['twpsondewnpnC3.b1.20060119.050300.custom.cdf', - 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', - 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', - 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', - 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', - 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', - 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', - 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', - 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', - 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', - 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', - 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', - 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', - 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', - 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', - 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', - 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', - 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', - 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', - 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', - 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', - 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', - 'twpsondewnpnC3.b1.20060124.231500.custom.cdf'] +twp_sonde_wildcard_list = [ + 'twpsondewnpnC3.b1.20060119.050300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.112000.custom.cdf', + 'twpsondewnpnC3.b1.20060119.163300.custom.cdf', + 'twpsondewnpnC3.b1.20060119.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060120.043800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.111900.custom.cdf', + 'twpsondewnpnC3.b1.20060120.170800.custom.cdf', + 'twpsondewnpnC3.b1.20060120.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060121.111600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060121.231600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.052600.custom.cdf', + 'twpsondewnpnC3.b1.20060122.111500.custom.cdf', + 'twpsondewnpnC3.b1.20060122.171800.custom.cdf', + 'twpsondewnpnC3.b1.20060122.232600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.052500.custom.cdf', + 'twpsondewnpnC3.b1.20060123.111700.custom.cdf', + 'twpsondewnpnC3.b1.20060123.171600.custom.cdf', + 'twpsondewnpnC3.b1.20060123.231500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.051500.custom.cdf', + 'twpsondewnpnC3.b1.20060124.111800.custom.cdf', + 'twpsondewnpnC3.b1.20060124.171700.custom.cdf', + 'twpsondewnpnC3.b1.20060124.231500.custom.cdf', +] sonde_filenames = [DATASETS.fetch(file) for file in twp_sonde_wildcard_list] sonde_ds = act.io.arm.read_arm_netcdf(sonde_filenames) diff --git a/examples/plotting/plot_xsection.py b/examples/plotting/plot_xsection.py index 126e3b9f84..6aec1f42a6 100644 --- a/examples/plotting/plot_xsection.py +++ b/examples/plotting/plot_xsection.py @@ -7,11 +7,9 @@ multi-dimensional dataset """ -from datetime import datetime from arm_test_data import DATASETS import matplotlib.pyplot as plt -import xarray as xr import act diff --git a/examples/qc/plot_arm_qc.py b/examples/qc/plot_arm_qc.py index d8abc6dd26..91d43645a0 100644 --- a/examples/qc/plot_arm_qc.py +++ b/examples/qc/plot_arm_qc.py @@ -145,7 +145,7 @@ # to give to other users. # There is a file in the same directory called sgpmfrsr7nchE11.b1.yaml with times of # incorrect or suspect values that can be read and applied to the Dataset. -from act.qc.add_supplemental_qc import apply_supplemental_qc +from act.qc.add_supplemental_qc import apply_supplemental_qc # noqa apply_supplemental_qc(ds, 'sgpmfrsr7nchE11.b1.yaml') diff --git a/examples/qc/plot_qc_bsrn.py b/examples/qc/plot_qc_bsrn.py index 5cbae6e687..37e3d907e7 100644 --- a/examples/qc/plot_qc_bsrn.py +++ b/examples/qc/plot_qc_bsrn.py @@ -25,10 +25,10 @@ display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) # Plot radiation data in top plot -display.plot(variable, subplot_index=(0,), day_night_background=True, cb_friendly=True) +display.plot(variable, subplot_index=(0,), day_night_background=True, cvd_friendly=True) # Plot ancillary QC data in bottom plot -display.qc_flag_block_plot(variable, subplot_index=(1,), cb_friendly=True) +display.qc_flag_block_plot(variable, subplot_index=(1,), cvd_friendly=True) plt.show() # Add initial BSRN QC tests to ancillary QC varialbles. Use defualts for @@ -69,9 +69,14 @@ display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(2,)) # Plot radiation data in top plot. Add QC information to top plot. -display.plot(variable, subplot_index=(0,), day_night_background=True, assessment_overplot=True, - cb_friendly=True) +display.plot( + variable, + subplot_index=(0,), + day_night_background=True, + assessment_overplot=True, + cvd_friendly=True, +) # Plot ancillary QC data in bottom plot -display.qc_flag_block_plot(variable, subplot_index=(1,), cb_friendly=True) +display.qc_flag_block_plot(variable, subplot_index=(1,), cvd_friendly=True) plt.show() diff --git a/examples/retrievals/plot_cbh_sobel.py b/examples/retrievals/plot_cbh_sobel.py index 100c2e9f25..e5764a1067 100644 --- a/examples/retrievals/plot_cbh_sobel.py +++ b/examples/retrievals/plot_cbh_sobel.py @@ -19,8 +19,9 @@ filename_ceil = DATASETS.fetch('sgpceilC1.b1.20190101.000000.nc') ds = act.io.arm.read_arm_netcdf(filename_ceil) -ds = act.retrievals.cbh.generic_sobel_cbh(ds, variable='backscatter', height_dim='range', - var_thresh=1000.0, fill_na=0.) +ds = act.retrievals.cbh.generic_sobel_cbh( + ds, variable='backscatter', height_dim='range', var_thresh=1000.0, fill_na=0.0 +) # Plot the cloud base height data display = act.plotting.TimeSeriesDisplay(ds, subplot_shape=(1, 2), figsize=(16, 6)) diff --git a/examples/templates/example_template.py b/examples/templates/example_template.py index 6119c56583..2de33a0c90 100644 --- a/examples/templates/example_template.py +++ b/examples/templates/example_template.py @@ -11,7 +11,8 @@ # Download and read file or files with the IO and discovery functions # within ACT, example: results = act.discovery.download_arm_data( - username, token, 'sgpceilC1.b1', '2022-01-14', '2022-01-19') + username, token, 'sgpceilC1.b1', '2022-01-14', '2022-01-19' +) ceil_ds = act.io.arm.read_arm_netcdf(results) # Plot file using the ACT display submodule, example: diff --git a/examples/templates/notebook_and_blog_template.ipynb b/examples/templates/notebook_and_blog_template.ipynb index cefe371a3b..0366a89eeb 100644 --- a/examples/templates/notebook_and_blog_template.ipynb +++ b/examples/templates/notebook_and_blog_template.ipynb @@ -192,11 +192,7 @@ "start_date = \"2022-01-01T12:00:00\"\n", "end_date = \"2022-01-07T12:00:00\"\n", "\n", - "files = act.discovery.download_data(arm_username,\n", - " arm_password,\n", - " datastream,\n", - " start_date,\n", - " end_date)" + "files = act.discovery.download_data(arm_username, arm_password, datastream, start_date, end_date)" ] }, { @@ -254,12 +250,12 @@ "source": [ "# Create an ACT TimeSeriesDisplay.\n", "display = act.plotting.TimeSeriesDisplay(\n", - " {'Shear, Wind Direction, and Speed at ANL ATMOS': ds},\n", - " subplot_shape=(1,), figsize=(15, 5))\n", + " {'Shear, Wind Direction, and Speed at ANL ATMOS': ds}, subplot_shape=(1,), figsize=(15, 5)\n", + ")\n", "\n", "# Plot shear with a wind barb overlay, while using a color vision\n", "# deficiency (CVD) colormap.\n", - "display.plot('shear', subplot_index=(0,), cb_friendly=True)\n", + "display.plot('shear', subplot_index=(0,), cvd_friendly=True)\n", "display.plot_barbs_from_spd_dir('speed', 'dir')\n", "plt.show()" ] diff --git a/examples/utils/plot_calculated_percentages.py b/examples/utils/plot_calculated_percentages.py new file mode 100644 index 0000000000..8bae97b357 --- /dev/null +++ b/examples/utils/plot_calculated_percentages.py @@ -0,0 +1,33 @@ +""" +Calculate and plot aerosol percentages. +---------------------------------------- + +Example on how to plot a Pie Chart of the composition of aerosols in a volume of air by +obtaining percentages of each aerosol from the dataset. + +Author: Zach Sherman +""" + +from arm_test_data import DATASETS +import matplotlib.pyplot as plt + +import act + +# Read in the data. +ds = act.io.read_arm_netcdf(DATASETS.fetch("sgpaosacsmE13.b2.20230420.000109.nc")) + +# Calculate percentages using selected fields. +fields = ['sulfate', 'ammonium', 'nitrate', 'chloride'] +time_slice = ('2023-04-20T17:38:20.000000000', '2023-04-20T20:29:47.000000000') +threshold = 0.0 +percentages = act.utils.calculate_percentages(ds, fields, time_slice=time_slice, threshold=0.0) + +# Get values for the pie chart. +labels = percentages.keys() +sizes = [percentages[i] for i in percentages.keys()] + +# Plot the figure +fig, ax = plt.subplots() +ax.pie(sizes, labels=labels, autopct='%1.1f%%') +plt.show() +ds.close() diff --git a/examples/utils/plot_tar.py b/examples/utils/plot_tar.py index d09c301871..b4dedaff0d 100644 --- a/examples/utils/plot_tar.py +++ b/examples/utils/plot_tar.py @@ -11,7 +11,6 @@ """ -import os from pathlib import Path # Import standard libraries @@ -27,13 +26,15 @@ # TAR file into read_arm_netcdf() to be unpacked and read. # Here we get a list of MET data files to pack into a TAR bundle -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] met_files = [Path(DATASETS.fetch(file)) for file in met_wildcard_list] # We can pass the list of netCDF data files to the pack_tar() function. diff --git a/examples/workflows/plot_aerioe_with_cbh.py b/examples/workflows/plot_aerioe_with_cbh.py index 717d47933e..aed0041f01 100644 --- a/examples/workflows/plot_aerioe_with_cbh.py +++ b/examples/workflows/plot_aerioe_with_cbh.py @@ -22,9 +22,13 @@ if username is None or token is None or len(username) == 0 or len(token) == 0: pass else: - results = act.discovery.download_arm_data(username, token, 'sgpaerioe1turnC1.c1', '2022-02-11', '2022-02-11') + results = act.discovery.download_arm_data( + username, token, 'sgpaerioe1turnC1.c1', '2022-02-11', '2022-02-11' + ) aerioe_ds = act.io.arm.read_arm_netcdf(results) - results = act.discovery.download_arm_data(username, token, 'sgpceilC1.b1', '2022-02-11', '2022-02-11') + results = act.discovery.download_arm_data( + username, token, 'sgpceilC1.b1', '2022-02-11', '2022-02-11' + ) ceil_ds = act.io.arm.read_arm_netcdf(results) # There isn't information content from the AERI above 3 km @@ -39,20 +43,47 @@ # Create a TimeSeriesDisplay object display = act.plotting.TimeSeriesDisplay( - {'AERIoe': aerioe_ds, 'Ceilometer': ceil_ds}, - subplot_shape=(2,), figsize=(20, 10) + {'AERIoe': aerioe_ds, 'Ceilometer': ceil_ds}, subplot_shape=(2,), figsize=(20, 10) ) # Plot data - display.plot('first_cbh', dsname='Ceilometer', marker='+', color='black', markeredgewidth=3, - linewidth=0, subplot_index=(0,), label='cbh') - display.plot('temperature', dsname='AERIoe', cmap='viridis', set_shading='nearest', - add_nan=True, subplot_index=(0,)) - - display.plot('first_cbh', dsname='Ceilometer', marker='+', color='black', markeredgewidth=3, - linewidth=0, subplot_index=(1,), label='cbh') - display.plot('waterVapor', dsname='AERIoe', cmap='HomeyerRainbow', set_shading='nearest', - add_nan=True, subplot_index=(1,)) + display.plot( + 'first_cbh', + dsname='Ceilometer', + marker='+', + color='black', + markeredgewidth=3, + linewidth=0, + subplot_index=(0,), + label='cbh', + ) + display.plot( + 'temperature', + dsname='AERIoe', + cmap='viridis', + set_shading='nearest', + add_nan=True, + subplot_index=(0,), + ) + + display.plot( + 'first_cbh', + dsname='Ceilometer', + marker='+', + color='black', + markeredgewidth=3, + linewidth=0, + subplot_index=(1,), + label='cbh', + ) + display.plot( + 'waterVapor', + dsname='AERIoe', + cmap='HomeyerRainbow', + set_shading='nearest', + add_nan=True, + subplot_index=(1,), + ) # If you want to save it you can # plt.savefig('sgpaerioe1turnC1.c1.20220211.png') diff --git a/examples/workflows/plot_merged_product.py b/examples/workflows/plot_merged_product.py index bc9764bb83..0713ef40a2 100644 --- a/examples/workflows/plot_merged_product.py +++ b/examples/workflows/plot_merged_product.py @@ -36,7 +36,7 @@ # The ECOR and EBBR have different definitions of latent heat # flux and what is positive vs negative. Check out the ARM # Handbooks for more information -ds_ecor['lv_e'].values = ds_ecor['lv_e'].values * -1. +ds_ecor['lv_e'].values = ds_ecor['lv_e'].values * -1.0 # For example purposes, let's rename the ecor latent heat flux ds_ecor = ds_ecor.rename({'lv_e': 'latent_heat_flux_ecor'}) @@ -58,7 +58,9 @@ ds = xr.merge([ds_ecor, ds_ebbr, ds_sebs], compat='override') # Apply the QC information to set all flagged data to missing/NaN -ds.qcfilter.datafilter(del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect']) +ds.qcfilter.datafilter( + del_qc_var=False, rm_assessments=['Bad', 'Incorrect', 'Indeterminate', 'Suspect'] +) # Plot up data from the merged dataset for each of the instruments display = act.plotting.TimeSeriesDisplay(ds, figsize=(15, 10), subplot_shape=(3,)) diff --git a/examples/workflows/plot_multiple_dataset.py b/examples/workflows/plot_multiple_dataset.py index fba3c58f05..40264b00fd 100644 --- a/examples/workflows/plot_multiple_dataset.py +++ b/examples/workflows/plot_multiple_dataset.py @@ -27,9 +27,13 @@ met_ds = act.io.arm.read_arm_netcdf(filename_met) else: # Download and read data - results = act.discovery.download_arm_data(username, token, 'sgpceilC1.b1', '2022-01-01', '2022-01-07') + results = act.discovery.download_arm_data( + username, token, 'sgpceilC1.b1', '2022-01-01', '2022-01-07' + ) ceil_ds = act.io.arm.read_arm_netcdf(results) - results = act.discovery.download_arm_data(username, token, 'sgpmetE13.b1', '2022-01-01', '2022-01-07') + results = act.discovery.download_arm_data( + username, token, 'sgpmetE13.b1', '2022-01-01', '2022-01-07' + ) met_ds = act.io.arm.read_arm_netcdf(results) # Read in CEIL data and correct it diff --git a/examples/workflows/plot_qc_transforms.py b/examples/workflows/plot_qc_transforms.py index b3ba93b01c..501318e0c0 100644 --- a/examples/workflows/plot_qc_transforms.py +++ b/examples/workflows/plot_qc_transforms.py @@ -10,7 +10,6 @@ from arm_test_data import DATASETS import matplotlib.pyplot as plt -import xarray as xr import act @@ -42,10 +41,17 @@ print('After: (2 5 - minute averages)', ds_5minb[variable].values[0:2]) ## Plot up the variable and qc block plot -display = act.plotting.TimeSeriesDisplay({'Original': ds, 'Average': ds_5min, 'Average_QCd': ds_5minb}, - figsize=(15, 10), subplot_shape=(2,)) +display = act.plotting.TimeSeriesDisplay( + {'Original': ds, 'Average': ds_5min, 'Average_QCd': ds_5minb}, + figsize=(15, 10), + subplot_shape=(2,), +) display.plot(variable, dsname='Original', subplot_index=(0,), day_night_background=True) -display.plot(variable, dsname='Average', subplot_index=(1,), day_night_background=True, label='No QC') -display.plot(variable, dsname='Average_QCd', subplot_index=(1,), day_night_background=True, label='QC') +display.plot( + variable, dsname='Average', subplot_index=(1,), day_night_background=True, label='No QC' +) +display.plot( + variable, dsname='Average_QCd', subplot_index=(1,), day_night_background=True, label='QC' +) plt.legend() plt.show() diff --git a/examples/workflows/plot_weighted_average.py b/examples/workflows/plot_weighted_average.py index b0645456fc..0199def978 100644 --- a/examples/workflows/plot_weighted_average.py +++ b/examples/workflows/plot_weighted_average.py @@ -35,13 +35,15 @@ # } # Get a list of filenames to use -met_wildcard_list = ['sgpmetE13.b1.20190101.000000.cdf', - 'sgpmetE13.b1.20190102.000000.cdf', - 'sgpmetE13.b1.20190103.000000.cdf', - 'sgpmetE13.b1.20190104.000000.cdf', - 'sgpmetE13.b1.20190105.000000.cdf', - 'sgpmetE13.b1.20190106.000000.cdf', - 'sgpmetE13.b1.20190107.000000.cdf'] +met_wildcard_list = [ + 'sgpmetE13.b1.20190101.000000.cdf', + 'sgpmetE13.b1.20190102.000000.cdf', + 'sgpmetE13.b1.20190103.000000.cdf', + 'sgpmetE13.b1.20190104.000000.cdf', + 'sgpmetE13.b1.20190105.000000.cdf', + 'sgpmetE13.b1.20190106.000000.cdf', + 'sgpmetE13.b1.20190107.000000.cdf', +] ds = {} new = {} diff --git a/guides/GUIDE_V2.rst b/guides/GUIDE_V2.rst index f276012691..fb26e247fb 100644 --- a/guides/GUIDE_V2.rst +++ b/guides/GUIDE_V2.rst @@ -51,7 +51,7 @@ Similar to the discovery module, functionality has not changed but the naming co Plotting ======== -A major change to how secondary y-axes are handled was implemented in the TimeSeriesDisplay and DistributionDisplay modules. Currently, those plotting routines return a 1-D array of display axes. This has always made the secondary y-axis more difficult to configure and use. In the new version, it will return a 2-D array of display axes [[left axes, right axes]] to make it simpler to utilize. +A major change to how secondary y-axes are handled was implemented in the TimeSeriesDisplay and DistributionDisplay modules. Currently, those plotting routines return a 1-D array of display axes. This has always made the secondary y-axis more difficult to configure and use. In the new version, it will return a 2-D array of display axes [[left axes, right axes]] to make it simpler to utilize. HistogramDisplay is being renamed to DistributionDisplay to be more inclusive of the variety of visualization types that are housed there. Additionally there are changes to two of the plot names to be more consistent with the others. diff --git a/guides/act_cheatsheet.tex b/guides/act_cheatsheet.tex index 819bc7a6bd..891a8e6a78 100644 --- a/guides/act_cheatsheet.tex +++ b/guides/act_cheatsheet.tex @@ -396,8 +396,8 @@ \begin{poster} { -headerborder=closed, colspacing=0.8em, bgColorOne=white, bgColorTwo=white, borderColor=lightblue, headerColorOne=black, headerColorTwo=lightblue, -headerFontColor=white, boxColorOne=white, textborder=roundedleft, eyecatcher=true, headerheight=0.06\textheight, headershape=roundedright, headerfont=\Large\bf\textsc, linewidth=2pt +headerborder=closed, colspacing=0.8em, bgColorOne=white, bgColorTwo=white, borderColor=lightblue, headerColorOne=black, headerColorTwo=lightblue, +headerFontColor=white, boxColorOne=white, textborder=roundedleft, eyecatcher=true, headerheight=0.06\textheight, headershape=roundedright, headerfont=\Large\bf\textsc, linewidth=2pt } %---------------------------------------------------------------- % Title @@ -436,7 +436,7 @@ $>$$>$$>$ display.put\_display\_in\_subplot(\\ \-\hspace{1.2cm} display, subplot\_index))\\ \-\hspace{0.2cm} $\bullet$ This will place a Display object into a specific\\ -\-\hspace{0.5cm} subplot. +\-\hspace{0.5cm} subplot. \end{tabular} \begin{tabular}{@{}ll@{}} diff --git a/pyproject.toml b/pyproject.toml index 06353c6682..6f4440c460 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,3 +6,9 @@ ignore = ["act/io/arm.py"] [tool.check-manifest] ignore = ["docs/*", "ci/*"] + +[tool.ruff] +target-version = "py39" +ignore = [ + "E501", +] diff --git a/requirements.txt b/requirements.txt index 9098993baf..6b8e108fbd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -18,4 +18,4 @@ fsspec metpy lxml cmweather -aiohttp>=3.9.0b1 \ No newline at end of file +aiohttp>=3.9.0b1 diff --git a/scripts/ads.py b/scripts/ads.py index 5a61ff51fb..d4cd336d50 100644 --- a/scripts/ads.py +++ b/scripts/ads.py @@ -10,7 +10,6 @@ """ import argparse -import re import json import glob import ast @@ -21,6 +20,7 @@ try: import cartopy.crs as ccrs + CARTOPY_AVAILABLE = True except ImportError: CARTOPY_AVAILABLE = False @@ -51,8 +51,10 @@ def option_error_check(args, error_fields, check_all=False): if not value.startswith(prepend): error_fields[ii] = prepend + value - print(f"\n{pathlib.Path(__file__).name}: error: {how_many} of the arguments " - f"{' '.join(error_fields)} is requried\n") + print( + f"\n{pathlib.Path(__file__).name}: error: {how_many} of the arguments " + f"{' '.join(error_fields)} is requried\n" + ) exit() @@ -118,7 +120,8 @@ def find_drop_vars(args): keep_vars_additional = [] for var_name in keep_vars: qc_var_name = ds.qcfilter.check_for_ancillary_qc( - var_name, add_if_missing=False, cleanup=False) + var_name, add_if_missing=False, cleanup=False + ) if qc_var_name is not None: keep_vars_additional.append(qc_var_name) @@ -142,16 +145,25 @@ def geodisplay(args): except KeyError: pass - display = act.plotting.GeographicPlotDisplay({dsname: ds}, - figsize=args.figsize) - - display.geoplot(data_field=args.field, lat_field=args.latitude, - lon_field=args.longitude, dsname=dsname, - cbar_label=args.cb_label, title=args.set_title, - plot_buffer=args.plot_buffer, stamen=args.stamen, - tile=args.tile, cartopy_feature=args.cfeatures, - cmap=args.cmap, text=args.text, gridlines=args.gridlines, - projection=args.projection, **args.kwargs) + display = act.plotting.GeographicPlotDisplay({dsname: ds}, figsize=args.figsize) + + display.geoplot( + data_field=args.field, + lat_field=args.latitude, + lon_field=args.longitude, + dsname=dsname, + cbar_label=args.cb_label, + title=args.set_title, + plot_buffer=args.plot_buffer, + stamen=args.stamen, + tile=args.tile, + cartopy_feature=args.cfeatures, + cmap=args.cmap, + text=args.text, + gridlines=args.gridlines, + projection=args.projection, + **args.kwargs, + ) plt.savefig(args.out_path) plt.show() @@ -175,26 +187,33 @@ def skewt(args): display = act.plotting.SkewTDisplay({dsname: ds}, figsize=args.figsize) if args.from_u_and_v: - display.plot_from_u_and_v(u_field=args.u_wind, v_field=args.v_wind, - p_field=args.p_field, t_field=args.t_field, - td_field=args.td_field, - subplot_index=subplot_index, - dsname=dsname, show_parcel=args.show_parcel, - p_levels_to_plot=args.plevels_plot, - shade_cape=args.shade_cape, - shade_cin=args.shade_cin, - set_title=args.set_title, - plot_barbs_kwargs=args.plot_barbs_kwargs, - plot_kwargs=args.plot_kwargs) + display.plot_from_u_and_v( + u_field=args.u_wind, + v_field=args.v_wind, + p_field=args.p_field, + t_field=args.t_field, + td_field=args.td_field, + subplot_index=subplot_index, + dsname=dsname, + show_parcel=args.show_parcel, + p_levels_to_plot=args.plevels_plot, + shade_cape=args.shade_cape, + shade_cin=args.shade_cin, + set_title=args.set_title, + plot_barbs_kwargs=args.plot_barbs_kwargs, + plot_kwargs=args.plot_kwargs, + ) if args.from_spd_and_dir: - display.plot_from_spd_and_dir(spd_field=args.spd_field, - dir_field=args.dir_field, - p_field=args.p_field, - t_field=args.t_field, - td_field=args.td_field, - dsname=dsname, - **args.kwargs) + display.plot_from_spd_and_dir( + spd_field=args.spd_field, + dir_field=args.dir_field, + p_field=args.p_field, + t_field=args.t_field, + td_field=args.td_field, + dsname=dsname, + **args.kwargs, + ) plt.savefig(args.out_path) plt.show() @@ -218,18 +237,26 @@ def xsection(args): display = act.plotting.XSectionDisplay({dsname: ds}, figsize=args.figsize) if args.plot_xsection: - display.plot_xsection(dsname=dsname, varname=args.field, - x=args.x_field, y=args.y_field, - subplot_index=subplot_index, - sel_kwargs=args.sel_kwargs, - isel_kwargs=args.isel_kwargs, **args.kwargs) + display.plot_xsection( + dsname=dsname, + varname=args.field, + x=args.x_field, + y=args.y_field, + subplot_index=subplot_index, + sel_kwargs=args.sel_kwargs, + isel_kwargs=args.isel_kwargs, + **args.kwargs, + ) if args.xsection_map: - display.plot_xsection_map(dsname=dsname, varname=args.field, - subplot_index=subplot_index, - coastlines=args.coastlines, - background=args.background, - **args.kwargs) + display.plot_xsection_map( + dsname=dsname, + varname=args.field, + subplot_index=subplot_index, + coastlines=args.coastlines, + background=args.background, + **args.kwargs, + ) plt.savefig(args.out_path) plt.show() @@ -239,7 +266,6 @@ def xsection(args): def wind_rose(args): - drop_vars = find_drop_vars(args) ds = act.io.arm.read_arm_netcdf(args.file_path, drop_variables=drop_vars) @@ -253,15 +279,20 @@ def wind_rose(args): except KeyError: pass - display = act.plotting.WindRoseDisplay({dsname: ds}, - figsize=args.figsize) - - display.plot(dir_field=args.dir_field, spd_field=args.spd_field, - subplot_index=subplot_index, - dsname=dsname, cmap=args.cmap, - set_title=args.set_title, - num_dirs=args.num_dir, spd_bins=args.spd_bins, - tick_interval=args.tick_interval, **args.kwargs) + display = act.plotting.WindRoseDisplay({dsname: ds}, figsize=args.figsize) + + display.plot( + dir_field=args.dir_field, + spd_field=args.spd_field, + subplot_index=subplot_index, + dsname=dsname, + cmap=args.cmap, + set_title=args.set_title, + num_dirs=args.num_dir, + spd_bins=args.spd_bins, + tick_interval=args.tick_interval, + **args.kwargs, + ) plt.savefig(args.out_path) plt.show() plt.close(display.fig) @@ -270,7 +301,6 @@ def wind_rose(args): def timeseries(args): - drop_vars = find_drop_vars(args) ds = act.io.arm.read_arm_netcdf(args.file_path, drop_variables=drop_vars) @@ -289,11 +319,19 @@ def timeseries(args): pass display = act.plotting.TimeSeriesDisplay( - {dsname: ds}, figsize=args.figsize, - subplot_shape=subplot_shape) - - options = ['plot', 'barbs_spd_dir', 'barbs_u_v', 'xsection_from_1d', - 'time_height_scatter', 'qc', 'fill_between', 'multi_panel'] + {dsname: ds}, figsize=args.figsize, subplot_shape=subplot_shape + ) + + options = [ + 'plot', + 'barbs_spd_dir', + 'barbs_u_v', + 'xsection_from_1d', + 'time_height_scatter', + 'qc', + 'fill_between', + 'multi_panel', + ] option_error_check(args, options) if args.plot: @@ -303,20 +341,27 @@ def timeseries(args): else: yrange = args.set_yrange display.plot( - field=args.field, dsname=dsname, cmap=args.cmap, - set_title=args.set_title, add_nan=args.add_nan, + field=args.field, + dsname=dsname, + cmap=args.cmap, + set_title=args.set_title, + add_nan=args.add_nan, subplot_index=subplot_index, use_var_for_y=args.var_y, day_night_background=args.day_night, invert_y_axis=args.invert_y_axis, - abs_limits=args.abs_limits, time_rng=args.time_rng, + abs_limits=args.abs_limits, + time_rng=args.time_rng, assessment_overplot=args.assessment_overplot, assessment_overplot_category=args.overplot_category, assessment_overplot_category_color=args.category_color, - force_line_plot=args.force_line_plot, labels=args.labels, - cbar_label=args.cb_label, secondary_y=args.secondary_y, + force_line_plot=args.force_line_plot, + labels=args.labels, + cbar_label=args.cb_label, + secondary_y=args.secondary_y, y_rng=yrange, - **args.kwargs) + **args.kwargs, + ) if args.barbs_spd_dir: display.plot_barbs_from_spd_dir( @@ -324,12 +369,15 @@ def timeseries(args): spd_field=args.spd_field, pres_field=args.p_field, dsname=dsname, - **args.kwargs) + **args.kwargs, + ) if args.barbs_u_v: display.plot_barbs_from_u_v( - u_field=args.u_wind, v_field=args.v_wind, - pres_field=args.p_field, dsname=dsname, + u_field=args.u_wind, + v_field=args.v_wind, + pres_field=args.p_field, + dsname=dsname, set_title=args.set_title, invert_y_axis=args.invert_y_axis, day_night_background=args.day_night, @@ -337,49 +385,61 @@ def timeseries(args): num_barbs_y=args.num_barb_y, use_var_for_y=args.var_y, subplot_index=subplot_index, - **args.kwargs) + **args.kwargs, + ) if args.xsection_from_1d: option_error_check(args, 'field') display.plot_time_height_xsection_from_1d_data( - data_field=args.field, pres_field=args.p_field, - dsname=dsname, set_title=args.set_title, + data_field=args.field, + pres_field=args.p_field, + dsname=dsname, + set_title=args.set_title, day_night_background=args.day_night, num_time_periods=args.num_time_periods, num_y_levels=args.num_y_levels, invert_y_axis=args.invert_y_axis, subplot_index=subplot_index, cbar_label=args.cb_label, - **args.kwargs) + **args.kwargs, + ) if args.time_height_scatter: option_error_check(args, 'field') display.time_height_scatter( - data_field=args.field, dsname=dsname, - cmap=args.cmap, alt_label=args.alt_label, - alt_field=args.alt_field, cb_label=args.cb_label, - **args.kwargs) + data_field=args.field, + dsname=dsname, + cmap=args.cmap, + alt_label=args.alt_label, + alt_field=args.alt_field, + cb_label=args.cb_label, + **args.kwargs, + ) if args.qc: option_error_check(args, 'field') display.qc_flag_block_plot( - data_field=args.field, dsname=dsname, + data_field=args.field, + dsname=dsname, subplot_index=subplot_index, time_rng=args.time_rng, assessment_color=args.assessment_color, - **args.kwargs) + **args.kwargs, + ) if args.fill_between: option_error_check(args, 'field') display.fill_between( - field=args.field, dsname=dsname, + field=args.field, + dsname=dsname, subplot_index=subplot_index, set_title=args.set_title, secondary_y=args.secondary_y, - **args.kwargs) + **args.kwargs, + ) if args.multi_panel: option_error_check(args, ['fields', 'plot_type'], check_all=True) @@ -387,27 +447,36 @@ def timeseries(args): for i, j, k in zip(args.fields, subplot_index, args.plot_type): if k == 'plot': display.plot( - field=i, dsname=dsname, cmap=args.cmap, - set_title=args.set_title, add_nan=args.add_nan, + field=i, + dsname=dsname, + cmap=args.cmap, + set_title=args.set_title, + add_nan=args.add_nan, subplot_index=j, use_var_for_y=args.var_y, day_night_background=args.day_night, invert_y_axis=args.invert_y_axis, - abs_limits=args.abs_limits, time_rng=args.time_rng, + abs_limits=args.abs_limits, + time_rng=args.time_rng, assessment_overplot=args.assessment_overplot, assessment_overplot_category=args.overplot_category, assessment_overplot_category_color=args.category_color, - force_line_plot=args.force_line_plot, labels=args.labels, - cbar_label=args.cb_label, secondary_y=args.secondary_y, - **args.kwargs) + force_line_plot=args.force_line_plot, + labels=args.labels, + cbar_label=args.cb_label, + secondary_y=args.secondary_y, + **args.kwargs, + ) if k == 'qc': display.qc_flag_block_plot( - data_field=i, dsname=dsname, + data_field=i, + dsname=dsname, subplot_index=j, time_rng=args.time_rng, assessment_color=args.assessment_color, - **args.kwargs) + **args.kwargs, + ) plt.savefig(args.out_path) plt.show() @@ -417,7 +486,6 @@ def timeseries(args): def histogram(args): - drop_vars = find_drop_vars(args) ds = act.io.arm.read_arm_netcdf(args.file_path, drop_variables=drop_vars) @@ -433,44 +501,58 @@ def histogram(args): pass display = act.plotting.DistributionDisplay( - {dsname: ds}, figsize=args.figsize, - subplot_shape=subplot_shape) + {dsname: ds}, figsize=args.figsize, subplot_shape=subplot_shape + ) if args.stacked_bar_graph: display.plot_stacked_bar_graph( - field=args.field, dsname=dsname, - bins=args.bins, density=args.density, + field=args.field, + dsname=dsname, + bins=args.bins, + density=args.density, sortby_field=args.sortby_field, sortby_bins=args.sortby_bins, set_title=args.set_title, subplot_index=subplot_index, - **args.kwargs) + **args.kwargs, + ) if args.size_dist: display.plot_size_distribution( - field=args.field, bins=args.bin_field, - time=args.time, dsname=dsname, + field=args.field, + bins=args.bin_field, + time=args.time, + dsname=dsname, set_title=args.set_title, subplot_index=subplot_index, - **args.kwargs) + **args.kwargs, + ) if args.stairstep: display.plot_stairstep_graph( - field=args.field, dsname=dsname, - bins=args.bins, density=args.density, + field=args.field, + dsname=dsname, + bins=args.bins, + density=args.density, sortby_field=args.sortby_field, sortby_bins=args.sortby_bins, set_title=args.set_title, subplot_index=subplot_index, - **args.kwargs) + **args.kwargs, + ) if args.heatmap: display.plot_heatmap( - x_field=args.x_field, y_field=args.y_field, - dsname=dsname, x_bins=args.x_bins, - y_bins=args.y_bins, set_title=args.set_title, + x_field=args.x_field, + y_field=args.y_field, + dsname=dsname, + x_bins=args.x_bins, + y_bins=args.y_bins, + set_title=args.set_title, density=args.density, - subplot_index=subplot_index, **args.kwargs) + subplot_index=subplot_index, + **args.kwargs, + ) plt.savefig(args.out_path) plt.show() @@ -498,40 +580,51 @@ def contour(args): display = act.plotting.ContourDisplay(data, figsize=args.figsize) if args.create_contour: - display.create_contour(fields=fields, time=time, function=args.function, - grid_delta=args.grid_delta, - grid_buffer=args.grid_buffer, - subplot_index=args.subplot_index, - **args.kwargs) + display.create_contour( + fields=fields, + time=time, + function=args.function, + grid_delta=args.grid_delta, + grid_buffer=args.grid_buffer, + subplot_index=args.subplot_index, + **args.kwargs, + ) if args.contourf: - display.contourf(x=args.x, y=args.y, z=args.z, - subplot_index=args.subplot_index, - **args.kwargs) + display.contourf( + x=args.x, y=args.y, z=args.z, subplot_index=args.subplot_index, **args.kwargs + ) if args.plot_contour: - display.contour(x=args.x, y=args.y, z=args.z, - subplot_index=args.subplot_index, - **args.kwargs) + display.contour( + x=args.x, y=args.y, z=args.z, subplot_index=args.subplot_index, **args.kwargs + ) if args.vectors_spd_dir: - display.plot_vectors_from_spd_dir(fields=wind_fields, time=time, - mesh=args.mesh, function=args.function, - grid_delta=args.grid_delta, - grid_buffer=args.grid_buffer, - subplot_index=args.subplot_index, - **args.kwargs) + display.plot_vectors_from_spd_dir( + fields=wind_fields, + time=time, + mesh=args.mesh, + function=args.function, + grid_delta=args.grid_delta, + grid_buffer=args.grid_buffer, + subplot_index=args.subplot_index, + **args.kwargs, + ) if args.barbs: - display.barbs(x=args.x, y=args.y, u=args.u, v=args.v, - subplot_index=args.subplot_index, - **args.kwargs) + display.barbs( + x=args.x, y=args.y, u=args.u, v=args.v, subplot_index=args.subplot_index, **args.kwargs + ) if args.plot_station: - display.plot_station(fields=station_fields, time=time, - text_color=args.text_color, - subplot_index=args.subplot_index, - **args.kwargs) + display.plot_station( + fields=station_fields, + time=time, + text_color=args.text_color, + subplot_index=args.subplot_index, + **args.kwargs, + ) plt.savefig(args.out_path) plt.show() @@ -555,8 +648,11 @@ def convert_arg_line_to_args(line): def main(): prefix_char = '@' parser = argparse.ArgumentParser( - description=(f'Create plot from a data file. Can use command line opitons ' - f'or point to a configuration file using {prefix_char} character.')) + description=( + f'Create plot from a data file. Can use command line opitons ' + f'or point to a configuration file using {prefix_char} character.' + ) + ) # Allow user to reference a file by using the @ symbol for a specific # argument value @@ -565,336 +661,817 @@ def main(): # Update the file parsing logic to skip commented lines parser.convert_arg_line_to_args = convert_arg_line_to_args - parser.add_argument('-f', '--file_path', type=str, required=True, - help=('Required: Full path to file for creating Plot. For multiple ' - 'files use terminal syntax for matching muliple files. ' - 'For example "sgpmetE13.b1.202007*.*.nc" will match all files ' - 'for the month of July in 2020. Need to use double quotes ' - 'to stop terminal from expanding the search, and let the ' - 'python program perform search.')) + parser.add_argument( + '-f', + '--file_path', + type=str, + required=True, + help=( + 'Required: Full path to file for creating Plot. For multiple ' + 'files use terminal syntax for matching muliple files. ' + 'For example "sgpmetE13.b1.202007*.*.nc" will match all files ' + 'for the month of July in 2020. Need to use double quotes ' + 'to stop terminal from expanding the search, and let the ' + 'python program perform search.' + ), + ) out_path_default = 'image.png' - parser.add_argument('-o', '--out_path', type=str, default=out_path_default, - help=("Full path filename to use for saving image. " - "Default is '{out_path_default}'. If only a path is given " - "will use that path with image name '{out_path_default}', " - "else will use filename given.")) - parser.add_argument('-fd', '--field', type=str, default=None, - help='Name of the field to plot') - parser.add_argument('-fds', '--fields', nargs='+', - type=str, default=None, - help='Name of the fields to use to plot') - parser.add_argument('-wfs', '--wind_fields', nargs='+', - type=str, default=None, - help='Wind field names used to plot') - parser.add_argument('-sfs', '--station_fields', nargs='+', - type=str, default=None, - help='Station field names to plot sites') + parser.add_argument( + '-o', + '--out_path', + type=str, + default=out_path_default, + help=( + "Full path filename to use for saving image. " + "Default is '{out_path_default}'. If only a path is given " + "will use that path with image name '{out_path_default}', " + "else will use filename given." + ), + ) + parser.add_argument('-fd', '--field', type=str, default=None, help='Name of the field to plot') + parser.add_argument( + '-fds', + '--fields', + nargs='+', + type=str, + default=None, + help='Name of the fields to use to plot', + ) + parser.add_argument( + '-wfs', + '--wind_fields', + nargs='+', + type=str, + default=None, + help='Wind field names used to plot', + ) + parser.add_argument( + '-sfs', + '--station_fields', + nargs='+', + type=str, + default=None, + help='Station field names to plot sites', + ) default = 'lat' - parser.add_argument('-lat', '--latitude', type=str, default=default, - help=f"Name of latitude variable in file. Default is '{default}'") + parser.add_argument( + '-lat', + '--latitude', + type=str, + default=default, + help=f"Name of latitude variable in file. Default is '{default}'", + ) default = 'lon' - parser.add_argument('-lon', '--longitude', type=str, default=default, - help=f"Name of longitude variable in file. Default is '{default}'") - parser.add_argument('-xf', '--x_field', type=str, default=None, - help='Name of variable to plot on x axis') - parser.add_argument('-yf', '--y_field', type=str, default=None, - help='Name of variable to plot on y axis') - parser.add_argument('-x', type=np.array, - help='x coordinates or grid for z') - parser.add_argument('-y', type=np.array, - help='y coordinates or grid for z') - parser.add_argument('-z', type=np.array, - help='Values over which to contour') + parser.add_argument( + '-lon', + '--longitude', + type=str, + default=default, + help=f"Name of longitude variable in file. Default is '{default}'", + ) + parser.add_argument( + '-xf', '--x_field', type=str, default=None, help='Name of variable to plot on x axis' + ) + parser.add_argument( + '-yf', '--y_field', type=str, default=None, help='Name of variable to plot on y axis' + ) + parser.add_argument('-x', type=np.array, help='x coordinates or grid for z') + parser.add_argument('-y', type=np.array, help='y coordinates or grid for z') + parser.add_argument('-z', type=np.array, help='Values over which to contour') default = 'u_wind' - parser.add_argument('-u', '--u_wind', type=str, default=default, - help=f"File variable name for u_wind wind component. Default is '{default}'") + parser.add_argument( + '-u', + '--u_wind', + type=str, + default=default, + help=f"File variable name for u_wind wind component. Default is '{default}'", + ) default = 'v_wind' - parser.add_argument('-v', '--v_wind', type=str, default=default, - help=f"File variable name for v_wind wind compenent. Default is '{default}'") + parser.add_argument( + '-v', + '--v_wind', + type=str, + default=default, + help=f"File variable name for v_wind wind compenent. Default is '{default}'", + ) default = 'pres' - parser.add_argument('-pf', '--p_field', type=str, default=default, - help=f"File variable name for pressure. Default is '{default}'") + parser.add_argument( + '-pf', + '--p_field', + type=str, + default=default, + help=f"File variable name for pressure. Default is '{default}'", + ) default = 'tdry' - parser.add_argument('-tf', '--t_field', type=str, default=default, - help=f"File variable name for temperature. Default is '{default}'") + parser.add_argument( + '-tf', + '--t_field', + type=str, + default=default, + help=f"File variable name for temperature. Default is '{default}'", + ) default = 'dp' - parser.add_argument('-tdf', '--td_field', type=str, default=default, - help=f"File variable name for dewpoint temperature. Default is '{default}'") + parser.add_argument( + '-tdf', + '--td_field', + type=str, + default=default, + help=f"File variable name for dewpoint temperature. Default is '{default}'", + ) default = 'wspd' - parser.add_argument('-sf', '--spd_field', type=str, default=default, - help=f"File variable name for wind speed. Default is '{default}'") + parser.add_argument( + '-sf', + '--spd_field', + type=str, + default=default, + help=f"File variable name for wind speed. Default is '{default}'", + ) default = 'deg' - parser.add_argument('-df', '--dir_field', type=str, default=default, - help=f"File variable name for wind direction. Default is '{default}'") - parser.add_argument('-al', '--alt_label', type=str, default=None, - help='Altitude axis label') + parser.add_argument( + '-df', + '--dir_field', + type=str, + default=default, + help=f"File variable name for wind direction. Default is '{default}'", + ) + parser.add_argument('-al', '--alt_label', type=str, default=None, help='Altitude axis label') default = 'alt' - parser.add_argument('-af', '--alt_field', type=str, default=default, - help=f"File variable name for altitude. Default is '{default}'") + parser.add_argument( + '-af', + '--alt_field', + type=str, + default=default, + help=f"File variable name for altitude. Default is '{default}'", + ) global _default_dsname _default_dsname = 'act_datastream' - parser.add_argument('-ds', '--dsname', type=str, default=_default_dsname, - help=f"Name of datastream to plot. Default is '{_default_dsname}'") + parser.add_argument( + '-ds', + '--dsname', + type=str, + default=_default_dsname, + help=f"Name of datastream to plot. Default is '{_default_dsname}'", + ) default = '(0, )' - parser.add_argument('-si', '--subplot_index', type=ast.literal_eval, - default=default, - help=f'Index of the subplot via tuple syntax. ' - f'Example for two plots is "(0,), (1,)". ' - f"Default is '{default}'") - default = (1, ) - parser.add_argument('-ss', '--subplot_shape', nargs='+', type=int, - default=default, - help=(f'The number of (rows, columns) ' - f'for the subplots in the display. ' - f'Default is {default}')) + parser.add_argument( + '-si', + '--subplot_index', + type=ast.literal_eval, + default=default, + help=f'Index of the subplot via tuple syntax. ' + f'Example for two plots is "(0,), (1,)". ' + f"Default is '{default}'", + ) + default = (1,) + parser.add_argument( + '-ss', + '--subplot_shape', + nargs='+', + type=int, + default=default, + help=( + f'The number of (rows, columns) ' + f'for the subplots in the display. ' + f'Default is {default}' + ), + ) plot_type_options = ['plot', 'qc'] - parser.add_argument('-pt', '--plot_type', nargs='+', type=str, - help=f'Type of plot to make. Current options include: ' - f'{plot_type_options}') - parser.add_argument('-vy', '--var_y', type=str, default=None, - help=('Set this to the name of a data variable in ' - 'the Dataset to use as the y-axis variable ' - 'instead of the default dimension.')) - parser.add_argument('-plp', '--plevels_plot', - type=np.array, default=None, - help='Pressure levels to plot the wind barbs on.') - parser.add_argument('-cbl', '--cb_label', type=str, default=None, - help='Colorbar label to use') - parser.add_argument('-st', '--set_title', type=str, default=None, - help='Title for the plot') + parser.add_argument( + '-pt', + '--plot_type', + nargs='+', + type=str, + help=f'Type of plot to make. Current options include: ' f'{plot_type_options}', + ) + parser.add_argument( + '-vy', + '--var_y', + type=str, + default=None, + help=( + 'Set this to the name of a data variable in ' + 'the Dataset to use as the y-axis variable ' + 'instead of the default dimension.' + ), + ) + parser.add_argument( + '-plp', + '--plevels_plot', + type=np.array, + default=None, + help='Pressure levels to plot the wind barbs on.', + ) + parser.add_argument('-cbl', '--cb_label', type=str, default=None, help='Colorbar label to use') + parser.add_argument('-st', '--set_title', type=str, default=None, help='Title for the plot') default = 0.08 - parser.add_argument('-pb', '--plot_buffer', type=float, default=default, - help=(f'Buffer to add around data on plot in lat ' - f'and lon dimension. Default is {default}')) + parser.add_argument( + '-pb', + '--plot_buffer', + type=float, + default=default, + help=( + f'Buffer to add around data on plot in lat ' f'and lon dimension. Default is {default}' + ), + ) default = 'terrain-background' - parser.add_argument('-sm', '--stamen', type=str, default=default, - help=f"Dataset to use for background image. Default is '{default}'") + parser.add_argument( + '-sm', + '--stamen', + type=str, + default=default, + help=f"Dataset to use for background image. Default is '{default}'", + ) default = 8 - parser.add_argument('-tl', '--tile', type=int, default=default, - help=f'Tile zoom to use with background image. Default is {default}') - parser.add_argument('-cfs', '--cfeatures', nargs='+', type=str, default=None, - help='Cartopy feature to add to plot') - parser.add_argument('-txt', '--text', type=json.loads, default=None, - help=('Dictionary of {text:[lon,lat]} to add to plot. ' - 'Can have more than one set of text to add.')) + parser.add_argument( + '-tl', + '--tile', + type=int, + default=default, + help=f'Tile zoom to use with background image. Default is {default}', + ) + parser.add_argument( + '-cfs', + '--cfeatures', + nargs='+', + type=str, + default=None, + help='Cartopy feature to add to plot', + ) + parser.add_argument( + '-txt', + '--text', + type=json.loads, + default=None, + help=( + 'Dictionary of {text:[lon,lat]} to add to plot. ' + 'Can have more than one set of text to add.' + ), + ) default = 'rainbow' - parser.add_argument('-cm', '--cmap', default=default, - help=f"colormap to use. Defaut is '{default}'") - parser.add_argument('-abl', '--abs_limits', nargs='+', type=float, - default=(None, None), - help=('Sets the bounds on plot limits even if data ' - 'values exceed those limits. Y axis limits. Default is no limits.')) - parser.add_argument('-tr', '--time_rng', nargs='+', type=float, default=None, - help=('List or tuple with (min,max) values to set the ' - 'x-axis range limits')) + parser.add_argument( + '-cm', '--cmap', default=default, help=f"colormap to use. Defaut is '{default}'" + ) + parser.add_argument( + '-abl', + '--abs_limits', + nargs='+', + type=float, + default=(None, None), + help=( + 'Sets the bounds on plot limits even if data ' + 'values exceed those limits. Y axis limits. Default is no limits.' + ), + ) + parser.add_argument( + '-tr', + '--time_rng', + nargs='+', + type=float, + default=None, + help=('List or tuple with (min,max) values to set the ' 'x-axis range limits'), + ) default = 20 - parser.add_argument('-nd', '--num_dir', type=int, default=default, - help=(f'Number of directions to splot the wind rose into. ' - f'Default is {default}')) - parser.add_argument('-sb', '--spd_bins', nargs='+', type=float, default=None, - help='Bin boundaries to sort the wind speeds into') + parser.add_argument( + '-nd', + '--num_dir', + type=int, + default=default, + help=(f'Number of directions to splot the wind rose into. ' f'Default is {default}'), + ) + parser.add_argument( + '-sb', + '--spd_bins', + nargs='+', + type=float, + default=None, + help='Bin boundaries to sort the wind speeds into', + ) default = 3 - parser.add_argument('-ti', '--tick_interval', type=int, default=default, - help=(f'Interval (in percentage) for the ticks ' - f'on the radial axis. Default is {default}')) - parser.add_argument('-ac', '--assessment_color', type=json.loads, - default=None, - help=('dictionary lookup to override default ' - 'assessment to color')) + parser.add_argument( + '-ti', + '--tick_interval', + type=int, + default=default, + help=( + f'Interval (in percentage) for the ticks ' f'on the radial axis. Default is {default}' + ), + ) + parser.add_argument( + '-ac', + '--assessment_color', + type=json.loads, + default=None, + help=('dictionary lookup to override default ' 'assessment to color'), + ) default = False - parser.add_argument('-ao', '--assessment_overplot', - default=default, action='store_true', - help=(f'Option to overplot quality control colored ' - f'symbols over plotted data using ' - f'flag_assessment categories. Default is {default}')) - default = {'Incorrect': ['Bad', 'Incorrect'], - 'Suspect': ['Indeterminate', 'Suspect']} - parser.add_argument('-oc', '--overplot_category', type=json.loads, default=default, - help=(f'Look up to categorize assessments into groups. ' - f'This allows using multiple terms for the same ' - f'quality control level of failure. ' - f'Also allows adding more to the defaults. Default is {default}')) + parser.add_argument( + '-ao', + '--assessment_overplot', + default=default, + action='store_true', + help=( + f'Option to overplot quality control colored ' + f'symbols over plotted data using ' + f'flag_assessment categories. Default is {default}' + ), + ) + default = {'Incorrect': ['Bad', 'Incorrect'], 'Suspect': ['Indeterminate', 'Suspect']} + parser.add_argument( + '-oc', + '--overplot_category', + type=json.loads, + default=default, + help=( + f'Look up to categorize assessments into groups. ' + f'This allows using multiple terms for the same ' + f'quality control level of failure. ' + f'Also allows adding more to the defaults. Default is {default}' + ), + ) default = {'Incorrect': 'red', 'Suspect': 'orange'} - parser.add_argument('-co', '--category_color', type=json.loads, - default=default, - help=(f'Lookup to match overplot category color to ' - f'assessment grouping. Default is {default}')) - parser.add_argument('-flp', '--force_line_plot', default=False, - action='store_true', - help='Option to plot 2D data as 1D line plots') - parser.add_argument('-l', '--labels', nargs='+', default=False, - type=str, - help=('Option to overwrite the legend labels. ' - 'Must have same dimensions as number of ' - 'lines plottes.')) - parser.add_argument('-sy', '--secondary_y', default=False, action='store_true', - help='Option to plot on secondary y axis') + parser.add_argument( + '-co', + '--category_color', + type=json.loads, + default=default, + help=( + f'Lookup to match overplot category color to ' + f'assessment grouping. Default is {default}' + ), + ) + parser.add_argument( + '-flp', + '--force_line_plot', + default=False, + action='store_true', + help='Option to plot 2D data as 1D line plots', + ) + parser.add_argument( + '-l', + '--labels', + nargs='+', + default=False, + type=str, + help=( + 'Option to overwrite the legend labels. ' + 'Must have same dimensions as number of ' + 'lines plottes.' + ), + ) + parser.add_argument( + '-sy', + '--secondary_y', + default=False, + action='store_true', + help='Option to plot on secondary y axis', + ) if CARTOPY_AVAILABLE: default = ccrs.PlateCarree() - parser.add_argument('-prj', '--projection', type=str, - default=default, - help=f"Projection to use on plot. Default is {default}") + parser.add_argument( + '-prj', + '--projection', + type=str, + default=default, + help=f"Projection to use on plot. Default is {default}", + ) default = 20 - parser.add_argument('-bx', '--num_barb_x', type=int, default=default, - help=f'Number of wind barbs to plot in the x axis. Default is {default}') + parser.add_argument( + '-bx', + '--num_barb_x', + type=int, + default=default, + help=f'Number of wind barbs to plot in the x axis. Default is {default}', + ) default = 20 - parser.add_argument('-by', '--num_barb_y', type=int, default=default, - help=f"Number of wind barbs to plot in the y axis. Default is {default}") + parser.add_argument( + '-by', + '--num_barb_y', + type=int, + default=default, + help=f"Number of wind barbs to plot in the y axis. Default is {default}", + ) default = 20 - parser.add_argument('-tp', '--num_time_periods', type=int, default=default, - help=f'Set how many time periods. Default is {default}') - parser.add_argument('-bn', '--bins', nargs='+', type=int, default=None, - help='histogram bin boundaries to use') - parser.add_argument('-bf', '--bin_field', type=str, default=None, - help=('name of the field that stores the ' - 'bins for the spectra')) - parser.add_argument('-xb', '--x_bins', nargs='+', type=int, default=None, - help='Histogram bin boundaries to use for x axis variable') - parser.add_argument('-yb', '--y_bins', nargs='+', type=int, default=None, - help='Histogram bin boundaries to use for y axis variable') - parser.add_argument('-t', '--time', type=str, default=None, - help='Time period to be plotted') - parser.add_argument('-sbf', '--sortby_field', type=str, default=None, - help='Sort histograms by a given field parameter') - parser.add_argument('-sbb', '--sortby_bins', nargs='+', type=int, - default=None, - help='Bins to sort the histograms by') + parser.add_argument( + '-tp', + '--num_time_periods', + type=int, + default=default, + help=f'Set how many time periods. Default is {default}', + ) + parser.add_argument( + '-bn', '--bins', nargs='+', type=int, default=None, help='histogram bin boundaries to use' + ) + parser.add_argument( + '-bf', + '--bin_field', + type=str, + default=None, + help=('name of the field that stores the ' 'bins for the spectra'), + ) + parser.add_argument( + '-xb', + '--x_bins', + nargs='+', + type=int, + default=None, + help='Histogram bin boundaries to use for x axis variable', + ) + parser.add_argument( + '-yb', + '--y_bins', + nargs='+', + type=int, + default=None, + help='Histogram bin boundaries to use for y axis variable', + ) + parser.add_argument('-t', '--time', type=str, default=None, help='Time period to be plotted') + parser.add_argument( + '-sbf', + '--sortby_field', + type=str, + default=None, + help='Sort histograms by a given field parameter', + ) + parser.add_argument( + '-sbb', + '--sortby_bins', + nargs='+', + type=int, + default=None, + help='Bins to sort the histograms by', + ) default = 20 - parser.add_argument('-nyl', '--num_y_levels', type=int, default=default, - help=f'Number of levels in the y axis to use. Default is {default}') - parser.add_argument('-sk', '--sel_kwargs', type=json.loads, default=None, - help=('The keyword arguments to pass into ' - ':py:func:`xarray.DataArray.sel`')) - parser.add_argument('-ik', '--isel_kwargs', type=json.loads, default=None, - help=('The keyword arguments to pass into ' - ':py:func:`xarray.DataArray.sel`')) + parser.add_argument( + '-nyl', + '--num_y_levels', + type=int, + default=default, + help=f'Number of levels in the y axis to use. Default is {default}', + ) + parser.add_argument( + '-sk', + '--sel_kwargs', + type=json.loads, + default=None, + help=('The keyword arguments to pass into ' ':py:func:`xarray.DataArray.sel`'), + ) + parser.add_argument( + '-ik', + '--isel_kwargs', + type=json.loads, + default=None, + help=('The keyword arguments to pass into ' ':py:func:`xarray.DataArray.sel`'), + ) default = 'cubic' - parser.add_argument('-fn', '--function', type=str, default=default, - help=(f'Defaults to cubic function for interpolation. ' - f'See scipy.interpolate.Rbf for additional options. ' - f'Default is {default}')) + parser.add_argument( + '-fn', + '--function', + type=str, + default=default, + help=( + f'Defaults to cubic function for interpolation. ' + f'See scipy.interpolate.Rbf for additional options. ' + f'Default is {default}' + ), + ) default = 0.1 - parser.add_argument('-gb', '--grid_buffer', type=float, default=default, - help=f'Buffer to apply to grid. Default is {default}') + parser.add_argument( + '-gb', + '--grid_buffer', + type=float, + default=default, + help=f'Buffer to apply to grid. Default is {default}', + ) default = (0.01, 0.01) - parser.add_argument('-gd', '--grid_delta', nargs='+', - type=float, default=default, - help=f'X and Y deltas for creating grid. Default is {default}') - parser.add_argument('-fg', '--figsize', nargs='+', type=float, - default=None, - help='Width and height in inches of figure') + parser.add_argument( + '-gd', + '--grid_delta', + nargs='+', + type=float, + default=default, + help=f'X and Y deltas for creating grid. Default is {default}', + ) + parser.add_argument( + '-fg', + '--figsize', + nargs='+', + type=float, + default=None, + help='Width and height in inches of figure', + ) default = 'white' - parser.add_argument('-tc', '--text_color', type=str, default=default, - help=f"Color of text. Default is '{default}'") - parser.add_argument('-kwargs', type=json.loads, default=dict(), - help='keyword arguments to use in plotting function') - parser.add_argument('-pk', '--plot_kwargs', type=json.loads, default=dict(), - help=("Additional keyword arguments to pass " - "into MetPy's SkewT.plot")) - parser.add_argument('-pbk', '--plot_barbs_kwargs', type=json.loads, - default=dict(), - help=("Additional keyword arguments to pass " - "into MetPy's SkewT.plot_barbs")) + parser.add_argument( + '-tc', + '--text_color', + type=str, + default=default, + help=f"Color of text. Default is '{default}'", + ) + parser.add_argument( + '-kwargs', + type=json.loads, + default=dict(), + help='keyword arguments to use in plotting function', + ) + parser.add_argument( + '-pk', + '--plot_kwargs', + type=json.loads, + default=dict(), + help=("Additional keyword arguments to pass " "into MetPy's SkewT.plot"), + ) + parser.add_argument( + '-pbk', + '--plot_barbs_kwargs', + type=json.loads, + default=dict(), + help=("Additional keyword arguments to pass " "into MetPy's SkewT.plot_barbs"), + ) default = True - parser.add_argument('-cu', '--cleanup', default=default, action='store_false', - help=f'Turn off standard methods for obj cleanup. Default is {default}') - parser.add_argument('-gl', '--gridlines', default=False, action='store_true', - help='Use latitude and lingitude gridlines.') - parser.add_argument('-cl', '--coastlines', default=False, action='store_true', - help='Plot coastlines on geographical map') - parser.add_argument('-bg', '--background', default=False, action='store_true', - help='Plot a stock image background') - parser.add_argument('-nan', '--add_nan', default=False, action='store_true', - help='Fill in data gaps with NaNs') - parser.add_argument('-dn', '--day_night', default=False, action='store_true', - help=("Fill in color coded background according " - "to time of day.")) - parser.add_argument('-yr', '--set_yrange', default=None, nargs=2, - help=("Set the yrange for the specific plot")) - parser.add_argument('-iya', '--invert_y_axis', default=False, - action='store_true', - help='Invert y axis') - parser.add_argument('-sp', '--show_parcel', default=False, action='store_true', - help='set to true to plot the parcel path.') - parser.add_argument('-cape', '--shade_cape', default=False, - action='store_true', - help='set to true to shade regions of cape.') - parser.add_argument('-cin', '--shade_cin', default=False, action='store_true', - help='set to true to shade regions of cin.') - parser.add_argument('-d', '--density', default=False, action='store_true', - help='Plot a p.d.f. instead of a frequency histogram') - parser.add_argument('-m', '--mesh', default=False, action='store_true', - help=('Set to True to interpolate u and v to ' - 'grid and create wind barbs')) - parser.add_argument('-uv', '--from_u_and_v', default=False, action='store_true', - help='Create SkewTPLot with u and v wind') - parser.add_argument('-sd', '--from_spd_and_dir', default=False, action='store_true', - help='Create SkewTPlot with wind speed and direction') - parser.add_argument('-px', '--plot_xsection', default=False, action='store_true', - help='plots a cross section whose x and y coordinates') - parser.add_argument('-pxm', '--xsection_map', default=False, action='store_true', - help='plots a cross section of 2D data on a geographical map') - parser.add_argument('-p', '--plot', default=False, action='store_true', - help='Makes a time series plot') - parser.add_argument('-mp', '--multi_panel', default=False, - action='store_true', - help='Makes a 2 panel timeseries plot') - parser.add_argument('-qc', '--qc', default=False, action='store_true', - help='Create time series plot of embedded quality control values') - parser.add_argument('-fb', '--fill_between', default=False, action='store_true', - help='makes a fill betweem plot based on matplotlib') - parser.add_argument('-bsd', '--barbs_spd_dir', default=False, action='store_true', - help=('Makes time series plot of wind barbs ' - 'using wind speed and dir.')) - parser.add_argument('-buv', '--barbs_u_v', default=False, action='store_true', - help=('Makes time series plot of wind barbs ' - 'using u and v wind components.')) - parser.add_argument('-pxs', '--xsection_from_1d', default=False, - action='store_true', - help='Will plot a time-height cross section from 1D dataset') - parser.add_argument('-ths', '--time_height_scatter', - default=False, action='store_true', - help='Create a scatter time series plot') - parser.add_argument('-sbg', '--stacked_bar_graph', - default=False, action='store_true', - help='Create stacked bar graph histogram') - parser.add_argument('-psd', '--size_dist', default=False, action='store_true', - help='Plots a stairstep plot of size distribution') - parser.add_argument('-sg', '--stairstep', default=False, action='store_true', - help='Plots stairstep plot of a histogram') - parser.add_argument('-hm', '--heatmap', default=False, action='store_true', - help='Plot a heatmap histogram from 2 variables') - parser.add_argument('-cc', '--create_contour', default=False, action='store_true', - help='Extracts, grids, and creates a contour plot') - parser.add_argument('-cf', '--contourf', default=False, action='store_true', - help=('Base function for filled contours if user ' - 'already has data gridded')) - parser.add_argument('-ct', '--plot_contour', default=False, action='store_true', - help=('Base function for contours if user ' - 'already has data gridded')) - parser.add_argument('-vsd', '--vectors_spd_dir', default=False, action='store_true', - help='Extracts, grids, and creates a contour plot.') - parser.add_argument('-b', '--barbs', default=False, action='store_true', - help='Base function for wind barbs.') - parser.add_argument('-ps', '--plot_station', default=False, action='store_true', - help='Extracts, grids, and creates a contour plot') + parser.add_argument( + '-cu', + '--cleanup', + default=default, + action='store_false', + help=f'Turn off standard methods for obj cleanup. Default is {default}', + ) + parser.add_argument( + '-gl', + '--gridlines', + default=False, + action='store_true', + help='Use latitude and lingitude gridlines.', + ) + parser.add_argument( + '-cl', + '--coastlines', + default=False, + action='store_true', + help='Plot coastlines on geographical map', + ) + parser.add_argument( + '-bg', + '--background', + default=False, + action='store_true', + help='Plot a stock image background', + ) + parser.add_argument( + '-nan', '--add_nan', default=False, action='store_true', help='Fill in data gaps with NaNs' + ) + parser.add_argument( + '-dn', + '--day_night', + default=False, + action='store_true', + help=("Fill in color coded background according " "to time of day."), + ) + parser.add_argument( + '-yr', '--set_yrange', default=None, nargs=2, help=("Set the yrange for the specific plot") + ) + parser.add_argument( + '-iya', '--invert_y_axis', default=False, action='store_true', help='Invert y axis' + ) + parser.add_argument( + '-sp', + '--show_parcel', + default=False, + action='store_true', + help='set to true to plot the parcel path.', + ) + parser.add_argument( + '-cape', + '--shade_cape', + default=False, + action='store_true', + help='set to true to shade regions of cape.', + ) + parser.add_argument( + '-cin', + '--shade_cin', + default=False, + action='store_true', + help='set to true to shade regions of cin.', + ) + parser.add_argument( + '-d', + '--density', + default=False, + action='store_true', + help='Plot a p.d.f. instead of a frequency histogram', + ) + parser.add_argument( + '-m', + '--mesh', + default=False, + action='store_true', + help=('Set to True to interpolate u and v to ' 'grid and create wind barbs'), + ) + parser.add_argument( + '-uv', + '--from_u_and_v', + default=False, + action='store_true', + help='Create SkewTPLot with u and v wind', + ) + parser.add_argument( + '-sd', + '--from_spd_and_dir', + default=False, + action='store_true', + help='Create SkewTPlot with wind speed and direction', + ) + parser.add_argument( + '-px', + '--plot_xsection', + default=False, + action='store_true', + help='plots a cross section whose x and y coordinates', + ) + parser.add_argument( + '-pxm', + '--xsection_map', + default=False, + action='store_true', + help='plots a cross section of 2D data on a geographical map', + ) + parser.add_argument( + '-p', '--plot', default=False, action='store_true', help='Makes a time series plot' + ) + parser.add_argument( + '-mp', + '--multi_panel', + default=False, + action='store_true', + help='Makes a 2 panel timeseries plot', + ) + parser.add_argument( + '-qc', + '--qc', + default=False, + action='store_true', + help='Create time series plot of embedded quality control values', + ) + parser.add_argument( + '-fb', + '--fill_between', + default=False, + action='store_true', + help='makes a fill betweem plot based on matplotlib', + ) + parser.add_argument( + '-bsd', + '--barbs_spd_dir', + default=False, + action='store_true', + help=('Makes time series plot of wind barbs ' 'using wind speed and dir.'), + ) + parser.add_argument( + '-buv', + '--barbs_u_v', + default=False, + action='store_true', + help=('Makes time series plot of wind barbs ' 'using u and v wind components.'), + ) + parser.add_argument( + '-pxs', + '--xsection_from_1d', + default=False, + action='store_true', + help='Will plot a time-height cross section from 1D dataset', + ) + parser.add_argument( + '-ths', + '--time_height_scatter', + default=False, + action='store_true', + help='Create a scatter time series plot', + ) + parser.add_argument( + '-sbg', + '--stacked_bar_graph', + default=False, + action='store_true', + help='Create stacked bar graph histogram', + ) + parser.add_argument( + '-psd', + '--size_dist', + default=False, + action='store_true', + help='Plots a stairstep plot of size distribution', + ) + parser.add_argument( + '-sg', + '--stairstep', + default=False, + action='store_true', + help='Plots stairstep plot of a histogram', + ) + parser.add_argument( + '-hm', + '--heatmap', + default=False, + action='store_true', + help='Plot a heatmap histogram from 2 variables', + ) + parser.add_argument( + '-cc', + '--create_contour', + default=False, + action='store_true', + help='Extracts, grids, and creates a contour plot', + ) + parser.add_argument( + '-cf', + '--contourf', + default=False, + action='store_true', + help=('Base function for filled contours if user ' 'already has data gridded'), + ) + parser.add_argument( + '-ct', + '--plot_contour', + default=False, + action='store_true', + help=('Base function for contours if user ' 'already has data gridded'), + ) + parser.add_argument( + '-vsd', + '--vectors_spd_dir', + default=False, + action='store_true', + help='Extracts, grids, and creates a contour plot.', + ) + parser.add_argument( + '-b', '--barbs', default=False, action='store_true', help='Base function for wind barbs.' + ) + parser.add_argument( + '-ps', + '--plot_station', + default=False, + action='store_true', + help='Extracts, grids, and creates a contour plot', + ) # The mutually exclusive but one requried group group = parser.add_mutually_exclusive_group(required=True) - group.add_argument('-gp', '--geodisplay', dest='action', action='store_const', - const=geodisplay, help='Set to genereate a geographic plot') - group.add_argument('-skt', '--skewt', dest='action', action='store_const', - const=skewt, help='Set to genereate a skew-t plot') - group.add_argument('-xs', '--xsection', dest='action', action='store_const', - const=xsection, help='Set to genereate a XSection plot') - group.add_argument('-wr', '--wind_rose', dest='action', action='store_const', - const=wind_rose, help='Set to genereate a wind rose plot') - group.add_argument('-ts', '--timeseries', dest='action', action='store_const', - const=timeseries, help='Set to genereate a timeseries plot') - group.add_argument('-c', '--contour', dest='action', action='store_const', - const=contour, help='Set to genereate a contour plot') - group.add_argument('-hs', '--histogram', dest='action', action='store_const', - const=histogram, help='Set to genereate a histogram plot') + group.add_argument( + '-gp', + '--geodisplay', + dest='action', + action='store_const', + const=geodisplay, + help='Set to genereate a geographic plot', + ) + group.add_argument( + '-skt', + '--skewt', + dest='action', + action='store_const', + const=skewt, + help='Set to genereate a skew-t plot', + ) + group.add_argument( + '-xs', + '--xsection', + dest='action', + action='store_const', + const=xsection, + help='Set to genereate a XSection plot', + ) + group.add_argument( + '-wr', + '--wind_rose', + dest='action', + action='store_const', + const=wind_rose, + help='Set to genereate a wind rose plot', + ) + group.add_argument( + '-ts', + '--timeseries', + dest='action', + action='store_const', + const=timeseries, + help='Set to genereate a timeseries plot', + ) + group.add_argument( + '-c', + '--contour', + dest='action', + action='store_const', + const=contour, + help='Set to genereate a contour plot', + ) + group.add_argument( + '-hs', + '--histogram', + dest='action', + action='store_const', + const=histogram, + help='Set to genereate a histogram plot', + ) args = parser.parse_args() diff --git a/tests/discovery/test_cropscape.py b/tests/discovery/test_cropscape.py index 3d594cc35d..500a1ac822 100644 --- a/tests/discovery/test_cropscape.py +++ b/tests/discovery/test_cropscape.py @@ -17,4 +17,4 @@ def test_croptype(): assert crop == 'Dbl Crop WinWht/Sorghum' if crop2 is not None: # assert crop2 == 'Sorghum' - assert crop2 == 'Soybeans' + assert crop2 in ['Soybeans', 'Winter Wheat'] diff --git a/tests/discovery/test_improve.py b/tests/discovery/test_improve.py new file mode 100644 index 0000000000..c8a75f1fd6 --- /dev/null +++ b/tests/discovery/test_improve.py @@ -0,0 +1,20 @@ +import numpy as np +import act + + +def test_get_improve(): + ds = act.discovery.get_improve_data(site_id='244', start_date='1/1/2023', end_date='12/31/2023') + + assert len(list(ds)) == 216 + assert 'lat' in ds + assert 'lon' in ds + assert len(ds.time.values) == 121 + assert 'aluminum_fine' in ds + assert ds['ammonium_nitrate_fine'].values[0] == 1.41363 + + with np.testing.assert_raises(ValueError): + ds = act.discovery.get_improve_data() + with np.testing.assert_raises(ValueError): + ds = act.discovery.get_improve_data(site_id='244') + with np.testing.assert_raises(ValueError): + ds = act.discovery.get_improve_data(site_id='244', start_date='1/1/2023') diff --git a/tests/io/test_ameriflux.py b/tests/io/test_ameriflux.py new file mode 100644 index 0000000000..395983de39 --- /dev/null +++ b/tests/io/test_ameriflux.py @@ -0,0 +1,33 @@ +import act +import glob +import xarray as xr + + +def test_convert_to_ameriflux(): + files = glob.glob(act.tests.sample_files.EXAMPLE_ECORSF_E39) + ds_ecor = act.io.arm.read_arm_netcdf(files) + + df = act.io.ameriflux.convert_to_ameriflux(ds_ecor) + + assert 'FC' in df + assert 'WS_MAX' in df + + files = glob.glob(act.tests.sample_files.EXAMPLE_SEBS_E39) + ds_sebs = act.io.arm.read_arm_netcdf(files) + + ds = xr.merge([ds_ecor, ds_sebs]) + df = act.io.ameriflux.convert_to_ameriflux(ds) + + assert 'SWC_2_1_1' in df + assert 'TS_3_1_1' in df + assert 'G_2_1_1' in df + + files = glob.glob(act.tests.sample_files.EXAMPLE_STAMP_E39) + ds_stamp = act.io.arm.read_arm_netcdf(files) + + ds = xr.merge([ds_ecor, ds_sebs, ds_stamp], compat='override') + df = act.io.ameriflux.convert_to_ameriflux(ds) + + assert 'SWC_6_10_1' in df + assert 'G_2_1_1' in df + assert 'TS_5_2_1' in df diff --git a/tests/io/test_hysplit.py b/tests/io/test_hysplit.py new file mode 100644 index 0000000000..672956401d --- /dev/null +++ b/tests/io/test_hysplit.py @@ -0,0 +1,16 @@ +import act + +from act.tests import sample_files + + +def test_read_hysplit(): + filename = sample_files.EXAMPLE_HYSPLIT + ds = act.io.read_hysplit(filename) + assert 'lat' in ds.variables.keys() + assert 'lon' in ds.variables.keys() + assert 'alt' in ds.variables.keys() + assert 'PRESSURE' in ds.variables.keys() + assert ds.sizes["num_grids"] == 8 + assert ds.sizes["num_trajectories"] == 1 + assert ds.sizes['time'] == 120 + assert ds['age'].min() == -120 diff --git a/tests/io/test_noaapsl.py b/tests/io/test_noaapsl.py index 35326ea592..2964b5c879 100644 --- a/tests/io/test_noaapsl.py +++ b/tests/io/test_noaapsl.py @@ -11,12 +11,12 @@ def test_read_psl_wind_profiler(): act.tests.EXAMPLE_NOAA_PSL, transpose=False ) # test dimensions - assert 'time' and 'HT' in test_ds_low.dims.keys() - assert 'time' and 'HT' in test_ds_hi.dims.keys() - assert test_ds_low.dims['time'] == 4 - assert test_ds_hi.dims['time'] == 4 - assert test_ds_low.dims['HT'] == 49 - assert test_ds_hi.dims['HT'] == 50 + assert 'time' and 'HT' in test_ds_low.sizes.keys() + assert 'time' and 'HT' in test_ds_hi.sizes.keys() + assert test_ds_low.sizes['time'] == 4 + assert test_ds_hi.sizes['time'] == 4 + assert test_ds_low.sizes['HT'] == 49 + assert test_ds_hi.sizes['HT'] == 50 # test coordinates assert (test_ds_low.coords['HT'][0:5] == np.array([0.151, 0.254, 0.356, 0.458, 0.561])).all() diff --git a/tests/plotting/baseline/test_2D_timeseries_plot.png b/tests/plotting/baseline/test_2D_timeseries_plot.png index d8c1e9e6d0..25bfcd9d69 100644 Binary files a/tests/plotting/baseline/test_2D_timeseries_plot.png and b/tests/plotting/baseline/test_2D_timeseries_plot.png differ diff --git a/tests/plotting/baseline/test_2d_as_1d.png b/tests/plotting/baseline/test_2d_as_1d.png index ee49a3fa4a..1d8617ddba 100644 Binary files a/tests/plotting/baseline/test_2d_as_1d.png and b/tests/plotting/baseline/test_2d_as_1d.png differ diff --git a/tests/plotting/baseline/test_add_nan_line.png b/tests/plotting/baseline/test_add_nan_line.png index 4ef242543a..9605beaee0 100644 Binary files a/tests/plotting/baseline/test_add_nan_line.png and b/tests/plotting/baseline/test_add_nan_line.png differ diff --git a/tests/plotting/baseline/test_add_nan_line_integer.png b/tests/plotting/baseline/test_add_nan_line_integer.png new file mode 100644 index 0000000000..be7bda4d31 Binary files /dev/null and b/tests/plotting/baseline/test_add_nan_line_integer.png differ diff --git a/tests/plotting/baseline/test_assessment_overplot.png b/tests/plotting/baseline/test_assessment_overplot.png index c1108a15b0..55c6f15d29 100644 Binary files a/tests/plotting/baseline/test_assessment_overplot.png and b/tests/plotting/baseline/test_assessment_overplot.png differ diff --git a/tests/plotting/baseline/test_assessment_overplot_multi.png b/tests/plotting/baseline/test_assessment_overplot_multi.png index 520c977077..bc8ea63087 100644 Binary files a/tests/plotting/baseline/test_assessment_overplot_multi.png and b/tests/plotting/baseline/test_assessment_overplot_multi.png differ diff --git a/tests/plotting/baseline/test_barb_sounding_plot.png b/tests/plotting/baseline/test_barb_sounding_plot.png index 98b8e5b756..9380ca3b6e 100644 Binary files a/tests/plotting/baseline/test_barb_sounding_plot.png and b/tests/plotting/baseline/test_barb_sounding_plot.png differ diff --git a/tests/plotting/baseline/test_colorbar_labels.png b/tests/plotting/baseline/test_colorbar_labels.png index ac4ead2ede..fdb5347016 100644 Binary files a/tests/plotting/baseline/test_colorbar_labels.png and b/tests/plotting/baseline/test_colorbar_labels.png differ diff --git a/tests/plotting/baseline/test_contour.png b/tests/plotting/baseline/test_contour.png index c2651dee65..d97bc4eab7 100644 Binary files a/tests/plotting/baseline/test_contour.png and b/tests/plotting/baseline/test_contour.png differ diff --git a/tests/plotting/baseline/test_contour2.png b/tests/plotting/baseline/test_contour2.png index c6a9567e89..f53bc9d534 100644 Binary files a/tests/plotting/baseline/test_contour2.png and b/tests/plotting/baseline/test_contour2.png differ diff --git a/tests/plotting/baseline/test_contour_stamp.png b/tests/plotting/baseline/test_contour_stamp.png index 25a17ba8f2..fb8aac80e7 100644 Binary files a/tests/plotting/baseline/test_contour_stamp.png and b/tests/plotting/baseline/test_contour_stamp.png differ diff --git a/tests/plotting/baseline/test_contourf.png b/tests/plotting/baseline/test_contourf.png index 726e7a824b..f4e040797c 100644 Binary files a/tests/plotting/baseline/test_contourf.png and b/tests/plotting/baseline/test_contourf.png differ diff --git a/tests/plotting/baseline/test_contourf2.png b/tests/plotting/baseline/test_contourf2.png index 3421f15ad7..9b0fce57d7 100644 Binary files a/tests/plotting/baseline/test_contourf2.png and b/tests/plotting/baseline/test_contourf2.png differ diff --git a/tests/plotting/baseline/test_enhanced_skewt_plot.png b/tests/plotting/baseline/test_enhanced_skewt_plot.png index 958a6c1272..27de1a5985 100644 Binary files a/tests/plotting/baseline/test_enhanced_skewt_plot.png and b/tests/plotting/baseline/test_enhanced_skewt_plot.png differ diff --git a/tests/plotting/baseline/test_enhanced_skewt_plot_2.png b/tests/plotting/baseline/test_enhanced_skewt_plot_2.png index f5796d5537..79dd95a641 100644 Binary files a/tests/plotting/baseline/test_enhanced_skewt_plot_2.png and b/tests/plotting/baseline/test_enhanced_skewt_plot_2.png differ diff --git a/tests/plotting/baseline/test_fill_between.png b/tests/plotting/baseline/test_fill_between.png index c595d3ff43..e4417bd3b6 100644 Binary files a/tests/plotting/baseline/test_fill_between.png and b/tests/plotting/baseline/test_fill_between.png differ diff --git a/tests/plotting/baseline/test_geoplot.png b/tests/plotting/baseline/test_geoplot.png index ef1febd4c6..974034f45e 100644 Binary files a/tests/plotting/baseline/test_geoplot.png and b/tests/plotting/baseline/test_geoplot.png differ diff --git a/tests/plotting/baseline/test_geoplot_tile.png b/tests/plotting/baseline/test_geoplot_tile.png index 22cd40e5ed..8390b0901c 100644 Binary files a/tests/plotting/baseline/test_geoplot_tile.png and b/tests/plotting/baseline/test_geoplot_tile.png differ diff --git a/tests/plotting/baseline/test_groupby_plot.png b/tests/plotting/baseline/test_groupby_plot.png index fc35f8fe73..3f84b4502d 100644 Binary files a/tests/plotting/baseline/test_groupby_plot.png and b/tests/plotting/baseline/test_groupby_plot.png differ diff --git a/tests/plotting/baseline/test_heatmap.png b/tests/plotting/baseline/test_heatmap.png index f63777fb05..500809d117 100644 Binary files a/tests/plotting/baseline/test_heatmap.png and b/tests/plotting/baseline/test_heatmap.png differ diff --git a/tests/plotting/baseline/test_heatmap2.png b/tests/plotting/baseline/test_heatmap2.png index 50eb8b296f..75787da33b 100644 Binary files a/tests/plotting/baseline/test_heatmap2.png and b/tests/plotting/baseline/test_heatmap2.png differ diff --git a/tests/plotting/baseline/test_heatmap3.png b/tests/plotting/baseline/test_heatmap3.png index 37a5b32610..0218fd1538 100644 Binary files a/tests/plotting/baseline/test_heatmap3.png and b/tests/plotting/baseline/test_heatmap3.png differ diff --git a/tests/plotting/baseline/test_match_ylimits_plot.png b/tests/plotting/baseline/test_match_ylimits_plot.png index 748b7c8385..d529a6f7f8 100644 Binary files a/tests/plotting/baseline/test_match_ylimits_plot.png and b/tests/plotting/baseline/test_match_ylimits_plot.png differ diff --git a/tests/plotting/baseline/test_multi_skewt_plot.png b/tests/plotting/baseline/test_multi_skewt_plot.png index 857ebed1f7..f08a1e3522 100644 Binary files a/tests/plotting/baseline/test_multi_skewt_plot.png and b/tests/plotting/baseline/test_multi_skewt_plot.png differ diff --git a/tests/plotting/baseline/test_multidataset_plot_dict.png b/tests/plotting/baseline/test_multidataset_plot_dict.png index a9f6a660f9..5f4b72bf78 100644 Binary files a/tests/plotting/baseline/test_multidataset_plot_dict.png and b/tests/plotting/baseline/test_multidataset_plot_dict.png differ diff --git a/tests/plotting/baseline/test_multidataset_plot_tuple.png b/tests/plotting/baseline/test_multidataset_plot_tuple.png index 8e74f35dca..83991fb2e2 100644 Binary files a/tests/plotting/baseline/test_multidataset_plot_tuple.png and b/tests/plotting/baseline/test_multidataset_plot_tuple.png differ diff --git a/tests/plotting/baseline/test_plot.png b/tests/plotting/baseline/test_plot.png index 921753d729..5e690435b9 100644 Binary files a/tests/plotting/baseline/test_plot.png and b/tests/plotting/baseline/test_plot.png differ diff --git a/tests/plotting/baseline/test_plot_barbs_from_u_v.png b/tests/plotting/baseline/test_plot_barbs_from_u_v.png index a1c58e3410..dec24618da 100644 Binary files a/tests/plotting/baseline/test_plot_barbs_from_u_v.png and b/tests/plotting/baseline/test_plot_barbs_from_u_v.png differ diff --git a/tests/plotting/baseline/test_plot_barbs_from_u_v2.png b/tests/plotting/baseline/test_plot_barbs_from_u_v2.png index 0b360d4e6e..9112d54ed0 100644 Binary files a/tests/plotting/baseline/test_plot_barbs_from_u_v2.png and b/tests/plotting/baseline/test_plot_barbs_from_u_v2.png differ diff --git a/tests/plotting/baseline/test_plot_barbs_from_u_v3.png b/tests/plotting/baseline/test_plot_barbs_from_u_v3.png new file mode 100644 index 0000000000..7504c32894 Binary files /dev/null and b/tests/plotting/baseline/test_plot_barbs_from_u_v3.png differ diff --git a/tests/plotting/baseline/test_plot_barbs_from_u_v4.png b/tests/plotting/baseline/test_plot_barbs_from_u_v4.png new file mode 100644 index 0000000000..c5f07621bb Binary files /dev/null and b/tests/plotting/baseline/test_plot_barbs_from_u_v4.png differ diff --git a/tests/plotting/baseline/test_plot_barbs_from_u_v5.png b/tests/plotting/baseline/test_plot_barbs_from_u_v5.png new file mode 100644 index 0000000000..55fa440b50 Binary files /dev/null and b/tests/plotting/baseline/test_plot_barbs_from_u_v5.png differ diff --git a/tests/plotting/baseline/test_plot_datarose.png b/tests/plotting/baseline/test_plot_datarose.png index a903d2a340..1b85fb841e 100644 Binary files a/tests/plotting/baseline/test_plot_datarose.png and b/tests/plotting/baseline/test_plot_datarose.png differ diff --git a/tests/plotting/baseline/test_plot_pie_chart.png b/tests/plotting/baseline/test_plot_pie_chart.png new file mode 100644 index 0000000000..79eeee2b48 Binary files /dev/null and b/tests/plotting/baseline/test_plot_pie_chart.png differ diff --git a/tests/plotting/baseline/test_plot_pie_chart_kwargs.png b/tests/plotting/baseline/test_plot_pie_chart_kwargs.png new file mode 100644 index 0000000000..2d3d8ae441 Binary files /dev/null and b/tests/plotting/baseline/test_plot_pie_chart_kwargs.png differ diff --git a/tests/plotting/baseline/test_qc_bar_plot.png b/tests/plotting/baseline/test_qc_bar_plot.png index d8167eb7d2..d298b39a08 100644 Binary files a/tests/plotting/baseline/test_qc_bar_plot.png and b/tests/plotting/baseline/test_qc_bar_plot.png differ diff --git a/tests/plotting/baseline/test_qc_flag_block_plot.png b/tests/plotting/baseline/test_qc_flag_block_plot.png index 4ce6106337..dccaed9b30 100644 Binary files a/tests/plotting/baseline/test_qc_flag_block_plot.png and b/tests/plotting/baseline/test_qc_flag_block_plot.png differ diff --git a/tests/plotting/baseline/test_scatter.png b/tests/plotting/baseline/test_scatter.png index bdd98143f2..7fba0883d0 100644 Binary files a/tests/plotting/baseline/test_scatter.png and b/tests/plotting/baseline/test_scatter.png differ diff --git a/tests/plotting/baseline/test_scatter2.png b/tests/plotting/baseline/test_scatter2.png index 1f512fe019..2feb1f4c53 100644 Binary files a/tests/plotting/baseline/test_scatter2.png and b/tests/plotting/baseline/test_scatter2.png differ diff --git a/tests/plotting/baseline/test_size_distribution.png b/tests/plotting/baseline/test_size_distribution.png index 2fa19f74d9..783fa2fdf7 100644 Binary files a/tests/plotting/baseline/test_size_distribution.png and b/tests/plotting/baseline/test_size_distribution.png differ diff --git a/tests/plotting/baseline/test_size_distribution2.png b/tests/plotting/baseline/test_size_distribution2.png index e5d63d4ac3..40ddfaf84b 100644 Binary files a/tests/plotting/baseline/test_size_distribution2.png and b/tests/plotting/baseline/test_size_distribution2.png differ diff --git a/tests/plotting/baseline/test_skewt_options.png b/tests/plotting/baseline/test_skewt_options.png index f39af2fde8..8b477d0ab5 100644 Binary files a/tests/plotting/baseline/test_skewt_options.png and b/tests/plotting/baseline/test_skewt_options.png differ diff --git a/tests/plotting/baseline/test_skewt_plot.png b/tests/plotting/baseline/test_skewt_plot.png index b9335339b6..22c75423ba 100644 Binary files a/tests/plotting/baseline/test_skewt_plot.png and b/tests/plotting/baseline/test_skewt_plot.png differ diff --git a/tests/plotting/baseline/test_skewt_plot_spd_dir.png b/tests/plotting/baseline/test_skewt_plot_spd_dir.png index b9335339b6..22c75423ba 100644 Binary files a/tests/plotting/baseline/test_skewt_plot_spd_dir.png and b/tests/plotting/baseline/test_skewt_plot_spd_dir.png differ diff --git a/tests/plotting/baseline/test_stacked_bar_graph.png b/tests/plotting/baseline/test_stacked_bar_graph.png index bd52279209..a4c73bfe9e 100644 Binary files a/tests/plotting/baseline/test_stacked_bar_graph.png and b/tests/plotting/baseline/test_stacked_bar_graph.png differ diff --git a/tests/plotting/baseline/test_stacked_bar_graph2.png b/tests/plotting/baseline/test_stacked_bar_graph2.png index 13e1fc78ef..fb55f921a9 100644 Binary files a/tests/plotting/baseline/test_stacked_bar_graph2.png and b/tests/plotting/baseline/test_stacked_bar_graph2.png differ diff --git a/tests/plotting/baseline/test_stacked_bar_graph3.png b/tests/plotting/baseline/test_stacked_bar_graph3.png index bd483fb485..64ece6b91f 100644 Binary files a/tests/plotting/baseline/test_stacked_bar_graph3.png and b/tests/plotting/baseline/test_stacked_bar_graph3.png differ diff --git a/tests/plotting/baseline/test_stacked_bar_graph_sorted.png b/tests/plotting/baseline/test_stacked_bar_graph_sorted.png index 4607ad3d27..0af0344762 100644 Binary files a/tests/plotting/baseline/test_stacked_bar_graph_sorted.png and b/tests/plotting/baseline/test_stacked_bar_graph_sorted.png differ diff --git a/tests/plotting/baseline/test_stair_graph.png b/tests/plotting/baseline/test_stair_graph.png index 8c0e0fb4c6..d5392f3142 100644 Binary files a/tests/plotting/baseline/test_stair_graph.png and b/tests/plotting/baseline/test_stair_graph.png differ diff --git a/tests/plotting/baseline/test_stair_graph2.png b/tests/plotting/baseline/test_stair_graph2.png index 298b8fe834..1ad8a2e48c 100644 Binary files a/tests/plotting/baseline/test_stair_graph2.png and b/tests/plotting/baseline/test_stair_graph2.png differ diff --git a/tests/plotting/baseline/test_stair_graph_sorted.png b/tests/plotting/baseline/test_stair_graph_sorted.png index 5d2f888b0c..02641f0e8c 100644 Binary files a/tests/plotting/baseline/test_stair_graph_sorted.png and b/tests/plotting/baseline/test_stair_graph_sorted.png differ diff --git a/tests/plotting/baseline/test_time_height_scatter.png b/tests/plotting/baseline/test_time_height_scatter.png index 08ab88119c..4e5dc819e1 100644 Binary files a/tests/plotting/baseline/test_time_height_scatter.png and b/tests/plotting/baseline/test_time_height_scatter.png differ diff --git a/tests/plotting/baseline/test_time_height_scatter2.png b/tests/plotting/baseline/test_time_height_scatter2.png index d737ec75d8..0ead21c30f 100644 Binary files a/tests/plotting/baseline/test_time_height_scatter2.png and b/tests/plotting/baseline/test_time_height_scatter2.png differ diff --git a/tests/plotting/baseline/test_time_plot.png b/tests/plotting/baseline/test_time_plot.png index 46ab1e433e..4c772ba994 100644 Binary files a/tests/plotting/baseline/test_time_plot.png and b/tests/plotting/baseline/test_time_plot.png differ diff --git a/tests/plotting/baseline/test_time_plot2.png b/tests/plotting/baseline/test_time_plot2.png index 95b493c342..19273939ec 100644 Binary files a/tests/plotting/baseline/test_time_plot2.png and b/tests/plotting/baseline/test_time_plot2.png differ diff --git a/tests/plotting/baseline/test_time_plot_match_color_ylabel.png b/tests/plotting/baseline/test_time_plot_match_color_ylabel.png index e356448e1c..ba3ba31448 100644 Binary files a/tests/plotting/baseline/test_time_plot_match_color_ylabel.png and b/tests/plotting/baseline/test_time_plot_match_color_ylabel.png differ diff --git a/tests/plotting/baseline/test_timeseries_invert.png b/tests/plotting/baseline/test_timeseries_invert.png index e51dbfd11a..8686032e91 100644 Binary files a/tests/plotting/baseline/test_timeseries_invert.png and b/tests/plotting/baseline/test_timeseries_invert.png differ diff --git a/tests/plotting/baseline/test_violin.png b/tests/plotting/baseline/test_violin.png index 743911ffde..9af6ec9c89 100644 Binary files a/tests/plotting/baseline/test_violin.png and b/tests/plotting/baseline/test_violin.png differ diff --git a/tests/plotting/baseline/test_violin2.png b/tests/plotting/baseline/test_violin2.png index e642fe633f..ce0b7258f9 100644 Binary files a/tests/plotting/baseline/test_violin2.png and b/tests/plotting/baseline/test_violin2.png differ diff --git a/tests/plotting/baseline/test_wind_rose.png b/tests/plotting/baseline/test_wind_rose.png index 95e6b4c1ee..cc86e9e53b 100644 Binary files a/tests/plotting/baseline/test_wind_rose.png and b/tests/plotting/baseline/test_wind_rose.png differ diff --git a/tests/plotting/baseline/test_xlim_correction_plot.png b/tests/plotting/baseline/test_xlim_correction_plot.png index 0d64734bc8..f66fd2b44f 100644 Binary files a/tests/plotting/baseline/test_xlim_correction_plot.png and b/tests/plotting/baseline/test_xlim_correction_plot.png differ diff --git a/tests/plotting/baseline/test_xsection_plot.png b/tests/plotting/baseline/test_xsection_plot.png index cc0de83249..4f88b5c404 100644 Binary files a/tests/plotting/baseline/test_xsection_plot.png and b/tests/plotting/baseline/test_xsection_plot.png differ diff --git a/tests/plotting/baseline/test_xsection_plot_map.png b/tests/plotting/baseline/test_xsection_plot_map.png index fa4ed0b2a3..9165ad70c7 100644 Binary files a/tests/plotting/baseline/test_xsection_plot_map.png and b/tests/plotting/baseline/test_xsection_plot_map.png differ diff --git a/tests/plotting/baseline/test_y_axis_flag_meanings.png b/tests/plotting/baseline/test_y_axis_flag_meanings.png index 76de97076d..9d1d2f2eee 100644 Binary files a/tests/plotting/baseline/test_y_axis_flag_meanings.png and b/tests/plotting/baseline/test_y_axis_flag_meanings.png differ diff --git a/tests/plotting/test_contourdisplay.py b/tests/plotting/test_contourdisplay.py index 2b6f4096b7..f0ef8a144c 100644 --- a/tests/plotting/test_contourdisplay.py +++ b/tests/plotting/test_contourdisplay.py @@ -8,7 +8,7 @@ matplotlib.use('Agg') -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_contour(): files = sample_files.EXAMPLE_MET_CONTOUR time = '2019-05-08T04:00:00.000000000' @@ -36,7 +36,7 @@ def test_contour(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_contour_stamp(): files = sample_files.EXAMPLE_STAMP_WILDCARD test = {} @@ -58,7 +58,7 @@ def test_contour_stamp(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_contour2(): files = sample_files.EXAMPLE_MET_CONTOUR time = '2019-05-08T04:00:00.000000000' @@ -86,7 +86,7 @@ def test_contour2(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_contourf(): files = sample_files.EXAMPLE_MET_CONTOUR time = '2019-05-08T04:00:00.000000000' @@ -126,7 +126,7 @@ def test_contourf(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_contourf2(): files = sample_files.EXAMPLE_MET_CONTOUR time = '2019-05-08T04:00:00.000000000' diff --git a/tests/plotting/test_distributiondisplay.py b/tests/plotting/test_distributiondisplay.py index ba9bfa0116..ad906ab443 100644 --- a/tests/plotting/test_distributiondisplay.py +++ b/tests/plotting/test_distributiondisplay.py @@ -80,7 +80,7 @@ def test_distribution_errors(): matplotlib.pyplot.close(fig=histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_stair_graph(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) @@ -94,7 +94,7 @@ def test_stair_graph(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_stair_graph2(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) del sonde_ds['tdry'].attrs['units'] @@ -109,7 +109,7 @@ def test_stair_graph2(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_stair_graph_sorted(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) @@ -128,7 +128,7 @@ def test_stair_graph_sorted(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_stacked_bar_graph(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) @@ -142,7 +142,7 @@ def test_stacked_bar_graph(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_stacked_bar_graph2(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) @@ -158,7 +158,7 @@ def test_stacked_bar_graph2(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_stacked_bar_graph3(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) del sonde_ds['tdry'].attrs['units'] @@ -173,7 +173,7 @@ def test_stacked_bar_graph3(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_stacked_bar_graph_sorted(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) @@ -192,7 +192,7 @@ def test_stacked_bar_graph_sorted(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_heatmap(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) @@ -212,7 +212,7 @@ def test_heatmap(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_heatmap2(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) del sonde_ds['tdry'].attrs['units'] @@ -233,7 +233,7 @@ def test_heatmap2(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_heatmap3(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) del sonde_ds['tdry'].attrs['units'] @@ -253,7 +253,7 @@ def test_heatmap3(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_size_distribution(): sigma = 10 mu = 50 @@ -270,7 +270,7 @@ def test_size_distribution(): matplotlib.pyplot.close(histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_size_distribution2(): sigma = 10 mu = 50 @@ -334,7 +334,7 @@ def test_histogram_kwargs(): matplotlib.pyplot.close(fig=histdisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_violin(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) @@ -352,7 +352,7 @@ def test_violin(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_violin2(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) del ds['temp_mean'].attrs['units'] @@ -371,7 +371,7 @@ def test_violin2(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_scatter(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) # Create a DistributionDisplay object to compare fields @@ -394,7 +394,7 @@ def test_scatter(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_scatter2(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) del ds['wspd_arith_mean'].attrs['units'] @@ -412,3 +412,38 @@ def test_scatter2(): return display.fig finally: matplotlib.pyplot.close(display.fig) + + +@pytest.mark.mpl_image_compare(tolerance=10) +def test_plot_pie_chart(): + ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_AOSACSM) + fields = ['sulfate', 'ammonium', 'nitrate', 'chloride'] + display = DistributionDisplay(ds) + display.plot_pie_chart(fields) + ds.close() + + try: + return display.fig + finally: + matplotlib.pyplot.close(display.fig) + + +@pytest.mark.mpl_image_compare(tolerance=10) +def test_plot_pie_chart_kwargs(): + ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_AOSACSM) + fields = ['sulfate', 'ammonium', 'nitrate', 'chloride'] + threshold = 0.0 + fill_value = 0.0 + display = DistributionDisplay(ds) + display.plot_pie_chart( + fields, + threshold=threshold, + fill_value=fill_value, + colors=['olivedrab', 'rosybrown', 'gray', 'saddlebrown'], + ) + ds.close() + + try: + return display.fig + finally: + matplotlib.pyplot.close(display.fig) diff --git a/tests/plotting/test_geodisplay.py b/tests/plotting/test_geodisplay.py index e576e965a8..d767c2f576 100644 --- a/tests/plotting/test_geodisplay.py +++ b/tests/plotting/test_geodisplay.py @@ -7,7 +7,7 @@ from act.tests import sample_files try: - import cartopy + import cartopy # noqa CARTOPY_AVAILABLE = True except ImportError: @@ -17,7 +17,7 @@ @pytest.mark.skipif(not CARTOPY_AVAILABLE, reason='Cartopy is not installed.') -@pytest.mark.mpl_image_compare(style='default', tolerance=30) +@pytest.mark.mpl_image_compare(style='default', tolerance=10) def test_geoplot(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) geodisplay = GeographicPlotDisplay({'sgpsondewnpnC1.b1': sonde_ds}, figsize=(15, 8)) @@ -46,7 +46,7 @@ def test_geoplot(): @pytest.mark.skipif(not CARTOPY_AVAILABLE, reason='Cartopy is not installed.') -@pytest.mark.mpl_image_compare(style='default', tolerance=30) +@pytest.mark.mpl_image_compare(style='default', tolerance=10) def test_geoplot_tile(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) geodisplay = GeographicPlotDisplay({'sgpsondewnpnC1.b1': sonde_ds}, figsize=(15, 8)) diff --git a/tests/plotting/test_skewtdisplay.py b/tests/plotting/test_skewtdisplay.py index aad586fda1..21a45281a9 100644 --- a/tests/plotting/test_skewtdisplay.py +++ b/tests/plotting/test_skewtdisplay.py @@ -1,4 +1,5 @@ import matplotlib +import matplotlib.pyplot as plt import numpy as np import pytest @@ -9,7 +10,7 @@ matplotlib.use('Agg') -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_skewt_plot(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) skewt = SkewTDisplay(sonde_ds) @@ -18,7 +19,7 @@ def test_skewt_plot(): return skewt.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_skewt_plot_spd_dir(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) skewt = SkewTDisplay(sonde_ds, ds_name='act_datastream') @@ -27,7 +28,7 @@ def test_skewt_plot_spd_dir(): return skewt.fig -@pytest.mark.mpl_image_compare(tolerance=81) +@pytest.mark.mpl_image_compare(tolerance=10) def test_multi_skewt_plot(): files = sample_files.EXAMPLE_TWP_SONDE_20060121 test = {} @@ -37,7 +38,7 @@ def test_multi_skewt_plot(): sonde_ds = sonde_ds.resample(time='30s').nearest() test.update({time: sonde_ds}) - skewt = SkewTDisplay(test, subplot_shape=(2, 2)) + skewt = SkewTDisplay(test, subplot_shape=(2, 2), figsize=(12, 14)) i = 0 j = 0 for f in files: @@ -52,15 +53,17 @@ def test_multi_skewt_plot(): dsname=time, p_levels_to_plot=np.arange(10.0, 1000.0, 25), ) + skewt.axes[j, i].set_ylim([1000, 10]) if j == 1: i += 1 j = 0 elif j == 0: j += 1 + plt.tight_layout() return skewt.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_enhanced_skewt_plot(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) display = act.plotting.SkewTDisplay(ds) @@ -69,7 +72,7 @@ def test_enhanced_skewt_plot(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_enhanced_skewt_plot_2(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) display = act.plotting.SkewTDisplay(ds) @@ -87,7 +90,7 @@ def test_enhanced_skewt_plot_2(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_skewt_options(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) skewt = SkewTDisplay(sonde_ds) diff --git a/tests/plotting/test_timeseriesdisplay.py b/tests/plotting/test_timeseriesdisplay.py index 3ae873473c..d1461b3779 100644 --- a/tests/plotting/test_timeseriesdisplay.py +++ b/tests/plotting/test_timeseriesdisplay.py @@ -14,7 +14,7 @@ matplotlib.use('Agg') -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_plot(): # Process MET data to get simple LCL files = sample_files.EXAMPLE_MET_WILDCARD @@ -130,7 +130,7 @@ def test_errors(): matplotlib.pyplot.close(fig=display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_multidataset_plot_tuple(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) ds2 = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SIRS) @@ -158,7 +158,7 @@ def test_multidataset_plot_tuple(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_multidataset_plot_dict(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) ds2 = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SIRS) @@ -179,7 +179,7 @@ def test_multidataset_plot_dict(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_barb_sounding_plot(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_TWP_SONDE_WILDCARD) BarbDisplay = TimeSeriesDisplay({'sonde_darwin': sonde_ds}) @@ -196,11 +196,11 @@ def test_barb_sounding_plot(): # Due to issues with pytest-mpl, for now we just test to see if it runs -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_time_height_scatter(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) - display = TimeSeriesDisplay({'sgpsondewnpnC1.b1': sonde_ds}, figsize=(7, 3)) + display = TimeSeriesDisplay({'sgpsondewnpnC1.b1': sonde_ds}, figsize=(10, 6)) display.time_height_scatter('tdry', plot_alt_field=True) sonde_ds.close() @@ -212,16 +212,22 @@ def test_time_height_scatter(): # Due to issues with pytest-mpl, for now we just test to see if it runs -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_time_height_scatter2(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SONDE1) - display = TimeSeriesDisplay({'sgpsondewnpnC1.b1': sonde_ds}, figsize=(7, 6), subplot_shape=(2,)) + display = TimeSeriesDisplay( + {'sgpsondewnpnC1.b1': sonde_ds}, figsize=(8, 10), subplot_shape=(2,) + ) display.time_height_scatter( - 'tdry', day_night_background=True, subplot_index=(0,), cb_friendly=True, plot_alt_field=True + 'tdry', + day_night_background=True, + subplot_index=(0,), + cvd_friendly=True, + plot_alt_field=True, ) display.time_height_scatter( - 'rh', day_night_background=True, subplot_index=(1,), cb_friendly=True + 'rh', day_night_background=True, subplot_index=(1,), cvd_friendly=True ) sonde_ds.close() @@ -232,7 +238,7 @@ def test_time_height_scatter2(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_qc_bar_plot(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) ds.clean.cleanup() @@ -265,7 +271,7 @@ def test_qc_bar_plot(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_2d_as_1d(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_CEIL1) @@ -281,7 +287,7 @@ def test_2d_as_1d(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_fill_between(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET_WILDCARD) @@ -299,16 +305,16 @@ def test_fill_between(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_qc_flag_block_plot(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_SURFSPECALB1MLAWER) - display = TimeSeriesDisplay(ds, subplot_shape=(2,), figsize=(8, 2 * 4)) + display = TimeSeriesDisplay(ds, subplot_shape=(2,), figsize=(10, 8)) display.plot('surface_albedo_mfr_narrowband_10m', force_line_plot=True, labels=True) display.qc_flag_block_plot( - 'surface_albedo_mfr_narrowband_10m', subplot_index=(1,), cb_friendly=True + 'surface_albedo_mfr_narrowband_10m', subplot_index=(1,), cvd_friendly=True ) ds.close() @@ -320,7 +326,7 @@ def test_qc_flag_block_plot(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_assessment_overplot(): var_name = 'temp_mean' files = sample_files.EXAMPLE_MET1 @@ -344,7 +350,7 @@ def test_assessment_overplot(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_assessment_overplot_multi(): var_name1, var_name2 = 'wspd_arith_mean', 'wspd_vec_mean' files = sample_files.EXAMPLE_MET1 @@ -377,7 +383,7 @@ def test_assessment_overplot_multi(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_plot_barbs_from_u_v(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_TWP_SONDE_WILDCARD) BarbDisplay = TimeSeriesDisplay({'sonde_darwin': sonde_ds}) @@ -389,7 +395,7 @@ def test_plot_barbs_from_u_v(): matplotlib.pyplot.close(BarbDisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_plot_barbs_from_u_v2(): bins = list(np.linspace(0, 1, 10)) xbins = list(pd.date_range(pd.to_datetime('2020-01-01'), pd.to_datetime('2020-01-02'), 12)) @@ -417,6 +423,7 @@ def test_plot_barbs_from_u_v2(): matplotlib.pyplot.close(BarbDisplay.fig) +@pytest.mark.mpl_image_compare(tolerance=10) def test_plot_barbs_from_u_v3(): bins = list(np.linspace(0, 1, 10)) xbins = list(pd.date_range(pd.to_datetime('2020-01-01'), pd.to_datetime('2020-01-02'), 12)) @@ -440,6 +447,7 @@ def test_plot_barbs_from_u_v3(): matplotlib.pyplot.close(BarbDisplay.fig) +@pytest.mark.mpl_image_compare(tolerance=10) def test_plot_barbs_from_u_v4(): bins = list(np.linspace(0, 1, 10)) xbins = [pd.to_datetime('2020-01-01')] @@ -465,6 +473,7 @@ def test_plot_barbs_from_u_v4(): matplotlib.pyplot.close(BarbDisplay.fig) +@pytest.mark.mpl_image_compare(tolerance=10) def test_plot_barbs_from_u_v5(): bins = list(np.linspace(0, 1, 10)) xbins = [pd.to_datetime('2020-01-01')] @@ -494,7 +503,7 @@ def test_plot_barbs_from_u_v5(): matplotlib.pyplot.close(BarbDisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_2D_timeseries_plot(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_CEIL1) display = TimeSeriesDisplay(ds) @@ -505,7 +514,7 @@ def test_2D_timeseries_plot(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_time_plot(): files = sample_files.EXAMPLE_MET1 ds = act.io.arm.read_arm_netcdf(files) @@ -514,7 +523,7 @@ def test_time_plot(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_time_plot_match_color_ylabel(): files = sample_files.EXAMPLE_MET1 ds = act.io.arm.read_arm_netcdf(files) @@ -523,7 +532,7 @@ def test_time_plot_match_color_ylabel(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=40) +@pytest.mark.mpl_image_compare(tolerance=10) def test_time_plot2(): files = sample_files.EXAMPLE_MET1 ds = act.io.arm.read_arm_netcdf(files, decode_times=False, use_cftime=False) @@ -532,7 +541,7 @@ def test_time_plot2(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_y_axis_flag_meanings(): variable = 'detection_status' ds = act.io.arm.read_arm_netcdf( @@ -547,7 +556,7 @@ def test_y_axis_flag_meanings(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=35) +@pytest.mark.mpl_image_compare(tolerance=10) def test_colorbar_labels(): variable = 'cloud_phase_hsrl' ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_CLOUDPHASE) @@ -568,7 +577,7 @@ def test_colorbar_labels(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_add_nan_line(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) @@ -597,7 +606,35 @@ def test_add_nan_line(): matplotlib.pyplot.close(display.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) +def test_add_nan_line_integer(): + data = np.arange(100, dtype=np.int32) + time = np.array('2019-11-01T00:00:00', dtype='datetime64[m]') + np.arange(data.size) + time = time.astype('datetime64[ns]') # Only done to stop a warning appearing + + # Remove data to produce a gap + data = np.delete(data, np.arange(50, 60), axis=0) + time = np.delete(time, np.arange(50, 60), axis=0) + data = np.delete(data, np.arange(70, 75), axis=0) + time = np.delete(time, np.arange(70, 75), axis=0) + + ds = xr.Dataset( + data_vars={'data': ('time', data, {'long_name': 'Data values', 'units': 'degC'})}, + coords={'time': ('time', time, {'long_name': 'Time in UTC'})}, + ) + + display = TimeSeriesDisplay({'test_datastream': ds}, figsize=(15, 10), subplot_shape=(1,)) + display.plot('data', subplot_index=(0,), add_nan=True, marker='.', markersize=20, linewidth=5) + + assert np.issubdtype(ds['data'].dtype, np.integer) + + try: + return display.fig + finally: + matplotlib.pyplot.close(display.fig) + + +@pytest.mark.mpl_image_compare(tolerance=10) def test_timeseries_invert(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_IRT25m20s) display = TimeSeriesDisplay(ds, figsize=(10, 8)) @@ -622,11 +659,11 @@ def test_plot_time_rng(): display.plot('temp_mean', time_rng=xrng) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_match_ylimits_plot(): files = sample_files.EXAMPLE_MET_WILDCARD ds = act.io.arm.read_arm_netcdf(files) - display = act.plotting.TimeSeriesDisplay(ds, figsize=(10, 8), subplot_shape=(2, 2)) + display = act.plotting.TimeSeriesDisplay(ds, figsize=(14, 8), subplot_shape=(2, 2)) groupby = display.group_by('day') groupby.plot_group('plot', None, field='temp_mean', marker=' ') groupby.display.set_yrng([-20, 20], match_axes_ylimits=True) @@ -634,7 +671,7 @@ def test_match_ylimits_plot(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_xlim_correction_plot(): ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_MET1) diff --git a/tests/plotting/test_windrosedisplay.py b/tests/plotting/test_windrosedisplay.py index b332e806ee..7566e9d8f0 100644 --- a/tests/plotting/test_windrosedisplay.py +++ b/tests/plotting/test_windrosedisplay.py @@ -9,7 +9,7 @@ matplotlib.use('Agg') -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_wind_rose(): sonde_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_TWP_SONDE_WILDCARD) @@ -33,7 +33,7 @@ def test_wind_rose(): matplotlib.pyplot.close(WindDisplay.fig) -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_plot_datarose(): files = sample_files.EXAMPLE_MET_WILDCARD ds = act.io.arm.read_arm_netcdf(files) @@ -131,7 +131,7 @@ def test_plot_datarose(): return display.fig -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_groupby_plot(): ds = act.io.arm.read_arm_netcdf(act.tests.EXAMPLE_MET_WILDCARD) diff --git a/tests/plotting/test_xsectiondisplay.py b/tests/plotting/test_xsectiondisplay.py index 29d460a729..732165cd2e 100644 --- a/tests/plotting/test_xsectiondisplay.py +++ b/tests/plotting/test_xsectiondisplay.py @@ -7,7 +7,7 @@ from act.tests import sample_files try: - import cartopy + import cartopy # noqa CARTOPY_AVAILABLE = True except ImportError: @@ -34,7 +34,7 @@ def test_xsection_errors(): matplotlib.pyplot.close(fig=display.fig) -@pytest.mark.mpl_image_compare(tolerance=31) +@pytest.mark.mpl_image_compare(tolerance=20) def test_xsection_plot(): visst_ds = act.io.arm.read_arm_netcdf(sample_files.EXAMPLE_CEIL1) @@ -51,7 +51,7 @@ def test_xsection_plot(): @pytest.mark.skipif(not CARTOPY_AVAILABLE, reason='Cartopy is not installed.') -@pytest.mark.mpl_image_compare(tolerance=30) +@pytest.mark.mpl_image_compare(tolerance=10) def test_xsection_plot_map(): radar_ds = act.io.arm.read_arm_netcdf( sample_files.EXAMPLE_VISST, combine='nested', concat_dim='time' diff --git a/tests/qc/conftest.py b/tests/qc/conftest.py new file mode 100644 index 0000000000..ab31c52f9f --- /dev/null +++ b/tests/qc/conftest.py @@ -0,0 +1,19 @@ +import pytest + + +def pytest_addoption(parser): + parser.addoption("--runbig", action="store_true", default=False, help="Run big tests") + + +def pytest_configure(config): + config.addinivalue_line("markers", "big: mark test as slow to run") + + +def pytest_collection_modifyitems(config, items): + if config.getoption("--runbig"): + # --runbig given in cli: do not skip big tests + return + skip_big = pytest.mark.skip(reason="need --runbig option to run") + for item in items: + if "big" in item.keywords: + item.add_marker(skip_big) diff --git a/tests/qc/test_arm_qc.py b/tests/qc/test_arm_qc.py index e118648706..ec623c51b2 100644 --- a/tests/qc/test_arm_qc.py +++ b/tests/qc/test_arm_qc.py @@ -12,7 +12,7 @@ def test_scalar_dqr(): # DQR webservice does go down, so ensure it # properly runs first before testing try: - ds = add_dqr_to_qc(ds) + ds = add_dqr_to_qc(ds, assessment='Reprocessed,Suspect,Incorrect') ran = True except ValueError: ran = False diff --git a/tests/qc/test_clean.py b/tests/qc/test_clean.py index add485b3d9..ec1e7ba4e2 100644 --- a/tests/qc/test_clean.py +++ b/tests/qc/test_clean.py @@ -1,7 +1,14 @@ import numpy as np from act.io.arm import read_arm_netcdf -from act.tests import EXAMPLE_CEIL1, EXAMPLE_CO2FLX4M, EXAMPLE_MET1 +from act.tests import ( + EXAMPLE_CEIL1, + EXAMPLE_CO2FLX4M, + EXAMPLE_MET1, + EXAMPLE_MET_SAIL, + EXAMPLE_SIRS_SIRI_QC, + EXAMPLE_SWATS, +) def test_global_qc_cleanup(): @@ -154,3 +161,183 @@ def test_qc_flag_description(): unique_flag_assessments = list({'Acceptable', 'Indeterminate', 'Bad'}) for f in list(set(ds[qc_var_name].attrs['flag_assessments'])): assert f in unique_flag_assessments + + +def test_clean_sirs_siri_qc(): + ds = read_arm_netcdf(EXAMPLE_SIRS_SIRI_QC) + + data = ds["qc_short_direct_normal"].values + data[0:5] = 1 + data[5:10] = 2 + data[10:15] = 3 + data[15:20] = 6 + data[20:25] = 7 + data[25:30] = 8 + data[30:35] = 9 + data[35:40] = 94 + data[40:45] = 95 + data[45:50] = 96 + data[50:55] = 97 + data[55:60] = 14 + data[60:65] = 18 + data[65:70] = 22 + data[70:75] = 26 + ds["qc_short_direct_normal"].values = data + + data = ds["qc_up_long_hemisp"].values + data[0:5] = 1 + data[5:10] = 2 + data[10:15] = 7 + data[15:20] = 8 + data[20:25] = 31 + ds["qc_up_long_hemisp"].values = data + + data = ds["qc_up_short_hemisp"].values + data[0:5] = 1 + data[5:10] = 2 + data[10:15] = 7 + data[15:20] = 8 + data[20:25] = 31 + ds["qc_up_short_hemisp"].values = data + + ds.clean.cleanup() + + assert ds["qc_short_direct_normal"].attrs['flag_masks'] == [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256, + 512, + 1024, + 2048, + 4096, + 8192, + 16384, + 32768, + ] + assert ds["qc_short_direct_normal"].attrs['flag_meanings'] == [ + 'Value is set to missing_value.', + 'Passed 1-component test; data fall within max-min limits of Kt,Kn, or Kd', + 'Passed 2-component test; data fall within 0.03 of the Gompertz boundaries', + 'Passed 3-component test; data come within +/- 0.03 of satifying Kt=Kn+Kd', + 'Value estimated; passes all pertinent SERI QC tests', + 'Failed 1-component test; lower than allowed minimum', + 'Falied 1-component test; higher than allowed maximum', + 'Passed 3-component test but failed 2-component test by >0.05', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of 0.05 to 0.10.', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of 0.10 to 0.15.', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of 0.15 to 0.20.', + 'Data fall into a physically impossible region where Kn>Kt by K-space distances of >= 0.20.', + 'Parameter too low by 3-component test (Kt=Kn+Kd)', + 'Parameter too high by 3-component test (Kt=Kn+Kd)', + 'Parameter too low by 2-component test (Gompertz boundary)', + 'Parameter too high by 2-component test (Gompertz boundary)', + ] + + assert ds["qc_up_long_hemisp"].attrs['flag_masks'] == [1, 2, 4, 8, 16, 32] + assert ds["qc_up_long_hemisp"].attrs['flag_meanings'] == [ + 'Value is set to missing_value.', + 'Passed 1-component test; data fall within max-min limits of up_long_hemisp and down_long_hemisp_shaded, but short_direct_normal and down_short_hemisp or down_short_diffuse fail the SERI QC tests.', + 'Passed 2-component test; data fall within max-min limits of up_long_hemisp and down_long_hemisp_shaded, and short_direct_normal, or down_short_hemisp and down_short_diffuse pass the SERI QC tests while the difference between down_short_hemisp and down_short_diffuse is greater than 20 W/m2.', + 'Failed 1-component test; lower than allowed minimum', + 'Failed 1-component test; higher than allowed maximum', + 'Failed 2-component test', + ] + + assert ds["qc_up_short_hemisp"].attrs['flag_masks'] == [1, 2, 4, 8, 16, 32] + assert ds["qc_up_short_hemisp"].attrs['flag_meanings'] == [ + 'Value is set to missing_value.', + 'Passed 1-component test', + 'Passed 2-component test', + 'Failed 1-component test; lower than allowed minimum', + 'Failed 1-component test; higher than allowed maximum', + 'Failed 2-component test; solar zenith angle is less than 80 degrees and down_short_hemisp is 0 or missing', + ] + + assert np.all(ds["qc_short_direct_normal"].values[0:5] == 2) + assert np.all(ds["qc_short_direct_normal"].values[5:10] == 4) + assert np.all(ds["qc_short_direct_normal"].values[10:15] == 8) + assert np.all(ds["qc_short_direct_normal"].values[15:20] == 16) + assert np.all(ds["qc_short_direct_normal"].values[20:25] == 32) + assert np.all(ds["qc_short_direct_normal"].values[25:30] == 64) + assert np.all(ds["qc_short_direct_normal"].values[30:35] == 128) + assert np.all(ds["qc_short_direct_normal"].values[35:40] == 256) + assert np.all(ds["qc_short_direct_normal"].values[40:45] == 512) + assert np.all(ds["qc_short_direct_normal"].values[45:50] == 1024) + assert np.all(ds["qc_short_direct_normal"].values[50:55] == 2048) + assert np.all(ds["qc_short_direct_normal"].values[55:60] == 4096) + assert np.all(ds["qc_short_direct_normal"].values[60:65] == 8192) + assert np.all(ds["qc_short_direct_normal"].values[65:70] == 16384) + assert np.all(ds["qc_short_direct_normal"].values[70:75] == 32768) + + assert np.all(ds["qc_up_long_hemisp"].values[0:5] == 2) + assert np.all(ds["qc_up_long_hemisp"].values[5:10] == 4) + assert np.all(ds["qc_up_long_hemisp"].values[10:15] == 8) + assert np.all(ds["qc_up_long_hemisp"].values[15:20] == 16) + assert np.all(ds["qc_up_long_hemisp"].values[20:25] == 32) + + assert np.all(ds["qc_up_short_hemisp"].values[0:5] == 2) + assert np.all(ds["qc_up_short_hemisp"].values[5:10] == 4) + assert np.all(ds["qc_up_short_hemisp"].values[10:15] == 8) + assert np.all(ds["qc_up_short_hemisp"].values[15:20] == 16) + assert np.all(ds["qc_up_short_hemisp"].values[20:25] == 32) + + +def test_swats_qc(): + ds = read_arm_netcdf(EXAMPLE_SWATS) + ds.clean.cleanup() + + data_var_names = [] + for var_name in ds.data_vars: + try: + ds[f'qc_{var_name}'] + data_var_names.append(var_name) + except KeyError: + pass + + for var_name in data_var_names: + qc_var_name = f'qc_{var_name}' + + assert ds[qc_var_name].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds[qc_var_name].attrs['flag_meanings'] == [ + 'Value is set to missing_value.', + 'Data value less than fail_min.', + 'Data value greater than fail_max.', + 'Difference between current and previous values exceeds fail_delta.', + ] + assert ds[qc_var_name].attrs['flag_assessments'] == ['Bad', 'Bad', 'Bad', 'Indeterminate'] + assert 'fail_min' in ds[qc_var_name].attrs + assert 'fail_max' in ds[qc_var_name].attrs + assert 'fail_delta' in ds[qc_var_name].attrs + + assert 'valid_min' not in ds[var_name].attrs + assert 'valid_max' not in ds[var_name].attrs + assert 'valid_delta' not in ds[var_name].attrs + assert ds[var_name].attrs['units'] != 'C' + + +def test_fix_incorrect_variable_bit_description_attributes(): + ds = read_arm_netcdf(EXAMPLE_MET_SAIL) + qc_var_name = 'qc_temp_mean' + ds[qc_var_name].attrs['qc_bit_2_description'] = ds[qc_var_name].attrs['bit_2_description'] + ds[qc_var_name].attrs['qc_bit_2_assessment'] = ds[qc_var_name].attrs['bit_2_assessment'] + del ds[qc_var_name].attrs['bit_2_description'] + del ds[qc_var_name].attrs['bit_2_assessment'] + + ds.clean.cleanup() + + assert ds[qc_var_name].attrs['flag_masks'] == [1, 2, 4, 8] + assert ds[qc_var_name].attrs['flag_meanings'] == [ + 'Value is equal to missing_value.', + 'Value is less than fail_min.', + 'Value is greater than fail_max.', + 'Difference between current and previous values exceeds fail_delta.', + ] + assert ds[qc_var_name].attrs['flag_assessments'] == ['Bad', 'Bad', 'Bad', 'Indeterminate'] + assert 'qc_bit_2_description' not in ds[qc_var_name].attrs + assert 'qc_bit_2_assessment' not in ds[qc_var_name].attrs diff --git a/tests/qc/test_qc_summary.py b/tests/qc/test_qc_summary.py new file mode 100644 index 0000000000..40cd8c5fc0 --- /dev/null +++ b/tests/qc/test_qc_summary.py @@ -0,0 +1,260 @@ +import numpy as np +from os import environ +from pathlib import Path +import random +import pytest +import datetime + +from act.io.arm import read_arm_netcdf +from act.tests import EXAMPLE_MET1 +from act.qc.qcfilter import set_bit +from act.utils.data_utils import DatastreamParserARM + + +def test_qc_summary(): + for cleanup in [False, True]: + ds = read_arm_netcdf(EXAMPLE_MET1, cleanup_qc=not cleanup) + for var_name in ['temp_mean', 'rh_mean']: + qc_var_name = f'qc_{var_name}' + qc_data = ds[qc_var_name].values + + assert np.sum(qc_data) == 0 + + index_4 = np.arange(100, 200) + qc_data[index_4] = set_bit(qc_data[index_4], 4) + index_1 = np.arange(170, 230) + qc_data[index_1] = set_bit(qc_data[index_1], 1) + index_2 = np.arange(250, 400) + qc_data[index_2] = set_bit(qc_data[index_2], 2) + index_3 = np.arange(450, 510) + qc_data[index_3] = set_bit(qc_data[index_3], 3) + ds[qc_var_name].values = qc_data + + result = ds.qcfilter.create_qc_summary(cleanup_qc=cleanup) + + for var_name in ['temp_mean', 'rh_mean']: + assert 'flag_masks' not in result[qc_var_name].attrs.keys() + assert isinstance(result[qc_var_name].attrs['flag_values'], list) + + assert np.sum(result[qc_var_name].values) == 610 + + qc_ma = result.qcfilter.get_masked_data(var_name, rm_assessments='Indeterminate') + assert np.all(np.where(qc_ma.mask)[0] == np.arange(100, 170)) + + qc_ma = result.qcfilter.get_masked_data(var_name, rm_assessments='Bad') + index = np.concatenate([index_1, index_2, index_3]) + assert np.all(np.where(qc_ma.mask)[0] == index) + + assert "Quality control summary implemented by ACT" in result.attrs['history'] + + del ds + + +def test_qc_summary_multiple_assessment_names(): + ds = read_arm_netcdf(EXAMPLE_MET1, cleanup_qc=True) + var_name = 'temp_mean' + qc_var_name = f'qc_{var_name}' + qc_data = ds[qc_var_name].values + + assert np.sum(qc_data) == 0 + + index_4 = np.arange(200, 300) + qc_data[index_4] = set_bit(qc_data[index_4], 4) + index_1 = np.arange(270, 330) + qc_data[index_1] = set_bit(qc_data[index_1], 1) + index_2 = np.arange(350, 500) + qc_data[index_2] = set_bit(qc_data[index_2], 2) + index_3 = np.arange(550, 610) + qc_data[index_3] = set_bit(qc_data[index_3], 3) + ds[qc_var_name].values = qc_data + + index_5 = np.arange(50, 150) + ds.qcfilter.add_test( + var_name, index=index_5, test_meaning='Testing Suspect', test_assessment='Suspect' + ) + + index_6 = np.arange(130, 210) + ds.qcfilter.add_test( + var_name, index=index_6, test_meaning='Testing Incorrect', test_assessment='Incorrect' + ) + + result = ds.qcfilter.create_qc_summary() + + assert result[qc_var_name].attrs['flag_assessments'] == [ + 'Not failing', + 'Suspect', + 'Indeterminate', + 'Incorrect', + 'Bad', + ] + + qc_ma = result.qcfilter.get_masked_data(var_name, rm_assessments='Indeterminate') + assert np.sum(np.where(qc_ma.mask)[0]) == 14370 + + qc_ma = result.qcfilter.get_masked_data(var_name, rm_assessments='Suspect') + assert np.sum(np.where(qc_ma.mask)[0]) == 7160 + + qc_ma = result.qcfilter.get_masked_data(var_name, rm_assessments='Bad') + assert np.sum(np.where(qc_ma.mask)[0]) == 116415 + + qc_ma = result.qcfilter.get_masked_data(var_name, rm_assessments='Incorrect') + assert np.sum(np.where(qc_ma.mask)[0]) == 13560 + + assert np.sum(np.where(result[qc_var_name].values == 0)) == 884575 + qc_ma = result.qcfilter.get_masked_data(var_name, rm_assessments='Not failing') + assert np.sum(np.where(qc_ma.mask)[0]) == 884575 + + +@pytest.mark.big +@pytest.mark.skipif('ARCHIVE_DATA' not in environ, reason="Running outside ADC system.") +def test_qc_summary_big_data(): + """ + We want to test on as much ARM data as possible. But we do not want to force + a large amount of test data in GitHub. Plan is to see if the pytest code is being + run on ARM system and if so then run on historical data. If running on GitHub + then don't run tests. Also, have a switch to not force this big test to always + run as that would be mean to the developer. So need to periodicaly run with the + manual switch enabled. + + All exceptions are caught and a file name is sent to the output file when + an exception is found. Since this is testing 10,000+ files it will take hours + to run. I suggest you run in background and capture the standard out to a different + file. If no files are written to the output file then all tests passed. + + Output file name follows the convention of: + ~/test_qc_summary_big_data.{datetime}.txt + + To Run this test set keyword on pytest command line: + > pytest -s --runbig test_qc_summary.py::test_qc_summary_big_data &> ~/out.txt & + + + """ + + base_path = Path(environ['ARCHIVE_DATA']) + if not base_path.is_dir(): + return + + # Set number of files from each directory to test. + skip_sites = [ + 'shb', + 'wbu', + 'dna', + 'rld', + 'smt', + 'nic', + 'isp', + 'dmf', + 'nac', + 'rev', + 'yeu', + 'zrh', + 'osc', + ] + skip_datastream_codes = [ + 'mmcrmom', + # 'microbasepi', + # 'lblch1a', + # '30co2flx4mmet', + # 'microbasepi2', + # '30co2flx60m', + # 'bbhrpavg1mlawer', + # 'co', + # 'lblch1b', + # '30co2flx25m', + # '30co2flx4m', + # 'armbeatm', + # 'armtrajcld', + # '1swfanalsiros1long', + ] + # skip_datastreams = ['nimmfrsraod5chcorM1.c1', 'anxaoso3M1.b0'] + num_files = 3 + expected_assessments = ['Not failing', 'Suspect', 'Indeterminate', 'Incorrect', 'Bad'] + + testing_files = [] + + single_test = False + if len(testing_files) == 0: + single_test = True + filename = ( + f'test_qc_summary_big_data.{datetime.datetime.utcnow().strftime("%Y%m%d.%H%M%S")}.txt' + ) + output_file = Path(environ['HOME'], filename) + output_file.unlink(missing_ok=True) + output_file.touch() + + site_dirs = list(base_path.glob('???')) + for site_dir in site_dirs: + if site_dir.name in skip_sites: + continue + + datastream_dirs = list(site_dir.glob('*.[bc]?')) + for datastream_dir in datastream_dirs: + if '-' in datastream_dir.name: + continue + + # if datastream_dir.name in skip_datastreams: + # continue + + fn_obj = DatastreamParserARM(datastream_dir.name) + facility = fn_obj.facility + if facility is not None and facility[0] in ['A', 'X', 'U', 'F', 'N']: + continue + + datastream_class = fn_obj.datastream_class + if datastream_class is not None and datastream_class in skip_datastream_codes: + continue + + files = list(datastream_dir.glob('*.nc')) + files.extend(datastream_dir.glob('*.cdf')) + if len(files) == 0: + continue + + num_tests = num_files + if len(files) < num_files: + num_tests = len(files) + + for ii in range(0, num_tests): + testing_files.append(random.choice(files)) + + if single_test: + print(f"Testing {len(testing_files)} files\n") + print(f"Output file name = {output_file}\n") + + for file in testing_files: + try: + print(f"Testing: {file}") + ds = read_arm_netcdf(str(file), cleanup_qc=True, decode_times=False) + ds = ds.qcfilter.create_qc_summary() + + created_qc_summary = False + for var_name in ds.data_vars: + qc_var_name = ds.qcfilter.check_for_ancillary_qc( + var_name, add_if_missing=False, cleanup=False + ) + + if qc_var_name is None: + continue + + created_qc_summary = True + assert isinstance(ds[qc_var_name].attrs['flag_values'], list) + assert isinstance(ds[qc_var_name].attrs['flag_assessments'], list) + assert isinstance(ds[qc_var_name].attrs['flag_meanings'], list) + assert len(ds[qc_var_name].attrs['flag_values']) >= 1 + assert len(ds[qc_var_name].attrs['flag_assessments']) >= 1 + assert len(ds[qc_var_name].attrs['flag_meanings']) >= 1 + assert ds[qc_var_name].attrs['flag_assessments'][0] == 'Not failing' + assert ( + ds[qc_var_name].attrs['flag_meanings'][0] == 'Not failing quality control tests' + ) + + for assessment in ds[qc_var_name].attrs['flag_assessments']: + assert assessment in expected_assessments + + if created_qc_summary: + assert "Quality control summary implemented by ACT" in ds.attrs['history'] + + del ds + + except Exception: + with open(output_file, "a") as myfile: + myfile.write(f"{file}\n") diff --git a/tests/qc/test_qcfilter.py b/tests/qc/test_qcfilter.py index 01a0adf643..163206f56f 100644 --- a/tests/qc/test_qcfilter.py +++ b/tests/qc/test_qcfilter.py @@ -1,5 +1,5 @@ import copy -from datetime import datetime +from datetime import datetime, timezone import dask.array as da import numpy as np @@ -13,7 +13,7 @@ from act.tests import EXAMPLE_MET1, EXAMPLE_METE40, EXAMPLE_IRT25m20s try: - import scikit_posthocs + import scikit_posthocs # noqa SCIKIT_POSTHOCS_AVAILABLE = True except ImportError: @@ -390,12 +390,12 @@ def test_qc_speed(): coords={'time': time}, ) - start = datetime.utcnow() + start = datetime.now(timezone.utc) for name, var in noisy_data_mapping.items(): failed_qc = var > 0.75 # Consider data above 0.75 as bad. Negligible time here. ds.qcfilter.add_test(name, index=failed_qc, test_meaning='Value above threshold') - time_diff = datetime.utcnow() - start + time_diff = datetime.now(timezone.utc) - start assert time_diff.seconds <= 4 diff --git a/tests/retrievals/test_sp2_retrievals.py b/tests/retrievals/test_sp2_retrievals.py index e22db09722..b5bf49f927 100644 --- a/tests/retrievals/test_sp2_retrievals.py +++ b/tests/retrievals/test_sp2_retrievals.py @@ -4,7 +4,7 @@ import act try: - import pysp2 + import pysp2 # noqa PYSP2_AVAILABLE = True except ImportError: diff --git a/tests/utils/test_data_utils.py b/tests/utils/test_data_utils.py index bf10076164..0a626e135f 100644 --- a/tests/utils/test_data_utils.py +++ b/tests/utils/test_data_utils.py @@ -4,9 +4,13 @@ import pytest import xarray as xr from numpy.testing import assert_almost_equal +from contextlib import redirect_stdout +from io import StringIO +from pathlib import Path import act from act.utils.data_utils import DatastreamParserARM as DatastreamParser +from act.utils.data_utils import convert_2d_to_1d spec = importlib.util.find_spec('pyart') if spec is not None: @@ -18,7 +22,7 @@ def test_add_in_nan(): # Make a 1D array of 10 minute data time = np.arange('2019-01-01T01:00', '2019-01-01T01:10', dtype='datetime64[m]') - time = time.astype('datetime64[us]') + time = time.astype('datetime64[ns]') time = np.delete(time, range(3, 8)) data = np.linspace(0.0, 8.0, time.size) @@ -93,10 +97,8 @@ def test_convert_units(): data = act.utils.data_utils.convert_units(r_data, 'K', 'C') assert np.ceil(data[0]) == 12 - try: + with np.testing.assert_raises(ValueError): ds.utils.change_units() - except ValueError as error: - assert str(error) == "Need to provide 'desired_unit' keyword for .change_units() method" desired_unit = 'degF' skip_vars = [ii for ii in ds.data_vars if ii.startswith('qc_')] @@ -138,6 +140,27 @@ def test_convert_units(): ds.close() del ds + # Test if exception or print statement is issued when an error occurs with units string + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_EBBR1) + with np.testing.assert_raises(ValueError): + ds.utils.change_units('home_signal_15', 'not_a_real_unit_string', raise_error=True) + + with np.testing.assert_raises(ValueError): + ds.utils.change_units('not_a_real_variable_name', 'degC', raise_error=True) + + f = StringIO() + var_name = 'home_signal_15' + unit = 'not_a_real_unit_string' + with redirect_stdout(f): + ds.utils.change_units('home_signal_15', 'not_a_real_unit_string', verbose=True) + s = f.getvalue() + assert ( + s.strip() + == f"Unable to convert '{var_name}' to units of '{unit}'. Skipping unit converstion for '{var_name}'." + ) + ds.close() + del ds + def test_ts_weighted_average(): ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_MET_WILDCARD) @@ -326,10 +349,12 @@ def test_height_adjusted_pressure(): def test_datastreamparser(): - pytest.raises(ValueError, DatastreamParser, 123) + test_values = [1234, 4321.0, True, ['sgpmetE13.b1'], ('sgpmetE13.b1',)] + for test_value in test_values: + pytest.raises(ValueError, DatastreamParser, test_value) - fn_obj = DatastreamParser() - pytest.raises(ValueError, fn_obj.set_datastream, None) + fn_obj = DatastreamParser() + pytest.raises(ValueError, fn_obj.set_datastream, test_values) fn_obj = DatastreamParser() assert fn_obj.site is None @@ -352,6 +377,16 @@ def test_datastreamparser(): assert fn_obj.time == '024254' assert fn_obj.ext == 'nc' + fn_obj = DatastreamParser(Path('/data/sgp/sgpmetE13.b1/sgpmetE13.b1.20190501.024254.nc')) + assert fn_obj.site == 'sgp' + assert fn_obj.datastream_class == 'met' + assert fn_obj.facility == 'E13' + assert fn_obj.level == 'b1' + assert fn_obj.datastream == 'sgpmetE13.b1' + assert fn_obj.date == '20190501' + assert fn_obj.time == '024254' + assert fn_obj.ext == 'nc' + fn_obj.set_datastream('nsatwrC1.a0.19991230.233451.cdf') assert fn_obj.site == 'nsa' assert fn_obj.datastream_class == 'twr' @@ -382,29 +417,29 @@ def test_datastreamparser(): assert fn_obj.time is None assert fn_obj.ext is None - fn_obj = DatastreamParser('sgpmetE13') + fn_obj = DatastreamParser(Path('sgpmetE13.b1')) assert fn_obj.site == 'sgp' assert fn_obj.datastream_class == 'met' assert fn_obj.facility == 'E13' - assert fn_obj.level is None - assert fn_obj.datastream is None + assert fn_obj.level == 'b1' + assert fn_obj.datastream == 'sgpmetE13.b1' assert fn_obj.date is None assert fn_obj.time is None assert fn_obj.ext is None - fn_obj = DatastreamParser('sgpmet') + fn_obj = DatastreamParser('sgpmetE13') assert fn_obj.site == 'sgp' assert fn_obj.datastream_class == 'met' - assert fn_obj.facility is None + assert fn_obj.facility == 'E13' assert fn_obj.level is None assert fn_obj.datastream is None assert fn_obj.date is None assert fn_obj.time is None assert fn_obj.ext is None - fn_obj = DatastreamParser('sgp') + fn_obj = DatastreamParser('sgpmet') assert fn_obj.site == 'sgp' - assert fn_obj.datastream_class is None + assert fn_obj.datastream_class == 'met' assert fn_obj.facility is None assert fn_obj.level is None assert fn_obj.datastream is None @@ -412,8 +447,8 @@ def test_datastreamparser(): assert fn_obj.time is None assert fn_obj.ext is None - fn_obj = DatastreamParser('sg') - assert fn_obj.site is None + fn_obj = DatastreamParser('sgp') + assert fn_obj.site == 'sgp' assert fn_obj.datastream_class is None assert fn_obj.facility is None assert fn_obj.level is None @@ -421,7 +456,38 @@ def test_datastreamparser(): assert fn_obj.date is None assert fn_obj.time is None assert fn_obj.ext is None - del fn_obj + + fn_obj = DatastreamParser(Path('zzzasoinfaoianasdfkansfaiZ99.s9.123456789.987654321.superlong')) + assert fn_obj.site == 'zzz' + assert fn_obj.datastream_class == 'asoinfaoianasdfkansfai' + assert fn_obj.facility == 'Z99' + assert fn_obj.level == 's9' + assert fn_obj.datastream == 'zzzasoinfaoianasdfkansfaiZ99.s9' + assert fn_obj.date == '123456789' + assert fn_obj.time == '987654321' + assert fn_obj.ext == 'superlong' + + values = [ + '', + ' ', + 'sg', + 'SGP', + 'SGPMETE13.B1', + Path('zzzasoinfaoianasdfkansfaiZ999.z1.123456789.987654321.superlong'), + Path('/data/not/a/real/path/AsgpmetE13.b1.20190501.024254.nc'), + '/data/not/a/real/path/AsgpmetE13.b1.20190501.024254.nc', + 'zzzasoinfaoianasdfkansfaiZ999.z1.123456789.987654321.superlong', + ] + for value in values: + fn_obj = DatastreamParser(value) + assert fn_obj.site is None + assert fn_obj.datastream_class is None + assert fn_obj.facility is None + assert fn_obj.level is None + assert fn_obj.datastream is None + assert fn_obj.date is None + assert fn_obj.time is None + assert fn_obj.ext is None def test_arm_site_location_search(): @@ -455,3 +521,87 @@ def test_arm_site_location_search(): assert list(test_dict_nsa)[0] == 'nsa C1' assert test_dict_nsa[list(test_dict_nsa)[0]]['latitude'] == 71.323 assert test_dict_nsa[list(test_dict_nsa)[0]]['longitude'] == -156.615 + + +def test_calculate_percentages(): + ds = act.io.arm.read_arm_netcdf(act.tests.sample_files.EXAMPLE_AOSACSM) + fields = ['sulfate', 'ammonium', 'nitrate', 'chloride'] + time = '2023-04-20T03:49:45.000000000' + time_slice = ('2023-04-20T17:38:20.000000000', '2023-04-20T20:29:47.000000000') + threshold = 0.0 + + # Without threshold, chloride has invalid negative values so + # percentages will be incorrect. Check if warning is created + with pytest.warns(UserWarning) as record: + act.utils.calculate_percentages( + ds, fields, time='2023-04-20T03:49:45.000000000', threshold=None + ) + if not record: + pytest.fail("Expected a warning for invalid data.") + + # Test with threshold and singular time + percentages = act.utils.calculate_percentages(ds, fields, time=time, threshold=threshold) + assert 'sulfate' in percentages.keys() + assert 'chloride' in percentages.keys() + assert np.round(percentages["sulfate"], 3) == 66.125 + assert np.round(percentages["chloride"], 3) == 0.539 + + # Test with sliced time + percentages = act.utils.calculate_percentages(ds, fields, time_slice=time_slice, threshold=0.0) + assert np.round(percentages["sulfate"], 3) == 68.342 + assert np.round(percentages["chloride"], 3) == 1.042 + + # Run on all times and check if warning exists. + with pytest.warns(UserWarning) as record: + percentages = act.utils.calculate_percentages(ds, fields, threshold=0.0) + assert np.round(percentages["sulfate"], 3) == 66.373 + assert np.round(percentages["chloride"], 3) == 0.915 + if not record: + pytest.fail("Expected a warning for using all times.") + + +def test_convert_2d_to_1d(): + # Create a sample dataset + data = np.array([[1, 2], [3, 4], [5, 6]]) + ds = xr.Dataset( + {'var': (('time', 'level'), data)}, coords={'time': [0, 1, 2], 'level': [10, 20]} + ) + ds['level'].attrs['units'] = 'm' + + # Run the function + result = convert_2d_to_1d(ds, parse='level') + + # Check the results + assert 'var_level_0' in result + assert 'var_level_1' in result + np.testing.assert_array_equal(result['var_level_0'].values, [1, 3, 5]) + np.testing.assert_array_equal(result['var_level_1'].values, [2, 4, 6]) + + # Run the function with use_dim_value_in_name=True + result = convert_2d_to_1d(ds, parse='level', use_dim_value_in_name=True) + + # Check the results + assert 'var_level_10m' in result + assert 'var_level_20m' in result + np.testing.assert_array_equal(result['var_level_10m'].values, [1, 3, 5]) + np.testing.assert_array_equal(result['var_level_20m'].values, [2, 4, 6]) + + # Run the function with custom labels + result = convert_2d_to_1d(ds, parse='level', dim_labels=['low', 'high']) + + # Check the results + assert 'var_low' in result + assert 'var_high' in result + np.testing.assert_array_equal(result['var_low'].values, [1, 3, 5]) + np.testing.assert_array_equal(result['var_high'].values, [2, 4, 6]) + + # Create a sample dataset + data = np.array([[1], [3], [5]]) + ds = xr.Dataset({'var': (('time', 'level'), data)}, coords={'time': [0, 1, 2], 'level': [10]}) + + # Run the function with keep_name_if_one=True + result = convert_2d_to_1d(ds, parse='level', keep_name_if_one=True) + + # Check the results + assert 'var' in result + np.testing.assert_array_equal(result['var'].values, [1, 3, 5]) diff --git a/tests/utils/test_datetime_utils.py b/tests/utils/test_datetime_utils.py index ce03f21a83..79d4b65055 100644 --- a/tests/utils/test_datetime_utils.py +++ b/tests/utils/test_datetime_utils.py @@ -1,4 +1,4 @@ -from datetime import datetime +from datetime import datetime, timezone import numpy as np import pandas as pd @@ -15,7 +15,7 @@ def test_dates_between(): answer = np.arange(start_string, end_string, dtype='datetime64[D]') answer = np.append(answer, answer[-1] + 1) answer = answer.astype('datetime64[s]').astype(int) - answer = [datetime.utcfromtimestamp(ii) for ii in answer] + answer = [datetime.fromtimestamp(ii, tz=timezone.utc).replace(tzinfo=None) for ii in answer] assert date_list == answer diff --git a/tests/utils/test_io_utils.py b/tests/utils/test_io_utils.py index 89cfee6ef6..6bde1635c0 100644 --- a/tests/utils/test_io_utils.py +++ b/tests/utils/test_io_utils.py @@ -1,24 +1,21 @@ -import glob -import os import random import shutil import tempfile -from os import PathLike, chdir, getcwd +from os import PathLike, chdir from pathlib import Path from string import ascii_letters import numpy as np import pytest -from arm_test_data import locate as test_data_locate import act from act.tests import sample_files try: - import moviepy.video.io.ImageSequenceClip + import moviepy.video.io.ImageSequenceClip # noqa MOVIEPY_AVAILABLE = True -except ImportError: +except (ImportError, RuntimeError): MOVIEPY_AVAILABLE = False @@ -278,5 +275,66 @@ def test_generate_movie(): assert Path(result).name == write_filename assert np.isclose(Path(result).stat().st_size, 173189, 1000) + # Test converting MPEG to mp4 + write_filename = 'movie3.mp4' + mpeg_file = sample_files.EXAMPLE_MPEG + result = act.utils.generate_movie(mpeg_file, write_filename=write_filename) + files = list(Path().glob(write_filename)) + assert len(files) == 1 + assert np.isclose(files[0].stat().st_size, 1625298, rtol=100, atol=100) + finally: chdir(cwd) + + +def test_arm_standards_validator(): + met_files = sample_files.EXAMPLE_MET_SAIL + errors = act.utils.arm_standards_validator(met_files) + assert len(errors) == 0 + + ds = act.io.read_arm_netcdf(met_files) + ds2 = ds.drop_vars(['lat', 'lon', 'alt']) + errors = act.utils.arm_standards_validator(dataset=ds2) + + assert len(errors) == 3 + + ds2 = ds + var = ['lat', 'lon', 'alt'] + for v in var: + del ds2[v].attrs['standard_name'] + + errors = act.utils.arm_standards_validator(dataset=ds2) + assert len(errors) == 3 + + ds2 = ds + for v in var: + ds2[v].attrs['standard_name'] = 'test' + errors = act.utils.arm_standards_validator(dataset=ds2) + assert len(errors) == 3 + + ds2 = ds + for v in ds2: + del ds2[v].attrs['long_name'] + errors = act.utils.arm_standards_validator(dataset=ds2) + assert len(errors) == 54 + + ds2 = act.io.read_arm_netcdf(met_files) + ds2['time'].values[1] = ds2['time'].values[10] + errors = act.utils.arm_standards_validator(dataset=ds2) + + assert 'Duplicate' in errors[0] + assert 'increasing' in errors[1] + + file = 'shpinstrumentX50.z1.202005.000000.nc' + errors = act.utils.arm_standards_validator(file) + + assert 'File is not in a standard format' in errors[0] + + file = 'sgpmetE13.z1.20200501.000000.nc' + errors = act.utils.arm_standards_validator(file) + + assert 'no files to open' in errors[0] + + ds = act.io.read_arm_netcdf(sample_files.EXAMPLE_CEIL1) + errors = act.utils.arm_standards_validator(dataset=ds) + assert len(errors) == 4