roms-tools 3.3.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

roms_tools/tests/test_utils.py

@@ -3,9 +3,12 @@ from pathlib import Path
 from unittest import mock
 
 import numpy as np
+import pandas as pd
 import pytest
 import xarray as xr
 
+from roms_tools.datasets.download import download_test_data
+from roms_tools.datasets.lat_lon_datasets import ERA5Correction
 from roms_tools.utils import (
     _path_list_from_input,
     generate_focused_coordinate_range,
@@ -13,6 +16,8 @@ from roms_tools.utils import (
     has_copernicus,
     has_dask,
     has_gcsfs,
+    interpolate_cyclic_time,
+    interpolate_from_climatology,
     load_data,
 )
 
@@ -241,3 +246,76 @@ def test_time_chunking_false_roms():
     dim_names = {"time": "ocean_time"}
     result = get_dask_chunks(dim_names, time_chunking=False)
     assert "ocean_time" not in result
+
+
+# test interpolate_from_climatology
+
+
+@pytest.fixture
+def climatology_data():
+    """Create a simple annual cycle dataset with 12 time points."""
+    time_coord = np.arange(1, 13)  # months as day_of_year approximation
+    da = xr.DataArray(np.arange(12), dims=("time",), coords={"time": time_coord})
+    ds = xr.Dataset({"var1": da, "var2": da * 2})
+    return da, ds, "time", "time"
+
+
+def test_interpolate_dataarray_single_time(climatology_data):
+    da, _, time_dim, time_coord = climatology_data
+    target_time = pd.Timestamp("2000-03-15")  # day_of_year ~ 75
+    interpolated = interpolate_from_climatology(da, time_dim, time_coord, target_time)
+    assert isinstance(interpolated, xr.DataArray)
+    assert interpolated.sizes[time_dim] == 1
+
+
+def test_interpolate_dataset_multiple_times(climatology_data):
+    _, ds, time_dim, time_coord = climatology_data
+    target_times = pd.date_range("2000-01-01", periods=3, freq="ME")
+    interpolated = interpolate_from_climatology(ds, time_dim, time_coord, target_times)
+    assert isinstance(interpolated, xr.Dataset)
+    assert all(interpolated[var].sizes[time_dim] == 3 for var in interpolated.data_vars)
+
+
+def test_interpolate_dataarray_time_dim_not_equal_time_coord():
+    time_values = np.arange(1, 13)
+    da = xr.DataArray(
+        np.arange(12),
+        dims=("time_dim",),
+        coords={"time_coord": ("time_dim", time_values)},
+    )
+    target_time = pd.Timestamp("2000-06-15")
+    interpolated = interpolate_from_climatology(
+        da, time_dim="time_dim", time_coord="time_coord", time=target_time
+    )
+    assert interpolated.sizes["time_dim"] == 1
+    assert np.issubdtype(interpolated.dtype, np.number)
+
+
+def test_interpolate_cyclic_time_basic():
+    time_values = np.arange(1, 13)
+    da = xr.DataArray(np.arange(12), dims=("time",), coords={"time": time_values})
+    target_days = [0.5, 6.5, 12.5]  # fractional days, include cyclic behavior
+    interpolated = interpolate_cyclic_time(
+        da, time_dim="time", time_coord="time", day_of_year=target_days
+    )
+    assert isinstance(interpolated, xr.DataArray)
+    assert interpolated.sizes["time"] == len(target_days)
+
+
+def test_interpolate_from_climatology_invalid_input():
+    with pytest.raises(TypeError):
+        interpolate_from_climatology(
+            "not a dataset", "time", "time", pd.Timestamp("2000-01-01")
+        )
+
+
+def test_interpolate_from_real_climatology(use_dask):
+    fname = download_test_data("ERA5_regional_test_data.nc")
+    era5_times = xr.open_dataset(fname).time
+
+    climatology = ERA5Correction(use_dask=use_dask)
+    field = climatology.ds["ssr_corr"]
+    field["time"] = field["time"].dt.days
+
+    interpolated_field = interpolate_from_climatology(field, "time", "time", era5_times)
+    assert len(interpolated_field.time) == len(era5_times)

roms_tools/tiling/partition.py

@@ -7,6 +7,61 @@ import xarray as xr
 
 from roms_tools.utils import save_datasets
 
+DIM_INFO = {
+    # eta-direction
+    "eta_rho": dict(axis="eta", ghost=2, edge="both"),
+    "eta_u": dict(axis="eta", ghost=2, edge="both"),
+    "eta_v": dict(axis="eta", ghost=1, edge="upper"),
+    "eta_psi": dict(axis="eta", ghost=3, edge="both"),
+    "eta_coarse": dict(axis="eta", ghost=2, edge="both"),
+    # xi-direction
+    "xi_rho": dict(axis="xi", ghost=2, edge="both"),
+    "xi_u": dict(axis="xi", ghost=1, edge="upper"),
+    "xi_v": dict(axis="xi", ghost=2, edge="both"),
+    "xi_psi": dict(axis="xi", ghost=3, edge="both"),
+    "xi_coarse": dict(axis="xi", ghost=2, edge="both"),
+}
+
+
+def _exact_division(size: int, nparts: int, dim: str) -> int:
+    if size % nparts != 0:
+        raise ValueError(
+            f"Dimension '{dim}' of size {size} cannot be evenly divided into {nparts} partitions."
+        )
+    return size // nparts
+
+
+def _compute_partition_sizes(
+    total_size: int,
+    nparts: int,
+    ghost: int,
+    edge: str,
+    dim: str,
+) -> list[int]:
+    """Compute per-tile sizes including ghost cells."""
+    if nparts == 1:
+        return [total_size]
+
+    core = _exact_division(total_size - ghost, nparts, dim)
+
+    sizes = [core] * nparts
+
+    if edge == "both":
+        sizes[0] += ghost // 2
+        sizes[-1] += ghost - ghost // 2
+    elif edge == "upper":
+        sizes[-1] += ghost
+    else:
+        raise ValueError(f"Unknown edge rule '{edge}' for {dim}")
+
+    return sizes
+
+
+def _cumsum(sizes: list[int]) -> np.ndarray:
+    out = np.zeros(len(sizes) + 1, dtype=int)
+    out[1:] = np.cumsum(sizes)
+    return out
+
 
 def partition(
     ds: xr.Dataset, np_eta: int = 1, np_xi: int = 1, include_coarse_dims: bool = True
@@ -16,8 +71,8 @@ def partition(
 
     This function divides the input dataset into `np_eta` by `np_xi` tiles, where each tile
     represents a subdomain of the original dataset. The partitioning is performed along
-    the spatial dimensions `eta_rho`, `xi_rho`, `eta_v`, `xi_u`, `eta_psi`, `xi_psi`, `eta_coarse`, and `xi_coarse`,
-    depending on which dimensions are present in the dataset.
+    the spatial dimensions `eta_rho`, `eta_u`, `eta_v`, `eta_coarse`, `xi_rho`, `xi_u`, `xi_v`,
+    and `xi_coarse`, depending on which dimensions are present in the dataset.
 
     Parameters
     ----------
@@ -71,227 +126,42 @@ def partition(
     ):
         raise ValueError("np_eta and np_xi must be positive integers")
 
-    base_dims = [
-        "eta_rho",
-        "xi_rho",
-        "eta_v",
-        "xi_u",
-        "eta_psi",
-        "xi_psi",
+    # Select applicable dimensions
+    dims_to_partition = [
+        d
+        for d in DIM_INFO
+        if d in ds.dims and (include_coarse_dims or "coarse" not in d)
     ]
-    coarse_dims = ["eta_coarse", "xi_coarse"]
-    partitionable_dims = base_dims + coarse_dims if include_coarse_dims else base_dims
-
-    dims_to_partition = [d for d in partitionable_dims if d in ds.dims]
-
-    # if eta is periodic there are no ghost cells along those dimensions
-    if "eta_v" in ds.sizes and ds.sizes["eta_rho"] == ds.sizes["eta_v"]:
-        # TODO how are we supposed to know if eta is periodic if eta_v doesn't appear? partit.F doesn't say...
-        n_eta_ghost_cells = 0
-    else:
-        n_eta_ghost_cells = 1
-
-    # if xi is periodic there are no ghost cells along those dimensions
-    if "xi_u" in ds.sizes and ds.sizes["xi_rho"] == ds.sizes["xi_u"]:
-        n_xi_ghost_cells = 0
-    else:
-        n_xi_ghost_cells = 1
-
-    def integer_division_or_raise(a: int, b: int, dimension: str) -> int:
-        """Perform integer division and ensure that the division is exact.
-
-        Parameters
-        ----------
-        a : int
-            The numerator for the division.
-        b : int
-            The denominator for the division.
-        dimension : str
-            The name of the dimension being partitioned, used for error reporting.
-
-        Returns
-        -------
-        int
-            The result of the integer division.
-
-        Raises
-        ------
-        ValueError
-            If the division is not exact, indicating that the domain cannot be evenly divided
-            along the specified dimension.
-        """
-        remainder = a % b
-        if remainder == 0:
-            return a // b
-        else:
-            raise ValueError(
-                f"Dimension '{dimension}' of size {a} cannot be evenly divided into {b} partitions."
-            )
-
-    if "eta_rho" in dims_to_partition:
-        eta_rho_domain_size = integer_division_or_raise(
-            ds.sizes["eta_rho"] - 2 * n_eta_ghost_cells, np_eta, "eta_rho"
-        )
 
-    if "xi_rho" in dims_to_partition:
-        xi_rho_domain_size = integer_division_or_raise(
-            ds.sizes["xi_rho"] - 2 * n_xi_ghost_cells, np_xi, "xi_rho"
-        )
+    partitioned_sizes = {}
 
-    if "eta_v" in dims_to_partition:
-        eta_v_domain_size = integer_division_or_raise(
-            ds.sizes["eta_v"] - 1 * n_eta_ghost_cells, np_eta, "eta_v"
-        )
-
-    if "xi_u" in dims_to_partition:
-        xi_u_domain_size = integer_division_or_raise(
-            ds.sizes["xi_u"] - 1 * n_xi_ghost_cells, np_xi, "xi_u"
-        )
-
-    if "eta_psi" in dims_to_partition:
-        eta_psi_domain_size = integer_division_or_raise(
-            ds.sizes["eta_psi"] - 3 * n_eta_ghost_cells, np_eta, "eta_psi"
-        )
-
-    if "xi_psi" in dims_to_partition:
-        xi_psi_domain_size = integer_division_or_raise(
-            ds.sizes["xi_psi"] - 3 * n_xi_ghost_cells, np_xi, "xi_psi"
-        )
+    for dim in dims_to_partition:
+        info = DIM_INFO[dim]
+        nparts = np_eta if info["axis"] == "eta" else np_xi
 
-    if "eta_coarse" in dims_to_partition:
-        eta_coarse_domain_size = integer_division_or_raise(
-            ds.sizes["eta_coarse"] - 2 * n_eta_ghost_cells, np_eta, "eta_coarse"
+        partitioned_sizes[dim] = _compute_partition_sizes(
+            total_size=ds.sizes[dim],
+            nparts=nparts,
+            ghost=info["ghost"],
+            edge=info["edge"],
+            dim=dim,
         )
-    if "xi_coarse" in dims_to_partition:
-        xi_coarse_domain_size = integer_division_or_raise(
-            ds.sizes["xi_coarse"] - 2 * n_xi_ghost_cells, np_xi, "xi_coarse"
-        )
-
-    # unpartitioned dimensions should have sizes unchanged
-    partitioned_sizes = {
-        dim: [size] for dim, size in ds.sizes.items() if dim in dims_to_partition
-    }
-
-    # TODO refactor to use two functions for odd- and even-length dimensions
-    if "eta_v" in dims_to_partition:
-        partitioned_sizes["eta_v"] = [eta_v_domain_size] * (np_eta - 1) + [
-            eta_v_domain_size + n_eta_ghost_cells
-        ]
-    if "xi_u" in dims_to_partition:
-        partitioned_sizes["xi_u"] = [xi_u_domain_size] * (np_xi - 1) + [
-            xi_u_domain_size + n_xi_ghost_cells
-        ]
-
-    if np_eta > 1:
-        if "eta_rho" in dims_to_partition:
-            partitioned_sizes["eta_rho"] = (
-                [eta_rho_domain_size + n_eta_ghost_cells]
-                + [eta_rho_domain_size] * (np_eta - 2)
-                + [eta_rho_domain_size + n_eta_ghost_cells]
-            )
-        if "eta_psi" in dims_to_partition:
-            partitioned_sizes["eta_psi"] = (
-                [n_eta_ghost_cells + eta_psi_domain_size]
-                + [eta_psi_domain_size] * (np_eta - 2)
-                + [eta_psi_domain_size + 2 * n_eta_ghost_cells]
-            )
-        if "eta_coarse" in dims_to_partition:
-            partitioned_sizes["eta_coarse"] = (
-                [eta_coarse_domain_size + n_eta_ghost_cells]
-                + [eta_coarse_domain_size] * (np_eta - 2)
-                + [eta_coarse_domain_size + n_eta_ghost_cells]
-            )
-
-    if np_xi > 1:
-        if "xi_rho" in dims_to_partition:
-            partitioned_sizes["xi_rho"] = (
-                [xi_rho_domain_size + n_xi_ghost_cells]
-                + [xi_rho_domain_size] * (np_xi - 2)
-                + [xi_rho_domain_size + n_xi_ghost_cells]
-            )
-        if "xi_psi" in dims_to_partition:
-            partitioned_sizes["xi_psi"] = (
-                [n_xi_ghost_cells + xi_psi_domain_size]
-                + [xi_psi_domain_size] * (np_xi - 2)
-                + [xi_psi_domain_size + 2 * n_xi_ghost_cells]
-            )
-        if "xi_coarse" in dims_to_partition:
-            partitioned_sizes["xi_coarse"] = (
-                [xi_coarse_domain_size + n_xi_ghost_cells]
-                + [xi_coarse_domain_size] * (np_xi - 2)
-                + [xi_coarse_domain_size + n_xi_ghost_cells]
-            )
-
-    def cumsum(pmf):
-        """Implementation of cumsum which ensures the result starts with zero."""
-        cdf = np.empty(len(pmf) + 1, dtype=int)
-        cdf[0] = 0
-        np.cumsum(pmf, out=cdf[1:])
-        return cdf
 
     file_numbers = []
     partitioned_datasets = []
+
     for i in range(np_eta):
         for j in range(np_xi):
-            file_number = j + (i * np_xi)
-            file_numbers.append(file_number)
-
+            file_numbers.append(j + i * np_xi)
             indexers = {}
 
-            if "eta_rho" in dims_to_partition:
-                eta_rho_partition_indices = cumsum(partitioned_sizes["eta_rho"])
-                indexers["eta_rho"] = slice(
-                    int(eta_rho_partition_indices[i]),
-                    int(eta_rho_partition_indices[i + 1]),
-                )
-            if "xi_rho" in dims_to_partition:
-                xi_rho_partition_indices = cumsum(partitioned_sizes["xi_rho"])
-                indexers["xi_rho"] = slice(
-                    int(xi_rho_partition_indices[j]),
-                    int(xi_rho_partition_indices[j + 1]),
-                )
-
-            if "eta_v" in dims_to_partition:
-                eta_v_partition_indices = cumsum(partitioned_sizes["eta_v"])
-                indexers["eta_v"] = slice(
-                    int(eta_v_partition_indices[i]),
-                    int(eta_v_partition_indices[i + 1]),
-                )
-            if "xi_u" in dims_to_partition:
-                xi_u_partition_indices = cumsum(partitioned_sizes["xi_u"])
-                indexers["xi_u"] = slice(
-                    int(xi_u_partition_indices[j]), int(xi_u_partition_indices[j + 1])
-                )
-            if "eta_psi" in dims_to_partition:
-                eta_psi_partition_indices = cumsum(partitioned_sizes["eta_psi"])
-                indexers["eta_psi"] = slice(
-                    int(eta_psi_partition_indices[i]),
-                    int(eta_psi_partition_indices[i + 1]),
-                )
-            if "xi_psi" in dims_to_partition:
-                xi_psi_partition_indices = cumsum(partitioned_sizes["xi_psi"])
-                indexers["xi_psi"] = slice(
-                    int(xi_psi_partition_indices[j]),
-                    int(xi_psi_partition_indices[j + 1]),
-                )
-
-            if "eta_coarse" in dims_to_partition:
-                eta_coarse_partition_indices = cumsum(partitioned_sizes["eta_coarse"])
-                indexers["eta_coarse"] = slice(
-                    int(eta_coarse_partition_indices[i]),
-                    int(eta_coarse_partition_indices[i + 1]),
-                )
-
-            if "xi_coarse" in dims_to_partition:
-                xi_coarse_partition_indices = cumsum(partitioned_sizes["xi_coarse"])
-                indexers["xi_coarse"] = slice(
-                    int(xi_coarse_partition_indices[j]),
-                    int(xi_coarse_partition_indices[j + 1]),
-                )
-
-            partitioned_ds = ds.isel(**indexers)
-
-            partitioned_datasets.append(partitioned_ds)
+            for dim, sizes in partitioned_sizes.items():
+                info = DIM_INFO[dim]
+                idx = i if info["axis"] == "eta" else j
+                bounds = _cumsum(sizes)
+                indexers[dim] = slice(bounds[idx], bounds[idx + 1])
+
+            partitioned_datasets.append(ds.isel(**indexers))
 
     return file_numbers, partitioned_datasets
 

roms_tools/utils.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from typing import TypeAlias
 
 import numpy as np
+import pandas as pd
 import xarray as xr
 
 from roms_tools.constants import R_EARTH
@@ -1031,3 +1032,195 @@ def get_pkg_error_msg(purpose: str, package_name: str, option_name: str) -> str:
           • `pip install {package_name}` or
           • `conda install {package_name}`
         Alternatively, install `roms-tools` with conda to include all dependencies.""")
+
+
+def wrap_longitudes(ds: xr.Dataset, straddle: bool) -> xr.Dataset:
+    """
+    Safely adjust longitude variables for datasets that may or may not cross
+    the dateline. Only modifies longitude-like variables that are present.
+
+    Parameters
+    ----------
+    ds : xr.Dataset
+        Dataset containing longitude variables (e.g., lon_rho, lon_u, lon_v).
+    straddle : bool
+        - True: force longitudes into [-180, 180]
+        - False: force longitudes into [0, 360]
+
+    Returns
+    -------
+    xr.Dataset
+        A new dataset with adjusted longitude values.
+    """
+    lon_vars = ["lon_rho", "lon_u", "lon_v"]
+
+    for lon_dim in lon_vars:
+        if lon_dim not in ds:
+            continue  # skip missing coordinate
+
+        lon = ds[lon_dim]
+
+        if straddle:
+            # wrap into [-180, 180]
+            lon_wrapped = xr.where(lon > 180, lon - 360, lon)
+        else:
+            # wrap into [0, 360]
+            lon_wrapped = xr.where(lon < 0, lon + 360, lon)
+
+        # preserve attributes
+        lon_wrapped.attrs.update(lon.attrs)
+        ds[lon_dim] = lon_wrapped
+
+    return ds
+
+
+def interpolate_from_climatology(
+    field: xr.DataArray | xr.Dataset,
+    time_dim: str,
+    time_coord: str,
+    time: xr.DataArray | pd.DatetimeIndex,
+) -> xr.DataArray | xr.Dataset:
+    """Interpolates a climatological field to specified time points.
+
+    This function interpolates the input `field` based on `day_of_year` values
+    extracted from the provided `time` points. If `field` is an `xarray.Dataset`,
+    interpolation is applied to all its data variables individually.
+
+    Parameters
+    ----------
+    field : xarray.DataArray or xarray.Dataset
+        The input field to be interpolated.
+        - If `field` is an `xarray.DataArray`, it must have a time dimension identified by `time_dim_name`.
+        - If `field` is an `xarray.Dataset`, all variables within the dataset are interpolated along `time_dim_name`.
+        The time dimension is assumed to represent `day_of_year` for climatological purposes.
+    time_dim : str
+        The name of the time dimension in `field`.
+    time_coord : str
+        The name of the time coordinate in `field`.
+    time : xarray.DataArray or pandas.DatetimeIndex
+        The target time points for interpolation. These are internally converted to `day_of_year`
+        before performing interpolation.
+
+    Returns
+    -------
+    xarray.DataArray or xarray.Dataset
+        The interpolated field, maintaining the same type (`xarray.DataArray` or `xarray.Dataset`)
+        but aligned to the specified `time` values.
+
+    Notes
+    -----
+    - This function assumes that `field` represents a climatological dataset, where time is expressed as `day_of_year` (1-365).
+    - The `time` input is automatically converted to `day_of_year`, so manual conversion is not required before calling this function.
+    """
+
+    def np_times_to_fractional_days(
+        np_times: np.ndarray | pd.DatetimeIndex | np.datetime64 | pd.Timestamp,
+    ) -> np.ndarray:
+        """Convert datetime(s) to fractional day-of-year values."""
+        pd_times = pd.to_datetime(np_times)
+
+        # scalar input -> make it a 1-element array
+        if np.isscalar(pd_times):
+            pd_times = np.array([pd_times])
+
+        fractional_days = pd_times.dayofyear + (
+            pd_times.hour / 24 + pd_times.minute / 1440 + pd_times.second / 86400
+        )
+        return (
+            fractional_days.values
+            if hasattr(fractional_days, "values")
+            else np.array(fractional_days)
+        )
+
+    def interpolate_single_field(data_array: xr.DataArray) -> xr.DataArray:
+        if isinstance(time, xr.DataArray):
+            day_of_year = time.dt.dayofyear
+        else:
+            day_of_year = np_times_to_fractional_days(time)
+
+        data_array_interpolated = interpolate_cyclic_time(
+            data_array, time_dim, time_coord, day_of_year
+        )
+
+        # expand dims if single element
+        if day_of_year.size == 1:
+            data_array_interpolated = data_array_interpolated.expand_dims({time_dim: 1})
+        return data_array_interpolated
+
+    if isinstance(field, xr.DataArray):
+        return interpolate_single_field(field)
+    elif isinstance(field, xr.Dataset):
+        interpolated_data_vars = {
+            var: interpolate_single_field(data_array)
+            for var, data_array in field.data_vars.items()
+        }
+        return xr.Dataset(interpolated_data_vars, attrs=field.attrs)
+
+    else:
+        raise TypeError("Input 'field' must be an xarray.DataArray or xarray.Dataset.")
+
+
+def interpolate_cyclic_time(
+    data_array: xr.DataArray,
+    time_dim: str,
+    time_coord: str,
+    day_of_year: int | float | np.ndarray | xr.DataArray | Sequence[int | float],
+) -> xr.DataArray:
+    """Interpolates a DataArray cyclically across the start and end of the year.
+
+    This function extends the data cyclically by appending the last time step
+    (shifted back by one year) at the beginning and the first time step
+    (shifted forward by one year) at the end. It then performs linear interpolation
+    to match the specified `day_of_year` values.
+
+    Parameters
+    ----------
+    data_array : xr.DataArray
+        The input data array containing a time-like dimension.
+    time_dim : str
+        The name of the time dimension in the dataset.
+    time_coord : str
+        The name of the time coordinate in the dataset.
+    day_of_year : Union[int, float, np.ndarray, xr.DataArray, Sequence[Union[int, float]]]
+        The target day(s) of the year for interpolation. This can be:
+        - A single integer or float representing the day of the year.
+        - A NumPy array or xarray DataArray containing multiple days.
+        - A list or tuple of integers or floats for multiple target days.
+
+    Returns
+    -------
+    xr.DataArray
+        The interpolated DataArray, ensuring cyclic continuity across year boundaries.
+
+    Notes
+    -----
+    - This function is useful for interpolating climatological data, where the time axis
+      represents a repeating annual cycle.
+    - The `day_of_year` values should be within the range [1, 365] or [1, 366] for leap years.
+    """
+    # Concatenate across the beginning and end of the year
+    time_concat = xr.concat(
+        [
+            data_array[time_coord][-1] - 365.25,  # Shift last time backward
+            data_array[time_coord],
+            data_array[time_coord][0] + 365.25,  # Shift first time forward
+        ],
+        dim=time_dim,
+    )
+
+    data_array_concat = xr.concat(
+        [
+            data_array.isel(**{time_dim: -1}),  # Append last value at the beginning
+            data_array,
+            data_array.isel(**{time_dim: 0}),  # Append first value at the end
+        ],
+        dim=time_dim,
+    )
+    data_array_concat[time_dim] = time_concat
+
+    # Interpolate to specified times
+    data_array_interpolated = data_array_concat.interp(
+        **{time_dim: day_of_year}, method="linear"
+    )
+
+    return data_array_interpolated

{roms_tools-3.3.0.dist-info → roms_tools-3.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roms-tools
-Version: 3.3.0
+Version: 3.4.0
 Summary: Tools for running and analysing UCLA-ROMS simulations
 Author-email: Nora Loose <nora.loose@gmail.com>, Thomas Nicholas <tom@cworthy.org>, Scott Eilerman <scott.eilerman@cworthy.org>
 License: Apache-2