From b3bb0ec09bca72ec83e5873a65e79f7bea8358e6 Mon Sep 17 00:00:00 2001 From: maawoo Date: Fri, 8 Dec 2023 16:03:36 +0100 Subject: [PATCH 1/6] [sdc.s1] new function `load_s1_surfmi` --- sdc/load.py | 5 +++- sdc/products/__init__.py | 2 +- sdc/products/s1.py | 64 +++++++++++++++++++++++++++++++++++++++- 3 files changed, 68 insertions(+), 3 deletions(-) diff --git a/sdc/load.py b/sdc/load.py index bb32645..62f1ff1 100644 --- a/sdc/load.py +++ b/sdc/load.py @@ -22,6 +22,7 @@ def load_product(product: str, product : str Product to load. Currently supported products are: - s1_rtc + - s1_surfmi - s2_l2a - sanlc - mswep @@ -53,7 +54,7 @@ def load_product(product: str, Xarray Dataset or DataArray containing the loaded data. """ if vec.lower() in ['site01', 'site02', 'site03', 'site04', 'site05', 'site06']: - if product in ['s1_rtc', 's2_l2a']: + if product in ['s1_rtc', 's1_surfmi', 's2_l2a']: print("WARNING: Loading data for an entire SALDi site will likely result " "in performance issues as it will load data from multiple tiles. " "Only do so if you know what you are doing and have optimized your " @@ -69,6 +70,8 @@ def load_product(product: str, if product == 's1_rtc': ds = prod.load_s1_rtc(**kwargs) + elif product == 's1_surfmi': + ds = prod.load_s1_surfmi(**kwargs) elif product == 's2_l2a': ds = prod.load_s2_l2a(apply_mask=s2_apply_mask, **kwargs) elif product == 'sanlc': diff --git a/sdc/products/__init__.py b/sdc/products/__init__.py index 88b8f4b..a13faa8 100644 --- a/sdc/products/__init__.py +++ b/sdc/products/__init__.py @@ -1,4 +1,4 @@ from .mswep import load_mswep -from .s1 import load_s1_rtc +from .s1 import load_s1_rtc, load_s1_surfmi from .s2 import load_s2_l2a from .sanlc import load_sanlc diff --git a/sdc/products/s1.py b/sdc/products/s1.py index ab6d49e..db1db61 100644 --- a/sdc/products/s1.py +++ b/sdc/products/s1.py @@ -1,8 +1,10 @@ from pystac import Catalog from odc.stac import load as odc_stac_load +import xarray as xr +import dask from typing import Optional -from xarray import Dataset +from xarray import Dataset, DataArray from sdc.products import _ancillary as anc from sdc.products import _query as query @@ -53,3 +55,63 @@ def load_s1_rtc(bounds: tuple[float, float, float, float], **anc.common_params()) return ds + + +def load_s1_surfmi(bounds: tuple[float, float, float, float], + time_range: Optional[tuple[str, str]] = None, + time_pattern: Optional[str] = None + ) -> DataArray: + """ + Loads the Sentinel-1 Surface Moisture Index (SurfMI) product for an area of interest. + + Parameters + ---------- + bounds: tuple of float + The bounding box of the area of interest in the format (minx, miny, maxx, maxy). + Will be used to filter the STAC Catalog for intersecting STAC Collections. + time_range : tuple of str, optional + The time range in the format (start_time, end_time) to filter STAC Items by. + Defaults to None, which will load all STAC Items in the filtered STAC + Collections. + time_pattern : str, optional + Time pattern to parse the time range. Only needed if it deviates from the + default: '%Y-%m-%d'. + + Returns + ------- + DataArray + An xarray DataArray containing the Sentinel-1 SurfMI data. + + Notes + ----- + See https://doi.org/10.3390/rs10091482 for more information on the SurfMI. + """ + # Load dry and wet reference as well as s1_rtc data chunked per time step + common_params = anc.common_params() + common_params['chunks']['time'] = 1 + + catalog = Catalog.from_file(anc.get_catalog_path(product='s1_smi_2')) + _, items = query.filter_stac_catalog(catalog=catalog, bbox=bounds) + ds_ref = odc_stac_load(items=items, bbox=bounds, dtype='float32', + **common_params) + + catalog = Catalog.from_file(anc.get_catalog_path(product='s1_rtc')) + _, items = query.filter_stac_catalog(catalog=catalog, bbox=bounds, + time_range=time_range, + time_pattern=time_pattern) + ds_s1 = odc_stac_load(items=items, bands=['vv'], bbox=bounds, dtype='float32', + **common_params) + + # Squeeze time dimension from reference data and persist in cluster memory + ds_ref = ds_ref.squeeze() + dry_ref = ds_ref.vv_q05.persist() + wet_ref = ds_ref.vv_q95.persist() + + # Calculate SurfMI + with dask.config.set({"array.rechunk.method": "p2p"}): + smi = ((ds_s1.vv - dry_ref)/(wet_ref - dry_ref))*100 + smi = smi.chunk({'time': -1, 'latitude': 'auto', 'longitude': 'auto'}) + smi = xr.where(smi < 0, 0, smi) + smi = xr.where(smi > 100, 100, smi) + + return smi From bc2293e329bbff340a7bf93cb87505c7603c3826 Mon Sep 17 00:00:00 2001 From: maawoo Date: Fri, 8 Dec 2023 17:31:02 +0100 Subject: [PATCH 2/6] [sdc.s1.load_s1_surfmi] assign metadata --- sdc/products/s1.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/sdc/products/s1.py b/sdc/products/s1.py index db1db61..66e77b3 100644 --- a/sdc/products/s1.py +++ b/sdc/products/s1.py @@ -94,6 +94,8 @@ def load_s1_surfmi(bounds: tuple[float, float, float, float], _, items = query.filter_stac_catalog(catalog=catalog, bbox=bounds) ds_ref = odc_stac_load(items=items, bbox=bounds, dtype='float32', **common_params) + meta_dry = items[0].assets['vv_q05'].href.removeprefix('./') + meta_wet = items[0].assets['vv_q95'].href.removeprefix('./') catalog = Catalog.from_file(anc.get_catalog_path(product='s1_rtc')) _, items = query.filter_stac_catalog(catalog=catalog, bbox=bounds, @@ -114,4 +116,5 @@ def load_s1_surfmi(bounds: tuple[float, float, float, float], smi = xr.where(smi < 0, 0, smi) smi = xr.where(smi > 100, 100, smi) + smi = smi.assign_attrs(dry_reference=meta_dry, wet_reference=meta_wet) return smi From 22c5921d32dcad09f888446072d59c5e44599534 Mon Sep 17 00:00:00 2001 From: maawoo Date: Fri, 8 Dec 2023 17:32:08 +0100 Subject: [PATCH 3/6] [docs] update `load_product`-section --- docs/content/02_Getting_Started/01_00_Data_Access.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/content/02_Getting_Started/01_00_Data_Access.md b/docs/content/02_Getting_Started/01_00_Data_Access.md index 8b56693..2f755fd 100644 --- a/docs/content/02_Getting_Started/01_00_Data_Access.md +++ b/docs/content/02_Getting_Started/01_00_Data_Access.md @@ -45,6 +45,7 @@ supported at the moment: - `"s2_l2a"`: Sentinel-2 Level 2A (L2A) - `"sanlc"`: South African National Land Cover (SANLC) 2020 - `"mswep"`: Multi-Source Weighted-Ensemble Precipitation (MSWEP) daily + - `"s1_surfmi"`: Sentinel-1 Surface Moisture Index (SurfMI) - `vec`: Filter the returned data spatially by either providing the name of a SALDi site in the format `"siteXX"`, where XX is the site number (e.g. `"site06"`), or a path to a vector file (any format [fiona](https://github.com/Toblerity/Fiona) From dd0a781c12ca17cfb6782817350f5138864d2e87 Mon Sep 17 00:00:00 2001 From: maawoo Date: Mon, 11 Dec 2023 13:15:32 +0100 Subject: [PATCH 4/6] [sdc.products.s1] remove dask config with-statement #31 implements `p2p` as default --- sdc/products/s1.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/sdc/products/s1.py b/sdc/products/s1.py index 66e77b3..57468b9 100644 --- a/sdc/products/s1.py +++ b/sdc/products/s1.py @@ -110,11 +110,10 @@ def load_s1_surfmi(bounds: tuple[float, float, float, float], wet_ref = ds_ref.vv_q95.persist() # Calculate SurfMI - with dask.config.set({"array.rechunk.method": "p2p"}): - smi = ((ds_s1.vv - dry_ref)/(wet_ref - dry_ref))*100 - smi = smi.chunk({'time': -1, 'latitude': 'auto', 'longitude': 'auto'}) - smi = xr.where(smi < 0, 0, smi) - smi = xr.where(smi > 100, 100, smi) + smi = ((ds_s1.vv - dry_ref)/(wet_ref - dry_ref))*100 + smi = smi.chunk({'time': -1, 'latitude': 'auto', 'longitude': 'auto'}) + smi = xr.where(smi < 0, 0, smi) + smi = xr.where(smi > 100, 100, smi) smi = smi.assign_attrs(dry_reference=meta_dry, wet_reference=meta_wet) return smi From d82afc694ba35402e178007ffbfe87fc872d0475 Mon Sep 17 00:00:00 2001 From: maawoo Date: Mon, 11 Dec 2023 15:28:34 +0100 Subject: [PATCH 5/6] [sdc.products.s1] set `optimization.fuse.active` to False Will otherwise run into https://github.com/dask/distributed/issues/7816 --- sdc/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/sdc/__init__.py b/sdc/__init__.py index 3a26271..e11376d 100644 --- a/sdc/__init__.py +++ b/sdc/__init__.py @@ -3,6 +3,7 @@ from sdc.cluster import start_slurm_cluster dask.config.set({"array.rechunk.method": "p2p"}) +dask.config.set({"optimization.fuse.active": False}) xr.set_options(keep_attrs=True) dask_client, cluster = start_slurm_cluster() From bcecc93c623329a981edf2f0cfa4c3ae46ee547f Mon Sep 17 00:00:00 2001 From: maawoo Date: Mon, 11 Dec 2023 16:11:10 +0100 Subject: [PATCH 6/6] [docs] add 01_05_S1_SurfMI --- docs/_assets/vec_01_05_01.geojson | 36 + docs/_toc.yml | 1 + .../02_Getting_Started/01_05_S1_SurfMI.ipynb | 1599 +++++++++++++++++ 3 files changed, 1636 insertions(+) create mode 100644 docs/_assets/vec_01_05_01.geojson create mode 100644 docs/content/02_Getting_Started/01_05_S1_SurfMI.ipynb diff --git a/docs/_assets/vec_01_05_01.geojson b/docs/_assets/vec_01_05_01.geojson new file mode 100644 index 0000000..40c161a --- /dev/null +++ b/docs/_assets/vec_01_05_01.geojson @@ -0,0 +1,36 @@ +{ + "type": "FeatureCollection", + "features": [ + { + "type": "Feature", + "properties": {}, + "geometry": { + "coordinates": [ + [ + [ + 31.46859018095364, + -25.05563626426381 + ], + [ + 31.46859018095364, + -25.081801126663677 + ], + [ + 31.49769085376809, + -25.081801126663677 + ], + [ + 31.49769085376809, + -25.05563626426381 + ], + [ + 31.46859018095364, + -25.05563626426381 + ] + ] + ], + "type": "Polygon" + } + } + ] + } \ No newline at end of file diff --git a/docs/_toc.yml b/docs/_toc.yml index 60dd898..772bd9d 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -13,4 +13,5 @@ parts: - file: content/02_Getting_Started/01_02_Sentinel2 - file: content/02_Getting_Started/01_03_SANLC - file: content/02_Getting_Started/01_04_MSWEP + - file: content/02_Getting_Started/01_05_S1_SurfMI - file: content/02_Getting_Started/02_00_How_to diff --git a/docs/content/02_Getting_Started/01_05_S1_SurfMI.ipynb b/docs/content/02_Getting_Started/01_05_S1_SurfMI.ipynb new file mode 100644 index 0000000..13d7bf2 --- /dev/null +++ b/docs/content/02_Getting_Started/01_05_S1_SurfMI.ipynb @@ -0,0 +1,1599 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(sentinel-1-surfmi)=\n", + "# Sentinel-1 Surface Moisture Index (SurfMI)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Product description" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Sentinel-1 Surface Moisture Index (SurfMI) is derived from the {ref}`sentinel-1` \n", + "product. It is a measure of the relative surface moisture, based on the \n", + "assumption that short-term variations of the radar backscatter signal are \n", + "associated with moisture variations, while long-term changes can be related to \n", + "vegetation and surface roughness. The SurfMI $m_s(t)$ is calculated as:\n", + "\n", + "$$\n", + "m_s(t)=\\frac{\\sigma^0(t)-\\sigma_{dry}^0(t)}{\\sigma_{wet}^0(t)-\\sigma_{dry}^0(t)} * 100\n", + "$$\n", + "\n", + "where $\\sigma^0(t)$ is a backscatter time series, $\\sigma_{dry}^0(t)$ the dry \n", + "reference (permanent wilting level) and $\\sigma_{wet}^0(t)$ the wet reference \n", + "(field capacity) ([Urban et al., 2018](https://doi.org/10.3390/rs10091482)). \n", + "For the dry and wet references, the 5th and 95th percentile of the backscatter \n", + "time series are used, respectively. These layers have been pre-computed for each \n", + "SALDi site based on the available Sentinel-1 RTC VV-polarised backscatter data \n", + "so that the SurfMI can be efficiently calculated on the fly.\n", + "\n", + "The product abbreviation used in this package is `s1_surfmi`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading data" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 385, latitude: 131, longitude: 147)>\n",
+       "dask.array<where, shape=(385, 131, 147), dtype=float32, chunksize=(385, 131, 147), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * latitude     (latitude) float64 -25.06 -25.06 -25.06 ... -25.08 -25.08\n",
+       "  * longitude    (longitude) float64 31.47 31.47 31.47 31.47 ... 31.5 31.5 31.5\n",
+       "    spatial_ref  int32 4326\n",
+       "  * time         (time) datetime64[ns] 2018-01-03T16:30:28.531898 ... 2022-12...\n",
+       "Attributes:\n",
+       "    dry_reference:  site06_vv_q05__20180103T163028_20230903T163910.tif\n",
+       "    wet_reference:  site06_vv_q95__20180103T163028_20230903T163910.tif
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * latitude (latitude) float64 -25.06 -25.06 -25.06 ... -25.08 -25.08\n", + " * longitude (longitude) float64 31.47 31.47 31.47 31.47 ... 31.5 31.5 31.5\n", + " spatial_ref int32 4326\n", + " * time (time) datetime64[ns] 2018-01-03T16:30:28.531898 ... 2022-12...\n", + "Attributes:\n", + " dry_reference: site06_vv_q05__20180103T163028_20230903T163910.tif\n", + " wet_reference: site06_vv_q95__20180103T163028_20230903T163910.tif" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sdc.load import load_product\n", + "\n", + "vec = '../../_assets/vec_01_05_01.geojson'\n", + "time_range=(\"2018-01-01\", \"2023-01-01\")\n", + "ds = load_product(product=\"s1_surfmi\", vec=vec, time_range=time_range)\n", + "ds" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison with precipitation data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's compare the SurfMI with the {ref}`mswep` precipitation data. Instead of \n", + "loading this product using the same vector file as above, we will load it for \n", + "the entire SALDi site and then select the central coordinate of the vector file. \n", + "This is a workaround for [this issue](https://github.com/Jena-Earth-Observation-School/sdc-tools/issues/27),\n", + "which results in an empty DataArray if the area of interest is smaller than a \n", + "single pixel of the MSWEP product." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'precipitation' (time: 1825)>\n",
+       "array([ 0.375    ,  1.6875   ,  0.       , ...,  2.7890625, 17.882812 ,\n",
+       "        6.015625 ], dtype=float32)\n",
+       "Coordinates:\n",
+       "  * time         (time) datetime64[ns] 2018-01-01 2018-01-02 ... 2022-12-31\n",
+       "    longitude    float32 31.45\n",
+       "    latitude     float32 -25.05\n",
+       "    spatial_ref  int32 4326\n",
+       "Attributes:\n",
+       "    units:    mm d-1
" + ], + "text/plain": [ + "\n", + "array([ 0.375 , 1.6875 , 0. , ..., 2.7890625, 17.882812 ,\n", + " 6.015625 ], dtype=float32)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2018-01-01 2018-01-02 ... 2022-12-31\n", + " longitude float32 31.45\n", + " latitude float32 -25.05\n", + " spatial_ref int32 4326\n", + "Attributes:\n", + " units: mm d-1" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import fiona\n", + "\n", + "# Load MSWEP data\n", + "mswep = load_product(product=\"mswep\", vec=\"site06\", time_range=time_range)\n", + "\n", + "# Get the center coordinate of the vector file\n", + "with fiona.open(vec) as src:\n", + " bounds = src.bounds\n", + " lon = (bounds[0] + bounds[2]) / 2\n", + " lat = (bounds[1] + bounds[3]) / 2\n", + "\n", + "# Select the nearest grid point to the center coordinate\n", + "mswep_pt = mswep.sel(latitude=lat, longitude=lon, method='nearest')\n", + "mswep_pt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the plot we calculate the mean and standard deviation for each time step of \n", + "the SurfMI data by aggregating over the spatial dimensions (latitude and \n", + "longitude):" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 385)>\n",
+       "dask.array<mean_agg-aggregate, shape=(385,), dtype=float32, chunksize=(385,), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "    spatial_ref  int32 4326\n",
+       "  * time         (time) datetime64[ns] 2018-01-03T16:30:28.531898 ... 2022-12...\n",
+       "Attributes:\n",
+       "    dry_reference:  site06_vv_q05__20180103T163028_20230903T163910.tif\n",
+       "    wet_reference:  site06_vv_q95__20180103T163028_20230903T163910.tif
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " spatial_ref int32 4326\n", + " * time (time) datetime64[ns] 2018-01-03T16:30:28.531898 ... 2022-12...\n", + "Attributes:\n", + " dry_reference: site06_vv_q05__20180103T163028_20230903T163910.tif\n", + " wet_reference: site06_vv_q95__20180103T163028_20230903T163910.tif" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_mean = ds.mean(dim=['latitude', 'longitude'])\n", + "ds_std = ds.std(dim=['latitude', 'longitude'])\n", + "\n", + "ds_mean" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, ' Sentinel-1 SurfMI vs. MSWEP precipitation')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.stem(mswep_pt.time, mswep_pt, markerfmt=\"\")\n", + "ax.grid(True, alpha=0.5)\n", + "ax.set_ylabel(\"Precipitation [mm/day]\")\n", + "ax.invert_yaxis()\n", + "\n", + "ax2 = ax.twinx()\n", + "ax2.fill_between(ds_mean.time, ds_mean - ds_std, ds_mean + ds_std, color='red', alpha=0.2)\n", + "ax2.scatter(ds_mean.time, ds_mean, color='black', s=15)\n", + "ax2.set_ylabel(\"Relative surface moisture [%]\")\n", + "\n", + "plt.xlabel(\"Time\")\n", + "plt.title(\" Sentinel-1 SurfMI vs. MSWEP precipitation\")" + ] + } + ], + "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.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}