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

roms_tools/setup/initial_conditions.py

@@ -5,7 +5,6 @@ import importlib.metadata
 from dataclasses import dataclass, field, asdict
 from typing import Optional, Dict, Union
 from roms_tools.setup.grid import Grid
-from roms_tools.setup.vertical_coordinate import VerticalCoordinate
 from datetime import datetime
 from roms_tools.setup.datasets import GLORYSDataset, CESMBGCDataset
 from roms_tools.setup.utils import (
@@ -25,8 +24,6 @@ class InitialConditions(ROMSToolsMixins):
     ----------
     grid : Grid
         Object representing the grid information used for the model.
-    vertical_coordinate : VerticalCoordinate
-        Object representing the vertical coordinate system.
     ini_time : datetime
         The date and time at which the initial conditions are set.
     physics_source : Dict[str, Union[str, None]]
@@ -51,7 +48,6 @@ class InitialConditions(ROMSToolsMixins):
     --------
     >>> initial_conditions = InitialConditions(
     ...     grid=grid,
-    ...     vertical_coordinate=vertical_coordinate,
     ...     ini_time=datetime(2022, 1, 1),
     ...     physics_source={"name": "GLORYS", "path": "physics_data.nc"},
     ...     bgc_source={
@@ -63,7 +59,6 @@ class InitialConditions(ROMSToolsMixins):
     """
 
     grid: Grid
-    vertical_coordinate: VerticalCoordinate
     ini_time: datetime
     physics_source: Dict[str, Union[str, None]]
     bgc_source: Optional[Dict[str, Union[str, None]]] = None
@@ -202,9 +197,7 @@ class InitialConditions(ROMSToolsMixins):
 
         # initialize vertical velocity to zero
         ds["w"] = xr.zeros_like(
-            self.vertical_coordinate.ds["interface_depth_rho"].expand_dims(
-                time=data_vars["u"].time
-            )
+            self.grid.ds["interface_depth_rho"].expand_dims(time=data_vars["u"].time)
         ).astype(np.float32)
         ds["w"].attrs["long_name"] = d_meta["w"]["long_name"]
         ds["w"].attrs["units"] = d_meta["w"]["units"]
@@ -215,10 +208,10 @@ class InitialConditions(ROMSToolsMixins):
 
         ds = ds.assign_coords(
             {
-                "layer_depth_u": self.vertical_coordinate.ds["layer_depth_u"],
-                "layer_depth_v": self.vertical_coordinate.ds["layer_depth_v"],
-                "interface_depth_u": self.vertical_coordinate.ds["interface_depth_u"],
-                "interface_depth_v": self.vertical_coordinate.ds["interface_depth_v"],
+                "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"],
             }
         )
 
@@ -246,12 +239,11 @@ class InitialConditions(ROMSToolsMixins):
         ] = f"seconds since {np.datetime_as_string(model_reference_date, unit='s')}"
         ds["ocean_time"].attrs["units"] = "seconds"
 
-        ds.attrs["theta_s"] = self.vertical_coordinate.ds["theta_s"].item()
-        ds.attrs["theta_b"] = self.vertical_coordinate.ds["theta_b"].item()
-        ds.attrs["Tcline"] = self.vertical_coordinate.ds["Tcline"].item()
-        ds.attrs["hc"] = self.vertical_coordinate.ds["hc"].item()
-        ds["sc_r"] = self.vertical_coordinate.ds["sc_r"]
-        ds["Cs_r"] = self.vertical_coordinate.ds["Cs_r"]
+        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"])
 
@@ -462,11 +454,6 @@ class InitialConditions(ROMSToolsMixins):
         grid_data.pop("ds", None)  # Exclude non-serializable fields
         grid_data.pop("straddle", None)
 
-        # Serialize VerticalCoordinate data
-        vertical_coordinate_data = asdict(self.vertical_coordinate)
-        vertical_coordinate_data.pop("ds", None)  # Exclude non-serializable fields
-        vertical_coordinate_data.pop("grid", None)  # Exclude non-serializable fields
-
         # Include the version of roms-tools
         try:
             roms_tools_version = importlib.metadata.version("roms-tools")
@@ -477,7 +464,6 @@ class InitialConditions(ROMSToolsMixins):
         header = f"---\nroms_tools_version: {roms_tools_version}\n---\n"
 
         grid_yaml_data = {"Grid": grid_data}
-        vertical_coordinate_yaml_data = {"VerticalCoordinate": vertical_coordinate_data}
 
         initial_conditions_data = {
             "InitialConditions": {
@@ -492,7 +478,6 @@ class InitialConditions(ROMSToolsMixins):
 
         yaml_data = {
             **grid_yaml_data,
-            **vertical_coordinate_yaml_data,
             **initial_conditions_data,
         }
 
@@ -545,13 +530,10 @@ class InitialConditions(ROMSToolsMixins):
                 initial_conditions_data[date_string]
             )
 
-        # Create VerticalCoordinate instance from the YAML file
-        vertical_coordinate = VerticalCoordinate.from_yaml(filepath)
-        grid = vertical_coordinate.grid
+        grid = Grid.from_yaml(filepath)
 
         # Create and return an instance of InitialConditions
         return cls(
             grid=grid,
-            vertical_coordinate=vertical_coordinate,
             **initial_conditions_data,
         )

roms_tools/setup/mixins.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from roms_tools.setup.grid import Grid
-from roms_tools.setup.vertical_coordinate import VerticalCoordinate
 from roms_tools.setup.fill import fill_and_interpolate
 from roms_tools.setup.utils import (
     extrapolate_deepest_to_bottom,
@@ -21,13 +20,10 @@ class ROMSToolsMixins:
     ----------
     grid : Grid
         Object representing the grid information used for the model.
-    vertical_coordinate : VerticalCoordinate
-        Object representing the vertical coordinate system. Defaults to None.
 
     """
 
     grid: Grid
-    vertical_coordinate: VerticalCoordinate = None
 
     def get_target_lon_lat(self, use_coarse_grid=False):
         """
@@ -54,11 +50,6 @@ class ROMSToolsMixins:
         """
 
         if use_coarse_grid:
-            if "lon_coarse" not in self.grid.ds:
-                raise ValueError(
-                    "Grid has not been coarsened yet. Execute grid.coarsen() first."
-                )
-
             lon = self.grid.ds.lon_coarse
             lat = self.grid.ds.lat_coarse
             angle = self.grid.ds.angle_coarse
@@ -134,7 +125,7 @@ class ROMSToolsMixins:
             coords = {
                 data.dim_names["latitude"]: lat,
                 data.dim_names["longitude"]: lon,
-                data.dim_names["depth"]: self.vertical_coordinate.ds["layer_depth_rho"],
+                data.dim_names["depth"]: self.grid.ds["layer_depth_rho"],
             }
         # extrapolate deepest value all the way to bottom ("flooding")
         for var in vars_3d:
@@ -167,8 +158,7 @@ class ROMSToolsMixins:
         This method performs the following steps:
         1. Rotates the velocity components to align with the grid orientation using the provided angle.
         2. Optionally interpolates the rotated velocities to the u- and v-points of the grid.
-        3. If a vertical coordinate is provided, computes the barotropic velocities by integrating
-           over the vertical dimension.
+        3. If the velocities are 3D (with vertical coordinates), computes barotropic (depth-averaged) velocities.
 
         Parameters
         ----------
@@ -183,8 +173,8 @@ class ROMSToolsMixins:
         Returns
         -------
         dict of str: xarray.DataArray
-            Dictionary of processed velocity components. Includes "ubar" and "vbar" if a vertical coordinate
-            is provided.
+            Dictionary of processed velocity components. Includes "ubar" and "vbar" if the velocity components
+            have vertical coordinates and are processed for barotropic (depth-averaged) velocities.
         """
         # Determine the correct variable names based on the keys in data_vars
         uname = "u" if "u" in data_vars else "uwnd"
@@ -202,7 +192,7 @@ class ROMSToolsMixins:
             data_vars[uname] = u_rot
             data_vars[vname] = v_rot
 
-        if self.vertical_coordinate is not None:
+        if "s_rho" in data_vars[uname].dims and "s_rho" in data_vars[vname].dims:
             # 3D masks for ROMS domain
             umask = self.grid.ds.mask_u.expand_dims({"s_rho": data_vars[uname].s_rho})
             vmask = self.grid.ds.mask_v.expand_dims({"s_rho": data_vars[vname].s_rho})
@@ -211,7 +201,7 @@ class ROMSToolsMixins:
             data_vars[vname] = data_vars[vname] * vmask
 
             # Compute barotropic velocity
-            dz = -self.vertical_coordinate.ds["interface_depth_rho"].diff(dim="s_w")
+            dz = -self.grid.ds["interface_depth_rho"].diff(dim="s_w")
             dz = dz.rename({"s_w": "s_rho"})
             dzu = interpolate_from_rho_to_u(dz)
             dzv = interpolate_from_rho_to_v(dz)

roms_tools/setup/topography.py

@@ -10,8 +10,42 @@ from itertools import count
 
 
 def _add_topography_and_mask(
-    ds, topography_source, smooth_factor, hmin, rmax
+    ds, topography_source, hmin, smooth_factor=8.0, rmax=0.2
 ) -> xr.Dataset:
+    """
+    Adds topography and a land/water mask to the dataset based on the provided topography source.
+
+    This function performs the following operations:
+    1. Interpolates topography data onto the desired grid.
+    2. Applies a mask based on ocean depth.
+    3. Smooths the topography globally to reduce grid-scale instabilities.
+    4. Fills enclosed basins with land.
+    5. Smooths the topography locally to ensure the steepness ratio satisfies the rmax criterion.
+    6. Adds topography metadata.
+
+    Parameters
+    ----------
+    ds : xr.Dataset
+        The dataset to which topography and the land/water mask will be added.
+    topography_source : str
+        The source of the topography data.
+    hmin : float
+        The minimum allowable depth for the topography.
+    smooth_factor : float, optional
+        The smoothing factor used in the domain-wide Gaussian smoothing of the
+        topography. Smaller values result in less smoothing, while larger
+        values produce more smoothing. The default is 8.0.
+    rmax : float, optional
+        The maximum allowable steepness ratio for the topography smoothing.
+        This parameter controls the local smoothing of the topography. Smaller values result in
+        smoother topography, while larger values preserve more detail. The default is 0.2.
+
+    Returns
+    -------
+    xr.Dataset
+        The dataset with added topography, mask, and metadata.
+    """
+
     lon = ds.lon_rho.values
     lat = ds.lat_rho.values
 
@@ -23,16 +57,11 @@ def _add_topography_and_mask(
     mask = xr.where(hraw > 0, 1.0, 0.0)
 
     # smooth topography domain-wide with Gaussian kernel to avoid grid scale instabilities
-    ds["hraw"] = _smooth_topography_globally(hraw, mask, smooth_factor)
-    ds["hraw"].attrs = {
-        "long_name": "Working bathymetry at rho-points",
-        "source": f"Raw bathymetry from {topography_source} (smoothing diameter {smooth_factor})",
-        "units": "meter",
-    }
+    hraw = _smooth_topography_globally(hraw, mask, smooth_factor)
 
     # fill enclosed basins with land
     mask = _fill_enclosed_basins(mask.values)
-    ds["mask_rho"] = xr.DataArray(mask, dims=("eta_rho", "xi_rho"))
+    ds["mask_rho"] = xr.DataArray(mask.astype(np.int32), dims=("eta_rho", "xi_rho"))
     ds["mask_rho"].attrs = {
         "long_name": "Mask at rho-points",
         "units": "land/water (0/1)",
@@ -41,7 +70,7 @@ def _add_topography_and_mask(
     ds = _add_velocity_masks(ds)
 
     # smooth topography locally to satisfy r < rmax
-    ds["h"] = _smooth_topography_locally(ds["hraw"] * ds["mask_rho"], hmin, rmax)
+    ds["h"] = _smooth_topography_locally(hraw * ds["mask_rho"], hmin, rmax)
     ds["h"].attrs = {
         "long_name": "Final bathymetry at rho-points",
         "units": "meter",
@@ -238,9 +267,7 @@ def _compute_rfactor(h):
 
 def _add_topography_metadata(ds, topography_source, smooth_factor, hmin, rmax):
     ds.attrs["topography_source"] = topography_source
-    ds.attrs["smooth_factor"] = smooth_factor
     ds.attrs["hmin"] = hmin
-    ds.attrs["rmax"] = rmax
 
     return ds
 
@@ -248,8 +275,12 @@ def _add_topography_metadata(ds, topography_source, smooth_factor, hmin, rmax):
 def _add_velocity_masks(ds):
 
     # add u- and v-masks
-    ds["mask_u"] = interpolate_from_rho_to_u(ds["mask_rho"], method="multiplicative")
-    ds["mask_v"] = interpolate_from_rho_to_v(ds["mask_rho"], method="multiplicative")
+    ds["mask_u"] = interpolate_from_rho_to_u(
+        ds["mask_rho"], method="multiplicative"
+    ).astype(np.int32)
+    ds["mask_v"] = interpolate_from_rho_to_v(
+        ds["mask_rho"], method="multiplicative"
+    ).astype(np.int32)
 
     ds["mask_u"].attrs = {"long_name": "Mask at u-points", "units": "land/water (0/1)"}
     ds["mask_v"].attrs = {"long_name": "Mask at v-points", "units": "land/water (0/1)"}

roms_tools/setup/vertical_coordinate.py

@@ -1,382 +1,5 @@
 import numpy as np
 import xarray as xr
-import yaml
-import importlib.metadata
-from dataclasses import dataclass, field, asdict
-from roms_tools.setup.grid import Grid
-from roms_tools.setup.utils import (
-    interpolate_from_rho_to_u,
-    interpolate_from_rho_to_v,
-)
-from roms_tools.setup.plot import _plot, _section_plot, _profile_plot, _line_plot
-import matplotlib.pyplot as plt
-
-
-@dataclass(frozen=True, kw_only=True)
-class VerticalCoordinate:
-    """
-    Represents vertical coordinate for ROMS.
-
-    Parameters
-    ----------
-    grid : Grid
-        Object representing the grid information.
-    N : int
-        The number of vertical levels.
-    theta_s : float
-        The surface control parameter. Must satisfy 0 < theta_s <= 10.
-    theta_b : float
-        The bottom control parameter. Must satisfy 0 < theta_b <= 4.
-    hc : float
-        The critical depth.
-
-    Attributes
-    ----------
-    ds : xr.Dataset
-        Xarray Dataset containing the atmospheric forcing data.
-    """
-
-    grid: Grid
-    N: int
-    theta_s: float
-    theta_b: float
-    hc: float
-
-    ds: xr.Dataset = field(init=False, repr=False)
-
-    def __post_init__(self):
-
-        h = self.grid.ds.h
-
-        cs_r, sigma_r = sigma_stretch(self.theta_s, self.theta_b, self.N, "r")
-        zr = compute_depth(h * 0, h, self.hc, cs_r, sigma_r)
-        cs_w, sigma_w = sigma_stretch(self.theta_s, self.theta_b, self.N, "w")
-        zw = compute_depth(h * 0, h, self.hc, cs_w, sigma_w)
-
-        ds = xr.Dataset()
-
-        ds["theta_s"] = np.float32(self.theta_s)
-        ds["theta_s"].attrs["long_name"] = "S-coordinate surface control parameter"
-        ds["theta_s"].attrs["units"] = "nondimensional"
-
-        ds["theta_b"] = np.float32(self.theta_b)
-        ds["theta_b"].attrs["long_name"] = "S-coordinate bottom control parameter"
-        ds["theta_b"].attrs["units"] = "nondimensional"
-
-        ds["Tcline"] = np.float32(self.hc)
-        ds["Tcline"].attrs["long_name"] = "S-coordinate surface/bottom layer width"
-        ds["Tcline"].attrs["units"] = "m"
-
-        ds["hc"] = np.float32(self.hc)
-        ds["hc"].attrs["long_name"] = "S-coordinate parameter critical depth"
-        ds["hc"].attrs["units"] = "m"
-
-        ds["sc_r"] = sigma_r.astype(np.float32)
-        ds["sc_r"].attrs["long_name"] = "S-coordinate at rho-points"
-        ds["sc_r"].attrs["units"] = "nondimensional"
-
-        ds["Cs_r"] = cs_r.astype(np.float32)
-        ds["Cs_r"].attrs["long_name"] = "S-coordinate stretching curves at rho-points"
-        ds["Cs_r"].attrs["units"] = "nondimensional"
-
-        depth = -zr
-        depth.attrs["long_name"] = "Layer depth at rho-points"
-        depth.attrs["units"] = "m"
-        ds = ds.assign_coords({"layer_depth_rho": depth.astype(np.float32)})
-
-        depth_u = interpolate_from_rho_to_u(depth).astype(np.float32)
-        depth_u.attrs["long_name"] = "Layer depth at u-points"
-        depth_u.attrs["units"] = "m"
-        ds = ds.assign_coords({"layer_depth_u": depth_u})
-
-        depth_v = interpolate_from_rho_to_v(depth).astype(np.float32)
-        depth_v.attrs["long_name"] = "Layer depth at v-points"
-        depth_v.attrs["units"] = "m"
-        ds = ds.assign_coords({"layer_depth_v": depth_v})
-
-        depth = -zw
-        depth.attrs["long_name"] = "Interface depth at rho-points"
-        depth.attrs["units"] = "m"
-        ds = ds.assign_coords({"interface_depth_rho": depth.astype(np.float32)})
-
-        depth_u = interpolate_from_rho_to_u(depth).astype(np.float32)
-        depth_u.attrs["long_name"] = "Interface depth at u-points"
-        depth_u.attrs["units"] = "m"
-        ds = ds.assign_coords({"interface_depth_u": depth_u})
-
-        depth_v = interpolate_from_rho_to_v(depth).astype(np.float32)
-        depth_v.attrs["long_name"] = "Interface depth at v-points"
-        depth_v.attrs["units"] = "m"
-        ds = ds.assign_coords({"interface_depth_v": depth_v})
-
-        ds = ds.drop_vars(["eta_rho", "xi_rho"])
-
-        ds.attrs["title"] = "ROMS vertical coordinate file created by ROMS-Tools"
-        # Include the version of roms-tools
-        try:
-            roms_tools_version = importlib.metadata.version("roms-tools")
-        except importlib.metadata.PackageNotFoundError:
-            roms_tools_version = "unknown"
-        ds.attrs["roms_tools_version"] = roms_tools_version
-
-        object.__setattr__(self, "ds", ds)
-
-    def plot(
-        self,
-        varname="layer_depth_rho",
-        s=None,
-        eta=None,
-        xi=None,
-    ) -> None:
-        """
-        Plot the vertical coordinate system for a given eta-, xi-, or s-slice.
-
-        Parameters
-        ----------
-        varname : str, optional
-            The field to plot. Options are "depth_rho", "depth_u", "depth_v".
-        s: int, optional
-            The s-index to plot. Default is None.
-        eta : int, optional
-            The eta-index to plot. Default is None.
-        xi : int, optional
-            The xi-index to plot. Default is None.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It generates and displays a plot.
-
-        Raises
-        ------
-        ValueError
-            If the specified varname is not one of the valid options.
-            If none of s, eta, xi are specified.
-        """
-
-        if not any([s is not None, eta is not None, xi is not None]):
-            raise ValueError("At least one of s, eta, or xi must be specified.")
-
-        self.ds[varname].load()
-        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
-        elif all(dim in field.dims for dim in ["eta_rho", "xi_u"]):
-            interface_depth = self.ds.interface_depth_u
-        elif all(dim in field.dims for dim in ["eta_v", "xi_rho"]):
-            interface_depth = self.ds.interface_depth_v
-
-        # slice the field as desired
-        title = field.long_name
-        if s is not None:
-            if "s_rho" in field.dims:
-                title = title + f", s_rho = {field.s_rho[s].item()}"
-                field = field.isel(s_rho=s)
-            elif "s_w" in field.dims:
-                title = title + f", s_w = {field.s_w[s].item()}"
-                field = field.isel(s_w=s)
-            else:
-                raise ValueError(
-                    f"None of the expected dimensions (s_rho, s_w) found in ds[{varname}]."
-                )
-
-        if eta is not None:
-            if "eta_rho" in field.dims:
-                title = title + f", eta_rho = {field.eta_rho[eta].item()}"
-                field = field.isel(eta_rho=eta)
-                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)
-                interface_depth = interface_depth.isel(eta_v=eta)
-            else:
-                raise ValueError(
-                    f"None of the expected dimensions (eta_rho, eta_v) found in ds[{varname}]."
-                )
-        if xi is not None:
-            if "xi_rho" in field.dims:
-                title = title + f", xi_rho = {field.xi_rho[xi].item()}"
-                field = field.isel(xi_rho=xi)
-                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)
-                interface_depth = interface_depth.isel(xi_u=xi)
-            else:
-                raise ValueError(
-                    f"None of the expected dimensions (xi_rho, xi_u) found in ds[{varname}]."
-                )
-
-        if eta is None and xi is None:
-            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.grid.ds,
-                field=field,
-                straddle=self.grid.straddle,
-                depth_contours=True,
-                title=title,
-                kwargs=kwargs,
-                c="g",
-            )
-        else:
-            if len(field.dims) == 2:
-                cmap = plt.colormaps.get_cmap("YlGnBu")
-                cmap.set_bad(color="gray")
-                kwargs = {"vmax": 0.0, "vmin": 0.0, "cmap": cmap, "add_colorbar": False}
-
-                _section_plot(
-                    xr.zeros_like(field),
-                    interface_depth=interface_depth,
-                    title=title,
-                    kwargs=kwargs,
-                )
-            else:
-                if "s_rho" in field.dims or "s_w" in field.dims:
-                    _profile_plot(field, title=title)
-                else:
-                    _line_plot(field, title=title)
-
-    def save(self, filepath: str) -> None:
-        """
-        Save the vertical coordinate information to a netCDF4 file.
-
-        Parameters
-        ----------
-        filepath
-        """
-        self.ds.to_netcdf(filepath)
-
-    def to_yaml(self, filepath: str) -> None:
-        """
-        Export the parameters of the class to a YAML file, including the version of roms-tools.
-
-        Parameters
-        ----------
-        filepath : str
-            The path to the YAML file where the parameters will be saved.
-        """
-        # Serialize Grid data
-        grid_data = asdict(self.grid)
-        grid_data.pop("ds", None)  # Exclude non-serializable fields
-        grid_data.pop("straddle", None)
-
-        # Include the version of roms-tools
-        try:
-            roms_tools_version = importlib.metadata.version("roms-tools")
-        except importlib.metadata.PackageNotFoundError:
-            roms_tools_version = "unknown"
-
-        # Create header
-        header = f"---\nroms_tools_version: {roms_tools_version}\n---\n"
-
-        grid_yaml_data = {"Grid": grid_data}
-
-        # Combine all sections
-        vertical_coordinate_data = {
-            "VerticalCoordinate": {
-                "N": self.N,
-                "theta_s": self.theta_s,
-                "theta_b": self.theta_b,
-                "hc": self.hc,
-            }
-        }
-
-        # Merge YAML data while excluding empty sections
-        yaml_data = {
-            **grid_yaml_data,
-            **vertical_coordinate_data,
-        }
-
-        with open(filepath, "w") as file:
-            # Write header
-            file.write(header)
-            # Write YAML data
-            yaml.dump(yaml_data, file, default_flow_style=False)
-
-    @classmethod
-    def from_file(cls, filepath: str) -> "VerticalCoordinate":
-        """
-        Create a VerticalCoordinate instance from an existing file.
-
-        Parameters
-        ----------
-        filepath : str
-            Path to the file containing the vertical coordinate information.
-
-        Returns
-        -------
-        VerticalCoordinate
-            A new instance of VerticalCoordinate populated with data from the file.
-        """
-        # Load the dataset from the file
-        ds = xr.open_dataset(filepath)
-
-        # Create a new VerticalCoordinate instance without calling __init__ and __post_init__
-        vertical_coordinate = cls.__new__(cls)
-
-        # Set the dataset for the vertical_corodinate instance
-        object.__setattr__(vertical_coordinate, "ds", ds)
-
-        # Manually set the remaining attributes by extracting parameters from dataset
-        object.__setattr__(vertical_coordinate, "N", ds.sizes["s_rho"])
-        object.__setattr__(vertical_coordinate, "theta_s", ds["theta_s"].values.item())
-        object.__setattr__(vertical_coordinate, "theta_b", ds["theta_b"].values.item())
-        object.__setattr__(vertical_coordinate, "hc", ds["hc"].values.item())
-        object.__setattr__(vertical_coordinate, "grid", None)
-
-        return vertical_coordinate
-
-    @classmethod
-    def from_yaml(cls, filepath: str) -> "VerticalCoordinate":
-        """
-        Create an instance of the VerticalCoordinate class from a YAML file.
-
-        Parameters
-        ----------
-        filepath : str
-            The path to the YAML file from which the parameters will be read.
-
-        Returns
-        -------
-        VerticalCoordinate
-            An instance of the VerticalCoordinate class.
-        """
-        # Read the entire file content
-        with open(filepath, "r") as file:
-            file_content = file.read()
-
-        # Split the content into YAML documents
-        documents = list(yaml.safe_load_all(file_content))
-
-        vertical_coordinate_data = None
-
-        # Process the YAML documents
-        for doc in documents:
-            if doc is None:
-                continue
-            if "VerticalCoordinate" in doc:
-                vertical_coordinate_data = doc["VerticalCoordinate"]
-                break
-
-        if vertical_coordinate_data is None:
-            raise ValueError(
-                "No VerticalCoordinate configuration found in the YAML file."
-            )
-
-        # Create Grid instance from the YAML file
-        grid = Grid.from_yaml(filepath)
-
-        # Create and return an instance of TidalForcing
-        return cls(
-            grid=grid,
-            **vertical_coordinate_data,
-        )
 
 
 def compute_cs(sigma, theta_s, theta_b):