roms-tools 2.2.1__py3-none-any.whl → 2.4.0__py3-none-any.whl

roms_tools/tests/test_setup/test_surface_forcing.py

@@ -2,10 +2,11 @@ import pytest
 from datetime import datetime
 import xarray as xr
 from roms_tools import Grid, SurfaceForcing
-from roms_tools.setup.download import download_test_data
+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,9 +345,9 @@ 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
 
 
@@ -356,10 +365,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 +384,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 +488,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 +559,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 +575,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 +592,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 +608,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 +621,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 +641,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 +702,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 +731,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

@@ -1,10 +1,10 @@
 import pytest
 from roms_tools import Grid, TidalForcing
 import xarray as xr
-from roms_tools.setup.download import download_test_data
+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_topography.py

@@ -1,7 +1,7 @@
 import pytest
 from roms_tools import Grid
 from roms_tools.setup.topography import _compute_rfactor
-from roms_tools.setup.download import download_test_data
+from roms_tools.download import download_test_data
 import numpy as np
 import numpy.testing as npt
 from scipy.ndimage import label

roms_tools/tests/test_setup/test_utils.py

@@ -1,7 +1,11 @@
+from roms_tools import Grid, BoundaryForcing
 from roms_tools.setup.utils import interpolate_from_climatology
 from roms_tools.setup.datasets import ERA5Correction
-from roms_tools.setup.download import download_test_data
+from roms_tools.download import download_test_data
 import xarray as xr
+import pytest
+from datetime import datetime
+from pathlib import Path
 
 
 def test_interpolate_from_climatology(use_dask):
@@ -11,6 +15,58 @@ 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)
+
+
+# Test yaml roundtrip with multiple source files
+@pytest.fixture()
+def boundary_forcing_from_multiple_source_files(request, use_dask):
+    """Fixture for creating a BoundaryForcing object."""
+
+    grid = Grid(
+        nx=5,
+        ny=5,
+        size_x=100,
+        size_y=100,
+        center_lon=-8,
+        center_lat=60,
+        rot=10,
+        N=3,  # number of vertical levels
+    )
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+
+    return BoundaryForcing(
+        grid=grid,
+        start_time=datetime(2011, 1, 1),
+        end_time=datetime(2013, 1, 1),
+        source={"name": "GLORYS", "path": [fname1, fname2]},
+        use_dask=use_dask,
+    )
+
+
+def test_roundtrip_yaml(
+    boundary_forcing_from_multiple_source_files, request, tmp_path, use_dask
+):
+    """Test that creating a BoundaryForcing object, saving its parameters to yaml file,
+    and re-opening yaml file creates the same object."""
+
+    # Create a temporary filepath using the tmp_path fixture
+    file_str = "test_yaml"
+    for filepath in [
+        tmp_path / file_str,
+        str(tmp_path / file_str),
+    ]:  # test for Path object and str
+
+        boundary_forcing_from_multiple_source_files.to_yaml(filepath)
+
+        bdry_forcing_from_file = BoundaryForcing.from_yaml(filepath, use_dask=use_dask)
+
+        assert boundary_forcing_from_multiple_source_files == bdry_forcing_from_file
+
+        filepath = Path(filepath)
+        filepath.unlink()

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