{ "cells": [ { "cell_type": "markdown", "id": "0", "metadata": {}, "source": [ "# Compute climate indicators on weather station data from ECCC's API\n", "\n", "Environment and Climate Change Canada (ECCC) offers an [API](https://api.weather.gc.ca/collections/climate-daily) to access daily weather station data. This notebook focus is on converting the JSON response from the server to an `xarray.Dataset`. At that point, it's then easy to compute numerous climate indicators on the daily time series using [xclim](http://xclim.readthedocs.io/)." ] }, { "cell_type": "code", "execution_count": 1, "id": "1", "metadata": { "pycharm": { "is_executing": true }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idLOCAL_MONTHLOCAL_DATEMIN_TEMPERATUREMIN_REL_HUMIDITYLOCAL_DAYSNOW_ON_GROUND_FLAGMEAN_TEMPERATURE_FLAGDIRECTION_MAX_GUSTCLIMATE_IDENTIFIER...HEATING_DEGREE_DAYSLOCAL_YEARTOTAL_RAINMAX_REL_HUMIDITY_FLAGPROVINCE_CODESNOW_ON_GROUNDTOTAL_RAIN_FLAGMAX_TEMPERATUREMAX_REL_HUMIDITYgeometry
07024745.1994.7.2671994-07-2617.3NaN26NoneNone0.07024745...0.01994NoneNoneQCNoneM26.7NaNPOINT (-73.57917 45.50474)
17024745.1994.7.2771994-07-2715.6NaN27NoneNone0.07024745...0.01994NoneNoneQCNoneM23.5NaNPOINT (-73.57917 45.50474)
27024745.1994.7.2871994-07-2817.0NaN28NoneNone0.07024745...0.01994NoneNoneQCNoneM21.2NaNPOINT (-73.57917 45.50474)
37024745.1994.7.2971994-07-2916.4NaN29NoneNone0.07024745...0.01994NoneNoneQCNoneM27.0NaNPOINT (-73.57917 45.50474)
47024745.1994.7.3071994-07-3018.0NaN30NoneNone0.07024745...0.01994NoneNoneQCNoneM23.7NaNPOINT (-73.57917 45.50474)
\n", "

5 rows × 36 columns

\n", "
" ], "text/plain": [ " id LOCAL_MONTH LOCAL_DATE MIN_TEMPERATURE \\\n", "0 7024745.1994.7.26 7 1994-07-26 17.3 \n", "1 7024745.1994.7.27 7 1994-07-27 15.6 \n", "2 7024745.1994.7.28 7 1994-07-28 17.0 \n", "3 7024745.1994.7.29 7 1994-07-29 16.4 \n", "4 7024745.1994.7.30 7 1994-07-30 18.0 \n", "\n", " MIN_REL_HUMIDITY LOCAL_DAY SNOW_ON_GROUND_FLAG MEAN_TEMPERATURE_FLAG \\\n", "0 NaN 26 None None \n", "1 NaN 27 None None \n", "2 NaN 28 None None \n", "3 NaN 29 None None \n", "4 NaN 30 None None \n", "\n", " DIRECTION_MAX_GUST CLIMATE_IDENTIFIER ... HEATING_DEGREE_DAYS LOCAL_YEAR \\\n", "0 0.0 7024745 ... 0.0 1994 \n", "1 0.0 7024745 ... 0.0 1994 \n", "2 0.0 7024745 ... 0.0 1994 \n", "3 0.0 7024745 ... 0.0 1994 \n", "4 0.0 7024745 ... 0.0 1994 \n", "\n", " TOTAL_RAIN MAX_REL_HUMIDITY_FLAG PROVINCE_CODE SNOW_ON_GROUND \\\n", "0 None None QC None \n", "1 None None QC None \n", "2 None None QC None \n", "3 None None QC None \n", "4 None None QC None \n", "\n", " TOTAL_RAIN_FLAG MAX_TEMPERATURE MAX_REL_HUMIDITY \\\n", "0 M 26.7 NaN \n", "1 M 23.5 NaN \n", "2 M 21.2 NaN \n", "3 M 27.0 NaN \n", "4 M 23.7 NaN \n", "\n", " geometry \n", "0 POINT (-73.57917 45.50474) \n", "1 POINT (-73.57917 45.50474) \n", "2 POINT (-73.57917 45.50474) \n", "3 POINT (-73.57917 45.50474) \n", "4 POINT (-73.57917 45.50474) \n", "\n", "[5 rows x 36 columns]" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "import os\n", "\n", "os.environ[\"USE_PYGEOS\"] = \"0\" # force use Shapely with GeoPandas\n", "\n", "import warnings\n", "\n", "import numba\n", "\n", "warnings.simplefilter(\"ignore\", category=numba.core.errors.NumbaDeprecationWarning)\n", "\n", "import urllib.request\n", "\n", "import cf_xarray as cfxr\n", "import geopandas as gpd\n", "from urlpath import URL\n", "\n", "# Compose the request\n", "host = URL(\"https://api.weather.gc.ca/\")\n", "api = host / \"collections\" / \"climate-daily\" / \"items\"\n", "url = api.with_query(\n", " {\n", " \"datetime\": \"1840-03-01 00:00:00/2021-06-02 00:00:00\",\n", " \"STN_ID\": \"10761\",\n", " \"sortby\": \"LOCAL_DATE\",\n", " }\n", ")\n", "\n", "# Use geopandas to convert the json output to a GeoDataFrame.\n", "with urllib.request.urlopen(url=str(url)) as req:\n", " gdf = gpd.read_file(filename=req, engine=\"pyogrio\")\n", "gdf.sort_index().head()" ] }, { "cell_type": "markdown", "id": "2", "metadata": {}, "source": [ "The next step is to convert the GeoDataFrame object into an `xarray.Dataset`, to do so, we've created some utilities packaged in `cf-xarray` to convert point geometries (the stations' locations) into CF-compliant coordinates. The function below bundles a number of operations to prepare the data for further analysis." ] }, { "cell_type": "code", "execution_count": 2, "id": "3", "metadata": { "tags": [] }, "outputs": [], "source": [ "def preprocessing(gdf):\n", " \"\"\"Convert geojson data from the ECCC weather API into a CF-compliant dataset.\n", "\n", " - Rename variables names CF standard names\n", " - Assign units to variables\n", " - Mask values with a flag\n", " - Convert wind directions in tens of degrees to degrees\n", " - Fill gaps in time series with NaNs\n", "\n", " Parameters\n", " ----------\n", " gdf : pandas.GeoDataFrame\n", " Data from the `api.weather.gc.ca` service.\n", "\n", " Returns\n", " -------\n", " xr.Dataset\n", " Dataset complete with units and CF-compliant temporal and spatial coordinates.\n", "\n", " Notes\n", " -----\n", " DIRECTION_MAX_GUST is only reported if the maximum gust speed exceeds 29 km/h.\n", " A value of 0 or 360 means wind blowing from the geographic north, and 90 from the east.\n", "\n", " \"\"\"\n", " import pandas as pd\n", " import xarray as xr\n", "\n", " # Convert timestamp to datetime object\n", " gdf[\"time\"] = gdf[\"LOCAL_DATE\"].astype(\"datetime64[ns]\")\n", "\n", " # Drop useless variables\n", " gdf = gdf.drop([\"LOCAL_DATE\", \"LOCAL_YEAR\", \"LOCAL_MONTH\", \"LOCAL_DAY\"], axis=1)\n", "\n", " # Convert to xarray.Dataset\n", " ds = gdf.set_index(\"time\").to_xarray()\n", "\n", " # Convert geometries to CF - creates a features dimension\n", " ds = cfxr.geometry.reshape_unique_geometries(ds)\n", " coords = cfxr.shapely_to_cf(ds.geometry, grid_mapping=\"longitude_latitude\")\n", " coords = coords.drop_vars([\"geometry_container\", \"x\", \"y\"])\n", " ds = xr.merge([ds.drop_vars(\"geometry\"), coords])\n", "\n", " # Rename `features` dimension to `station`\n", " ds = ds.rename(features=\"station\")\n", "\n", " # Mask values with a flag then drop flag variable\n", " for key in ds.data_vars:\n", " if key.endswith(\"_FLAG\"):\n", " valid = ds[key].isnull()\n", " name = key.replace(\"_FLAG\", \"\")\n", " ds[name] = ds[name].where(valid)\n", " ds = ds.drop_vars(key)\n", "\n", " # Convert wind gust from tens of degrees to degrees\n", " if \"DIRECTION_MAX_GUST\" in ds.data_vars:\n", " ds[\"DIRECTION_MAX_GUST\"] *= 10\n", "\n", " # Assign units to variables\n", " # TODO: Add long_name and description from https://climate.weather.gc.ca/glossary_e.html\n", " attrs = {\n", " \"MEAN_TEMPERATURE\": {\n", " \"units\": \"degC\",\n", " \"standard_name\": \"air_temperature\",\n", " \"cell_methods\": \"time: mean within days\",\n", " },\n", " \"MIN_TEMPERATURE\": {\n", " \"units\": \"degC\",\n", " \"standard_name\": \"air_temperature\",\n", " \"cell_methods\": \"time: min within days\",\n", " },\n", " \"MAX_TEMPERATURE\": {\n", " \"units\": \"degC\",\n", " \"standard_name\": \"air_temperature\",\n", " \"cell_methods\": \"time: max within days\",\n", " },\n", " \"TOTAL_PRECIPITATION\": {\n", " \"units\": \"mm/day\",\n", " \"standard_name\": \"precipitation_flux\",\n", " },\n", " \"TOTAL_RAIN\": {\n", " \"units\": \"mm/day\",\n", " },\n", " \"TOTAL_SNOW\": {\"units\": \"mm/day\", \"standard_name\": \"solid_precipitation_flux\"},\n", " \"SNOW_ON_GROUND\": {\"units\": \"cm\", \"standard_name\": \"surface_snow_thickness\"},\n", " \"DIRECTION_MAX_GUST\": {\n", " \"units\": \"degree\",\n", " \"standard_name\": \"wind_gust_from_direction\",\n", " },\n", " \"SPEED_MAX_GUST\": {\n", " \"units\": \"km/h\",\n", " \"standard_name\": \"wind_speed_of_gust\",\n", " \"cell_methods\": \"time: max within days\",\n", " },\n", " \"COOLING_DEGREE_DAYS\": {\"units\": \"degC days\"},\n", " \"HEATING_DEGREE_DAYS\": {\"units\": \"degC days\"},\n", " \"MIN_REL_HUMIDITY\": {\n", " \"units\": \"%\",\n", " \"standard_name\": \"relative_humidity\",\n", " \"cell_methods\": \"time: min within days\",\n", " },\n", " \"MAX_REL_HUMIDITY\": {\n", " \"units\": \"%\",\n", " \"standard_name\": \"relative_humidity\",\n", " \"cell_methods\": \"time: max within days\",\n", " },\n", " }\n", "\n", " for key in ds.data_vars:\n", " ds[key].attrs.update(attrs.get(key, {}))\n", "\n", " # Try to squeeze arrays of identical values along the time dimension\n", " for key in [\"STATION_NAME\", \"CLIMATE_IDENTIFIER\", \"PROVINCE_CODE\"]:\n", " ds[key] = squeeze_if_unique(ds[key], \"time\")\n", "\n", " # Reindex over continuous time series\n", " ts = pd.date_range(ds.time[0].values, ds.time[-1].values)\n", " return ds.reindex(time=ts)\n", "\n", "\n", "def squeeze_if_unique(da, dim):\n", " \"\"\"Squeeze dimension out of DataArray if all values are identical or masked.\n", "\n", " If a value is replicated along the time dimension, this function will return a\n", " DataArray defined only over the dimensions where values vary. If the resulting\n", " object is a scalar, it is converted to a global attribute.\n", "\n", " Parameters\n", " ----------\n", " da : xr.DataArray\n", " Input values.\n", " dim : str\n", " Dimension to squeeze if possible.\n", " \"\"\"\n", " import numpy as np\n", "\n", " def n_unique(arr):\n", " return len(set(np.unique(arr)) - {\"\"})\n", "\n", " if da.dtype == object:\n", " # Check if possible to squeeze along `dim`\n", " n = np.apply_along_axis(\n", " n_unique,\n", " da.get_axis_num(dim),\n", " da.fillna(\"\").values,\n", " )\n", "\n", " if (n == 1).all():\n", " return da.max(dim) # Should avoid returning the null value.\n", "\n", " return da\n", "\n", " # else : int, float or datetime\n", " da_filled = da.ffill(dim).bfill(dim)\n", " if (da_filled.isel({dim: 0}) == da_filled).all():\n", " return da_filled.isel({dim: 0}, drop=True)\n", "\n", " return da" ] }, { "cell_type": "code", "execution_count": 3, "id": "4", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:              (station: 1, time: 1061)\n",
       "Coordinates:\n",
       "  * station              (station) int64 0\n",
       "  * time                 (time) datetime64[ns] 1994-07-26 ... 1997-06-20\n",
       "    lon                  (station) float64 -73.58\n",
       "    lat                  (station) float64 45.5\n",
       "Data variables: (12/18)\n",
       "    id                   (station, time) object '7024745.1994.7.26' ... '7024...\n",
       "    MIN_TEMPERATURE      (station, time) float64 17.3 15.6 17.0 ... 15.7 15.6\n",
       "    MIN_REL_HUMIDITY     (station, time) float64 nan nan nan ... 78.0 38.0 35.0\n",
       "    DIRECTION_MAX_GUST   (station, time) float64 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n",
       "    CLIMATE_IDENTIFIER   (station) object '7024745'\n",
       "    STATION_NAME         (station) object 'MCTAVISH'\n",
       "    ...                   ...\n",
       "    HEATING_DEGREE_DAYS  (station, time) float64 0.0 0.0 0.0 0.0 ... 0.8 0.0 0.0\n",
       "    TOTAL_RAIN           (station, time) object nan nan nan nan ... nan nan nan\n",
       "    PROVINCE_CODE        (station) object 'QC'\n",
       "    SNOW_ON_GROUND       (station, time) object None None None ... None None\n",
       "    MAX_TEMPERATURE      (station, time) float64 26.7 23.5 21.2 ... 25.0 25.9\n",
       "    MAX_REL_HUMIDITY     (station, time) float64 nan nan nan ... 98.0 99.0 74.0
" ], "text/plain": [ "\n", "Dimensions: (station: 1, time: 1061)\n", "Coordinates:\n", " * station (station) int64 0\n", " * time (time) datetime64[ns] 1994-07-26 ... 1997-06-20\n", " lon (station) float64 -73.58\n", " lat (station) float64 45.5\n", "Data variables: (12/18)\n", " id (station, time) object '7024745.1994.7.26' ... '7024...\n", " MIN_TEMPERATURE (station, time) float64 17.3 15.6 17.0 ... 15.7 15.6\n", " MIN_REL_HUMIDITY (station, time) float64 nan nan nan ... 78.0 38.0 35.0\n", " DIRECTION_MAX_GUST (station, time) float64 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n", " CLIMATE_IDENTIFIER (station) object '7024745'\n", " STATION_NAME (station) object 'MCTAVISH'\n", " ... ...\n", " HEATING_DEGREE_DAYS (station, time) float64 0.0 0.0 0.0 0.0 ... 0.8 0.0 0.0\n", " TOTAL_RAIN (station, time) object nan nan nan nan ... nan nan nan\n", " PROVINCE_CODE (station) object 'QC'\n", " SNOW_ON_GROUND (station, time) object None None None ... None None\n", " MAX_TEMPERATURE (station, time) float64 26.7 23.5 21.2 ... 25.0 25.9\n", " MAX_REL_HUMIDITY (station, time) float64 nan nan nan ... 98.0 99.0 74.0" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "\n", "# Convert the GeoDataFrame to an xarray.Dataset\n", "# Different stations are aligned along the `station` dimension\n", "ds = preprocessing(gdf)\n", "ds" ] }, { "cell_type": "markdown", "id": "5", "metadata": {}, "source": [ "## Computing climate indicators\n", "\n", "In the next cell, we compute the monthly mean temperature from the daily observations. By default, `xclim` is very strict about missing values, marking any month with one missing value as entirely missing. Here we'll use the WMO recommendation for missing data, where a month is considered missing if there are 11 days or more missing, or 5 consecutive missing values." ] }, { "cell_type": "code", "execution_count": 4, "id": "6", "metadata": {}, "outputs": [], "source": [ "import xclim\n", "\n", "with xclim.set_options(check_missing=\"wmo\"):\n", " mtas = xclim.atmos.tg_mean(ds.MEAN_TEMPERATURE, freq=\"MS\")" ] }, { "cell_type": "code", "execution_count": 5, "id": "7", "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from matplotlib import pyplot as plt\n", "\n", "name = ds.STATION_NAME.isel(station=0).values\n", "mtas.isel(station=0).plot()\n", "plt.title(f\"Mean monthly temperature at station {name}\")\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" }, "nbdime-conflicts": { "local_diff": [ { "diff": [ { "diff": [ { "diff": [ { "key": 4, "op": "addrange", "valuelist": "6" }, { "key": 4, "length": 2, "op": "removerange" } ], "key": 0, "op": "patch" } ], "key": "version", "op": "patch" } ], "key": "language_info", "op": "patch" } ], "remote_diff": [ { "diff": [ { "diff": [ { "diff": [ { "key": 5, "op": "addrange", "valuelist": "3" }, { "key": 5, "length": 1, "op": "removerange" } ], "key": 0, "op": "patch" } ], "key": "version", "op": "patch" } ], "key": "language_info", "op": "patch" } ] } }, "nbformat": 4, "nbformat_minor": 5 }