roms-tools 0.1.0__py3-none-any.whl → 0.20__py3-none-any.whl

roms_tools/setup/tides.py

@@ -1,11 +1,498 @@
 from datetime import datetime
 import xarray as xr
 import numpy as np
-from dataclasses import dataclass, field
+import yaml
+import importlib.metadata
+
+from dataclasses import dataclass, field, asdict
 from roms_tools.setup.grid import Grid
 from roms_tools.setup.plot import _plot
-import os
-import hashlib
+from roms_tools.setup.fill import fill_and_interpolate
+from roms_tools.setup.datasets import Dataset
+from roms_tools.setup.utils import (
+    nan_check,
+    interpolate_from_rho_to_u,
+    interpolate_from_rho_to_v,
+)
+from typing import Dict, List
+import matplotlib.pyplot as plt
+
+
+@dataclass(frozen=True, kw_only=True)
+class TPXO(Dataset):
+    """
+    Represents tidal data on original grid.
+
+    Parameters
+    ----------
+    filename : str
+        The path to the TPXO dataset.
+    var_names : List[str], optional
+        List of variable names that are required in the dataset. Defaults to
+        ["h_Re", "h_Im", "sal_Re", "sal_Im", "u_Re", "u_Im", "v_Re", "v_Im"].
+    dim_names: Dict[str, str], optional
+        Dictionary specifying the names of dimensions in the dataset. Defaults to
+        {"longitude": "ny", "latitude": "nx"}.
+
+    Attributes
+    ----------
+    ds : xr.Dataset
+        The xarray Dataset containing TPXO tidal model data.
+    """
+
+    filename: str
+    var_names: List[str] = field(
+        default_factory=lambda: [
+            "h_Re",
+            "h_Im",
+            "sal_Re",
+            "sal_Im",
+            "u_Re",
+            "u_Im",
+            "v_Re",
+            "v_Im",
+            "depth",
+        ]
+    )
+    dim_names: Dict[str, str] = field(
+        default_factory=lambda: {"longitude": "ny", "latitude": "nx", "ntides": "nc"}
+    )
+    ds: xr.Dataset = field(init=False, repr=False)
+
+    def __post_init__(self):
+        # Perform any necessary dataset initialization or modifications here
+        ds = super().load_data()
+
+        # Clean up dataset
+        ds = ds.assign_coords(
+            {
+                "omega": ds["omega"],
+                "nx": ds["lon_r"].isel(
+                    ny=0
+                ),  # lon_r is constant along ny, i.e., is only a function of nx
+                "ny": ds["lat_r"].isel(
+                    nx=0
+                ),  # lat_r is constant along nx, i.e., is only a function of ny
+            }
+        )
+        ds = ds.rename({"nx": "longitude", "ny": "latitude"})
+
+        object.__setattr__(
+            self,
+            "dim_names",
+            {
+                "latitude": "latitude",
+                "longitude": "longitude",
+                "ntides": self.dim_names["ntides"],
+            },
+        )
+        # Select relevant fields
+        ds = super().select_relevant_fields(ds)
+
+        # Check whether the data covers the entire globe
+        is_global = self.check_if_global(ds)
+
+        if is_global:
+            ds = self.concatenate_longitudes(ds)
+
+        object.__setattr__(self, "ds", ds)
+
+    def check_number_constituents(self, ntides: int):
+        """
+        Checks if the number of constituents in the dataset is at least `ntides`.
+
+        Parameters
+        ----------
+        ntides : int
+            The required number of tidal constituents.
+
+        Raises
+        ------
+        ValueError
+            If the number of constituents in the dataset is less than `ntides`.
+        """
+        if len(self.ds[self.dim_names["ntides"]]) < ntides:
+            raise ValueError(
+                f"The dataset contains fewer than {ntides} tidal constituents."
+            )
+
+    def get_corrected_tides(self, model_reference_date, allan_factor):
+        # Get equilibrium tides
+        tpc = compute_equilibrium_tide(self.ds["longitude"], self.ds["latitude"]).isel(
+            nc=self.ds.nc
+        )
+        # Correct for SAL
+        tsc = allan_factor * (self.ds["sal_Re"] + 1j * self.ds["sal_Im"])
+        tpc = tpc - tsc
+
+        # Elevations and transports
+        thc = self.ds["h_Re"] + 1j * self.ds["h_Im"]
+        tuc = self.ds["u_Re"] + 1j * self.ds["u_Im"]
+        tvc = self.ds["v_Re"] + 1j * self.ds["v_Im"]
+
+        # Apply correction for phases and amplitudes
+        pf, pu, aa = egbert_correction(model_reference_date)
+        pf = pf.isel(nc=self.ds.nc)
+        pu = pu.isel(nc=self.ds.nc)
+        aa = aa.isel(nc=self.ds.nc)
+
+        tpxo_reference_date = datetime(1992, 1, 1)
+        dt = (model_reference_date - tpxo_reference_date).days * 3600 * 24
+
+        thc = pf * thc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
+        tuc = pf * tuc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
+        tvc = pf * tvc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
+        tpc = pf * tpc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
+
+        tides = {
+            "ssh_Re": thc.real,
+            "ssh_Im": thc.imag,
+            "u_Re": tuc.real,
+            "u_Im": tuc.imag,
+            "v_Re": tvc.real,
+            "v_Im": tvc.imag,
+            "pot_Re": tpc.real,
+            "pot_Im": tpc.imag,
+            "omega": self.ds["omega"],
+        }
+
+        for k in tides.keys():
+            tides[k] = tides[k].rename({"nc": "ntides"})
+
+        return tides
+
+
+@dataclass(frozen=True, kw_only=True)
+class TidalForcing:
+    """
+    Represents tidal forcing data used in ocean modeling.
+
+    Parameters
+    ----------
+    grid : Grid
+        The grid object representing the ROMS grid associated with the tidal forcing data.
+    filename: str
+        The path to the native tidal dataset.
+    ntides : int, optional
+        Number of constituents to consider. Maximum number is 14. Default is 10.
+    model_reference_date : datetime, optional
+        The reference date for the ROMS simulation. Default is datetime(2000, 1, 1).
+    source : str, optional
+        The source of the tidal data. Default is "TPXO".
+    allan_factor : float, optional
+        The Allan factor used in tidal model computation. Default is 2.0.
+
+    Attributes
+    ----------
+    ds : xr.Dataset
+        The xarray Dataset containing the tidal forcing data.
+
+    Examples
+    --------
+    >>> grid = Grid(...)
+    >>> tidal_forcing = TidalForcing(grid)
+    >>> print(tidal_forcing.ds)
+    """
+
+    grid: Grid
+    filename: str
+    ntides: int = 10
+    model_reference_date: datetime = datetime(2000, 1, 1)
+    source: str = "TPXO"
+    allan_factor: float = 2.0
+    ds: xr.Dataset = field(init=False, repr=False)
+
+    def __post_init__(self):
+        if self.source == "TPXO":
+            data = TPXO(filename=self.filename)
+        else:
+            raise ValueError('Only "TPXO" is a valid option for source.')
+
+        data.check_number_constituents(self.ntides)
+        # operate on longitudes between -180 and 180 unless ROMS domain lies at least 5 degrees in lontitude away from Greenwich meridian
+        lon = self.grid.ds.lon_rho
+        lat = self.grid.ds.lat_rho
+        angle = self.grid.ds.angle
+
+        lon = xr.where(lon > 180, lon - 360, lon)
+        straddle = True
+        if not self.grid.straddle and abs(lon).min() > 5:
+            lon = xr.where(lon < 0, lon + 360, lon)
+            straddle = False
+
+        # The following consists of two steps:
+        # Step 1: Choose subdomain of forcing data including safety margin for interpolation, and Step 2: Convert to the proper longitude range.
+        # We perform these two steps for two reasons:
+        # A) Since the horizontal dimensions consist of a single chunk, selecting a subdomain before interpolation is a lot more performant.
+        # B) Step 1 is necessary to avoid discontinuous longitudes that could be introduced by Step 2. Specifically, discontinuous longitudes
+        # can lead to artifacts in the interpolation process. Specifically, if there is a data gap if data is not global,
+        # discontinuous longitudes could result in values that appear to come from a distant location instead of producing NaNs.
+        # These NaNs are important as they can be identified and handled appropriately by the nan_check function.
+        data.choose_subdomain(
+            latitude_range=[lat.min().values, lat.max().values],
+            longitude_range=[lon.min().values, lon.max().values],
+            margin=2,
+            straddle=straddle,
+        )
+
+        tides = data.get_corrected_tides(self.model_reference_date, self.allan_factor)
+
+        # select desired number of constituents
+        for k in tides.keys():
+            tides[k] = tides[k].isel(ntides=slice(None, self.ntides))
+
+        # interpolate onto desired grid
+        coords = {"latitude": lat, "longitude": lon}
+        mask = xr.where(data.ds.depth > 0, 1, 0)
+
+        varnames = [
+            "ssh_Re",
+            "ssh_Im",
+            "pot_Re",
+            "pot_Im",
+            "u_Re",
+            "u_Im",
+            "v_Re",
+            "v_Im",
+        ]
+        data_vars = {}
+
+        for var in varnames:
+            data_vars[var] = fill_and_interpolate(
+                tides[var],
+                mask,
+                list(coords.keys()),
+                coords,
+                method="linear",
+            )
+
+        # Rotate to grid orientation
+        u_Re = data_vars["u_Re"] * np.cos(angle) + data_vars["v_Re"] * np.sin(angle)
+        v_Re = data_vars["v_Re"] * np.cos(angle) - data_vars["u_Re"] * np.sin(angle)
+        u_Im = data_vars["u_Im"] * np.cos(angle) + data_vars["v_Im"] * np.sin(angle)
+        v_Im = data_vars["v_Im"] * np.cos(angle) - data_vars["u_Im"] * np.sin(angle)
+
+        # Convert to barotropic velocity
+        u_Re = u_Re / self.grid.ds.h
+        v_Re = v_Re / self.grid.ds.h
+        u_Im = u_Im / self.grid.ds.h
+        v_Im = v_Im / self.grid.ds.h
+
+        # Interpolate from rho- to velocity points
+        u_Re = interpolate_from_rho_to_u(u_Re)
+        v_Re = interpolate_from_rho_to_v(v_Re)
+        u_Im = interpolate_from_rho_to_u(u_Im)
+        v_Im = interpolate_from_rho_to_v(v_Im)
+
+        # save in new dataset
+        ds = xr.Dataset()
+
+        # ds["omega"] = tides["omega"]
+
+        ds["ssh_Re"] = data_vars["ssh_Re"].astype(np.float32)
+        ds["ssh_Im"] = data_vars["ssh_Im"].astype(np.float32)
+        ds["ssh_Re"].attrs["long_name"] = "Tidal elevation, real part"
+        ds["ssh_Im"].attrs["long_name"] = "Tidal elevation, complex part"
+        ds["ssh_Re"].attrs["units"] = "m"
+        ds["ssh_Im"].attrs["units"] = "m"
+
+        ds["pot_Re"] = data_vars["pot_Re"].astype(np.float32)
+        ds["pot_Im"] = data_vars["pot_Im"].astype(np.float32)
+        ds["pot_Re"].attrs["long_name"] = "Tidal potential, real part"
+        ds["pot_Im"].attrs["long_name"] = "Tidal potential, complex part"
+        ds["pot_Re"].attrs["units"] = "m"
+        ds["pot_Im"].attrs["units"] = "m"
+
+        ds["u_Re"] = u_Re.astype(np.float32)
+        ds["u_Im"] = u_Im.astype(np.float32)
+        ds["u_Re"].attrs["long_name"] = "Tidal velocity in x-direction, real part"
+        ds["u_Im"].attrs["long_name"] = "Tidal velocity in x-direction, complex part"
+        ds["u_Re"].attrs["units"] = "m/s"
+        ds["u_Im"].attrs["units"] = "m/s"
+
+        ds["v_Re"] = v_Re.astype(np.float32)
+        ds["v_Im"] = v_Im.astype(np.float32)
+        ds["v_Re"].attrs["long_name"] = "Tidal velocity in y-direction, real part"
+        ds["v_Im"].attrs["long_name"] = "Tidal velocity in y-direction, complex part"
+        ds["v_Re"].attrs["units"] = "m/s"
+        ds["v_Im"].attrs["units"] = "m/s"
+
+        ds.attrs["title"] = "ROMS tidal forcing 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
+
+        ds.attrs["source"] = self.source
+        ds.attrs["model_reference_date"] = str(self.model_reference_date)
+        ds.attrs["allan_factor"] = self.allan_factor
+
+        object.__setattr__(self, "ds", ds)
+
+        for var in ["ssh_Re", "u_Re", "v_Im"]:
+            nan_check(self.ds[var].isel(ntides=0), self.grid.ds.mask_rho)
+
+    def plot(self, varname, ntides=0) -> None:
+        """
+        Plot the specified tidal forcing variable for a given tidal constituent.
+
+        Parameters
+        ----------
+        varname : str
+            The tidal forcing variable to plot. Options include:
+            - "ssh_Re": Real part of tidal elevation.
+            - "ssh_Im": Imaginary part of tidal elevation.
+            - "pot_Re": Real part of tidal potential.
+            - "pot_Im": Imaginary part of tidal potential.
+            - "u_Re": Real part of tidal velocity in the x-direction.
+            - "u_Im": Imaginary part of tidal velocity in the x-direction.
+            - "v_Re": Real part of tidal velocity in the y-direction.
+            - "v_Im": Imaginary part of tidal velocity in the y-direction.
+        ntides : int, optional
+            The index of the tidal constituent to plot. Default is 0, which corresponds
+            to the first constituent.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It generates and displays a plot.
+
+        Raises
+        ------
+        ValueError
+            If the specified field is not one of the valid options.
+
+
+        Examples
+        --------
+        >>> tidal_forcing = TidalForcing(grid)
+        >>> tidal_forcing.plot("ssh_Re", nc=0)
+        """
+
+        field = self.ds[varname].isel(ntides=ntides).compute()
+
+        title = "%s, ntides = %i" % (field.long_name, self.ds[varname].ntides[ntides])
+
+        vmax = max(field.max(), -field.min())
+        vmin = -vmax
+        cmap = plt.colormaps.get_cmap("RdBu_r")
+        cmap.set_bad(color="gray")
+
+        kwargs = {"vmax": vmax, "vmin": vmin, "cmap": cmap}
+
+        _plot(
+            self.grid.ds,
+            field=field,
+            straddle=self.grid.straddle,
+            c="g",
+            kwargs=kwargs,
+            title=title,
+        )
+
+    def save(self, filepath: str) -> None:
+        """
+        Save the tidal forcing 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.
+        """
+        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"
+
+        # Extract grid data
+        grid_yaml_data = {"Grid": grid_data}
+
+        # Extract tidal forcing data
+        tidal_forcing_data = {
+            "TidalForcing": {
+                "filename": self.filename,
+                "ntides": self.ntides,
+                "model_reference_date": self.model_reference_date.isoformat(),
+                "source": self.source,
+                "allan_factor": self.allan_factor,
+            }
+        }
+
+        # Combine both sections
+        yaml_data = {**grid_yaml_data, **tidal_forcing_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_yaml(cls, filepath: str) -> "TidalForcing":
+        """
+        Create an instance of the TidalForcing class from a YAML file.
+
+        Parameters
+        ----------
+        filepath : str
+            The path to the YAML file from which the parameters will be read.
+
+        Returns
+        -------
+        TidalForcing
+            An instance of the TidalForcing 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))
+
+        tidal_forcing_data = None
+
+        # Process the YAML documents
+        for doc in documents:
+            if doc is None:
+                continue
+            if "TidalForcing" in doc:
+                tidal_forcing_data = doc["TidalForcing"]
+                break
+
+        if tidal_forcing_data is None:
+            raise ValueError("No TidalForcing configuration found in the YAML file.")
+
+        # Convert the model_reference_date from string to datetime
+        tidal_forcing_params = tidal_forcing_data
+        tidal_forcing_params["model_reference_date"] = datetime.fromisoformat(
+            tidal_forcing_params["model_reference_date"]
+        )
+
+        # Create Grid instance from the YAML file
+        grid = Grid.from_yaml(filepath)
+
+        # Create and return an instance of TidalForcing
+        return cls(grid=grid, **tidal_forcing_params)
 
 
 def modified_julian_days(year, month, day, hour=0):
@@ -224,453 +711,99 @@ def egbert_correction(date):
     return pf, pu, aa
 
 
-@dataclass(frozen=True, kw_only=True)
-class TPXO:
-    """
-    Represents TPXO tidal atlas.
-
-    Parameters
-    ----------
-    filename : str
-        The path to the TPXO dataset.
-
-    Attributes
-    ----------
-    ds : xr.Dataset
-        The xarray Dataset containing TPXO tidal model data.
-
-    Notes
-    -----
-    This class provides a convenient interface to work with TPXO tidal atlas.
-
-    Examples
-    --------
-    >>> tpxo = TPXO()
-    >>> tpxo.load_data("tpxo_data.nc")
-    >>> print(tpxo.ds)
-    <xarray.Dataset>
-    Dimensions:  ...
-    """
-
-    filename: str
-    ds: xr.Dataset = field(init=False, repr=False)
-
-    def __post_init__(self):
-        ds = self.load_data(self.filename)
-        # Lon_r is constant along ny, i.e., is only a function of nx
-        ds["nx"] = ds["lon_r"].isel(ny=0)
-        # Lat_r is constant along nx, i.e., is only a function of ny
-        ds["ny"] = ds["lat_r"].isel(nx=0)
-
-        object.__setattr__(self, "ds", ds)
-
-    def get_corrected_tides(self, model_reference_date, allan_factor):
-        # Get equilibrium tides
-        tpc = self.compute_equilibrium_tide(self.ds["lon_r"], self.ds["lat_r"])
-        # Correct for SAL
-        tsc = allan_factor * (self.ds["sal_Re"] + 1j * self.ds["sal_Im"])
-        tpc = tpc - tsc
-
-        # Elevations and transports
-        thc = self.ds["h_Re"] + 1j * self.ds["h_Im"]
-        tuc = self.ds["u_Re"] + 1j * self.ds["u_Im"]
-        tvc = self.ds["v_Re"] + 1j * self.ds["v_Im"]
-
-        # Apply correction for phases and amplitudes
-        pf, pu, aa = egbert_correction(model_reference_date)
-        tpxo_reference_date = datetime(1992, 1, 1)
-        dt = (model_reference_date - tpxo_reference_date).days * 3600 * 24
-
-        thc = pf * thc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
-        tuc = pf * tuc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
-        tvc = pf * tvc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
-        tpc = pf * tpc * np.exp(1j * (self.ds["omega"] * dt + pu + aa))
-
-        tides = {"ssh": thc, "u": tuc, "v": tvc, "pot": tpc, "omega": self.ds["omega"]}
-
-        return tides
-
-    @staticmethod
-    def load_data(filename):
-        """
-        Load tidal forcing data from the specified file.
-
-        Parameters
-        ----------
-        filename : str
-            The path to the tidal dataset file.
-
-        Returns
-        -------
-        ds : xr.Dataset
-            The loaded xarray Dataset containing the tidal forcing data.
-
-        Raises
-        ------
-        FileNotFoundError
-            If the specified file does not exist.
-        ValueError
-            If the file checksum does not match the expected value.
-
-        Notes
-        -----
-        This method performs basic file existence and checksum checks to ensure the integrity of the loaded dataset.
-
-        """
-        # Check if the file exists
-        if not os.path.exists(filename):
-            raise FileNotFoundError(f"File '{filename}' not found.")
-
-        # Calculate the checksum of the file
-        expected_checksum = (
-            "306956d8769737ba39040118d8d08f467187fe453e02a5651305621d095bce6e"
-        )
-        with open(filename, "rb") as file:
-            actual_checksum = hashlib.sha256(file.read()).hexdigest()
-
-        # Compare the checksums
-        if actual_checksum != expected_checksum:
-            raise ValueError(
-                "Checksum mismatch. The file may be corrupted or tampered with."
-            )
-
-        # Load the dataset
-        ds = xr.open_dataset(filename)
-
-        return ds
-
-    @staticmethod
-    def compute_equilibrium_tide(lon, lat):
-        """
-        Compute equilibrium tide for given longitudes and latitudes.
-
-        Parameters
-        ----------
-        lon : xr.DataArray
-            Longitudes in degrees.
-        lat : xr.DataArray
-            Latitudes in degrees.
-
-        Returns
-        -------
-        tpc : xr.DataArray
-            Equilibrium tide complex amplitude.
-
-        Notes
-        -----
-        This method computes the equilibrium tide complex amplitude for given longitudes
-        and latitudes. It considers 15 tidal constituents and their corresponding
-        amplitudes and elasticity factors. The types of tides are classified as follows:
-            - 2: semidiurnal
-            - 1: diurnal
-            - 0: long-term
-
-        """
-
-        # Amplitudes and elasticity factors for 15 tidal constituents
-        A = xr.DataArray(
-            data=np.array(
-                [
-                    0.242334,  # M2
-                    0.112743,  # S2
-                    0.046397,  # N2
-                    0.030684,  # K2
-                    0.141565,  # K1
-                    0.100661,  # O1
-                    0.046848,  # P1
-                    0.019273,  # Q1
-                    0.042041,  # Mf
-                    0.022191,  # Mm
-                    0.0,  # M4
-                    0.0,  # Mn4
-                    0.0,  # Ms4
-                    0.006141,  # 2n2
-                    0.000764,  # S1
-                ]
-            ),
-            dims="nc",
-        )
-        B = xr.DataArray(
-            data=np.array(
-                [
-                    0.693,  # M2
-                    0.693,  # S2
-                    0.693,  # N2
-                    0.693,  # K2
-                    0.736,  # K1
-                    0.695,  # O1
-                    0.706,  # P1
-                    0.695,  # Q1
-                    0.693,  # Mf
-                    0.693,  # Mm
-                    0.693,  # M4
-                    0.693,  # Mn4
-                    0.693,  # Ms4
-                    0.693,  # 2n2
-                    0.693,  # S1
-                ]
-            ),
-            dims="nc",
-        )
-
-        # types: 2 = semidiurnal, 1 = diurnal, 0 = long-term
-        ityp = xr.DataArray(
-            data=np.array([2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 2, 1]), dims="nc"
-        )
-
-        d2r = np.pi / 180
-        coslat2 = np.cos(d2r * lat) ** 2
-        sin2lat = np.sin(2 * d2r * lat)
-
-        p_amp = (
-            xr.where(ityp == 2, 1, 0) * A * B * coslat2  # semidiurnal
-            + xr.where(ityp == 1, 1, 0) * A * B * sin2lat  # diurnal
-            + xr.where(ityp == 0, 1, 0) * A * B * (0.5 - 1.5 * coslat2)  # long-term
-        )
-        p_pha = (
-            xr.where(ityp == 2, 1, 0) * (-2 * lon * d2r)  # semidiurnal
-            + xr.where(ityp == 1, 1, 0) * (-lon * d2r)  # diurnal
-            + xr.where(ityp == 0, 1, 0) * xr.zeros_like(lon)  # long-term
-        )
-
-        tpc = p_amp * np.exp(-1j * p_pha)
-
-        return tpc
-
-    @staticmethod
-    def concatenate_across_dateline(field):
-        """
-        Concatenate a field across the dateline for TPXO atlas.
-
-        Parameters
-        ----------
-        field : xr.DataArray
-            The field to be concatenated across the dateline.
-
-        Returns
-        -------
-        field_concatenated : xr.DataArray
-            The field concatenated across the dateline.
-
-        Notes
-        -----
-        The TPXO atlas has a minimum longitude of 0.167 and a maximum longitude of 360.0.
-        This method concatenates the field along the dateline on the lower end, considering
-        the discontinuity in longitudes.
-
-        """
-        lon = field["nx"]
-        lon_minus360 = lon - 360
-        lon_concatenated = xr.concat([lon_minus360, lon], dim="nx")
-        field_concatenated = xr.concat([field, field], dim="nx")
-        field_concatenated["nx"] = lon_concatenated
-
-        return field_concatenated
-
-
-@dataclass(frozen=True, kw_only=True)
-class TidalForcing:
+def compute_equilibrium_tide(lon, lat):
     """
-    Represents tidal forcing data used in ocean modeling.
+    Compute equilibrium tide for given longitudes and latitudes.
 
     Parameters
     ----------
-    grid : Grid
-        The grid object representing the ROMS grid associated with the tidal forcing data.
-    filename: str
-        The path to the native tidal dataset.
-    nc : int, optional
-        Number of constituents to consider. Maximum number is 14. Default is 10.
-    model_reference_date : datetime, optional
-        The reference date for the ROMS simulation. Default is datetime(2000, 1, 1).
-    source : str, optional
-        The source of the tidal data. Default is "tpxo".
-    allan_factor : float, optional
-        The Allan factor used in tidal model computation. Default is 2.0.
+    lon : xr.DataArray
+        Longitudes in degrees.
+    lat : xr.DataArray
+        Latitudes in degrees.
 
-    Attributes
-    ----------
-    ds : xr.Dataset
-        The xarray Dataset containing the tidal forcing data.
+    Returns
+    -------
+    tpc : xr.DataArray
+        Equilibrium tide complex amplitude.
 
     Notes
     -----
-    This class represents tidal forcing data used in ocean modeling. It provides
-    functionality to load and process tidal data for use in numerical simulations.
-    The tidal forcing data is loaded from a TPXO dataset and processed to generate
-    tidal elevation, tidal potential, and tidal velocity fields.
+    This method computes the equilibrium tide complex amplitude for given longitudes
+    and latitudes. It considers 15 tidal constituents and their corresponding
+    amplitudes and elasticity factors. The types of tides are classified as follows:
+        - 2: semidiurnal
+        - 1: diurnal
+        - 0: long-term
 
-    Examples
-    --------
-    >>> grid = Grid(...)
-    >>> tidal_forcing = TidalForcing(grid)
-    >>> print(tidal_forcing.ds)
     """
 
-    grid: Grid
-    filename: str
-    nc: int = 10
-    model_reference_date: datetime = datetime(2000, 1, 1)
-    source: str = "tpxo"
-    allan_factor: float = 2.0
-    ds: xr.Dataset = field(init=False, repr=False)
-
-    def __post_init__(self):
-        if self.source == "tpxo":
-            tpxo = TPXO(filename=self.filename)
-
-            tides = tpxo.get_corrected_tides(
-                self.model_reference_date, self.allan_factor
-            )
-
-            # rename dimension and select desired number of constituents
-            for k in tides.keys():
-                tides[k] = tides[k].rename({"nc": "ntides"})
-                tides[k] = tides[k].isel(ntides=slice(None, self.nc))
-
-            # make sure interpolation works across dateline
-            for key in ["ssh", "pot", "u", "v"]:
-                tides[key] = tpxo.concatenate_across_dateline(tides[key])
-
-            # interpolate onto desired grid
-            ssh_tide = (
-                tides["ssh"]
-                .interp(nx=self.grid.ds.lon_rho, ny=self.grid.ds.lat_rho)
-                .drop_vars(["nx", "ny"])
-            )
-            pot_tide = (
-                tides["pot"]
-                .interp(nx=self.grid.ds.lon_rho, ny=self.grid.ds.lat_rho)
-                .drop_vars(["nx", "ny"])
-            )
-            u = (
-                tides["u"]
-                .interp(nx=self.grid.ds.lon_rho, ny=self.grid.ds.lat_rho)
-                .drop_vars(["nx", "ny"])
-            )
-            v = (
-                tides["v"]
-                .interp(nx=self.grid.ds.lon_rho, ny=self.grid.ds.lat_rho)
-                .drop_vars(["nx", "ny"])
-            )
-
-        # Rotate to grid orientation
-        u_tide = u * np.cos(self.grid.ds.angle) + v * np.sin(self.grid.ds.angle)
-        v_tide = v * np.cos(self.grid.ds.angle) - u * np.sin(self.grid.ds.angle)
-
-        # Convert to barotropic velocity
-        u_tide = u_tide / self.grid.ds.h
-        v_tide = v_tide / self.grid.ds.h
-
-        # Interpolate from rho- to velocity points
-        u_tide = (
-            (u_tide + u_tide.shift(xi_rho=1))
-            .isel(xi_rho=slice(1, None))
-            .drop_vars(["lat_rho", "lon_rho"])
-        )
-        u_tide = u_tide.swap_dims({"xi_rho": "xi_u"})
-        v_tide = (
-            (v_tide + v_tide.shift(eta_rho=1))
-            .isel(eta_rho=slice(1, None))
-            .drop_vars(["lat_rho", "lon_rho"])
-        )
-        v_tide = v_tide.swap_dims({"eta_rho": "eta_v"})
-
-        # save in new dataset
-        ds = xr.Dataset()
-
-        ds["omega"] = tides["omega"]
-
-        ds["ssh_Re"] = ssh_tide.real
-        ds["ssh_Im"] = ssh_tide.imag
-        ds["ssh_Re"].attrs["long_name"] = "Tidal elevation, real part"
-        ds["ssh_Im"].attrs["long_name"] = "Tidal elevation, complex part"
-        ds["ssh_Re"].attrs["units"] = "m"
-        ds["ssh_Im"].attrs["units"] = "m"
-
-        ds["pot_Re"] = pot_tide.real
-        ds["pot_Im"] = pot_tide.imag
-        ds["pot_Re"].attrs["long_name"] = "Tidal potential, real part"
-        ds["pot_Im"].attrs["long_name"] = "Tidal potential, complex part"
-        ds["pot_Re"].attrs["units"] = "m"
-        ds["pot_Im"].attrs["units"] = "m"
-
-        ds["u_Re"] = u_tide.real
-        ds["u_Im"] = u_tide.imag
-        ds["u_Re"].attrs["long_name"] = "Tidal velocity in x-direction, real part"
-        ds["u_Im"].attrs["long_name"] = "Tidal velocity in x-direction, complex part"
-        ds["u_Re"].attrs["units"] = "m/s"
-        ds["u_Im"].attrs["units"] = "m/s"
-
-        ds["v_Re"] = v_tide.real
-        ds["v_Im"] = v_tide.imag
-        ds["v_Re"].attrs["long_name"] = "Tidal velocity in y-direction, real part"
-        ds["v_Im"].attrs["long_name"] = "Tidal velocity in y-direction, complex part"
-        ds["v_Re"].attrs["units"] = "m/s"
-        ds["v_Im"].attrs["units"] = "m/s"
-
-        ds.attrs["source"] = self.source
-        ds.attrs["model_reference_date"] = self.model_reference_date
-        ds.attrs["allan_factor"] = self.allan_factor
-
-        object.__setattr__(self, "ds", ds)
-
-    def plot(self, var, nc=0) -> None:
-        """
-        Plot the specified tidal forcing variable for a given tidal constituent.
-
-        Parameters
-        ----------
-        var : str
-            The tidal forcing variable to plot. Options include:
-            - "ssh_Re": Real part of tidal elevation.
-            - "ssh_Im": Imaginary part of tidal elevation.
-            - "pot_Re": Real part of tidal potential.
-            - "pot_Im": Imaginary part of tidal potential.
-            - "u_Re": Real part of tidal velocity in the x-direction.
-            - "u_Im": Imaginary part of tidal velocity in the x-direction.
-            - "v_Re": Real part of tidal velocity in the y-direction.
-            - "v_Im": Imaginary part of tidal velocity in the y-direction.
-        nc : int, optional
-            The index of the tidal constituent to plot. Default is 0, which corresponds
-            to the first constituent.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It generates and displays a plot.
-
-        Raises
-        ------
-        ValueError
-            If the specified field is not one of the valid options.
-
+    # Amplitudes and elasticity factors for 15 tidal constituents
+    A = xr.DataArray(
+        data=np.array(
+            [
+                0.242334,  # M2
+                0.112743,  # S2
+                0.046397,  # N2
+                0.030684,  # K2
+                0.141565,  # K1
+                0.100661,  # O1
+                0.046848,  # P1
+                0.019273,  # Q1
+                0.042041,  # Mf
+                0.022191,  # Mm
+                0.0,  # M4
+                0.0,  # Mn4
+                0.0,  # Ms4
+                0.006141,  # 2n2
+                0.000764,  # S1
+            ]
+        ),
+        dims="nc",
+    )
+    B = xr.DataArray(
+        data=np.array(
+            [
+                0.693,  # M2
+                0.693,  # S2
+                0.693,  # N2
+                0.693,  # K2
+                0.736,  # K1
+                0.695,  # O1
+                0.706,  # P1
+                0.695,  # Q1
+                0.693,  # Mf
+                0.693,  # Mm
+                0.693,  # M4
+                0.693,  # Mn4
+                0.693,  # Ms4
+                0.693,  # 2n2
+                0.693,  # S1
+            ]
+        ),
+        dims="nc",
+    )
 
-        Examples
-        --------
-        >>> tidal_forcing = TidalForcing(grid)
-        >>> tidal_forcing.plot("ssh_Re", nc=0)
-        """
+    # types: 2 = semidiurnal, 1 = diurnal, 0 = long-term
+    ityp = xr.DataArray(
+        data=np.array([2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 2, 1]), dims="nc"
+    )
 
-        vmax = max(
-            self.ds[var].isel(ntides=nc).max(), -self.ds[var].isel(ntides=nc).min()
-        )
-        kwargs = {"cmap": "RdBu_r", "vmax": vmax, "vmin": -vmax}
+    d2r = np.pi / 180
+    coslat2 = np.cos(d2r * lat) ** 2
+    sin2lat = np.sin(2 * d2r * lat)
 
-        _plot(
-            self.ds,
-            field=self.ds[var].isel(ntides=nc),
-            straddle=self.grid.straddle,
-            c="g",
-            kwargs=kwargs,
-        )
+    p_amp = (
+        xr.where(ityp == 2, 1, 0) * A * B * coslat2  # semidiurnal
+        + xr.where(ityp == 1, 1, 0) * A * B * sin2lat  # diurnal
+        + xr.where(ityp == 0, 1, 0) * A * B * (0.5 - 1.5 * coslat2)  # long-term
+    )
+    p_pha = (
+        xr.where(ityp == 2, 1, 0) * (-2 * lon * d2r)  # semidiurnal
+        + xr.where(ityp == 1, 1, 0) * (-lon * d2r)  # diurnal
+        + xr.where(ityp == 0, 1, 0) * xr.zeros_like(lon)  # long-term
+    )
 
-    def save(self, filepath: str) -> None:
-        """
-        Save the tidal forcing information to a netCDF4 file.
+    tpc = p_amp * np.exp(-1j * p_pha)
 
-        Parameters
-        ----------
-        filepath
-        """
-        self.ds.to_netcdf(filepath)
+    return tpc