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

ci/environment.yml

@@ -1,4 +1,4 @@
-name: romstools
+name: romstools-test
 channels:
   - conda-forge
   - nodefaults
@@ -12,10 +12,3 @@ dependencies:
   - black
   - pre-commit
   - coverage
-  # docs
-  - sphinx
-  - nbsphinx
-  - sphinx-book-theme
-  - sphinxcontrib-bibtex
-  # for running jupyter notebooks
-  - ipykernel

roms_tools/_version.py

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

roms_tools/setup/grid.py

@@ -137,7 +137,6 @@ class Grid:
         # Check if the Greenwich meridian goes through the domain.
         self._straddle()
 
-        ds = _add_lat_lon_at_velocity_points(self.ds, self.straddle)
         object.__setattr__(self, "ds", ds)
 
         # Update the grid by adding grid variables that are coarsened versions of the original grid variables
@@ -805,7 +804,6 @@ def _make_grid_ds(
 
     # rotate coordinate system
     rotated_lon_lat_vars = _rotate(*initial_lon_lat_vars, rot)
-    lon, *_ = rotated_lon_lat_vars
 
     # translate coordinate system
     translated_lon_lat_vars = _translate(*rotated_lon_lat_vars, center_lat, center_lon)
@@ -817,7 +815,28 @@ def _make_grid_ds(
     # compute angle of local grid positive x-axis relative to east
     ang = _compute_angle(lon, lonu, latu, lonq)
 
-    ds = _create_grid_ds(lon, lat, pm, pn, ang, rot, center_lon, center_lat)
+    # make sure lons are in [0, 360] range
+    lon[lon < 0] = lon[lon < 0] + 2 * np.pi
+    lonu[lonu < 0] = lonu[lonu < 0] + 2 * np.pi
+    lonv[lonv < 0] = lonv[lonv < 0] + 2 * np.pi
+    lonq[lonq < 0] = lonq[lonq < 0] + 2 * np.pi
+
+    ds = _create_grid_ds(
+        lon,
+        lat,
+        lonu,
+        latu,
+        lonv,
+        latv,
+        lonq,
+        latq,
+        pm,
+        pn,
+        ang,
+        rot,
+        center_lon,
+        center_lat,
+    )
 
     ds = _add_global_metadata(ds, size_x, size_y, center_lon, center_lat, rot)
 
@@ -1096,15 +1115,18 @@ def _compute_angle(lon, lonu, latu, lonq):
     ang[:, 0] = ang[:, 1]
     ang[:, -1] = ang[:, -2]
 
-    lon[lon < 0] = lon[lon < 0] + 2 * np.pi
-    lonq[lonq < 0] = lonq[lonq < 0] + 2 * np.pi
-
     return ang
 
 
 def _create_grid_ds(
     lon,
     lat,
+    lonu,
+    latu,
+    lonv,
+    latv,
+    lonq,
+    latq,
     pm,
     pn,
     angle,
@@ -1124,8 +1146,49 @@ def _create_grid_ds(
         dims=["eta_rho", "xi_rho"],
         attrs={"long_name": "latitude of rho-points", "units": "degrees North"},
     )
+    lon_u = xr.Variable(
+        data=lonu * 180 / np.pi,
+        dims=["eta_rho", "xi_u"],
+        attrs={"long_name": "longitude of u-points", "units": "degrees East"},
+    )
+    lat_u = xr.Variable(
+        data=latu * 180 / np.pi,
+        dims=["eta_rho", "xi_u"],
+        attrs={"long_name": "latitude of u-points", "units": "degrees North"},
+    )
+    lon_v = xr.Variable(
+        data=lonv * 180 / np.pi,
+        dims=["eta_v", "xi_rho"],
+        attrs={"long_name": "longitude of v-points", "units": "degrees East"},
+    )
+    lat_v = xr.Variable(
+        data=latv * 180 / np.pi,
+        dims=["eta_v", "xi_rho"],
+        attrs={"long_name": "latitude of v-points", "units": "degrees North"},
+    )
+    lon_q = xr.Variable(
+        data=lonq * 180 / np.pi,
+        dims=["eta_psi", "xi_psi"],
+        attrs={"long_name": "longitude of psi-points", "units": "degrees East"},
+    )
+    lat_q = xr.Variable(
+        data=latq * 180 / np.pi,
+        dims=["eta_psi", "xi_psi"],
+        attrs={"long_name": "latitude of psi-points", "units": "degrees North"},
+    )
 
-    ds = ds.assign_coords({"lat_rho": lat_rho, "lon_rho": lon_rho})
+    ds = ds.assign_coords(
+        {
+            "lat_rho": lat_rho,
+            "lon_rho": lon_rho,
+            "lat_u": lat_u,
+            "lon_u": lon_u,
+            "lat_v": lat_v,
+            "lon_v": lon_v,
+            "lat_psi": lat_q,
+            "lon_psi": lon_q,
+        }
+    )
 
     ds["angle"] = xr.Variable(
         data=angle,
@@ -1242,7 +1305,28 @@ def _f2c_xdir(f):
 
 
 def _add_lat_lon_at_velocity_points(ds, straddle):
-
+    """
+    Adds latitude and longitude coordinates at velocity points (u and v points) to the dataset.
+    This function computes approximate latitude and longitude values at u and v velocity points
+    based on the rho points (cell centers). If the grid straddles the Greenwich meridian, it adjusts
+    the longitudes to avoid jumps from 360 to 0 degrees. The computed coordinates are added to the
+    dataset as new variables with appropriate metadata.
+    Parameters
+    ----------
+    ds : xarray.Dataset
+        The input dataset containing rho point coordinates ("lat_rho", "lon_rho").
+    straddle : bool
+        Indicates whether the grid straddles the Greenwich meridian. If True, longitudes are adjusted
+        to avoid discontinuities.
+    Returns
+    -------
+    ds : xarray.Dataset
+        The dataset with added coordinates for u and v points ("lat_u", "lon_u", "lat_v", "lon_v").
+    Notes
+    -----
+    This function only computes approximate latitude and longitude values. It should only be used if
+    more accurate values are not available from grid generation.
+    """
     if straddle:
         # avoid jump from 360 to 0 in interpolation
         lon_rho = xr.where(ds["lon_rho"] > 180, ds["lon_rho"] - 360, ds["lon_rho"])

roms_tools/setup/topography.py

@@ -61,6 +61,10 @@ def _add_topography_and_mask(
 
     # fill enclosed basins with land
     mask = _fill_enclosed_basins(mask.values)
+
+    # adjust mask boundaries by copying values from adjacent cells
+    mask = _handle_boundaries(mask)
+
     ds["mask_rho"] = xr.DataArray(mask.astype(np.int32), dims=("eta_rho", "xi_rho"))
     ds["mask_rho"].attrs = {
         "long_name": "Mask at rho-points",
@@ -233,10 +237,7 @@ def _smooth_topography_locally(h, hmin=5, rmax=0.2):
         )
 
         # No gradient at the domain boundaries
-        h_log[0, :] = h_log[1, :]
-        h_log[-1, :] = h_log[-2, :]
-        h_log[:, 0] = h_log[:, 1]
-        h_log[:, -1] = h_log[:, -2]
+        h_log = _handle_boundaries(h_log)
 
         # Update h
         h = hmin * np.exp(h_log)
@@ -252,6 +253,31 @@ def _smooth_topography_locally(h, hmin=5, rmax=0.2):
     return h
 
 
+def _handle_boundaries(field):
+    """
+    Adjust the boundaries of a 2D field by copying values from adjacent cells.
+
+    Parameters
+    ----------
+    field : numpy.ndarray or xarray.DataArray
+        A 2D array representing a field (e.g., topography or mask) whose boundary values
+        need to be adjusted.
+
+    Returns
+    -------
+    field : numpy.ndarray or xarray.DataArray
+        The input field with adjusted boundary values.
+
+    """
+
+    field[0, :] = field[1, :]
+    field[-1, :] = field[-2, :]
+    field[:, 0] = field[:, 1]
+    field[:, -1] = field[:, -2]
+
+    return field
+
+
 def _compute_rfactor(h):
     """
     Computes slope parameter (or r-factor) r = |Delta h| / 2h in both horizontal grid directions.