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

roms_tools/setup/topography.py

@@ -0,0 +1,242 @@
+import xarray as xr
+import numpy as np
+import gcm_filters
+from scipy.interpolate import RegularGridInterpolator
+from scipy.ndimage import label
+from roms_tools.setup.datasets import fetch_topo
+import warnings
+from itertools import count
+
+
+def _add_topography_and_mask(
+    ds, topography_source, smooth_factor, hmin, rmax
+) -> xr.Dataset:
+    lon = ds.lon_rho.values
+    lat = ds.lat_rho.values
+
+    # interpolate topography onto desired grid
+    hraw = _make_raw_topography(lon, lat, topography_source)
+    hraw = xr.DataArray(data=hraw, dims=["eta_rho", "xi_rho"])
+
+    # Mask is obtained by finding locations where ocean depth is positive
+    mask = xr.where(hraw > 0, 1, 0)
+
+    # smooth topography domain-wide with Gaussian kernel to avoid grid scale instabilities
+    ds["hraw"] = _smooth_topography_globally(hraw, mask, smooth_factor)
+    ds["hraw"].attrs = {
+        "long_name": "Working bathymetry at rho-points",
+        "source": f"Raw bathymetry from {topography_source} (smoothing diameter {smooth_factor})",
+        "units": "meter",
+    }
+
+    # fill enclosed basins with land
+    mask = _fill_enclosed_basins(mask.values)
+    ds["mask_rho"] = xr.DataArray(mask, dims=("eta_rho", "xi_rho"))
+    ds["mask_rho"].attrs = {
+        "long_name": "Mask at rho-points",
+        "units": "land/water (0/1)",
+    }
+
+    # smooth topography locally to satisfy r < rmax
+    ds["h"] = _smooth_topography_locally(ds["hraw"] * ds["mask_rho"], hmin, rmax)
+    ds["h"].attrs = {
+        "long_name": "Final bathymetry at rho-points",
+        "units": "meter",
+    }
+
+    ds = _add_topography_metadata(ds, topography_source, smooth_factor, hmin, rmax)
+
+    return ds
+
+
+def _make_raw_topography(lon, lat, topography_source) -> np.ndarray:
+    """
+    Given a grid of (lon, lat) points, fetch the topography file and interpolate height values onto the desired grid.
+    """
+
+    topo_ds = fetch_topo(topography_source)
+
+    # the following will depend on the topography source
+    if topography_source == "etopo5":
+        topo_lon = topo_ds["topo_lon"].copy()
+        # Modify longitude values where necessary
+        topo_lon = xr.where(topo_lon < 0, topo_lon + 360, topo_lon)
+        topo_lon_minus360 = topo_lon - 360
+        topo_lon_plus360 = topo_lon + 360
+        # Concatenate along the longitude axis
+        topo_lon_concatenated = xr.concat(
+            [topo_lon_minus360, topo_lon, topo_lon_plus360], dim="lon"
+        )
+        topo_concatenated = xr.concat(
+            [-topo_ds["topo"], -topo_ds["topo"], -topo_ds["topo"]], dim="lon"
+        )
+
+        interp = RegularGridInterpolator(
+            (topo_ds["topo_lat"].values, topo_lon_concatenated.values),
+            topo_concatenated.values,
+            method="linear",
+        )
+
+    # Interpolate onto desired domain grid points
+    hraw = interp((lat, lon))
+
+    return hraw
+
+
+def _smooth_topography_globally(hraw, wet_mask, factor) -> xr.DataArray:
+    # since GCM-Filters assumes periodic domain, we extend the domain by one grid cell in each dimension
+    # and set that margin to land
+    margin_mask = xr.concat([wet_mask, 0 * wet_mask.isel(eta_rho=-1)], dim="eta_rho")
+    margin_mask = xr.concat(
+        [margin_mask, 0 * margin_mask.isel(xi_rho=-1)], dim="xi_rho"
+    )
+
+    # we choose a Gaussian filter kernel corresponding to a Gaussian with standard deviation factor/sqrt(12);
+    # this standard deviation matches the standard deviation of a boxcar kernel with total width equal to factor.
+    filter = gcm_filters.Filter(
+        filter_scale=factor,
+        dx_min=1,
+        filter_shape=gcm_filters.FilterShape.GAUSSIAN,
+        grid_type=gcm_filters.GridType.REGULAR_WITH_LAND,
+        grid_vars={"wet_mask": margin_mask},
+    )
+    hraw_extended = xr.concat([hraw, hraw.isel(eta_rho=-1)], dim="eta_rho")
+    hraw_extended = xr.concat(
+        [hraw_extended, hraw_extended.isel(xi_rho=-1)], dim="xi_rho"
+    )
+
+    hsmooth = filter.apply(hraw_extended, dims=["eta_rho", "xi_rho"])
+    hsmooth = hsmooth.isel(eta_rho=slice(None, -1), xi_rho=slice(None, -1))
+
+    return hsmooth
+
+
+def _fill_enclosed_basins(mask) -> np.ndarray:
+    """
+    Fills in enclosed basins with land
+    """
+
+    # Label connected regions in the mask
+    reg, nreg = label(mask)
+    # Find the largest region
+    lint = 0
+    lreg = 0
+    for ireg in range(nreg):
+        int_ = np.sum(reg == ireg)
+        if int_ > lint and mask[reg == ireg].sum() > 0:
+            lreg = ireg
+            lint = int_
+
+    # Remove regions other than the largest one
+    for ireg in range(nreg):
+        if ireg != lreg:
+            mask[reg == ireg] = 0
+
+    return mask
+
+
+def _smooth_topography_locally(h, hmin=5, rmax=0.2):
+    """
+    Smoothes topography locally to satisfy r < rmax
+    """
+    # Compute rmax_log
+    if rmax > 0.0:
+        rmax_log = np.log((1.0 + rmax * 0.9) / (1.0 - rmax * 0.9))
+    else:
+        rmax_log = 0.0
+
+    # Apply hmin threshold
+    h = xr.where(h < hmin, hmin, h)
+
+    # We will smooth logarithmically
+    h_log = np.log(h / hmin)
+
+    cf1 = 1.0 / 6
+    cf2 = 0.25
+
+    for iter in count():
+        # Compute gradients in domain interior
+
+        # in eta-direction
+        cff = h_log.diff("eta_rho").isel(xi_rho=slice(1, -1))
+        cr = np.abs(cff)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")  # Ignore division by zero warning
+            Op1 = xr.where(cr < rmax_log, 0, 1.0 * cff * (1 - rmax_log / cr))
+
+        # in xi-direction
+        cff = h_log.diff("xi_rho").isel(eta_rho=slice(1, -1))
+        cr = np.abs(cff)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")  # Ignore division by zero warning
+            Op2 = xr.where(cr < rmax_log, 0, 1.0 * cff * (1 - rmax_log / cr))
+
+        # in diagonal direction
+        cff = (h_log - h_log.shift(eta_rho=1, xi_rho=1)).isel(
+            eta_rho=slice(1, None), xi_rho=slice(1, None)
+        )
+        cr = np.abs(cff)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")  # Ignore division by zero warning
+            Op3 = xr.where(cr < rmax_log, 0, 1.0 * cff * (1 - rmax_log / cr))
+
+        # in the other diagonal direction
+        cff = (h_log.shift(eta_rho=1) - h_log.shift(xi_rho=1)).isel(
+            eta_rho=slice(1, None), xi_rho=slice(1, None)
+        )
+        cr = np.abs(cff)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")  # Ignore division by zero warning
+            Op4 = xr.where(cr < rmax_log, 0, 1.0 * cff * (1 - rmax_log / cr))
+
+        # Update h_log in domain interior
+        h_log[1:-1, 1:-1] += cf1 * (
+            Op1[1:, :]
+            - Op1[:-1, :]
+            + Op2[:, 1:]
+            - Op2[:, :-1]
+            + cf2 * (Op3[1:, 1:] - Op3[:-1, :-1] + Op4[:-1, 1:] - Op4[1:, :-1])
+        )
+
+        # No gradient at the domain boundaries
+        h_log[0, :] = h_log[1, :]
+        h_log[-1, :] = h_log[-2, :]
+        h_log[:, 0] = h_log[:, 1]
+        h_log[:, -1] = h_log[:, -2]
+
+        # Update h
+        h = hmin * np.exp(h_log)
+        # Apply hmin threshold again
+        h = xr.where(h < hmin, hmin, h)
+
+        # compute maximum slope parameter r
+        r_eta, r_xi = _compute_rfactor(h)
+        rmax0 = np.max([r_eta.max(), r_xi.max()])
+        if rmax0 < rmax:
+            break
+
+    return h
+
+
+def _compute_rfactor(h):
+    """
+    Computes slope parameter (or r-factor) r = |Delta h| / 2h in both horizontal grid directions.
+    """
+    # compute r_{i-1/2} = |h_i - h_{i-1}| / (h_i + h_{i+1})
+    r_eta = np.abs(h.diff("eta_rho")) / (h + h.shift(eta_rho=1)).isel(
+        eta_rho=slice(1, None)
+    )
+    r_xi = np.abs(h.diff("xi_rho")) / (h + h.shift(xi_rho=1)).isel(
+        xi_rho=slice(1, None)
+    )
+
+    return r_eta, r_xi
+
+
+def _add_topography_metadata(ds, topography_source, smooth_factor, hmin, rmax):
+    ds.attrs["topography_source"] = topography_source
+    ds.attrs["smooth_factor"] = smooth_factor
+    ds.attrs["hmin"] = hmin
+    ds.attrs["rmax"] = rmax
+
+    return ds

roms_tools/tests/test_setup.py

@@ -1,19 +1,25 @@
 import pytest
 import numpy as np
 import numpy.testing as npt
-
+from scipy.ndimage import label
 from roms_tools import Grid
+from roms_tools.setup.topography import _compute_rfactor
+from roms_tools.setup.tides import TPXO
+import os
+import tempfile
 
 
 class TestCreateGrid:
     def test_simple_regression(self):
-        grid = Grid(nx=1, ny=1, size_x=100, size_y=100, center_lon=-20, center_lat=0)
+        grid = Grid(
+            nx=1, ny=1, size_x=100, size_y=100, center_lon=-20, center_lat=0, rot=0
+        )
 
         expected_lat = np.array(
             [
-                [1.79855429e00, 1.79855429e00, 1.79855429e00],
-                [1.72818690e-14, 1.70960078e-14, 1.70960078e-14],
-                [-1.79855429e00, -1.79855429e00, -1.79855429e00],
+                [-8.99249453e-01, -8.99249453e-01, -8.99249453e-01],
+                [0.0, 0.0, 0.0],
+                [8.99249453e-01, 8.99249453e-01, 8.99249453e-01],
             ]
         )
         expected_lon = np.array(
@@ -24,18 +30,18 @@ class TestCreateGrid:
             ]
         )
 
-        npt.assert_allclose(grid.ds["lat_rho"], expected_lat)
-        npt.assert_allclose(grid.ds["lon_rho"], expected_lon)
+        # TODO: adapt tolerances according to order of magnitude of respective fields
+        npt.assert_allclose(grid.ds["lat_rho"], expected_lat, atol=1e-8)
+        npt.assert_allclose(grid.ds["lon_rho"], expected_lon, atol=1e-8)
 
-    def test_raise_if_crossing_dateline(self):
-        with pytest.raises(ValueError, match="cannot cross Greenwich Meridian"):
-            # test grid centered over London
-            Grid(nx=3, ny=3, size_x=100, size_y=100, center_lon=0, center_lat=51.5)
+    def test_raise_if_domain_too_large(self):
+        with pytest.raises(ValueError, match="Domain size has to be smaller"):
+            Grid(nx=3, ny=3, size_x=30000, size_y=30000, center_lon=0, center_lat=51.5)
 
-        # test Iceland grid which is rotated specifically to avoid Greenwich Meridian
+        # test grid with reasonable domain size
         grid = Grid(
-            nx=100,
-            ny=100,
+            nx=3,
+            ny=3,
             size_x=1800,
             size_y=2400,
             center_lon=-21,
@@ -44,11 +50,132 @@ class TestCreateGrid:
         )
         assert isinstance(grid, Grid)
 
+    def test_grid_straddle_crosses_meridian(self):
+        grid = Grid(
+            nx=3,
+            ny=3,
+            size_x=100,
+            size_y=100,
+            center_lon=0,
+            center_lat=61,
+            rot=20,
+        )
+        assert grid.straddle
+
+        grid = Grid(
+            nx=3,
+            ny=3,
+            size_x=100,
+            size_y=100,
+            center_lon=180,
+            center_lat=61,
+            rot=20,
+        )
+        assert not grid.straddle
 
-class TestGridFromFile:
-    def test_equal_to_from_init(self):
-        ...
 
+class TestGridFromFile:
     def test_roundtrip(self):
         """Test that creating a grid, saving it to file, and re-opening it is the same as just creating it."""
-        ...
+
+        # Initialize a Grid object using the initializer
+        grid_init = Grid(
+            nx=10,
+            ny=15,
+            size_x=100.0,
+            size_y=150.0,
+            center_lon=0.0,
+            center_lat=0.0,
+            rot=0.0,
+            topography_source="etopo5",
+            smooth_factor=2,
+            hmin=5.0,
+            rmax=0.2,
+        )
+
+        # Create a temporary file
+        with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
+            filepath = tmpfile.name
+
+        try:
+            # Save the grid to a file
+            grid_init.save(filepath)
+
+            # Load the grid from the file
+            grid_from_file = Grid.from_file(filepath)
+
+            # Assert that the initial grid and the loaded grid are equivalent (including the 'ds' attribute)
+            assert grid_init == grid_from_file
+
+        finally:
+            os.remove(filepath)
+
+
+class TestTopography:
+    def test_enclosed_regions(self):
+        """Test that there are only two connected regions, one dry and one wet."""
+
+        grid = Grid(
+            nx=100,
+            ny=100,
+            size_x=1800,
+            size_y=2400,
+            center_lon=30,
+            center_lat=61,
+            rot=20,
+        )
+
+        reg, nreg = label(grid.ds.mask_rho)
+        npt.assert_equal(nreg, 2)
+
+    def test_rmax_criterion(self):
+        grid = Grid(
+            nx=100,
+            ny=100,
+            size_x=1800,
+            size_y=2400,
+            center_lon=30,
+            center_lat=61,
+            rot=20,
+            smooth_factor=4,
+            rmax=0.2,
+        )
+        r_eta, r_xi = _compute_rfactor(grid.ds.h)
+        rmax0 = np.max([r_eta.max(), r_xi.max()])
+        npt.assert_array_less(rmax0, grid.rmax)
+
+    def test_hmin_criterion(self):
+        grid = Grid(
+            nx=100,
+            ny=100,
+            size_x=1800,
+            size_y=2400,
+            center_lon=30,
+            center_lat=61,
+            rot=20,
+            smooth_factor=2,
+            rmax=0.2,
+            hmin=5,
+        )
+
+        assert np.less_equal(grid.hmin, grid.ds.h.min())
+
+
+class TestTPXO:
+    def test_load_data_file_not_found(self):
+        # Test loading data from a non-existing file
+        with pytest.raises(FileNotFoundError):
+            TPXO.load_data("non_existing_file.nc")
+
+    def test_load_data_checksum_mismatch(self):
+        # Create a temporary file for testing
+        filename = "test_tidal_data.nc"
+        with open(filename, "wb") as file:
+            # Write some data to the file
+            file.write(b"test data")
+        # Test loading data with incorrect checksum
+        with open(filename, "wb") as file:
+            with pytest.raises(ValueError):
+                TPXO.load_data(filename)
+        # Remove temporary file
+        os.remove(filename)

roms_tools-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: roms-tools
+Version: 0.1.0
+Summary: Tools for running and analysing UCLA-ROMS simulations
+Author-email: Nora Loose <nora.loose@gmail.com>, Thomas Nicholas <tom@cworthy.org>
+License: Apache-2
+Project-URL: Home, https://github.com/CWorthy-ocean/roms-tools
+Project-URL: Documentation, https://roms-tools.readthedocs.io/en/latest/
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xarray >=2022.6.0
+Requires-Dist: numpy
+Requires-Dist: netcdf4
+Requires-Dist: pooch
+Requires-Dist: matplotlib
+Requires-Dist: cartopy
+Requires-Dist: packaging
+Requires-Dist: scipy
+Requires-Dist: gcm-filters
+Requires-Dist: numba
+
+# ROMS-Tools
+
+[![Documentation Status](https://readthedocs.org/projects/roms-tools/badge/?version=latest)](https://roms-tools.readthedocs.io/en/latest/?badge=latest)
+[![PyPI version](https://badge.fury.io/py/roms-tools.svg)](https://badge.fury.io/py/roms-tools)
+
+## Overview
+
+A suite of python tools for setting up a [ROMS](https://github.com/CESR-lab/ucla-roms) simulation.
+
+## Installation instructions
+
+### Installation from pip
+
+```bash
+pip install roms-tools
+```
+
+### Installation from GitHub
+
+To obtain the latest development version, clone the source repository and install it:
+
+```bash
+git clone https://github.com/CWorthy-ocean/roms-tools.git
+cd roms-tools
+pip install -e .
+```
+
+
+### Run the tests
+
+Before running the tests you can install and activate the following conda environment:
+
+```bash
+cd roms-tools
+conda env create -f ci/environment.yml
+conda activate romstools
+```
+
+Check the installation of `ROMS-Tools` has worked by running the test suite
+```bash
+pytest
+```
+
+## Getting Started
+
+To learn how to use `ROMS-Tools`, check out the [documentation](https://roms-tools.readthedocs.io/en/latest/).
+
+## Feedback and contributions
+
+**If you find a bug, have a feature suggestion, or any other kind of feedback, please start a Discussion.**
+
+We also accept contributions in the form of Pull Requests.
+
+
+## See also
+
+- [ROMS source code](https://github.com/CESR-lab/ucla-roms)
+- [C-Star](https://github.com/CWorthy-ocean/C-Star)

roms_tools-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+ci/environment.yml,sha256=OzTO5aTfzirFobAM6TmzJXZ622liCwIzreZH-x7n4mU,394
+roms_tools/__init__.py,sha256=9MiZw2yYthIwOrktbOKwNptyZPmMV4_p4aCK4HymzUM,489
+roms_tools/_version.py,sha256=FGsmFbZ942cZk42U_qHqxgRCbsD--5Vld_eR6xKJ-mQ,72
+roms_tools/setup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+roms_tools/setup/atmospheric_forcing.py,sha256=A6wPmEfjeCIO3tu4TLt4Sul_J6AnF_peWZdON3I_6iw,34790
+roms_tools/setup/datasets.py,sha256=0Hcsr7VzE-jo51kSMZ0ltHnIqc3fHe2v9lAC6ig2rH0,1943
+roms_tools/setup/fill.py,sha256=8Klt77rkJqyXQ54TUv75KK_5iHcAwH-3bBtO3eoBieM,8701
+roms_tools/setup/grid.py,sha256=p8AgCzUx5CkuxFcjFX6X65pYwEyOzxslx_nZDNJd-M4,26449
+roms_tools/setup/plot.py,sha256=LZjTB4NHpXGsju_VZSCBwTfyox08nXHh6TkqmNBvz5Y,1809
+roms_tools/setup/tides.py,sha256=aOez64Zv6MM1VFs1WIClKPpSg9vySvogqfqbg2eHKHA,20942
+roms_tools/setup/topography.py,sha256=hj_IEbMTaazEtp6rrNbqAtGgPesWcCs8eHko0XHEhJg,8010
+roms_tools/tests/test_setup.py,sha256=L90eM0IroRhYQ8ZY9BVOyUQND41lzdJKB_y2n7Aihmc,5102
+roms_tools-0.1.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+roms_tools-0.1.0.dist-info/METADATA,sha256=XtN4Icf1h7Sh_ZbL9OFNCr9wIkvRpqTuo95szsLNtcg,2567
+roms_tools-0.1.0.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+roms_tools-0.1.0.dist-info/top_level.txt,sha256=aAf4T4nYQSkay5iKJ9kmTjlDgd4ETdp9OSlB4sJdt8Y,19
+roms_tools-0.1.0.dist-info/RECORD,,

{roms_tools-0.0.6.dist-info → roms_tools-0.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (70.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{roms_tools-0.0.6.dist-info → roms_tools-0.1.0.dist-info}/top_level.txt

@@ -1,2 +1,3 @@
+ci
 dist
 roms_tools

roms_tools-0.0.6.dist-info/METADATA

@@ -1,134 +0,0 @@
-Metadata-Version: 2.1
-Name: roms-tools
-Version: 0.0.6
-Summary: Tools for running and analysing UCLA-ROMS simulations
-Author-email: Thomas Nicholas <tom@cworthy.org>
-License: Apache-2
-Project-URL: Home, https://github.com/CWorthy-ocean/roms-tools
-Project-URL: Documentation, https://github.com/CWorthy-ocean/roms-tools#readme
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: xarray >=2022.6.0
-Requires-Dist: numpy
-Requires-Dist: netcdf4
-Requires-Dist: matplotlib
-Requires-Dist: cartopy
-Requires-Dist: packaging
-
-# ROMS-tools
-
-## Overview
-
-A suite of python tools for setting up a [ROMS](https://github.com/CESR-lab/ucla-roms) simulation.
-
-_Note these tools are for the [Center for Earth Systems Research Group](http://research.atmos.ucla.edu/cesr/) at UCLA's version of ROMS._
-
-## Installation instructions
-
-Install via pip
-
-```bash
-pip install roms-tools
-```
-
-Check the installation has worked by running the tests (you will need to also install pytest to run these)
-```bash
-pytest
-```
-
-Dependencies required are xarray and netcdf4, plus matplotlib and cartopy for visualising grids.
-
-ROMS-tools should run on any platform that can install the above dependencies.
-
-
-## Usage instructions
-
-To set up all the input files for a new ROMS simulation from scratch, follow these steps in order.
-
-### Step 1: Make Grid
-
-The first step is choosing the domain size, location, and resolution. Do this by creating an instance of the `Grid` class:
-
-```python
-from roms_tools import Grid
-
-grid = Grid(
-    nx=100,          # number of points in the x-direction (not including 2 boundary cells on either end)
-    ny=100,          # number of points in the y-direction (not including 2 boundary cells on either end)
-    size_x=1800,     # size of the domain in the x-direction (in km)
-    size_y=2400,     # size of the domain in the y-direction (in km)
-    center_lon=-21,  # longitude of the center of the domain
-    center_lat=61,   # latitude of the center of the domain
-    rot=20,          # rotation of the grid's x-direction from lines of constant longitude, with positive values being a counter-clockwise rotation
-)
-```
-
-To visualize the grid we have just created, use the `.plot` method:
-
-```python
-grid.plot()
-```
-
-![iceland_grid](https://github.com/CWorthy-ocean/roms-tools/assets/35968931/de8c03ab-3c61-4ba5-a9b7-65592fd9280f)
-
-To see the values of the grid variables you can examine the `xarray.Dataset` object returned by the `.ds` property
-
-```python
-grid.ds
-```
-```
-<xarray.Dataset>
-Dimensions:    (eta_rho: 3, xi_rho: 3, one: 1)
-Dimensions without coordinates: eta_rho, xi_rho, one
-Data variables:
-    angle      (eta_rho, xi_rho) float64 0.0 0.0 0.0 -1.46e-16 ... 0.0 0.0 0.0
-    f0         (eta_rho, xi_rho) float64 4.565e-06 4.565e-06 ... -4.565e-06
-    pn         (eta_rho, xi_rho) float64 5e-06 5e-06 5e-06 ... 5e-06 5e-06 5e-06
-    lon_rho    (eta_rho, xi_rho) float64 339.1 340.0 340.9 ... 339.1 340.0 340.9
-    lat_rho    (eta_rho, xi_rho) float64 1.799 1.799 1.799 ... -1.799 -1.799
-    spherical  (one) <U1 'T'
-    tra_lon    (one) int64 -20
-    tra_lat    (one) int64 0
-    rotate     (one) int64 0
-Attributes:
-    Title:    ROMS grid. Settings: nx: 1 ny: 1  xsize: 0.1 ysize: 0.1 rotate:...
-    Date:     2023-11-20
-    Type:     ROMS grid produced by roms-tools
-```
-
-Once we are happy with our grid, we can save it as a netCDF file via the `.save` method:
-
-```python
-grid.save('grids/my_new_roms_grid.nc')
-```
-
-The basic grid domain is now ready for use by ROMS.
-
-
-### Steps 2-7:
-
-Coming soon!
-
-
-## Feedback and contributions
-
-**If you find a bug, have a feature suggestion, or any other kind of feedback, please start a Discussion.**
-
-We also accept contributions in the form of Pull Requests.
-
-
-## See also
-
-- [ROMS source code](https://github.com/CESR-lab/ucla-roms)
-- [C-Star](https://github.com/CWorthy-ocean/C-Star)