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

roms_tools/tests/test_setup/test_boundary_forcing.py

@@ -1,10 +1,11 @@
 import pytest
 from datetime import datetime
 import xarray as xr
+import numpy as np
 from roms_tools import Grid, BoundaryForcing
 import textwrap
 from roms_tools.download import download_test_data
-from conftest import calculate_file_hash
+from conftest import calculate_data_hash
 from pathlib import Path
 import logging
 
@@ -13,19 +14,23 @@ import logging
     "boundary_forcing_fixture",
     [
         "boundary_forcing",
-        # "boundary_forcing_with_2d_fill",
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
     ],
 )
 def test_boundary_forcing_creation(boundary_forcing_fixture, request):
     """Test the creation of the BoundaryForcing object."""
 
-    fname = Path(download_test_data("GLORYS_coarse_test_data.nc"))
     boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
-    assert boundary_forcing.start_time == datetime(2021, 6, 29)
-    assert boundary_forcing.end_time == datetime(2021, 6, 30)
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+    assert boundary_forcing.start_time == datetime(2012, 1, 1)
+    assert boundary_forcing.end_time == datetime(2012, 12, 31)
     assert boundary_forcing.source == {
         "name": "GLORYS",
-        "path": fname,
+        "path": [fname1, fname2],
         "climatology": False,
     }
     assert boundary_forcing.model_reference_date == datetime(2000, 1, 1)
@@ -44,16 +49,17 @@ def test_boundary_forcing_creation(boundary_forcing_fixture, request):
         assert f"v_{direction}" in boundary_forcing.ds
         assert f"zeta_{direction}" in boundary_forcing.ds
 
-    assert len(boundary_forcing.ds.bry_time) == 1
+    assert len(boundary_forcing.ds.bry_time) == 2
     assert boundary_forcing.ds.coords["bry_time"].attrs["units"] == "days"
     assert not hasattr(boundary_forcing.ds, "climatology")
+    assert hasattr(boundary_forcing.ds, "adjust_depth_for_sea_surface_height")
+    assert hasattr(boundary_forcing.ds, "apply_2d_horizontal_fill")
 
 
 @pytest.mark.parametrize(
     "boundary_forcing_fixture",
     [
         "bgc_boundary_forcing_from_climatology",
-        # "bgc_boundary_forcing_from_climatology_with_2d_fill",
     ],
 )
 def test_boundary_forcing_creation_with_bgc(boundary_forcing_fixture, request):
@@ -133,6 +139,69 @@ def test_unsuccessful_boundary_forcing_creation_with_1d_fill(use_dask):
         )
 
 
+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"
+    ):
+        BoundaryForcing(
+            grid=None,
+            start_time=datetime(2022, 1, 1),
+            end_time=None,  # end_time is None, should raise an error
+            source={"name": "GLORYS", "path": "glorys_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"
+    ):
+        BoundaryForcing(
+            grid=None,
+            start_time=None,  # start_time is None, should raise an error
+            end_time=datetime(2022, 1, 2),
+            source={"name": "GLORYS", "path": "glorys_data.nc"},
+            use_dask=use_dask,
+        )
+
+
+def test_start_time_end_time_warning(use_dask, caplog):
+    """Test that a warning is triggered when both start_time and end_time are None."""
+    # Catching the warning during test
+    grid = Grid(
+        nx=3,
+        ny=3,
+        size_x=400,
+        size_y=400,
+        center_lon=-8,
+        center_lat=58,
+        rot=0,
+        N=3,  # number of vertical levels
+        theta_s=5.0,  # surface control parameter
+        theta_b=2.0,  # bottom control parameter
+        hc=250.0,  # critical depth
+    )
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+
+    with caplog.at_level(logging.INFO):
+        BoundaryForcing(
+            grid=grid,
+            start_time=None,
+            end_time=None,
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            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_boundary_divided_by_land_warning(caplog, use_dask):
 
     # Iceland intersects the western boundary of the following grid
@@ -155,6 +224,113 @@ def test_boundary_divided_by_land_warning(caplog, use_dask):
     assert "the western boundary is divided by land" in caplog.text
 
 
+def test_info_depth(caplog, use_dask):
+
+    grid = Grid(
+        nx=3,
+        ny=3,
+        size_x=400,
+        size_y=400,
+        center_lon=-8,
+        center_lat=58,
+        rot=0,
+        N=3,  # number of vertical levels
+        theta_s=5.0,  # surface control parameter
+        theta_b=2.0,  # bottom control parameter
+        hc=250.0,  # critical depth
+    )
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+
+    with caplog.at_level(logging.INFO):
+        BoundaryForcing(
+            grid=grid,
+            start_time=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            adjust_depth_for_sea_surface_height=True,
+            use_dask=use_dask,
+        )
+
+    # Verify the warning message in the log
+    assert "Sea surface height will be used to adjust depth coordinates." in caplog.text
+
+    # Clear the log before the next test
+    caplog.clear()
+
+    with caplog.at_level(logging.INFO):
+
+        BoundaryForcing(
+            grid=grid,
+            start_time=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            adjust_depth_for_sea_surface_height=False,
+            use_dask=use_dask,
+        )
+    # Verify the warning message in the log
+    assert (
+        "Sea surface height will NOT be used to adjust depth coordinates."
+        in caplog.text
+    )
+
+
+def test_info_fill(caplog, use_dask):
+
+    grid = Grid(
+        nx=3,
+        ny=3,
+        size_x=400,
+        size_y=400,
+        center_lon=-8,
+        center_lat=58,
+        rot=0,
+        N=3,  # number of vertical levels
+        theta_s=5.0,  # surface control parameter
+        theta_b=2.0,  # bottom control parameter
+        hc=250.0,  # critical depth
+    )
+
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+
+    with caplog.at_level(logging.INFO):
+        BoundaryForcing(
+            grid=grid,
+            start_time=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            apply_2d_horizontal_fill=True,
+            use_dask=use_dask,
+        )
+
+    # Verify the warning message in the log
+    assert (
+        "Applying 2D horizontal fill to the source data before regridding."
+        in caplog.text
+    )
+
+    # Clear the log before the next test
+    caplog.clear()
+
+    with caplog.at_level(logging.INFO):
+
+        BoundaryForcing(
+            grid=grid,
+            start_time=datetime(2012, 1, 1),
+            end_time=datetime(2012, 12, 31),
+            source={"name": "GLORYS", "path": [fname1, fname2]},
+            apply_2d_horizontal_fill=False,
+            use_dask=use_dask,
+        )
+    # Verify the warning message in the log
+    assert (
+        "Applying 1D horizontal fill separately to each regridded boundary."
+        in caplog.text
+    )
+
+
 def test_1d_and_2d_fill_coincide_if_no_land(use_dask):
 
     # this grid lies entirely over open ocean
@@ -182,23 +358,95 @@ def test_1d_and_2d_fill_coincide_if_no_land(use_dask):
     xr.testing.assert_allclose(bf_1d_fill.ds, bf_2d_fill.ds, rtol=1.0e-4)
 
 
-def test_boundary_forcing_plot(boundary_forcing):
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
+    ],
+)
+def test_correct_depth_coords_adjusted_for_zeta(
+    boundary_forcing_fixture, request, use_dask
+):
+
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
+
+    for direction in ["south", "east", "north", "west"]:
+
+        # Test that uppermost interface coincides with sea surface height
+        assert np.allclose(
+            boundary_forcing.ds_depth_coords[f"interface_depth_rho_{direction}"]
+            .isel(s_w=-1)
+            .values,
+            -boundary_forcing.ds[f"zeta_{direction}"].values,
+            atol=1e-6,
+        )
+
+
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing",
+        "boundary_forcing_with_2d_fill",
+    ],
+)
+def test_correct_depth_coords_zero_zeta(boundary_forcing_fixture, request, use_dask):
+
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
+
+    for direction in ["south", "east", "north", "west"]:
+
+        # Test that uppermost interface coincides with sea surface height
+        assert np.allclose(
+            boundary_forcing.ds_depth_coords[f"interface_depth_rho_{direction}"]
+            .isel(s_w=-1)
+            .values,
+            0 * boundary_forcing.ds[f"zeta_{direction}"].values,
+            atol=1e-6,
+        )
+
+
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing",
+        "boundary_forcing_with_2d_fill",
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
+    ],
+)
+def test_boundary_forcing_plot(boundary_forcing_fixture, request):
     """Test plot."""
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
-    boundary_forcing.plot(var_name="temp_south", layer_contours=True)
-    boundary_forcing.plot(var_name="temp_east", layer_contours=True)
-    boundary_forcing.plot(var_name="temp_north", layer_contours=True)
-    boundary_forcing.plot(var_name="temp_west", layer_contours=True)
-    boundary_forcing.plot(var_name="zeta_south")
-    boundary_forcing.plot(var_name="zeta_east")
-    boundary_forcing.plot(var_name="zeta_north")
-    boundary_forcing.plot(var_name="zeta_west")
-    boundary_forcing.plot(var_name="vbar_north")
-    boundary_forcing.plot(var_name="ubar_west")
+    for direction in ["south", "east", "north", "west"]:
+        for layer_contours in [False, True]:
+            boundary_forcing.plot(
+                var_name=f"temp_{direction}", layer_contours=layer_contours
+            )
+            boundary_forcing.plot(
+                var_name=f"u_{direction}", layer_contours=layer_contours
+            )
+            boundary_forcing.plot(
+                var_name=f"v_{direction}", layer_contours=layer_contours
+            )
+        boundary_forcing.plot(var_name=f"zeta_{direction}")
+        boundary_forcing.plot(var_name=f"vbar_{direction}")
+        boundary_forcing.plot(var_name=f"ubar_{direction}")
 
 
-def test_boundary_forcing_save(boundary_forcing, tmp_path):
+@pytest.mark.parametrize(
+    "boundary_forcing_fixture",
+    [
+        "boundary_forcing",
+        "boundary_forcing_with_2d_fill",
+        "boundary_forcing_adjusted_for_zeta",
+        "boundary_forcing_with_2d_fill_adjusted_for_zeta",
+    ],
+)
+def test_boundary_forcing_save(boundary_forcing_fixture, request, tmp_path):
     """Test save method."""
+    boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     for file_str in ["test_bf", "test_bf.nc"]:
         # Create a temporary filepath using the tmp_path fixture
@@ -207,8 +455,8 @@ def test_boundary_forcing_save(boundary_forcing, tmp_path):
             str(tmp_path / file_str),
         ]:  # test for Path object and str
 
-            # Test saving without partitioning and grouping
-            saved_filenames = boundary_forcing.save(filepath)
+            # Test saving without grouping
+            saved_filenames = boundary_forcing.save(filepath, group=False)
 
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}.nc")
@@ -217,28 +465,16 @@ def test_boundary_forcing_save(boundary_forcing, tmp_path):
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving without partitioning but with grouping
+            # Test saving with grouping
             saved_filenames = boundary_forcing.save(filepath, group=True)
 
             filepath_str = str(Path(filepath).with_suffix(""))
-            expected_filepath = Path(f"{filepath_str}_202106.nc")
+            expected_filepath = Path(f"{filepath_str}_2012.nc")
 
             assert saved_filenames == [expected_filepath]
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving with partitioning and grouping
-            saved_filenames = boundary_forcing.save(filepath, np_eta=2, group=True)
-            expected_filepath_list = [
-                Path(filepath_str + f"_202106.{index}.nc") for index in range(2)
-            ]
-
-            assert saved_filenames == expected_filepath_list
-
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 def test_bgc_boundary_forcing_plot(bgc_boundary_forcing_from_climatology):
     """Test plot method."""
@@ -264,7 +500,9 @@ def test_bgc_boundary_forcing_save(bgc_boundary_forcing_from_climatology, tmp_pa
         ]:  # test for Path object and str
 
             # Test saving without partitioning and grouping
-            saved_filenames = bgc_boundary_forcing_from_climatology.save(filepath)
+            saved_filenames = bgc_boundary_forcing_from_climatology.save(
+                filepath, group=False
+            )
 
             filepath_str = str(Path(filepath).with_suffix(""))
             expected_filepath = Path(f"{filepath_str}.nc")
@@ -283,20 +521,6 @@ def test_bgc_boundary_forcing_save(bgc_boundary_forcing_from_climatology, tmp_pa
             assert expected_filepath.exists()
             expected_filepath.unlink()
 
-            # Test saving with partitioning
-            saved_filenames = bgc_boundary_forcing_from_climatology.save(
-                filepath, np_xi=2, group=True
-            )
-
-            expected_filepath_list = [
-                Path(filepath_str + f"_clim.{index}.nc") for index in range(2)
-            ]
-            assert saved_filenames == expected_filepath_list
-
-            for expected_filepath in expected_filepath_list:
-                assert expected_filepath.exists()
-                expected_filepath.unlink()
-
 
 @pytest.mark.parametrize(
     "bdry_forcing_fixture",
@@ -341,11 +565,12 @@ def test_files_have_same_hash(boundary_forcing, tmp_path, use_dask):
 
     filepath_str1 = str(Path(filepath1).with_suffix(""))
     filepath_str2 = str(Path(filepath2).with_suffix(""))
-    expected_filepath1 = f"{filepath_str1}_202106.nc"
-    expected_filepath2 = f"{filepath_str2}_202106.nc"
+    expected_filepath1 = f"{filepath_str1}_2012.nc"
+    expected_filepath2 = f"{filepath_str2}_2012.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}"
 
@@ -372,8 +597,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_data/bgc_boundary_forcing_from_climatology.zarr/.zattrs

@@ -1,9 +1,11 @@
 {
+    "adjust_depth_for_sea_surface_height": "False",
+    "apply_2d_horizontal_fill": "True",
     "climatology": "True",
     "end_time": "2021-06-30 00:00:00",
     "hc": 250.0,
     "model_reference_date": "2000-01-01 00:00:00",
-    "roms_tools_version": "0.1.dev169+dirty",
+    "roms_tools_version": "2.1.1.dev3+gef240eb.d20250116",
     "source": "CESM_REGRIDDED",
     "start_time": "2021-06-29 00:00:00",
     "theta_b": 2.0,

roms_tools/tests/test_setup/test_data/bgc_boundary_forcing_from_climatology.zarr/.zmetadata

@@ -1,11 +1,13 @@
 {
     "metadata": {
         ".zattrs": {
+            "adjust_depth_for_sea_surface_height": "False",
+            "apply_2d_horizontal_fill": "True",
             "climatology": "True",
             "end_time": "2021-06-30 00:00:00",
             "hc": 250.0,
             "model_reference_date": "2000-01-01 00:00:00",
-            "roms_tools_version": "0.1.dev169+dirty",
+            "roms_tools_version": "2.1.1.dev3+gef240eb.d20250116",
             "source": "CESM_REGRIDDED",
             "start_time": "2021-06-29 00:00:00",
             "theta_b": 2.0,