From 021127da9bf38f97e09169eb0885bf2a9bc193a0 Mon Sep 17 00:00:00 2001 From: Scott Wales Date: Tue, 4 May 2021 15:42:44 +1000 Subject: [PATCH] Add extrap notebook --- .../notebooks/2021-05-04-xesmf_extrap.html | 13379 ++++++++++++++++ _posts/2021-05-04-xesmf_extrap.md | 8 + notebooks/2021-05-04-xesmf_extrap.ipynb | 229 + 3 files changed, 13616 insertions(+) create mode 100644 _includes/notebooks/2021-05-04-xesmf_extrap.html create mode 100644 _posts/2021-05-04-xesmf_extrap.md create mode 100644 notebooks/2021-05-04-xesmf_extrap.ipynb diff --git a/_includes/notebooks/2021-05-04-xesmf_extrap.html b/_includes/notebooks/2021-05-04-xesmf_extrap.html new file mode 100644 index 0000000..ec2fe6d --- /dev/null +++ b/_includes/notebooks/2021-05-04-xesmf_extrap.html @@ -0,0 +1,13379 @@ + + + + + +2021-05-04-xesmf_extrap + + + + + + + + + + + + + + + +
+
+ +
+
+
+

Extrapolation with xesmf

When regridding data from one grid to another, it's common for the data to have different masks - you have one mask on the ocean grid for the ocean data and one mask on the atmosphere grid for the atmosphere data. These masks don't always line up perfectly if the data comes from different sources, so when we regrid there can be points missing along the coastline.

+

One way to work around this is to use extrapolation, extending the data so it covers the masked area. There are a couple ways to do this with ESMF_RegridWeightGen - you can just find the nearest unmasked point (neareststod), you can use some average of all nearby points weighted by distance (nearestidavg) or you can gradually reduce the size of the mask filling in grid cells with the mean of those around them (creep).

+

With the Pangeo variant of xesmf installed in hh5 Conda you can access these extrapolation methods directly from Python.

+ +
+
+
+
+
+
In [1]:
+
+
+
import xarray
+import xesmf
+import numpy
+
+ +
+
+
+ +
+
+
+
+

I'll start out with some sample data - in reality you'd read this from a file, I'll just use some random values from numpy.random.random. These two datasets are on different grids - dataset a is on a 10x15 grid, b on a 20x20 grid.

+ +
+
+
+
+
+
In [2]:
+
+
+
da_a = xarray.DataArray(numpy.random.random((10,15)), coords=[('lat', numpy.linspace(0,50, num=10)), ('lon', numpy.linspace(0,50,num=15))], name='a')
+da_b = xarray.DataArray(numpy.random.random((20,20)), coords=[('lat', numpy.linspace(0,50, num=20)), ('lon', numpy.linspace(0,50,num=20))], name='b')
+
+ds_a = da_a.to_dataset()
+ds_b = da_a.to_dataset()
+
+ +
+
+
+ +
+
+
+
+

To use the xesmf extrapolation we need to specify the mask as a new variable in the dataset named mask. Again you'd read this from a file when working with a dataset - most datasets have a special mask file, or if the data is already masked you can access that mask with .mask on the array.

+

The mask needs to be 1 on the grid cells that are valid and 0 on the grid cells that are masked out.

+ +
+
+
+
+
+
In [3]:
+
+
+
ds_a['mask'] = (('lat', 'lon'), numpy.ones(ds_a.a.shape))
+ds_a['mask'][0:5, 0:5] = 0
+
+# I'm working a bit backwards and applying the mask I've just made to the data
+ds_a['a'] = ds_a['a'].where(ds_a['mask'] == 1)
+
+ +
+
+
+ +
+
+
+
+

Now our 'a' data is masked in the bottom left corner, and we'd like to regrid it to the same grid as 'b', extrapolating to fill the masked area.

+ +
+
+
+
+
+
In [4]:
+
+
+
ds_a['a'].plot()
+
+ +
+
+
+ +
+
+ + +
+ +
Out[4]:
+ + + + +
+
<matplotlib.collections.QuadMesh at 0x14608e524910>
+
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
+

The 'pangeo' version of xesmf is installed in conda, which includes extrapolation. Make sure there is a 'mask' variable in the source dataset if you want to use extrapolation.

+

https://pangeo-xesmf.readthedocs.io/en/latest/user_api.html

+ +
+
+
+
+
+
In [5]:
+
+
+
re = xesmf.Regridder(ds_a, ds_b, 'bilinear', extrap_method='nearest_s2d')
+re.regrid_dataarray(ds_a['a']).plot()
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
/g/data3/hh5/public/apps/miniconda3/envs/analysis3-21.01/lib/python3.8/site-packages/xesmf/frontend.py:464: FutureWarning: ``output_sizes`` should be given in the ``dask_gufunc_kwargs`` parameter. It will be removed as direct parameter in a future version.
+  dr_out = xr.apply_ufunc(
+
+
+
+ +
+ +
Out[5]:
+ + + + +
+
<matplotlib.collections.QuadMesh at 0x146085185760>
+
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
+

You can see that the bottom corner has been filled in. Remember this isn't new information, it's only the nearby values copied over.

+

The inverse distance extrapolation produces smoother results, there are a couple parameters that can be used to tune the averaging.

+ +
+
+
+
+
+
In [6]:
+
+
+
re2 = xesmf.Regridder(ds_a, ds_b, 'bilinear', extrap_method='inverse_dist')
+re2.regrid_dataarray(ds_a['a']).plot()
+
+ +
+
+
+ +
+
+ + +
+ +
Out[6]:
+ + + + +
+
<matplotlib.collections.QuadMesh at 0x1460850ac040>
+
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
In [ ]:
+
+
+
 
+
+ +
+
+
+ +
+
+
+ + + + + + + + + diff --git a/_posts/2021-05-04-xesmf_extrap.md b/_posts/2021-05-04-xesmf_extrap.md new file mode 100644 index 0000000..639c922 --- /dev/null +++ b/_posts/2021-05-04-xesmf_extrap.md @@ -0,0 +1,8 @@ +--- +title: Extrapolating with xesmf +layout: notebook +notebook: 2021-05-04-xesmf_extrap.html +excerpt: >- + Extrapolating with xesmf to fill in missing data points +tags: python regridder +--- diff --git a/notebooks/2021-05-04-xesmf_extrap.ipynb b/notebooks/2021-05-04-xesmf_extrap.ipynb new file mode 100644 index 0000000..9aa4aeb --- /dev/null +++ b/notebooks/2021-05-04-xesmf_extrap.ipynb @@ -0,0 +1,229 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Extrapolation with xesmf\n", + "\n", + "When regridding data from one grid to another, it's common for the data to have different masks - you have one mask on the ocean grid for the ocean data and one mask on the atmosphere grid for the atmosphere data. These masks don't always line up perfectly if the data comes from different sources, so when we regrid there can be points missing along the coastline.\n", + "\n", + "One way to work around this is to use extrapolation, extending the data so it covers the masked area. There are a couple ways to do this with ESMF_RegridWeightGen - you can just find the nearest unmasked point (`neareststod`), you can use some average of all nearby points weighted by distance (`nearestidavg`) or you can gradually reduce the size of the mask filling in grid cells with the mean of those around them (`creep`).\n", + "\n", + "With the Pangeo variant of [`xesmf`](https://pangeo-xesmf.readthedocs.io/en/latest/index.html) installed in [hh5 Conda](http://climate-cms.wikis.unsw.edu.au/Conda) you can access these extrapolation methods directly from Python." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import xarray\n", + "import xesmf\n", + "import numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I'll start out with some sample data - in reality you'd read this from a file, I'll just use some random values from `numpy.random.random`. These two datasets are on different grids - dataset `a` is on a 10x15 grid, `b` on a 20x20 grid." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "da_a = xarray.DataArray(numpy.random.random((10,15)), coords=[('lat', numpy.linspace(0,50, num=10)), ('lon', numpy.linspace(0,50,num=15))], name='a')\n", + "da_b = xarray.DataArray(numpy.random.random((20,20)), coords=[('lat', numpy.linspace(0,50, num=20)), ('lon', numpy.linspace(0,50,num=20))], name='b')\n", + "\n", + "ds_a = da_a.to_dataset()\n", + "ds_b = da_a.to_dataset()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use the xesmf extrapolation we need to specify the mask as a new variable in the dataset named `mask`. Again you'd read this from a file when working with a dataset - most datasets have a special mask file, or if the data is already masked you can access that mask with `.mask` on the array.\n", + "\n", + "The mask needs to be `1` on the grid cells that are valid and `0` on the grid cells that are masked out." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "ds_a['mask'] = (('lat', 'lon'), numpy.ones(ds_a.a.shape))\n", + "ds_a['mask'][0:5, 0:5] = 0\n", + "\n", + "# I'm working a bit backwards and applying the mask I've just made to the data\n", + "ds_a['a'] = ds_a['a'].where(ds_a['mask'] == 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now our 'a' data is masked in the bottom left corner, and we'd like to regrid it to the same grid as 'b', extrapolating to fill the masked area." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ds_a['a'].plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The 'pangeo' version of xesmf is installed in conda, which includes extrapolation. Make sure there is a `'mask'` variable in the source dataset if you want to use extrapolation.\n", + "\n", + "https://pangeo-xesmf.readthedocs.io/en/latest/user_api.html" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/g/data3/hh5/public/apps/miniconda3/envs/analysis3-21.01/lib/python3.8/site-packages/xesmf/frontend.py:464: FutureWarning: ``output_sizes`` should be given in the ``dask_gufunc_kwargs`` parameter. It will be removed as direct parameter in a future version.\n", + " dr_out = xr.apply_ufunc(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "re = xesmf.Regridder(ds_a, ds_b, 'bilinear', extrap_method='nearest_s2d')\n", + "re.regrid_dataarray(ds_a['a']).plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that the bottom corner has been filled in. Remember this isn't new information, it's only the nearby values copied over. \n", + "\n", + "The inverse distance extrapolation produces smoother results, there are a couple parameters that can be used to tune the averaging." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "re2 = xesmf.Regridder(ds_a, ds_b, 'bilinear', extrap_method='inverse_dist')\n", + "re2.regrid_dataarray(ds_a['a']).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:analysis3]", + "language": "python", + "name": "conda-env-analysis3-py" + }, + "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.8.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}