roms-tools 2.4.0__py3-none-any.whl → 2.5.0__py3-none-any.whl

roms_tools/__init__.py

@@ -14,7 +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
+from roms_tools.setup.nesting import ChildGrid  # noqa: F401
 from roms_tools.tiling.partition import partition_netcdf  # noqa: F401
 from roms_tools.analysis.roms_output import ROMSOutput  # noqa: F401
 

roms_tools/analysis/roms_output.py

@@ -5,7 +5,6 @@ from roms_tools.utils import _load_data
 from dataclasses import dataclass, field
 from typing import Union, Optional
 from pathlib import Path
-import os
 import re
 import logging
 from datetime import datetime, timedelta
@@ -25,34 +24,25 @@ class ROMSOutput:
     grid : Grid
         Object representing the grid information.
     path : Union[str, Path, List[Union[str, Path]]]
-        Directory, filename, or list of filenames with model output.
-    type : str
-        Specifies the type of model output. Options are:
-
-          - "restart": for restart files.
-          - "average": for time-averaged files.
-          - "snapshot": for snapshot files.
-
+        Filename, or list of filenames with model output.
     model_reference_date : datetime, optional
         If not specified, this is inferred from metadata of the model output
         If specified and does not coincide with metadata, a warning is raised.
+    adjust_depth_for_sea_surface_height : bool, optional
+        Whether to account for sea surface height variations when computing depth coordinates.
+        Defaults to `False`.
     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.
     """
 
     grid: Grid
     path: Union[str, Path]
-    type: Union[str, Path]
     use_dask: bool = False
     model_reference_date: Optional[datetime] = None
+    adjust_depth_for_sea_surface_height: Optional[bool] = False
     ds: xr.Dataset = field(init=False, repr=False)
 
     def __post_init__(self):
-        # Validate `type`
-        if self.type not in {"restart", "average", "snapshot"}:
-            raise ValueError(
-                f"Invalid type '{self.type}'. Must be one of 'restart', 'average', or 'snapshot'."
-            )
 
         ds = self._load_model_output()
         self._infer_model_reference_date_from_metadata(ds)
@@ -61,6 +51,9 @@ class ROMSOutput:
         ds = self._add_lat_lon_coords(ds)
         object.__setattr__(self, "ds", ds)
 
+        # Dataset for depth coordinates
+        object.__setattr__(self, "ds_depth_coords", xr.Dataset())
+
     def plot(
         self,
         var_name,
@@ -68,6 +61,7 @@ class ROMSOutput:
         s=None,
         eta=None,
         xi=None,
+        include_boundary=False,
         depth_contours=False,
         layer_contours=False,
         ax=None,
@@ -94,6 +88,11 @@ class ROMSOutput:
         xi : int, optional
             The xi-index to plot. Used for vertical sections or horizontal slices.
             Default is None.
+        include_boundary : bool, optional
+            Whether to include the outermost grid cells along the `eta`- and `xi`-boundaries in the plot.
+            In diagnostic ROMS output fields, these boundary cells are set to zero, so excluding them can improve visualization.
+            This option is only relevant for 2D horizontal plots (`eta=None`, `xi=None`).
+            Default is False.
         depth_contours : bool, optional
             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.
@@ -183,10 +182,18 @@ class ROMSOutput:
         compute_layer_depth = (depth_contours or s is None) and len(field.dims) > 2
         compute_interface_depth = layer_contours and s is None
 
+        # Compute depth coordinates directly instead of using .ds_depth_coords.
+        # Many cases below require only a 1D or 2D slice, making direct computation
+        # more efficient than triggering a full 3D depth computation just to extract a subset.
+        # This is especially beneficial when using Dask or if .ds_depth_coords is precomputed.
+        if self.adjust_depth_for_sea_surface_height:
+            zeta = self.ds.zeta.isel(time=time)
+        else:
+            zeta = 0
         if compute_layer_depth:
             layer_depth = compute_depth_coordinates(
                 self.grid.ds,
-                self.ds.zeta.isel(time=time),
+                zeta,
                 depth_type="layer",
                 location=loc,
                 eta=eta,
@@ -197,7 +204,7 @@ class ROMSOutput:
         if compute_interface_depth:
             interface_depth = compute_depth_coordinates(
                 self.grid.ds,
-                self.ds.zeta.isel(time=time),
+                zeta,
                 depth_type="interface",
                 location=loc,
                 eta=eta,
@@ -252,6 +259,32 @@ class ROMSOutput:
         if compute_layer_depth:
             field = field.assign_coords({"layer_depth": layer_depth})
 
+        if not include_boundary:
+            slice_dict = None
+
+            if eta is None and xi is None:
+                slice_dict = {
+                    "rho": {"eta_rho": slice(1, -1), "xi_rho": slice(1, -1)},
+                    "u": {"eta_rho": slice(1, -1), "xi_u": slice(1, -1)},
+                    "v": {"eta_v": slice(1, -1), "xi_rho": slice(1, -1)},
+                }
+            elif eta is None:
+                slice_dict = {
+                    "rho": {"eta_rho": slice(1, -1)},
+                    "u": {"eta_rho": slice(1, -1)},
+                    "v": {"eta_v": slice(1, -1)},
+                }
+            elif xi is None:
+                slice_dict = {
+                    "rho": {"xi_rho": slice(1, -1)},
+                    "u": {"xi_u": slice(1, -1)},
+                    "v": {"xi_rho": slice(1, -1)},
+                }
+            if slice_dict is not None:
+                if loc in slice_dict:
+                    field = field.isel(**slice_dict[loc])
+                    mask = mask.isel(**slice_dict[loc])
+
         # Choose colorbar
         if var_name in ["u", "v", "w", "ubar", "vbar", "zeta"]:
             vmax = max(field.where(mask).max().values, -field.where(mask).min().values)
@@ -300,8 +333,8 @@ class ROMSOutput:
                 else:
                     _line_plot(field.where(mask), title=title, ax=ax)
 
-    def compute_depth_coordinates(self, depth_type="layer", locations=["rho"]):
-        """Compute and update vertical depth coordinates.
+    def _get_depth_coordinates(self, depth_type="layer", locations=["rho"]):
+        """Ensure depth coordinates are stored for a given location and depth type.
 
         Calculates vertical depth coordinates (layer or interface) for specified locations (e.g., rho, u, v points)
         and updates them in the dataset (`self.ds`).
@@ -321,61 +354,44 @@ class ROMSOutput:
 
         Updates
         -------
-        self.ds : xarray.Dataset
-            The dataset (`self.ds`) is updated with the following depth coordinate variables:
-            - f"{depth_type}_depth_rho": Depth coordinates at rho points.
-            - f"{depth_type}_depth_u": Depth coordinates at u points (if included in `locations`).
-            - f"{depth_type}_depth_v": Depth coordinates at v points (if included in `locations`).
+        self.ds_depth_coords : xarray.Dataset
+
+        Raises
+        ------
+        ValueError
+            If `adjust_depth_for_sea_surface_height` is enabled but `zeta` is missing from `self.ds`.
 
         Notes
         -----
-        This method uses the `compute_and_update_depth_coordinates` function to perform calculations and updates.
+        - This method relies on the `compute_depth_coordinates` function to perform calculations.
+        - If `adjust_depth_for_sea_surface_height` is `True`, the method accounts for variations
+          in sea surface height (`zeta`).
         """
 
-        for location in locations:
-            self.ds[f"{depth_type}_depth_{location}"] = compute_depth_coordinates(
-                self.grid.ds, self.ds.zeta, depth_type, location
-            )
-
-    def _load_model_output(self) -> xr.Dataset:
-        """Load the model output based on the type."""
-        if isinstance(self.path, list):
-            filetype = "list"
-            force_combine_nested = True
-            # Check if all items in the list are files
-            if not all(Path(item).is_file() for item in self.path):
-                raise FileNotFoundError(
-                    "All items in the provided list must be valid files."
+        if self.adjust_depth_for_sea_surface_height:
+            if "zeta" not in self.ds:
+                raise ValueError(
+                    "`zeta` is required in provided ROMS output when `adjust_depth_for_sea_surface_height` is enabled."
                 )
-        elif Path(self.path).is_file():
-            filetype = "file"
-            force_combine_nested = False
-        elif Path(self.path).is_dir():
-            filetype = "dir"
-            force_combine_nested = True
+            zeta = self.ds.zeta
         else:
-            raise FileNotFoundError(
-                f"The specified path '{self.path}' is neither a file, nor a list of files, nor a directory."
-            )
+            zeta = 0
 
-        time_chunking = True
-        if self.type == "restart":
-            time_chunking = False
-            filename = _validate_and_set_filenames(self.path, filetype, "rst")
-        elif self.type == "average":
-            filename = _validate_and_set_filenames(self.path, filetype, "avg")
-        elif self.type == "snapshot":
-            filename = _validate_and_set_filenames(self.path, filetype, "his")
-        else:
-            raise ValueError(f"Unsupported type '{self.type}'.")
+        for location in locations:
+            self.ds_depth_coords[
+                f"{depth_type}_depth_{location}"
+            ] = compute_depth_coordinates(self.grid.ds, zeta, depth_type, location)
+
+    def _load_model_output(self) -> xr.Dataset:
+        """Load the model output."""
 
         # Load the dataset
         ds = _load_data(
-            filename,
+            self.path,
             dim_names={"time": "time"},
             use_dask=self.use_dask,
-            time_chunking=time_chunking,
-            force_combine_nested=force_combine_nested,
+            time_chunking=True,
+            force_combine_nested=True,
         )
 
         return ds
@@ -551,40 +567,3 @@ class ROMSOutput:
         )
 
         return ds
-
-
-def _validate_and_set_filenames(
-    filenames: Union[str, list], filetype: str, string: str
-) -> Union[str, list]:
-    """Validates and adjusts the filename or list of filenames based on the specified
-    type and checks for the presence of a string in the filename.
-
-    Parameters
-    ----------
-    filenames : Union[str, list]
-        A single filename (str), a list of filenames, or a directory path.
-    filetype : str
-        The type of input: 'file' for a single file, 'list' for a list of files, or 'dir' for a directory.
-    string : str
-        The string that should be present in each filename.
-
-    Returns
-    -------
-    Union[str, list]
-        The validated filename(s). If a directory is provided, the function returns the adjusted file pattern.
-    """
-    if filetype == "file":
-        if string not in os.path.basename(filenames):
-            logging.warning(
-                f"The file '{filenames}' does not appear to contain '{string}' in the name."
-            )
-    elif filetype == "list":
-        for file in filenames:
-            if string not in os.path.basename(file):
-                logging.warning(
-                    f"The file '{file}' does not appear to contain '{string}' in the name."
-                )
-    elif filetype == "dir":
-        filenames = os.path.join(filenames, f"*{string}.*.nc")
-
-    return filenames

roms_tools/plot.py

@@ -19,8 +19,8 @@ def _plot(
 
     Parameters
     ----------
-    field : xarray.DataArray, optional
-        The field to plot. If None, only the grid is plotted.
+    field : xarray.DataArray
+        The field to plot.
     depth_contours : bool, optional
         If True, adds depth contours to the plot.
     c : str, optional
@@ -284,6 +284,7 @@ def _section_plot(field, interface_depth=None, title="", kwargs={}, ax=None):
             )
 
     ax.set_title(title)
+    ax.set_ylabel("Depth [m]")
 
 
 def _profile_plot(field, title="", ax=None):
@@ -324,6 +325,7 @@ def _profile_plot(field, title="", ax=None):
     kwargs = {"y": depth_label, "yincrease": False}
     field.plot(**kwargs)
     ax.set_title(title)
+    ax.set_ylabel("Depth [m]")
     ax.grid()
 
 

roms_tools/setup/boundary_forcing.py

@@ -3,7 +3,7 @@ import numpy as np
 from scipy.ndimage import label
 import logging
 import importlib.metadata
-from typing import Dict, Union, List
+from typing import Dict, Union, List, Optional
 from dataclasses import dataclass, field
 from datetime import datetime
 import matplotlib.pyplot as plt
@@ -43,10 +43,14 @@ class BoundaryForcing:
     ----------
     grid : Grid
         Object representing the grid information.
-    start_time : datetime
-        Start time of the desired boundary forcing data.
-    end_time : datetime
-        End time of the desired boundary forcing data.
+    start_time : datetime, optional
+        The start time of the desired surface forcing data. This time is used to filter the dataset
+        to include only records on or after this time, with a single record at or before this time.
+        If no time filtering is desired, set it to None. Default is None.
+    end_time : datetime, optional
+        The end time of the desired surface forcing data. This time is used to filter the dataset
+        to include only records on or before this time, with a single record at or after this time.
+        If no time filtering is desired, set it to None. Default is None.
     boundaries : Dict[str, bool], optional
         Dictionary specifying which boundaries are forced (south, east, north, west). Default is all True.
     source : Dict[str, Union[str, Path, List[Union[str, Path]]], bool]
@@ -96,8 +100,8 @@ class BoundaryForcing:
     """
 
     grid: Grid
-    start_time: datetime
-    end_time: datetime
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
     boundaries: Dict[str, bool] = field(
         default_factory=lambda: {
             "south": True,
@@ -127,10 +131,13 @@ class BoundaryForcing:
         data = self._get_data()
 
         if self.apply_2d_horizontal_fill:
+
             data.choose_subdomain(
                 target_coords,
                 buffer_points=20,  # lateral fill needs good buffer from data margin
             )
+            # Enforce double precision to ensure reproducibility
+            data.convert_to_float64()
             data.extrapolate_deepest_to_bottom()
             data.apply_lateral_fill()
 
@@ -158,6 +165,8 @@ class BoundaryForcing:
                 )
 
                 if not self.apply_2d_horizontal_fill:
+                    # Enforce double precision to ensure reproducibility
+                    bdry_data.convert_to_float64()
                     bdry_data.extrapolate_deepest_to_bottom()
 
                 processed_fields = {}
@@ -329,6 +338,18 @@ class BoundaryForcing:
         object.__setattr__(self, "ds", ds)
 
     def _input_checks(self):
+        # Check that start_time and end_time are both None or none of them is
+        if (self.start_time is None) != (self.end_time is None):
+            raise ValueError(
+                "Both `start_time` and `end_time` must be provided together as datetime objects or both should be None."
+            )
+
+        # Trigger a warning if both are None
+        if self.start_time is None and self.end_time is None:
+            logging.warning(
+                "Both `start_time` and `end_time` are None. No time filtering will be applied to the source data."
+            )
+
         # Validate the 'type' parameter
         if self.type not in ["physics", "bgc"]:
             raise ValueError("`type` must be either 'physics' or 'bgc'.")
@@ -967,7 +988,6 @@ class BoundaryForcing:
         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.
 
@@ -977,10 +997,6 @@ 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
         -------
@@ -993,9 +1009,7 @@ class BoundaryForcing:
         params = _from_yaml(cls, filepath)
 
         # Create and return an instance of InitialConditions
-        return cls(
-            grid=grid, **params, use_dask=use_dask, bypass_validation=bypass_validation
-        )
+        return cls(grid=grid, **params, use_dask=use_dask)
 
 
 def apply_1d_horizontal_fill(data_array: xr.DataArray) -> xr.DataArray:

roms_tools/setup/datasets.py

@@ -35,10 +35,11 @@ class Dataset:
         The path to the data file(s). Can be a single string (with or without wildcards), a single Path object,
         or a list of strings or Path objects containing multiple files.
     start_time : Optional[datetime], optional
-        The start time for selecting relevant data. If not provided, the data is not filtered by start time.
+        Start time for selecting relevant data. If not provided, no time-based filtering is applied.
     end_time : Optional[datetime], optional
-        The end time for selecting relevant data. If not provided, only data at the start_time is selected if start_time is provided,
-        or no filtering is applied if start_time is not provided.
+        End time for selecting relevant data. If not provided, the dataset selects the time entry
+        closest to `start_time` within the range `[start_time, start_time + 24 hours]`.
+        If `start_time` is also not provided, no time-based filtering is applied.
     dim_names: Dict[str, str], optional
         Dictionary specifying the names of dimensions in the dataset.
     var_names: Dict[str, str]
@@ -510,6 +511,25 @@ class Dataset:
         """
         pass
 
+    def convert_to_float64(self) -> None:
+        """Convert all data variables in the dataset to float64.
+
+        This method updates the dataset by converting all of its data variables to the
+        `float64` data type, ensuring consistency for numerical operations that require
+        high precision. The dataset is modified in place.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method modifies the dataset in place and does not return anything.
+        """
+        ds = self.ds.astype({var: "float64" for var in self.ds.data_vars})
+        object.__setattr__(self, "ds", ds)
+
     def choose_subdomain(
         self,
         target_coords,
@@ -1843,15 +1863,10 @@ class RiverDataset:
 
         Returns
         -------
-        indices : dict
+        indices : dict[str, list[tuple]]
             A dictionary containing the indices of the rivers that are within the threshold distance from
-            the target coordinates. The dictionary keys are:
-            - "station" : numpy.ndarray
-                The indices of the rivers that satisfy the distance threshold.
-            - "eta_rho" : numpy.ndarray
-                The indices of the `eta_rho` dimension corresponding to the selected stations.
-            - "xi_rho" : numpy.ndarray
-                The indices of the `xi_rho` dimension corresponding to the selected stations.
+            the target coordinates. The dictionary structure consists of river names as keys, and each value is a list of tuples. Each tuple represents
+            a pair of indices corresponding to the `eta_rho` and `xi_rho` grid coordinates of the river.
         """
 
         # Retrieve longitude and latitude of river mouths
@@ -1878,30 +1893,75 @@ class RiverDataset:
 
             # Find the indices of the closest grid cell to the river mouth
             indices = np.where(dist == dist_min)
+            stations = indices[0]
+            eta_rho_values = indices[1]
+            xi_rho_values = indices[2]
             names = (
-                self.ds[self.var_names["name"]]
-                .isel({self.dim_names["station"]: indices[0]})
+                ds[self.var_names["name"]]
+                .isel({self.dim_names["station"]: stations})
                 .values
             )
-            # Return the indices in a dictionary format
-            indices = {
-                "station": indices[0],
-                "eta_rho": indices[1],
-                "xi_rho": indices[2],
-                "name": names,
-            }
+            river_indices = {}
+            for i in range(len(stations)):
+                river_name = names[i]
+                river_indices[river_name] = [
+                    (int(eta_rho_values[i]), int(xi_rho_values[i]))
+                ]  # list of tuples
         else:
             ds = xr.Dataset()
-            indices = {
-                "station": [],
-                "eta_rho": [],
-                "xi_rho": [],
-                "name": [],
-            }
+            river_indices = {}
 
         object.__setattr__(self, "ds", ds)
 
-        return indices
+        return river_indices
+
+    def extract_named_rivers(self, indices):
+        """Extracts a subset of the dataset based on the provided river names in the
+        indices dictionary.
+
+        This method filters the dataset to include only the rivers specified in the `indices` dictionary.
+        The resulting subset is stored in the `ds` attribute of the class.
+
+        Parameters
+        ----------
+        indices : dict
+            A dictionary where the keys are river names (strings) and the values are dictionaries
+            containing river-related data (e.g., river indices, coordinates).
+
+        Returns
+        -------
+        None
+            The method modifies the `self.ds` attribute in place, setting it to the filtered dataset
+            containing only the data related to the specified rivers.
+
+        Raises
+        ------
+        ValueError
+            - If `indices` is not a dictionary.
+            - If any of the requested river names are not found in the dataset.
+        """
+
+        if not isinstance(indices, dict):
+            raise ValueError("`indices` must be a dictionary.")
+
+        river_names = list(indices.keys())
+
+        # Ensure the dataset is filtered based on the provided river names
+        ds_filtered = self.ds.where(
+            self.ds[self.var_names["name"]].isin(river_names), drop=True
+        )
+
+        # Check that all requested rivers exist in the dataset
+        filtered_river_names = set(ds_filtered[self.var_names["name"]].values)
+        missing_rivers = set(river_names) - filtered_river_names
+
+        if missing_rivers:
+            raise ValueError(
+                f"The following rivers were not found in the dataset: {missing_rivers}"
+            )
+
+        # Set the filtered dataset as the new `ds`
+        object.__setattr__(self, "ds", ds_filtered)
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -2050,7 +2110,7 @@ def _check_dataset(
 
 
 def _select_relevant_times(
-    ds, time_dim, start_time=None, end_time=None, climatology=False
+    ds, time_dim, start_time, end_time=None, climatology=False
 ) -> xr.Dataset:
     """Select a subset of the dataset based on the specified time range.
 
@@ -2067,11 +2127,10 @@ def _select_relevant_times(
         The input dataset to be filtered. Must contain a time dimension.
     time_dim: str
         Name of time dimension.
-    start_time : Optional[datetime], optional
-        The start time for selecting relevant data. If not provided, the data is not filtered by start time.
+    start_time : datetime
+        The start time for selecting relevant data.
     end_time : Optional[datetime], optional
-        The end time for selecting relevant data. If not provided, only data at the start_time is selected if start_time is provided,
-        or no filtering is applied if start_time is not provided.
+        The end time for selecting relevant data. If not provided, only data at the start_time is selected if start_time is provided.
     climatology : bool
         Indicates whether the dataset is climatological. Defaults to False.
 

roms_tools/setup/grid.py

@@ -18,6 +18,7 @@ from roms_tools.setup.utils import (
     interpolate_from_rho_to_v,
     get_target_coords,
     gc_dist,
+    _pop_grid_data,
 )
 from roms_tools.setup.utils import extract_single_value
 from pathlib import Path
@@ -112,7 +113,7 @@ class Grid:
         # Coarsen the dataset if needed
         self._coarsen()
 
-        # Topography and mask
+        # Topography
         self.update_topography(
             topography_source=self.topography_source,
             hmin=self.hmin,
@@ -205,7 +206,7 @@ class Grid:
                 f"=== Generating the topography using {topography_source['name']} data and hmin = {hmin} meters ==="
             )
 
-        # Add topography and mask to the dataset
+        # Add topography to the dataset
         ds = _add_topography(
             ds=self.ds,
             target_coords=target_coords,
@@ -688,9 +689,7 @@ class Grid:
         filepath = Path(filepath)
 
         data = asdict(self)
-        data.pop("ds", None)
-        data.pop("straddle", None)
-        data.pop("verbose", None)
+        data = _pop_grid_data(data)
 
         # Include the version of roms-tools
         try:

roms_tools/setup/initial_conditions.py

@@ -150,6 +150,8 @@ class InitialConditions:
             target_coords,
             buffer_points=20,  # lateral fill needs good buffer from data margin
         )
+        # Enforce double precision to ensure reproducibility
+        data.convert_to_float64()
         data.extrapolate_deepest_to_bottom()
         data.apply_lateral_fill()
 
@@ -234,6 +236,11 @@ class InitialConditions:
         return processed_fields
 
     def _input_checks(self):
+        # Check that ini_time is not None
+        if self.ini_time is None:
+            raise ValueError(
+                "`ini_time` must be a valid datetime object and cannot be None."
+            )
 
         if "name" not in self.source.keys():
             raise ValueError("`source` must include a 'name'.")
@@ -898,7 +905,6 @@ class InitialConditions:
         cls,
         filepath: Union[str, Path],
         use_dask: bool = False,
-        bypass_validation: bool = False,
     ) -> "InitialConditions":
         """Create an instance of the InitialConditions class from a YAML file.
 
@@ -908,10 +914,6 @@ class InitialConditions:
             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
         -------
@@ -926,5 +928,4 @@ class InitialConditions:
             grid=grid,
             **initial_conditions_params,
             use_dask=use_dask,
-            bypass_validation=bypass_validation,
         )