From f3f4ded5c2823638aaeadb4d65e600289685ff00 Mon Sep 17 00:00:00 2001 From: Robbi Bishop-Taylor Date: Wed, 30 Oct 2024 03:49:53 +0000 Subject: [PATCH] Add model phases to notebook --- docs/notebooks/Model_tides.ipynb | 448 ++++++++++++++++++++++++++++++- 1 file changed, 441 insertions(+), 7 deletions(-) diff --git a/docs/notebooks/Model_tides.ipynb b/docs/notebooks/Model_tides.ipynb index b7630d3..d3b3064 100644 --- a/docs/notebooks/Model_tides.ipynb +++ b/docs/notebooks/Model_tides.ipynb @@ -6,12 +6,15 @@ "source": [ "# Modelling tides\n", "\n", - "**This guide demonstrates how to use the [`model_tides`](../../api/#eo_tides.model.model_tides) function from the [`eo_tides.model`](../../api/#eo_tides.model) module to model tide heights at multiple coordinates or time steps, using one or more ocean tide models.**\n", + "**This guide demonstrates how to use the [`model_tides`](../../api/#eo_tides.model.model_tides) and [`model_phases`](../../api/#eo_tides.model.model_phases) functions from the [`eo_tides.model`](../../api/#eo_tides.model) module to model tide heights at multiple coordinates or time steps, using one or more ocean tide models.**\n", "\n", "The `model_tides` function supports tide modelling based on a wide range of ocean tide models using a single line of code, parallelising this modelling where possible and returning data in a standardised `pandas.Dataframe` format.\n", "The `model_tides` function can be used independently of Earth observation (EO) data, e.g. for any application where you need to generate a time series of tide heights.\n", "However, it also underpins the more complex EO-related functions demonstrated in [Combining tides with satellite data](../Satellite_data).\n", "\n", + "The `model_phases` function can be used to model the phase of the tide at any location and time.\n", + "This can be used to classify tides into high and low tide observations, or determine whether the tide was rising (i.e. flow tide) or falling (i.e. ebb tide).\n", + "\n", "
\n", "

Tip

\n", "

\n", @@ -298,7 +301,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 3/3 [00:00<00:00, 20.51it/s]\n" + "100%|██████████| 3/3 [00:00<00:00, 22.93it/s]\n" ] }, { @@ -491,7 +494,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 2/2 [00:00<00:00, 16.25it/s]\n" + "100%|██████████| 2/2 [00:00<00:00, 17.37it/s]\n" ] }, { @@ -695,7 +698,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 2/2 [00:00<00:00, 17.00it/s]\n" + "100%|██████████| 2/2 [00:00<00:00, 17.63it/s]\n" ] }, { @@ -795,7 +798,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 6/6 [00:00<00:00, 28.57it/s]\n" + "100%|██████████| 6/6 [00:00<00:00, 32.15it/s]\n" ] }, { @@ -981,7 +984,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 6/6 [00:00<00:00, 29.29it/s]\n" + "100%|██████████| 6/6 [00:00<00:00, 25.30it/s]\n" ] }, { @@ -1087,13 +1090,444 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using model_phases\n", + "\n", + "In addition to tide height, it can be useful to obtain information about the phase of the tide at each observation. For example, we may want to know whether tides were low or high, or whether water levels were rising (\"flow\" tide) or falling (\"ebb\" tide).\n", + "Tide phase data can provide valuable contextual information for interpreting satellite imagery, particularly in tidal flat or mangrove forest environments where water may remain in the landscape for considerable time after the tidal peak.\n", + "\n", + "The `model_phases` function calculates ebb and low phases by modelling tides once for the requested timesteps, and again after subtracting a small time offset (by default, 15 minutes).\n", + "If tides increased over this period, they are assigned as \"flow\"; if they decreased, they are assigned as \"ebb\".\n", + "Tides are considered \"high\" if equal or greater than 0 metres tide height, otherwise \"low\".\n", + "\n", + "We can run `model_phases` by providing `x` and `y` coordinates and `time`:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using EOT20\n", + "Modelling tides using EOT20\n" + ] + }, + { + "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", + "
tide_modeltide_phase
timexy
2018-01-01 00:00:00122.2186-18.0008EOT20high-flow
2018-01-01 05:00:00122.2186-18.0008EOT20low-ebb
2018-01-01 10:00:00122.2186-18.0008EOT20low-flow
2018-01-01 15:00:00122.2186-18.0008EOT20high-ebb
2018-01-01 20:00:00122.2186-18.0008EOT20low-ebb
\n", + "
" + ], + "text/plain": [ + " tide_model tide_phase\n", + "time x y \n", + "2018-01-01 00:00:00 122.2186 -18.0008 EOT20 high-flow\n", + "2018-01-01 05:00:00 122.2186 -18.0008 EOT20 low-ebb\n", + "2018-01-01 10:00:00 122.2186 -18.0008 EOT20 low-flow\n", + "2018-01-01 15:00:00 122.2186 -18.0008 EOT20 high-ebb\n", + "2018-01-01 20:00:00 122.2186 -18.0008 EOT20 low-ebb" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from eo_tides.model import model_phases\n", + "\n", + "model_phases(\n", + " x=122.2186,\n", + " y=-18.0008,\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-02\", freq=\"5h\"),\n", + " directory=directory,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `pandas.DataFrame` contains:\n", + "\n", + "* `time`, `x`, `y`: Our original input timesteps and coordinates\n", + "* `tide_model`: a column listing the tide model used\n", + "* `tide_phase`: the modelled tidal phase (\"high-flow\", \"high-ebb\", \"low-ebb\", \"low-flow\").\n", + "\n", + "To change the time offset used to calculate tide phase from the 15 minute default, pass a custom value to `time_offset`:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using EOT20\n", + "Modelling tides using EOT20\n" + ] + }, + { + "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", + "
tide_modeltide_phase
timexy
2018-01-01 00:00:00122.2186-18.0008EOT20high-flow
2018-01-01 05:00:00122.2186-18.0008EOT20low-ebb
2018-01-01 10:00:00122.2186-18.0008EOT20low-flow
2018-01-01 15:00:00122.2186-18.0008EOT20high-ebb
2018-01-01 20:00:00122.2186-18.0008EOT20low-ebb
\n", + "
" + ], + "text/plain": [ + " tide_model tide_phase\n", + "time x y \n", + "2018-01-01 00:00:00 122.2186 -18.0008 EOT20 high-flow\n", + "2018-01-01 05:00:00 122.2186 -18.0008 EOT20 low-ebb\n", + "2018-01-01 10:00:00 122.2186 -18.0008 EOT20 low-flow\n", + "2018-01-01 15:00:00 122.2186 -18.0008 EOT20 high-ebb\n", + "2018-01-01 20:00:00 122.2186 -18.0008 EOT20 low-ebb" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_phases(\n", + " x=122.2186,\n", + " y=-18.0008,\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-02\", freq=\"5h\"),\n", + " time_offset='30 min',\n", + " directory=directory,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Optionally, we can choose to return tide heights too by providing `return_tides=True`.\n", + "This will include a new `tide_height` column in our dataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using EOT20\n", + "Modelling tides using EOT20\n" + ] + }, + { + "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", + "
tide_modeltide_heighttide_phase
timexy
2018-01-01 00:00:00122.2186-18.0008EOT201.229286high-flow
2018-01-01 00:30:00122.2186-18.0008EOT201.763103high-flow
2018-01-01 01:00:00122.2186-18.0008EOT202.162897high-flow
2018-01-01 01:30:00122.2186-18.0008EOT202.405015high-flow
2018-01-01 02:00:00122.2186-18.0008EOT202.476600high-flow
\n", + "
" + ], + "text/plain": [ + " tide_model tide_height tide_phase\n", + "time x y \n", + "2018-01-01 00:00:00 122.2186 -18.0008 EOT20 1.229286 high-flow\n", + "2018-01-01 00:30:00 122.2186 -18.0008 EOT20 1.763103 high-flow\n", + "2018-01-01 01:00:00 122.2186 -18.0008 EOT20 2.162897 high-flow\n", + "2018-01-01 01:30:00 122.2186 -18.0008 EOT20 2.405015 high-flow\n", + "2018-01-01 02:00:00 122.2186 -18.0008 EOT20 2.476600 high-flow" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "phase_df = model_phases(\n", + " x=122.2186,\n", + " y=-18.0008,\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-02\", freq=\"30min\"),\n", + " return_tides=True,\n", + " directory=directory,\n", + ")\n", + "\n", + "# Print outputs\n", + "phase_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we plot our `tide_height` and `tide_phase` data, we can see it follows a logical progression from \"high-flow\" > \"high-ebb\" > \"low-ebb\" > \"low-flow\":" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot tide heights\n", + "ax = phase_df.droplevel([\"x\", \"y\"]).tide_height.plot(color=\"black\")\n", + "\n", + "# Define plotting parameters for each phase\n", + "plot_params = {\n", + " \"high-flow\": {\"marker\": \"^\", \"color\": \"tab:blue\"},\n", + " \"high-ebb\": {\"marker\": \"v\", \"color\": \"tab:blue\"},\n", + " \"low-flow\": {\"marker\": \"^\", \"color\": \"tab:orange\"},\n", + " \"low-ebb\": {\"marker\": \"v\", \"color\": \"tab:orange\"},\n", + "}\n", + "\n", + "# Plot each phase\n", + "for phase, params in plot_params.items():\n", + " phase_df.droplevel([\"x\", \"y\"]).query(f\"tide_phase == '{phase}'\").tide_height.plot(\n", + " marker=params[\"marker\"],\n", + " linewidth=0.0,\n", + " color=params[\"color\"],\n", + " markersize=10,\n", + " label=phase,\n", + " )\n", + "ax.legend();" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Next steps\n", "\n", - "Now that we have demonstrated how to model tides, we can learn how to [combine modelled tides with satellite data](../Satellite_data) for further analysis." + "Now that we have demonstrated how to model tide heights and phases, we can learn how to [combine modelled tides with satellite data](../Satellite_data) for further analysis." ] } ],