diff --git a/GoogleFloodHub/src/analyse/__init__.py b/GoogleFloodHub/src/analyse/__init__.py index 1a7714d..357cc31 100644 --- a/GoogleFloodHub/src/analyse/__init__.py +++ b/GoogleFloodHub/src/analyse/__init__.py @@ -19,6 +19,7 @@ from .plots import plot_Niger_river_downstream_flow_stat from .plots import plot_reforecast from .plots import plot_reanalysis +from .plots import add_return_periods from .tests import assert_same_coord_system print('GoogleFloodHub-data-analyser initialized\n') \ No newline at end of file diff --git a/GoogleFloodHub/src/extract_GRRR.ipynb b/GoogleFloodHub/src/extract_GRRR.ipynb index 476e345..a589e9f 100644 --- a/GoogleFloodHub/src/extract_GRRR.ipynb +++ b/GoogleFloodHub/src/extract_GRRR.ipynb @@ -1226,7 +1226,7 @@ }, { "cell_type": "code", - "execution_count": 260, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1344,43 +1344,43 @@ }, { "cell_type": "code", - "execution_count": 259, + "execution_count": 264, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0 ['ML0506']\n", - "1 ['ML0201', 'ML0207']\n", - "2 ['ML0201']\n", - "3 ['ML0406']\n", - "4 ['ML0206', 'ML0401']\n", - "5 ['ML0206']\n", - "6 ['ML0203', 'ML0204']\n", - "7 ['ML0202', 'ML0305']\n", - "8 ['ML0303', 'ML0301', 'ML0305']\n", - "9 ['ML0306']\n", - "10 ['ML0506']\n", - "11 ['ML0507']\n", - "12 ['ML0403']\n", - "13 ['ML0406']\n", - "14 ['ML0206', 'ML0401', 'ML0406']\n", - "15 ['ML0204']\n" + "0 ds_reforecast_1120641660 ['ML0506']\n", + "1 ds_reforecast_1120650110 ['ML0201', 'ML0207']\n", + "2 ds_reforecast_1120661040 ['ML0201']\n", + "3 ds_reforecast_1120679780 ['ML0406']\n", + "4 ds_reforecast_1120689830 ['ML0206', 'ML0401']\n", + "5 ds_reforecast_1120705070 ['ML0206']\n", + "6 ds_reforecast_1120737100 ['ML0203', 'ML0204']\n", + "7 ds_reforecast_1120739110 ['ML0202', 'ML0305']\n", + "8 ds_reforecast_1120758950 ['ML0303', 'ML0301', 'ML0305']\n", + "9 ds_reforecast_1120766460 ['ML0306']\n", + "10 ds_reforecast_1121890140 ['ML0506']\n", + "11 ds_reforecast_1121893090 ['ML0507']\n", + "12 ds_reforecast_1121895840 ['ML0403']\n", + "13 ds_reforecast_1121900350 ['ML0406']\n", + "14 ds_reforecast_1121905290 ['ML0206', 'ML0401', 'ML0406']\n", + "15 ds_reforecast_1121919510 ['ML0204']\n" ] } ], "source": [ "# loop through all datasets and print out all administrative unit names\n", "idx = 0\n", - "for ds in dict_datasets.values():\n", - " print(idx, ds.attrs['admin_unit'])\n", + "for hybas, ds in dict_datasets.items():\n", + " print(idx, hybas, ds.attrs['admin_unit'])\n", " idx += 1" ] }, { "cell_type": "code", - "execution_count": 261, + "execution_count": 266, "metadata": {}, "outputs": [ { @@ -1404,214 +1404,10 @@ "aggregating 14/15: ML0201\n", "aggregating 15/15: ML0206\n" ] - }, - { - "data": { - "text/plain": [ - "{'ML0207': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 0.8396 0.9069 0.9403 ... 2.022 2.051 2.277\n", - " Attributes:\n", - " latitude: 14.277083333332143\n", - " longitude: -6.9270833333361\n", - " gauge_id: 1120650110\n", - " admin_unit: ['ML0201', 'ML0207'],\n", - " 'ML0406': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 258.6 258.3 253.9 ... 363.2 388.2 385.6\n", - " Attributes:\n", - " latitude: 13.493749999998954\n", - " longitude: -6.202083333336134\n", - " gauge_id: 1120679780\n", - " admin_unit: ['ML0406'],\n", - " 'ML0203': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 159.5 161.9 159.9 ... 313.0 343.2 343.4\n", - " Attributes:\n", - " latitude: 12.018749999998988\n", - " longitude: -8.322916666669414\n", - " gauge_id: 1120737100\n", - " admin_unit: ['ML0203', 'ML0204'],\n", - " 'ML0303': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 12.7 12.42 12.39 ... 21.0 20.87 20.88\n", - " Attributes:\n", - " latitude: 11.427083333332233\n", - " longitude: -6.581250000002682\n", - " gauge_id: 1120758950\n", - " admin_unit: ['ML0303', 'ML0301', 'ML0305'],\n", - " 'ML0301': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 12.7 12.42 12.39 ... 21.0 20.87 20.88\n", - " Attributes:\n", - " latitude: 11.427083333332233\n", - " longitude: -6.581250000002682\n", - " gauge_id: 1120758950\n", - " admin_unit: ['ML0303', 'ML0301', 'ML0305'],\n", - " 'ML0306': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 45.41 42.74 41.67 ... 92.15 82.95 84.3\n", - " Attributes:\n", - " latitude: 11.22291666666553\n", - " longitude: -8.485416666669321\n", - " gauge_id: 1120766460\n", - " admin_unit: ['ML0306'],\n", - " 'ML0204': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 305.8 302.0 299.3 ... 488.3 538.5 535.4\n", - " Attributes:\n", - " latitude: 12.018749999998988\n", - " longitude: -8.322916666669414\n", - " gauge_id: 1120737100\n", - " admin_unit: ['ML0203', 'ML0204'],\n", - " 'ML0305': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 18.4 17.84 17.56 ... 28.08 29.55 31.36\n", - " Attributes:\n", - " latitude: 11.977083333332189\n", - " longitude: -6.360416666669494\n", - " gauge_id: 1120739110\n", - " admin_unit: ['ML0202', 'ML0305'],\n", - " 'ML0507': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 211.4 212.8 212.6 ... 297.6 318.9 313.9\n", - " Attributes:\n", - " latitude: 14.131249999998944\n", - " longitude: -5.039583333336168\n", - " gauge_id: 1121893090\n", - " admin_unit: ['ML0507'],\n", - " 'ML0202': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 18.4 17.84 17.56 ... 28.08 29.55 31.36\n", - " Attributes:\n", - " latitude: 11.977083333332189\n", - " longitude: -6.360416666669494\n", - " gauge_id: 1120739110\n", - " admin_unit: ['ML0202', 'ML0305'],\n", - " 'ML0403': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 231.7 231.5 227.4 ... 347.0 366.4 366.0\n", - " Attributes:\n", - " latitude: 13.956249999998818\n", - " longitude: -5.360416666669494\n", - " gauge_id: 1121895840\n", - " admin_unit: ['ML0403'],\n", - " 'ML0506': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 298.7 299.2 291.1 ... 230.1 248.3 248.2\n", - " Attributes:\n", - " latitude: 14.506249999999\n", - " longitude: -4.206250000002797\n", - " gauge_id: 1120641660\n", - " admin_unit: ['ML0506'],\n", - " 'ML0401': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 272.7 272.6 267.4 ... 386.4 417.4 418.3\n", - " Attributes:\n", - " latitude: 13.210416666665594\n", - " longitude: -7.07708333333602\n", - " gauge_id: 1120689830\n", - " admin_unit: ['ML0206', 'ML0401'],\n", - " 'ML0201': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 0.8396 0.9069 0.9403 ... 2.022 2.051 2.277\n", - " Attributes:\n", - " latitude: 14.277083333332143\n", - " longitude: -6.9270833333361\n", - " gauge_id: 1120650110\n", - " admin_unit: ['ML0201', 'ML0207'],\n", - " 'ML0206': \n", - " Dimensions: (issue_time: 2738)\n", - " Coordinates:\n", - " * issue_time (issue_time) datetime64[ns] 2016-01-01 ... 2023-06-30\n", - " lead_time timedelta64[ns] 7 days\n", - " actual_date (issue_time) datetime64[ns] 2016-01-08 ... 2023-07-07\n", - " Data variables:\n", - " streamflow (issue_time) float32 307.4 303.4 299.4 ... 504.1 531.8 526.6\n", - " Attributes:\n", - " latitude: 13.210416666665594\n", - " longitude: -7.07708333333602\n", - " gauge_id: 1120689830\n", - " admin_unit: ['ML0206', 'ML0401']}" - ] - }, - "execution_count": 261, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "aggregate_per_admin_unit(dict_datasets)" + "dict_datasets_agg = aggregate_per_admin_unit(dict_datasets)" ] }, { @@ -1673,6 +1469,141 @@ "print(ds_actual_dates)" ] }, + { + "cell_type": "code", + "execution_count": 278, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List, Tuple\n", + "import datetime\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import pandas as pd\n", + "import xarray as xr\n", + "# make a plot to visualise the aggregated data for a certain admin unit\n", + "# by plotting the individual gauges in the admin unit and the aggregated data\n", + "# which should nicely visualise the aggregation process, while also serving as a check\n", + "def plot_aggregated_reforecast(\n", + " issue_time_start_date: str, issue_time_end_date: str,\n", + " reforecasts: List[xr.Dataset],\n", + " ds_aggregated: xr.Dataset\n", + " ) -> None:\n", + " \"\"\" \n", + " Plots the gauges in an administrative unit and the aggregated data\n", + " for that same administrative unit, showing if the aggregation process\n", + " was processed correctly. (In contrast to plot_reforecast(), this function\n", + " does not plot distinct lead times, since they're already filtered out\n", + " in the aggregation process.)\n", + "\n", + " :param issue_time_start_date: start date for the issue time\n", + " :param issue_time_end_date: end date for the issue time\n", + " :param reforecasts: list of xarray datasets for individual gauges\n", + " :param ds_aggregated: aggregated xarray dataset for the admin unit\n", + " :param admin_unit: administrative unit identifier\n", + " :param ds_return_periods: return periods dataset\n", + " :param thresholds: list of thresholds to add return periods for\n", + " \"\"\"\n", + " fig, ax = plt.subplots(figsize = (20, 4))\n", + " \n", + " # plot individual gauges in the administrative unit\n", + " for ds_reforecast in reforecasts:\n", + " issue_times = ds_reforecast.sel(issue_time = \\\n", + " slice(issue_time_start_date, issue_time_end_date))['issue_time']\n", + "\n", + " for issue_time in issue_times: # select issue time slice\n", + " issue_time_slice = ds_reforecast.sel(issue_time = issue_time)\n", + "\n", + " ax.plot([pd.to_datetime(issue_time.values)] * \\\n", + " len(issue_time_slice['streamflow'].values),\n", + " issue_time_slice['streamflow'].values,\n", + " alpha = 0.5, # make the lines little bit transparent\n", + " label = f'gauge {ds_reforecast.attrs[\"gauge_id\"]}'\n", + " )\n", + " \n", + " # plot the aggregated timeseries (usually the maximum)\n", + " aggregated_issue_times = ds_aggregated.sel(issue_time = \\\n", + " slice(issue_time_start_date, issue_time_end_date))['issue_time']\n", + " for issue_time in aggregated_issue_times:\n", + " issue_time_slice = ds_aggregated.sel(issue_time = issue_time)\n", + " streamflow_values = issue_time_slice['streamflow'].values\n", + " # if there is only one value, it is not a list, so make it a list\n", + " if not hasattr(streamflow_values, '__len__'):\n", + " streamflow_values = [streamflow_values]\n", + "\n", + " ax.plot([pd.to_datetime(issue_time.values)] * \\\n", + " len(streamflow_values),\n", + " streamflow_values,\n", + " color = '#092448',\n", + " linewidth = 2,\n", + " label = 'aggregated',\n", + " zorder = 3 # make sure the aggregated data is on top\n", + " )\n", + "\n", + " plt.legend(loc = 'upper right')\n", + " plt.show()\n", + "\n", + "\n", + "from collections import Counter\n", + "def get_datasets_unit_with_most_gauges(\n", + " dict_ds: Dict[str, xr.Dataset]\n", + " ) -> Tuple[List[xr.Dataset], str]:\n", + " \"\"\"\n", + " Finds the administrative unit with the most gauges and returns \n", + " the datasets belonging to that unit in a list\n", + "\n", + " :param dict_ds: dict with the datasets\n", + " :return: list with the datasets of the admin unit with most gauges and unit name\n", + " \"\"\"\n", + " # https://docs.python.org/3/library/collections.html#collections.Counter\n", + " admin_counter = Counter()\n", + " for ds in dict_datasets.values():\n", + " for admin_unit in ds.attrs['admin_unit']:\n", + " admin_counter[admin_unit] += 1\n", + "\n", + " admin_unit_most_gauges = admin_counter.most_common(1)[0][0]\n", + "\n", + " gauges = [ds for ds in dict_datasets.values() if \\\n", + " admin_unit_most_gauges in ds.attrs['admin_unit']]\n", + " return gauges, admin_unit_most_gauges" + ] + }, + { + "cell_type": "code", + "execution_count": 279, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "len() of unsized object", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[279], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m ds_admin_unit_most_gauges, admin_unit_most_gauges \u001b[38;5;241m=\u001b[39m \\\n\u001b[0;32m 2\u001b[0m get_datasets_unit_with_most_gauges(dict_datasets)\n\u001b[1;32m----> 3\u001b[0m \u001b[43mplot_aggregated_reforecast\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m2018-05-01\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m2018-10-30\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mds_admin_unit_most_gauges\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mdict_datasets_agg\u001b[49m\u001b[43m[\u001b[49m\u001b[43madmin_unit_most_gauges\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[1;32mIn[278], line 58\u001b[0m, in \u001b[0;36mplot_aggregated_reforecast\u001b[1;34m(issue_time_start_date, issue_time_end_date, reforecasts, ds_aggregated)\u001b[0m\n\u001b[0;32m 54\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(streamflow_values, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__len__\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[0;32m 55\u001b[0m streamflow_values \u001b[38;5;241m=\u001b[39m [streamflow_values]\n\u001b[0;32m 57\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot([pd\u001b[38;5;241m.\u001b[39mto_datetime(issue_time\u001b[38;5;241m.\u001b[39mvalues)] \u001b[38;5;241m*\u001b[39m \\\n\u001b[1;32m---> 58\u001b[0m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mstreamflow_values\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[0;32m 59\u001b[0m streamflow_values,\n\u001b[0;32m 60\u001b[0m color \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m#092448\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m 61\u001b[0m linewidth \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m,\n\u001b[0;32m 62\u001b[0m label \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124maggregated\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[0;32m 63\u001b[0m zorder \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m \u001b[38;5;66;03m# make sure the aggregated data is on top\u001b[39;00m\n\u001b[0;32m 64\u001b[0m )\n\u001b[0;32m 66\u001b[0m plt\u001b[38;5;241m.\u001b[39mlegend(loc \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mupper right\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m 67\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[1;31mTypeError\u001b[0m: len() of unsized object" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds_admin_unit_most_gauges, admin_unit_most_gauges = \\\n", + " get_datasets_unit_with_most_gauges(dict_datasets)\n", + "plot_aggregated_reforecast('2018-05-01', '2018-10-30',\n", + " ds_admin_unit_most_gauges,\n", + " dict_datasets_agg[admin_unit_most_gauges])" + ] + }, { "cell_type": "code", "execution_count": 263,