pyTMD 2.1.2__tar.gz → 2.1.4__tar.gz

{pytmd-2.1.2 → pytmd-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyTMD
-Version: 2.1.2
+Version: 2.1.4
 Summary: Tide Model Driver to read OTIS, GOT and FES formatted tidal solutions and make tidal predictions
 Home-page: https://github.com/tsutterley/pyTMD
 Author: Tyler Sutterley

{pytmd-2.1.2 → pytmd-2.1.4}/pyTMD/compute.py

@@ -62,6 +62,8 @@ PROGRAM DEPENDENCIES:
 UPDATE HISTORY:
     Updated 07/2024: assert that data type is a known value
         make number of days to convert JD to MJD a variable
+        added option to crop tide models to the domain of the input data
+        added option to use JSON format definition files
     Updated 06/2024: use np.clongdouble instead of np.longcomplex
     Updated 04/2024: use wrapper to importlib for optional dependencies
     Updated 02/2024: changed class name for ellipsoid parameters to datum
@@ -114,6 +116,7 @@ from __future__ import print_function, annotations
 import logging
 import pathlib
 import numpy as np
+from io import IOBase
 import scipy.interpolate
 import pyTMD.crs
 import pyTMD.io
@@ -183,7 +186,10 @@ def tide_elevations(
         MODEL: str | None = None,
         ATLAS_FORMAT: str = 'netcdf',
         GZIP: bool = False,
-        DEFINITION_FILE: str | pathlib.Path | None = None,
+        DEFINITION_FILE: str | pathlib.Path | IOBase | None = None,
+        DEFINITION_FORMAT: str = 'ascii',
+        CROP: bool = False,
+        BOUNDS: list | np.ndarray | None = None,
         EPSG: str | int = 3031,
         EPOCH: list | tuple = (2000, 1, 1, 0, 0, 0),
         TYPE: str | None = 'drift',
@@ -219,8 +225,17 @@ def tide_elevations(
             - ``'netcdf'``
     GZIP: bool, default False
         Tide model files are gzip compressed
-    DEFINITION_FILE: str or NoneType, default None
+    DEFINITION_FILE: str, pathlib.Path, io.IOBase or NoneType, default None
         Tide model definition file for use
+    DEFINITION_FORMAT: str, default 'ascii'
+        Format for model definition file
+
+            - ``'ascii'``: tab-delimited definition file
+            - ``'json'``: JSON formatted definition file
+    CROP: bool, default False
+        Crop tide model data to (buffered) bounds
+    BOUNDS: list, np.ndarray or NoneType, default None
+        Boundaries for cropping tide model data
     EPSG: int, default: 3031 (Polar Stereographic South, WGS84)
         Input coordinate system
     EPOCH: tuple, default (2000,1,1,0,0,0)
@@ -280,8 +295,8 @@ def tide_elevations(
 
     # get parameters for tide model
     if DEFINITION_FILE is not None:
-        model = pyTMD.io.model(DIRECTORY).from_file(
-            pathlib.Path(DEFINITION_FILE).expanduser())
+        model = pyTMD.io.model(DIRECTORY).from_file(DEFINITION_FILE,
+            format=DEFINITION_FORMAT)
     else:
         model = pyTMD.io.model(DIRECTORY, format=ATLAS_FORMAT,
             compressed=GZIP).elevation(MODEL)
@@ -323,28 +338,28 @@ def tide_elevations(
     if model.format in ('OTIS', 'ATLAS', 'TMD3'):
         amp,ph,D,c = pyTMD.io.OTIS.extract_constants(lon, lat, model.grid_file,
             model.model_file, model.projection, type=model.type,
-            method=METHOD, extrapolate=EXTRAPOLATE, cutoff=CUTOFF,
-            grid=model.format, apply_flexure=APPLY_FLEXURE)
+            crop=CROP, bounds=BOUNDS, method=METHOD, extrapolate=EXTRAPOLATE,
+            cutoff=CUTOFF, grid=model.format, apply_flexure=APPLY_FLEXURE)
         # use delta time at 2000.0 to match TMD outputs
         deltat = np.zeros((nt), dtype=np.float64)
     elif (model.format == 'netcdf'):
         amp,ph,D,c = pyTMD.io.ATLAS.extract_constants(lon, lat, model.grid_file,
-            model.model_file, type=model.type, method=METHOD,
-            extrapolate=EXTRAPOLATE, cutoff=CUTOFF, scale=model.scale,
-            compressed=model.compressed)
+            model.model_file, type=model.type, crop=CROP, bounds=BOUNDS, 
+            method=METHOD, extrapolate=EXTRAPOLATE, cutoff=CUTOFF,
+            scale=model.scale, compressed=model.compressed)
         # use delta time at 2000.0 to match TMD outputs
         deltat = np.zeros((nt), dtype=np.float64)
     elif (model.format == 'GOT'):
         amp,ph,c = pyTMD.io.GOT.extract_constants(lon, lat, model.model_file,
-            method=METHOD, extrapolate=EXTRAPOLATE, cutoff=CUTOFF,
-            scale=model.scale, compressed=model.compressed)
+            crop=CROP, bounds=BOUNDS, method=METHOD, extrapolate=EXTRAPOLATE,
+            cutoff=CUTOFF, scale=model.scale, compressed=model.compressed)
         # delta time (TT - UT1)
         deltat = ts.tt_ut1
     elif (model.format == 'FES'):
         amp,ph = pyTMD.io.FES.extract_constants(lon, lat, model.model_file,
-            type=model.type, version=model.version, method=METHOD,
-            extrapolate=EXTRAPOLATE, cutoff=CUTOFF, scale=model.scale,
-            compressed=model.compressed)
+            type=model.type, version=model.version, crop=CROP, bounds=BOUNDS,
+            method=METHOD, extrapolate=EXTRAPOLATE, cutoff=CUTOFF,
+            scale=model.scale, compressed=model.compressed)
         # available model constituents
         c = model.constituents
         # delta time (TT - UT1)
@@ -412,7 +427,10 @@ def tide_currents(
         MODEL: str | None = None,
         ATLAS_FORMAT: str = 'netcdf',
         GZIP: bool = False,
-        DEFINITION_FILE: str | pathlib.Path | None = None,
+        DEFINITION_FILE: str | pathlib.Path | IOBase | None = None,
+        DEFINITION_FORMAT: str = 'ascii',
+        CROP: bool = False,
+        BOUNDS: list | np.ndarray | None = None,
         EPSG: str | int = 3031,
         EPOCH: list | tuple = (2000, 1, 1, 0, 0, 0),
         TYPE: str | None = 'drift',
@@ -447,8 +465,17 @@ def tide_currents(
             - ``'netcdf'``
     GZIP: bool, default False
         Tide model files are gzip compressed
-    DEFINITION_FILE: str or NoneType, default None
+    DEFINITION_FILE: str, pathlib.Path, io.IOBase or NoneType, default None
         Tide model definition file for use
+    DEFINITION_FORMAT: str, default 'ascii'
+        Format for model definition file
+
+            - ``'ascii'``: tab-delimited definition file
+            - ``'json'``: JSON formatted definition file
+    CROP: bool, default False
+        Crop tide model data to (buffered) bounds
+    BOUNDS: list, np.ndarray or NoneType, default None
+        Boundaries for cropping tide model data
     EPSG: int, default: 3031 (Polar Stereographic South, WGS84)
         Input coordinate system
     EPOCH: tuple, default (2000,1,1,0,0,0)
@@ -504,8 +531,8 @@ def tide_currents(
 
     # get parameters for tide model
     if DEFINITION_FILE is not None:
-        model = pyTMD.io.model(DIRECTORY).from_file(
-            pathlib.Path(DEFINITION_FILE).expanduser())
+        model = pyTMD.io.model(DIRECTORY).from_file(DEFINITION_FILE,
+            format=DEFINITION_FORMAT)
     else:
         model = pyTMD.io.model(DIRECTORY, format=ATLAS_FORMAT,
             compressed=GZIP).current(MODEL)
@@ -551,22 +578,22 @@ def tide_currents(
         if model.format in ('OTIS', 'ATLAS', 'TMD3'):
             amp,ph,D,c = pyTMD.io.OTIS.extract_constants(lon, lat, model.grid_file,
                 model.model_file['u'], model.projection, type=t,
-                method=METHOD, extrapolate=EXTRAPOLATE, cutoff=CUTOFF,
-                grid=model.format)
+                crop=CROP, bounds=BOUNDS, method=METHOD, extrapolate=EXTRAPOLATE,
+                cutoff=CUTOFF, grid=model.format)
             # use delta time at 2000.0 to match TMD outputs
             deltat = np.zeros((nt), dtype=np.float64)
         elif (model.format == 'netcdf'):
             amp,ph,D,c = pyTMD.io.ATLAS.extract_constants(lon, lat, model.grid_file,
-                model.model_file[t], type=t, method=METHOD,
-                extrapolate=EXTRAPOLATE, cutoff=CUTOFF, scale=model.scale,
-                compressed=model.compressed)
+                model.model_file[t], type=t, crop=CROP, bounds=BOUNDS, 
+                method=METHOD, extrapolate=EXTRAPOLATE, cutoff=CUTOFF,
+                scale=model.scale, compressed=model.compressed)
             # use delta time at 2000.0 to match TMD outputs
             deltat = np.zeros((nt), dtype=np.float64)
         elif (model.format == 'FES'):
             amp,ph = pyTMD.io.FES.extract_constants(lon, lat, model.model_file[t],
-                type=t, version=model.version, method=METHOD,
-                extrapolate=EXTRAPOLATE, cutoff=CUTOFF, scale=model.scale,
-                compressed=model.compressed)
+                type=t, version=model.version, crop=CROP, bounds=BOUNDS, 
+                method=METHOD, extrapolate=EXTRAPOLATE, cutoff=CUTOFF,
+                scale=model.scale, compressed=model.compressed)
             # available model constituents
             c = model.constituents
             # delta time (TT - UT1)

{pytmd-2.1.2 → pytmd-2.1.4}/pyTMD/crs.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 u"""
 crs.py
-Written by Tyler Sutterley (05/2024)
+Written by Tyler Sutterley (07/2024)
 Coordinates Reference System (CRS) routines
 
 CALLING SEQUENCE:
@@ -30,6 +30,7 @@ PYTHON DEPENDENCIES:
         https://pyproj4.github.io/pyproj/
 
 UPDATE HISTORY:
+    Updated 07/2024: added function to get the CRS transform
     Updated 05/2024: make subscriptable and allow item assignment
     Updated 04/2024: use wrapper to importlib for optional dependencies
     Updated 02/2024: changed class name for ellipsoid parameters to datum
@@ -106,6 +107,34 @@ class crs:
         o2: np.ndarray
             Output transformed y-coordinates
         """
+        # name of the projection
+        self.name = PROJ
+        # set the transform and transform direction
+        self.get(PROJ, EPSG=EPSG)
+        self._direction = BF[0].upper()
+        # run conversion program and return values
+        return self.transform(i1, i2)
+
+    # PURPOSE: try to get the projection information
+    def get(self, PROJ: str, EPSG: int | str = 4326):
+        """
+        Tries to get the CRS transformer for given values
+
+        Parameters
+        ----------
+        PROJ: str
+            Spatial reference system code for coordinate transformations
+        EPSG: int or str, default 4326 (WGS84 Latitude/Longitude)
+            input (``'F'``) or output (``'B'``) coordinate system
+
+        Returns
+        -------
+        o1: np.ndarray
+            Output transformed x-coordinates
+        o2: np.ndarray
+            Output transformed y-coordinates
+        """
+        # name of the projection
         self.name = PROJ
         # python dictionary with named conversion functions
         transforms = {}
@@ -115,8 +144,6 @@ class crs:
         transforms['3976'] = self._EPSG3976
         transforms['PSNorth'] = self._PSNorth
         transforms['4326'] = self._EPSG4326
-        # set the direction of the transform
-        self._direction = BF.upper()
         # check that PROJ for conversion was entered correctly
         # run named conversion program and return values
         try:
@@ -125,7 +152,7 @@ class crs:
             pass
         else:
             # return the output variables
-            return self.transform(i1, i2)
+            return self
         # try changing the projection using a custom projection
         # run custom conversion program and return values
         try:
@@ -133,11 +160,14 @@ class crs:
         except Exception as exc:
             pass
         else:
-            return self.transform(i1, i2)
+            return self
         # projection not found or available
         raise Exception(f'PROJ: {PROJ} conversion function not found')
 
-    def transform(self, i1: np.ndarray, i2: np.ndarray):
+    def transform(self,
+            i1: np.ndarray,
+            i2: np.ndarray,
+            **kwargs):
         """
         Performs Coordinates Reference System (CRS) transformations
 
@@ -147,6 +177,8 @@ class crs:
             Input x-coordinates
         i2: np.ndarray
             Input y-coordinates
+        kwargs: dict
+            Keyword arguments for the transformation
 
         Returns
         -------
@@ -155,10 +187,11 @@ class crs:
         o2: np.ndarray
             Output transformed y-coordinates
         """
+        # set the direction of the transformation
+        kwargs.setdefault('direction', self.direction)
         if (self.name == 'PSNorth') and (self.direction.name == 'FORWARD'):
             # convert input coordinate reference system to lat/lon
-            lon, lat = self.transformer.transform(i1, i2,
-                direction=self.direction)
+            lon, lat = self.transformer.transform(i1, i2, **kwargs)
             # convert lat/lon to (idealized) Polar-Stereographic x/y
             o1 = (90.0 - lat)*111.7*np.cos(lon/180.0*np.pi)
             o2 = (90.0 - lat)*111.7*np.sin(lon/180.0*np.pi)
@@ -170,12 +203,10 @@ class crs:
             ii, = np.nonzero(lon < 0)
             lon[ii] += 360.0
             # convert to output coordinate reference system
-            o1, o2 = self.transformer.transform(lon, lat,
-                direction=self.direction)
+            o1, o2 = self.transformer.transform(lon, lat, **kwargs)
         else:
             # convert coordinate reference system
-            o1, o2 = self.transformer.transform(i1, i2,
-                direction=self.direction)
+            o1, o2 = self.transformer.transform(i1, i2, **kwargs)
         # return the transformed coordinates
         return (o1, o2)
 
@@ -340,12 +371,22 @@ class crs:
         ``pyproj`` direction of the coordinate transform
         """
         # convert from input coordinates to model coordinates
-        if (self._direction.upper() == 'F'):
+        if (self._direction is None) or (self._direction.upper() == 'F'):
             return pyproj.enums.TransformDirection.FORWARD
         # convert from model coordinates to coordinates
         elif (self._direction.upper() == 'B'):
             return pyproj.enums.TransformDirection.INVERSE
 
+    @property
+    def is_geographic(self):
+        """
+        Check if the coordinate reference system is geographic
+        """
+        if (self.name == 'PSNorth'):
+            return False
+        else:
+            return self.transformer.target_crs.is_geographic
+
     def __str__(self):
         """String representation of the ``crs`` object
         """

{pytmd-2.1.2 → pytmd-2.1.4}/pyTMD/interpolate.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 u"""
 interpolate.py
-Written by Tyler Sutterley (12/2022)
+Written by Tyler Sutterley (07/2024)
 Interpolators for spatial data
 
 PYTHON DEPENDENCIES:
@@ -12,6 +12,7 @@ PYTHON DEPENDENCIES:
         https://docs.scipy.org/doc/
 
 UPDATE HISTORY:
+    Updated 07/2024: changed projection flag in extrapolation to is_geographic
     Written 12/2022
 """
 from __future__ import annotations
@@ -275,7 +276,7 @@ def extrapolate(
         fill_value: float = None,
         dtype: str | np.dtype = np.float64,
         cutoff: int | float = np.inf,
-        EPSG: str | int = '4326',
+        is_geographic: bool = True,
         **kwargs
     ):
     """
@@ -303,14 +304,17 @@ def extrapolate(
         return only neighbors within distance [km]
 
         Set to ``np.inf`` to extrapolate for all points
-    EPSG: str, default '4326'
-        projection of tide model data
+    is_geographic: bool, default True
+        input grid is in geographic coordinates
 
     Returns
     -------
     DATA: np.ndarray
         interpolated data
     """
+    # set geographic flag if using old EPSG projection keyword
+    if hasattr(kwargs, 'EPSG') and (kwargs['EPSG'] == '4326'):
+        is_geographic = True
     # verify output dimensions
     lon = np.atleast_1d(lon)
     lat = np.atleast_1d(lat)
@@ -332,7 +336,7 @@ def extrapolate(
     valid_bounds = np.ones_like(idata.mask, dtype=bool)
 
     # calculate coordinates for nearest-neighbors
-    if (EPSG == '4326'):
+    if is_geographic:
         # global or regional equirectangular model
         # calculate meshgrid of model coordinates
         gridlon, gridlat = np.meshgrid(ilon, ilat)

{pytmd-2.1.2 → pytmd-2.1.4}/pyTMD/io/ATLAS.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 u"""
 ATLAS.py
-Written by Tyler Sutterley (02/2024)
+Written by Tyler Sutterley (07/2024)
 
 Reads files for a tidal model and makes initial calculations to run tide program
 Includes functions to extract tidal harmonic constants from OTIS tide models for
@@ -55,6 +55,7 @@ PROGRAM DEPENDENCIES:
     interpolate.py: interpolation routines for spatial data
 
 UPDATE HISTORY:
+    Updated 07/2024: added crop and bounds keywords for trimming model data
     Updated 02/2024: changed variable for setting global grid flag to is_global
     Updated 10/2023: add generic wrapper function for reading constituents
     Updated 04/2023: using pathlib to define and expand tide model paths
@@ -141,6 +142,10 @@ def extract_constants(
             - ``'U'``: horizontal depth-averaged transport
             - ``'v'``: vertical transport velocities
             - ``'V'``: vertical depth-averaged transport
+    crop: bool, default False
+        Crop tide model data to (buffered) bounds
+    bounds: list or NoneType, default None
+        Boundaries for cropping tide model data
     method: str, default 'spline'
         Interpolation method
 
@@ -171,6 +176,7 @@ def extract_constants(
     """
     # set default keyword arguments
     kwargs.setdefault('type', 'z')
+    kwargs.setdefault('crop', False)
     kwargs.setdefault('method', 'spline')
     kwargs.setdefault('extrapolate', False)
     kwargs.setdefault('cutoff', 10.0)
@@ -204,9 +210,24 @@ def extract_constants(
     # adjust dimensions of input coordinates to be iterable
     ilon = np.atleast_1d(np.copy(ilon))
     ilat = np.atleast_1d(np.copy(ilat))
-    # adjust longitudinal convention of input latitude and longitude
-    # to fit tide model convention
-    if (np.min(ilon) < 0.0) & (np.max(lon) > 180.0):
+    # set default bounds if cropping
+    xmin, xmax = np.min(ilon), np.max(ilon)
+    ymin, ymax = np.min(ilat), np.max(ilat)
+    kwargs.setdefault('bounds', [xmin, xmax, ymin, ymax])
+    # grid step size of tide model
+    dlon = lon[1] - lon[0]
+    # if global: extend limits
+    is_global = False
+
+    # crop bathymetry data to (buffered) bounds
+    # or adjust longitudinal convention to fit tide model
+    if kwargs['crop'] and np.any(kwargs['bounds']):
+        mlon, mlat = np.copy(lon), np.copy(lat)
+        bathymetry, lon, lat = _crop(bathymetry, mlon, mlat,
+            bounds=kwargs['bounds'],
+            buffer=4*dlon
+        )
+    elif (np.min(ilon) < 0.0) & (np.max(lon) > 180.0):
         # input points convention (-180:180)
         # tide model convention (0:360)
         ilon[ilon < 0.0] += 360.0
@@ -215,10 +236,6 @@ def extract_constants(
         # tide model convention (-180:180)
         ilon[ilon > 180.0] -= 360.0
 
-    # grid step size of tide model
-    dlon = lon[1] - lon[0]
-    # if global: extend limits
-    is_global = False
     # replace original values with extend arrays/matrices
     if np.isclose(lon[-1] - lon[0], 360.0 - dlon):
         lon = _extend_array(lon, dlon)
@@ -280,6 +297,12 @@ def extract_constants(
             compressed=kwargs['compressed'])
         # append constituent to list
         constituents.append(cons)
+        # crop tide model data to (buffered) bounds
+        if kwargs['crop'] and np.any(kwargs['bounds']):
+            hc, _, _ = _crop(hc, mlon, mlat,
+                bounds=kwargs['bounds'],
+                buffer=4*dlon
+            )
         # replace original values with extend matrices
         if is_global:
             hc = _extend_matrix(hc)
@@ -366,6 +389,10 @@ def read_constants(
             - ``'V'``: vertical depth-averaged transport
     compressed: bool, default False
         Input files are gzip compressed
+    crop: bool, default False
+        Crop tide model data to (buffered) bounds
+    bounds: list or NoneType, default None
+        Boundaries for cropping tide model data
 
     Returns
     -------
@@ -375,6 +402,8 @@ def read_constants(
     # set default keyword arguments
     kwargs.setdefault('type', 'z')
     kwargs.setdefault('compressed', True)
+    kwargs.setdefault('crop', False)
+    kwargs.setdefault('bounds', None)
 
     # raise warning if model files are entered as a string or path
     if isinstance(model_files, (str, pathlib.Path)):
@@ -389,12 +418,21 @@ def read_constants(
     # read the tide grid file for bathymetry and spatial coordinates
     lon, lat, bathymetry = read_netcdf_grid(grid_file, kwargs['type'],
         compressed=kwargs['compressed'])
+    is_global = False
 
+    # crop bathymetry data to (buffered) bounds
+    if kwargs['crop'] and np.any(kwargs['bounds']):
+        mlon, mlat = np.copy(lon), np.copy(lat)
+        bathymetry, lon, lat = _crop(bathymetry, mlon, mlat,
+            bounds=kwargs['bounds'],
+        )
     # grid step size of tide model
     dlon = lon[1] - lon[0]
     # replace original values with extend arrays/matrices
-    lon = _extend_array(lon, dlon)
-    bathymetry = _extend_matrix(bathymetry)
+    if np.isclose(lon[-1] - lon[0], 360.0 - dlon):
+        lon = _extend_array(lon, dlon)
+        bathymetry = _extend_matrix(bathymetry)
+        is_global = True
     # save output constituents
     constituents = pyTMD.io.constituents(
         longitude=lon,
@@ -412,8 +450,15 @@ def read_constants(
         # read constituent from netCDF4 file
         hc, cons = read_netcdf_file(model_file, kwargs['type'],
             compressed=kwargs['compressed'])
+        # crop tide model data to (buffered) bounds
+        if kwargs['crop'] and np.any(kwargs['bounds']):
+            hc, lon, lat = _crop(hc, mlon, mlat,
+                bounds=kwargs['bounds'],
+            )
         # replace original values with extend matrices
-        hc = _extend_matrix(hc)
+        if is_global:
+            hc = _extend_matrix(hc)
+        # set constituent masks
         hc.mask[:] |= bathymetry.mask[:]
         # append extended constituent
         constituents.append(cons,  hc)
@@ -1171,8 +1216,128 @@ def _extend_matrix(input_matrix: np.ndarray):
         extended matrix
     """
     ny, nx = np.shape(input_matrix)
-    temp = np.ma.zeros((ny,nx+2), dtype=input_matrix.dtype)
+    # allocate for extended matrix
+    if np.ma.isMA(input_matrix):
+        temp = np.ma.zeros((ny,nx+2), dtype=input_matrix.dtype)
+    else:
+        temp = np.zeros((ny,nx+2), dtype=input_matrix.dtype)
+    # extend matrix
     temp[:,0] = input_matrix[:,-1]
     temp[:,1:-1] = input_matrix[:,:]
     temp[:,-1] = input_matrix[:,0]
     return temp
+
+# PURPOSE: crop tide model data to bounds
+def _crop(
+        input_matrix: np.ndarray,
+        ilon: np.ndarray,
+        ilat: np.ndarray,
+        bounds: list | tuple,
+        buffer: int | float = 0
+    ):
+    """
+    Crop tide model data to bounds
+
+    Parameters
+    ----------
+    input_matrix: np.ndarray
+        matrix to crop
+    ilon: np.ndarray
+        longitude of tidal model
+    ilat: np.ndarray
+        latitude of tidal model
+    bounds: list, tuple
+        bounding box: ``[xmin, xmax, ymin, ymax]``
+    buffer: int or float, default 0
+        buffer to add to bounds for cropping
+
+    Returns
+    -------
+    temp: np.ndarray
+        cropped matrix
+    lon: np.ndarray
+        cropped longitude
+    lat: np.ndarray
+        cropped latitude
+    """
+    # adjust longitudinal convention of tide model
+    if (np.min(bounds[:2]) < 0.0) & (np.max(ilon) > 180.0):
+        input_matrix, ilon = _shift(input_matrix, ilon,
+            lon0=180.0, cyclic=360.0, direction='west')
+    elif (np.max(bounds[:2]) > 180.0) & (np.min(ilon) < 0.0):
+        input_matrix, ilon = _shift(input_matrix, ilon,
+            lon0=0.0, cyclic=360.0, direction='east')
+    # unpack bounds and buffer
+    xmin = bounds[0] - buffer
+    xmax = bounds[1] + buffer
+    ymin = bounds[2] - buffer
+    ymax = bounds[3] + buffer
+    # find indices for cropping
+    yind = np.flatnonzero((ilat >= ymin) & (ilat <= ymax))
+    xind = np.flatnonzero((ilon >= xmin) & (ilon <= xmax))
+    # slices for cropping axes
+    rows = slice(yind[0], yind[-1]+1)
+    cols = slice(xind[0], xind[-1]+1)
+    # crop matrix
+    temp = input_matrix[rows, cols]
+    lon = ilon[cols]
+    lat = ilat[rows]
+    # return cropped data
+    return (temp, lon, lat)
+
+# PURPOSE: shift a grid east or west
+def _shift(
+        input_matrix: np.ndarray,
+        ilon: np.ndarray,
+        lon0: int | float = 180,
+        cyclic: int | float = 360,
+        direction: str = 'west'
+    ):
+    """
+    Shift global grid east or west to a new base longitude
+
+    Parameters
+    ----------
+    input_matrix: np.ndarray
+        input matrix to shift
+    ilon: np.ndarray
+        longitude of tidal model
+    lon0: int or float, default 180
+        Starting longitude for shifted grid
+    cyclic: int or float, default 360
+        width of periodic domain
+    direction: str, default 'west'
+        Direction to shift grid
+
+            - ``'west'``
+            - ``'east'``
+
+    Returns
+    -------
+    temp: np.ndarray
+        shifted matrix
+    lon: np.ndarray
+        shifted longitude
+    """
+    # find the starting index if cyclic
+    offset = 0 if (np.fabs(ilon[-1]-ilon[0]-cyclic) > 1e-4) else 1
+    i0 = np.argmin(np.fabs(ilon - lon0))
+    # shift longitudinal values
+    lon = np.zeros(ilon.shape, ilon.dtype)
+    lon[0:-i0] = ilon[i0:]
+    lon[-i0:] = ilon[offset: i0+offset]
+    # add or remove the cyclic
+    if (direction == 'east'):
+        lon[-i0:] += cyclic
+    elif (direction == 'west'):
+        lon[0:-i0] -= cyclic
+    # allocate for shifted data
+    if np.ma.isMA(input_matrix):
+        temp = np.ma.zeros(input_matrix.shape,input_matrix.dtype)
+    else:
+        temp = np.zeros(input_matrix.shape, input_matrix.dtype)
+    # shift data values
+    temp[:,:-i0] = input_matrix[:,i0:]
+    temp[:,-i0:] = input_matrix[:,offset: i0+offset]
+    # return the shifted values
+    return (temp, lon)