roms-tools 2.3.0__py3-none-any.whl → 2.5.0__py3-none-any.whl

roms_tools/tests/test_setup/test_surface_forcing.py

@@ -5,7 +5,8 @@ from roms_tools import Grid, SurfaceForcing
 from roms_tools.download import download_test_data
 import textwrap
 from pathlib import Path
-from conftest import calculate_file_hash
+import logging
+from conftest import calculate_data_hash
 
 
 @pytest.fixture
@@ -163,7 +164,9 @@ def grid_that_lies_west_of_dateline_more_than_five_degrees_away():
         "grid_that_lies_west_of_dateline_more_than_five_degrees_away",
     ],
 )
-def test_successful_initialization_with_regional_data(grid_fixture, request, use_dask):
+def test_successful_initialization_with_regional_data(
+    grid_fixture, request, caplog, use_dask
+):
     """Test the initialization of SurfaceForcing with regional ERA5 data.
 
     The test is performed twice:
@@ -178,16 +181,17 @@ def test_successful_initialization_with_regional_data(grid_fixture, request, use
 
     grid = request.getfixturevalue(grid_fixture)
 
-    for use_coarse_grid in [False, True]:
-        sfc_forcing = SurfaceForcing(
-            grid=grid,
-            use_coarse_grid=use_coarse_grid,
-            start_time=start_time,
-            end_time=end_time,
-            source={"name": "ERA5", "path": fname},
-            correct_radiation=True,
-            use_dask=use_dask,
-        )
+    for coarse_grid_mode in ["always", "never"]:
+        with caplog.at_level(logging.INFO):
+            sfc_forcing = SurfaceForcing(
+                grid=grid,
+                start_time=start_time,
+                end_time=end_time,
+                source={"name": "ERA5", "path": fname},
+                correct_radiation=True,
+                coarse_grid_mode=coarse_grid_mode,
+                use_dask=use_dask,
+            )
 
         assert sfc_forcing.ds is not None
         assert "uwnd" in sfc_forcing.ds
@@ -208,10 +212,15 @@ def test_successful_initialization_with_regional_data(grid_fixture, request, use
         }
         assert sfc_forcing.ds.coords["time"].attrs["units"] == "days"
 
-        if use_coarse_grid:
+        if coarse_grid_mode == "always":
             assert sfc_forcing.use_coarse_grid
-        else:
+            assert (
+                "Data will be interpolated onto grid coarsened by factor 2."
+                in caplog.text
+            )
+        elif coarse_grid_mode == "never":
             assert not sfc_forcing.use_coarse_grid
+            assert "Data will be interpolated onto fine grid." in caplog.text
 
         sfc_forcing.plot("uwnd", time=0)
         sfc_forcing.plot("vwnd", time=0)
@@ -239,12 +248,12 @@ def test_nan_detection_initialization_with_regional_data(
 
     grid = request.getfixturevalue(grid_fixture)
 
-    for use_coarse_grid in [True, False]:
+    for coarse_grid_mode in ["always", "never"]:
         with pytest.raises(ValueError, match="NaN values found"):
 
             SurfaceForcing(
                 grid=grid,
-                use_coarse_grid=use_coarse_grid,
+                coarse_grid_mode=coarse_grid_mode,
                 start_time=start_time,
                 end_time=end_time,
                 source={"name": "ERA5", "path": fname},
@@ -266,14 +275,14 @@ def test_no_longitude_intersection_initialization_with_regional_data(
 
     fname = Path(download_test_data("ERA5_regional_test_data.nc"))
 
-    for use_coarse_grid in [True, False]:
+    for coarse_grid_mode in ["always", "never"]:
         with pytest.raises(
             ValueError, match="Selected longitude range does not intersect with dataset"
         ):
 
             SurfaceForcing(
                 grid=grid_that_straddles_180_degree_meridian,
-                use_coarse_grid=use_coarse_grid,
+                coarse_grid_mode=coarse_grid_mode,
                 start_time=start_time,
                 end_time=end_time,
                 source={"name": "ERA5", "path": fname},
@@ -308,10 +317,10 @@ def test_successful_initialization_with_global_data(grid_fixture, request, use_d
 
     grid = request.getfixturevalue(grid_fixture)
 
-    for use_coarse_grid in [True, False]:
+    for coarse_grid_mode in ["always", "never"]:
         sfc_forcing = SurfaceForcing(
             grid=grid,
-            use_coarse_grid=use_coarse_grid,
+            coarse_grid_mode=coarse_grid_mode,
             start_time=start_time,
             end_time=end_time,
             source={"name": "ERA5", "path": fname},
@@ -336,12 +345,59 @@ def test_successful_initialization_with_global_data(grid_fixture, request, use_d
         assert sfc_forcing.ds.attrs["source"] == "ERA5"
         assert sfc_forcing.ds.coords["time"].attrs["units"] == "days"
 
-        if use_coarse_grid:
+        if coarse_grid_mode == "always":
             assert sfc_forcing.use_coarse_grid
-        else:
+        elif coarse_grid_mode == "never":
             assert not sfc_forcing.use_coarse_grid
 
 
+def test_start_time_end_time_error(use_dask):
+    """Test error when start_time and end_time are not both provided or both None."""
+    # Case 1: Only start_time provided
+    with pytest.raises(
+        ValueError, match="Both `start_time` and `end_time` must be provided together"
+    ):
+        SurfaceForcing(
+            grid=None,
+            start_time=datetime(2022, 1, 1),
+            end_time=None,  # end_time is None, should raise an error
+            source={"name": "ERA5", "path": "era5_data.nc"},
+            use_dask=use_dask,
+        )
+
+    # Case 2: Only end_time provided
+    with pytest.raises(
+        ValueError, match="Both `start_time` and `end_time` must be provided together"
+    ):
+        SurfaceForcing(
+            grid=None,
+            start_time=None,  # start_time is None, should raise an error
+            end_time=datetime(2022, 1, 2),
+            source={"name": "ERA5", "path": "era5_data.nc"},
+            use_dask=use_dask,
+        )
+
+
+def test_start_time_end_time_warning(grid_that_straddles_dateline, use_dask, caplog):
+    """Test that a warning is triggered when both start_time and end_time are None."""
+    fname = Path(download_test_data("ERA5_regional_test_data.nc"))
+
+    with caplog.at_level(logging.INFO):
+        SurfaceForcing(
+            grid=grid_that_straddles_dateline,
+            start_time=None,
+            end_time=None,
+            source={"name": "ERA5", "path": fname},
+            use_dask=use_dask,
+        )
+
+    # Verify the warning message in the log
+    assert (
+        "Both `start_time` and `end_time` are None. No time filtering will be applied to the source data."
+        in caplog.text
+    )
+
+
 def test_nans_filled_in(grid_that_straddles_dateline, use_dask):
     """Test that the surface forcing fields contain no NaNs.
 
@@ -356,10 +412,10 @@ def test_nans_filled_in(grid_that_straddles_dateline, use_dask):
     fname = Path(download_test_data("ERA5_regional_test_data.nc"))
     fname_bgc = Path(download_test_data("CESM_surface_global_test_data_climatology.nc"))
 
-    for use_coarse_grid in [True, False]:
+    for coarse_grid_mode in ["always", "never"]:
         sfc_forcing = SurfaceForcing(
             grid=grid_that_straddles_dateline,
-            use_coarse_grid=use_coarse_grid,
+            coarse_grid_mode=coarse_grid_mode,
             start_time=start_time,
             end_time=end_time,
             source={"name": "ERA5", "path": fname},
@@ -375,7 +431,7 @@ def test_nans_filled_in(grid_that_straddles_dateline, use_dask):
 
         sfc_forcing = SurfaceForcing(
             grid=grid_that_straddles_dateline,
-            use_coarse_grid=use_coarse_grid,
+            coarse_grid_mode=coarse_grid_mode,
             start_time=start_time,
             end_time=end_time,
             source={"name": "CESM_REGRIDDED", "path": fname_bgc, "climatology": True},
@@ -479,6 +535,57 @@ def test_surface_forcing_pco2_replication(sfc_forcing_fixture, request):
     )
 
 
+def test_determine_usage_coarse_grid():
+    # ERA5 data with 1/4 degree resolution spanning [-50E, 30E] and [40N, 80N]
+    fname = download_test_data("ERA5_regional_test_data.nc")
+
+    # at 50N, 1/4 degree of longitude is about 17.87 km; to automatically use the coarse grid, the ROMS grid needs to be of resolution < 17.87km / 2 = 8.9km
+    grid_10km = Grid(
+        nx=3, ny=3, size_x=30, size_y=30, center_lon=-10, center_lat=50, rot=0
+    )
+    surface_forcing = SurfaceForcing(
+        grid=grid_10km,
+        start_time=datetime(2020, 2, 1),
+        end_time=datetime(2020, 2, 2),
+        source={"name": "ERA5", "path": fname},
+    )
+    assert not surface_forcing.use_coarse_grid
+
+    grid_7km = Grid(
+        nx=3, ny=3, size_x=21, size_y=21, center_lon=-10, center_lat=50, rot=0
+    )
+    surface_forcing = SurfaceForcing(
+        grid=grid_7km,
+        start_time=datetime(2020, 2, 1),
+        end_time=datetime(2020, 2, 2),
+        source={"name": "ERA5", "path": fname},
+    )
+    assert surface_forcing.use_coarse_grid
+
+    # at 70N, 1/4 degree of longitude is about 9.5 km; to automatically use the coarse grid, the ROMS grid needs to be of resolution < 9.5km / 2 = 4.75km
+    grid_7km = Grid(
+        nx=3, ny=3, size_x=21, size_y=21, center_lon=-10, center_lat=70, rot=0
+    )
+    surface_forcing = SurfaceForcing(
+        grid=grid_7km,
+        start_time=datetime(2020, 2, 1),
+        end_time=datetime(2020, 2, 2),
+        source={"name": "ERA5", "path": fname},
+    )
+    assert not surface_forcing.use_coarse_grid
+
+    grid_4km = Grid(
+        nx=3, ny=3, size_x=12, size_y=12, center_lon=-10, center_lat=70, rot=0
+    )
+    surface_forcing = SurfaceForcing(
+        grid=grid_4km,
+        start_time=datetime(2020, 2, 1),
+        end_time=datetime(2020, 2, 2),
+        source={"name": "ERA5", "path": fname},
+    )
+    assert surface_forcing.use_coarse_grid
+
+
 @pytest.mark.parametrize(
     "sfc_forcing_fixture",
     [
@@ -499,15 +606,15 @@ def test_surface_forcing_save(sfc_forcing_fixture, request, tmp_path):
             str(tmp_path / file_str),
         ]:  # test for Path object and str
 
-            # Test saving without partitioning and grouping
-            saved_filenames = sfc_forcing.save(filepath)
+            # Test saving without grouping
+            saved_filenames = sfc_forcing.save(filepath, group=False)
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}.nc")
             assert saved_filenames == [expected_filepath]
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving without partitioning but with grouping
+            # Test saving with grouping
             saved_filenames = sfc_forcing.save(filepath, group=True)
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}_202002.nc")
@@ -515,17 +622,6 @@ def test_surface_forcing_save(sfc_forcing_fixture, request, tmp_path):
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving with partitioning
-            saved_filenames = sfc_forcing.save(filepath, np_eta=1, group=True)
-
-            expected_filepath_list = [
-                Path(filepath_str + f"_202002.{index}.nc") for index in range(1)
-            ]
-            assert saved_filenames == expected_filepath_list
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 def test_surface_forcing_bgc_plot(bgc_surface_forcing):
     """Test plot method."""
@@ -543,15 +639,15 @@ def test_surface_forcing_bgc_save(bgc_surface_forcing, tmp_path):
             str(tmp_path / file_str),
         ]:  # test for Path object and str
 
-            # Test saving without partitioning and grouping
-            saved_filenames = bgc_surface_forcing.save(filepath)
+            # Test saving without grouping
+            saved_filenames = bgc_surface_forcing.save(filepath, group=False)
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}.nc")
             assert saved_filenames == [expected_filepath]
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving without partitioning but with grouping
+            # Test saving with grouping
             saved_filenames = bgc_surface_forcing.save(filepath, group=True)
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}_202002.nc")
@@ -559,17 +655,6 @@ def test_surface_forcing_bgc_save(bgc_surface_forcing, tmp_path):
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving with partitioning
-            saved_filenames = bgc_surface_forcing.save(filepath, np_xi=5, group=True)
-
-            expected_filepath_list = [
-                Path(filepath_str + f"_202002.{index}.nc") for index in range(5)
-            ]
-            assert saved_filenames == expected_filepath_list
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 def test_surface_forcing_bgc_from_clim_save(
     bgc_surface_forcing_from_climatology, tmp_path
@@ -583,15 +668,17 @@ def test_surface_forcing_bgc_from_clim_save(
             str(tmp_path / file_str),
         ]:  # test for Path object and str
 
-            # Test saving without partitioning and grouping
-            saved_filenames = bgc_surface_forcing_from_climatology.save(filepath)
+            # Test saving without grouping
+            saved_filenames = bgc_surface_forcing_from_climatology.save(
+                filepath, group=False
+            )
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}.nc")
             assert saved_filenames == [expected_filepath]
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving without partitioning but with grouping
+            # Test saving with grouping
             saved_filenames = bgc_surface_forcing_from_climatology.save(
                 filepath, group=True
             )
@@ -601,19 +688,6 @@ def test_surface_forcing_bgc_from_clim_save(
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving with partitioning and grouping
-            saved_filenames = bgc_surface_forcing_from_climatology.save(
-                filepath, np_eta=5, group=True
-            )
-
-            expected_filepath_list = [
-                Path(filepath_str + f"_clim.{index}.nc") for index in range(5)
-            ]
-            assert saved_filenames == expected_filepath_list
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 @pytest.mark.parametrize(
     "sfc_forcing_fixture",
@@ -675,8 +749,9 @@ def test_files_have_same_hash(sfc_forcing_fixture, request, tmp_path, use_dask):
     expected_filepath1 = f"{filepath_str1}_202002.nc"
     expected_filepath2 = f"{filepath_str2}_202002.nc"
 
-    hash1 = calculate_file_hash(expected_filepath1)
-    hash2 = calculate_file_hash(expected_filepath2)
+    # Only compare hash of datasets because metadata is non-deterministic with dask
+    hash1 = calculate_data_hash(expected_filepath1)
+    hash2 = calculate_data_hash(expected_filepath2)
 
     assert hash1 == hash2, f"Hashes do not match: {hash1} != {hash2}"
 
@@ -703,8 +778,9 @@ def test_files_have_same_hash_clim(
     expected_filepath1 = f"{filepath_str1}_clim.nc"
     expected_filepath2 = f"{filepath_str2}_clim.nc"
 
-    hash1 = calculate_file_hash(expected_filepath1)
-    hash2 = calculate_file_hash(expected_filepath2)
+    # Only compare hash of datasets because metadata is non-deterministic with dask
+    hash1 = calculate_data_hash(expected_filepath1)
+    hash2 = calculate_data_hash(expected_filepath2)
 
     assert hash1 == hash2, f"Hashes do not match: {hash1} != {hash2}"
 

roms_tools/tests/test_setup/test_tides.py

@@ -4,7 +4,7 @@ import xarray as xr
 from roms_tools.download import download_test_data
 import textwrap
 from pathlib import Path
-from conftest import calculate_file_hash
+from conftest import calculate_data_hash
 
 
 @pytest.fixture
@@ -185,7 +185,6 @@ def test_tidal_forcing_save(tidal_forcing, tmp_path):
             str(tmp_path / file_str),
         ]:  # test for Path object and str
 
-            # Test saving without partitioning
             saved_filenames = tidal_forcing.save(filepath)
             # Check if the .nc file was created
             filepath = Path(filepath).with_suffix(".nc")
@@ -194,18 +193,6 @@ def test_tidal_forcing_save(tidal_forcing, tmp_path):
             # Clean up the .nc file
             filepath.unlink()
 
-            # Test saving with partitioning
-            saved_filenames = tidal_forcing.save(filepath, np_eta=3, np_xi=3)
-
-            filepath_str = str(filepath.with_suffix(""))
-            expected_filepath_list = [
-                Path(filepath_str + f".{index}.nc") for index in range(9)
-            ]
-            assert saved_filenames == expected_filepath_list
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 def test_roundtrip_yaml(tidal_forcing, tmp_path, use_dask):
     """Test that creating a TidalForcing object, saving its parameters to yaml file, and
@@ -242,8 +229,9 @@ def test_files_have_same_hash(tidal_forcing, tmp_path, use_dask):
     tidal_forcing_from_file = TidalForcing.from_yaml(yaml_filepath, use_dask=use_dask)
     tidal_forcing_from_file.save(filepath2)
 
-    hash1 = calculate_file_hash(filepath1)
-    hash2 = calculate_file_hash(filepath2)
+    # Only compare hash of datasets because metadata is non-deterministic with dask
+    hash1 = calculate_data_hash(filepath1)
+    hash2 = calculate_data_hash(filepath2)
 
     assert hash1 == hash2, f"Hashes do not match: {hash1} != {hash2}"
 

roms_tools/tests/test_setup/test_utils.py

@@ -15,6 +15,7 @@ def test_interpolate_from_climatology(use_dask):
 
     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)

roms_tools/tests/test_setup/test_validation.py

@@ -70,7 +70,39 @@ def test_check_results(forcing_fixture, request):
 
     fname = _get_fname(forcing_fixture)
     expected_forcing_ds = xr.open_zarr(fname, decode_timedelta=False)
-
     forcing = request.getfixturevalue(forcing_fixture)
 
-    xr.testing.assert_allclose(forcing.ds, expected_forcing_ds, rtol=1.0e-5)
+    xr.testing.assert_allclose(forcing.ds, expected_forcing_ds, rtol=1.0e-5, atol=1e-08)
+
+
+@pytest.mark.parametrize(
+    "forcing_fixture",
+    [
+        "tidal_forcing",
+        "initial_conditions_with_bgc_from_climatology",
+        "surface_forcing",
+        "coarse_surface_forcing",
+        "corrected_surface_forcing",
+        "bgc_surface_forcing",
+        "bgc_surface_forcing_from_climatology",
+        "boundary_forcing",
+        "bgc_boundary_forcing_from_climatology",
+    ],
+)
+def test_dask_vs_no_dask(forcing_fixture, request, tmp_path, use_dask):
+    """Test comparing the forcing created with and without Dask on same platform."""
+
+    if not use_dask:
+        pytest.skip("Test only runs when --use_dask is specified")
+
+    # Get the forcing with Dask
+    forcing_with_dask = request.getfixturevalue(forcing_fixture)
+
+    filepath = tmp_path / "test.yaml"
+    forcing_with_dask.to_yaml(filepath)
+
+    # Get the forcing without Dask
+    forcing_without_dask = type(forcing_with_dask).from_yaml(filepath, use_dask=False)
+
+    # Compare the two datasets using assert_equal (only within the same platform)
+    xr.testing.assert_equal(forcing_with_dask.ds, forcing_without_dask.ds)

roms_tools/tests/{test_utils.py → test_tiling/test_partition.py}

@@ -2,7 +2,7 @@ import pytest
 from pathlib import Path
 import xarray.testing as xrt
 
-from roms_tools.utils import partition, partition_netcdf
+from roms_tools.tiling.partition import partition, partition_netcdf
 from roms_tools import Grid