Regridding with xESMF #

# Import necessary python modules
%matplotlib inline
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import xarray as xr
import xesmf as xe
from pathlib import Path
from clisops.ops.subset import subset

Perform regridding#

We create the regridding weights by calling xe.Regridder(grid_in, grid_out, method). A grid is just an xarray DataSet containing latitude and longitude coordinates.

xESMF supports multiple remapping methods, but which method should be applied for the problem?

Method	Description	Application
bilinear	linear interpolation monotonic (i.e. creates no new maxima/minima)	smoothly varying variables (eg. temperature)
conservative	preserving area average maintaining eg. energy budgets monotonic	discontinuous variables / fluxes upscaling (remapping to coarser grid)
nearest neighbour	monotonic	categorical data (eg. binary masks, land usage type)
patch	least square fit of surrounding surface patches preserving derivatives	eg. wind speed

# Calculation of weights, using xesmf.Regridder
method_list = ["bilinear",
               "conservative",
               "conservative_normed",
               "patch",
               "nearest_s2d",
               "nearest_d2s"]

regridder = {}
for method in method_list:
    print("\n"+method)
    %time regridder[method+"_tas"] = xe.Regridder(ds_tas, ds_out, method)
    %time regridder[method+"_tos"] = xe.Regridder(ds_tos, ds_out, method)

bilinear
CPU times: user 87.9 ms, sys: 101 ms, total: 189 ms
Wall time: 118 ms

/home/k/k204199/.conda/envs/summerschool_2022/lib/python3.10/site-packages/xesmf/backend.py:38: UserWarning: Input array is not F_CONTIGUOUS. Will affect performance.
  warnings.warn('Input array is not F_CONTIGUOUS. ' 'Will affect performance.')

CPU times: user 187 ms, sys: 3.97 ms, total: 191 ms
Wall time: 193 ms

conservative
CPU times: user 157 ms, sys: 0 ns, total: 157 ms
Wall time: 158 ms

CPU times: user 383 ms, sys: 1.44 ms, total: 384 ms
Wall time: 385 ms

conservative_normed
CPU times: user 156 ms, sys: 0 ns, total: 156 ms
Wall time: 156 ms

CPU times: user 377 ms, sys: 331 µs, total: 378 ms
Wall time: 378 ms

patch

CPU times: user 905 ms, sys: 67 µs, total: 905 ms
Wall time: 907 ms

CPU times: user 999 ms, sys: 259 µs, total: 1e+03 ms
Wall time: 1 s

nearest_s2d
CPU times: user 13.7 ms, sys: 0 ns, total: 13.7 ms
Wall time: 13.7 ms
CPU times: user 39.8 ms, sys: 0 ns, total: 39.8 ms
Wall time: 39.9 ms

nearest_d2s
CPU times: user 20.9 ms, sys: 12 µs, total: 20.9 ms
Wall time: 21 ms
CPU times: user 98.1 ms, sys: 0 ns, total: 98.1 ms
Wall time: 98.4 ms

# Applying the weights to remap the data
for method in method_list:
    ds_out[method+"_tas"] = regridder[method+"_tas"](ds_tas.tas.isel(time=0))
    ds_out[method+"_tos"] = regridder[method+"_tos"](ds_tos.tos.isel(time=0))

/home/k/k204199/.conda/envs/summerschool_2022/lib/python3.10/site-packages/xesmf/smm.py:130: UserWarning: Input array is not C_CONTIGUOUS. Will affect performance.
  warnings.warn('Input array is not C_CONTIGUOUS. ' 'Will affect performance.')

/home/k/k204199/.conda/envs/summerschool_2022/lib/python3.10/site-packages/xesmf/smm.py:130: UserWarning: Input array is not C_CONTIGUOUS. Will affect performance.
  warnings.warn('Input array is not C_CONTIGUOUS. ' 'Will affect performance.')

Plot the results#

The regridding result is consistent with the original data, with a much finer resolution:

fig, axes = plt.subplots(3, 2, figsize=[16, 16])

for i, method in enumerate(method_list):
    ax = axes.flatten()[i]
    ds_out[method+"_tas"].plot.pcolormesh(ax=ax, shading="auto", cmap="RdBu_r")
    ax.set_title(method, fontsize=15)

plt.tight_layout()

fig, axes = plt.subplots(3, 2, figsize=[16, 16])

for i, method in enumerate(method_list):
    ax = axes.flatten()[i]
    ds_out[method+"_tos"].plot.pcolormesh(ax=ax, shading="auto", cmap="RdBu_r")
    ax.set_title(method, fontsize=15)

plt.tight_layout()

The missing values of the land cells are contaminating the result, since a target cell will get a missing value as long as only a single contributing cell of the source grid has a missing value.
nearest_s2d maps each cell of the target grid to one cell of the source grid.
nearest_d2s maps each cell of the source grid to a cell of the target grid. In case of multiple matches, which is usually the case for upscaling, the values will be added up.

Masking#

Use an input mask to obtain a better result#

# Create the mask - it has to be labeled "mask"
import numpy as np
ds_tos["mask"] = xr.where(~np.isnan(ds_tos["tos"].isel(time=0)), 1, 0)
ds_tos["mask"].plot.pcolormesh(x="longitude", y="latitude", shading="auto",
                               cmap="binary", xlim=(-25,60), ylim=(35,75));

# Create the weights
for method in method_list:
    regridder[method+"_tos_mask"] = xe.Regridder(ds_tos, ds_out, method)

/home/k/k204199/.conda/envs/summerschool_2022/lib/python3.10/site-packages/xesmf/backend.py:38: UserWarning: Input array is not F_CONTIGUOUS. Will affect performance.
  warnings.warn('Input array is not F_CONTIGUOUS. ' 'Will affect performance.')

# Regrid the data
for method in method_list:
    ds_out[method+"_tos_mask"] = regridder[method+"_tos_mask"](ds_tos.tos.isel(time=0))

# Plot
fig, axes = plt.subplots(3, 2, figsize=[16, 16])

for i, method in enumerate(method_list):
    ax = axes.flatten()[i]
    ds_out[method+"_tos_mask"].plot.pcolormesh(ax=ax, shading="auto", cmap="RdBu_r")
    ax.set_title(method, fontsize=15)

plt.tight_layout()

conservative: the values near the coastline are too low since masked cells contribute to the area average with value 0
conservative_normed: here a renormalization is performed for these cells
nearest_s2d: cells on land have the same value as the closest unmasked source grid cell

Instead of an input mask, apply adaptive masking#

The skipna parameter (boolean, default: False) will cause cells with missing values to be ignored. Additionally, a renormalization is conducted. Adaptive masking has no effect for the nearest neighbour remapping methods.

The parameter na_thres (numeric, default: 1.0) allows to specify a maximum ratio of occuring missing values, up to which to apply this adaptive masking technique. If set to 1.0, no target grid cell that has any contribution of a souce grid cell will be set to missing_value. In rare cases this can lead to weird results for single cells with the bilinear and patch remapping methods. If set to 0.0, the target grid cell will be set to missing_value if any contributing cell of the source grid is missing.

A big advantage over the input mask approach is, that weights can be reused for input data on the same grid if it is masked differently (eg. 3D ocean data with the land sea mask varying with depth, 3D atmospheric data with orography varying with height, time dependent masks, …).

# We reuse the weights created above and store the remapped datasets in the same output dataset
for method in method_list:
    ds_out[method+"_tos_skipna"] = regridder[method+"_tos"](ds_tos.tos.isel(time=0), skipna=True, na_thres=0.3)

fig, axes = plt.subplots(3, 2, figsize=[16, 16])

for i, method in enumerate(method_list):
    ax = axes.flatten()[i]
    ds_out[method+"_tos_skipna"].plot.pcolormesh(ax=ax, shading="auto", cmap="RdBu_r")
    ax.set_title(method, fontsize=15)

plt.tight_layout()

The adaptive masking technique is best applied for the conservative and patch remapping methods, especially when upscaling (remapping to a coarser grid).

If skipna=True, na_thres=1.0 are set, the conservative method yields the same result as the conservative_normed method with a defined input mask.

More Examples#

For more examples see:

the extensive xESMF documentation
this selection of jupyter notebooks:

Jupyter Guide to Climate Data

Regridding with xESMF

Contents

Regridding with xESMF #

Prepare data#

Input data#

Target grid#

Perform regridding#

Plot the results#

Masking#

Use an input mask to obtain a better result#

Instead of an input mask, apply adaptive masking#

Regridding of the global dataset#

More Examples#

Jupyter Guide to Climate Data

Regridding with xESMF

Contents

Regridding with xESMF#

Prepare data#

Input data#

Target grid#

Perform regridding#

Plot the results#

Masking#

Use an input mask to obtain a better result#

Instead of an input mask, apply adaptive masking#

Regridding of the global dataset#

More Examples#

Regridding with xESMF #