roms-tools 2.0.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

roms_tools/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = _version("roms_tools")
 except ImportError:  # pragma: no cover
     # Local copy or not installed with setuptools
-    __version__ = "999"
+    __version__ = "9999"
 
 
 from roms_tools.setup.grid import Grid  # noqa: F401
@@ -14,6 +14,7 @@ from roms_tools.setup.surface_forcing import SurfaceForcing  # noqa: F401
 from roms_tools.setup.initial_conditions import InitialConditions  # noqa: F401
 from roms_tools.setup.boundary_forcing import BoundaryForcing  # noqa: F401
 from roms_tools.setup.river_forcing import RiverForcing  # noqa: F401
+from roms_tools.setup.nesting import Nesting  # noqa: F401
 
 # Configure logging when the package is imported
 logging.basicConfig(level=logging.INFO, format="%(levelname)s - %(message)s")

roms_tools/setup/boundary_forcing.py

@@ -24,6 +24,7 @@ from roms_tools.setup.utils import (
     interpolate_from_rho_to_u,
     interpolate_from_rho_to_v,
     convert_to_roms_time,
+    get_boundary_coords,
     _to_yaml,
     _from_yaml,
 )
@@ -71,6 +72,10 @@ class BoundaryForcing:
         Reference date for the model. Default is January 1, 2000.
     use_dask: bool, optional
         Indicates whether to use dask for processing. If True, data is processed with dask; if False, data is processed eagerly. Defaults to False.
+    bypass_validation: bool, optional
+        Indicates whether to skip validation checks in the processed data. When set to True,
+        the validation process that ensures no NaN values exist at wet points
+        in the processed dataset is bypassed. Defaults to False.
 
     Examples
     --------
@@ -100,6 +105,7 @@ class BoundaryForcing:
     apply_2d_horizontal_fill: bool = False
     model_reference_date: datetime = datetime(2000, 1, 1)
     use_dask: bool = False
+    bypass_validation: bool = False
 
     ds: xr.Dataset = field(init=False, repr=False)
 
@@ -279,7 +285,8 @@ class BoundaryForcing:
         # Add global information
         ds = self._add_global_metadata(data, ds)
 
-        self._validate(ds)
+        if not self.bypass_validation:
+            self._validate(ds)
 
         # substitute NaNs over land by a fill value to avoid blow-up of ROMS
         for var_name in ds.data_vars:
@@ -459,7 +466,7 @@ class BoundaryForcing:
         return ds
 
     def _set_boundary_info(self):
-        """Updates boundary coordinates for rho, u, and v variables on the grid.
+        """Sets boundary coordinates for rho, u, and v variables on the grid.
 
         This method determines the boundary points for the grid variables by specifying the
         indices for the south, east, north, and west boundaries. The resulting boundary
@@ -476,32 +483,7 @@ class BoundaryForcing:
               grid indices for the respective variable types.
         """
 
-        bdry_coords = {
-            "rho": {
-                "south": {"eta_rho": 0},
-                "east": {"xi_rho": -1},
-                "north": {"eta_rho": -1},
-                "west": {"xi_rho": 0},
-            },
-            "u": {
-                "south": {"eta_rho": 0},
-                "east": {"xi_u": -1},
-                "north": {"eta_rho": -1},
-                "west": {"xi_u": 0},
-            },
-            "v": {
-                "south": {"eta_v": 0},
-                "east": {"xi_rho": -1},
-                "north": {"eta_v": -1},
-                "west": {"xi_rho": 0},
-            },
-            "vector": {
-                "south": {"eta_rho": [0, 1]},
-                "east": {"xi_rho": [-2, -1]},
-                "north": {"eta_rho": [-2, -1]},
-                "west": {"xi_rho": [0, 1]},
-            },
-        }
+        bdry_coords = get_boundary_coords()
 
         object.__setattr__(self, "bdry_coords", bdry_coords)
 
@@ -728,8 +710,7 @@ class BoundaryForcing:
         variable in the dataset.
         """
         for var_name in self.variable_info:
-            # only validate variables based on "validate" flag if use_dask is false
-            if not self.use_dask or self.variable_info[var_name]["validate"]:
+            if self.variable_info[var_name]["validate"]:
                 location = self.variable_info[var_name]["location"]
 
                 # Select the appropriate mask based on variable location
@@ -980,7 +961,10 @@ class BoundaryForcing:
 
     @classmethod
     def from_yaml(
-        cls, filepath: Union[str, Path], use_dask: bool = False
+        cls,
+        filepath: Union[str, Path],
+        use_dask: bool = False,
+        bypass_validation: bool = False,
     ) -> "BoundaryForcing":
         """Create an instance of the BoundaryForcing class from a YAML file.
 
@@ -990,6 +974,10 @@ class BoundaryForcing:
             The path to the YAML file from which the parameters will be read.
         use_dask: bool, optional
             Indicates whether to use dask for processing. If True, data is processed with dask; if False, data is processed eagerly. Defaults to False.
+        bypass_validation: bool, optional
+            Indicates whether to skip validation checks in the processed data. When set to True,
+            the validation process that ensures no NaN values exist at wet points
+            in the processed dataset is bypassed. Defaults to False.
 
         Returns
         -------
@@ -1002,7 +990,9 @@ class BoundaryForcing:
         params = _from_yaml(cls, filepath)
 
         # Create and return an instance of InitialConditions
-        return cls(grid=grid, **params, use_dask=use_dask)
+        return cls(
+            grid=grid, **params, use_dask=use_dask, bypass_validation=bypass_validation
+        )
 
 
 def apply_1d_horizontal_fill(processed_fields: dict) -> dict:

roms_tools/setup/datasets.py

@@ -1369,7 +1369,7 @@ class ERA5Correction(Dataset):
 
         super().__post_init__()
 
-    def choose_subdomain(self, coords, straddle: bool):
+    def choose_subdomain(self, target_coords, straddle: bool):
         """Converts longitude values in the dataset if necessary and selects a subdomain
         based on the specified coordinates.
 
@@ -1378,7 +1378,7 @@ class ERA5Correction(Dataset):
 
         Parameters
         ----------
-        coords : dict
+        target_coords : dict
             A dictionary specifying the target coordinates for selecting the subdomain. Keys should correspond to the
             dimension names of the dataset (e.g., latitude and longitude), and values should be the desired ranges or
             specific coordinate values.
@@ -1397,32 +1397,24 @@ class ERA5Correction(Dataset):
         - The dataset (`self.ds`) is updated in place to reflect the chosen subdomain.
         """
 
-        lon = self.ds[self.dim_names["longitude"]]
-
-        if not self.is_global:
-            if lon.min().values < 0 and not straddle:
-                # Convert from [-180, 180] to [0, 360]
-                self.ds[self.dim_names["longitude"]] = xr.where(lon < 0, lon + 360, lon)
+        # Select the subdomain in latitude direction (so that we have to concatenate fewer latitudes below if concatenation is performed)
+        subdomain = self.ds.sel({self.dim_names["latitude"]: target_coords["lat"]})
 
-            if lon.max().values > 180 and straddle:
-                # Convert from [0, 360] to [-180, 180]
-                self.ds[self.dim_names["longitude"]] = xr.where(
-                    lon > 180, lon - 360, lon
-                )
+        if self.is_global:
+            # Always concatenate because computational overhead should be managable for 1/4 degree ERA5 resolution
+            subdomain = self.concatenate_longitudes(
+                subdomain, end="both", verbose=False
+            )
 
-        # Select the subdomain based on the specified latitude and longitude ranges
-        subdomain = self.ds.sel(**coords)
+        # Select the subdomain in longitude direction
+        subdomain = subdomain.sel({self.dim_names["longitude"]: target_coords["lon"]})
 
         # Check if the selected subdomain contains the specified latitude and longitude values
-        if not subdomain[self.dim_names["latitude"]].equals(
-            coords[self.dim_names["latitude"]]
-        ):
+        if not subdomain[self.dim_names["latitude"]].equals(target_coords["lat"]):
             raise ValueError(
                 "The correction dataset does not contain all specified latitude values."
             )
-        if not subdomain[self.dim_names["longitude"]].equals(
-            coords[self.dim_names["longitude"]]
-        ):
+        if not subdomain[self.dim_names["longitude"]].equals(target_coords["lon"]):
             raise ValueError(
                 "The correction dataset does not contain all specified longitude values."
             )
@@ -2060,6 +2052,12 @@ def _load_data(filename, dim_names, use_dask, decode_times=True):
             **combine_kwargs,
             **kwargs,
         )
+
+        # Rechunk the dataset along the tidal constituent dimension ("ntides") after loading
+        # because the original dataset does not have a chunk size of 1 along this dimension.
+        if "ntides" in dim_names:
+            ds = ds.chunk({dim_names["ntides"]: 1})
+
     else:
         ds_list = []
         for file in matching_files: