roms-tools 3.1.1__py3-none-any.whl → 3.1.2__py3-none-any.whl

roms_tools/__init__.py

@@ -20,5 +20,9 @@ from roms_tools.setup.surface_forcing import SurfaceForcing  # noqa: F401
 from roms_tools.setup.tides import TidalForcing  # noqa: F401
 from roms_tools.tiling.partition import partition_netcdf  # noqa: F401
 
+
 # Configure logging when the package is imported
-logging.basicConfig(level=logging.INFO, format="%(levelname)s - %(message)s")
+LOG_FORMAT = "%(asctime)s - %(levelname)s - %(message)s"
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+logging.basicConfig(level=logging.INFO, format=LOG_FORMAT, datefmt=DATE_FORMAT)

roms_tools/plot.py

@@ -212,7 +212,14 @@ def plot_nesting(parent_grid_ds, child_grid_ds, parent_straddle, with_dim_names=
     return fig
 
 
-def section_plot(field, interface_depth=None, title="", kwargs={}, ax=None):
+def section_plot(
+    field: xr.DataArray,
+    interface_depth: xr.DataArray | None = None,
+    title: str = "",
+    yincrease: bool | None = False,
+    kwargs: dict = {},
+    ax: Axes | None = None,
+):
     """Plots a vertical section of a field with optional interface depths.
 
     Parameters
@@ -224,6 +231,11 @@ def section_plot(field, interface_depth=None, title="", kwargs={}, ax=None):
         Defaults to None.
     title : str, optional
         Title of the plot. Defaults to an empty string.
+    yincrease : bool or None, optional
+        Whether to orient the y-axis with increasing values upward.
+        If True, y-values increase upward (standard).
+        If False, y-values decrease upward (inverted).
+        If None (default), behavior is equivalent to False (inverted axis).
     kwargs : dict, optional
         Additional keyword arguments to pass to `xarray.plot`. Defaults to an empty dictionary.
     ax : matplotlib.axes.Axes, optional
@@ -248,6 +260,8 @@ def section_plot(field, interface_depth=None, title="", kwargs={}, ax=None):
     """
     if ax is None:
         fig, ax = plt.subplots(1, 1, figsize=(9, 5))
+    if yincrease is None:
+        yincrease = False
 
     dims_to_check = ["eta_rho", "eta_v", "xi_rho", "xi_u", "lat", "lon"]
     try:
@@ -279,7 +293,7 @@ def section_plot(field, interface_depth=None, title="", kwargs={}, ax=None):
     # Handle NaNs on either horizontal end
     field = field.where(~field[depth_label].isnull(), drop=True)
 
-    more_kwargs = {"x": xdim, "y": depth_label, "yincrease": False}
+    more_kwargs = {"x": xdim, "y": depth_label, "yincrease": yincrease}
 
     field.plot(**kwargs, **more_kwargs, ax=ax)
 
@@ -313,7 +327,12 @@ def section_plot(field, interface_depth=None, title="", kwargs={}, ax=None):
         return fig
 
 
-def profile_plot(field, title="", ax=None):
+def profile_plot(
+    field: xr.DataArray,
+    title: str = "",
+    yincrease: bool | None = False,
+    ax: Axes | None = None,
+):
     """Plots a vertical profile of the given field against depth.
 
     This function generates a profile plot by plotting the field values against
@@ -326,6 +345,11 @@ def profile_plot(field, title="", ax=None):
         The field to plot, typically representing vertical profile data.
     title : str, optional
         Title of the plot. Defaults to an empty string.
+    yincrease : bool or None, optional
+        Whether to orient the y-axis with increasing values upward.
+        If True, y-values increase upward (standard).
+        If False, y-values decrease upward (inverted).
+        If None (default), behavior is equivalent to False (inverted axis).
     ax : matplotlib.axes.Axes, optional
         Pre-existing axes to draw the plot on. If None, a new figure and axes are created.
 
@@ -343,6 +367,9 @@ def profile_plot(field, title="", ax=None):
     -----
     - The y-axis is inverted to ensure that depth increases downward.
     """
+    if yincrease is None:
+        yincrease = False
+
     depths_to_check = [
         "layer_depth",
         "interface_depth",
@@ -360,8 +387,8 @@ def profile_plot(field, title="", ax=None):
 
     if ax is None:
         fig, ax = plt.subplots(1, 1, figsize=(4, 7))
-    kwargs = {"y": depth_label, "yincrease": False}
-    field.plot(**kwargs, linewidth=2)
+    kwargs = {"y": depth_label, "yincrease": yincrease}
+    field.plot(ax=ax, linewidth=2, **kwargs)
     ax.set_title(title)
     ax.set_ylabel("Depth [m]")
     ax.grid()
@@ -370,7 +397,12 @@ def profile_plot(field, title="", ax=None):
         return fig
 
 
-def line_plot(field, title="", ax=None):
+def line_plot(
+    field: xr.DataArray,
+    title: str = "",
+    ax: Axes | None = None,
+    yincrease: bool | None = False,
+):
     """Plots a line graph of the given field with grey vertical bars indicating NaN
     regions.
 
@@ -382,6 +414,11 @@ def line_plot(field, title="", ax=None):
         Title of the plot. Defaults to an empty string.
     ax : matplotlib.axes.Axes, optional
         Pre-existing axes to draw the plot on. If None, a new figure and axes are created.
+    yincrease : bool, optional
+        Whether to orient the y-axis with increasing values upward.
+        If True, y-values increase upward (standard).
+        If False, y-values decrease upward (inverted).
+        If None (default), behavior is equivalent to True (standard axis).
 
     Returns
     -------
@@ -399,10 +436,12 @@ def line_plot(field, title="", ax=None):
     -----
     - NaN regions are identified and marked using `axvspan` with a grey shade.
     """
+    if yincrease is None:
+        yincrease = True
     if ax is None:
         fig, ax = plt.subplots(1, 1, figsize=(7, 4))
 
-    field.plot(ax=ax, linewidth=2)
+    field.plot(ax=ax, linewidth=2, yincrease=yincrease)
 
     # Loop through the NaNs in the field and add grey vertical bars
     dims_to_check = ["eta_rho", "eta_v", "xi_rho", "xi_u", "lat", "lon"]
@@ -775,6 +814,7 @@ def plot(
     depth_contours: bool = False,
     layer_contours: bool = False,
     max_nr_layer_contours: int | None = 10,
+    yincrease: bool | None = None,
     use_coarse_grid: bool = False,
     with_dim_names: bool = False,
     ax: Axes | None = None,
@@ -838,6 +878,12 @@ def plot(
     max_nr_layer_contours : int, optional
         Maximum number of vertical layer contours to draw. Default is 10.
 
+    yincrease: bool, optional
+        If True, the y-axis values increase upward (standard orientation).
+        If False, the y-axis values decrease upward (inverted axis).
+        If None (default), the orientation is determined by the default behavior
+        of the underlying plotting function.
+
     use_coarse_grid : bool, optional
         Use precomputed coarse-resolution grid. Default is False.
 
@@ -1086,14 +1132,15 @@ def plot(
                 field,
                 interface_depth=interface_depth,
                 title=title,
+                yincrease=yincrease,
                 kwargs={**kwargs, "add_colorbar": add_colorbar},
                 ax=ax,
             )
         else:
             if "s_rho" in field.dims:
-                fig = profile_plot(field, title=title, ax=ax)
+                fig = profile_plot(field, title=title, yincrease=yincrease, ax=ax)
             else:
-                fig = line_plot(field, title=title, ax=ax)
+                fig = line_plot(field, title=title, ax=ax, yincrease=yincrease)
 
     if save_path:
         plt.savefig(save_path, dpi=300, bbox_inches="tight")

roms_tools/regrid.py

@@ -251,7 +251,12 @@ class VerticalRegridFromROMS:
         ds : xarray.Dataset
             The dataset containing the ROMS output data, which must include the vertical coordinate `s_rho`.
         """
-        self.grid = xgcm.Grid(ds, coords={"s_rho": {"center": "s_rho"}}, periodic=False)
+        self.grid = xgcm.Grid(
+            ds,
+            coords={"s_rho": {"center": "s_rho"}},
+            periodic=False,
+            autoparse_metadata=False,
+        )
 
     def apply(self, da, depth_coords, target_depth_levels, mask_edges=True):
         """Applies vertical regridding from ROMS to the specified target depth levels.

roms_tools/setup/boundary_forcing.py

@@ -1,5 +1,6 @@
 import importlib.metadata
 import logging
+from collections import defaultdict
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
@@ -12,7 +13,13 @@ from scipy.ndimage import label
 from roms_tools import Grid
 from roms_tools.plot import line_plot, section_plot
 from roms_tools.regrid import LateralRegridToROMS, VerticalRegridToROMS
-from roms_tools.setup.datasets import CESMBGCDataset, GLORYSDataset, UnifiedBGCDataset
+from roms_tools.setup.datasets import (
+    CESMBGCDataset,
+    Dataset,
+    GLORYSDataset,
+    GLORYSDefaultDataset,
+    UnifiedBGCDataset,
+)
 from roms_tools.setup.utils import (
     add_time_info_to_ds,
     compute_barotropic_velocity,
@@ -181,8 +188,8 @@ class BoundaryForcing:
             }
         )
 
-        for direction in ["south", "east", "north", "west"]:
-            if self.boundaries[direction]:
+        for direction, is_enabled in self.boundaries.items():
+            if is_enabled:
                 bdry_target_coords = {
                     "lat": target_coords["lat"].isel(
                         **self.bdry_coords["vector"][direction]
@@ -403,7 +410,10 @@ class BoundaryForcing:
         if "name" not in self.source:
             raise ValueError("`source` must include a 'name'.")
         if "path" not in self.source:
-            raise ValueError("`source` must include a 'path'.")
+            if self.source["name"] != "GLORYS":
+                raise ValueError("`source` must include a 'path'.")
+
+            self.source["path"] = GLORYSDefaultDataset.dataset_name
 
         # Set 'climatology' to False if not provided in 'source'
         self.source = {
@@ -425,34 +435,49 @@ class BoundaryForcing:
                 "Sea surface height will NOT be used to adjust depth coordinates."
             )
 
-    def _get_data(self):
-        data_dict = {
-            "filename": self.source["path"],
-            "start_time": self.start_time,
-            "end_time": self.end_time,
-            "climatology": self.source["climatology"],
-            "use_dask": self.use_dask,
+    def _get_data(self) -> Dataset:
+        """Determine the correct `Dataset` type and return an instance.
+
+        Returns
+        -------
+        Dataset
+            The `Dataset` instance
+
+        """
+        dataset_map: dict[str, dict[str, dict[str, type[Dataset]]]] = {
+            "physics": {
+                "GLORYS": {
+                    "external": GLORYSDataset,
+                    "default": GLORYSDefaultDataset,
+                },
+            },
+            "bgc": {
+                "CESM_REGRIDDED": defaultdict(lambda: CESMBGCDataset),
+                "UNIFIED": defaultdict(lambda: UnifiedBGCDataset),
+            },
         }
 
-        if self.type == "physics":
-            if self.source["name"] == "GLORYS":
-                data = GLORYSDataset(**data_dict)
-            else:
-                raise ValueError(
-                    'Only "GLORYS" is a valid option for source["name"] when type is "physics".'
-                )
+        source_name = str(self.source["name"])
+        if source_name not in dataset_map[self.type]:
+            tpl = 'Valid options for source["name"] for type {} include: {}'
+            msg = tpl.format(self.type, " and ".join(dataset_map[self.type].keys()))
+            raise ValueError(msg)
 
-        elif self.type == "bgc":
-            if self.source["name"] == "CESM_REGRIDDED":
-                data = CESMBGCDataset(**data_dict)
-            elif self.source["name"] == "UNIFIED":
-                data = UnifiedBGCDataset(**data_dict)
-            else:
-                raise ValueError(
-                    'Only "CESM_REGRIDDED" and "UNIFIED" are valid options for source["name"] when type is "bgc".'
-                )
+        has_no_path = "path" not in self.source
+        has_default_path = self.source.get("path") == GLORYSDefaultDataset.dataset_name
+        use_default = has_no_path or has_default_path
+
+        variant = "default" if use_default else "external"
+
+        data_type = dataset_map[self.type][source_name][variant]
 
-        return data
+        return data_type(
+            filename=self.source["path"],
+            start_time=self.start_time,
+            end_time=self.end_time,
+            climatology=self.source["climatology"],
+            use_dask=self.use_dask,
+        )  # type: ignore
 
     def _set_variable_info(self, data):
         """Sets up a dictionary with metadata for variables based on the type of data
@@ -797,8 +822,8 @@ class BoundaryForcing:
                 elif location == "v":
                     mask = self.grid.ds.mask_v
 
-                for direction in ["south", "east", "north", "west"]:
-                    if self.boundaries[direction]:
+                for direction, is_enabled in self.boundaries.items():
+                    if is_enabled:
                         bdry_var_name = f"{var_name}_{direction}"
 
                         # Check for NaN values at the first time step using the nan_check function

roms_tools/setup/cdr_forcing.py

@@ -1039,18 +1039,12 @@ def _map_3d_gaussian(
         # Stack 2D distribution at that vertical level
         distribution_3d[{"s_rho": vertical_idx}] = distribution_2d
     else:
-        # Compute layer thickness
-        depth_interface = compute_depth_coordinates(
-            grid.ds, zeta=0, depth_type="interface", location="rho"
-        )
-        dz = depth_interface.diff("s_w").rename({"s_w": "s_rho"})
-
         # Compute vertical Gaussian shape
         exponent = -(((depth - release.depth) / release.vsc) ** 2)
         vertical_profile = np.exp(exponent)
 
         # Apply vertical Gaussian scaling
-        distribution_3d = distribution_2d * vertical_profile * dz
+        distribution_3d = distribution_2d * vertical_profile
 
         # Normalize
         distribution_3d /= release.vsc * np.sqrt(np.pi)

roms_tools/setup/datasets.py

@@ -1,9 +1,13 @@
+import importlib.util
 import logging
 import time
 from collections import Counter, defaultdict
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from pathlib import Path
+from types import ModuleType
+from typing import ClassVar
 
 import numpy as np
 import xarray as xr
@@ -25,7 +29,7 @@ from roms_tools.setup.utils import (
     interpolate_from_climatology,
     one_dim_fill,
 )
-from roms_tools.utils import _has_gcsfs, _load_data
+from roms_tools.utils import _get_pkg_error_msg, _has_gcsfs, _load_data
 
 # lat-lon datasets
 
@@ -96,17 +100,18 @@ class Dataset:
     use_dask: bool | None = False
     apply_post_processing: bool | None = True
     read_zarr: bool | None = False
+    ds_loader_fn: Callable[[], xr.Dataset] | None = None
 
     is_global: bool = field(init=False, repr=False)
     ds: xr.Dataset = field(init=False, repr=False)
 
-    def __post_init__(self):
-        """
-        Post-initialization processing:
+    def __post_init__(self) -> None:
+        """Perform post-initialization processing.
+
         1. Loads the dataset from the specified filename.
-        2. Applies time filtering based on start_time and end_time if provided.
-        3. Selects relevant fields as specified by var_names.
-        4. Ensures latitude values and depth values are in ascending order.
+        2. Applies time filtering based on start_time and end_time (if provided).
+        3. Selects relevant fields as specified by `var_names`.
+        4. Ensures latitude, longitude, and depth values are in ascending order.
         5. Checks if the dataset covers the entire globe and adjusts if necessary.
         """
         # Validate start_time and end_time
@@ -168,7 +173,11 @@ class Dataset:
             If a list of files is provided but self.dim_names["time"] is not available or use_dask=False.
         """
         ds = _load_data(
-            self.filename, self.dim_names, self.use_dask, read_zarr=self.read_zarr
+            self.filename,
+            self.dim_names,
+            self.use_dask or False,
+            read_zarr=self.read_zarr or False,
+            ds_loader_fn=self.ds_loader_fn,
         )
 
         return ds
@@ -1075,6 +1084,83 @@ class GLORYSDataset(Dataset):
         self.ds["mask_vel"] = mask_vel
 
 
+@dataclass(kw_only=True)
+class GLORYSDefaultDataset(GLORYSDataset):
+    """A GLORYS dataset that is loaded from the Copernicus Marine Data Store."""
+
+    dataset_name: ClassVar[str] = "cmems_mod_glo_phy_my_0.083deg_P1D-m"
+    """The GLORYS dataset-id for requests to the Copernicus Marine Toolkit"""
+    _tk_module: ModuleType | None = None
+    """The dynamically imported Copernicus Marine module."""
+
+    def __post_init__(self) -> None:
+        """Configure attributes to ensure use of the correct upstream data-source."""
+        self.read_zarr = True
+        self.use_dask = True
+        self.filename = self.dataset_name
+        self.ds_loader_fn = self._load_from_copernicus
+
+        super().__post_init__()
+
+    def _check_auth(self, package_name: str) -> None:
+        """Check the local credential hierarchy for auth credentials.
+
+        Raises
+        ------
+        RuntimeError
+            If auth credentials cannot be found.
+        """
+        if self._tk_module and not self._tk_module.login(check_credentials_valid=True):
+            msg = f"Authenticate with `{package_name} login` to retrieve GLORYS data."
+            raise RuntimeError(msg)
+
+    def _load_copernicus(self) -> ModuleType:
+        """Dynamically load the optional Copernicus Marine Toolkit dependency.
+
+        Raises
+        ------
+        RuntimeError
+            - If the toolkit module is not available or cannot be imported.
+            - If auth credentials cannot be found.
+        """
+        package_name = "copernicusmarine"
+        if self._tk_module:
+            self._check_auth(package_name)
+            return self._tk_module
+
+        spec = importlib.util.find_spec(package_name)
+        if not spec:
+            msg = _get_pkg_error_msg("cloud-based GLORYS data", package_name, "stream")
+            raise RuntimeError(msg)
+
+        try:
+            self._tk_module = importlib.import_module(package_name)
+        except ImportError as e:
+            msg = f"Package `{package_name}` was found but could not be loaded."
+            raise RuntimeError(msg) from e
+
+        self._check_auth(package_name)
+        return self._tk_module
+
+    def _load_from_copernicus(self) -> xr.Dataset:
+        """Load a GLORYS dataset supporting streaming.
+
+        Returns
+        -------
+        xr.Dataset
+            The streaming dataset
+        """
+        copernicusmarine = self._load_copernicus()
+        return copernicusmarine.open_dataset(
+            self.dataset_name,
+            start_datetime=self.start_time,
+            end_datetime=self.end_time,
+            service="arco-geo-series",
+            coordinates_selection_method="inside",
+            chunk_size_limit=2,
+        )
+
+
 @dataclass(kw_only=True)
 class UnifiedDataset(Dataset):
     """Represents unified BGC data on original grid.
@@ -1549,12 +1635,8 @@ class ERA5ARCODataset(ERA5Dataset):
     def __post_init__(self):
         self.read_zarr = True
         if not _has_gcsfs():
-            raise RuntimeError(
-                "To use cloud-based ERA5 data, GCSFS is required but not installed. Install it with:\n"
-                "  • `pip install roms-tools[stream]` or\n"
-                "  • `conda install gcsfs`\n"
-                "Alternatively, install `roms-tools` with conda to include all dependencies."
-            )
+            msg = _get_pkg_error_msg("cloud-based ERA5 data", "gcsfs", "stream")
+            raise RuntimeError(msg)
 
         super().__post_init__()
 

roms_tools/setup/grid.py

@@ -415,30 +415,57 @@ class Grid:
 
     def plot(
         self,
+        lat: float | None = None,
+        lon: float | None = None,
         with_dim_names: bool = False,
         save_path: str | None = None,
     ) -> None:
-        """Plot the grid.
+        """Plot the grid with bathymetry.
+
+        Depending on the arguments, this will either:
+          * Plot the full horizontal grid (if both `lat` and `lon` are None),
+          * Plot a zonal (east-west) vertical section at a given latitude (`lat`),
+          * Plot a meridional (south-north) vertical section at a given longitude (`lon`).
 
         Parameters
         ----------
+        lat : float, optional
+            Latitude in degrees at which to plot a vertical (zonal) section. Cannot be
+            provided together with `lon`. Default is None.
+
+        lon : float, optional
+            Longitude in degrees at which to plot a vertical (meridional) section. Cannot be
+            provided together with `lat`. Default is None.
+
         with_dim_names : bool, optional
-            Whether or not to plot the dimension names. Default is False.
+            If True and no section is requested (i.e., both `lat` and `lon` are None), annotate
+            the plot with the underlying dimension names. Default is False.
 
         save_path : str, optional
             Path to save the generated plot. If None, the plot is shown interactively.
             Default is None.
 
+        Raises
+        ------
+        ValueError
+            If both `lat` and `lon` are specified simultaneously.
+
         Returns
         -------
         None
             This method does not return any value. It generates and displays a plot.
         """
+        if lat is not None and lon is not None:
+            raise ValueError("Specify either `lat` or `lon`, not both.")
+
         field = self.ds["h"]
 
         plot(
             field=field,
             grid_ds=self.ds,
+            lat=lat,
+            lon=lon,
+            yincrease=False,
             with_dim_names=with_dim_names,
             save_path=save_path,
             cmap_name="YlGnBu",

roms_tools/setup/surface_forcing.py

@@ -150,12 +150,20 @@ class SurfaceForcing:
             use_coarse_grid = False
         elif self.coarse_grid_mode == "auto":
             use_coarse_grid = self._determine_coarse_grid_usage(data)
-        if use_coarse_grid:
-            logging.info("Data will be interpolated onto grid coarsened by factor 2.")
-        else:
-            logging.info("Data will be interpolated onto fine grid.")
         self.use_coarse_grid = use_coarse_grid
 
+        opt_file = "bulk_frc.opt" if self.type == "physics" else "bgc.opt"
+        grid_desc = "grid coarsened by factor 2" if use_coarse_grid else "fine grid"
+        interp_flag = 1 if use_coarse_grid else 0
+
+        logging.info(
+            "Data will be interpolated onto the %s. "
+            "Remember to set `interp_frc = %d` in your `%s` ROMS option file.",
+            grid_desc,
+            interp_flag,
+            opt_file,
+        )
+
         target_coords = get_target_coords(self.grid, self.use_coarse_grid)
         self.target_coords = target_coords
 

roms_tools/tests/test_setup/test_boundary_forcing.py

@@ -1,7 +1,9 @@
 import logging
+import os
 import textwrap
 from datetime import datetime
 from pathlib import Path
+from unittest import mock
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -758,3 +760,58 @@ def test_from_yaml_missing_boundary_forcing(tmp_path, use_dask):
 
         yaml_filepath = Path(yaml_filepath)
         yaml_filepath.unlink()
+
+
+@pytest.mark.stream
+@pytest.mark.use_dask
+@pytest.mark.use_copernicus
+def test_default_glorys_dataset_loading(tiny_grid: Grid) -> None:
+    """Verify the default GLORYS dataset is loaded when a path is not provided."""
+    start_time = datetime(2010, 2, 1)
+    end_time = datetime(2010, 3, 1)
+
+    with mock.patch.dict(
+        os.environ, {"PYDEVD_WARN_EVALUATION_TIMEOUT": "90"}, clear=True
+    ):
+        bf = BoundaryForcing(
+            grid=tiny_grid,
+            source={"name": "GLORYS"},
+            type="physics",
+            start_time=start_time,
+            end_time=end_time,
+            use_dask=True,
+            bypass_validation=True,
+        )
+
+        expected_vars = {"u_south", "v_south", "temp_south", "salt_south"}
+        assert set(bf.ds.data_vars).issuperset(expected_vars)
+
+
+@pytest.mark.parametrize(
+    "use_dask",
+    [pytest.param(True, marks=pytest.mark.use_dask), False],
+)
+def test_nondefault_glorys_dataset_loading(small_grid: Grid, use_dask: bool) -> None:
+    """Verify a non-default GLORYS dataset is loaded when a path is provided."""
+    start_time = datetime(2012, 1, 1)
+    end_time = datetime(2012, 12, 31)
+
+    local_path = Path(download_test_data("GLORYS_NA_20120101.nc"))
+
+    with mock.patch.dict(
+        os.environ, {"PYDEVD_WARN_EVALUATION_TIMEOUT": "90"}, clear=True
+    ):
+        bf = BoundaryForcing(
+            grid=small_grid,
+            source={
+                "name": "GLORYS",
+                "path": local_path,
+            },
+            type="physics",
+            start_time=start_time,
+            end_time=end_time,
+            use_dask=use_dask,
+        )
+
+        expected_vars = {"u_south", "v_south", "temp_south", "salt_south"}
+        assert set(bf.ds.data_vars).issuperset(expected_vars)