diff --git a/README.md b/README.md index 4b1287c..6853a89 100644 --- a/README.md +++ b/README.md @@ -12,9 +12,11 @@ > [!CAUTION] > This package is a work in progress, and not currently ready for operational use. -The `eo-tides` package provides tools for analysing coastal and ocean satellite earth observation data using information about ocean tides. +The `eo-tides` package provides powerful, parallelized tools for seamlessly integrating satellite Earth observation data with tide modelling. -`eo-tides` combines advanced tide modelling functionality from the [`pyTMD`](https://pytmd.readthedocs.io/en/latest/) package and integrates it with `pandas`, `xarray` and `odc-geo` to provide a powerful set of parallelised tools for integrating satellite imagery with tide data – from local, regional to continental scale. +`eo-tides` combines advanced tide modelling functionality from the [`pyTMD`](https://pytmd.readthedocs.io/en/latest/) package and integrates it with [`pandas`](https://pandas.pydata.org/docs/index.html), [`xarray`](https://docs.xarray.dev/en/stable/) and [`odc-geo`](https://odc-geo.readthedocs.io/en/latest/), providing a suite of flexible tools for efficient analysis of coastal and ocean earth observation data – from regional, continental, to global scale. + +These tools can be applied to petabytes of freely available satellite data (e.g. from [Digital Earth Australia](https://knowledge.dea.ga.gov.au/) or [Microsoft Planetary Computer](https://planetarycomputer.microsoft.com/)) loaded via Open Data Cube's [`odc-stac`](https://odc-stac.readthedocs.io/en/latest/) or [`datacube`](https://opendatacube.readthedocs.io/en/latest/) packages, supporting coastal and ocean earth observation analysis for any time period or location globally. ## Highlights @@ -23,18 +25,16 @@ The `eo-tides` package provides tools for analysing coastal and ocean satellite - 🌐 Model tides for every individual satellite pixel, producing three-dimensional "tide height" `xarray`-format datacubes that can be combined with satellite data - 🎯 Combine multiple tide models into a single locally-optimised "ensemble" model informed by satellite altimetry and satellite-observed patterns of tidal inundation - 📈 Calculate statistics describing local tide dynamics, as well as biases caused by interactions between tidal processes and satellite orbits -- 🛠️ Validate modelled tides using measured sea levels from coastal tide gauges (e.g. GESLA) - -These tools can be applied directly to petabytes of freely available satellite data (e.g. from Digital Earth Australia or Microsoft Planetary Computer) loaded via Open Data Cube's `odc-stac` or `datacube` packages, supporting coastal and ocean earth observation analysis for any time period or location globally. +- 🛠️ Validate modelled tides using measured sea levels from coastal tide gauges (e.g. [GESLA Global Extreme Sea Level Analysis](https://gesla.org/)) ## Supported tide models `eo-tides` supports [all ocean tide models supported by `pyTMD`](https://pytmd.readthedocs.io/en/latest/getting_started/Getting-Started.html#model-database). These include: +- [Empirical Ocean Tide model](https://doi.org/10.5194/essd-13-3869-2021) (`EOT20`) - [Finite Element Solution tide models](https://doi.org/10.5194/os-2020-96) (`FES2022`, `FES2014`, `FES2012`) - [TOPEX/POSEIDON global tide models](https://www.tpxo.net/global) (`TPXO10`, `TPXO9`, `TPXO8`) -- [Global Ocean Tide models](https://doi.org/10.1002/2016RG000546) (`GOT5.6`, `GOT5.5`, `GOT4.10`) -- [Empirical Ocean Tide models](https://doi.org/10.5194/essd-13-3869-2021) (`EOT20`) +- [Global Ocean Tide models](https://doi.org/10.1002/2016RG000546) (`GOT5.6`, `GOT5.5`, `GOT4.10`, `GOT4.8`, `GOT4.7`) - [Hamburg direct data Assimilation Methods for Tides models](https://doi.org/10.1002/2013JC009766) (`HAMTIDE11`) For instructions on how to set up these models for use in `eo-tides`, refer to [Setting up tide models](https://geoscienceaustralia.github.io/eo-tides/setup/). diff --git a/docs/assets/fes_productselection.jpg b/docs/assets/fes_productselection.jpg index 05b3ae7..0dbb6e7 100644 Binary files a/docs/assets/fes_productselection.jpg and b/docs/assets/fes_productselection.jpg differ diff --git a/docs/credits.md b/docs/credits.md index 2f8209a..e5167cc 100644 --- a/docs/credits.md +++ b/docs/credits.md @@ -3,22 +3,18 @@ To cite `eo-tides` in your work, please use the following software citation: ``` -Bishop-Taylor, R., Sagar, S., Phillips, C., & Newey, V. (2024). eo-tides: Tide modelling tools for large-scale satellite earth observation analysis [Computer software]. https://github.com/GeoscienceAustralia/eo-tides +Bishop-Taylor, R., Sagar, S., Phillips, C., & Newey, V. (2024). eo-tides: Tide modelling tools for large-scale satellite earth observation analysis. https://github.com/GeoscienceAustralia/eo-tides ``` -In addition, consider citing the following scientific publications where applicable: +In addition, please consider also citing the underlying [`pyTMD` Python package](https://pytmd.readthedocs.io/en/latest/) which powers the tide modelling functionality behind `eo-tides`: ``` -Bishop-Taylor, R., Sagar, S., Lymburner, L., Beaman, R.L., 2019. Between the tides: modelling the elevation of Australia's exposed intertidal zone at continental scale. Estuarine, Coastal and Shelf Science. 223, 115-128. Available: https://doi.org/10.1016/j.ecss.2019.03.006 -``` - -``` -Bishop-Taylor, R., Nanson, R., Sagar, S., Lymburner, L., 2021. Mapping Australia's dynamic coastline at mean sea level using three decades of Landsat imagery. Remote Sensing of Environment, 267, 112734. Available: https://doi.org/10.1016/j.rse.2021.112734 +Sutterley, T. C., Alley, K., Brunt, K., Howard, S., Padman, L., Siegfried, M. (2017) pyTMD: Python-based tidal prediction software. 10.5281/zenodo.5555395 ``` ## Credits -`eo-tides` builds on (and wouldn't be possible without!) fundamental tide modelling tools provided by the [`pyTMD` Python package](https://pytmd.readthedocs.io/en/latest/). The authors wish to thank Dr. Tyler Sutterley for his ongoing development and support of this incredible modelling tool. +`eo-tides` builds on (and wouldn't be possible without!) fundamental tide modelling tools provided by `pyTMD`. The authors wish to thank Dr. Tyler Sutterley for his ongoing development and support of this incredible modelling tool. Functions from `eo-tides` were originally developed in the [`Digital Earth Australia Notebooks and Tools` repository](https://github.com/GeoscienceAustralia/dea-notebooks/). The authors would like to thank all DEA Notebooks contributers and maintainers for their invaluable assistance with code review, feature suggestions and code edits. @@ -39,4 +35,6 @@ Hart-Davis Michael, Piccioni Gaia, Dettmering Denise, Schwatke Christian, Passar Hart-Davis Michael G., Piccioni Gaia, Dettmering Denise, Schwatke Christian, Passaro Marcello, Seitz Florian (2021). EOT20: a global ocean tide model from multi-mission satellite altimetry. Earth System Science Data, 13 (8), 3869-3884. +Sutterley, T. C., Markus, T., Neumann, T. A., van den Broeke, M., van Wessem, J. M., and Ligtenberg, S. R. M.: Antarctic ice shelf thickness change from multimission lidar mapping, The Cryosphere, 13, 1801–1817, https://doi.org/10.5194/tc-13-1801-2019, 2019. + diff --git a/docs/index.md b/docs/index.md index cf6a8af..876a0d5 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,5 +1,5 @@ -# `eo-tides`: Tide modelling tools for large-scale satellite earth observation analysis +# `eo-tides`: Tide modelling tools for large-scale satellite Earth observation analysis [![Release](https://img.shields.io/github/v/release/GeoscienceAustralia/eo-tides)](https://img.shields.io/github/v/release/GeoscienceAustralia/eo-tides) [![Build status](https://img.shields.io/github/actions/workflow/status/GeoscienceAustralia/eo-tides/main.yml?branch=main)](https://github.com/GeoscienceAustralia/eo-tides/actions/workflows/main.yml?query=branch%3Amain) @@ -10,9 +10,11 @@ Note: This package is a work in progress, and not currently ready for operational use. -The `eo-tides` package provides tools for analysing coastal and ocean satellite earth observation data using information about ocean tides. +The `eo-tides` package provides powerful, parallelized tools for seamlessly integrating satellite Earth observation data with tide modelling. -`eo-tides` combines advanced tide modelling functionality from the [`pyTMD`](https://pytmd.readthedocs.io/en/latest/) package and integrates it with `pandas`, `xarray` and `odc-geo` to provide a powerful set of parallelised tools for integrating satellite imagery with tide data – from local, regional to continental scale. +`eo-tides` combines advanced tide modelling functionality from the [`pyTMD`](https://pytmd.readthedocs.io/en/latest/) package and integrates it with [`pandas`](https://pandas.pydata.org/docs/index.html), [`xarray`](https://docs.xarray.dev/en/stable/) and [`odc-geo`](https://odc-geo.readthedocs.io/en/latest/), providing a suite of flexible tools for efficient analysis of coastal and ocean earth observation data – from regional, continental, to global scale. + +These tools can be applied to petabytes of freely available satellite data (e.g. from [Digital Earth Australia](https://knowledge.dea.ga.gov.au/) or [Microsoft Planetary Computer](https://planetarycomputer.microsoft.com/)) loaded via Open Data Cube's [`odc-stac`](https://odc-stac.readthedocs.io/en/latest/) or [`datacube`](https://opendatacube.readthedocs.io/en/latest/) packages, supporting coastal and ocean earth observation analysis for any time period or location globally. ## Highlights @@ -21,18 +23,16 @@ The `eo-tides` package provides tools for analysing coastal and ocean satellite - 🌐 Model tides for every individual satellite pixel, producing three-dimensional "tide height" `xarray`-format datacubes that can be combined with satellite data - 🎯 Combine multiple tide models into a single locally-optimised "ensemble" model informed by satellite altimetry and satellite-observed patterns of tidal inundation - 📈 Calculate statistics describing local tide dynamics, as well as biases caused by interactions between tidal processes and satellite orbits -- 🛠️ Validate modelled tides using measured sea levels from coastal tide gauges (e.g. GESLA) - -These tools can be applied directly to petabytes of freely available satellite data (e.g. from Digital Earth Australia or Microsoft Planetary Computer) loaded via Open Data Cube's `odc-stac` or `datacube` packages, supporting coastal and ocean earth observation analysis for any time period or location globally. +- 🛠️ Validate modelled tides using measured sea levels from coastal tide gauges (e.g. [GESLA Global Extreme Sea Level Analysis](https://gesla.org/)) ## Supported tide models `eo-tides` supports [all ocean tide models supported by `pyTMD`](https://pytmd.readthedocs.io/en/latest/getting_started/Getting-Started.html#model-database). These include: +- [Empirical Ocean Tide model](https://doi.org/10.5194/essd-13-3869-2021) (`EOT20`) - [Finite Element Solution tide models](https://doi.org/10.5194/os-2020-96) (`FES2022`, `FES2014`, `FES2012`) - [TOPEX/POSEIDON global tide models](https://www.tpxo.net/global) (`TPXO10`, `TPXO9`, `TPXO8`) -- [Global Ocean Tide models](https://doi.org/10.1002/2016RG000546) (`GOT5.6`, `GOT5.5`, `GOT4.10`) -- [Empirical Ocean Tide models](https://doi.org/10.5194/essd-13-3869-2021) (`EOT20`) +- [Global Ocean Tide models](https://doi.org/10.1002/2016RG000546) (`GOT5.6`, `GOT5.5`, `GOT4.10`, `GOT4.8`, `GOT4.7`) - [Hamburg direct data Assimilation Methods for Tides models](https://doi.org/10.1002/2013JC009766) (`HAMTIDE11`) For instructions on how to set up these models for use in `eo-tides`, refer to [Setting up tide models](setup.md). @@ -42,7 +42,7 @@ For instructions on how to set up these models for use in `eo-tides`, refer to [ To cite `eo-tides` in your work, please use the following citation: ``` -Bishop-Taylor, R., Sagar, S., Phillips, C., & Newey, V. (2024). eo-tides: Tide modelling tools for large-scale satellite earth observation analysis [Computer software]. https://github.com/GeoscienceAustralia/eo-tides +Bishop-Taylor, R., Sagar, S., Phillips, C., & Newey, V. (2024). eo-tides: Tide modelling tools for large-scale satellite earth observation analysis. https://github.com/GeoscienceAustralia/eo-tides ``` ## Next steps diff --git a/docs/migration.md b/docs/migration.md index 0eb7498..8b11c97 100644 --- a/docs/migration.md +++ b/docs/migration.md @@ -5,6 +5,11 @@ To migrate your code from DEA Tools to `eo-tides`, please be aware of the follow ## Breaking changes +### `model_tides` tide height column renamed + +The output tide heights column generated by the `model_tides` function (when running in the default `output_format="long"` format) has been renamed from `tide_m` to `tide_height`. +This more clearly describes the data, particularly when used in combination with `output_units="cm"` or `output_units="mm"` which returns tide heights in non-metre units. + ### Tide model directory environment variable updated The `DEA_TOOLS_TIDE_MODELS` environmental variable has been renamed to `EO_TIDES_TIDE_MODELS`. diff --git a/docs/notebooks/Model_tides.ipynb b/docs/notebooks/Model_tides.ipynb index 3490a51..efc6755 100644 --- a/docs/notebooks/Model_tides.ipynb +++ b/docs/notebooks/Model_tides.ipynb @@ -6,6 +6,34 @@ "source": [ "# Modelling tides\n", "\n", + "## Getting started\n", + "As a first step, we need to tell `eo-tides` the location of our tide model directory that contains our downloaded tide model data ([refer to the detailed setup instructions here](../setup.md) if you haven't set this up).\n", + "\n", + "We will pass this path to `eo-tides` functions using the `directory` parameter.\n", + "\n", + "
\n", + " \n", + "**Note:** Update the `directory` path below to point to the location of your own tide model directory.\n", + "\n", + "
\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "directory = \"../../tests/data/tide_models_tests\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "## Using \"model_tides\"\n", "\n", "To model tide heights for a specific location and set of timesteps, we can use the `eo_tides.model.model_tides` function. \n", @@ -14,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "tags": [] }, @@ -50,7 +78,7 @@ " \n", " \n", " tide_model\n", - " tide_m\n", + " tide_height\n", " \n", " \n", " time\n", @@ -101,16 +129,16 @@ "" ], "text/plain": [ - " tide_model tide_m\n", - "time x y \n", - "2018-01-01 00:00:00 122.2186 -18.0008 FES2014 1.285507\n", - "2018-01-01 01:00:00 122.2186 -18.0008 FES2014 2.360098\n", - "2018-01-01 02:00:00 122.2186 -18.0008 FES2014 2.573156\n", - "2018-01-01 03:00:00 122.2186 -18.0008 FES2014 2.035899\n", - "2018-01-01 04:00:00 122.2186 -18.0008 FES2014 1.126837" + " tide_model tide_height\n", + "time x y \n", + "2018-01-01 00:00:00 122.2186 -18.0008 FES2014 1.285507\n", + "2018-01-01 01:00:00 122.2186 -18.0008 FES2014 2.360098\n", + "2018-01-01 02:00:00 122.2186 -18.0008 FES2014 2.573156\n", + "2018-01-01 03:00:00 122.2186 -18.0008 FES2014 2.035899\n", + "2018-01-01 04:00:00 122.2186 -18.0008 FES2014 1.126837" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -120,10 +148,10 @@ "import pandas as pd\n", "\n", "tide_df = model_tides(\n", - " x=122.2186, \n", - " y=-18.0008, \n", - " time=pd.date_range(\"2018-01-01\", \"2018-01-20\", freq=\"1h\"), \n", - " directory=\"../../tests/data/tide_models_tests\"\n", + " x=122.2186,\n", + " y=-18.0008,\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-20\", freq=\"1h\"),\n", + " directory=directory,\n", ")\n", "\n", "# Print outputs\n", @@ -134,15 +162,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Tide heights for each time and coordinate are included in the `tide_m` column above (representing tide height in metres relative to Mean Sea Level).\n", + "The resulting `pandas.DataFrame` contains a `tide_model` column containing the name of the tide model used (FES2014 by default), and modelled tide heights in the `tide_height` column above with values representing tide height in metres relative to Mean Sea Level.\n", "\n", "We can also plot out resulting tides to view how tides changed across this month. \n", - "By looking at the y-axis, we can see that tides ranged from a minimum of ~-4 metres up to a maximum of +4 metres relative to Mean Sea Level:" + "Looking at the y-axis, we can see that tides at this macrotidal region ranged from -4 metres up to a maximum of +4 metres relative to Mean Sea Level:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "tags": [] }, @@ -159,37 +187,57 @@ } ], "source": [ - "tide_df.reset_index([\"x\", \"y\"]).tide_m.plot();" + "tide_df.reset_index([\"x\", \"y\"], drop=True).tide_height.plot();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### \"One-to-many\" and \"one-to-one\" modes\n", + "### Multiple models\n", "\n", - "By default, the `model_tides` function operates in **\"one-to-many\"** mode, which will model tides for every requested timestep, at every requested location.\n", - "For example, if we provided five x, y coordinates and five timesteps, the function would return:\n", - "```\n", - "5 locations * 5 timesteps = 25 modelled tides\n", - "```\n", + "By default, `model_tides` will model tides using the FES2014 tide model. \n", + "However, we can easily model tides using multiple models by passing a list of models to the `model` parameter.\n", + "`eo-tides` will process these in parallel where possible, and return the data into a single `pandas.DataFrame`.\n", "\n", - "However, often you may have a list of locations and matching timesteps.\n", - "Using **\"one-to-one\"** mode, we can model tides for only these exact pairs of locations and times:\n", - "```\n", - "5 timesteps at 5 locations = 5 modelled tides\n", - "```\n", + "For example, we can model tides using the FES2014 and HAMTIDE11 models.\n", + "\n", + "
\n", + " \n", + "**Note:** Here we also set `output_format=\"wide\"`, which will place data from each model into a new column.\n", + " This can make it easier to plot our data. For more details, [see below](#\"Wide\"-and-\"long\"-output-formats).\n", "\n", - "To demonstrate \"one-to-one\" mode, imagine we have a `pandas.Dataframe` where each row contains unique site locations and times:" + "
" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "tags": [] }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using FES2014, HAMTIDE11 in parallel\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:01<00:00, 1.41it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converting to a wide format dataframe\n" + ] + }, { "data": { "text/html": [ @@ -211,77 +259,141 @@ " \n", " \n", " \n", + " \n", + " tide_model\n", + " FES2014\n", + " HAMTIDE11\n", + " \n", + " \n", " time\n", " x\n", " y\n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " 0\n", - " 2022-09-01 00:00:00\n", - " 122.21\n", - " -18.2\n", + " 2018-01-01 00:00:00\n", + " 122.2186\n", + " -18.0008\n", + " 1.285507\n", + " 1.422702\n", " \n", " \n", - " 1\n", - " 2022-09-08 06:00:00\n", - " 122.22\n", - " -18.2\n", + " 2018-01-01 01:00:00\n", + " 122.2186\n", + " -18.0008\n", + " 2.360098\n", + " 2.302042\n", " \n", " \n", - " 2\n", - " 2022-09-15 12:00:00\n", - " 122.23\n", - " -18.2\n", + " 2018-01-01 02:00:00\n", + " 122.2186\n", + " -18.0008\n", + " 2.573156\n", + " 2.537032\n", " \n", " \n", - " 3\n", - " 2022-09-22 18:00:00\n", - " 122.24\n", - " -18.2\n", + " 2018-01-01 03:00:00\n", + " 122.2186\n", + " -18.0008\n", + " 2.035899\n", + " 2.072846\n", " \n", " \n", - " 4\n", - " 2022-09-30 00:00:00\n", - " 122.25\n", - " -18.2\n", + " 2018-01-01 04:00:00\n", + " 122.2186\n", + " -18.0008\n", + " 1.126837\n", + " 1.034931\n", " \n", " \n", "\n", "" ], "text/plain": [ - " time x y\n", - "0 2022-09-01 00:00:00 122.21 -18.2\n", - "1 2022-09-08 06:00:00 122.22 -18.2\n", - "2 2022-09-15 12:00:00 122.23 -18.2\n", - "3 2022-09-22 18:00:00 122.24 -18.2\n", - "4 2022-09-30 00:00:00 122.25 -18.2" + "tide_model FES2014 HAMTIDE11\n", + "time x y \n", + "2018-01-01 00:00:00 122.2186 -18.0008 1.285507 1.422702\n", + "2018-01-01 01:00:00 122.2186 -18.0008 2.360098 2.302042\n", + "2018-01-01 02:00:00 122.2186 -18.0008 2.573156 2.537032\n", + "2018-01-01 03:00:00 122.2186 -18.0008 2.035899 2.072846\n", + "2018-01-01 04:00:00 122.2186 -18.0008 1.126837 1.034931" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "sites_df = pd.DataFrame(\n", - " {\n", - " \"time\": pd.date_range(start=\"2022-09-01\", end=\"2022-09-30\", periods=5),\n", - " \"x\": [122.21, 122.22, 122.23, 122.24, 122.25],\n", - " \"y\": [-18.20, -18.20, -18.20, -18.20, -18.20],\n", - " }\n", + "tide_df_multiple = model_tides(\n", + " x=122.2186,\n", + " y=-18.0008,\n", + " model=[\"FES2014\", \"HAMTIDE11\"],\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-20\", freq=\"1h\"),\n", + " output_format=\"wide\",\n", + " directory=directory,\n", ")\n", "\n", - "sites_df" + "# Print outputs\n", + "tide_df_multiple.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot our outputs to see both models on a graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Print outputs\n", + "tide_df_multiple.reset_index([\"x\", \"y\"], drop=True).plot(legend=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Using \"one-to-one\" mode, we can model a tide height for each row in our dataframe, and add it as a new dataframe column:" + "### \"One-to-many\" and \"one-to-one\" modes\n", + "\n", + "By default, the `model_tides` function operates in **\"one-to-many\"** mode, which will model tides for every requested timestep, at every requested location.\n", + "This is particularly useful for satellite Earth observation applications where we may want to model tides for every satellite acquisition through time, across a large set of satellite pixels.\n", + "\n", + "For example, if we provide two locations and two timesteps, the function will return:\n", + "```\n", + "2 locations * 2 timesteps = 4 modelled tides\n", + "```" ] }, { @@ -302,68 +414,83 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:04<00:00, 1.05it/s]\n" + "100%|██████████| 2/2 [00:01<00:00, 1.35it/s]\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", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - "
tide_modeltide_height
 timexytide_heighttimexy
02022-09-01 00:00:00122.210000-18.200000-3.590410
12022-09-08 06:00:00122.220000-18.200000-1.6421752018-01-01122.21-18.20FES20141.268451
22022-09-15 12:00:00122.230000-18.200000-3.3518152018-01-20122.21-18.20FES2014-2.900882
32022-09-22 18:00:00122.240000-18.200000-0.9429392018-01-01122.22-18.21FES20141.270160
42022-09-30 00:00:00122.250000-18.200000-3.6133172018-01-20122.22-18.21FES2014-2.916972
\n" + "\n", + "" ], "text/plain": [ - "" + " tide_model tide_height\n", + "time x y \n", + "2018-01-01 122.21 -18.20 FES2014 1.268451\n", + "2018-01-20 122.21 -18.20 FES2014 -2.900882\n", + "2018-01-01 122.22 -18.21 FES2014 1.270160\n", + "2018-01-20 122.22 -18.21 FES2014 -2.916972" ] }, "execution_count": 6, @@ -372,41 +499,126 @@ } ], "source": [ - "# Model tides in \"one-to-one\" mode\n", - "onetoone_df = model_tides(\n", - " x=sites_df.x,\n", - " y=sites_df.y,\n", - " time=sites_df.time,\n", - " mode=\"one-to-one\",\n", - " directory=\"../../tests/data/tide_models_tests\",\n", - ")\n", - "\n", - "# Add results as a new datframe column\n", - "sites_df[\"tide_height\"] = onetoone_df.tide_m.values\n", - "sites_df.style.set_properties(**{\"background-color\": \"#FFFF8F\"}, subset=[\"tide_height\"])" + "model_tides(\n", + " x=[122.21, 122.22],\n", + " y=[-18.20, -18.21],\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-20\", periods=2),\n", + " mode=\"one-to-many\",\n", + " directory=directory,\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Validation against GESLA tide gauges" + "However, another common use case is having a list of locations and matching timesteps that you want to use to model tides.\n", + "Using **\"one-to-one\"** mode, we can model tides for each unique pair of locations and times:\n", + "```\n", + "2 timesteps at 2 locations = 2 modelled tides\n", + "```\n", + "\n", + "For example, you may have a `pandas.DataFrame` containing `x`, `y` and `time` values:" ] }, { "cell_type": "code", "execution_count": 7, + "metadata": { + "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", + "
timexy
02018-01-01122.21-18.20
12018-01-20122.22-18.21
\n", + "
" + ], + "text/plain": [ + " time x y\n", + "0 2018-01-01 122.21 -18.20\n", + "1 2018-01-20 122.22 -18.21" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(\n", + " {\n", + " \"time\": pd.date_range(start=\"2018-01-01\", end=\"2018-01-20\", periods=2),\n", + " \"x\": [122.21, 122.22],\n", + " \"y\": [-18.20, -18.21],\n", + " }\n", + ")\n", + "df" + ] + }, + { + "cell_type": "markdown", "metadata": {}, + "source": [ + "We can pass these values to `model_tides` directly, and run the function in \"one-to-one\" mode to return a tide height for each unique row:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "tags": [] + }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using FES2014 in parallel\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "/env/lib/python3.10/site-packages/geopandas/array.py:403: UserWarning: Geometry is in a geographic CRS. Results from 'sjoin_nearest' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", - "\n", - " warnings.warn(\n", - "/home/jovyan/Robbi/eo-tides/eo_tides/validation.py:157: FutureWarning: Support for nested sequences for 'parse_dates' in pd.read_csv is deprecated. Combine the desired columns with pd.to_datetime after parsing instead.\n", - " pd.read_csv(\n" + "100%|██████████| 2/2 [00:01<00:00, 1.35it/s]\n" ] }, { @@ -430,333 +642,334 @@ " \n", " \n", " \n", - " \n", - " sea_level\n", - " qc_flag\n", - " use_flag\n", - " file_name\n", - " site_name\n", - " country\n", - " contributor_abbreviated\n", - " contributor_full\n", - " contributor_website\n", - " contributor_contact\n", - " ...\n", - " start_date_time\n", - " end_date_time\n", - " number_of_years\n", - " time_zone_hours\n", - " datum_information\n", - " instrument\n", - " precision\n", - " null_value\n", - " gauge_type\n", - " overall_record_quality\n", - " \n", - " \n", - " site_code\n", " time\n", + " x\n", + " y\n", + " tide_height\n", + " \n", + " \n", + " \n", + " \n", + " 0\n", + " 2018-01-01\n", + " 122.21\n", + " -18.20\n", + " 1.268451\n", + " \n", + " \n", + " 1\n", + " 2018-01-20\n", + " 122.22\n", + " -18.21\n", + " -2.916972\n", + " \n", + " \n", + "\n", + "" + ], + "text/plain": [ + " time x y tide_height\n", + "0 2018-01-01 122.21 -18.20 1.268451\n", + "1 2018-01-20 122.22 -18.21 -2.916972" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Model tides and add back into dataframe\n", + "df[\"tide_height\"] = model_tides(\n", + " x=df.x,\n", + " y=df.y,\n", + " time=df.time,\n", + " mode=\"one-to-one\",\n", + " directory=directory,\n", + ").tide_height.values\n", + "\n", + "# Print dataframe with added tide height data:\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \"Wide\" and \"long\" output formats\n", + "By default, modelled tides will be returned in **\"long\"** format, with multiple models stacked under a `tide_models` column and tide heights in the `tide_height` column:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using FES2014, HAMTIDE11 in parallel\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4/4 [00:01<00:00, 2.77it/s]\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", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \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_height
timexy
626502018-01-01 00:00:001.20422711../../tests/data/broome-62650-aus-bomBroomeAUSBOMBureau of Meteorologyhttp://www.bom.gov.au/oceanography/projects/nt...tides@bom.gov.au...2/07/1966 0:0031/12/2019 23:00510Chart Datum / Lowest Astronomical TideUnspecifiedUnspecified-99.9999CoastalNo obvious issues2018-01-01122.21-18.20FES20141.268451
2018-01-01 01:00:002.30722711../../tests/data/broome-62650-aus-bomBroomeAUSBOMBureau of Meteorologyhttp://www.bom.gov.au/oceanography/projects/nt...tides@bom.gov.au...2/07/1966 0:0031/12/2019 23:00510Chart Datum / Lowest Astronomical TideUnspecifiedUnspecified-99.9999CoastalNo obvious issues2018-01-20122.21-18.20FES2014-2.900882
2018-01-01 02:00:002.70822711../../tests/data/broome-62650-aus-bomBroomeAUSBOMBureau of Meteorologyhttp://www.bom.gov.au/oceanography/projects/nt...tides@bom.gov.au...2/07/1966 0:0031/12/2019 23:00510Chart Datum / Lowest Astronomical TideUnspecifiedUnspecified-99.9999CoastalNo obvious issues2018-01-01122.22-18.21FES20141.270160
2018-01-01 03:00:002.13322711../../tests/data/broome-62650-aus-bomBroomeAUSBOMBureau of Meteorologyhttp://www.bom.gov.au/oceanography/projects/nt...tides@bom.gov.au...2/07/1966 0:0031/12/2019 23:00510Chart Datum / Lowest Astronomical TideUnspecifiedUnspecified-99.9999CoastalNo obvious issues2018-01-20122.22-18.21FES2014-2.916972
2018-01-01 04:00:001.04522711../../tests/data/broome-62650-aus-bomBroomeAUSBOMBureau of Meteorologyhttp://www.bom.gov.au/oceanography/projects/nt...tides@bom.gov.au...2/07/1966 0:0031/12/2019 23:00510Chart Datum / Lowest Astronomical TideUnspecifiedUnspecified-99.9999CoastalNo obvious issues2018-01-01122.21-18.20HAMTIDE111.435844
2018-01-20122.21-18.20HAMTIDE11-2.662284
2018-01-01122.22-18.21HAMTIDE111.435844
2018-01-20122.22-18.21HAMTIDE11-2.662284
\n", - "

5 rows × 26 columns

\n", "
" ], "text/plain": [ - " sea_level qc_flag use_flag \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 1.204227 1 1 \n", - " 2018-01-01 01:00:00 2.307227 1 1 \n", - " 2018-01-01 02:00:00 2.708227 1 1 \n", - " 2018-01-01 03:00:00 2.133227 1 1 \n", - " 2018-01-01 04:00:00 1.045227 1 1 \n", - "\n", - " file_name \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 ../../tests/data/broome-62650-aus-bom \n", - " 2018-01-01 01:00:00 ../../tests/data/broome-62650-aus-bom \n", - " 2018-01-01 02:00:00 ../../tests/data/broome-62650-aus-bom \n", - " 2018-01-01 03:00:00 ../../tests/data/broome-62650-aus-bom \n", - " 2018-01-01 04:00:00 ../../tests/data/broome-62650-aus-bom \n", - "\n", - " site_name country contributor_abbreviated \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 Broome AUS BOM \n", - " 2018-01-01 01:00:00 Broome AUS BOM \n", - " 2018-01-01 02:00:00 Broome AUS BOM \n", - " 2018-01-01 03:00:00 Broome AUS BOM \n", - " 2018-01-01 04:00:00 Broome AUS BOM \n", - "\n", - " contributor_full \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 Bureau of Meteorology \n", - " 2018-01-01 01:00:00 Bureau of Meteorology \n", - " 2018-01-01 02:00:00 Bureau of Meteorology \n", - " 2018-01-01 03:00:00 Bureau of Meteorology \n", - " 2018-01-01 04:00:00 Bureau of Meteorology \n", - "\n", - " contributor_website \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 http://www.bom.gov.au/oceanography/projects/nt... \n", - " 2018-01-01 01:00:00 http://www.bom.gov.au/oceanography/projects/nt... \n", - " 2018-01-01 02:00:00 http://www.bom.gov.au/oceanography/projects/nt... \n", - " 2018-01-01 03:00:00 http://www.bom.gov.au/oceanography/projects/nt... \n", - " 2018-01-01 04:00:00 http://www.bom.gov.au/oceanography/projects/nt... \n", - "\n", - " contributor_contact ... start_date_time \\\n", - "site_code time ... \n", - "62650 2018-01-01 00:00:00 tides@bom.gov.au ... 2/07/1966 0:00 \n", - " 2018-01-01 01:00:00 tides@bom.gov.au ... 2/07/1966 0:00 \n", - " 2018-01-01 02:00:00 tides@bom.gov.au ... 2/07/1966 0:00 \n", - " 2018-01-01 03:00:00 tides@bom.gov.au ... 2/07/1966 0:00 \n", - " 2018-01-01 04:00:00 tides@bom.gov.au ... 2/07/1966 0:00 \n", - "\n", - " end_date_time number_of_years \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 31/12/2019 23:00 51 \n", - " 2018-01-01 01:00:00 31/12/2019 23:00 51 \n", - " 2018-01-01 02:00:00 31/12/2019 23:00 51 \n", - " 2018-01-01 03:00:00 31/12/2019 23:00 51 \n", - " 2018-01-01 04:00:00 31/12/2019 23:00 51 \n", - "\n", - " time_zone_hours \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 0 \n", - " 2018-01-01 01:00:00 0 \n", - " 2018-01-01 02:00:00 0 \n", - " 2018-01-01 03:00:00 0 \n", - " 2018-01-01 04:00:00 0 \n", - "\n", - " datum_information \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 Chart Datum / Lowest Astronomical Tide \n", - " 2018-01-01 01:00:00 Chart Datum / Lowest Astronomical Tide \n", - " 2018-01-01 02:00:00 Chart Datum / Lowest Astronomical Tide \n", - " 2018-01-01 03:00:00 Chart Datum / Lowest Astronomical Tide \n", - " 2018-01-01 04:00:00 Chart Datum / Lowest Astronomical Tide \n", - "\n", - " instrument precision null_value \\\n", - "site_code time \n", - "62650 2018-01-01 00:00:00 Unspecified Unspecified -99.9999 \n", - " 2018-01-01 01:00:00 Unspecified Unspecified -99.9999 \n", - " 2018-01-01 02:00:00 Unspecified Unspecified -99.9999 \n", - " 2018-01-01 03:00:00 Unspecified Unspecified -99.9999 \n", - " 2018-01-01 04:00:00 Unspecified Unspecified -99.9999 \n", - "\n", - " gauge_type overall_record_quality \n", - "site_code time \n", - "62650 2018-01-01 00:00:00 Coastal No obvious issues \n", - " 2018-01-01 01:00:00 Coastal No obvious issues \n", - " 2018-01-01 02:00:00 Coastal No obvious issues \n", - " 2018-01-01 03:00:00 Coastal No obvious issues \n", - " 2018-01-01 04:00:00 Coastal No obvious issues \n", - "\n", - "[5 rows x 26 columns]" + " tide_model tide_height\n", + "time x y \n", + "2018-01-01 122.21 -18.20 FES2014 1.268451\n", + "2018-01-20 122.21 -18.20 FES2014 -2.900882\n", + "2018-01-01 122.22 -18.21 FES2014 1.270160\n", + "2018-01-20 122.22 -18.21 FES2014 -2.916972\n", + "2018-01-01 122.21 -18.20 HAMTIDE11 1.435844\n", + "2018-01-20 122.21 -18.20 HAMTIDE11 -2.662284\n", + "2018-01-01 122.22 -18.21 HAMTIDE11 1.435844\n", + "2018-01-20 122.22 -18.21 HAMTIDE11 -2.662284" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from eo_tides.validation import eval_metrics, load_gauge_gesla\n", - "\n", - "# Load gauge data, subtracting to observed mean sea level\n", - "gauge_df = load_gauge_gesla(\n", - " x=122.3186,\n", - " y=-18.0008,\n", - " time=(\"2018-01-01\", \"2018-01-20\"),\n", - " correct_mean=True,\n", - " data_path=\"../../tests/data/\",\n", - " metadata_path=\"../../tests/data/GESLA3_ALL 2.csv\",\n", - ")\n", - "gauge_df.head()\n" + "model_tides(\n", + " x=[122.21, 122.22],\n", + " y=[-18.20, -18.21],\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-20\", periods=2),\n", + " model=[\"FES2014\", \"HAMTIDE11\"],\n", + " output_format=\"long\",\n", + " directory=directory,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "We can also run the function in **\"wide\"** format, which will return a new column for each tide model (e.g. `FES2014`, `HAMTIDE11` etc):" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "tags": [] }, "outputs": [ { - "data": { - "text/plain": [ - "Correlation 0.998\n", - "RMSE 0.144\n", - "MAE 0.113\n", - "R-squared 0.995\n", - "Bias 0.004\n", - "Regression slope 0.986\n", - "dtype: float64" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using FES2014, HAMTIDE11 in parallel\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4/4 [00:01<00:00, 2.76it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converting to a wide format dataframe\n" + ] }, { "data": { - "image/png": "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", + "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", + "
tide_modelFES2014HAMTIDE11
timexy
2018-01-01122.21-18.201.2684511.435844
122.22-18.211.2701601.435844
2018-01-20122.21-18.20-2.900882-2.662284
122.22-18.21-2.916972-2.662284
\n", + "
" + ], "text/plain": [ - "
" + "tide_model FES2014 HAMTIDE11\n", + "time x y \n", + "2018-01-01 122.21 -18.20 1.268451 1.435844\n", + " 122.22 -18.21 1.270160 1.435844\n", + "2018-01-20 122.21 -18.20 -2.900882 -2.662284\n", + " 122.22 -18.21 -2.916972 -2.662284" ] }, + "execution_count": 10, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "# Combine modelled and observed gauge data and compare\n", - "joined_df = gauge_df.join(tide_df)\n", - "joined_df.plot.scatter(x=\"sea_level\", y=\"tide_m\")\n", - "eval_metrics(x=joined_df.sea_level, y=joined_df.tide_m)" + "model_tides(\n", + " x=[122.21, 122.22],\n", + " y=[-18.20, -18.21],\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-20\", periods=2),\n", + " model=[\"FES2014\", \"HAMTIDE11\"],\n", + " output_format=\"wide\",\n", + " directory=directory,\n", + ")" ] } ], diff --git a/docs/notebooks/Satellite_data.ipynb b/docs/notebooks/Satellite_data.ipynb index 97af901..64732f6 100644 --- a/docs/notebooks/Satellite_data.ipynb +++ b/docs/notebooks/Satellite_data.ipynb @@ -6,7 +6,7 @@ "source": [ "# Combining with satellite data\n", "\n", - "## Load satellite data using \"odc-stac\"\n", + "## Load satellite data using odc-stac\n", "\n" ] }, @@ -197,7 +197,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Using \"pixel_tides\"\n", + "## Using pixel_tides\n", "\n" ] }, diff --git a/docs/notebooks/Validating_tides.ipynb b/docs/notebooks/Validating_tides.ipynb new file mode 100644 index 0000000..dc6895f --- /dev/null +++ b/docs/notebooks/Validating_tides.ipynb @@ -0,0 +1,230 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "48f11312-2f68-46e1-8603-2e54a169083c", + "metadata": { + "tags": [] + }, + "source": [ + "# Validating modelled tide heights\n", + "\n", + "### Validation against GESLA tide gauges" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a7bd7c1c-eae0-4585-a8d3-ca688e4d13af", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Modelling tides using FES2014\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_height
timexy
2018-01-01 00:00:00122.2186-18.0008FES20141.285507
2018-01-01 01:00:00122.2186-18.0008FES20142.360098
2018-01-01 02:00:00122.2186-18.0008FES20142.573156
2018-01-01 03:00:00122.2186-18.0008FES20142.035899
2018-01-01 04:00:00122.2186-18.0008FES20141.126837
\n", + "
" + ], + "text/plain": [ + " tide_model tide_height\n", + "time x y \n", + "2018-01-01 00:00:00 122.2186 -18.0008 FES2014 1.285507\n", + "2018-01-01 01:00:00 122.2186 -18.0008 FES2014 2.360098\n", + "2018-01-01 02:00:00 122.2186 -18.0008 FES2014 2.573156\n", + "2018-01-01 03:00:00 122.2186 -18.0008 FES2014 2.035899\n", + "2018-01-01 04:00:00 122.2186 -18.0008 FES2014 1.126837" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from eo_tides.model import model_tides\n", + "import pandas as pd\n", + "\n", + "tide_model_dir = \"../../tests/data/tide_models_tests\"\n", + "\n", + "tide_df = model_tides(\n", + " x=122.2186,\n", + " y=-18.0008,\n", + " time=pd.date_range(start=\"2018-01-01\", end=\"2018-01-20\", freq=\"1h\"),\n", + " directory=tide_model_dir,\n", + ")\n", + "\n", + "# Print outputs\n", + "tide_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "737c7e94-5954-4b88-b767-40f51db7a63a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/env/lib/python3.10/site-packages/geopandas/array.py:403: UserWarning: Geometry is in a geographic CRS. Results from 'sjoin_nearest' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n", + "\n", + " warnings.warn(\n", + "/home/jovyan/Robbi/eo-tides/eo_tides/validation.py:157: FutureWarning: Support for nested sequences for 'parse_dates' in pd.read_csv is deprecated. Combine the desired columns with pd.to_datetime after parsing instead.\n", + " pd.read_csv(\n" + ] + }, + { + "data": { + "text/plain": [ + "Correlation 0.998\n", + "RMSE 0.144\n", + "MAE 0.113\n", + "R-squared 0.995\n", + "Bias 0.004\n", + "Regression slope 0.986\n", + "dtype: float64" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from eo_tides.validation import eval_metrics, load_gauge_gesla\n", + "\n", + "# Load gauge data, subtracting to observed mean sea level\n", + "gauge_df = load_gauge_gesla(\n", + " x=122.3186,\n", + " y=-18.0008,\n", + " time=(\"2018-01-01\", \"2018-01-20\"),\n", + " correct_mean=True,\n", + " data_path=\"../../tests/data/\",\n", + " metadata_path=\"../../tests/data/GESLA3_ALL 2.csv\",\n", + ")\n", + "gauge_df.head()\n", + "\n", + "# Combine modelled and observed gauge data and compare\n", + "joined_df = gauge_df.join(tide_df)\n", + "joined_df.plot.scatter(x=\"sea_level\", y=\"tide_height\")\n", + "eval_metrics(x=joined_df.sea_level, y=joined_df.tide_height)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9427ee6f-0db7-47a5-86e1-1617f9372c6c", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css index ac7a477..9d26a65 100644 --- a/docs/stylesheets/extra.css +++ b/docs/stylesheets/extra.css @@ -14,11 +14,6 @@ color: #ffffff !important; } -/* Increase content width */ -.md-grid { - max-width: 1200px; -} - /* Add wrapping to code blocks */ code { white-space: pre-wrap !important; diff --git a/eo_tides/model.py b/eo_tides/model.py index ac5715d..60a878e 100644 --- a/eo_tides/model.py +++ b/eo_tides/model.py @@ -207,16 +207,16 @@ def _model_tides( "x": np.repeat(x, time_repeat), "y": np.repeat(y, time_repeat), "tide_model": model, - "tide_m": tide, + "tide_height": tide, }).set_index(["time", "x", "y"]) # Optionally convert outputs to integer units (can save memory) if output_units == "m": - tide_df["tide_m"] = tide_df.tide_m.astype(np.float32) + tide_df["tide_height"] = tide_df.tide_height.astype(np.float32) elif output_units == "cm": - tide_df["tide_m"] = (tide_df.tide_m * 100).astype(np.int16) + tide_df["tide_height"] = (tide_df.tide_height * 100).astype(np.int16) elif output_units == "mm": - tide_df["tide_m"] = (tide_df.tide_m * 1000).astype(np.int16) + tide_df["tide_height"] = (tide_df.tide_height * 1000).astype(np.int16) return tide_df @@ -261,7 +261,7 @@ def _ensemble_model( to ensure that interpolations are performed in the correct CRS. tide_df : pandas.DataFrame DataFrame containing tide model predictions with columns - `["time", "x", "y", "tide_m", "tide_model"]`. + `["time", "x", "y", "tide_height", "tide_model"]`. ensemble_models : list A list of models to include in the ensemble modelling process. All values must exist as columns with the prefix "rank_" in @@ -298,7 +298,7 @@ def _ensemble_model( pandas.DataFrame DataFrame containing the ensemble model predictions, matching the format of the input `tide_df` (e.g. columns `["time", "x", - "y", "tide_m", "tide_model"]`. By default the 'tide_model' + "y", "tide_height", "tide_model"]`. By default the 'tide_model' column will be labeled "ensemble" for the combined model predictions (but if a custom dictionary of ensemble functions is provided via `ensemble_func`, each ensemble will be named using @@ -362,7 +362,7 @@ def _ensemble_model( # Add temp columns containing weightings and weighted values .assign( weights=ensemble_f, # use custom func to compute weights - weighted=lambda i: i.tide_m * i.weights, + weighted=lambda i: i.tide_height * i.weights, ) # Groupby is specified in a weird order here as this seems # to be the easiest way to preserve correct index sorting @@ -374,7 +374,7 @@ def _ensemble_model( # Calculate weighted mean and convert back to dataframe grouped.weighted.sum() .div(grouped.weights.sum()) - .to_frame("tide_m") + .to_frame("tide_height") # Label ensemble model and ensure indexes are in expected order .assign(tide_model=ensemble_n) .reorder_levels(["time", "x", "y"], axis=0) @@ -405,47 +405,24 @@ def model_tides( ensemble_models=None, **ensemble_kwargs, ): - """Compute tides at multiple points and times using tidal harmonics. + """ + Compute tide heights from multiple tide models and for + multiple coordinates and/or timesteps. - This function supports all tidal models supported by `pyTMD`, - including FES Finite Element Solution models, TPXO TOPEX/POSEIDON - models, EOT Empirical Ocean Tide models, GOT Global Ocean Tide - models, and HAMTIDE Hamburg direct data Assimilation Methods for - Tides models. + This function is parallelised to improve performance, and + supports all tidal models supported by `pyTMD`, including: + - Empirical Ocean Tide model (`EOT20`) + - Finite Element Solution tide models (`FES2022`, `FES2014`, `FES2012`) + - TOPEX/POSEIDON global tide models (`TPXO10`, `TPXO9`, `TPXO8`) + - Global Ocean Tide models (`GOT5.6`, `GOT5.5`, `GOT4.10`, `GOT4.8`, `GOT4.7`) + - Hamburg direct data Assimilation Methods for Tides models (`HAMTIDE11`) This function requires access to tide model data files. These should be placed in a folder with subfolders matching - the formats specified by `pyTMD`: + the structure required by `pyTMD`. For more details: + - For FES2014 (): - - - `{directory}/fes2014/ocean_tide/` - - For FES2022 (): - - - `{directory}/fes2022b/ocean_tide/` - - For TPXO8-atlas (): - - - `{directory}/tpxo8_atlas/` - - For TPXO9-atlas-v5 (): - - - `{directory}/TPXO9_atlas_v5/` - - For EOT20 (): - - - `{directory}/EOT20/ocean_tides/` - - For GOT4.10c (): - - - `{directory}/GOT4.10c/grids_oceantide_netcdf/` - - For HAMTIDE (): - - - `{directory}/hamtide/` - This function is a modification of the `pyTMD` package's `compute_tide_corrections` function. For more info: @@ -514,9 +491,10 @@ def model_tides( want to model tides for a specific list of timesteps across multiple spatial points (e.g. for the same set of satellite acquisition times at various locations across your study area). - - "one-to-one": Model tides using a different timestep for each - x and y coordinate point. In this mode, the number of x and + - "one-to-one": Model tides using a unique timestep for each + set of x and y coordinates. In this mode, the number of x and y points must equal the number of timesteps provided in "time". + parallel : boolean, optional Whether to parallelise tide modelling using `concurrent.futures`. If multiple tide models are requested, these will be run in @@ -538,7 +516,7 @@ def model_tides( for millimetres. output_format : str, optional Whether to return the output dataframe in long format (with - results stacked vertically along "tide_model" and "tide_m" + results stacked vertically along "tide_model" and "tide_height" columns), or wide format (with a column for each tide model). Defaults to "long". ensemble_models : list, optional @@ -734,7 +712,7 @@ def model_tides( if output_format == "wide": # Pivot into wide format with each time model as a column print("Converting to a wide format dataframe") - tide_df = tide_df.pivot(columns="tide_model", values="tide_m") + tide_df = tide_df.pivot(columns="tide_model", values="tide_height") # If in 'one-to-one' mode, reindex using our input time/x/y # values to ensure the output is sorted the same as our inputs @@ -812,7 +790,7 @@ def _pixel_tides_resample( how=ds.odc.geobox, chunks=dask_chunks, resampling=resample_method, - ).rename("tide_m") + ).rename("tide_height") # Optionally process and load into memory with Dask if dask_compute: @@ -1064,7 +1042,7 @@ def pixel_tides( .set_index("tide_model", append=True) # Convert to xarray and select our tide modelling xr.DataArray .to_xarray() - .tide_m + .tide_height # Re-index and transpose into our input coordinates and dim order .reindex_like(rescaled_ds) .transpose("tide_model", "time", y_dim, x_dim) diff --git a/mkdocs.yml b/mkdocs.yml index 8d44720..4ef9a28 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -15,6 +15,7 @@ nav: - notebooks/Model_tides.ipynb - notebooks/Satellite_data.ipynb - notebooks/Tide_statistics.ipynb + - notebooks/Validating_tides.ipynb - Package: - API reference: api.md - Reference: diff --git a/tests/test_model.py b/tests/test_model.py index 5bb152e..6b7d6b1 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -34,7 +34,7 @@ def measured_tides_ds(): # Update index and column names measured_tides_df.index.name = "time" - measured_tides_df.columns = ["tide_m"] + measured_tides_df.columns = ["tide_height"] # Apply station AHD offset measured_tides_df += ahd_offset @@ -115,12 +115,12 @@ def test_model_tides(measured_tides_ds, x, y, crs, method): ) # Compare measured and modelled tides - val_stats = eval_metrics(x=measured_tides_ds.tide_m, y=modelled_tides_df.tide_m) + val_stats = eval_metrics(x=measured_tides_ds.tide_height, y=modelled_tides_df.tide_height) # Test that modelled tides contain correct headings and have same # number of timesteps assert modelled_tides_df.index.names == ["time", "x", "y"] - assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_m"] + assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_height"] assert len(modelled_tides_df.index) == len(measured_tides_ds.time) # Test that modelled tides meet expected accuracy @@ -159,7 +159,7 @@ def test_model_tides_multiplemodels(measured_tides_ds, models, output_format): if output_format == "long": # Verify output has correct columns assert modelled_tides_df.index.names == ["time", "x", "y"] - assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_m"] + assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_height"] # Verify tide model column contains correct values assert modelled_tides_df.tide_model.unique().tolist() == models @@ -193,11 +193,11 @@ def test_model_tides_units(measured_tides_ds, units, expected_range, expected_dt ) # Calculate tide range - tide_range = modelled_tides_df.tide_m.max() - modelled_tides_df.tide_m.min() + tide_range = modelled_tides_df.tide_height.max() - modelled_tides_df.tide_height.min() # Verify tide range and dtypes are as expected for unit assert np.isclose(tide_range, expected_range, rtol=0.01) - assert modelled_tides_df.tide_m.dtype == expected_dtype + assert modelled_tides_df.tide_height.dtype == expected_dtype # Run test for each combination of mode, output format, and one or @@ -290,7 +290,7 @@ def test_model_tides_ensemble(): ) assert modelled_tides_df.index.names == ["time", "x", "y"] - assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_m"] + assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_height"] assert all(modelled_tides_df.tide_model == "ensemble") # Default, ensemble + other models requested @@ -304,10 +304,10 @@ def test_model_tides_ensemble(): ) assert modelled_tides_df.index.names == ["time", "x", "y"] - assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_m"] + assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_height"] assert set(modelled_tides_df.tide_model) == set(models) assert np.allclose( - modelled_tides_df.tide_m, + modelled_tides_df.tide_height, [ -2.831, -1.897, @@ -336,7 +336,7 @@ def test_model_tides_ensemble(): ) assert modelled_tides_df.index.names == ["time", "x", "y"] - assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_m"] + assert modelled_tides_df.columns.tolist() == ["tide_model", "tide_height"] assert set(modelled_tides_df.tide_model) == set(models) # Wide mode, default @@ -487,7 +487,7 @@ def test_pixel_tides(satellite_ds, measured_tides_ds, resolution): ) # Calculate accuracy stats - gauge_stats = eval_metrics(x=measured_tides_ds.tide_m, y=modelled_tides_gauge) + gauge_stats = eval_metrics(x=measured_tides_ds.tide_height, y=modelled_tides_gauge) # Assert pixel_tide outputs are accurate assert gauge_stats["Correlation"] > 0.99