roms-tools 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

roms_tools/_version.py

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

roms_tools/setup/boundary_forcing.py

@@ -101,7 +101,7 @@ class BoundaryForcing(ROMSToolsMixins):
         vars_2d = ["zeta"]
         vars_3d = ["temp", "salt", "u", "v"]
         data_vars = super().regrid_data(data, vars_2d, vars_3d, lon, lat)
-        data_vars = super().process_velocities(data_vars, angle)
+        data_vars = super().process_velocities(data_vars, angle, "u", "v")
         object.__setattr__(data, "data_vars", data_vars)
 
         if self.bgc_source is not None:
@@ -121,9 +121,9 @@ class BoundaryForcing(ROMSToolsMixins):
             bgc_data = None
 
         d_meta = super().get_variable_metadata()
-        bdry_coords, rename = super().get_boundary_info()
+        bdry_coords = super().get_boundary_info()
 
-        ds = self._write_into_datatree(data, bgc_data, d_meta, bdry_coords, rename)
+        ds = self._write_into_datatree(data, bgc_data, d_meta, bdry_coords)
 
         for direction in ["south", "east", "north", "west"]:
             if self.boundaries[direction]:
@@ -202,7 +202,7 @@ class BoundaryForcing(ROMSToolsMixins):
 
         return data
 
-    def _write_into_dataset(self, data, d_meta, bdry_coords, rename):
+    def _write_into_dataset(self, data, d_meta, bdry_coords):
 
         # save in new dataset
         ds = xr.Dataset()
@@ -215,21 +215,18 @@ class BoundaryForcing(ROMSToolsMixins):
                         ds[f"{var}_{direction}"] = (
                             data.data_vars[var]
                             .isel(**bdry_coords["u"][direction])
-                            .rename(**rename["u"][direction])
                             .astype(np.float32)
                         )
                     elif var in ["v", "vbar"]:
                         ds[f"{var}_{direction}"] = (
                             data.data_vars[var]
                             .isel(**bdry_coords["v"][direction])
-                            .rename(**rename["v"][direction])
                             .astype(np.float32)
                         )
                     else:
                         ds[f"{var}_{direction}"] = (
                             data.data_vars[var]
                             .isel(**bdry_coords["rho"][direction])
-                            .rename(**rename["rho"][direction])
                             .astype(np.float32)
                         )
                     ds[f"{var}_{direction}"].attrs[
@@ -288,7 +285,7 @@ class BoundaryForcing(ROMSToolsMixins):
 
         return ds
 
-    def _write_into_datatree(self, data, bgc_data, d_meta, bdry_coords, rename):
+    def _write_into_datatree(self, data, bgc_data, d_meta, bdry_coords):
 
         ds = self._add_global_metadata()
         ds["sc_r"] = self.grid.ds["sc_r"]
@@ -296,119 +293,55 @@ class BoundaryForcing(ROMSToolsMixins):
 
         ds = DataTree(name="root", data=ds)
 
-        ds_physics = self._write_into_dataset(data, d_meta, bdry_coords, rename)
-        ds_physics = self._add_coordinates(bdry_coords, rename, ds_physics)
+        ds_physics = self._write_into_dataset(data, d_meta, bdry_coords)
         ds_physics = self._add_global_metadata(ds_physics)
         ds_physics.attrs["physics_source"] = self.physics_source["name"]
 
         ds_physics = DataTree(name="physics", parent=ds, data=ds_physics)
 
         if bgc_data:
-            ds_bgc = self._write_into_dataset(bgc_data, d_meta, bdry_coords, rename)
-            ds_bgc = self._add_coordinates(bdry_coords, rename, ds_bgc)
+            ds_bgc = self._write_into_dataset(bgc_data, d_meta, bdry_coords)
             ds_bgc = self._add_global_metadata(ds_bgc)
             ds_bgc.attrs["bgc_source"] = self.bgc_source["name"]
             ds_bgc = DataTree(name="bgc", parent=ds, data=ds_bgc)
 
         return ds
 
-    def _add_coordinates(self, bdry_coords, rename, ds=None):
-
-        if ds is None:
-            ds = xr.Dataset()
-
-        for direction in ["south", "east", "north", "west"]:
-
-            if self.boundaries[direction]:
+    def _get_coordinates(self, direction, point):
+        """
+        Retrieve layer and interface depth coordinates for a specified grid boundary.
 
-                lat_rho = self.grid.ds.lat_rho.isel(
-                    **bdry_coords["rho"][direction]
-                ).rename(**rename["rho"][direction])
-                lon_rho = self.grid.ds.lon_rho.isel(
-                    **bdry_coords["rho"][direction]
-                ).rename(**rename["rho"][direction])
-                layer_depth_rho = (
-                    self.grid.ds["layer_depth_rho"]
-                    .isel(**bdry_coords["rho"][direction])
-                    .rename(**rename["rho"][direction])
-                )
-                interface_depth_rho = (
-                    self.grid.ds["interface_depth_rho"]
-                    .isel(**bdry_coords["rho"][direction])
-                    .rename(**rename["rho"][direction])
-                )
+        This method extracts the layer depth and interface depth coordinates along
+        a specified boundary (north, south, east, or west) and for a specified point
+        type (rho, u, or v) from the grid dataset.
 
-                lat_u = self.grid.ds.lat_u.isel(**bdry_coords["u"][direction]).rename(
-                    **rename["u"][direction]
-                )
-                lon_u = self.grid.ds.lon_u.isel(**bdry_coords["u"][direction]).rename(
-                    **rename["u"][direction]
-                )
-                layer_depth_u = (
-                    self.grid.ds["layer_depth_u"]
-                    .isel(**bdry_coords["u"][direction])
-                    .rename(**rename["u"][direction])
-                )
-                interface_depth_u = (
-                    self.grid.ds["interface_depth_u"]
-                    .isel(**bdry_coords["u"][direction])
-                    .rename(**rename["u"][direction])
-                )
+        Parameters
+        ----------
+        direction : str
+            The direction of the boundary to retrieve coordinates for. Valid options
+            are "north", "south", "east", and "west".
+        point : str
+            The type of grid point to retrieve coordinates for. Valid options are
+            "rho" for the grid's central points, "u" for the u-flux points, and "v"
+            for the v-flux points.
 
-                lat_v = self.grid.ds.lat_v.isel(**bdry_coords["v"][direction]).rename(
-                    **rename["v"][direction]
-                )
-                lon_v = self.grid.ds.lon_v.isel(**bdry_coords["v"][direction]).rename(
-                    **rename["v"][direction]
-                )
-                layer_depth_v = (
-                    self.grid.ds["layer_depth_v"]
-                    .isel(**bdry_coords["v"][direction])
-                    .rename(**rename["v"][direction])
-                )
-                interface_depth_v = (
-                    self.grid.ds["interface_depth_v"]
-                    .isel(**bdry_coords["v"][direction])
-                    .rename(**rename["v"][direction])
-                )
+        Returns
+        -------
+        xarray.DataArray, xarray.DataArray
+            The layer depth and interface depth coordinates for the specified grid
+            boundary and point type.
+        """
 
-                ds = ds.assign_coords(
-                    {
-                        f"layer_depth_rho_{direction}": layer_depth_rho,
-                        f"layer_depth_u_{direction}": layer_depth_u,
-                        f"layer_depth_v_{direction}": layer_depth_v,
-                        f"interface_depth_rho_{direction}": interface_depth_rho,
-                        f"interface_depth_u_{direction}": interface_depth_u,
-                        f"interface_depth_v_{direction}": interface_depth_v,
-                        f"lat_rho_{direction}": lat_rho,
-                        f"lat_u_{direction}": lat_u,
-                        f"lat_v_{direction}": lat_v,
-                        f"lon_rho_{direction}": lon_rho,
-                        f"lon_u_{direction}": lon_u,
-                        f"lon_v_{direction}": lon_v,
-                    }
-                )
+        bdry_coords = super().get_boundary_info()
 
-        # Gracefully handle dropping variables that might not be present
-        variables_to_drop = [
-            "s_rho",
-            "layer_depth_rho",
-            "layer_depth_u",
-            "layer_depth_v",
-            "interface_depth_rho",
-            "interface_depth_u",
-            "interface_depth_v",
-            "lat_rho",
-            "lon_rho",
-            "lat_u",
-            "lon_u",
-            "lat_v",
-            "lon_v",
-        ]
-        existing_vars = [var for var in variables_to_drop if var in ds]
-        ds = ds.drop_vars(existing_vars)
+        layer_depth = self.grid.ds[f"layer_depth_{point}"].isel(
+            **bdry_coords[point][direction]
+        )
+        interface_depth = self.grid.ds[f"interface_depth_{point}"].isel(
+            **bdry_coords[point][direction]
+        )
 
-        return ds
+        return layer_depth, interface_depth
 
     def _add_global_metadata(self, ds=None):
 
@@ -486,8 +419,9 @@ class BoundaryForcing(ROMSToolsMixins):
         time : int, optional
             The time index to plot. Default is 0.
         layer_contours : bool, optional
-            Whether to include layer contours in the plot. This can help visualize the depth levels
-            of the field. Default is False.
+            If True, contour lines representing the boundaries between vertical layers will
+            be added to the plot. For clarity, the number of layer
+            contours displayed is limited to a maximum of 10. Default is False.
 
         Returns
         -------
@@ -513,6 +447,19 @@ class BoundaryForcing(ROMSToolsMixins):
         field = ds[varname].isel(bry_time=time).load()
         title = field.long_name
 
+        if "s_rho" in field.dims:
+            if varname.startswith(("u_", "ubar_")):
+                point = "u"
+            elif varname.startswith(("v_", "vbar_")):
+                point = "v"
+            else:
+                point = "rho"
+            direction = varname.split("_")[-1]
+
+            layer_depth, interface_depth = self._get_coordinates(direction, point)
+
+            field = field.assign_coords({"layer_depth": layer_depth})
+
         # chose colorbar
         if varname.startswith(("u", "v", "ubar", "vbar", "zeta")):
             vmax = max(field.max().values, -field.min().values)
@@ -530,27 +477,6 @@ class BoundaryForcing(ROMSToolsMixins):
 
         if len(field.dims) == 2:
             if layer_contours:
-                depths_to_check = [
-                    "interface_depth_rho",
-                    "interface_depth_u",
-                    "interface_depth_v",
-                ]
-                try:
-                    interface_depth = next(
-                        ds[depth_label]
-                        for depth_label in ds.coords
-                        if any(
-                            depth_label.startswith(prefix) for prefix in depths_to_check
-                        )
-                        and (
-                            set(ds[depth_label].dims) - {"s_w"}
-                            == set(field.dims) - {"s_rho"}
-                        )
-                    )
-                except StopIteration:
-                    raise ValueError(
-                        f"None of the expected depths ({', '.join(depths_to_check)}) have dimensions matching field.dims"
-                    )
                 # restrict number of layer_contours to 10 for the sake of plot clearity
                 nr_layers = len(interface_depth["s_w"])
                 selected_layers = np.linspace(

roms_tools/setup/datasets.py

@@ -584,9 +584,14 @@ class TPXODataset(Dataset):
                 "ntides": self.dim_names["ntides"],
             },
         )
+        self.check_dataset(ds)
+
         # Select relevant fields
         ds = super().select_relevant_fields(ds)
 
+        # Make sure that latitude is ascending
+        ds = super().ensure_latitude_ascending(ds)
+
         # Check whether the data covers the entire globe
         object.__setattr__(self, "is_global", super().check_if_global(ds))
 
@@ -769,6 +774,8 @@ class CESMDataset(Dataset):
             ds = assign_dates_to_climatology(ds, time_dim)
             # rename dimension
             ds = ds.swap_dims({time_dim: "time"})
+            if time_dim in ds.variables:
+                ds = ds.drop_vars(time_dim)
             # Update dimension names
             updated_dim_names = self.dim_names.copy()
             updated_dim_names["time"] = "time"
@@ -872,9 +879,9 @@ class CESMBGCDataset(CESMDataset):
             ds["depth"].attrs["long_name"] = "Depth"
             ds["depth"].attrs["units"] = "m"
             ds = ds.swap_dims({"z_t": "depth"})
-            if "z_t" in ds:
+            if "z_t" in ds.variables:
                 ds = ds.drop_vars("z_t")
-            if "z_t_150m" in ds:
+            if "z_t_150m" in ds.variables:
                 ds = ds.drop_vars("z_t_150m")
             # update dataset
             object.__setattr__(self, "ds", ds)
@@ -932,6 +939,19 @@ class CESMBGCSurfaceForcingDataset(CESMDataset):
 
     climatology: Optional[bool] = False
 
+    def post_process(self):
+        """
+        Perform post-processing on the dataset to remove specific variables.
+
+        This method checks if the variable "z_t" exists in the dataset. If it does,
+        the variable is removed from the dataset. The modified dataset is then
+        reassigned to the `ds` attribute of the object.
+        """
+
+        if "z_t" in self.ds.variables:
+            ds = self.ds.drop_vars("z_t")
+            object.__setattr__(self, "ds", ds)
+
 
 @dataclass(frozen=True, kw_only=True)
 class ERA5Dataset(Dataset):

roms_tools/setup/grid.py

@@ -361,11 +361,20 @@ class Grid:
         """
 
         if bathymetry:
-            kwargs = {"cmap": "YlGnBu"}
+            field = self.ds.h.where(self.ds.mask_rho)
+            field = field.assign_coords(
+                {"lon": self.ds.lon_rho, "lat": self.ds.lat_rho}
+            )
+
+            vmax = field.max().values
+            vmin = field.min().values
+            cmap = plt.colormaps.get_cmap("YlGnBu")
+            cmap.set_bad(color="gray")
+            kwargs = {"vmax": vmax, "vmin": vmin, "cmap": cmap}
 
             _plot(
                 self.ds,
-                field=self.ds.h.where(self.ds.mask_rho),
+                field=field,
                 straddle=self.straddle,
                 kwargs=kwargs,
             )
@@ -419,10 +428,18 @@ class Grid:
 
         if all(dim in field.dims for dim in ["eta_rho", "xi_rho"]):
             interface_depth = self.ds.interface_depth_rho
+            field = field.where(self.ds.mask_rho)
+            field = field.assign_coords(
+                {"lon": self.ds.lon_rho, "lat": self.ds.lat_rho}
+            )
         elif all(dim in field.dims for dim in ["eta_rho", "xi_u"]):
             interface_depth = self.ds.interface_depth_u
+            field = field.where(self.ds.mask_u)
+            field = field.assign_coords({"lon": self.ds.lon_u, "lat": self.ds.lat_u})
         elif all(dim in field.dims for dim in ["eta_v", "xi_rho"]):
             interface_depth = self.ds.interface_depth_v
+            field = field.where(self.ds.mask_v)
+            field = field.assign_coords({"lon": self.ds.lon_v, "lat": self.ds.lat_v})
 
         # slice the field as desired
         title = field.long_name
@@ -476,10 +493,9 @@ class Grid:
                 self.ds,
                 field=field,
                 straddle=self.straddle,
-                depth_contours=True,
+                depth_contours=False,
                 title=title,
                 kwargs=kwargs,
-                c="g",
             )
         else:
             if len(field.dims) == 2:

roms_tools/setup/initial_conditions.py

@@ -82,7 +82,7 @@ class InitialConditions(ROMSToolsMixins):
         vars_2d = ["zeta"]
         vars_3d = ["temp", "salt", "u", "v"]
         data_vars = super().regrid_data(data, vars_2d, vars_3d, lon, lat)
-        data_vars = super().process_velocities(data_vars, angle)
+        data_vars = super().process_velocities(data_vars, angle, "u", "v")
 
         if self.bgc_source is not None:
             bgc_data = self._get_bgc_data()
@@ -172,18 +172,18 @@ class InitialConditions(ROMSToolsMixins):
 
         if self.bgc_source["name"] == "CESM_REGRIDDED":
 
-            bgc_data = CESMBGCDataset(
+            data = CESMBGCDataset(
                 filename=self.bgc_source["path"],
                 start_time=self.ini_time,
                 climatology=self.bgc_source["climatology"],
             )
-            bgc_data.post_process()
+            data.post_process()
         else:
             raise ValueError(
                 'Only "CESM_REGRIDDED" is a valid option for bgc_source["name"].'
             )
 
-        return bgc_data
+        return data
 
     def _write_into_dataset(self, data_vars, d_meta):
 
@@ -202,19 +202,43 @@ class InitialConditions(ROMSToolsMixins):
         ds["w"].attrs["long_name"] = d_meta["w"]["long_name"]
         ds["w"].attrs["units"] = d_meta["w"]["units"]
 
+        variables_to_drop = [
+            "s_rho",
+            "lat_rho",
+            "lon_rho",
+            "layer_depth_rho",
+            "interface_depth_rho",
+            "lat_u",
+            "lon_u",
+            "lat_v",
+            "lon_v",
+        ]
+        existing_vars = [var for var in variables_to_drop if var in ds]
+        ds = ds.drop_vars(existing_vars)
+
+        ds["sc_r"] = self.grid.ds["sc_r"]
+        ds["Cs_r"] = self.grid.ds["Cs_r"]
+
+        # Preserve absolute time coordinate for readability
+        ds = ds.assign_coords({"abs_time": ds["time"]})
+
+        # Translate the time coordinate to days since the model reference date
+        model_reference_date = np.datetime64(self.model_reference_date)
+
+        # Convert the time coordinate to the format expected by ROMS (days since model reference date)
+        ocean_time = (ds["time"] - model_reference_date).astype("float64") * 1e-9
+        ds = ds.assign_coords(ocean_time=("time", np.float32(ocean_time)))
+        ds["ocean_time"].attrs[
+            "long_name"
+        ] = f"seconds since {np.datetime_as_string(model_reference_date, unit='s')}"
+        ds["ocean_time"].attrs["units"] = "seconds"
+        ds = ds.swap_dims({"time": "ocean_time"})
+        ds = ds.drop_vars("time")
+
         return ds
 
     def _add_global_metadata(self, ds):
 
-        ds = ds.assign_coords(
-            {
-                "layer_depth_u": self.grid.ds["layer_depth_u"],
-                "layer_depth_v": self.grid.ds["layer_depth_v"],
-                "interface_depth_u": self.grid.ds["interface_depth_u"],
-                "interface_depth_v": self.grid.ds["interface_depth_v"],
-            }
-        )
-
         ds.attrs["title"] = "ROMS initial conditions file created by ROMS-Tools"
         # Include the version of roms-tools
         try:
@@ -228,24 +252,9 @@ class InitialConditions(ROMSToolsMixins):
         if self.bgc_source is not None:
             ds.attrs["bgc_source"] = self.bgc_source["name"]
 
-        # Translate the time coordinate to days since the model reference date
-        model_reference_date = np.datetime64(self.model_reference_date)
-
-        # Convert the time coordinate to the format expected by ROMS (days since model reference date)
-        ocean_time = (ds["time"] - model_reference_date).astype("float64") * 1e-9
-        ds = ds.assign_coords(ocean_time=("time", np.float32(ocean_time)))
-        ds["ocean_time"].attrs[
-            "long_name"
-        ] = f"seconds since {np.datetime_as_string(model_reference_date, unit='s')}"
-        ds["ocean_time"].attrs["units"] = "seconds"
-
         ds.attrs["theta_s"] = self.grid.ds.attrs["theta_s"]
         ds.attrs["theta_b"] = self.grid.ds.attrs["theta_b"]
         ds.attrs["hc"] = self.grid.ds.attrs["hc"]
-        ds["sc_r"] = self.grid.ds["sc_r"]
-        ds["Cs_r"] = self.grid.ds["Cs_r"]
-
-        ds = ds.drop_vars(["s_rho"])
 
         return ds
 
@@ -306,13 +315,23 @@ class InitialConditions(ROMSToolsMixins):
             - "diazP": Diazotroph Phosphorus (mmol/m³).
             - "diazFe": Diazotroph Iron (mmol/m³).
         s : int, optional
-            The index of the vertical layer to plot. Default is None.
+            The index of the vertical layer (`s_rho`) to plot. If not specified, the plot
+            will represent a horizontal slice (eta- or xi- plane). Default is None.
         eta : int, optional
-            The eta-index to plot. Default is None.
+            The eta-index to plot. Used for vertical sections or horizontal slices.
+            Default is None.
         xi : int, optional
-            The xi-index to plot. Default is None.
+            The xi-index to plot. Used for vertical sections or horizontal slices.
+            Default is None.
         depth_contours : bool, optional
-            Whether to include depth contours in the plot. Default is False.
+            If True, depth contours will be overlaid on the plot, showing lines of constant
+            depth. This is typically used for plots that show a single vertical layer.
+            Default is False.
+        layer_contours : bool, optional
+            If True, contour lines representing the boundaries between vertical layers will
+            be added to the plot. This is particularly useful in vertical sections to
+            visualize the layering of the water column. For clarity, the number of layer
+            contours displayed is limited to a maximum of 10. Default is False.
 
         Returns
         -------
@@ -325,6 +344,7 @@ class InitialConditions(ROMSToolsMixins):
             If the specified `varname` is not one of the valid options.
             If the field specified by `varname` is 3D and none of `s`, `eta`, or `xi` are specified.
             If the field specified by `varname` is 2D and both `eta` and `xi` are specified.
+
         """
 
         if len(self.ds[varname].squeeze().dims) == 3 and not any(
@@ -343,17 +363,38 @@ class InitialConditions(ROMSToolsMixins):
         field = self.ds[varname].squeeze()
 
         if all(dim in field.dims for dim in ["eta_rho", "xi_rho"]):
-            interface_depth = self.ds.interface_depth_rho
+            interface_depth = self.grid.ds.interface_depth_rho
+            layer_depth = self.grid.ds.layer_depth_rho
+            field = field.where(self.grid.ds.mask_rho)
+            field = field.assign_coords(
+                {"lon": self.grid.ds.lon_rho, "lat": self.grid.ds.lat_rho}
+            )
+
         elif all(dim in field.dims for dim in ["eta_rho", "xi_u"]):
-            interface_depth = self.ds.interface_depth_u
+            interface_depth = self.grid.ds.interface_depth_u
+            layer_depth = self.grid.ds.layer_depth_u
+            field = field.where(self.grid.ds.mask_u)
+            field = field.assign_coords(
+                {"lon": self.grid.ds.lon_u, "lat": self.grid.ds.lat_u}
+            )
+
         elif all(dim in field.dims for dim in ["eta_v", "xi_rho"]):
-            interface_depth = self.ds.interface_depth_v
+            interface_depth = self.grid.ds.interface_depth_v
+            layer_depth = self.grid.ds.layer_depth_v
+            field = field.where(self.grid.ds.mask_v)
+            field = field.assign_coords(
+                {"lon": self.grid.ds.lon_v, "lat": self.grid.ds.lat_v}
+            )
+        else:
+            ValueError("provided field does not have two horizontal dimension")
 
         # slice the field as desired
         title = field.long_name
         if s is not None:
             title = title + f", s_rho = {field.s_rho[s].item()}"
             field = field.isel(s_rho=s)
+            layer_depth = layer_depth.isel(s_rho=s)
+            field = field.assign_coords({"layer_depth": layer_depth})
         else:
             depth_contours = False
 
@@ -361,10 +402,14 @@ class InitialConditions(ROMSToolsMixins):
             if "eta_rho" in field.dims:
                 title = title + f", eta_rho = {field.eta_rho[eta].item()}"
                 field = field.isel(eta_rho=eta)
+                layer_depth = layer_depth.isel(eta_rho=eta)
+                field = field.assign_coords({"layer_depth": layer_depth})
                 interface_depth = interface_depth.isel(eta_rho=eta)
             elif "eta_v" in field.dims:
                 title = title + f", eta_v = {field.eta_v[eta].item()}"
                 field = field.isel(eta_v=eta)
+                layer_depth = layer_depth.isel(eta_v=eta)
+                field = field.assign_coords({"layer_depth": layer_depth})
                 interface_depth = interface_depth.isel(eta_v=eta)
             else:
                 raise ValueError(
@@ -374,10 +419,14 @@ class InitialConditions(ROMSToolsMixins):
             if "xi_rho" in field.dims:
                 title = title + f", xi_rho = {field.xi_rho[xi].item()}"
                 field = field.isel(xi_rho=xi)
+                layer_depth = layer_depth.isel(xi_rho=xi)
+                field = field.assign_coords({"layer_depth": layer_depth})
                 interface_depth = interface_depth.isel(xi_rho=xi)
             elif "xi_u" in field.dims:
                 title = title + f", xi_u = {field.xi_u[xi].item()}"
                 field = field.isel(xi_u=xi)
+                layer_depth = layer_depth.isel(xi_u=xi)
+                field = field.assign_coords({"layer_depth": layer_depth})
                 interface_depth = interface_depth.isel(xi_u=xi)
             else:
                 raise ValueError(