Source code for opendrift.readers.basereader.unstructured

from abc import abstractmethod
import numpy as np
import scipy
import logging
logger = logging.getLogger(__name__)

from .variables import Variables

[docs] class UnstructuredReader(Variables): """ An unstructured reader. Data is gridded irregularily. The initial type of grid that this class supports are `triangular prisms <>`_. Unstructured in xy-coordinates, x and y is constant in z. z might be non-cartesian (e.g. sigma-levels). .. seealso:: :py:mod:`opendrift.readers` :class:`.structured.StructuredReader` """ # Number of parallel threads to use when possible PARALLEL_WORKERS = -1 boundary = None # nodes x = None y = None node_variables = None # list of std-name variables defined at nodes nodes_idx = None # faces xc = None yc = None face_variables = None # list of std-name variables defined at center of faces faces_idx = None def __init__(self): super().__init__()
[docs] @abstractmethod def get_variables(self, variables, time=None, x=None, y=None, z=None): """ Obtain and return values of the requested variables at all positions (x, y, z) closest to given time. Returns: Dictionary with arrays of length len(time) with values at exact positions x, y and z. """
[docs] def _get_variables_interpolated_(self, variables, profiles, profiles_depth, time, reader_x, reader_y, z): env = self.get_variables(variables, time, reader_x, reader_y, z) # We probably have to use an UnstructuredBlock to store closest time-steps, and thus avoid fetching # more data on every call. logger.debug('Fetched env-before') env_profiles = None if profiles is not None: # Copying data from environment to vertical profiles env_profiles = {'z': [0, -profiles_depth]} for var in profiles: env_profiles[var] =[env[var], env[var]]) return env, env_profiles
[docs] def _build_boundary_polygon_(self, x, y): """ Build a polygon of the boundary of the mesh. Arguments: :param x: Array of node x position, lenght N :param y: Array of node y position, length N Returns: A `shapely.prepareped.prep` `shapely.Polygon`. The boundary of the mesh, ideally including holes in the mesh. Algorithms: .. note:: Try this alogrithm: Boundary edges (line between two nodes) are only referenced by a single triangle. 1. Find a starting edge segment: [v_start, v_next] (v is vertex or node) 2. Find another _unvisited_ edge segment [v_i, v_j] that has either v_i = v_next or v_j = v_next and add the one not equal to v_next to the polygon. 3. Reset v_next to the newly added point. Mark edge as visited. 4. Continue untill we reach v_start. The polygon has a rotation, but this should not matter for our purpose of checking the bounds. Note: In order to find holes in the polygon all points must be scanned. Approximate using the convex hull: An alternative simple approximation is to use the convex hull of the points, but this will miss points along the boundary which form a wedge in the boundary (as well as holes in the mesh). Holes in the mesh will often be covered by the landmask anyway, so they will usually not be a problem. """ from shapely.geometry import Polygon from shapely.prepared import prep from scipy.spatial import ConvexHull P = np.vstack((x, y)).T hull = ConvexHull(P) boundary = P[hull.vertices, :] boundary = prep(Polygon(boundary)) return boundary
[docs] def covers_positions(self, x, y, z=0): """ Check which points are within boundary of mesh. """ assert self.boundary is not None, "Boundary of mesh has not been prepared by reader" # TODO: Check z coordinates logger.warning("z-coordinates are not bounds-checked") from shapely.vectorized import contains return contains(self.boundary, x, y)
[docs] def _build_rtree_(self, x, y): """ Builds an R-tree of x, y """ from rtree import index data = ((i, (xy[0], xy[1], xy[0], xy[1]), None) for i, xy in enumerate(zip(x, y))) idx = index.Index(data) return idx
[docs] def _build_ckdtree_(self, x, y): from scipy.spatial import cKDTree P = np.vstack((x, y)).T return cKDTree(P)
[docs] def __nearest_ckdtree__(self, idx, x, y): """ Return index of nearest point in cKDTree """ q = np.vstack((x, y)).T return idx.query(q, k = 1, workers = self.PARALLEL_WORKERS)[1]
[docs] @staticmethod def __nearest_rtree__(idx, x, y): """ Take array of points and get nearest point in rtree index. """ return [idx.nearest((x, y, x, y), objects = False) for x, y in zip(x, y)]
[docs] def _nearest_node_(self, x, y): """ Return nearest node (id) for x and y """ return self.__nearest_ckdtree__(self.nodes_idx, x, y)
[docs] def _nearest_face_(self, xc, yc): """ Return nearest element or face (id) for xc and yc """ return self.__nearest_ckdtree__(self.faces_idx, xc, yc)