roms-tools 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

roms_tools/_version.py

@@ -1,2 +1,2 @@
 # Do not change! Do not track in version control!
-__version__ = "1.4.1"
+__version__ = "1.5.0"

roms_tools/setup/boundary_forcing.py

@@ -6,16 +6,21 @@ import importlib.metadata
 from typing import Dict, Union, List
 from dataclasses import dataclass, field, asdict
 from roms_tools.setup.grid import Grid
-from roms_tools.setup.mixins import ROMSToolsMixins
+from roms_tools.setup.fill import _lateral_fill
+from roms_tools.setup.regrid import _lateral_regrid, _vertical_regrid
 from datetime import datetime
 from roms_tools.setup.datasets import GLORYSDataset, CESMBGCDataset
 from roms_tools.setup.utils import (
     nan_check,
     substitute_nans_by_fillvalue,
     get_variable_metadata,
-    get_boundary_info,
     group_dataset,
     save_datasets,
+    get_target_coords,
+    rotate_velocities,
+    compute_barotropic_velocity,
+    _extrapolate_deepest_to_bottom,
+    transpose_dimensions,
 )
 from roms_tools.setup.plot import _section_plot, _line_plot
 import matplotlib.pyplot as plt
@@ -23,9 +28,8 @@ from pathlib import Path
 
 
 @dataclass(frozen=True, kw_only=True)
-class BoundaryForcing(ROMSToolsMixins):
-    """
-    Represents boundary forcing input data for ROMS.
+class BoundaryForcing:
+    """Represents boundary forcing input data for ROMS.
 
     Parameters
     ----------
@@ -38,21 +42,27 @@ class BoundaryForcing(ROMSToolsMixins):
     boundaries : Dict[str, bool], optional
         Dictionary specifying which boundaries are forced (south, east, north, west). Default is all True.
     source : Dict[str, Union[str, Path, List[Union[str, Path]]], bool]
-        Dictionary specifying the source of the boundary forcing data:
-        - "name" (str): Name of the data source (e.g., "GLORYS").
-        - "path" (Union[str, Path, List[Union[str, Path]]]): The path to the raw data file(s). Can be a single string (with or without wildcards),
-          a single Path object, or a list of strings or Path objects containing multiple files.
-        - "climatology" (bool): Indicates if the data is climatology data. Defaults to False.
+        Dictionary specifying the source of the boundary forcing data. Keys include:
+
+          - "name" (str): Name of the data source (e.g., "GLORYS").
+          - "path" (Union[str, Path, List[Union[str, Path]]]): The path to the raw data file(s). This can be:
+
+            - A single string (with or without wildcards).
+            - A single Path object.
+            - A list of strings or Path objects containing multiple files.
+          - "climatology" (bool): Indicates if the data is climatology data. Defaults to False.
+
+    type : str
+        Specifies the type of forcing data. Options are:
+
+          - "physics": for physical atmospheric forcing.
+          - "bgc": for biogeochemical forcing.
+
     model_reference_date : datetime, optional
         Reference date for the model. Default is January 1, 2000.
     use_dask: bool, optional
         Indicates whether to use dask for processing. If True, data is processed with dask; if False, data is processed eagerly. Defaults to False.
 
-    Attributes
-    ----------
-    ds : xr.Dataset
-        Xarray Dataset containing the boundary forcing data.
-
     Examples
     --------
     >>> boundary_forcing = BoundaryForcing(
@@ -86,33 +96,115 @@ class BoundaryForcing(ROMSToolsMixins):
     def __post_init__(self):
 
         self._input_checks()
-        lon, lat, angle, straddle = super().get_target_lon_lat()
+        target_coords = get_target_coords(self.grid)
 
         data = self._get_data()
         data.choose_subdomain(
-            latitude_range=[lat.min().values, lat.max().values],
-            longitude_range=[lon.min().values, lon.max().values],
+            latitude_range=[
+                target_coords["lat"].min().values,
+                target_coords["lat"].max().values,
+            ],
+            longitude_range=[
+                target_coords["lon"].min().values,
+                target_coords["lon"].max().values,
+            ],
             margin=2,
-            straddle=straddle,
+            straddle=target_coords["straddle"],
         )
 
-        if self.type == "physics":
-            vars_2d = ["zeta"]
-            vars_3d = ["temp", "salt", "u", "v"]
-        elif self.type == "bgc":
-            vars_2d = []
-            vars_3d = data.var_names.keys()
-
-        data_vars = super().regrid_data(data, vars_2d, vars_3d, lon, lat)
+        variable_info = self._set_variable_info(data)
 
-        if self.type == "physics":
-            data_vars = super().process_velocities(data_vars, angle, "u", "v")
-        object.__setattr__(data, "data_vars", data_vars)
+        data_vars = {}
+        data_vars = _extrapolate_deepest_to_bottom(data_vars, data)
+        data_vars = _lateral_fill(data_vars, data)
 
-        d_meta = get_variable_metadata()
         bdry_coords = get_boundary_info()
+        ds = xr.Dataset()
+        for direction in ["south", "east", "north", "west"]:
+            if self.boundaries[direction]:
+
+                bdry_data_vars = data_vars.copy()
+
+                # lateral regridding of vector fields
+                vector_var_names = [
+                    name for name, info in variable_info.items() if info["is_vector"]
+                ]
+                if len(vector_var_names) > 0:
+                    lon = target_coords["lon"].isel(**bdry_coords["vector"][direction])
+                    lat = target_coords["lat"].isel(**bdry_coords["vector"][direction])
+                    bdry_data_vars = _lateral_regrid(
+                        data, lon, lat, bdry_data_vars, vector_var_names
+                    )
+                # lateral regridding of tracer fields
+                tracer_var_names = [
+                    name
+                    for name, info in variable_info.items()
+                    if not info["is_vector"]
+                ]
+                if len(tracer_var_names) > 0:
+                    lon = target_coords["lon"].isel(**bdry_coords["rho"][direction])
+                    lat = target_coords["lat"].isel(**bdry_coords["rho"][direction])
+                    bdry_data_vars = _lateral_regrid(
+                        data, lon, lat, bdry_data_vars, tracer_var_names
+                    )
+
+                # rotation of velocities and interpolation to u/v points
+                if "u" in variable_info and "v" in variable_info:
+                    angle = target_coords["angle"].isel(
+                        **bdry_coords["vector"][direction]
+                    )
+                    (bdry_data_vars["u"], bdry_data_vars["v"],) = rotate_velocities(
+                        bdry_data_vars["u"],
+                        bdry_data_vars["v"],
+                        angle,
+                        interpolate=True,
+                    )
+
+                # selection of outermost margin for u/v variables
+                for var in variable_info.keys():
+                    if var in bdry_data_vars:
+                        location = variable_info[var]["location"]
+                        if location in ["u", "v"]:
+                            bdry_data_vars[var] = bdry_data_vars[var].isel(
+                                **bdry_coords[location][direction]
+                            )
+
+                # vertical regridding
+                for location in ["rho", "u", "v"]:
+                    var_names = [
+                        name
+                        for name, info in variable_info.items()
+                        if info["location"] == location and info["is_3d"]
+                    ]
+                    if len(var_names) > 0:
+                        bdry_data_vars = _vertical_regrid(
+                            data,
+                            self.grid.ds[f"layer_depth_{location}"].isel(
+                                **bdry_coords[location][direction],
+                            ),
+                            bdry_data_vars,
+                            var_names,
+                        )
+
+                # compute barotropic velocities
+                if "u" in variable_info and "v" in variable_info:
+                    for var in ["u", "v"]:
+                        bdry_data_vars[f"{var}bar"] = compute_barotropic_velocity(
+                            bdry_data_vars[var],
+                            self.grid.ds[f"interface_depth_{var}"].isel(
+                                **bdry_coords[var][direction]
+                            ),
+                        )
+
+                # Reorder dimensions
+                for var in bdry_data_vars.keys():
+                    bdry_data_vars[var] = transpose_dimensions(bdry_data_vars[var])
+
+                # Write the boundary data into dataset
+                ds = self._write_into_dataset(direction, bdry_data_vars, ds)
 
-        ds = self._write_into_dataset(data, d_meta, bdry_coords)
+        # Add global information
+        ds = self._add_global_metadata(data, ds)
 
         # NaN values at wet points indicate that the raw data did not cover the domain, and the following will raise a ValueError
         # this check works only for 2D fields because for 3D I extrapolate to bottom which eliminates NaNs
@@ -182,37 +274,86 @@ class BoundaryForcing(ROMSToolsMixins):
 
         return data
 
-    def _write_into_dataset(self, data, d_meta, bdry_coords):
+    def _set_variable_info(self, data):
+        """Sets up a dictionary with metadata for variables based on the type of data
+        (physics or BGC).
 
-        # save in new dataset
-        ds = xr.Dataset()
+        The dictionary contains the following information:
+        - `location`: Where the variable resides in the grid (e.g., rho, u, or v points).
+        - `is_vector`: Whether the variable is part of a vector (True for velocity components like 'u' and 'v').
+        - `vector_pair`: For vector variables, this indicates the associated variable that forms the vector (e.g., 'u' and 'v').
+        - `is_3d`: Indicates whether the variable is 3D (True for variables like 'temp' and 'salt') or 2D (False for 'zeta').
 
-        for direction in ["south", "east", "north", "west"]:
-            if self.boundaries[direction]:
+        Returns
+        -------
+        dict
+            A dictionary where the keys are variable names and the values are dictionaries of metadata
+            about each variable, including 'location', 'is_vector', 'vector_pair', and 'is_3d'.
+        """
+        default_info = {
+            "location": "rho",
+            "is_vector": False,
+            "vector_pair": None,
+            "is_3d": True,
+        }
 
-                for var in data.data_vars.keys():
-                    if var in ["u", "ubar"]:
-                        ds[f"{var}_{direction}"] = (
-                            data.data_vars[var]
-                            .isel(**bdry_coords["u"][direction])
-                            .astype(np.float32)
-                        )
-                    elif var in ["v", "vbar"]:
-                        ds[f"{var}_{direction}"] = (
-                            data.data_vars[var]
-                            .isel(**bdry_coords["v"][direction])
-                            .astype(np.float32)
-                        )
-                    else:
-                        ds[f"{var}_{direction}"] = (
-                            data.data_vars[var]
-                            .isel(**bdry_coords["rho"][direction])
-                            .astype(np.float32)
-                        )
-                    ds[f"{var}_{direction}"].attrs[
-                        "long_name"
-                    ] = f"{direction}ern boundary {d_meta[var]['long_name']}"
-                    ds[f"{var}_{direction}"].attrs["units"] = d_meta[var]["units"]
+        # Define a dictionary for variable names and their associated information
+        if self.type == "physics":
+            variable_info = {
+                "zeta": {
+                    "location": "rho",
+                    "is_vector": False,
+                    "vector_pair": None,
+                    "is_3d": False,
+                },
+                "temp": default_info,
+                "salt": default_info,
+                "u": {
+                    "location": "u",
+                    "is_vector": True,
+                    "vector_pair": "v",
+                    "is_3d": True,
+                },
+                "v": {
+                    "location": "v",
+                    "is_vector": True,
+                    "vector_pair": "u",
+                    "is_3d": True,
+                },
+                "ubar": {
+                    "location": "u",
+                    "is_vector": True,
+                    "vector_pair": "vbar",
+                    "is_3d": False,
+                },
+                "vbar": {
+                    "location": "v",
+                    "is_vector": True,
+                    "vector_pair": "ubar",
+                    "is_3d": False,
+                },
+            }
+        elif self.type == "bgc":
+            variable_info = {}
+            for var in data.var_names.keys():
+                variable_info[var] = default_info
+
+        return variable_info
+
+    def _write_into_dataset(self, direction, data_vars, ds=None):
+        if ds is None:
+            ds = xr.Dataset()
+
+        d_meta = get_variable_metadata()
+
+        for var in data_vars.keys():
+            ds[f"{var}_{direction}"] = data_vars[var].astype(np.float32)
+
+            ds[f"{var}_{direction}"].attrs[
+                "long_name"
+            ] = f"{direction}ern boundary {d_meta[var]['long_name']}"
+
+            ds[f"{var}_{direction}"].attrs["units"] = d_meta[var]["units"]
 
         # Gracefully handle dropping variables that might not be present
         variables_to_drop = [
@@ -233,61 +374,10 @@ class BoundaryForcing(ROMSToolsMixins):
         existing_vars = [var for var in variables_to_drop if var in ds]
         ds = ds.drop_vars(existing_vars)
 
-        ds = self._add_global_metadata(ds)
-
-        # Convert the time coordinate to the format expected by ROMS
-        if data.climatology:
-            ds.attrs["climatology"] = str(True)
-            # Preserve absolute time coordinate for readability
-            ds = ds.assign_coords(
-                {"abs_time": np.datetime64(self.model_reference_date) + ds["time"]}
-            )
-            # Convert to pandas TimedeltaIndex
-            timedelta_index = pd.to_timedelta(ds["time"].values)
-
-            # Determine the start of the year for the base_datetime
-            start_of_year = datetime(self.model_reference_date.year, 1, 1)
-
-            # Calculate the offset from midnight of the new year
-            offset = self.model_reference_date - start_of_year
-
-            # Convert the timedelta to nanoseconds first, then to days
-            bry_time = xr.DataArray(
-                (timedelta_index - offset).view("int64") / 3600 / 24 * 1e-9,
-                dims="time",
-            )
-
-        else:
-            # Preserve absolute time coordinate for readability
-            ds = ds.assign_coords({"abs_time": ds["time"]})
-            # TODO: Check if we need to convert from 12:00:00 to 00:00:00 as in matlab scripts
-            bry_time = (
-                (ds["time"] - np.datetime64(self.model_reference_date)).astype(
-                    "float64"
-                )
-                / 3600
-                / 24
-                * 1e-9
-            )
-
-        ds = ds.assign_coords({"bry_time": bry_time})
-        ds["bry_time"].attrs[
-            "long_name"
-        ] = f"days since {str(self.model_reference_date)}"
-        ds["bry_time"].encoding["units"] = "days"
-        ds["bry_time"].attrs["units"] = "days"
-        ds = ds.swap_dims({"time": "bry_time"})
-        ds = ds.drop_vars("time")
-        ds.encoding["unlimited_dims"] = "bry_time"
-
-        if data.climatology:
-            ds["bry_time"].attrs["cycle_length"] = 365.25
-
         return ds
 
     def _get_coordinates(self, direction, point):
-        """
-        Retrieve layer and interface depth coordinates for a specified grid boundary.
+        """Retrieve layer and interface depth coordinates for a specified grid boundary.
 
         This method extracts the layer depth and interface depth coordinates along
         a specified boundary (north, south, east, or west) and for a specified point
@@ -321,7 +411,7 @@ class BoundaryForcing(ROMSToolsMixins):
 
         return layer_depth, interface_depth
 
-    def _add_global_metadata(self, ds=None):
+    def _add_global_metadata(self, data, ds=None):
 
         if ds is None:
             ds = xr.Dataset()
@@ -341,6 +431,53 @@ class BoundaryForcing(ROMSToolsMixins):
         ds.attrs["theta_b"] = self.grid.ds.attrs["theta_b"]
         ds.attrs["hc"] = self.grid.ds.attrs["hc"]
 
+        # Convert the time coordinate to the format expected by ROMS
+        if data.climatology:
+            ds.attrs["climatology"] = str(True)
+            # Preserve absolute time coordinate for readability
+            ds = ds.assign_coords(
+                {"abs_time": np.datetime64(self.model_reference_date) + ds["time"]}
+            )
+            # Convert to pandas TimedeltaIndex
+            timedelta_index = pd.to_timedelta(ds["time"].values)
+
+            # Determine the start of the year for the base_datetime
+            start_of_year = datetime(self.model_reference_date.year, 1, 1)
+
+            # Calculate the offset from midnight of the new year
+            offset = self.model_reference_date - start_of_year
+
+            # Convert the timedelta to nanoseconds first, then to days
+            bry_time = xr.DataArray(
+                (timedelta_index - offset).view("int64") / 3600 / 24 * 1e-9,
+                dims="time",
+            )
+
+        else:
+            # Preserve absolute time coordinate for readability
+            ds = ds.assign_coords({"abs_time": ds["time"]})
+            bry_time = (
+                (ds["time"] - np.datetime64(self.model_reference_date)).astype(
+                    "float64"
+                )
+                / 3600
+                / 24
+                * 1e-9
+            )
+
+        ds = ds.assign_coords({"bry_time": bry_time})
+        ds["bry_time"].attrs[
+            "long_name"
+        ] = f"days since {str(self.model_reference_date)}"
+        ds["bry_time"].encoding["units"] = "days"
+        ds["bry_time"].attrs["units"] = "days"
+        ds = ds.swap_dims({"time": "bry_time"})
+        ds = ds.drop_vars("time")
+        ds.encoding["unlimited_dims"] = "bry_time"
+
+        if data.climatology:
+            ds["bry_time"].attrs["cycle_length"] = 365.25
+
         return ds
 
     def plot(
@@ -349,52 +486,55 @@ class BoundaryForcing(ROMSToolsMixins):
         time=0,
         layer_contours=False,
     ) -> None:
-        """
-        Plot the boundary forcing field for a given time-slice.
+        """Plot the boundary forcing field for a given time-slice.
 
         Parameters
         ----------
         varname : str
             The name of the boundary forcing field to plot. Options include:
-            - "temp_{direction}": Potential temperature, where {direction} can be one of ["south", "east", "north", "west"].
-            - "salt_{direction}": Salinity, where {direction} can be one of ["south", "east", "north", "west"].
-            - "zeta_{direction}": Sea surface height, where {direction} can be one of ["south", "east", "north", "west"].
-            - "u_{direction}": u-flux component, where {direction} can be one of ["south", "east", "north", "west"].
-            - "v_{direction}": v-flux component, where {direction} can be one of ["south", "east", "north", "west"].
-            - "ubar_{direction}": Vertically integrated u-flux component, where {direction} can be one of ["south", "east", "north", "west"].
-            - "vbar_{direction}": Vertically integrated v-flux component, where {direction} can be one of ["south", "east", "north", "west"].
-            - "PO4_{direction}": Dissolved Inorganic Phosphate (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "NO3_{direction}": Dissolved Inorganic Nitrate (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "SiO3_{direction}": Dissolved Inorganic Silicate (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "NH4_{direction}": Dissolved Ammonia (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "Fe_{direction}": Dissolved Inorganic Iron (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "Lig_{direction}": Iron Binding Ligand (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "O2_{direction}": Dissolved Oxygen (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DIC_{direction}": Dissolved Inorganic Carbon (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DIC_ALT_CO2_{direction}": Dissolved Inorganic Carbon, Alternative CO2 (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "ALK_{direction}": Alkalinity (meq/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "ALK_ALT_CO2_{direction}": Alkalinity, Alternative CO2 (meq/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DOC_{direction}": Dissolved Organic Carbon (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DON_{direction}": Dissolved Organic Nitrogen (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DOP_{direction}": Dissolved Organic Phosphorus (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DOPr_{direction}": Refractory Dissolved Organic Phosphorus (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DONr_{direction}": Refractory Dissolved Organic Nitrogen (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "DOCr_{direction}": Refractory Dissolved Organic Carbon (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "zooC_{direction}": Zooplankton Carbon (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "spChl_{direction}": Small Phytoplankton Chlorophyll (mg/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "spC_{direction}": Small Phytoplankton Carbon (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "spP_{direction}": Small Phytoplankton Phosphorous (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "spFe_{direction}": Small Phytoplankton Iron (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "spCaCO3_{direction}": Small Phytoplankton CaCO3 (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diatChl_{direction}": Diatom Chlorophyll (mg/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diatC_{direction}": Diatom Carbon (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diatP_{direction}": Diatom Phosphorus (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diatFe_{direction}": Diatom Iron (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diatSi_{direction}": Diatom Silicate (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diazChl_{direction}": Diazotroph Chlorophyll (mg/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diazC_{direction}": Diazotroph Carbon (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diazP_{direction}": Diazotroph Phosphorus (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
-            - "diazFe_{direction}": Diazotroph Iron (mmol/m³), where {direction} can be one of ["south", "east", "north", "west"].
+
+            - "temp_{direction}": Potential temperature,
+            - "salt_{direction}": Salinity,
+            - "zeta_{direction}": Sea surface height,
+            - "u_{direction}": u-flux component,
+            - "v_{direction}": v-flux component,
+            - "ubar_{direction}": Vertically integrated u-flux component,
+            - "vbar_{direction}": Vertically integrated v-flux component,
+            - "PO4_{direction}": Dissolved Inorganic Phosphate (mmol/m³),
+            - "NO3_{direction}": Dissolved Inorganic Nitrate (mmol/m³),
+            - "SiO3_{direction}": Dissolved Inorganic Silicate (mmol/m³),
+            - "NH4_{direction}": Dissolved Ammonia (mmol/m³),
+            - "Fe_{direction}": Dissolved Inorganic Iron (mmol/m³),
+            - "Lig_{direction}": Iron Binding Ligand (mmol/m³),
+            - "O2_{direction}": Dissolved Oxygen (mmol/m³),
+            - "DIC_{direction}": Dissolved Inorganic Carbon (mmol/m³),
+            - "DIC_ALT_CO2_{direction}": Dissolved Inorganic Carbon, Alternative CO2 (mmol/m³),
+            - "ALK_{direction}": Alkalinity (meq/m³),
+            - "ALK_ALT_CO2_{direction}": Alkalinity, Alternative CO2 (meq/m³),
+            - "DOC_{direction}": Dissolved Organic Carbon (mmol/m³),
+            - "DON_{direction}": Dissolved Organic Nitrogen (mmol/m³),
+            - "DOP_{direction}": Dissolved Organic Phosphorus (mmol/m³),
+            - "DOPr_{direction}": Refractory Dissolved Organic Phosphorus (mmol/m³),
+            - "DONr_{direction}": Refractory Dissolved Organic Nitrogen (mmol/m³),
+            - "DOCr_{direction}": Refractory Dissolved Organic Carbon (mmol/m³),
+            - "zooC_{direction}": Zooplankton Carbon (mmol/m³),
+            - "spChl_{direction}": Small Phytoplankton Chlorophyll (mg/m³),
+            - "spC_{direction}": Small Phytoplankton Carbon (mmol/m³),
+            - "spP_{direction}": Small Phytoplankton Phosphorous (mmol/m³),
+            - "spFe_{direction}": Small Phytoplankton Iron (mmol/m³),
+            - "spCaCO3_{direction}": Small Phytoplankton CaCO3 (mmol/m³),
+            - "diatChl_{direction}": Diatom Chlorophyll (mg/m³),
+            - "diatC_{direction}": Diatom Carbon (mmol/m³),
+            - "diatP_{direction}": Diatom Phosphorus (mmol/m³),
+            - "diatFe_{direction}": Diatom Iron (mmol/m³),
+            - "diatSi_{direction}": Diatom Silicate (mmol/m³),
+            - "diazChl_{direction}": Diazotroph Chlorophyll (mg/m³),
+            - "diazC_{direction}": Diazotroph Carbon (mmol/m³),
+            - "diazP_{direction}": Diazotroph Phosphorus (mmol/m³),
+            - "diazFe_{direction}": Diazotroph Iron (mmol/m³),
+
+            where {direction} can be one of ["south", "east", "north", "west"].
+
         time : int, optional
             The time index to plot. Default is 0.
         layer_contours : bool, optional
@@ -468,21 +608,22 @@ class BoundaryForcing(ROMSToolsMixins):
     def save(
         self, filepath: Union[str, Path], np_eta: int = None, np_xi: int = None
     ) -> None:
-        """
-        Save the boundary forcing fields to netCDF4 files.
+        """Save the boundary forcing fields to netCDF4 files.
 
         This method saves the dataset by grouping it into subsets based on the data frequency. The subsets are then written
         to one or more netCDF4 files. The filenames of the output files reflect the temporal coverage of the data.
 
         There are two modes of saving the dataset:
 
-        1. **Single File Mode (default)**:
-           - If both `np_eta` and `np_xi` are `None`, the entire dataset, divided by temporal subsets, is saved as a single netCDF4 file
-             with the base filename specified by `filepath.nc`.
+          1. **Single File Mode (default)**:
 
-        2. **Partitioned Mode**:
-           - If either `np_eta` or `np_xi` is specified, the dataset is divided into spatial tiles along the eta-axis and xi-axis.
-           - Each spatial tile is saved as a separate netCDF4 file.
+            If both `np_eta` and `np_xi` are `None`, the entire dataset, divided by temporal subsets, is saved as a single netCDF4 file
+            with the base filename specified by `filepath.nc`.
+
+          2. **Partitioned Mode**:
+
+            - If either `np_eta` or `np_xi` is specified, the dataset is divided into spatial tiles along the eta-axis and xi-axis.
+            - Each spatial tile is saved as a separate netCDF4 file.
 
         Parameters
         ----------
@@ -516,8 +657,8 @@ class BoundaryForcing(ROMSToolsMixins):
         return saved_filenames
 
     def to_yaml(self, filepath: Union[str, Path]) -> None:
-        """
-        Export the parameters of the class to a YAML file, including the version of roms-tools.
+        """Export the parameters of the class to a YAML file, including the version of
+        roms-tools.
 
         Parameters
         ----------
@@ -568,8 +709,7 @@ class BoundaryForcing(ROMSToolsMixins):
     def from_yaml(
         cls, filepath: Union[str, Path], use_dask: bool = False
     ) -> "BoundaryForcing":
-        """
-        Create an instance of the BoundaryForcing class from a YAML file.
+        """Create an instance of the BoundaryForcing class from a YAML file.
 
         Parameters
         ----------
@@ -614,3 +754,47 @@ class BoundaryForcing(ROMSToolsMixins):
 
         # Create and return an instance of InitialConditions
         return cls(grid=grid, **boundary_forcing_data, use_dask=use_dask)
+
+
+def get_boundary_info():
+    """This function provides information about the boundary points for the rho, u, and
+    v variables on the grid, specifying the indices for the south, east, north, and west
+    boundaries.
+
+    Returns
+    -------
+    dict
+        A dictionary where keys are variable types ("rho", "u", "v"), and values
+        are nested dictionaries mapping directions ("south", "east", "north", "west")
+        to the corresponding boundary coordinates.
+    """
+
+    # Boundary coordinates
+    bdry_coords = {
+        "rho": {
+            "south": {"eta_rho": 0},
+            "east": {"xi_rho": -1},
+            "north": {"eta_rho": -1},
+            "west": {"xi_rho": 0},
+        },
+        "u": {
+            "south": {"eta_rho": 0},
+            "east": {"xi_u": -1},
+            "north": {"eta_rho": -1},
+            "west": {"xi_u": 0},
+        },
+        "v": {
+            "south": {"eta_v": 0},
+            "east": {"xi_rho": -1},
+            "north": {"eta_v": -1},
+            "west": {"xi_rho": 0},
+        },
+        "vector": {
+            "south": {"eta_rho": [0, 1]},
+            "east": {"xi_rho": [-2, -1]},
+            "north": {"eta_rho": [-2, -1]},
+            "west": {"xi_rho": [0, 1]},
+        },
+    }
+
+    return bdry_coords