Allow concatenation of string coordinates of differing width (#6676) (#7125)

* Allow concatenation of string coordinates of differing width

Concatenation compared coordinate dtypes exactly, so two cubes whose
string coordinate differed only in width (e.g. '<U1' vs '<U5') were
reported as having differing metadata and could not be concatenated.
When comparing the coordinate signatures, collapse string dtypes to
their kind so differing widths no longer block concatenation; numpy
promotes the points to a common width when they are joined. Genuine
dtype-kind differences (e.g. string vs integer) are still rejected.

Fixes #6676.

* Address string coordinate concat review comments

Author: gaoflow

changelog/7125.bugfix.rst

@@ -0,0 +1,4 @@
+:user:`gaoflow` fixed :meth:`iris.cube.CubeList.concatenate` so that cubes
+with string coordinates of differing width, such as dtypes ``<U1`` and
+``<U5``, can be concatenated. The result coordinate is promoted to the wider
+dtype. (:issue:`6676`)

lib/iris/_concatenate.py

@@ -102,6 +102,11 @@ def __new__(mcs, coord, dims):
         bounds_dtype = (
             coord.core_bounds().dtype if coord.core_bounds() is not None else None
         )
+        # Ignore string width; joined coordinates promote to a common width.
+        if points_dtype.kind in ("U", "S"):
+            points_dtype = np.dtype(points_dtype.kind)
+        if bounds_dtype is not None and bounds_dtype.kind in ("U", "S"):
+            bounds_dtype = np.dtype(bounds_dtype.kind)
         kwargs = {}
         # Add scalar flag metadata.
         kwargs["scalar"] = coord.core_points().size == 1

lib/iris/tests/unit/concatenate/test_concatenate.py

@@ -389,6 +389,39 @@ def test_desc_bounds_all_singleton(self):
         assert result1 == result2
 
 
+class TestStringAuxCoordWidths:
+    # Cubes with string auxiliary coordinates of differing width (dtype) should
+    # still concatenate, with the result promoted to the wider dtype (#6676).
+    def _make_cube(self, dim_points, aux_points):
+        data = np.arange(len(dim_points))
+        cube = iris.cube.Cube(data, long_name="test")
+        cube.add_dim_coord(iris.coords.DimCoord(dim_points, long_name="dim"), 0)
+        cube.add_aux_coord(
+            iris.coords.AuxCoord(np.array(aux_points), long_name="example"), 0
+        )
+        return cube
+
+    def test_different_widths(self):
+        cube_a = self._make_cube([0, 1], ["1", "2"])
+        cube_b = self._make_cube([10, 11, 12], ["1", "123", "12345"])
+        assert cube_a.coord("example").dtype != cube_b.coord("example").dtype
+
+        (result,) = concatenate([cube_a, cube_b], True)
+
+        coord = result.coord("example")
+        assert coord.dtype == np.dtype("<U5")
+        np.testing.assert_array_equal(coord.points, ["1", "2", "1", "123", "12345"])
+
+    def test_different_dtype_kind_still_rejected(self):
+        # A genuine dtype-kind difference (string vs integer) must still block
+        # concatenation.
+        cube_a = self._make_cube([0, 1], ["1", "2"])
+        cube_b = self._make_cube([2, 3], [1, 2])
+
+        with pytest.raises(ConcatenateError):
+            _ = concatenate([cube_a, cube_b], True)
+
+
 class TestConcatenate__dask:
     @pytest.fixture
     def sample_lazy_cubes(self):