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

roms_tools/setup/atmospheric_forcing.py

@@ -1,191 +1,19 @@
 import xarray as xr
 import dask
-from dataclasses import dataclass, field
+import yaml
+import importlib.metadata
+from dataclasses import dataclass, field, asdict
 from roms_tools.setup.grid import Grid
 from datetime import datetime
 import glob
 import numpy as np
 from typing import Optional, Dict
-from roms_tools.setup.fill import lateral_fill
+from roms_tools.setup.fill import fill_and_interpolate
+from roms_tools.setup.datasets import Dataset
+from roms_tools.setup.utils import nan_check
+from roms_tools.setup.plot import _plot
 import calendar
-
-
-@dataclass(frozen=True, kw_only=True)
-class ForcingDataset:
-    """
-    Represents forcing data on original grid.
-
-    Parameters
-    ----------
-    filename : str
-        The path to the data files. Can contain wildcards.
-    start_time: datetime
-        The start time for selecting relevant data.
-    end_time: datetime
-        The end time for selecting relevant data.
-    dim_names: Dict[str, str], optional
-        Dictionary specifying the names of dimensions in the dataset.
-
-    Attributes
-    ----------
-    ds : xr.Dataset
-        The xarray Dataset containing the forcing data on its original grid.
-
-    Examples
-    --------
-    >>> dataset = ForcingDataset(
-    ...     filename="data.nc",
-    ...     start_time=datetime(2022, 1, 1),
-    ...     end_time=datetime(2022, 12, 31),
-    ... )
-    >>> dataset.load_data()
-    >>> print(dataset.ds)
-    <xarray.Dataset>
-    Dimensions:  ...
-    """
-
-    filename: str
-    start_time: datetime
-    end_time: datetime
-    dim_names: Dict[str, str] = field(
-        default_factory=lambda: {"longitude": "lon", "latitude": "lat", "time": "time"}
-    )
-
-    ds: xr.Dataset = field(init=False, repr=False)
-
-    def __post_init__(self):
-
-        ds = self.load_data()
-
-        # Select relevant times
-        times = (np.datetime64(self.start_time) < ds[self.dim_names["time"]]) & (
-            ds[self.dim_names["time"]] < np.datetime64(self.end_time)
-        )
-        ds = ds.where(times, drop=True)
-
-        # Make sure that latitude is ascending
-        diff = np.diff(ds[self.dim_names["latitude"]])
-        if np.all(diff < 0):
-            ds = ds.isel(**{self.dim_names["latitude"]: slice(None, None, -1)})
-
-        object.__setattr__(self, "ds", ds)
-
-    def load_data(self) -> xr.Dataset:
-        """
-        Load dataset from the specified file.
-
-        Returns
-        -------
-        ds : xr.Dataset
-            The loaded xarray Dataset containing the forcing data.
-
-        Raises
-        ------
-        FileNotFoundError
-            If the specified file does not exist.
-        """
-
-        # Check if the file exists
-        matching_files = glob.glob(self.filename)
-        if not matching_files:
-            raise FileNotFoundError(
-                f"No files found matching the pattern '{self.filename}'."
-            )
-
-        # Load the dataset
-        with dask.config.set(**{"array.slicing.split_large_chunks": False}):
-            # initially, we wawnt time chunk size of 1 to enable quick .nan_check() and .plot() methods for AtmosphericForcing
-            ds = xr.open_mfdataset(
-                self.filename,
-                combine="nested",
-                concat_dim=self.dim_names["time"],
-                coords="minimal",
-                compat="override",
-                chunks={self.dim_names["time"]: 1},
-            )
-
-        return ds
-
-    def choose_subdomain(self, latitude_range, longitude_range, margin, straddle):
-        """
-        Selects a subdomain from the given xarray Dataset based on latitude and longitude ranges,
-        extending the selection by the specified margin. Handles the conversion of longitude values
-        in the dataset from one range to another.
-
-        Parameters
-        ----------
-        latitude_range : tuple
-            A tuple (lat_min, lat_max) specifying the minimum and maximum latitude values of the subdomain.
-        longitude_range : tuple
-            A tuple (lon_min, lon_max) specifying the minimum and maximum longitude values of the subdomain.
-        margin : float
-            Margin in degrees to extend beyond the specified latitude and longitude ranges when selecting the subdomain.
-        straddle : bool
-            If True, target longitudes are expected in the range [-180, 180].
-            If False, target longitudes are expected in the range [0, 360].
-
-        Returns
-        -------
-        xr.Dataset
-            The subset of the original dataset representing the chosen subdomain, including an extended area
-            to cover one extra grid point beyond the specified ranges.
-
-        Raises
-        ------
-        ValueError
-            If the selected latitude or longitude range does not intersect with the dataset.
-        """
-        lat_min, lat_max = latitude_range
-        lon_min, lon_max = longitude_range
-
-        lon = self.ds[self.dim_names["longitude"]]
-        # Adjust longitude range if needed to match the expected range
-        if not straddle:
-            if lon.min() < -180:
-                if lon_max + margin > 0:
-                    lon_min -= 360
-                    lon_max -= 360
-            elif lon.min() < 0:
-                if lon_max + margin > 180:
-                    lon_min -= 360
-                    lon_max -= 360
-
-        if straddle:
-            if lon.max() > 360:
-                if lon_min - margin < 180:
-                    lon_min += 360
-                    lon_max += 360
-            elif lon.max() > 180:
-                if lon_min - margin < 0:
-                    lon_min += 360
-                    lon_max += 360
-
-        # Select the subdomain
-        subdomain = self.ds.sel(
-            **{
-                self.dim_names["latitude"]: slice(lat_min - margin, lat_max + margin),
-                self.dim_names["longitude"]: slice(lon_min - margin, lon_max + margin),
-            }
-        )
-
-        # Check if the selected subdomain has zero dimensions in latitude or longitude
-        if subdomain[self.dim_names["latitude"]].size == 0:
-            raise ValueError("Selected latitude range does not intersect with dataset.")
-
-        if subdomain[self.dim_names["longitude"]].size == 0:
-            raise ValueError(
-                "Selected longitude range does not intersect with dataset."
-            )
-
-        # Adjust longitudes to expected range if needed
-        lon = subdomain[self.dim_names["longitude"]]
-        if straddle:
-            subdomain[self.dim_names["longitude"]] = xr.where(lon > 180, lon - 360, lon)
-        else:
-            subdomain[self.dim_names["longitude"]] = xr.where(lon < 0, lon + 360, lon)
-
-        # Set the modified subdomain to the object attribute
-        object.__setattr__(self, "ds", subdomain)
+import matplotlib.pyplot as plt
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -445,6 +273,43 @@ class SWRCorrection:
 
         return field_interpolated
 
+    @classmethod
+    def from_yaml(cls, filepath: str) -> "SWRCorrection":
+        """
+        Create an instance of the class from a YAML file.
+
+        Parameters
+        ----------
+        filepath : str
+            The path to the YAML file from which the parameters will be read.
+
+        Returns
+        -------
+        Grid
+            An instance of the Grid 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))
+
+        swr_correction_data = None
+
+        # Iterate over documents to find the header and grid configuration
+        for doc in documents:
+            if doc is None:
+                continue
+            if "SWRCorrection" in doc:
+                swr_correction_data = doc["SWRCorrection"]
+                break
+
+        if swr_correction_data is None:
+            raise ValueError("No SWRCorrection configuration found in the YAML file.")
+
+        return cls(**swr_correction_data)
+
 
 @dataclass(frozen=True, kw_only=True)
 class Rivers:
@@ -463,6 +328,43 @@ class Rivers:
         if not self.filename:
             raise ValueError("The 'filename' must be provided.")
 
+    @classmethod
+    def from_yaml(cls, filepath: str) -> "Rivers":
+        """
+        Create an instance of the class from a YAML file.
+
+        Parameters
+        ----------
+        filepath : str
+            The path to the YAML file from which the parameters will be read.
+
+        Returns
+        -------
+        Grid
+            An instance of the Grid 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))
+
+        rivers_data = None
+
+        # Iterate over documents to find the header and grid configuration
+        for doc in documents:
+            if doc is None:
+                continue
+            if "Rivers" in doc:
+                rivers_data = doc
+                break
+
+        if rivers_data is None:
+            raise ValueError("No Rivers configuration found in the YAML file.")
+
+        return cls(**rivers_data)
+
 
 @dataclass(frozen=True, kw_only=True)
 class AtmosphericForcing:
@@ -482,7 +384,7 @@ class AtmosphericForcing:
     model_reference_date : datetime, optional
         Reference date for the model. Default is January 1, 2000.
     source : str, optional
-        Source of the atmospheric forcing data. Default is "era5".
+        Source of the atmospheric forcing data. Default is "ERA5".
     filename: str
         Path to the atmospheric forcing source data file. Can contain wildcards.
     swr_correction : SWRCorrection
@@ -495,10 +397,6 @@ class AtmosphericForcing:
     ds : xr.Dataset
         Xarray Dataset containing the atmospheric forcing data.
 
-    Notes
-    -----
-    This class represents atmospheric forcing data used in ocean modeling. It provides a convenient
-    interface to work with forcing data including shortwave radiation correction and river forcing.
 
     Examples
     --------
@@ -509,7 +407,7 @@ class AtmosphericForcing:
     ...     grid=grid_info,
     ...     start_time=start_time,
     ...     end_time=end_time,
-    ...     source="era5",
+    ...     source="ERA5",
     ...     filename="atmospheric_data_*.nc",
     ...     swr_correction=swr_correction,
     ... )
@@ -520,7 +418,7 @@ class AtmosphericForcing:
     start_time: datetime
     end_time: datetime
     model_reference_date: datetime = datetime(2000, 1, 1)
-    source: str = "era5"
+    source: str = "ERA5"
     filename: str
     swr_correction: Optional["SWRCorrection"] = None
     rivers: Optional["Rivers"] = None
@@ -528,6 +426,30 @@ class AtmosphericForcing:
 
     def __post_init__(self):
 
+        # Check that the source is "ERA5"
+        if self.source != "ERA5":
+            raise ValueError('Only "ERA5" is a valid option for source.')
+        if self.source == "ERA5":
+            dims = {"longitude": "longitude", "latitude": "latitude", "time": "time"}
+            varnames = {
+                "u10": "u10",
+                "v10": "v10",
+                "swr": "ssr",
+                "lwr": "strd",
+                "t2m": "t2m",
+                "d2m": "d2m",
+                "rain": "tp",
+                "mask": "sst",
+            }
+
+        data = Dataset(
+            filename=self.filename,
+            start_time=self.start_time,
+            end_time=self.end_time,
+            var_names=varnames.values(),
+            dim_names=dims,
+        )
+
         if self.use_coarse_grid:
             if "lon_coarse" not in self.grid.ds:
                 raise ValueError(
@@ -542,16 +464,6 @@ class AtmosphericForcing:
             lat = self.grid.ds.lat_rho
             angle = self.grid.ds.angle
 
-        if self.source == "era5":
-            dims = {"longitude": "longitude", "latitude": "latitude", "time": "time"}
-
-        data = ForcingDataset(
-            filename=self.filename,
-            start_time=self.start_time,
-            end_time=self.end_time,
-            dim_names=dims,
-        )
-
         # operate on longitudes between -180 and 180 unless ROMS domain lies at least 5 degrees in lontitude away from Greenwich meridian
         lon = xr.where(lon > 180, lon - 360, lon)
         straddle = True
@@ -559,9 +471,12 @@ class AtmosphericForcing:
             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.
-        # Step 1 is necessary to avoid discontinuous longitudes that could be introduced by Step 2.
-        # Discontinuous longitudes can lead to artifacts in the interpolation process. Specifically, if there is a data gap,
+        # 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(
@@ -572,42 +487,33 @@ class AtmosphericForcing:
         )
 
         # interpolate onto desired grid
-        if self.source == "era5":
-            mask = xr.where(data.ds["sst"].isel(time=0).isnull(), 0, 1)
-            varnames = {
-                "u10": "u10",
-                "v10": "v10",
-                "swr": "ssr",
-                "lwr": "strd",
-                "t2m": "t2m",
-                "d2m": "d2m",
-                "rain": "tp",
-            }
-
         coords = {dims["latitude"]: lat, dims["longitude"]: lon}
-        u10 = self._interpolate(
-            data.ds[varnames["u10"]], mask, coords=coords, method="linear"
-        )
-        v10 = self._interpolate(
-            data.ds[varnames["v10"]], mask, coords=coords, method="linear"
-        )
-        swr = self._interpolate(
-            data.ds[varnames["swr"]], mask, coords=coords, method="linear"
-        )
-        lwr = self._interpolate(
-            data.ds[varnames["lwr"]], mask, coords=coords, method="linear"
-        )
-        t2m = self._interpolate(
-            data.ds[varnames["t2m"]], mask, coords=coords, method="linear"
-        )
-        d2m = self._interpolate(
-            data.ds[varnames["d2m"]], mask, coords=coords, method="linear"
-        )
-        rain = self._interpolate(
-            data.ds[varnames["rain"]], mask, coords=coords, method="linear"
-        )
 
-        if self.source == "era5":
+        data_vars = {}
+
+        mask = xr.where(data.ds[varnames["mask"]].isel(time=0).isnull(), 0, 1)
+
+        # Fill and interpolate each variable
+        for var in varnames.keys():
+            if var != "mask":
+                data_vars[var] = fill_and_interpolate(
+                    data.ds[varnames[var]],
+                    mask,
+                    list(coords.keys()),
+                    coords,
+                    method="linear",
+                )
+
+        # Access the interpolated variables using data_vars dictionary
+        u10 = data_vars["u10"]
+        v10 = data_vars["v10"]
+        swr = data_vars["swr"]
+        lwr = data_vars["lwr"]
+        t2m = data_vars["t2m"]
+        d2m = data_vars["d2m"]
+        rain = data_vars["rain"]
+
+        if self.source == "ERA5":
             # translate radiation to fluxes. ERA5 stores values integrated over 1 hour.
             swr = swr / 3600  # from J/m^2 to W/m^2
             lwr = lwr / 3600  # from J/m^2 to W/m^2
@@ -650,8 +556,12 @@ class AtmosphericForcing:
                 self.swr_correction.dim_names["latitude"]: lat,
                 self.swr_correction.dim_names["longitude"]: lon,
             }
-            corr_factor = self._interpolate(
-                corr_factor, mask, coords=coords_correction, method="linear"
+            corr_factor = fill_and_interpolate(
+                corr_factor,
+                mask,
+                list(coords_correction.keys()),
+                coords_correction,
+                method="linear",
             )
 
             # temporal interpolation
@@ -700,11 +610,22 @@ class AtmosphericForcing:
         ds["rain"].attrs["long_name"] = "Total precipitation"
         ds["rain"].attrs["units"] = "cm/day"
 
-        ds.attrs["Title"] = "ROMS bulk surface forcing file produced by roms-tools"
+        ds.attrs["title"] = "ROMS atmospheric forcing 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
+        ds.attrs["start_time"] = str(self.start_time)
+        ds.attrs["end_time"] = str(self.end_time)
+        ds.attrs["model_reference_date"] = str(self.model_reference_date)
+        ds.attrs["source"] = self.source
+        ds.attrs["use_coarse_grid"] = str(self.use_coarse_grid)
+        ds.attrs["swr_correction"] = str(self.swr_correction is not None)
+        ds.attrs["rivers"] = str(self.rivers is not None)
 
         ds = ds.assign_coords({"lon": lon, "lat": lat})
-        if dims["time"] != "time":
-            ds = ds.rename({dims["time"]: "time"})
         if self.use_coarse_grid:
             ds = ds.rename({"eta_coarse": "eta_rho", "xi_coarse": "xi_rho"})
             mask_roms = self.grid.ds["mask_coarse"].rename(
@@ -713,84 +634,28 @@ class AtmosphericForcing:
         else:
             mask_roms = self.grid.ds["mask_rho"]
 
-        object.__setattr__(self, "ds", ds)
-
-        self.nan_check(mask_roms, time=0)
-
-    @staticmethod
-    def _interpolate(field, mask, coords, method="linear"):
-        """
-        Interpolate a field using specified coordinates and a given method.
-
-        Parameters
-        ----------
-        field : xr.DataArray
-            The data array to be interpolated.
-
-        mask : xr.DataArray
-            A data array with same spatial dimensions as `field`, where `1` indicates wet (ocean)
-            points and `0` indicates land points.
-
-        coords : dict
-            A dictionary specifying the target coordinates for interpolation. The keys
-            should match the dimensions of `field` (e.g., {"longitude": lon_values, "latitude": lat_values}).
-
-        method : str, optional, default='linear'
-            The interpolation method to use. Valid options are those supported by
-            `xarray.DataArray.interp`.
-
-        Returns
-        -------
-        xr.DataArray
-            The interpolated data array.
-
-        Notes
-        -----
-        This method first sets land values to NaN based on the provided mask. It then uses the
-        `lateral_fill` function to propagate ocean values. These two steps serve the purpose to
-        avoid interpolation across the land-ocean boundary. Finally, it performs interpolation
-        over the specified coordinates.
-
-        """
-
-        dims = list(coords.keys())
-
-        # set land values to nan
-        field = field.where(mask)
-        # propagate ocean values into land interior before interpolation
-        field = lateral_fill(field, 1 - mask, dims)
-        # interpolate
-        field_interpolated = field.interp(**coords, method=method).drop_vars(dims)
-
-        return field_interpolated
+        if dims["time"] != "time":
+            ds = ds.rename({dims["time"]: "time"})
 
-    def nan_check(self, mask, time=0) -> None:
-        """
-        Checks for NaN values at wet points in all variables of the dataset at a specified time step.
+        # Preserve the original time coordinate for readability
+        ds = ds.assign_coords({"absolute_time": ds["time"]})
 
-        Parameters
-        ----------
-        mask : array-like
-            A boolean mask indicating the wet points in the dataset.
-        time : int
-            The time step at which to check for NaN values. Default is 0.
+        # Translate the time coordinate to days since the model reference date
+        model_reference_date = np.datetime64(self.model_reference_date)
 
-        Raises
-        ------
-        ValueError
-            If any variable contains NaN values at the specified time step.
+        # Convert the time coordinate to the format expected by ROMS (days since model reference date)
+        ds["time"] = (
+            (ds["time"] - model_reference_date).astype("float64") / 3600 / 24 * 1e-9
+        )
+        ds["time"].attrs[
+            "long_name"
+        ] = f"time since {np.datetime_as_string(model_reference_date, unit='D')}"
+        ds["time"].attrs["units"] = "days"
 
-        """
+        for var in ds.data_vars:
+            nan_check(ds[var].isel(time=0), mask_roms)
 
-        for var in self.ds.data_vars:
-            da = xr.where(mask == 1, self.ds[var].isel(time=time), 0)
-            if da.isnull().any().values:
-                raise ValueError(
-                    f"NaN values found in the variable '{var}' at time step {time} over the ocean. This likely "
-                    "occurs because the ROMS grid, including a small safety margin for interpolation, is not "
-                    "fully contained within the dataset's longitude/latitude range. Please ensure that the "
-                    "dataset covers the entire area required by the ROMS grid."
-                )
+        object.__setattr__(self, "ds", ds)
 
     def plot(self, varname, time=0) -> None:
         """
@@ -828,87 +693,45 @@ class AtmosphericForcing:
         ...     grid=grid_info,
         ...     start_time=start_time,
         ...     end_time=end_time,
-        ...     source="era5",
+        ...     source="ERA5",
         ...     filename="atmospheric_data_*.nc",
         ...     swr_correction=swr_correction,
         ... )
         >>> atm_forcing.plot("uwnd", time=0)
         """
 
-        import cartopy.crs as ccrs
-        import matplotlib.pyplot as plt
-
-        lon_deg = self.ds.lon
-        lat_deg = self.ds.lat
-
-        # check if North or South pole are in domain
-        if lat_deg.max().values > 89 or lat_deg.min().values < -89:
-            raise NotImplementedError(
-                "Plotting the atmospheric forcing is not implemented for the case that the domain contains the North or South pole."
-            )
-
-        if self.grid.straddle:
-            lon_deg = xr.where(lon_deg > 180, lon_deg - 360, lon_deg)
-
-        # Define projections
-        proj = ccrs.PlateCarree()
-
-        trans = ccrs.NearsidePerspective(
-            central_longitude=lon_deg.mean().values,
-            central_latitude=lat_deg.mean().values,
+        title = "%s at time %s" % (
+            self.ds[varname].long_name,
+            np.datetime_as_string(self.ds["absolute_time"].isel(time=time), unit="s"),
         )
 
-        lon_deg = lon_deg.values
-        lat_deg = lat_deg.values
-
-        # find corners
-        (lo1, la1) = (lon_deg[0, 0], lat_deg[0, 0])
-        (lo2, la2) = (lon_deg[0, -1], lat_deg[0, -1])
-        (lo3, la3) = (lon_deg[-1, -1], lat_deg[-1, -1])
-        (lo4, la4) = (lon_deg[-1, 0], lat_deg[-1, 0])
-
-        # transform coordinates to projected space
-        lo1t, la1t = trans.transform_point(lo1, la1, proj)
-        lo2t, la2t = trans.transform_point(lo2, la2, proj)
-        lo3t, la3t = trans.transform_point(lo3, la3, proj)
-        lo4t, la4t = trans.transform_point(lo4, la4, proj)
-
-        plt.figure(figsize=(10, 10))
-        ax = plt.axes(projection=trans)
-
-        ax.plot(
-            [lo1t, lo2t, lo3t, lo4t, lo1t],
-            [la1t, la2t, la3t, la4t, la1t],
-            "go-",
-        )
-
-        ax.coastlines(
-            resolution="50m", linewidth=0.5, color="black"
-        )  # add map of coastlines
-        ax.gridlines()
-
         field = self.ds[varname].isel(time=time).compute()
+
+        # choose colorbar
         if varname in ["uwnd", "vwnd"]:
             vmax = max(field.max().values, -field.min().values)
             vmin = -vmax
-            cmap = "RdBu_r"
+            cmap = plt.colormaps.get_cmap("RdBu_r")
         else:
             vmax = field.max().values
             vmin = field.min().values
             if varname in ["swrad", "lwrad", "Tair", "qair"]:
-                cmap = "YlOrRd"
+                cmap = plt.colormaps.get_cmap("YlOrRd")
             else:
-                cmap = "YlGnBu"
-
-        p = ax.pcolormesh(
-            lon_deg, lat_deg, field, transform=proj, vmax=vmax, vmin=vmin, cmap=cmap
+                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,
+            coarse_grid=self.use_coarse_grid,
+            title=title,
+            kwargs=kwargs,
+            c="g",
         )
-        plt.colorbar(p, label=field.units)
-        ax.set_title(
-            "%s at time %s"
-            % (field.long_name, np.datetime_as_string(field.time, unit="s"))
-        )
-        plt.show()
 
     def save(self, filepath: str, time_chunk_size: int = 1) -> None:
         """
@@ -938,11 +761,11 @@ class AtmosphericForcing:
         writes = []
 
         # Group dataset by year
-        gb = self.ds.groupby("time.year")
+        gb = self.ds.groupby("absolute_time.year")
 
         for year, group_ds in gb:
             # Further group each yearly group by month
-            sub_gb = group_ds.groupby("time.month")
+            sub_gb = group_ds.groupby("absolute_time.month")
 
             for month, ds in sub_gb:
                 # Chunk the dataset by the specified time chunk size
@@ -951,8 +774,8 @@ class AtmosphericForcing:
 
                 # Determine the number of days in the month
                 num_days_in_month = calendar.monthrange(year, month)[1]
-                first_day = ds.time.dt.day.values[0]
-                last_day = ds.time.dt.day.values[-1]
+                first_day = ds.time.absolute_time.dt.day.values[0]
+                last_day = ds.time.absolute_time.dt.day.values[-1]
 
                 # Create filename based on whether the dataset contains a full month
                 if first_day == 1 and last_day == num_days_in_month:
@@ -971,23 +794,142 @@ class AtmosphericForcing:
 
         for ds, filename in zip(datasets, filenames):
 
-            # Translate the time coordinate to days since the model reference date
-            model_reference_date = np.datetime64(self.model_reference_date)
-
-            # Preserve the original time coordinate for readability
-            ds["Time"] = ds["time"]
-
-            # Convert the time coordinate to the format expected by ROMS (days since model reference date)
-            ds["time"] = (
-                (ds["time"] - model_reference_date).astype("float64") / 3600 / 24 * 1e-9
-            )
-            ds["time"].attrs[
-                "long_name"
-            ] = f"time since {np.datetime_as_string(model_reference_date, unit='D')}"
-
             # Prepare the dataset for writing to a netCDF file without immediately computing
             write = ds.to_netcdf(filename, compute=False)
             writes.append(write)
 
         # Perform the actual write operations in parallel
-        dask.compute(*writes)
+        dask.persist(*writes)
+
+    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)
+
+        if self.swr_correction:
+            swr_correction_data = asdict(self.swr_correction)
+            swr_correction_data.pop("ds", None)
+        else:
+            swr_correction_data = None
+
+        rivers_data = asdict(self.rivers) if self.rivers else 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"
+
+        # Create YAML data for Grid and optional attributes
+        grid_yaml_data = {"Grid": grid_data}
+        swr_correction_yaml_data = (
+            {"SWRCorrection": swr_correction_data} if swr_correction_data else {}
+        )
+        rivers_yaml_data = {"Rivers": rivers_data} if rivers_data else {}
+
+        # Combine all sections
+        atmospheric_forcing_data = {
+            "AtmosphericForcing": {
+                "filename": self.filename,
+                "start_time": self.start_time.isoformat(),
+                "end_time": self.end_time.isoformat(),
+                "model_reference_date": self.model_reference_date.isoformat(),
+                "source": self.source,
+                "use_coarse_grid": self.use_coarse_grid,
+            }
+        }
+
+        # Merge YAML data while excluding empty sections
+        yaml_data = {
+            **grid_yaml_data,
+            **swr_correction_yaml_data,
+            **rivers_yaml_data,
+            **atmospheric_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) -> "AtmosphericForcing":
+        """
+        Create an instance of the AtmosphericForcing class from a YAML file.
+
+        Parameters
+        ----------
+        filepath : str
+            The path to the YAML file from which the parameters will be read.
+
+        Returns
+        -------
+        AtmosphericForcing
+            An instance of the AtmosphericForcing 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))
+
+        swr_correction_data = None
+        rivers_data = None
+        atmospheric_forcing_data = None
+
+        # Process the YAML documents
+        for doc in documents:
+            if doc is None:
+                continue
+            if "AtmosphericForcing" in doc:
+                atmospheric_forcing_data = doc["AtmosphericForcing"]
+            if "SWRCorrection" in doc:
+                swr_correction_data = doc["SWRCorrection"]
+            if "Rivers" in doc:
+                rivers_data = doc["Rivers"]
+
+        if atmospheric_forcing_data is None:
+            raise ValueError(
+                "No AtmosphericForcing configuration found in the YAML file."
+            )
+
+        # Convert from string to datetime
+        for date_string in ["model_reference_date", "start_time", "end_time"]:
+            atmospheric_forcing_data[date_string] = datetime.fromisoformat(
+                atmospheric_forcing_data[date_string]
+            )
+
+        # Create Grid instance from the YAML file
+        grid = Grid.from_yaml(filepath)
+
+        if swr_correction_data is not None:
+            swr_correction = SWRCorrection.from_yaml(filepath)
+        else:
+            swr_correction = None
+
+        if rivers_data is not None:
+            rivers = Rivers.from_yaml(filepath)
+        else:
+            rivers = None
+
+        # Create and return an instance of AtmosphericForcing
+        return cls(
+            grid=grid,
+            swr_correction=swr_correction,
+            rivers=rivers,
+            **atmospheric_forcing_data,
+        )