{ "cells": [ { "cell_type": "markdown", "id": "326cef8d-1d19-4aaa-8234-38cf31f84bc8", "metadata": {}, "source": [ "# Guideline for how to get started when using data in CSV files" ] }, { "cell_type": "markdown", "id": "c1b5906d-b5c8-4fc5-b76f-14f22448be18", "metadata": {}, "source": [ "_Maybe some general remarks on working with CSV data in OpenSense?_" ] }, { "cell_type": "markdown", "id": "2ff5bc00", "metadata": {}, "source": [ "## PWS data\n", "This notebook gives an example how to get started using single PWS csv-files. The following exmaples uses a subset data from the AMS dateset published by de Vos et al. (2019). \n", "PWS data which are dowloaded using the API come as individual csv files and should also include a meta file with PWS IDs and coordinates. " ] }, { "cell_type": "code", "execution_count": 14, "id": "a7754105", "metadata": {}, "outputs": [], "source": [ "import datetime\n", "import glob\n", "import warnings\n", "\n", "import numpy as np\n", "import pandas as pd\n", "import xarray as xr\n", "\n", "warnings.simplefilter(action=\"ignore\", category=FutureWarning)" ] }, { "cell_type": "markdown", "id": "84e2dfae-160a-432c-9f6f-8bda26aff3a0", "metadata": {}, "source": [ "### Functions for checking data" ] }, { "cell_type": "markdown", "id": "5fef4176", "metadata": {}, "source": [ "It is quite frequent, that Netamo PWS have identical coordinates. This indicates that the users have not used the web interface from Netatmo correctly to place their PWS which leads to a false location information. This function is used later on to remove PWS with identical coordinates. " ] }, { "cell_type": "code", "execution_count": 15, "id": "2f13c5fb", "metadata": {}, "outputs": [], "source": [ "# Small function to remove PWS with duplicate coordinates from an xarray.Dataset\n", "def get_duplicate_coordinates(ds, id_var_name=\"id\", keep=False, lat=\"lat\", lon=\"lon\"): # noqa: D103\n", " # lat and lon can be set if a dataset does not follow our OS cenvention\n", " df_data = ds[id_var_name].to_dataframe() # assumes that there is an 'id' dimension\n", " # return a boolean series which can easily be used for indexing in the initial `ds`\n", " return df_data.duplicated(subset=[lon, lat], keep=keep)" ] }, { "cell_type": "markdown", "id": "2341289d", "metadata": {}, "source": [ "Netatmo PWS data can have a temporal resolution up to ~5 Min. However, these invervals are not exactly 5 minutes and can occasionally be a bit longer which leads to either missing time stamps in the data series or single timestamps with missing data. The following functions checks for complete time series with NaN for the missing values. Otherwise the missing dates are infilled by reindexing the dataframe.\n", "\n", "Note that this function uses specific metadata entries for the AMS PWS dataset. This function works only if all the timestamps start at at full 5 minutes. This needs to be adjusted accordingly for other datasets." ] }, { "cell_type": "code", "execution_count": 16, "id": "c91a3888-7111-46de-b424-7cfa7dd73e87", "metadata": {}, "outputs": [], "source": [ "def reindex_timestamps(df_data): # noqa: D103\n", " # check if timestamps are complete\n", " start = df_data.index[0]\n", " end = df_data.index[-1]\n", " dates = pd.date_range(start=start, end=end, freq=\"5Min\")\n", " if len(df_data.index) != len(dates):\n", " print(f\"File {fn} has missing time steps, reindexing\") # noqa: T201\n", " df_data = df_data.reindex(dates)\n", " return df_data" ] }, { "cell_type": "markdown", "id": "8b0e2076-e395-4d11-ad4a-9ecf8bd5fda3", "metadata": {}, "source": [ "### Read CSV raw data file" ] }, { "cell_type": "markdown", "id": "c8c50914-64b0-429e-96b1-d3ec0610932d", "metadata": {}, "source": [ "Let's get a list of the all the raw data files. In the next steps we will use only one file, but later we want to loop through all files." ] }, { "cell_type": "code", "execution_count": 17, "id": "a1368e14-7e1a-4020-b213-67c183785963", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['csv_cookbook_data/ams1.csv',\n", " 'csv_cookbook_data/ams2.csv',\n", " 'csv_cookbook_data/ams3.csv',\n", " 'csv_cookbook_data/ams4.csv',\n", " 'csv_cookbook_data/ams5.csv',\n", " 'csv_cookbook_data/ams6.csv',\n", " 'csv_cookbook_data/ams7.csv',\n", " 'csv_cookbook_data/ams8.csv',\n", " 'csv_cookbook_data/ams9.csv']" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fn_list = sorted(glob.glob(\"csv_cookbook_data/ams*.csv\")) # noqa: PTH207\n", "fn_list" ] }, { "cell_type": "code", "execution_count": 18, "id": "27bf150e-6d74-4ab2-a432-edd78e2e1e6f", "metadata": {}, "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", "
ams1
Time
2016-05-01 00:05:000.0
2016-05-01 00:10:000.0
2016-05-01 00:15:000.0
2016-05-01 00:20:000.0
2016-05-01 00:25:000.0
\n", "
" ], "text/plain": [ " ams1\n", "Time \n", "2016-05-01 00:05:00 0.0\n", "2016-05-01 00:10:00 0.0\n", "2016-05-01 00:15:00 0.0\n", "2016-05-01 00:20:00 0.0\n", "2016-05-01 00:25:00 0.0" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pws_data = pd.read_csv(fn_list[0], index_col=0, parse_dates=True, sep=\",\")\n", "pws_data.head()" ] }, { "cell_type": "markdown", "id": "4dcc60fa-da22-45b8-b209-a1448cf2e649", "metadata": {}, "source": [ "### Read in CSV metadata file" ] }, { "cell_type": "code", "execution_count": 19, "id": "b126133f", "metadata": {}, "outputs": [], "source": [ "# Load metadata from the Amsterdam PWS data set (showcase subset with 9 PWS)\n", "pws_meta = pd.read_csv(\"csv_cookbook_data/AMS_metadatasubset.csv\", sep=\",\")" ] }, { "cell_type": "code", "execution_count": 20, "id": "5be82826-4ffb-4b74-87bb-3523784e1e5d", "metadata": {}, "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", "
IDlonlat
0ams14.67066452.305896
1ams24.67494052.302044
2ams34.67727552.308427
3ams44.67755452.346013
4ams54.67859352.318572
\n", "
" ], "text/plain": [ " ID lon lat\n", "0 ams1 4.670664 52.305896\n", "1 ams2 4.674940 52.302044\n", "2 ams3 4.677275 52.308427\n", "3 ams4 4.677554 52.346013\n", "4 ams5 4.678593 52.318572" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pws_meta.head()" ] }, { "cell_type": "markdown", "id": "0439e8f7-6743-412c-9275-62c791b36059", "metadata": {}, "source": [ "### Convert data from `pandas.Dataframe` to `xarray.Dataset` including metadata" ] }, { "cell_type": "markdown", "id": "d152b7fc-e7ac-42cf-846e-d90f507e8440", "metadata": {}, "source": [ "The following function converts the `pandas.Dataframe` to `xarray.Dataset` including metadata. This follows the data conventions defined in the OpenSense Cost Action (link to white paper)\n", "\n", "Note that this function uses specific metadata entries for the AMS PWS dataset. This needs to be adjusted accordingly for other dataset." ] }, { "cell_type": "code", "execution_count": 21, "id": "1469b5ff-b31a-425e-8bfa-028cd80bf6a1", "metadata": {}, "outputs": [], "source": [ "def dataframe_to_dataset(pws_data, lon, lat, elevation=None): # noqa: D103\n", " pws_data.index = pws_data.index.rename(\"time\")\n", "\n", " ds = pws_data.to_xarray().to_array(dim=\"id\")\n", "\n", " ds = ds.to_dataset(name=\"rainfall\")\n", "\n", " if elevation is None:\n", " ds = ds.assign_coords({\"elevation\": xr.full_like(ds.id, np.nan)})\n", " else:\n", " ds = ds.assign_coords({\"elevation\": elevation})\n", "\n", " ds = ds.assign_coords({\"lon\": lon})\n", " ds = ds.assign_coords({\"lat\": lat})\n", " # Important: Set the reference, otherwise the first time step is used.\n", " ds.time.encoding[\"units\"] = \"seconds since 1970-01-01 00:00:00\"\n", "\n", " # variable attributes\n", " ds.rainfall.attrs = {\n", " \"name\": \"rainfall\",\n", " \"long_name\": \"rainfall amount per time unit\",\n", " \"units\": \"mm\",\n", " \"coverage_contant_type\": \"physicalMeasurement\",\n", " }\n", "\n", " # coordiate attributes\n", " ds.time.attrs = {\"unit\": \"seconds since 1970-01-01 00:00:00\"}\n", " ds.lon.attrs = {\"units\": \"degrees in WGS84 projection\"}\n", " ds.lat.attrs = {\"units\": \"degrees in WGS84 projection\"}\n", " ds.elevation.attrs = {\"units\": \"meters\", \"longname\": \"meters_above_sea\"}\n", "\n", " # global Atrributes\n", " ds.attrs[\"title\"] = \"PWS data from Amsterdam\"\n", " ds.attrs[\n", " \"institution\"\n", " ] = \"Wageningen University and Research, Department of Environmental Sciences\"\n", " ds.attrs[\"history\"] = \"Subset of the orignal PWS dataset from de Vos et al. (2019)\"\n", " ds.attrs[\"references\"] = \"https://doi.org/10.1029/2019GL083731\"\n", " ds.attrs[\"date_created\"] = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n", " ds.attrs[\"Conventions\"] = \"OpenSense-0.1\"\n", " ds.attrs[\n", " \"license restrictions\"\n", " ] = \"CC-BY 4.0 https://creativecommons.org/licenses/by/4.0/\"\n", " ds.attrs[\"location\"] = \"Amsterdam (NL)\"\n", " ds.attrs[\"source\"] = \"Netatmo PWS\"\n", " ds.attrs[\"comment\"] = \"\"\n", "\n", " return ds" ] }, { "cell_type": "markdown", "id": "79da101b-0263-4ad6-8840-2bc66eedebe9", "metadata": {}, "source": [ "### Parse raw data and convert to `xarray.Dataset` with metadata" ] }, { "cell_type": "markdown", "id": "8f3d4434-8970-4b0b-8ae4-20fe80226103", "metadata": {}, "source": [ "PWS ams1 has single timestamps with missing data, PWS ams2, ams6 and ams7 have empty timestemps (which corresponds to NaN). " ] }, { "cell_type": "code", "execution_count": 22, "id": "bf304368", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2016-05-01 00:05:00\n", "File csv_cookbook_data/ams1.csv has missing time steps, reindexing\n", "ams1 has 0 % missing values\n", "2016-05-01 00:05:00\n", "ams2 has 100 % missing values\n", "2016-05-01 17:30:00\n", "ams3 has 4 % missing values\n", "2016-05-01 00:05:00\n", "ams4 has 1 % missing values\n", "2016-05-01 00:05:00\n", "ams5 has 100 % missing values\n", "2016-05-01 00:05:00\n", "ams6 has 4 % missing values\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2016-05-01 00:05:00\n", "ams7 has 100 % missing values\n", "2016-05-01 00:05:00\n", "ams8 has 100 % missing values\n", "2016-05-01 00:05:00\n", "ams9 has 100 % missing values\n" ] } ], "source": [ "ds_list = []\n", "for _, metadata_row in pws_meta.iterrows():\n", " fn = f\"csv_cookbook_data/{metadata_row.ID}.csv\"\n", " pws_data = pd.read_csv(fn, index_col=0, parse_dates=True, sep=\",\")\n", " print(pws_data.index[0]) # noqa: T201\n", "\n", " duplicate_ix = pws_data.index.duplicated(keep=False).sum()\n", " if duplicate_ix > 0:\n", " print(str(duplicate_ix) + \" duplicate indices in file \" + metadata_row.ID) # noqa: T201\n", " pws_data = pws_data[~pws_data.index.duplicated(keep=\"last\")]\n", "\n", " # check if timestamps are complete\n", " # PWS ams1 has single timestamps with missing data,\n", " # PWS ams2, ams6 and ams7 have empty timestemps (which corresponds to NaN).\n", " reindex_timestamps(pws_data)\n", "\n", " # replace values smaller than 0 with np.nan\n", " # This is relevant if PWS have numerical values (e.g. -9999) for NaN\n", " pws_data[pws_data < 0] = np.nan\n", "\n", " print( # noqa: T201\n", " metadata_row.ID,\n", " \"has\",\n", " int(pws_data.isnull().sum()[0] / pws_data.index.shape[0] * 100), # noqa: PD003\n", " \"% missing values\",\n", " )\n", "\n", " # The follwoing lines convert the data to array and add the attributes\n", " # accoding to the OpenSense naming conventions\n", " ds = dataframe_to_dataset(pws_data, metadata_row.lon, metadata_row.lat)\n", " ds_list.append(ds)" ] }, { "cell_type": "markdown", "id": "f18336bc-b937-4a9a-91d4-5e5516713c8e", "metadata": {}, "source": [ "### Concatenate all individual `xarray.Datasets` to one `xarray.Dataset` with all stations" ] }, { "cell_type": "markdown", "id": "f6ba8f4d-ad9c-4dd8-be82-26a530b58b3b", "metadata": {}, "source": [ "PWS ams8 and ams9 have identical coordinates. These stations will be removed using the fuction defined above when creating one `xarray.Dataset` with all stations " ] }, { "cell_type": "code", "execution_count": 23, "id": "9c8b9d12-996b-413a-9c06-42d5cd7069bc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset has 2 PWS with identical lat/lon coordinates\n" ] } ], "source": [ "# write list to one netCDF file\n", "ds_all = xr.concat(ds_list, dim=\"id\")\n", "\n", "# remove PWS with duplicate coordinates from xarray.Dataset\n", "duplicates = get_duplicate_coordinates(ds_all, lat=\"lat\", lon=\"lon\")\n", "ds_all = ds_all.sel(id=~duplicates.to_numpy())\n", "print(\"Dataset has\", duplicates.sum(), \"PWS with identical lat/lon coordinates\") # noqa: T201" ] }, { "cell_type": "code", "execution_count": 24, "id": "6061bcf6-51fe-4e6e-95a8-2f615030f19a", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset>\n",
       "Dimensions:    (time: 2879, id: 7)\n",
       "Coordinates:\n",
       "  * time       (time) datetime64[ns] 2016-05-01T00:05:00 ... 2016-05-10T23:55:00\n",
       "  * id         (id) object 'ams1' 'ams2' 'ams3' 'ams4' 'ams5' 'ams6' 'ams7'\n",
       "    elevation  (id) object nan nan nan nan nan nan nan\n",
       "    lon        (id) float64 4.671 4.675 4.677 4.678 4.679 4.679 4.679\n",
       "    lat        (id) float64 52.31 52.3 52.31 52.35 52.32 52.3 52.3\n",
       "Data variables:\n",
       "    rainfall   (id, time) float64 0.0 0.0 0.0 0.0 0.0 ... nan nan nan nan nan\n",
       "Attributes:\n",
       "    title:                 PWS data from Amsterdam\n",
       "    institution:           Wageningen University and Research, Department of ...\n",
       "    history:               Subset of the orignal PWS dataset from de Vos et a...\n",
       "    references:            https://doi.org/10.1029/2019GL083731\n",
       "    date_created:          2024-06-20 17:08:03\n",
       "    Conventions:           OpenSense-0.1\n",
       "    license restrictions:  CC-BY 4.0 https://creativecommons.org/licenses/by/...\n",
       "    location:              Amsterdam (NL)\n",
       "    source:                Netatmo PWS\n",
       "    comment:
" ], "text/plain": [ "\n", "Dimensions: (time: 2879, id: 7)\n", "Coordinates:\n", " * time (time) datetime64[ns] 2016-05-01T00:05:00 ... 2016-05-10T23:55:00\n", " * id (id) object 'ams1' 'ams2' 'ams3' 'ams4' 'ams5' 'ams6' 'ams7'\n", " elevation (id) object nan nan nan nan nan nan nan\n", " lon (id) float64 4.671 4.675 4.677 4.678 4.679 4.679 4.679\n", " lat (id) float64 52.31 52.3 52.31 52.35 52.32 52.3 52.3\n", "Data variables:\n", " rainfall (id, time) float64 0.0 0.0 0.0 0.0 0.0 ... nan nan nan nan nan\n", "Attributes:\n", " title: PWS data from Amsterdam\n", " institution: Wageningen University and Research, Department of ...\n", " history: Subset of the orignal PWS dataset from de Vos et a...\n", " references: https://doi.org/10.1029/2019GL083731\n", " date_created: 2024-06-20 17:08:03\n", " Conventions: OpenSense-0.1\n", " license restrictions: CC-BY 4.0 https://creativecommons.org/licenses/by/...\n", " location: Amsterdam (NL)\n", " source: Netatmo PWS\n", " comment: " ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ds_all" ] }, { "cell_type": "code", "execution_count": 25, "id": "97000bcf-78ea-44c4-8347-e55299b387a9", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ds_all.rainfall.cumsum(dim=\"time\").plot.line(x=\"time\", figsize=(14, 4));" ] }, { "cell_type": "markdown", "id": "944316d8-16ba-4466-a1b0-f634bebd2dcf", "metadata": {}, "source": [ "### Save data to compressed NetCDF" ] }, { "cell_type": "code", "execution_count": 26, "id": "852e4488-1241-40c5-a044-634e616066e2", "metadata": {}, "outputs": [], "source": [ "# add enconoding to compress the file\n", "myencoding = {\n", " \"rainfall\": {\n", " \"dtype\": \"int32\",\n", " \"scale_factor\": 0.001,\n", " \"zlib\": True,\n", " \"_FillValue\": -9999,\n", " \"complevel\": 3,\n", " }\n", "}\n", "\n", "ds_all.to_netcdf(\"AMS_PWS_subset.nc\", encoding=myencoding)" ] }, { "cell_type": "markdown", "id": "e57f44cd-697f-4e67-b951-7306dc91d69d", "metadata": {}, "source": [ "## CML data" ] }, { "cell_type": "markdown", "id": "dbe899b4-9567-4f81-a2c9-80d6f5538c2b", "metadata": {}, "source": [ "### to be added..." ] }, { "cell_type": "code", "execution_count": null, "id": "101ebb47-d490-4384-95db-1f0a42b48d8a", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.6" } }, "nbformat": 4, "nbformat_minor": 5 }