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

roms_tools/setup/utils.py

@@ -9,6 +9,7 @@ from datetime import datetime
 from dataclasses import fields, asdict
 import importlib.metadata
 import yaml
+from roms_tools.utils import interpolate_from_rho_to_u, interpolate_from_rho_to_v
 
 
 def nan_check(field, mask, error_message=None) -> None:
@@ -71,100 +72,6 @@ def substitute_nans_by_fillvalue(field, fill_value=0.0) -> xr.DataArray:
     return field.fillna(fill_value)
 
 
-def interpolate_from_rho_to_u(field, method="additive"):
-    """Interpolates the given field from rho points to u points.
-
-    This function performs an interpolation from the rho grid (cell centers) to the u grid
-    (cell edges in the xi direction). Depending on the chosen method, it either averages
-    (additive) or multiplies (multiplicative) the field values between adjacent rho points
-    along the xi dimension. It also handles the removal of unnecessary coordinate variables
-    and updates the dimensions accordingly.
-
-    Parameters
-    ----------
-    field : xr.DataArray
-        The input data array on the rho grid to be interpolated. It is assumed to have a dimension
-        named "xi_rho".
-
-    method : str, optional, default='additive'
-        The method to use for interpolation. Options are:
-        - 'additive': Average the field values between adjacent rho points.
-        - 'multiplicative': Multiply the field values between adjacent rho points. Appropriate for
-          binary masks.
-
-    Returns
-    -------
-    field_interpolated : xr.DataArray
-        The interpolated data array on the u grid with the dimension "xi_u".
-    """
-
-    if method == "additive":
-        field_interpolated = 0.5 * (field + field.shift(xi_rho=1)).isel(
-            xi_rho=slice(1, None)
-        )
-    elif method == "multiplicative":
-        field_interpolated = (field * field.shift(xi_rho=1)).isel(xi_rho=slice(1, None))
-    else:
-        raise NotImplementedError(f"Unsupported method '{method}' specified.")
-
-    vars_to_drop = ["lat_rho", "lon_rho", "eta_rho", "xi_rho"]
-    for var in vars_to_drop:
-        if var in field_interpolated.coords:
-            field_interpolated = field_interpolated.drop_vars(var)
-
-    field_interpolated = field_interpolated.swap_dims({"xi_rho": "xi_u"})
-
-    return field_interpolated
-
-
-def interpolate_from_rho_to_v(field, method="additive"):
-    """Interpolates the given field from rho points to v points.
-
-    This function performs an interpolation from the rho grid (cell centers) to the v grid
-    (cell edges in the eta direction). Depending on the chosen method, it either averages
-    (additive) or multiplies (multiplicative) the field values between adjacent rho points
-    along the eta dimension. It also handles the removal of unnecessary coordinate variables
-    and updates the dimensions accordingly.
-
-    Parameters
-    ----------
-    field : xr.DataArray
-        The input data array on the rho grid to be interpolated. It is assumed to have a dimension
-        named "eta_rho".
-
-    method : str, optional, default='additive'
-        The method to use for interpolation. Options are:
-        - 'additive': Average the field values between adjacent rho points.
-        - 'multiplicative': Multiply the field values between adjacent rho points. Appropriate for
-          binary masks.
-
-    Returns
-    -------
-    field_interpolated : xr.DataArray
-        The interpolated data array on the v grid with the dimension "eta_v".
-    """
-
-    if method == "additive":
-        field_interpolated = 0.5 * (field + field.shift(eta_rho=1)).isel(
-            eta_rho=slice(1, None)
-        )
-    elif method == "multiplicative":
-        field_interpolated = (field * field.shift(eta_rho=1)).isel(
-            eta_rho=slice(1, None)
-        )
-    else:
-        raise NotImplementedError(f"Unsupported method '{method}' specified.")
-
-    vars_to_drop = ["lat_rho", "lon_rho", "eta_rho", "xi_rho"]
-    for var in vars_to_drop:
-        if var in field_interpolated.coords:
-            field_interpolated = field_interpolated.drop_vars(var)
-
-    field_interpolated = field_interpolated.swap_dims({"eta_rho": "eta_v"})
-
-    return field_interpolated
-
-
 def one_dim_fill(da: xr.DataArray, dim: str, direction="forward") -> xr.DataArray:
     """Fill NaN values in a DataArray along a specified dimension.
 
@@ -863,45 +770,6 @@ def compute_barotropic_velocity(
     return vel_bar
 
 
-def transpose_dimensions(da: xr.DataArray) -> xr.DataArray:
-    """Transpose the dimensions of an xarray.DataArray to ensure that 'time', any
-    dimension starting with 's_', 'eta_', and 'xi_' are ordered first, followed by the
-    remaining dimensions in their original order.
-
-    Parameters
-    ----------
-    da : xarray.DataArray
-        The input DataArray whose dimensions are to be reordered.
-
-    Returns
-    -------
-    xarray.DataArray
-        The DataArray with dimensions reordered so that 'time', 's_*', 'eta_*',
-        and 'xi_*' are first, in that order, if they exist.
-    """
-
-    # List of preferred dimension patterns
-    preferred_order = ["time", "s_", "eta_", "xi_"]
-
-    # Get the existing dimensions in the DataArray
-    dims = list(da.dims)
-
-    # Collect dimensions that match any of the preferred patterns
-    matched_dims = []
-    for pattern in preferred_order:
-        # Find dimensions that start with the pattern
-        matched_dims += [dim for dim in dims if dim.startswith(pattern)]
-
-    # Create a new order: first the matched dimensions, then the rest
-    remaining_dims = [dim for dim in dims if dim not in matched_dims]
-    new_order = matched_dims + remaining_dims
-
-    # Transpose the DataArray to the new order
-    transposed_da = da.transpose(*new_order)
-
-    return transposed_da
-
-
 def get_vector_pairs(variable_info):
     """Extracts all unique vector pairs from the variable_info dictionary.
 
@@ -1079,12 +947,20 @@ def _to_yaml(forcing_object, filepath: Union[str, Path]) -> None:
 
         grid_yaml_data = {**parent_grid_yaml_data, **child_grid_yaml_data}
 
-    # Ensure forcing_object.source.path is a string (convert if it's a pathlib object)
-    if hasattr(forcing_object, "source") and "path" in forcing_object.source:
-        forcing_object.source["path"] = str(forcing_object.source["path"])
+    # Step 2: Ensure Paths are Strings
+    def ensure_paths_are_strings(obj, key):
+        attr = getattr(obj, key, None)
+        if attr is not None and "path" in attr:
+            paths = attr["path"]
+            if isinstance(paths, list):
+                attr["path"] = [str(p) if isinstance(p, Path) else p for p in paths]
+            elif isinstance(paths, Path):
+                attr["path"] = str(paths)
+
+    ensure_paths_are_strings(forcing_object, "source")
+    ensure_paths_are_strings(forcing_object, "bgc_source")
 
-    # Step 2: Get ROMS Tools version
-    # Fetch the version of the 'roms-tools' package for inclusion in the YAML header
+    # Step 3: Get ROMS Tools version
     try:
         roms_tools_version = importlib.metadata.version("roms-tools")
     except importlib.metadata.PackageNotFoundError:
@@ -1093,8 +969,7 @@ def _to_yaml(forcing_object, filepath: Union[str, Path]) -> None:
     # Create YAML header with version information
     header = f"---\nroms_tools_version: {roms_tools_version}\n---\n"
 
-    # Step 3: Prepare Forcing Data
-    # Prepare the forcing object fields, excluding 'grid' and 'ds'
+    # Step 4: Prepare Forcing Data
     forcing_data = {}
     field_names = [field.name for field in fields(forcing_object)]
     filtered_field_names = [
@@ -1123,14 +998,13 @@ def _to_yaml(forcing_object, filepath: Union[str, Path]) -> None:
         # Add the field and its value to the forcing_data dictionary
         forcing_data[field_name] = value
 
-    # Step 4: Combine Grid and Forcing Data
-    # Combine grid and forcing data into a single dictionary for the final YAML content
+    # Step 5: Combine Grid and Forcing Data into a single dictionary for the final YAML content
     yaml_data = {
         **grid_yaml_data,  # Add the grid data to the final YAML structure
         forcing_object.__class__.__name__: forcing_data,  # Include the serialized forcing object data
     }
 
-    # Step 5: Write to YAML file
+    # Step 6: Write to YAML file
     with filepath.open("w") as file:
         # Write the header first
         file.write(header)
@@ -1176,6 +1050,8 @@ def _from_yaml(forcing_object: Type, filepath: Union[str, Path]) -> Dict[str, An
     ValueError
         If no configuration for the specified class name is found in the YAML file.
     """
+    # Ensure filepath is a Path object
+    filepath = Path(filepath)
 
     # Read the entire file content
     with filepath.open("r") as file:

roms_tools/tests/test_analysis/test_roms_output.py

@@ -0,0 +1,269 @@
+import pytest
+from pathlib import Path
+import xarray as xr
+import os
+import logging
+from datetime import datetime
+from roms_tools import Grid, ROMSOutput
+from roms_tools.download import download_test_data
+
+
+@pytest.fixture
+def roms_output_from_restart_file(use_dask):
+
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Single file
+    return ROMSOutput(
+        grid=grid,
+        path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
+        type="restart",
+        use_dask=use_dask,
+    )
+
+
+def test_load_model_output_file(roms_output_from_restart_file, use_dask):
+
+    assert isinstance(roms_output_from_restart_file.ds, xr.Dataset)
+
+
+def test_load_model_output_directory(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Download at least two files, so these will be found within the pooch directory
+    _ = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    _ = Path(download_test_data("eastpac25km_rst.19980126000000.nc"))
+
+    # Directory
+    directory = os.path.dirname(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    output = ROMSOutput(grid=grid, path=directory, type="restart", use_dask=use_dask)
+    assert isinstance(output.ds, xr.Dataset)
+
+
+def test_load_model_output_file_list(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # List of files
+    file1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    file2 = Path(download_test_data("eastpac25km_rst.19980126000000.nc"))
+    output = ROMSOutput(
+        grid=grid, path=[file1, file2], type="restart", use_dask=use_dask
+    )
+    assert isinstance(output.ds, xr.Dataset)
+
+
+def test_invalid_type(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Invalid type
+    with pytest.raises(ValueError, match="Invalid type 'invalid_type'"):
+        ROMSOutput(
+            grid=grid,
+            path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
+            type="invalid_type",
+            use_dask=use_dask,
+        )
+
+
+def test_invalid_path(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Non-existent file
+    with pytest.raises(FileNotFoundError):
+        ROMSOutput(
+            grid=grid,
+            path=Path("/path/to/nonexistent/file.nc"),
+            type="restart",
+            use_dask=use_dask,
+        )
+
+    # Non-existent directory
+    with pytest.raises(FileNotFoundError):
+        ROMSOutput(
+            grid=grid,
+            path=Path("/path/to/nonexistent/directory"),
+            type="restart",
+            use_dask=use_dask,
+        )
+
+
+def test_set_correct_model_reference_date(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    output = ROMSOutput(
+        grid=grid,
+        path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
+        type="restart",
+        use_dask=use_dask,
+    )
+    assert output.model_reference_date == datetime(1995, 1, 1)
+
+
+def test_model_reference_date_mismatch(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    # Create a ROMSOutput with a specified model_reference_date
+    model_ref_date = datetime(2020, 1, 1)
+    with pytest.raises(
+        ValueError, match="Mismatch between `self.model_reference_date`"
+    ):
+        ROMSOutput(
+            grid=grid,
+            path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
+            type="restart",
+            model_reference_date=model_ref_date,
+            use_dask=use_dask,
+        )
+
+
+def test_model_reference_date_no_metadata(use_dask, tmp_path, caplog):
+    # Helper function to handle the test logic for cases where metadata is missing or invalid
+    def test_no_metadata(faulty_ocean_time_attr, expected_exception, log_message=None):
+        ds = xr.open_dataset(fname)
+        ds["ocean_time"].attrs = faulty_ocean_time_attr
+
+        # Write modified dataset to a new file
+        fname_mod = tmp_path / "eastpac25km_rst.19980106000000_without_metadata.nc"
+        ds.to_netcdf(fname_mod)
+
+        # Test case 1: Expecting a ValueError when metadata is missing or invalid
+        with pytest.raises(
+            expected_exception,
+            match="Model reference date could not be inferred from the metadata",
+        ):
+            ROMSOutput(grid=grid, path=fname_mod, type="restart", use_dask=use_dask)
+
+        # Test case 2: When a model reference date is explicitly set, verify the warning
+        with caplog.at_level(logging.WARNING):
+            ROMSOutput(
+                grid=grid,
+                path=fname_mod,
+                model_reference_date=datetime(1995, 1, 1),
+                type="restart",
+                use_dask=use_dask,
+            )
+
+            if log_message:
+                # Verify the warning message in the log
+                assert log_message in caplog.text
+
+        fname_mod.unlink()
+
+    # Load grid and test data
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+    fname = download_test_data("eastpac25km_rst.19980106000000.nc")
+
+    # Test 1: Ocean time attribute 'long_name' is missing
+    test_no_metadata({}, ValueError)
+
+    # Test 2: Ocean time attribute 'long_name' contains invalid information
+    test_no_metadata(
+        {"long_name": "some random text"},
+        ValueError,
+        "Could not infer the model reference date from the metadata.",
+    )
+
+
+def test_compute_depth_coordinates(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    fname_restart1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    output = ROMSOutput(
+        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
+    )
+
+    # Before calling get_vertical_coordinates, check if the dataset doesn't already have depth coordinates
+    assert "layer_depth_rho" not in output.ds.data_vars
+
+    # Call the method to get vertical coordinates
+    output.compute_depth_coordinates(depth_type="layer")
+
+    # Check if the depth coordinates were added
+    assert "layer_depth_rho" in output.ds.data_vars
+
+
+def test_check_vertical_coordinate_mismatch(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    fname_restart1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    output = ROMSOutput(
+        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
+    )
+
+    # create a mock dataset with inconsistent vertical coordinate parameters
+    ds_mock = output.ds.copy()
+
+    # Modify one of the vertical coordinate attributes to cause a mismatch
+    ds_mock.attrs["theta_s"] = 999
+
+    # Check if ValueError is raised due to mismatch
+    with pytest.raises(ValueError, match="theta_s from grid"):
+        output._check_vertical_coordinate(ds_mock)
+
+    # create a mock dataset with inconsistent vertical coordinate parameters
+    ds_mock = output.ds.copy()
+
+    # Modify one of the vertical coordinate attributes to cause a mismatch
+    ds_mock.attrs["Cs_w"] = ds_mock.attrs["Cs_w"] + 0.01
+
+    # Check if ValueError is raised due to mismatch
+    with pytest.raises(ValueError, match="Cs_w from grid"):
+        output._check_vertical_coordinate(ds_mock)
+
+
+def test_that_coordinates_are_added(use_dask):
+    fname_grid = Path(download_test_data("epac25km_grd.nc"))
+    grid = Grid.from_file(fname_grid)
+
+    fname_restart1 = Path(download_test_data("eastpac25km_rst.19980106000000.nc"))
+    output = ROMSOutput(
+        grid=grid, path=fname_restart1, type="restart", use_dask=use_dask
+    )
+
+    assert "abs_time" in output.ds.coords
+    assert "lat_rho" in output.ds.coords
+    assert "lon_rho" in output.ds.coords
+
+
+def test_plot(roms_output_from_restart_file, use_dask):
+
+    kwargs = {}
+    for var_name in ["temp", "u", "v"]:
+        roms_output_from_restart_file.plot(var_name, time=0, s=-1, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, eta=0, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, xi=0, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, eta=0, xi=0, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, s=-1, eta=0, **kwargs)
+
+    kwargs = {"depth_contours": True, "layer_contours": True}
+    for var_name in ["temp", "u", "v"]:
+        roms_output_from_restart_file.plot(var_name, time=0, s=-1, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, eta=0, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, xi=0, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, eta=0, xi=0, **kwargs)
+        roms_output_from_restart_file.plot(var_name, time=0, s=-1, eta=0, **kwargs)
+
+    roms_output_from_restart_file.plot("zeta", time=0, **kwargs)
+    roms_output_from_restart_file.plot("zeta", time=0, eta=0, **kwargs)
+    roms_output_from_restart_file.plot("zeta", time=0, xi=0, **kwargs)
+
+
+def test_plot_errors(roms_output_from_restart_file, use_dask):
+    with pytest.raises(ValueError, match="Invalid time index"):
+        roms_output_from_restart_file.plot("temp", time=10, s=-1)
+    with pytest.raises(ValueError, match="Invalid input"):
+        roms_output_from_restart_file.plot("temp", time=0)
+    with pytest.raises(ValueError, match="Ambiguous input"):
+        roms_output_from_restart_file.plot("temp", time=0, s=-1, eta=0, xi=0)
+    with pytest.raises(ValueError, match="Conflicting input"):
+        roms_output_from_restart_file.plot("zeta", time=0, eta=0, xi=0)

roms_tools/tests/{test_setup/test_regrid.py → test_regrid.py}

@@ -1,7 +1,7 @@
 import pytest
 import numpy as np
 import xarray as xr
-from roms_tools.setup.regrid import VerticalRegrid
+from roms_tools.regrid import VerticalRegrid
 
 
 def vertical_regridder(depth_values, layer_depth_rho_values):

roms_tools/tests/test_setup/test_boundary_forcing.py

@@ -3,7 +3,7 @@ from datetime import datetime
 import xarray as xr
 from roms_tools import Grid, BoundaryForcing
 import textwrap
-from roms_tools.setup.download import download_test_data
+from roms_tools.download import download_test_data
 from conftest import calculate_file_hash
 from pathlib import Path
 import logging

roms_tools/tests/test_setup/test_datasets.py

@@ -9,7 +9,7 @@ from roms_tools.setup.datasets import (
     ERA5Correction,
     CESMBGCDataset,
 )
-from roms_tools.setup.download import download_test_data
+from roms_tools.download import download_test_data
 from pathlib import Path
 
 

roms_tools/tests/test_setup/test_grid.py

@@ -4,7 +4,7 @@ import xarray as xr
 from roms_tools import Grid
 import importlib.metadata
 import textwrap
-from roms_tools.setup.download import download_test_data
+from roms_tools.download import download_test_data
 from conftest import calculate_file_hash
 from pathlib import Path
 

roms_tools/tests/test_setup/test_initial_conditions.py

@@ -4,7 +4,7 @@ from roms_tools import InitialConditions, Grid
 import xarray as xr
 import numpy as np
 import textwrap
-from roms_tools.setup.download import download_test_data
+from roms_tools.download import download_test_data
 from roms_tools.setup.datasets import CESMBGCDataset
 from pathlib import Path
 from conftest import calculate_file_hash
@@ -250,7 +250,9 @@ def test_initial_conditions_save(
                 expected_filepath.unlink()
 
 
-def test_roundtrip_yaml(initial_conditions, tmp_path, use_dask):
+def test_roundtrip_yaml(
+    initial_conditions_with_bgc_from_climatology, tmp_path, use_dask
+):
     """Test that creating an InitialConditions object, saving its parameters to yaml
     file, and re-opening yaml file creates the same object."""
 
@@ -261,13 +263,15 @@ def test_roundtrip_yaml(initial_conditions, tmp_path, use_dask):
         str(tmp_path / file_str),
     ]:  # test for Path object and str
 
-        initial_conditions.to_yaml(filepath)
+        initial_conditions_with_bgc_from_climatology.to_yaml(filepath)
 
         initial_conditions_from_file = InitialConditions.from_yaml(
             filepath, use_dask=use_dask
         )
 
-        assert initial_conditions == initial_conditions_from_file
+        assert (
+            initial_conditions_with_bgc_from_climatology == initial_conditions_from_file
+        )
 
         filepath = Path(filepath)
         filepath.unlink()

roms_tools/tests/test_setup/test_river_forcing.py

@@ -6,7 +6,7 @@ import textwrap
 from pathlib import Path
 import pytest
 from conftest import calculate_file_hash
-from roms_tools.setup.download import download_river_data
+from roms_tools.download import download_river_data
 
 
 @pytest.fixture

roms_tools/tests/test_setup/test_surface_forcing.py

@@ -2,7 +2,7 @@ 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

roms_tools/tests/test_setup/test_tides.py

@@ -1,7 +1,7 @@
 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

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):
@@ -14,3 +18,54 @@ def test_interpolate_from_climatology(use_dask):
 
     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()