Add option to ignore horizontal coordinates if there are multiple when regridding (#2672)

Author: bouweandela

doc/recipe/preprocessor.rst

@@ -887,6 +887,24 @@ The arguments are defined below:
   Otherwise, it cuts off at the previous value.
 * ``step_longitude``: Longitude distance between the centers of two neighbouring cells.
 
+Regridding input data with multiple horizontal coordinates
+----------------------------------------------------------
+
+When there are multiple horizontal coordinates available in the input data, the
+standard names of the coordinates to use need to be specified. By default, these
+are ``[latitude, longitude]``. To use the coordinates from a
+`rotated pole grid <https://cfconventions.org/Data/cf-conventions/cf-conventions-1.12/cf-conventions.html#grid-mappings-and-projections>`__,
+one would specify:
+
+.. code-block:: yaml
+
+    preprocessors:
+      regrid_preprocessor:
+        regrid:
+          target_grid: 1x1
+          scheme: linear
+          use_src_coords: [grid_latitude, grid_longitude]
+
 Regridding (interpolation, extrapolation) schemes
 -------------------------------------------------
 

esmvalcore/preprocessor/_regrid.py

@@ -10,6 +10,7 @@
 import re
 import ssl
 import warnings
+from collections.abc import Iterable
 from copy import deepcopy
 from decimal import Decimal
 from pathlib import Path
@@ -745,6 +746,7 @@ def regrid(
     lat_offset: bool = True,
     lon_offset: bool = True,
     cache_weights: bool = False,
+    use_src_coords: Iterable[str] = ("latitude", "longitude"),
 ) -> Cube:
     """Perform horizontal regridding.
 
@@ -800,6 +802,9 @@ def regrid(
         support weights caching. More details on this are given in the section
         on :ref:`caching_regridding_weights`. To clear the cache, use
         :func:`esmvalcore.preprocessor.regrid.cache_clear`.
+    use_src_coords:
+        If there are multiple horizontal coordinates available in the source
+        cube, only use horizontal coordinates with these standard names.
 
     Returns
     -------
@@ -848,6 +853,16 @@ def regrid(
             scheme:
               reference: esmf_regrid.schemes:ESMFAreaWeighted
     """
+    # Remove unwanted coordinates from the source cube.
+    cube = cube.copy()
+    use_src_coords = set(use_src_coords)
+    for axis in ("X", "Y"):
+        coords = cube.coords(axis=axis)
+        if len(coords) > 1:
+            for coord in coords:
+                if coord.standard_name not in use_src_coords:
+                    cube.remove_coord(coord)
+
     # Load target grid and select appropriate scheme
     target_grid_cube = _get_target_grid_cube(
         cube,
@@ -858,15 +873,16 @@ def regrid(
 
     # Horizontal grids from source and target (almost) match
     # -> Return source cube with target coordinates
-    if _horizontal_grid_is_close(cube, target_grid_cube):
-        for coord in ["latitude", "longitude"]:
-            cube.coord(coord).points = target_grid_cube.coord(
-                coord
-            ).core_points()
-            cube.coord(coord).bounds = target_grid_cube.coord(
-                coord
-            ).core_bounds()
-        return cube
+    if cube.coords("latitude") and cube.coords("longitude"):
+        if _horizontal_grid_is_close(cube, target_grid_cube):
+            for coord in ["latitude", "longitude"]:
+                cube.coord(coord).points = target_grid_cube.coord(
+                    coord
+                ).core_points()
+                cube.coord(coord).bounds = target_grid_cube.coord(
+                    coord
+                ).core_bounds()
+            return cube
 
     # Load scheme and reuse existing regridder if possible
     if isinstance(scheme, str):

tests/integration/preprocessor/_regrid/test_regrid.py

@@ -42,6 +42,31 @@ def setUp(self):
             dim_coords_and_dims=coords_spec,
         )
 
+        # Setup cube with multiple horizontal dimensions
+        self.multidim_cube = _make_cube(data, grid="rotated", aux_coord=False)
+        lats, lons = np.meshgrid(
+            np.arange(1, data.shape[-2] + 1),
+            np.arange(1, data.shape[-1] + 1),
+        )
+        self.multidim_cube.add_aux_coord(
+            iris.coords.AuxCoord(
+                lats,
+                var_name="lat",
+                standard_name="latitude",
+                units="degrees",
+            ),
+            (1, 2),
+        )
+        self.multidim_cube.add_aux_coord(
+            iris.coords.AuxCoord(
+                lons,
+                var_name="lon",
+                standard_name="longitude",
+                units="degrees",
+            ),
+            (1, 2),
+        )
+
         # Setup mesh cube
         self.mesh_cube = _make_cube(data, grid="mesh")
 
@@ -125,6 +150,17 @@ def test_regrid__linear(self, cache_weights):
         expected = np.array([[[1.5]], [[5.5]], [[9.5]]])
         assert_array_equal(result.data, expected)
 
+    def test_regrid__linear_multidim(self):
+        """Test that latitude/longitude are used by default."""
+        result = regrid(
+            self.multidim_cube,
+            self.grid_for_linear,
+            "linear",
+        )
+        expected = np.ma.masked_array([[[1.5]], [[5.5]], [[9.5]]], mask=False)
+        result.data = np.round(result.data, 1)
+        assert_array_equal(result.data, expected)
+
     @pytest.mark.parametrize("cache_weights", [True, False])
     def test_regrid__linear_file(self, tmp_path, cache_weights):
         file = tmp_path / "file.nc"

tests/unit/preprocessor/_regrid/__init__.py

@@ -37,12 +37,12 @@ def _make_vcoord(data, dtype=None):
 
 
 def _make_cube(
-    data,
-    aux_coord=True,
-    dim_coord=True,
+    data: np.ndarray,
+    aux_coord: bool = True,
+    dim_coord: bool = True,
     dtype=None,
     grid: Literal["regular", "rotated", "mesh"] = "regular",
-):
+) -> iris.cube.Cube:
     """Create a 3d synthetic test cube."""
     if dtype is None:
         dtype = np.int32

tests/unit/preprocessor/_regrid/test_regrid.py

@@ -233,7 +233,7 @@ def test_regrid_is_skipped_if_grids_are_the_same():
 
     # regridding to the same spec returns the same cube
     expected_same_cube = regrid(cube, target_grid="10x10", scheme=scheme)
-    assert expected_same_cube is cube
+    assert expected_same_cube == cube
 
     # regridding to a different spec returns a different cube
     expected_different_cube = regrid(cube, target_grid="5x5", scheme=scheme)