roms-tools 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

roms_tools/tests/test_setup/test_nesting.py

@@ -11,9 +11,11 @@ from roms_tools.setup.nesting import (
     compute_boundary_distance,
     interpolate_indices,
     map_child_boundaries_onto_parent_grid_indices,
-    modify_child_topography_and_mask,
+    modify_child_mask,
+    modify_child_topography,
 )
 from roms_tools.setup.utils import get_boundary_coords
+from roms_tools.utils import wrap_longitudes
 
 
 @pytest.fixture()
@@ -46,9 +48,7 @@ def big_grid_that_straddles():
 
 @pytest.fixture()
 def small_grid_that_straddles():
-    return Grid(
-        nx=10, ny=10, center_lon=10, center_lat=61, rot=-20, size_x=500, size_y=500
-    )
+    return Grid(nx=10, ny=10, center_lon=0, center_lat=61, rot=0, size_x=50, size_y=200)
 
 
 @pytest.fixture()
@@ -71,11 +71,11 @@ def child_grid_that_straddles(big_grid_that_straddles):
         parent_grid=big_grid_that_straddles,
         nx=10,
         ny=10,
-        center_lon=10,
+        center_lon=0,
         center_lat=61,
-        rot=-20,
-        size_x=500,
-        size_y=500,
+        rot=0,
+        size_x=50,
+        size_y=200,
     )
 
 
@@ -100,13 +100,14 @@ class TestInterpolateIndices:
             mask = grid.ds[f"mask_{location}"].isel(**bdry_coords)
 
             with caplog.at_level(logging.WARNING):
-                i_eta, i_xi = interpolate_indices(grid.ds, lon, lat, mask)
+                i_eta, i_xi = interpolate_indices(grid.ds, lon, lat, mask, direction)
 
-            # Verify the warning message in the log
-            assert (
-                "Some boundary points of the child grid are very close to the boundary of the parent grid."
-                in caplog.text
-            )
+            if mask.sum() > 0:
+                # Verify the warning message in the log
+                assert (
+                    "boundary of the child grid lie very close to the edges of the parent grid"
+                    in caplog.text
+                )
 
             if direction == "south":
                 expected_i_eta = -0.5 * xr.ones_like(grid.ds.xi_rho)
@@ -142,20 +143,27 @@ class TestInterpolateIndices:
         big_grid = request.getfixturevalue(big_grid_fixture)
         small_grid = request.getfixturevalue(small_grid_fixture)
 
+        big_grid_ds = wrap_longitudes(big_grid.ds.copy(), straddle=big_grid.straddle)
+        small_grid_ds = wrap_longitudes(
+            small_grid.ds.copy(), straddle=big_grid.straddle
+        )
+
         bdry_coords_dict = get_boundary_coords()
         for location in ["rho", "u", "v"]:
             for direction in ["south", "east", "north", "west"]:
                 bdry_coords = bdry_coords_dict[location][direction]
-                lon = small_grid.ds[f"lon_{location}"].isel(**bdry_coords)
-                lat = small_grid.ds[f"lat_{location}"].isel(**bdry_coords)
-                mask = small_grid.ds[f"mask_{location}"].isel(**bdry_coords)
+                lon = small_grid_ds[f"lon_{location}"].isel(**bdry_coords)
+                lat = small_grid_ds[f"lat_{location}"].isel(**bdry_coords)
+                mask = small_grid_ds[f"mask_{location}"].isel(**bdry_coords)
 
-                i_eta, i_xi = interpolate_indices(big_grid.ds, lon, lat, mask)
+                i_eta, i_xi = interpolate_indices(
+                    big_grid_ds, lon, lat, mask, direction
+                )
 
                 expected_i_eta_min = -0.5
-                expected_i_eta_max = big_grid.ds.eta_rho[-1] - 0.5
+                expected_i_eta_max = big_grid_ds.eta_rho[-1] - 0.5
                 expected_i_xi_min = -0.5
-                expected_i_xi_max = big_grid.ds.xi_rho[-1] - 0.5
+                expected_i_xi_max = big_grid_ds.xi_rho[-1] - 0.5
 
                 assert (i_eta >= expected_i_eta_min).all()
                 assert (i_eta <= expected_i_eta_max).all()
@@ -166,11 +174,16 @@ class TestInterpolateIndices:
 class TestMapChildBoundaries:
     def test_update_indices_does_nothing_if_no_parent_land(self, small_grid, baby_grid):
         """Verify no change in indices when parent grid has no land at boundaries."""
+        small_grid_ds = wrap_longitudes(
+            small_grid.ds.copy(), straddle=small_grid.straddle
+        )
+        baby_grid_ds = wrap_longitudes(baby_grid.ds.copy(), straddle=baby_grid.straddle)
+
         ds_without_updated_indices = map_child_boundaries_onto_parent_grid_indices(
-            small_grid.ds, baby_grid.ds, update_land_indices=False
+            small_grid_ds, baby_grid_ds, update_land_indices=False
         )
         ds_with_updated_indices = map_child_boundaries_onto_parent_grid_indices(
-            small_grid.ds, baby_grid.ds, update_land_indices=True
+            small_grid_ds, baby_grid_ds, update_land_indices=True
         )
 
         xr.testing.assert_allclose(ds_without_updated_indices, ds_with_updated_indices)
@@ -189,7 +202,12 @@ class TestMapChildBoundaries:
         big_grid = request.getfixturevalue(big_grid_fixture)
         small_grid = request.getfixturevalue(small_grid_fixture)
 
-        ds = map_child_boundaries_onto_parent_grid_indices(big_grid.ds, small_grid.ds)
+        big_grid_ds = wrap_longitudes(big_grid.ds.copy(), straddle=big_grid.straddle)
+        small_grid_ds = wrap_longitudes(
+            small_grid.ds.copy(), straddle=big_grid.straddle
+        )
+
+        ds = map_child_boundaries_onto_parent_grid_indices(big_grid_ds, small_grid_ds)
         for direction in ["south", "east", "north", "west"]:
             for location in ["rho", "u", "v"]:
                 if location == "rho":
@@ -224,9 +242,14 @@ class TestMapChildBoundaries:
         big_grid = request.getfixturevalue(big_grid_fixture)
         small_grid = request.getfixturevalue(small_grid_fixture)
 
+        big_grid_ds = wrap_longitudes(big_grid.ds.copy(), straddle=big_grid.straddle)
+        small_grid_ds = wrap_longitudes(
+            small_grid.ds.copy(), straddle=big_grid.straddle
+        )
+
         for update_land_indices in [False, True]:
             ds = map_child_boundaries_onto_parent_grid_indices(
-                big_grid.ds, small_grid.ds, update_land_indices=update_land_indices
+                big_grid_ds, small_grid_ds, update_land_indices=update_land_indices
             )
 
             for direction in ["south", "east", "north", "west"]:
@@ -292,9 +315,7 @@ class TestModifyChid:
     ):
         """Confirm child mask remains unchanged if no parent land is at boundaries."""
         mask_original = baby_grid.ds.mask_rho.copy()
-        modified_baby_grid_ds = modify_child_topography_and_mask(
-            small_grid.ds, baby_grid.ds
-        )
+        modified_baby_grid_ds = modify_child_mask(small_grid.ds, baby_grid.ds)
         xr.testing.assert_allclose(modified_baby_grid_ds.mask_rho, mask_original)
 
     @pytest.mark.parametrize(
@@ -311,7 +332,8 @@ class TestModifyChid:
 
         h_original = grid.ds.h.copy()
         mask_original = grid.ds.mask_rho.copy()
-        modified_grid_ds = modify_child_topography_and_mask(grid.ds, grid.ds)
+        modified_grid_ds = modify_child_mask(grid.ds, grid.ds)
+        modified_grid_ds = modify_child_topography(grid.ds, modified_grid_ds)
 
         xr.testing.assert_allclose(modified_grid_ds.h, h_original)
         xr.testing.assert_allclose(modified_grid_ds.mask_rho, mask_original)
@@ -325,7 +347,8 @@ class TestModifyChid:
         mask_original = small_grid.ds.mask_rho.copy()
 
         # Apply the modification function
-        modified_ds = modify_child_topography_and_mask(big_grid.ds, small_grid.ds)
+        modified_ds = modify_child_mask(big_grid.ds, small_grid.ds)
+        modified_ds = modify_child_topography(big_grid.ds, modified_ds)
 
         # Calculate the center indices for the grid
         eta_center = h_original.sizes["eta_rho"] // 2
@@ -405,9 +428,75 @@ class TestNesting:
         params = dataclasses.asdict(small_grid)
         del params["ds"], params["straddle"]
 
-        with pytest.raises(ValueError, match="Some points are outside the grid."):
+        with pytest.raises(
+            ValueError, match="boundary of the child grid lie outside the parent grid"
+        ):
             ChildGrid(parent_grid=big_grid, **params)
 
+    def test_no_error_if_land_child_points_beyond_parent_grid(self):
+        # coarse resolution Pacific domain
+        parent_grid = Grid(
+            nx=50,
+            ny=50,
+            size_x=23000,
+            size_y=12000,
+            center_lon=-161,
+            center_lat=14.4,
+            rot=-3,
+        )
+
+        # California Current System domain, where some land points extend beyond Pacific domain
+        child_grid_parameters = {
+            "nx": 50,
+            "ny": 50,
+            "size_x": 2688,
+            "size_y": 5280,
+            "center_lat": 39.6,
+            "center_lon": -134.5,
+            "rot": 33.3,
+        }
+
+        child_grid = ChildGrid(
+            **child_grid_parameters,
+            parent_grid=parent_grid,
+            boundaries={"north": True, "west": True, "south": True, "east": False},
+        )
+        assert isinstance(child_grid.ds, xr.Dataset)
+
+    def test_no_error_if_child_boundary_entirely_on_land(self):
+        parent_grid = Grid(
+            nx=7,
+            ny=7,
+            size_x=240,
+            size_y=240,
+            center_lon=-4.1,
+            center_lat=52.36,
+            rot=0,
+        )
+
+        child_grid_parameters = {
+            "nx": 5,
+            "ny": 5,
+            "size_x": 100,
+            "size_y": 100,
+            "center_lon": -4.1,
+            "center_lat": 52.36,
+        }
+
+        child_grid = ChildGrid(
+            **child_grid_parameters,
+            parent_grid=parent_grid,
+            boundaries={
+                "south": True,
+                "east": True,
+                "north": True,
+                "west": True,
+            },
+        )
+
+        assert isinstance(child_grid.ds, xr.Dataset)
+        assert isinstance(child_grid.ds_nesting, xr.Dataset)
+
     @pytest.mark.parametrize(
         "child_grid_fixture",
         ["child_grid", "child_grid_that_straddles"],

roms_tools/tests/test_setup/test_surface_forcing.py

@@ -9,8 +9,8 @@ import xarray as xr
 
 from conftest import calculate_data_hash
 from roms_tools import Grid, SurfaceForcing
-from roms_tools.download import download_test_data
-from roms_tools.setup.datasets import RawDataSource
+from roms_tools.datasets.download import download_test_data
+from roms_tools.setup.utils import RawDataSource
 
 
 @pytest.fixture

roms_tools/tests/test_setup/test_tides.py

@@ -6,7 +6,7 @@ import xarray as xr
 
 from conftest import calculate_data_hash
 from roms_tools import Grid, TidalForcing
-from roms_tools.download import download_test_data
+from roms_tools.datasets.download import download_test_data
 
 
 @pytest.fixture(scope="session")

roms_tools/tests/test_setup/test_utils.py

@@ -7,11 +7,11 @@ import pytest
 import xarray as xr
 
 from roms_tools import BoundaryForcing, Grid
-from roms_tools.download import download_test_data
-from roms_tools.setup.datasets import ERA5Correction
+from roms_tools.datasets.download import download_test_data
 from roms_tools.setup.utils import (
+    _infer_valid_boundaries_from_mask,
+    check_and_set_boundaries,
     get_target_coords,
-    interpolate_from_climatology,
     validate_names,
 )
 
@@ -101,18 +101,6 @@ class TestGetTargetCoords:
         assert "mask" in result
 
 
-def test_interpolate_from_climatology(use_dask):
-    fname = download_test_data("ERA5_regional_test_data.nc")
-    era5_times = xr.open_dataset(fname).time
-
-    climatology = ERA5Correction(use_dask=use_dask)
-    field = climatology.ds["ssr_corr"]
-    field["time"] = field["time"].dt.days
-
-    interpolated_field = interpolate_from_climatology(field, "time", era5_times)
-    assert len(interpolated_field.time) == len(era5_times)
-
-
 # Test yaml roundtrip with multiple source files
 @pytest.fixture()
 def boundary_forcing_from_multiple_source_files(request, use_dask):
@@ -210,3 +198,100 @@ def test_non_string_elements_in_list_raises():
 def test_custom_label_in_errors():
     with pytest.raises(ValueError, match="Invalid foozs: z"):
         validate_names(["z"], VALID_NAMES, SENTINEL, MAX_TO_PLOT, label="fooz")
+
+
+# test _infer_valid_boundaries_from_mask
+@pytest.fixture
+def simple_mask():
+    data = np.array(
+        [
+            [0, 0, 0, 0],  # south
+            [1, 0, 0, 0],
+            [1, 0, 0, 0],
+            [1, 1, 1, 1],  # north
+        ]
+    )
+    return xr.DataArray(data, dims=("eta_rho", "xi_rho"))
+
+
+def test_infer_valid_boundaries_partial(simple_mask):
+    out = _infer_valid_boundaries_from_mask(simple_mask)
+
+    assert out == {
+        "south": False,
+        "north": True,
+        "west": True,
+        "east": True,
+    }
+
+
+def test_infer_valid_boundaries_all_ocean():
+    mask = xr.DataArray(np.ones((3, 3)), dims=("eta_rho", "xi_rho"))
+
+    out = _infer_valid_boundaries_from_mask(mask)
+    assert all(out.values())
+
+
+# test check_and_set_boundaries
+
+
+def test_check_and_set_default_boundaries(simple_mask, monkeypatch):
+    monkeypatch.setattr(
+        "roms_tools.setup.utils._infer_valid_boundaries_from_mask",
+        lambda mask: {
+            "south": True,
+            "north": False,
+            "west": True,
+            "east": False,
+        },
+    )
+
+    result = check_and_set_boundaries(None, simple_mask)
+
+    assert result == {
+        "south": True,
+        "north": False,
+        "west": True,
+        "east": False,
+    }
+
+
+def test_check_and_set_partial_boundaries(simple_mask, monkeypatch):
+    monkeypatch.setattr(
+        "roms_tools.setup.utils._infer_valid_boundaries_from_mask",
+        lambda mask: {
+            "south": True,
+            "north": False,
+            "west": True,
+            "east": False,
+        },
+    )
+
+    user = {"south": False}  # user overrides south → False
+
+    result = check_and_set_boundaries(user, simple_mask)
+
+    assert result == {
+        "south": False,  # user-preserved
+        "north": False,  # inferred
+        "west": True,  # inferred
+        "east": False,  # inferred
+    }
+
+
+def test_check_and_set_type_error(simple_mask):
+    with pytest.raises(TypeError):
+        check_and_set_boundaries({"south": "yes"}, simple_mask)
+
+
+def test_check_and_set_invalid_key(simple_mask):
+    with pytest.raises(ValueError):
+        check_and_set_boundaries({"northeast": True}, simple_mask)
+
+
+def test_check_and_set_full_user_boundaries(simple_mask):
+    boundaries = {"south": False, "north": True, "east": False, "west": True}
+
+    result = check_and_set_boundaries(boundaries, simple_mask)
+
+    assert result == boundaries  # unchanged

roms_tools/tests/test_tiling/test_partition.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 
+import numpy as np
 import pytest
+import xarray as xr
 import xarray.testing as xrt
 
 from roms_tools import Grid
@@ -18,7 +20,7 @@ class TestPartitionGrid:
     def test_partition_grid_along_x(self, grid):
         _, [ds1, ds2, ds3] = partition(grid.ds, np_eta=3, np_xi=1)
 
-        assert ds1.sizes == {
+        assert dict(ds1.sizes) == {
             "eta_rho": 11,
             "xi_rho": 32,
             "xi_u": 31,
@@ -30,7 +32,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds2.sizes == {
+        assert dict(ds2.sizes) == {
             "eta_rho": 10,
             "xi_rho": 32,
             "xi_u": 31,
@@ -42,7 +44,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds3.sizes == {
+        assert dict(ds3.sizes) == {
             "eta_rho": 11,
             "xi_rho": 32,
             "xi_u": 31,
@@ -58,7 +60,7 @@ class TestPartitionGrid:
     def test_partition_grid_along_y(self, grid):
         _, [ds1, ds2, ds3] = partition(grid.ds, np_eta=1, np_xi=3)
 
-        assert ds1.sizes == {
+        assert dict(ds1.sizes) == {
             "eta_rho": 32,
             "xi_rho": 11,
             "xi_u": 10,
@@ -70,7 +72,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds2.sizes == {
+        assert dict(ds2.sizes) == {
             "eta_rho": 32,
             "xi_rho": 10,
             "xi_u": 10,
@@ -82,7 +84,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds3.sizes == {
+        assert dict(ds3.sizes) == {
             "eta_rho": 32,
             "xi_rho": 11,
             "xi_u": 11,
@@ -103,7 +105,7 @@ class TestPartitionGrid:
          ds7, ds8, ds9] = partition(grid.ds, np_eta=3, np_xi=3)
         # fmt: on
 
-        assert ds1.sizes == {
+        assert dict(ds1.sizes) == {
             "eta_rho": 11,
             "xi_rho": 11,
             "xi_u": 10,
@@ -115,7 +117,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds4.sizes == {
+        assert dict(ds4.sizes) == {
             "eta_rho": 10,
             "xi_rho": 11,
             "xi_u": 10,
@@ -127,7 +129,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds7.sizes == {
+        assert dict(ds7.sizes) == {
             "eta_rho": 11,
             "xi_rho": 11,
             "xi_u": 10,
@@ -139,7 +141,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds2.sizes == {
+        assert dict(ds2.sizes) == {
             "eta_rho": 11,
             "xi_rho": 10,
             "xi_u": 10,
@@ -151,7 +153,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds5.sizes == {
+        assert dict(ds5.sizes) == {
             "eta_rho": 10,
             "xi_rho": 10,
             "xi_u": 10,
@@ -163,7 +165,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds8.sizes == {
+        assert dict(ds8.sizes) == {
             "eta_rho": 11,
             "xi_rho": 10,
             "xi_u": 10,
@@ -175,7 +177,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds3.sizes == {
+        assert dict(ds3.sizes) == {
             "eta_rho": 11,
             "xi_rho": 11,
             "xi_u": 11,
@@ -187,7 +189,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds6.sizes == {
+        assert dict(ds6.sizes) == {
             "eta_rho": 10,
             "xi_rho": 11,
             "xi_u": 11,
@@ -199,7 +201,7 @@ class TestPartitionGrid:
             "s_rho": 100,
             "s_w": 101,
         }
-        assert ds9.sizes == {
+        assert dict(ds9.sizes) == {
             "eta_rho": 11,
             "xi_rho": 11,
             "xi_u": 11,
@@ -246,6 +248,52 @@ class TestPartitionGrid:
             assert ds.sizes["xi_coarse"] == grid.ds.sizes["xi_coarse"]
 
 
+class TestPartitionGridWithExtraDims:
+    @pytest.fixture
+    def ds_with_extra_dims(self):
+        # Base dims
+        eta_rho = 10
+        xi_rho = 12
+        s_rho = 5
+        eta_v = eta_rho - 1
+        xi_u = xi_rho - 1
+
+        # Extra dims
+        eta_u = eta_rho
+        xi_v = xi_rho
+
+        ds = xr.Dataset(
+            {
+                "zeta": (("eta_rho", "xi_rho"), np.zeros((eta_rho, xi_rho))),
+                "u": (("s_rho", "eta_u", "xi_u"), np.zeros((s_rho, eta_u, xi_u))),
+                "v": (("s_rho", "eta_v", "xi_v"), np.zeros((s_rho, eta_v, xi_v))),
+            },
+            coords={
+                "eta_rho": np.arange(eta_rho),
+                "eta_u": np.arange(eta_u),
+                "eta_v": np.arange(eta_v),
+                "xi_rho": np.arange(xi_rho),
+                "xi_u": np.arange(xi_u),
+                "xi_v": np.arange(xi_v),
+                "s_rho": np.arange(s_rho),
+            },
+        )
+
+        return ds
+
+    def test_partition_with_extra_dims(self, ds_with_extra_dims):
+        file_numbers, parts = partition(ds_with_extra_dims, np_eta=2, np_xi=2)
+
+        # Test that partitioned datasets contain eta_u and xi_v
+        for ds_part in parts:
+            assert "eta_u" in ds_part.dims
+            assert "xi_v" in ds_part.dims
+            assert ds_part.sizes["eta_u"] < ds_with_extra_dims.sizes["eta_u"]
+            assert ds_part.sizes["xi_v"] < ds_with_extra_dims.sizes["xi_v"]
+            assert ds_part.sizes["eta_u"] > 0
+            assert ds_part.sizes["xi_v"] > 0
+
+
 class TestPartitionMissingDims:
     def test_partition_missing_dims(self, grid):
         dims_to_drop = ["xi_u", "eta_v", "eta_coarse", "xi_coarse"]

roms_tools/tests/test_utils.py

@@ -3,9 +3,12 @@ from pathlib import Path
 from unittest import mock
 
 import numpy as np
+import pandas as pd
 import pytest
 import xarray as xr
 
+from roms_tools.datasets.download import download_test_data
+from roms_tools.datasets.lat_lon_datasets import ERA5Correction
 from roms_tools.utils import (
     _path_list_from_input,
     generate_focused_coordinate_range,
@@ -13,6 +16,8 @@ from roms_tools.utils import (
     has_copernicus,
     has_dask,
     has_gcsfs,
+    interpolate_cyclic_time,
+    interpolate_from_climatology,
     load_data,
 )
 
@@ -241,3 +246,76 @@ def test_time_chunking_false_roms():
     dim_names = {"time": "ocean_time"}
     result = get_dask_chunks(dim_names, time_chunking=False)
     assert "ocean_time" not in result
+
+
+# test interpolate_from_climatology
+
+
+@pytest.fixture
+def climatology_data():
+    """Create a simple annual cycle dataset with 12 time points."""
+    time_coord = np.arange(1, 13)  # months as day_of_year approximation
+    da = xr.DataArray(np.arange(12), dims=("time",), coords={"time": time_coord})
+    ds = xr.Dataset({"var1": da, "var2": da * 2})
+    return da, ds, "time", "time"
+
+
+def test_interpolate_dataarray_single_time(climatology_data):
+    da, _, time_dim, time_coord = climatology_data
+    target_time = pd.Timestamp("2000-03-15")  # day_of_year ~ 75
+    interpolated = interpolate_from_climatology(da, time_dim, time_coord, target_time)
+    assert isinstance(interpolated, xr.DataArray)
+    assert interpolated.sizes[time_dim] == 1
+
+
+def test_interpolate_dataset_multiple_times(climatology_data):
+    _, ds, time_dim, time_coord = climatology_data
+    target_times = pd.date_range("2000-01-01", periods=3, freq="ME")
+    interpolated = interpolate_from_climatology(ds, time_dim, time_coord, target_times)
+    assert isinstance(interpolated, xr.Dataset)
+    assert all(interpolated[var].sizes[time_dim] == 3 for var in interpolated.data_vars)
+
+
+def test_interpolate_dataarray_time_dim_not_equal_time_coord():
+    time_values = np.arange(1, 13)
+    da = xr.DataArray(
+        np.arange(12),
+        dims=("time_dim",),
+        coords={"time_coord": ("time_dim", time_values)},
+    )
+    target_time = pd.Timestamp("2000-06-15")
+    interpolated = interpolate_from_climatology(
+        da, time_dim="time_dim", time_coord="time_coord", time=target_time
+    )
+    assert interpolated.sizes["time_dim"] == 1
+    assert np.issubdtype(interpolated.dtype, np.number)
+
+
+def test_interpolate_cyclic_time_basic():
+    time_values = np.arange(1, 13)
+    da = xr.DataArray(np.arange(12), dims=("time",), coords={"time": time_values})
+    target_days = [0.5, 6.5, 12.5]  # fractional days, include cyclic behavior
+    interpolated = interpolate_cyclic_time(
+        da, time_dim="time", time_coord="time", day_of_year=target_days
+    )
+    assert isinstance(interpolated, xr.DataArray)
+    assert interpolated.sizes["time"] == len(target_days)
+
+
+def test_interpolate_from_climatology_invalid_input():
+    with pytest.raises(TypeError):
+        interpolate_from_climatology(
+            "not a dataset", "time", "time", pd.Timestamp("2000-01-01")
+        )
+
+
+def test_interpolate_from_real_climatology(use_dask):
+    fname = download_test_data("ERA5_regional_test_data.nc")
+    era5_times = xr.open_dataset(fname).time
+
+    climatology = ERA5Correction(use_dask=use_dask)
+    field = climatology.ds["ssr_corr"]
+    field["time"] = field["time"].dt.days
+
+    interpolated_field = interpolate_from_climatology(field, "time", "time", era5_times)
+    assert len(interpolated_field.time) == len(era5_times)