diff --git a/mikeio/dfs.py b/mikeio/dfs.py index 5b97de588..1cf7af8ae 100644 --- a/mikeio/dfs.py +++ b/mikeio/dfs.py @@ -2,9 +2,10 @@ from abc import abstractmethod from datetime import datetime, timedelta from typing import Iterable, List, Optional, Tuple, Union - import numpy as np import pandas as pd +from tqdm import tqdm, trange + from copy import deepcopy from mikecore.DfsFactory import DfsFactory from mikecore.DfsFile import ( @@ -16,7 +17,7 @@ ) from mikecore.DfsFileFactory import DfsFileFactory from mikecore.eum import eumQuantity -from tqdm import tqdm, trange +from mikecore.Projections import Cartography from .base import TimeSeries from .dataset import Dataset @@ -751,3 +752,25 @@ def orientation(self): def dx(self): """Step size in x direction""" pass + + def _validate_no_orientation_in_geo(self): + if self.is_geo and abs(self._orientation) > 1e-6: + raise ValueError("Orientation is not supported for LONG/LAT coordinates") + + def _origin_and_orientation_in_CRS(self): + """Project origin and orientation to projected CRS (if not LONG/LAT)""" + if self.is_geo: + origin = self._longitude, self._latitude + orientation = 0.0 + else: + lon, lat = self._longitude, self._latitude + cart = Cartography.CreateGeoOrigin( + projectionString=self._projstr, + lonOrigin=lon, + latOrigin=lat, + orientation=self._orientation, + ) + # convert origin and orientation to projected CRS + origin = tuple(np.round(cart.Geo2Proj(lon, lat), 6)) + orientation = cart.OrientationProj + return origin, orientation diff --git a/mikeio/dfs2.py b/mikeio/dfs2.py index 34aff6017..c882af7a9 100644 --- a/mikeio/dfs2.py +++ b/mikeio/dfs2.py @@ -1,14 +1,14 @@ import os from copy import deepcopy - import numpy as np import pandas as pd +from tqdm import tqdm + from mikecore.DfsFactory import DfsBuilder, DfsFactory from mikecore.DfsFile import DfsFile, DfsSimpleType from mikecore.DfsFileFactory import DfsFileFactory from mikecore.eum import eumQuantity, eumUnit from mikecore.Projections import Cartography -from tqdm import tqdm from . import __dfs_version__ from .dataset import Dataset @@ -44,14 +44,14 @@ def _write_dfs2_header(filename, ds: Dataset, title="") -> DfsFile: factory = DfsFactory() _write_dfs2_spatial_axis(builder, factory, geometry) - proj = geometry.projection_string + proj_str = geometry.projection_string origin = geometry.origin orient = geometry.orientation if geometry.is_geo: - proj = factory.CreateProjectionGeoOrigin(proj, *origin, orient) + proj = factory.CreateProjectionGeoOrigin(proj_str, *origin, orient) else: - cart: Cartography = Cartography.CreateProjOrigin(proj, *origin, orient) + cart: Cartography = Cartography.CreateProjOrigin(proj_str, *origin, orient) proj = factory.CreateProjectionGeoOrigin( wktProjectionString=geometry.projection, lon0=cart.LonOrigin, @@ -105,62 +105,35 @@ class Dfs2(_Dfs123): _ndim = 2 - def __init__(self, filename=None, type="horizontal"): + def __init__(self, filename=None, type: str = "horizontal"): super().__init__(filename) self._dx = None self._dy = None self._nx = None self._ny = None - self._x0 = 0 - self._y0 = 0 + self._x0 = 0.0 + self._y0 = 0.0 self.geometry = None if filename: - self._read_dfs2_header() - is_spectral = type == "spectral" - - if self._projstr == "LONG/LAT": - if np.abs(self._orientation) < 1e-6: - origin = self._longitude, self._latitude - self.geometry = Grid2D( - dx=self._dx, - dy=self._dy, - nx=self._nx, - ny=self._ny, - x0=self._x0, - y0=self._y0, - origin=origin, - projection=self._projstr, - is_spectral=is_spectral, - ) - else: - raise ValueError( - "LONG/LAT with non-zero orientation is not supported" - ) - else: - lon, lat = self._longitude, self._latitude - cart = Cartography.CreateGeoOrigin( - projectionString=self._projstr, - lonOrigin=self._longitude, - latOrigin=self._latitude, - orientation=self._orientation, - ) - origin_projected = np.round(cart.Geo2Proj(lon, lat), 7) - orientation_projected = cart.OrientationProj - - self.geometry = Grid2D( - dx=self._dx, - dy=self._dy, - nx=self._nx, - ny=self._ny, - x0=self._x0, - y0=self._y0, - orientation=orientation_projected, - origin=origin_projected, - projection=self._projstr, - is_spectral=is_spectral, - ) + is_spectral = type.lower() in ["spectral", "spectra", "spectrum"] + self._read_dfs2_header(read_x0y0=is_spectral) + self._validate_no_orientation_in_geo() + origin, orientation = self._origin_and_orientation_in_CRS() + + self.geometry = Grid2D( + dx=self._dx, + dy=self._dy, + nx=self._nx, + ny=self._ny, + x0=self._x0, + y0=self._y0, + orientation=orientation, + origin=origin, + projection=self._projstr, + is_spectral=is_spectral, + ) def __repr__(self): out = [""] @@ -185,14 +158,15 @@ def __repr__(self): return str.join("\n", out) - def _read_dfs2_header(self): + def _read_dfs2_header(self, read_x0y0: bool = False): if not os.path.isfile(self._filename): raise Exception(f"file {self._filename} does not exist!") self._dfs = DfsFileFactory.Dfs2FileOpen(self._filename) self._source = self._dfs - self._x0 = self._dfs.SpatialAxis.X0 - self._y0 = self._dfs.SpatialAxis.Y0 + if read_x0y0: + self._x0 = self._dfs.SpatialAxis.X0 + self._y0 = self._dfs.SpatialAxis.Y0 self._dx = self._dfs.SpatialAxis.Dx self._dy = self._dfs.SpatialAxis.Dy self._nx = self._dfs.SpatialAxis.XCount diff --git a/mikeio/dfs3.py b/mikeio/dfs3.py index 8a1a71e21..5e551ce2d 100644 --- a/mikeio/dfs3.py +++ b/mikeio/dfs3.py @@ -2,11 +2,13 @@ import numpy as np import pandas as pd + from mikecore.DfsBuilder import DfsBuilder from mikecore.DfsFactory import DfsFactory from mikecore.DfsFile import DfsFile, DfsSimpleType from mikecore.DfsFileFactory import DfsFileFactory from mikecore.eum import eumQuantity, eumUnit +from mikecore.Projections import Cartography from . import __dfs_version__ from .dataset import Dataset @@ -34,23 +36,23 @@ def _write_dfs3_header(filename, ds: Dataset, title="") -> DfsFile: factory = DfsFactory() _write_dfs3_spatial_axis(builder, factory, geometry) - origin = geometry._origin # Origin in geographical coordinates - orient = geometry._orientation + origin = geometry.origin # Origin in geographical coordinates + orient = geometry.orientation - # if geometry.is_geo: - proj = factory.CreateProjectionGeoOrigin( - geometry.projection_string, *origin, orient - ) - # else: - # cart: Cartography = Cartography.CreateProjOrigin( - # geometry.projection_string, *origin, orient - # ) - # proj = factory.CreateProjectionGeoOrigin( - # wktProjectionString=geometry.projection, - # lon0=cart.LonOrigin, - # lat0=cart.LatOrigin, - # orientation=cart.Orientation, - # ) + if geometry.is_geo: + proj = factory.CreateProjectionGeoOrigin( + geometry.projection_string, *origin, orient + ) + else: + cart: Cartography = Cartography.CreateProjOrigin( + geometry.projection_string, *origin, orient + ) + proj = factory.CreateProjectionGeoOrigin( + wktProjectionString=geometry.projection, + lon0=cart.LonOrigin, + lat0=cart.LatOrigin, + orientation=cart.Orientation, + ) builder.SetGeographicalProjection(proj) @@ -110,13 +112,16 @@ def __init__(self, filename=None): self._nx = None self._ny = None self._nz = None - self._x0 = 0 - self._y0 = 0 - self._z0 = 0 + self._x0 = 0.0 + self._y0 = 0.0 + self._z0 = 0.0 self.geometry = None if filename: self._read_dfs3_header() + self._validate_no_orientation_in_geo() + origin, orientation = self._origin_and_orientation_in_CRS() + self.geometry = Grid3D( x0=self._x0, dx=self._dx, @@ -127,9 +132,9 @@ def __init__(self, filename=None): z0=self._z0, dz=self._dz, nz=self._nz, - origin=(self._longitude, self._latitude), + origin=origin, projection=self._projstr, - orientation=self._orientation, + orientation=orientation, ) def __repr__(self): @@ -154,17 +159,19 @@ def __repr__(self): return str.join("\n", out) - def _read_dfs3_header(self): + def _read_dfs3_header(self, read_x0y0z0: bool = False): if not os.path.isfile(self._filename): raise Exception(f"file {self._filename} does not exist!") self._dfs = DfsFileFactory.Dfs3FileOpen(self._filename) - self.source = self._dfs + self._source = self._dfs + + if read_x0y0z0: + self._x0 = self._dfs.SpatialAxis.X0 + self._y0 = self._dfs.SpatialAxis.Y0 + self._z0 = self._dfs.SpatialAxis.Z0 - self._x0 = self._dfs.SpatialAxis.X0 - self._y0 = self._dfs.SpatialAxis.Y0 - self._z0 = self._dfs.SpatialAxis.Z0 self._dx = self._dfs.SpatialAxis.Dx self._dy = self._dfs.SpatialAxis.Dy self._dz = self._dfs.SpatialAxis.Dz @@ -406,3 +413,8 @@ def dz(self): @property def shape(self): return (self._n_timesteps, self._nz, self._ny, self._nx) + + @property + def is_geo(self): + """Are coordinates geographical (LONG/LAT)?""" + return self._projstr == "LONG/LAT" diff --git a/mikeio/spatial/grid_geometry.py b/mikeio/spatial/grid_geometry.py index 1174f3b9c..f6f1b14f9 100644 --- a/mikeio/spatial/grid_geometry.py +++ b/mikeio/spatial/grid_geometry.py @@ -1,10 +1,10 @@ import warnings -from typing import Sequence, Tuple, Union - +from typing import Optional, Sequence, Tuple, Union from dataclasses import dataclass - import numpy as np +from mikecore.Projections import Cartography # type: ignore + from .geometry import ( BoundingBox, GeometryPoint2D, @@ -57,6 +57,23 @@ class Grid1D(_Geometry): """1D grid (node-based) axis is increasing and equidistant + Parameters + ---------- + x : array_like + node coordinates + x0 : float + first node coordinate + dx : float + grid spacing + nx : int + number of nodes + projection : str + projection string + origin : tuple + not commonly used + orientation : float + not commonly used + Examples -------- >>> mikeio.Grid1D(nx=3,dx=0.1) @@ -89,7 +106,8 @@ def __init__( ): """Create equidistant 1D spatial geometry""" super().__init__(projection) - self._origin = origin + self._origin = (0.0, 0.0) if origin is None else tuple(origin) + assert len(self._origin) == 2, "origin must be a tuple of length 2" self._orientation = orientation self._x0, self._dx, self._nx = _parse_grid_axis("x", x, x0, dx, nx) @@ -114,7 +132,7 @@ def find_index(self, x: float, **kwargs) -> int: """Find nearest point""" d = (self.x - x) ** 2 - return np.argmin(d) + return int(np.argmin(d)) def get_spatial_interpolant(self, coords, **kwargs): @@ -160,8 +178,35 @@ def origin(self) -> Tuple[float, float]: def orientation(self) -> float: return self._orientation - def isel(self, idx, axis=0): - """Get a subset geometry from this geometry""" + def isel( + self, idx, axis=None + ) -> Union[GeometryPoint2D, GeometryPoint3D, GeometryUndefined]: + """Get a subset geometry from this geometry + + Parameters + ---------- + idx : int or slice + index or slice + axis : int, optional + Not used for Grid1D, by default None + + Returns + ------- + GeometryPoint2D or GeometryPoint3D or GeometryUndefined + The geometry of the selected point + + Examples + -------- + >>> g = mikeio.Grid1D(nx=3,dx=0.1) + >>> g + + x: [0, 0.1, 0.2] (nx=3, dx=0.1) + >>> g.isel([1,2]) + + x: [0.1, 0.2] (nx=2, dx=0.1) + >>> g.isel(1) + GeometryUndefined() + """ if not np.isscalar(idx): nc = None if self._nc is None else self._nc[idx, :] @@ -204,7 +249,7 @@ def __call__(self, ax=None, figsize=None, **kwargs): @staticmethod def _get_ax(ax=None, figsize=None): - import matplotlib.pyplot as plt + import matplotlib.pyplot as plt # type: ignore if ax is None: _, ax = plt.subplots(figsize=figsize) @@ -299,25 +344,66 @@ class Grid2D(_Geometry): def __init__( self, *, - x=None, - x0=0.0, - dx=None, - nx=None, - y=None, - y0=0.0, - dy=None, - ny=None, + x: Optional[Sequence[float]] = None, + x0: float = 0.0, + dx: Optional[float] = None, + nx: Optional[int] = None, + y: Optional[Sequence[float]] = None, + y0: float = 0.0, + dy: Optional[float] = None, + ny: Optional[int] = None, bbox=None, projection="NON-UTM", - origin: Tuple[float, float] = None, + origin: Optional[Tuple[float, float]] = None, orientation=0.0, axis_names=("x", "y"), is_spectral=False, ): - """Create equidistant 2D spatial geometry""" + """Create equidistant 2D spatial geometry + + Parameters + ---------- + x : array_like, optional + x coordinates of cell centers + x0 : float, optional + x coordinate of lower-left corner of first cell + dx : float, optional + x cell size + nx : int, optional + number of cells in x direction + y : array_like, optional + y coordinates of cell centers + y0 : float, optional + y coordinate of lower-left corner of first cell + dy : float, optional + y cell size + ny : int, optional + number of cells in y direction + bbox : tuple, optional + (x0, y0, x1, y1) of bounding box + projection : str, optional + projection string, by default "NON-UTM" + origin : tuple, optional + user-defined origin, by default None + orientation : float, optional + rotation angle in degrees, by default 0.0 + axis_names : tuple, optional + names of x and y axes, by default ("x", "y") + is_spectral : bool, optional + if True, the grid is spectral, by default False + + Examples + -------- + >>> mikeio.Grid2D(x0=12.0, nx=2, dx=0.25, y0=55.0, ny=3, dy=0.25, projection="LONG/LAT") + + x: [12, 12.25] (nx=2, dx=0.25) + y: [55, 55.25, 55.5] (ny=3, dy=0.25) + projection: LONG/LAT + """ super().__init__(projection) self._shift_origin_on_write = origin is None # user-constructed - self._origin = (0.0, 0.0) if origin is None else origin + self._origin = (0.0, 0.0) if origin is None else tuple(origin) + assert len(self._origin) == 2, "origin must be a tuple of length 2" self._orientation = orientation self.__xx = None self.__yy = None @@ -565,17 +651,30 @@ def coordinates(self): """n-by-2 array of x- and y-coordinates""" return self.xy + @property + def _cart(self): + """MIKE Core Cartography object""" + factory = ( + Cartography.CreateGeoOrigin if self.is_geo else Cartography.CreateProjOrigin + ) + return factory(self.projection_string, *self.origin, self.orientation) + def _shift_x0y0_to_origin(self): """Shift spatial axis to start at (0,0) adding the start to origin instead Note: this will not change the x or y properties. """ if self._is_rotated: raise ValueError("Only possible if orientation = 0") - if self.is_spectral: + # TODO: needs testing + # i0, j0 = self._x0/self.dx, self._y0/self.dy + # self._x0, self._y0 = 0.0, 0.0 + # self._origin = self._cart.Xy2Proj(i0, j0) + elif self.is_spectral: raise ValueError("Not possible for spectral Grid2D") - x0, y0 = self._x0, self._y0 - self._x0, self._y0 = 0.0, 0.0 - self._origin = (self._origin[0] + x0, self._origin[1] + y0) + else: + x0, y0 = self._x0, self._y0 + self._x0, self._y0 = 0.0, 0.0 + self._origin = (self._origin[0] + x0, self._origin[1] + y0) def contains(self, coords): """test if a list of points are inside grid @@ -601,7 +700,13 @@ def contains(self, coords): def __contains__(self, pt) -> bool: return self.contains(pt) - def find_index(self, x: float = None, y: float = None, coords=None, area=None): + def find_index( + self, + x: Optional[float] = None, + y: Optional[float] = None, + coords=None, + area=None, + ): """Find nearest index (i,j) of point(s) -1 is returned if point is outside grid @@ -683,7 +788,19 @@ def _bbox_to_index( return i, j - def isel(self, idx, axis): + def isel( + self, idx, axis: Union[int, str] + ) -> Union["Grid2D", "Grid1D", "GeometryUndefined"]: + """Return a new geometry as a subset of Grid2D along the given axis.""" + if isinstance(axis, str): + if axis == "y": + axis = 0 + elif axis == "x": + axis = 1 + else: + raise ValueError(f"axis must be 'x' or 'y', not {axis}") + assert isinstance(axis, int), "axis must be an integer (or 'x' or 'y')" + axis = axis + 2 if axis < 0 else axis if not np.isscalar(idx): d = np.diff(idx) @@ -699,16 +816,19 @@ def isel(self, idx, axis): # we return a "copy" of the x-axis nc = np.column_stack([self.x, self.y[idx] * np.ones_like(self.x)]) return Grid1D(x=self.x, projection=self.projection, node_coordinates=nc) - else: + elif axis == 1: nc = np.column_stack([self.x[idx] * np.ones_like(self.y), self.y]) return Grid1D( x=self.y, projection=self.projection, node_coordinates=nc, axis_name="y" ) + else: + raise ValueError(f"axis must be 0 or 1 (or 'x' or 'y'), not {axis}") def _index_to_Grid2D(self, ii=None, jj=None): ii = range(self.nx) if ii is None else ii jj = range(self.ny) if jj is None else jj assert len(ii) > 1 and len(jj) > 1, "Index must be at least len 2" + assert ii[-1] < self.nx and jj[-1] < self.ny, "Index out of bounds" di = np.diff(ii) dj = np.diff(jj) if (np.any(di < 1) or not np.allclose(di, di[0])) or ( @@ -722,7 +842,13 @@ def _index_to_Grid2D(self, ii=None, jj=None): x0 = self._x0 + (self.x[ii[0]] - self.x[0]) y0 = self._y0 + (self.y[jj[0]] - self.y[0]) origin = None if self._shift_origin_on_write else self.origin - if not self._is_rotated and not self._shift_origin_on_write: + # if not self._is_rotated and not self._shift_origin_on_write: + if self._is_rotated: + origin = self._cart.Xy2Proj(ii[0], jj[0]) + # what about the orientation if is_geo?? + # orientationGeo = proj.Proj2GeoRotation(east, north, orientationProj) + x0, y0 = (0.0, 0.0) + elif not self.is_spectral: origin = (self.origin[0] + x0, self.origin[1] + y0) x0, y0 = (0.0, 0.0) @@ -892,6 +1018,8 @@ def __init__( ) -> None: super().__init__() + self._origin = (0.0, 0.0) if origin is None else tuple(origin) + assert len(self._origin) == 2, "origin must be a tuple of length 2" self._x0, self._dx, self._nx = _parse_grid_axis("x", x, x0, dx, nx) self._y0, self._dy, self._ny = _parse_grid_axis("y", y, y0, dy, ny) self._z0, self._dz, self._nz = _parse_grid_axis("z", z, z0, dz, nz) @@ -904,11 +1032,16 @@ def __init__( def ndim(self) -> int: return 3 + @property + def _is_rotated(self): + return np.abs(self._orientation) > 1e-5 + @property def x(self): - """array of x-axis node coordinates""" + """array of x-axis coordinates (element center)""" x1 = self._x0 + self.dx * (self.nx - 1) - return np.linspace(self._x0, x1, self.nx) + x_local = np.linspace(self._x0, x1, self.nx) + return x_local if self._is_rotated else x_local + self.origin[0] @property def dx(self) -> float: @@ -917,14 +1050,15 @@ def dx(self) -> float: @property def nx(self) -> int: - """number of x-axis nodes""" + """number of x grid points""" return self._nx @property def y(self): - """array of y-axis node coordinates""" + """array of y-axis coordinates (element center)""" y1 = self._y0 + self.dy * (self.ny - 1) - return np.linspace(self._y0, y1, self.ny) + y_local = np.linspace(self._y0, y1, self.ny) + return y_local if self._is_rotated else y_local + self.origin[1] @property def dy(self) -> float: @@ -933,7 +1067,7 @@ def dy(self) -> float: @property def ny(self) -> int: - """number of y-axis nodes""" + """number of y grid points""" return self._ny @property @@ -949,7 +1083,7 @@ def dz(self) -> float: @property def nz(self) -> int: - """number of z-axis nodes""" + """number of z grid points""" return self._nz @property @@ -973,15 +1107,27 @@ def find_index(self, coords=None, layers=None, area=None): def isel(self, idx, axis): """Get a subset geometry from this geometry""" + if isinstance(axis, str): + if axis == "z": + axis = 0 + elif axis == "y": + axis = 1 + elif axis == "x": + axis = 2 + else: + raise ValueError(f"axis must be 'x', 'y' or 'z', not {axis}") + assert isinstance(axis, int), "axis must be an integer (or 'x', 'y' or 'z')" + axis = axis + 3 if axis < 0 else axis + if not np.isscalar(idx): d = np.diff(idx) if np.any(d < 1) or not np.allclose(d, d[0]): return GeometryUndefined() else: - x = self.x[idx] if axis == 2 else self.x - y = self.y[idx] if axis == 1 else self.y - z = self.z[idx] if axis == 0 else self.z - return Grid3D(x=x, y=y, z=z, projection=self.projection) + ii = idx if axis == 2 else None + jj = idx if axis == 1 else None + kk = idx if axis == 0 else None + return self._index_to_Grid3D(ii, jj, kk) if axis == 0: # z is the first axis! return x-y Grid2D @@ -1005,7 +1151,7 @@ def isel(self, idx, axis): y=self.z, # projection=self._projection, ) - else: + elif axis == 2: # x is the last axis! return y-z Grid2D # TODO: origin, how to pass self.x[idx]? return Grid2D( @@ -1013,6 +1159,61 @@ def isel(self, idx, axis): y=self.z, # projection=self._projection, ) + else: + raise ValueError(f"axis must be 0, 1 or 2 (or 'x', 'y' or 'z'), not {axis}") + + def _index_to_Grid3D(self, ii=None, jj=None, kk=None): + ii = range(self.nx) if ii is None else ii + jj = range(self.ny) if jj is None else jj + kk = range(self.nz) if kk is None else kk + assert ( + len(ii) > 1 and len(jj) > 1 and len(kk) > 1 + ), "Index must be at least len 2" + assert ( + ii[-1] < self.nx and jj[-1] < self.ny and kk[-1] < self.nz + ), "Index out of bounds" + di = np.diff(ii) + dj = np.diff(jj) + dk = np.diff(kk) + if ( + (np.any(di < 1) or not np.allclose(di, di[0])) + or (np.any(dj < 1) or not np.allclose(dj, dj[0])) + or (np.any(dk < 1) or not np.allclose(dk, dk[0])) + ): + warnings.warn("Axis not equidistant! Will return GeometryUndefined()") + return GeometryUndefined() + else: + dx = self.dx * di[0] + dy = self.dy * dj[0] + dz = self.dz * dk[0] + x0 = self._x0 + (self.x[ii[0]] - self.x[0]) + y0 = self._y0 + (self.y[jj[0]] - self.y[0]) + z0 = self._z0 + (self.z[kk[0]] - self.z[0]) + if self._is_rotated: + # rotated => most be projected + cart = Cartography.CreateProjOrigin( + self.projection, *self.origin, self.orientation + ) + origin = cart.Xy2Proj(ii[0], jj[0]) + else: + origin = (self.origin[0] + x0, self.origin[1] + y0) + + x0, y0 = (0.0, 0.0) + + return Grid3D( + x0=x0, + y0=y0, + z0=z0, + dx=dx, + dy=dy, + dz=dz, + nx=len(ii), + ny=len(jj), + nz=len(kk), + projection=self.projection, + orientation=self.orientation, + origin=origin, + ) def __repr__(self): out = [""] @@ -1029,13 +1230,15 @@ def __repr__(self): def __str__(self): return f"Grid3D(nz={self.nz}, ny={self.ny}, nx={self.nx})" - def _geometry_for_layers(self, layers, keepdims=False) -> Union[Grid2D, "Grid3D"]: + def _geometry_for_layers( + self, layers, keepdims=False + ) -> Union[Grid2D, "Grid3D", "GeometryUndefined"]: if layers is None: return self g = self if len(layers) == 1 and not keepdims: - geometry = Grid2D( + geometry_2d = Grid2D( dx=g._dx, dy=g._dy, nx=g._nx, @@ -1046,7 +1249,7 @@ def _geometry_for_layers(self, layers, keepdims=False) -> Union[Grid2D, "Grid3D" projection=g._projstr, orientation=g.orientation, ) - return geometry + return geometry_2d d = np.diff(g.z[layers]) if len(d) > 0: diff --git a/notebooks/Dfs2 - Various types.ipynb b/notebooks/Dfs2 - Various types.ipynb index 03158caf5..4dde3c89b 100644 --- a/notebooks/Dfs2 - Various types.ipynb +++ b/notebooks/Dfs2 - Various types.ipynb @@ -108,14 +108,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -186,14 +184,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -264,14 +260,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -286,14 +280,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -341,14 +333,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -363,14 +353,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -442,14 +430,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -520,14 +506,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -542,14 +526,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -558,10 +540,13 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Spectral" + "## Spectral\n", + "\n", + "When reading spectral dfs2 files, the user must specify type='spectral'. " ] }, { @@ -593,7 +578,7 @@ ], "source": [ "fn = \"../tests/testdata/dir_wave_analysis_spectra.dfs2\"\n", - "dfs = mikeio.open(fn) #, type=\"spectral\")\n", + "dfs = mikeio.open(fn, type=\"spectral\")\n", "da = dfs.read()[0]\n", "da" ] @@ -606,7 +591,7 @@ { "data": { "text/plain": [ - "\n", + " (spectral)\n", "x: [0.003906, 0.007812, ..., 0.5] (nx=128, dx=0.003906)\n", "y: [0, 10, ..., 360] (ny=37, dy=10)\n", "projection: NON-UTM" @@ -628,19 +613,16 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "da.geometry.is_spectral = True\n", "da.plot();" ] }, @@ -752,14 +734,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -776,11 +756,8 @@ } ], "metadata": { - "interpreter": { - "hash": "fa576ebcd40e010bdc0ae86b06ce09151f3424f9e9aed6893ff04f39a9299d89" - }, "kernelspec": { - "display_name": "Python 3.8.10 ('base')", + "display_name": "base", "language": "python", "name": "python3" }, @@ -794,9 +771,14 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.10.8" }, - "orig_nbformat": 4 + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "7aec4f91c09090e98e6ae8203c38529831bb4a3ce54cd1b69639b53cb01a6aa9" + } + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/tests/test_dfs2.py b/tests/test_dfs2.py index e3d5f7e3e..b530a8353 100644 --- a/tests/test_dfs2.py +++ b/tests/test_dfs2.py @@ -32,13 +32,13 @@ def dfs2_random_2items(): @pytest.fixture def dfs2_pt_spectrum(): filepath = Path("tests/testdata/pt_spectra.dfs2") - return mikeio.open(filepath) + return mikeio.open(filepath, type="spectral") @pytest.fixture def dfs2_pt_spectrum_linearf(): filepath = Path("tests/testdata/dir_wave_analysis_spectra.dfs2") - return mikeio.open(filepath) + return mikeio.open(filepath, type="spectral") @pytest.fixture @@ -109,7 +109,7 @@ def test_write_projected(tmpdir): dx=100, dy=100, projection="UTM-33", - origin=(0.0, 0.0), + # origin=(0.0, 0.0), ) da = mikeio.DataArray( data=d, time=pd.date_range("2012-1-1", freq="s", periods=100), geometry=grid @@ -119,11 +119,11 @@ def test_write_projected(tmpdir): ds2 = mikeio.read(filename) assert ds2.geometry.dx == 100 assert ds2.geometry.dy == 100 - # NOT shifted x0y0 to origin as origin was explicitly set to (0,0) - assert ds2.geometry._x0 == pytest.approx(x0) - assert ds2.geometry._y0 == pytest.approx(y0) - assert ds2.geometry.origin[0] == 0.0 - assert ds2.geometry.origin[1] == 0.0 + # CHANGED: NOT shifted x0y0 to origin as origin was explicitly set to (0,0) + # assert ds2.geometry._x0 == pytest.approx(x0) + # assert ds2.geometry._y0 == pytest.approx(y0) + assert ds2.geometry.origin[0] == pytest.approx(x0) + assert ds2.geometry.origin[1] == pytest.approx(y0) grid = Grid2D(nx=nx, ny=ny, origin=(x0, y0), dx=100, dy=100, projection="UTM-33") da = mikeio.DataArray( @@ -200,7 +200,8 @@ def test_read_area_subset_bad_bbox(): def test_read_area_subset_geo(): - + # x: [-15, -14.75, ..., 40] (nx=221, dx=0.25) + # y: [30, 30.25, ..., 55] (ny=101, dy=0.25) filename = "tests/testdata/europe_wind_long_lat.dfs2" bbox = (10, 40, 20, 50) dsall = mikeio.read(filename) @@ -308,16 +309,15 @@ def test_properties_pt_spectrum(dfs2_pt_spectrum): assert dfs.n_timesteps == 31 g = dfs.geometry + assert g.is_spectral assert g.x[0] == pytest.approx(0.055) - assert g.x[-1] > 25 # if considered linear + # assert g.x[-1] > 25 # if considered linear + assert g.x[-1] < 0.6 # logarithmic assert g.y[0] == 0 assert g.dx == pytest.approx(1.1) assert g.dy == 22.5 assert g.orientation == 0 - g.is_spectral = True - assert g.x[-1] < 0.6 # logarithmic - def test_properties_pt_spectrum_linearf(dfs2_pt_spectrum_linearf): dfs = dfs2_pt_spectrum_linearf @@ -357,7 +357,7 @@ def test_dir_wave_spectra_relative_time_axis(): def test_properties_rotated_longlat(): filepath = Path("tests/testdata/gebco_sound_crop_rotate.dfs2") - with pytest.raises(ValueError, match="LONG/LAT with non-zero orientation"): + with pytest.raises(ValueError, match="Orientation is not supported for LONG/LAT"): mikeio.open(filepath) @@ -382,31 +382,48 @@ def test_properties_rotated_UTM(): def test_select_area_rotated_UTM(tmpdir): filepath = Path("tests/testdata/BW_Ronne_Layout1998_rotated.dfs2") ds = mikeio.read(filepath) + assert ds.geometry.origin == pytest.approx((479670, 6104860)) + assert ds.geometry.orientation == pytest.approx(-22.2387902) dssel = ds.isel(x=range(10, 20), y=range(15, 45)) - assert ds.geometry.orientation == dssel.geometry.orientation - assert dssel.geometry._x0 == ds.geometry.x[10] - assert dssel.geometry._y0 == ds.geometry.y[15] + assert dssel.geometry.orientation == ds.geometry.orientation + assert dssel.geometry.origin == pytest.approx((479673.579, 6104877.669)) tmpfile = os.path.join(tmpdir.dirname, "subset_rotated.dfs2") dssel.to_dfs(tmpfile) dfs = mikeio.open(tmpfile) g = dfs.geometry - assert dfs.x0 == 50 - assert dfs.y0 == 75 + assert dfs.x0 == 0 + assert dfs.y0 == 0 assert dfs.dx == 5 assert dfs.dy == 5 assert dfs.nx == 10 assert dfs.ny == 30 - assert dfs.longitude == pytest.approx(14.6814730403) - assert dfs.latitude == pytest.approx(55.090063) - assert dfs.orientation == pytest.approx(-22.2387902) + assert dfs.orientation == pytest.approx(ds.geometry.orientation) assert g.orientation == dfs.orientation - # origin is projected coordinates - assert g.origin == pytest.approx((479670, 6104860)) - assert g.x[0] == dfs.x0 - assert g.y[0] == dfs.y0 + # origin is in projected coordinates + assert g.origin == pytest.approx(dssel.geometry.origin) + + +def test_select_area_rotated_UTM_2(): + fn = Path("tests/testdata/BW_Ronne_Layout1998_rotated.dfs2") + ds = mikeio.read(fn) + dssel = ds.isel(x=range(50, 61), y=range(75, 106)) + g1 = dssel.geometry + + # compare to file that has been cropped in MIKE Zero + fn = Path("tests/testdata/BW_Ronne_Layout1998_rotated_crop.dfs2") + ds2 = mikeio.read(fn) + g2 = ds2.geometry + + assert g1.origin == pytest.approx(g2.origin) + assert g1.dx == g2.dx + assert g1.dy == g2.dy + assert g1.nx == g2.nx + assert g1.ny == g2.ny + assert g1.orientation == g2.orientation # orientation in projected coordinates + assert g1.projection_string == g2.projection_string def test_write_selected_item_to_new_file(dfs2_random_2items, tmpdir): @@ -840,3 +857,23 @@ def test_read_write_header_unchanged_vertical(tmpdir): def test_read_write_header_unchanged_spectral_2(tmpdir): is_header_unchanged_on_read_write(tmpdir, "pt_spectra.dfs2") + + +def test_read_write_header_unchanged_MIKE_SHE_output(tmpdir): + is_header_unchanged_on_read_write(tmpdir, "Karup_MIKE_SHE_output.dfs2") + + +def test_MIKE_SHE_output(): + ds = mikeio.read("tests/testdata/Karup_MIKE_SHE_output.dfs2") + assert ds.n_timesteps == 6 + assert ds.n_items == 2 + g = ds.geometry + assert g.x[0] == 494329.0 + assert g.y[0] == pytest.approx(6220250.0) + assert g.origin == pytest.approx((494329.0, 6220250.0)) + + ds2 = ds.isel(x=range(30, 45), y=range(35, 42)) + g2 = ds2.geometry + assert g2.x[0] == g.x[0] + 30 * g.dx + assert g2.y[0] == g.y[0] + 35 * g.dy + assert g2.origin == pytest.approx((g2.x[0], g2.y[0])) diff --git a/tests/test_dfs3.py b/tests/test_dfs3.py index c2fa1da5c..1b82fc1d1 100644 --- a/tests/test_dfs3.py +++ b/tests/test_dfs3.py @@ -94,10 +94,13 @@ def test_dfs3_read_write(tmpdir): def test_read_rotated_grid(): - ds = mikeio.read("tests/testdata/dissolved_oxygen.dfs3") - assert pytest.approx(ds.geometry.orientation) == 18.1246891 + dfs = mikeio.open("tests/testdata/dissolved_oxygen.dfs3") + # North to Y orientation: 18.124689102173 + # Grid rotation: 17.0003657182497 - # North to Y rotation != Grid rotation + # assert dfs._orientation == pytest.approx(18.1246891) + assert dfs.orientation == pytest.approx(17.0003657) + assert dfs.geometry.orientation == pytest.approx(17.0003657) # in own CRS def test_dfs3_to_dfs(tmpdir): @@ -171,6 +174,7 @@ def test_read_single_timestep_dfs3(): assert ds.dims == ("z", "y", "x") assert ds.shape == (5, 17, 21) + def test_read_write_single_layer_as_dfs3(tmpdir): fn = "tests/testdata/single_layer.dfs3" ds1 = mikeio.read(fn, keepdims=True) @@ -179,7 +183,23 @@ def test_read_write_single_layer_as_dfs3(tmpdir): ds2 = mikeio.read(fn, layers=0, keepdims=True) assert ds2.dims == ("time", "z", "y", "x") assert isinstance(ds2.geometry, Grid3D) - + outfile = os.path.join(tmpdir, "single_layer.dfs3") - ds2.to_dfs(outfile) \ No newline at end of file + ds2.to_dfs(outfile) + + +def test_MIKE_SHE_dfs3_output(): + ds = mikeio.read("tests/testdata/Karup_MIKE_SHE_head_output.dfs3") + assert ds.n_timesteps == 6 + assert ds.n_items == 1 + g = ds.geometry + assert g.x[0] == 494329.0 + assert g.y[0] == pytest.approx(6220250.0) + assert g.origin == pytest.approx((494329.0, 6220250.0)) + + ds2 = ds.isel(x=range(30, 45)) + g2 = ds2.geometry + assert g2.x[0] == g.x[0] + 30 * g.dx + assert g2.y[0] == g.y[0] # + 35 * g.dy + assert g2.origin == pytest.approx((g2.x[0], g2.y[0])) diff --git a/tests/test_geometry_grid.py b/tests/test_geometry_grid.py index 437857a3d..a8c7991f4 100644 --- a/tests/test_geometry_grid.py +++ b/tests/test_geometry_grid.py @@ -6,6 +6,7 @@ from mikeio import Mesh from mikeio import Grid2D, Grid1D from mikeio.spatial.FM_geometry import GeometryFM +from mikeio.spatial.geometry import GeometryUndefined def test_create_nx_ny(): @@ -32,6 +33,21 @@ def test_grid1d_x(): assert g.x[-1] == x1 +def test_grid1d_isel(): + g = Grid1D(nx=10, dx=0.1) + + g2 = g.isel([0, 1, 2]) + assert g2.nx == 3 + + with pytest.raises(NotImplementedError, match="equidistant"): + g.isel([0, 1, 9]) + + p1 = g.isel(3) + assert isinstance( + p1, GeometryUndefined + ) # the only info we have is how far along a 1d axis we are, not enough to create a 2d point + + def test_grid1d_equality(): g1 = Grid1D(dx=0.1, nx=10) g2 = Grid1D(dx=0.1, nx=10) diff --git a/tests/testdata/BW_Ronne_Layout1998_rotated_crop.dfs2 b/tests/testdata/BW_Ronne_Layout1998_rotated_crop.dfs2 new file mode 100644 index 000000000..b593ad568 Binary files /dev/null and b/tests/testdata/BW_Ronne_Layout1998_rotated_crop.dfs2 differ diff --git a/tests/testdata/Karup_MIKE_SHE_head_output.dfs3 b/tests/testdata/Karup_MIKE_SHE_head_output.dfs3 new file mode 100644 index 000000000..b9a8b8ca6 Binary files /dev/null and b/tests/testdata/Karup_MIKE_SHE_head_output.dfs3 differ diff --git a/tests/testdata/Karup_MIKE_SHE_output.dfs2 b/tests/testdata/Karup_MIKE_SHE_output.dfs2 new file mode 100644 index 000000000..a08a1da14 Binary files /dev/null and b/tests/testdata/Karup_MIKE_SHE_output.dfs2 differ