From 8b745a30f4797203063ec5590633826ca3745490 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 08:20:28 +0100 Subject: [PATCH 01/20] init --- mikeio/dfsu/_dfsu.py | 47 ++++++++++++++++++++--------------------- mikeio/dfsu/_factory.py | 8 +++---- 2 files changed, 27 insertions(+), 28 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 21591c455..7c2e1c924 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -108,6 +108,26 @@ def _write_dfsu(filename: str | Path, data: Dataset) -> None: class _Dfsu: show_progress = False + def __init__(self, filename: str | Path) -> None: + """ + Create a Dfsu object + + Parameters + --------- + filename: str + dfsu filename + """ + # placeholder + # self._timestep_in_seconds = None + + # TODO remove + self._filename = str(filename) + # input = self._filename if dfs is None else dfs + self._read_header(filename) + # self.time = ... + # self.geometry = ... + # self.items = ... + def __repr__(self): out = [] type_name = "Flexible Mesh" if self._type is None else self.type_name @@ -148,13 +168,8 @@ def __repr__(self): out.append(f" {self._start_time} -- {self.end_time}") return str.join("\n", out) - def _read_header(self, input: DfsuFile | str | Path) -> None: + def _read_header(self, input: str | Path) -> None: # TODO set instance variables in __init__ instead of here - if isinstance(input, DfsuFile): - # input is a dfsu file object (already open) - self._read_dfsu_header(input) - return - filename = input path = Path(input) if not path.exists(): @@ -163,6 +178,7 @@ def _read_header(self, input: DfsuFile | str | Path) -> None: ext = path.suffix.lower() if ext == ".mesh": + raise ValueError("Not supported") # TODO remove the possibility to read mesh files from this class self._read_mesh_header(filename) @@ -292,7 +308,7 @@ def _read_dfsu_header(self, dfs): @property def type_name(self): """Type name, e.g. Mesh, Dfsu2D""" - return self._type.name if self._type else "Mesh" + return self._type.name @property def geometry(self): @@ -555,23 +571,6 @@ def plot( add_colorbar=add_colorbar, ) - def __init__(self, filename, dfs: DfsuFile | None = None): - """ - Create a Dfsu object - - Parameters - --------- - filename: str - dfsu or mesh filename - dfs : - """ - # placeholder - self._timestep_in_seconds = None - - self._filename = str(filename) - input = self._filename if dfs is None else dfs - self._read_header(input) - @property def deletevalue(self): """File delete value""" diff --git a/mikeio/dfsu/_factory.py b/mikeio/dfsu/_factory.py index 1e6d7d074..ebb99d968 100644 --- a/mikeio/dfsu/_factory.py +++ b/mikeio/dfsu/_factory.py @@ -13,13 +13,13 @@ def __new__(self, filename, *args, **kwargs): type, dfs = self._get_DfsuFileType_n_Obj(filename) if self._type_is_spectral(type): - return DfsuSpectral(filename, dfs, *args, **kwargs) + return DfsuSpectral(filename, *args, **kwargs) elif self._type_is_2d_horizontal(type): - return Dfsu2DH(filename, dfs, *args, **kwargs) + return Dfsu2DH(filename, *args, **kwargs) elif self._type_is_2d_vertical(type): - return Dfsu2DV(filename, dfs, *args, **kwargs) + return Dfsu2DV(filename, *args, **kwargs) elif self._type_is_3d(type): - return Dfsu3D(filename, dfs, *args, **kwargs) + return Dfsu3D(filename, *args, **kwargs) else: raise ValueError(f"Type {type} is unsupported!") From d773979efe6a5160d1def6e9531bc8a815921ebd Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 09:08:37 +0100 Subject: [PATCH 02/20] Set relevant instance variables --- mikeio/dfsu/_dfsu.py | 73 ++++++++++++++++++++++++++------------------ 1 file changed, 44 insertions(+), 29 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 7c2e1c924..62320686b 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -123,9 +123,11 @@ def __init__(self, filename: str | Path) -> None: # TODO remove self._filename = str(filename) # input = self._filename if dfs is None else dfs - self._read_header(filename) + # self._read_header(filename) # self.time = ... - # self.geometry = ... + self._geometry, self._time, self._timestep, self._items = self._read_header( + filename + ) # self.items = ... def __repr__(self): @@ -158,14 +160,14 @@ def __repr__(self): out.append(f" {i}: {item}") else: out.append(f"number of items: {self.n_items}") - if self._n_timesteps is not None: - if self._n_timesteps == 1: + if self.n_timesteps is not None: + if self.n_timesteps == 1: out.append(f"time: time-invariant file (1 step) at {self._start_time}") else: out.append( - f"time: {self._n_timesteps} steps with dt={self._timestep_in_seconds}s" + f"time: {str(self.time[0])} - {str(self.time[-1])} ({self.n_timesteps} records)" ) - out.append(f" {self._start_time} -- {self.end_time}") + out.append(f" {self.start_time} -- {self.end_time}") return str.join("\n", out) def _read_header(self, input: str | Path) -> None: @@ -184,7 +186,8 @@ def _read_header(self, input: str | Path) -> None: elif ext == ".dfsu": dfs = DfsuFile.Open(filename) - self._read_dfsu_header(dfs) + geometry, time, timestep, items = self._read_dfsu_header(dfs) + return geometry, time, timestep, items else: raise Exception(f"Filetype {ext} not supported (mesh,dfsu)") @@ -225,7 +228,7 @@ def _read_dfsu_header(self, dfs): # geometry if self._type == DfsuFileType.DfsuSpectral0D: - self._geometry = GeometryFMPointSpectrum( + geometry = GeometryFMPointSpectrum( frequencies=frequencies, directions=directions ) else: @@ -241,7 +244,7 @@ def _read_dfsu_header(self, dfs): ): geom_cls = GeometryFMVerticalProfile - self._geometry = geom_cls( + geometry = geom_cls( node_coordinates=node_table.coordinates, element_table=el_table.connectivity, codes=node_table.codes, @@ -254,7 +257,7 @@ def _read_dfsu_header(self, dfs): validate=False, ) elif self._type == DfsuFileType.DfsuSpectral1D: - self._geometry = GeometryFMLineSpectrum( + geometry = GeometryFMLineSpectrum( node_coordinates=node_table.coordinates, element_table=el_table.connectivity, codes=node_table.codes, @@ -267,7 +270,7 @@ def _read_dfsu_header(self, dfs): directions=directions, ) elif self._type == DfsuFileType.DfsuSpectral2D: - self._geometry = GeometryFMAreaSpectrum( + geometry = GeometryFMAreaSpectrum( node_coordinates=node_table.coordinates, element_table=el_table.connectivity, codes=node_table.codes, @@ -280,7 +283,7 @@ def _read_dfsu_header(self, dfs): directions=directions, ) else: - self._geometry = GeometryFM2D( + geometry = GeometryFM2D( node_coordinates=node_table.coordinates, element_table=el_table.connectivity, codes=node_table.codes, @@ -294,16 +297,23 @@ def _read_dfsu_header(self, dfs): # items n_items = len(dfs.ItemInfo) first_idx = 1 if self.is_layered else 0 - self._items = _get_item_info( + items = _get_item_info( dfs.ItemInfo, list(range(n_items - first_idx)), ignore_first=self.is_layered ) # time - self._start_time = dfs.StartDateTime - self._n_timesteps = dfs.NumberOfTimeSteps - self._timestep_in_seconds = dfs.TimeStepInSeconds + time = pd.date_range( + start=dfs.StartDateTime, + periods=dfs.NumberOfTimeSteps, + freq=f"{dfs.TimeStepInSeconds}S", + ) + # self._start_time = dfs.StartDateTime + # self._n_timesteps = dfs.NumberOfTimeSteps + # self._timestep_in_seconds = dfs.TimeStepInSeconds + timestep = dfs.TimeStepInSeconds dfs.Close() + return geometry, time, timestep, items @property def type_name(self): @@ -589,34 +599,39 @@ def items(self): @property def start_time(self): """File start time""" - return self._start_time + return self._time[0] @property def n_timesteps(self): """Number of time steps""" - return self._n_timesteps + return len(self._time) @property def timestep(self): """Time step size in seconds""" - return self._timestep_in_seconds + return self._timestep @property def end_time(self): """File end time""" - return self.start_time + timedelta( - seconds=((self.n_timesteps - 1) * self.timestep) - ) + return self._time[-1] + # return self.start_time + timedelta( + # seconds=((self.n_timesteps - 1) * self.timestep) + # ) @property def time(self): - """File all datetimes""" - return pd.to_datetime( - [ - self.start_time + timedelta(seconds=i * self.timestep) - for i in range(self.n_timesteps) - ] - ) + return self._time + + # @property + # def time(self): + # """File all datetimes""" + # return pd.to_datetime( + # [ + # self.start_time + timedelta(seconds=i * self.timestep) + # for i in range(self.n_timesteps) + # ] + # ) def _read( self, From 703a6a6ce99744f40ab7d16269ec3c971b8cd675 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 09:08:56 +0100 Subject: [PATCH 03/20] No support for Dfsu append --- tests/test_dfsu.py | 116 +++++++++++++++++++++++---------------------- 1 file changed, 59 insertions(+), 57 deletions(-) diff --git a/tests/test_dfsu.py b/tests/test_dfsu.py index 4f22c4e91..8bb7d524f 100644 --- a/tests/test_dfsu.py +++ b/tests/test_dfsu.py @@ -604,47 +604,48 @@ def test_incremental_write_from_dfsu_context_manager_3d(tmp_path): assert dfs.end_time == newdfs.end_time -def test_write_big_file(tmp_path): - fp = tmp_path / "big.dfsu" - meshfilename = "tests/testdata/odense_rough.mesh" +# TODO add workaround to write big file +# def test_write_big_file(tmp_path): +# fp = tmp_path / "big.dfsu" +# meshfilename = "tests/testdata/odense_rough.mesh" - msh = Mesh(meshfilename) +# msh = Mesh(meshfilename) - n_elements = msh.n_elements +# n_elements = msh.n_elements - dfs = Dfsu(meshfilename) +# dfs = Dfsu(meshfilename) - nt = 5 # or some big number 50000 +# nt = 5 # or some big number 50000 - n_items = 10 +# n_items = 10 - das = [ - DataArray( - data=np.random.random((1, n_elements)), - geometry=msh.geometry, - time="2000-1-1", - item=f"Item {i+1}", - ) - for i in range(n_items) - ] +# das = [ +# DataArray( +# data=np.random.random((1, n_elements)), +# geometry=msh.geometry, +# time="2000-1-1", +# item=f"Item {i+1}", +# ) +# for i in range(n_items) +# ] - ds = Dataset(das) +# ds = Dataset(das) - with dfs.write(fp, data=ds, dt=3600, keep_open=True) as f: - for _ in range(1, nt): - data = [] - for i in range(n_items): - d = np.random.random((1, n_elements)) - da = DataArray(data=d, geometry=msh.geometry, item=f"Item {i+1}") - data.append(da) - dst = Dataset(data) - f.append(dst) +# with dfs.write(fp, data=ds, dt=3600, keep_open=True) as f: +# for _ in range(1, nt): +# data = [] +# for i in range(n_items): +# d = np.random.random((1, n_elements)) +# da = DataArray(data=d, geometry=msh.geometry, item=f"Item {i+1}") +# data.append(da) +# dst = Dataset(data) +# f.append(dst) - dfsu = mikeio.open(fp) +# dfsu = mikeio.open(fp) - assert dfsu.n_items == n_items - assert dfsu.n_timesteps == nt - assert dfsu.start_time.year == 2000 +# assert dfsu.n_items == n_items +# assert dfsu.n_timesteps == nt +# assert dfsu.start_time.year == 2000 def test_write_from_dfsu_2_time_steps(tmp_path): @@ -1068,32 +1069,33 @@ def test_interp_like_fm_dataset(): assert isinstance(dsi.geometry, GeometryFM2D) -def test_write_header(tmp_path): - meshfilename = "tests/testdata/north_sea_2.mesh" - fp = tmp_path / "NS_write_header.dfsu" - dfs = mikeio.Dfsu(meshfilename) - n_elements = dfs.n_elements - nt = 3 - n_items = 2 - items = [ItemInfo(f"Item {i+1}") for i in range(n_items)] - time0 = datetime(2021, 1, 1) - with dfs.write_header(fp, items=items, start_time=time0, dt=3600) as f: - for _ in range(nt): - data = [] - for _ in range(n_items): - d = np.random.random((1, n_elements)) # 2d - data.append(d) - f.append(data) - - # append also works for data without time axis - fp = tmp_path / "NS_write_header2.dfsu" - with dfs.write_header(fp, items=items, start_time=time0, dt=3600) as f: - for _ in range(nt): - data = [] - for _ in range(n_items): - d = np.random.random((n_elements)) # 1d - data.append(d) - f.append(data) +# TODO add workaround to write big file +# def test_write_header(tmp_path): +# meshfilename = "tests/testdata/north_sea_2.mesh" +# fp = tmp_path / "NS_write_header.dfsu" +# dfs = mikeio.Dfsu(meshfilename) +# n_elements = dfs.n_elements +# nt = 3 +# n_items = 2 +# items = [ItemInfo(f"Item {i+1}") for i in range(n_items)] +# time0 = datetime(2021, 1, 1) +# with dfs.write_header(fp, items=items, start_time=time0, dt=3600) as f: +# for _ in range(nt): +# data = [] +# for _ in range(n_items): +# d = np.random.random((1, n_elements)) # 2d +# data.append(d) +# f.append(data) + +# # append also works for data without time axis +# fp = tmp_path / "NS_write_header2.dfsu" +# with dfs.write_header(fp, items=items, start_time=time0, dt=3600) as f: +# for _ in range(nt): +# data = [] +# for _ in range(n_items): +# d = np.random.random((n_elements)) # 1d +# data.append(d) +# f.append(data) def test_writing_non_equdistant_dfsu_is_not_possible(tmp_path): From 81eb4e2f838a1ae330872cee4f59eac3f9bba07d Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 11:01:02 +0100 Subject: [PATCH 04/20] Remove Dfsu.write and Dfsu.append --- Makefile | 3 + mikeio/dfsu/_dfsu.py | 636 ++++++++++++++++++--------------------- mikeio/dfsu/_layered.py | 2 - mikeio/dfsu/_spectral.py | 23 +- tests/test_dfsu.py | 94 +++--- 5 files changed, 364 insertions(+), 394 deletions(-) diff --git a/Makefile b/Makefile index 931fec8d6..34a80e113 100644 --- a/Makefile +++ b/Makefile @@ -10,6 +10,9 @@ build: typecheck test lint: ruff . +pylint: + pylint --disable=all --enable=attribute-defined-outside-init mikeio/ + test: pytest --disable-warnings diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 62320686b..133ea145a 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -1,10 +1,8 @@ from __future__ import annotations -import os from pathlib import Path import warnings -from datetime import datetime, timedelta from functools import wraps -from typing import Collection, List, Tuple +from typing import Any, Collection, List, Tuple import numpy as np import pandas as pd @@ -12,7 +10,6 @@ from mikecore.DfsuBuilder import DfsuBuilder from mikecore.DfsuFile import DfsuFile, DfsuFileType from mikecore.eum import eumQuantity, eumUnit -from mikecore.MeshFile import MeshFile from tqdm import trange from mikeio.spatial._utils import xy_to_bbox @@ -25,7 +22,7 @@ _valid_item_numbers, _valid_timesteps, ) -from ..eum import EUMType, EUMUnit, ItemInfo +from ..eum import ItemInfo from ..spatial import ( GeometryFM2D, GeometryFM3D, @@ -117,18 +114,15 @@ def __init__(self, filename: str | Path) -> None: filename: str dfsu filename """ - # placeholder - # self._timestep_in_seconds = None - - # TODO remove self._filename = str(filename) - # input = self._filename if dfs is None else dfs - # self._read_header(filename) - # self.time = ... - self._geometry, self._time, self._timestep, self._items = self._read_header( - filename - ) - # self.items = ... + ( + self._geometry, + self._time, + self._timestep, + self._items, + self._type, + self._deletevalue, + ) = self._read_header(filename) def __repr__(self): out = [] @@ -170,65 +164,27 @@ def __repr__(self): out.append(f" {self.start_time} -- {self.end_time}") return str.join("\n", out) - def _read_header(self, input: str | Path) -> None: - # TODO set instance variables in __init__ instead of here + # TODO return type DfsHeader? + def _read_header( + self, input: str | Path + ) -> Tuple[Any, pd.DatetimeIndex, float, List[ItemInfo], DfsuFileType, float]: filename = input path = Path(input) if not path.exists(): raise FileNotFoundError(f"file {path} does not exist!") - ext = path.suffix.lower() + dfs = DfsuFile.Open(filename) + dfsu_type = DfsuFileType(dfs.DfsuFileType) + deletevalue = dfs.DeleteValueFloat - if ext == ".mesh": - raise ValueError("Not supported") - # TODO remove the possibility to read mesh files from this class - self._read_mesh_header(filename) - - elif ext == ".dfsu": - dfs = DfsuFile.Open(filename) - geometry, time, timestep, items = self._read_dfsu_header(dfs) - return geometry, time, timestep, items - else: - raise Exception(f"Filetype {ext} not supported (mesh,dfsu)") - - def _read_mesh_header(self, filename): - """ - Read header of mesh file and set object properties - """ - msh = MeshFile.ReadMesh(filename) - self._source = msh - self._type = None # =DfsuFileType.Mesh - - node_table = get_nodes_from_source(msh) - el_table = get_elements_from_source(msh) - - self._geometry = GeometryFM2D( - node_coordinates=node_table.coordinates, - element_table=el_table.connectivity, - codes=node_table.codes, - projection=msh.ProjectionString, - dfsu_type=self._type, - element_ids=el_table.ids, - node_ids=node_table.ids, - validate=False, - ) - - def _read_dfsu_header(self, dfs): - """ - Read header of dfsu file and set object properties - """ - self._source = dfs - self._type = DfsuFileType(dfs.DfsuFileType) - self._deletevalue = dfs.DeleteValueFloat - - if self.is_spectral: + if self._is_spectral(dfsu_type): dir = dfs.Directions directions = None if dir is None else dir * (180 / np.pi) frequencies = dfs.Frequencies # geometry - if self._type == DfsuFileType.DfsuSpectral0D: - geometry = GeometryFMPointSpectrum( + if dfsu_type == DfsuFileType.DfsuSpectral0D: + geometry: Any = GeometryFMPointSpectrum( frequencies=frequencies, directions=directions ) else: @@ -236,9 +192,9 @@ def _read_dfsu_header(self, dfs): node_table = get_nodes_from_source(dfs) el_table = get_elements_from_source(dfs) - if self.is_layered: - geom_cls = GeometryFM3D - if self._type in ( + if self._is_layered(dfsu_type): + geom_cls: Any = GeometryFM3D + if dfsu_type in ( DfsuFileType.DfsuVerticalProfileSigma, DfsuFileType.DfsuVerticalProfileSigmaZ, ): @@ -249,33 +205,33 @@ def _read_dfsu_header(self, dfs): element_table=el_table.connectivity, codes=node_table.codes, projection=dfs.Projection.WKTString, - dfsu_type=self._type, + dfsu_type=dfsu_type, element_ids=el_table.ids, node_ids=node_table.ids, n_layers=dfs.NumberOfLayers, n_sigma=min(dfs.NumberOfSigmaLayers, dfs.NumberOfLayers), validate=False, ) - elif self._type == DfsuFileType.DfsuSpectral1D: + elif dfsu_type == DfsuFileType.DfsuSpectral1D: geometry = GeometryFMLineSpectrum( node_coordinates=node_table.coordinates, element_table=el_table.connectivity, codes=node_table.codes, projection=dfs.Projection.WKTString, - dfsu_type=self._type, + dfsu_type=dfsu_type, element_ids=el_table.ids, node_ids=node_table.ids, validate=False, frequencies=frequencies, directions=directions, ) - elif self._type == DfsuFileType.DfsuSpectral2D: + elif dfsu_type == DfsuFileType.DfsuSpectral2D: geometry = GeometryFMAreaSpectrum( node_coordinates=node_table.coordinates, element_table=el_table.connectivity, codes=node_table.codes, projection=dfs.Projection.WKTString, - dfsu_type=self._type, + dfsu_type=dfsu_type, element_ids=el_table.ids, node_ids=node_table.ids, validate=False, @@ -288,7 +244,7 @@ def _read_dfsu_header(self, dfs): element_table=el_table.connectivity, codes=node_table.codes, projection=dfs.Projection.WKTString, - dfsu_type=self._type, + dfsu_type=dfsu_type, element_ids=el_table.ids, node_ids=node_table.ids, validate=False, @@ -296,9 +252,11 @@ def _read_dfsu_header(self, dfs): # items n_items = len(dfs.ItemInfo) - first_idx = 1 if self.is_layered else 0 + first_idx = 1 if self._is_layered(dfsu_type) else 0 items = _get_item_info( - dfs.ItemInfo, list(range(n_items - first_idx)), ignore_first=self.is_layered + dfs.ItemInfo, + list(range(n_items - first_idx)), + ignore_first=self._is_layered(dfsu_type), ) # time @@ -307,13 +265,10 @@ def _read_dfsu_header(self, dfs): periods=dfs.NumberOfTimeSteps, freq=f"{dfs.TimeStepInSeconds}S", ) - # self._start_time = dfs.StartDateTime - # self._n_timesteps = dfs.NumberOfTimeSteps - # self._timestep_in_seconds = dfs.TimeStepInSeconds timestep = dfs.TimeStepInSeconds dfs.Close() - return geometry, time, timestep, items + return geometry, time, timestep, items, dfsu_type, deletevalue @property def type_name(self): @@ -405,11 +360,9 @@ def is_2d(self): None, ) - @property - def is_layered(self): - """Type is layered dfsu (3d, vertical profile or vertical column)""" - return self._type in ( - DfsuFileType.DfsuVerticalColumn, + @staticmethod + def _is_layered(dfsu_type: DfsuFileType) -> bool: + return dfsu_type in ( DfsuFileType.DfsuVerticalProfileSigma, DfsuFileType.DfsuVerticalProfileSigmaZ, DfsuFileType.Dfsu3DSigma, @@ -417,14 +370,23 @@ def is_layered(self): ) @property - def is_spectral(self): - """Type is spectral dfsu (point, line or area spectrum)""" - return self._type in ( + def is_layered(self): + """Type is layered dfsu (3d, vertical profile or vertical column)""" + return self._is_layered(self._type) + + @staticmethod + def _is_spectral(dfsu_type: DfsuFileType) -> bool: + return dfsu_type in ( DfsuFileType.DfsuSpectral0D, DfsuFileType.DfsuSpectral1D, DfsuFileType.DfsuSpectral2D, ) + @property + def is_spectral(self): + """Type is spectral dfsu (point, line or area spectrum)""" + return self._is_spectral(self._type) + @property def is_tri_only(self): """Does the mesh consist of triangles only?""" @@ -658,8 +620,6 @@ def _read( # TODO: add more checks that this is actually still the same file # (could have been replaced in the meantime) - self._n_timesteps = dfs.NumberOfTimeSteps - single_time_selected, time_steps = _valid_timesteps(dfs, time) self._validate_elements_and_geometry_sel(elements, area=area, x=x, y=y) @@ -916,253 +876,255 @@ def write( keep_open=keep_open, ) - def _write( - self, - filename, - data, - start_time=None, - dt=None, - items=None, - elements=None, - title=None, - keep_open=False, - ): - """Write a new dfsu file - - Parameters - ----------- - filename: str - full path to the new dfsu file - data: list[np.array] or Dataset - list of matrices, one for each item. Matrix dimension: time, x - start_time: datetime, optional, deprecated - start date of type datetime. - dt: float, optional, deprecated - The time step (in seconds) - items: list[ItemInfo], optional, deprecated - elements: list[int], optional - write only these element ids to file - title: str - title of the dfsu file. Default is blank. - keep_open: bool, optional - Keep file open for appending - """ - if self.is_spectral: - raise ValueError("write() is not supported for spectral dfsu!") - - if dt and not keep_open: - warnings.warn( - "argument dt is deprecated, please supply data in the form of a Dataset", - FutureWarning, - ) - - filename = str(filename) - - if isinstance(data, Dataset): - items = data.items - start_time = data.time[0] - if dt is None and len(data.time) > 1: - if not data.is_equidistant: - raise ValueError( - "Data is not equidistant in time. Dfsu requires equidistant temporal axis!" - ) - dt = (data.time[1] - data.time[0]).total_seconds() - if data.geometry.is_layered: - zn_dynamic = data[0]._zn - - # data needs to be a list so we can fit zn later - data = [np.atleast_2d(x.to_numpy()) for x in data] - - n_items = len(data) - n_time_steps = 0 - if n_items > 0: - n_time_steps = np.shape(data[0])[0] - - if dt is None: - if ( - self.timestep is None - ): # TODO this is a sign that this method needs to be removed - dt = 1 - else: - dt = self.timestep # 1 # Arbitrary if there is only a single timestep - - if start_time is None: - if self.start_time is None: - start_time = datetime.now() - warnings.warn( - f"No start time supplied. Using current time: {start_time} as start time." - ) - else: - start_time = self.start_time - warnings.warn( - f"No start time supplied. Using start time from source: {start_time} as start time." - ) - - if items is None: - if n_items == 0: - raise ValueError( - "Number of items unknown. Add (..., items=[ItemInfo(...)]" - ) - items = [ItemInfo(f"Item {i + 1}") for i in range(n_items)] - - if title is None: - title = "" - - file_start_time = start_time - - # spatial subset - if elements is None: - geometry = self.geometry - else: - geometry = self.geometry.elements_to_geometry(elements) - if (not self.is_2d) and (geometry._type == DfsuFileType.Dfsu2D): - # redo extraction as 2d: - # print("will redo extraction in 2d!") - geometry = self.geometry.elements_to_geometry( - elements, node_layers="bottom" - ) - if (items[0].name == "Z coordinate") and ( - items[0].type == EUMType.ItemGeometry3D - ): - # get rid of z-item - items = items[1 : (n_items + 1)] - n_items = n_items - 1 - new_data = [] - for j in range(n_items): - new_data.append(data[j + 1]) - data = new_data - - if geometry.is_layered: - z_item = ItemInfo( - "Z coordinate", itemtype=EUMType.ItemGeometry3D, unit=EUMUnit.meter - ) - items.insert(0, z_item) - n_items = len(items) - zn_dynamic = geometry.node_coordinates[:, 2] - data.insert(0, zn_dynamic) - - # Default filetype; - if geometry._type is None: # == DfsuFileType.Mesh: - # create dfs2d from mesh - dfsu_filetype = DfsuFileType.Dfsu2D - else: - # # TODO: if subset is slice... - dfsu_filetype = geometry._type.value - - if dfsu_filetype != DfsuFileType.Dfsu2D: - if (items[0].name != "Z coordinate") and ( - items[0].type == EUMType.ItemGeometry3D - ): - raise Exception("First item must be z coordinates of the nodes!") - - xn = geometry.node_coordinates[:, 0] - yn = geometry.node_coordinates[:, 1] - - # zn have to be Single precision?? - zn = geometry.node_coordinates[:, 2] - - # TODO verify this - # elem_table = geometry.element_table - elem_table = [] - for j in range(geometry.n_elements): - elem_nodes = geometry.element_table[j] - elem_nodes = [nd + 1 for nd in elem_nodes] - elem_table.append(np.array(elem_nodes)) - elem_table = elem_table - - builder = DfsuBuilder.Create(dfsu_filetype) - - builder.SetNodes(xn, yn, zn, geometry.codes) - builder.SetElements(elem_table) - # builder.SetNodeIds(geometry.node_ids+1) - # builder.SetElementIds(geometry.elements+1) - - factory = DfsFactory() - proj = factory.CreateProjection(geometry.projection_string) - builder.SetProjection(proj) - builder.SetTimeInfo(file_start_time, dt) - builder.SetZUnit(eumUnit.eumUmeter) - - if dfsu_filetype != DfsuFileType.Dfsu2D: - builder.SetNumberOfSigmaLayers(geometry.n_sigma_layers) - - for item in items: - if item.name != "Z coordinate": - builder.AddDynamicItem( - item.name, eumQuantity.Create(item.type, item.unit) - ) - - builder.ApplicationTitle = "mikeio" - builder.ApplicationVersion = __dfs_version__ - - try: - # TODO self._dfs is used by append, can we handle this better? - self._dfs = builder.CreateFile(filename) - except IOError: - print("cannot create dfsu file: ", filename) - - deletevalue = self._dfs.DeleteValueFloat - - try: - # Add data for all item-timesteps, copying from source - - for i in trange(n_time_steps, disable=not self.show_progress): - if geometry.is_layered and len(data) > 0: - self._dfs.WriteItemTimeStepNext(0, data[0].astype(np.float32)) - - for item in range(len(items)): - if items[item].name != "Z coordinate": - d = data[item][i, :] - d[np.isnan(d)] = deletevalue - darray = d - self._dfs.WriteItemTimeStepNext(0, darray.astype(np.float32)) - if not keep_open: - self._dfs.Close() - else: - return self - - except Exception as e: - print(e) - self._dfs.Close() - os.remove(filename) - - def append(self, data: List[np.ndarray] | Dataset) -> None: - """Append to a dfsu file opened with `write(...,keep_open=True)` - - Parameters - ----------- - data: list[np.array] or Dataset - list of matrices, one for each item. Matrix dimension: time, x - """ - - deletevalue = self._dfs.DeleteValueFloat - n_items = len(data) - has_time_axis = len(np.shape(data[0])) == 2 # type: ignore - n_timesteps = np.shape(data[0])[0] if has_time_axis else 1 # type: ignore - for i in trange(n_timesteps, disable=not self.show_progress): - if self.geometry.is_layered: - zn = self.geometry.node_coordinates[:, 2] - self._dfs.WriteItemTimeStepNext(0, zn.astype(np.float32)) - for item in range(n_items): - dai: np.ndarray | DataArray | Dataset = data[item] - if isinstance(dai, DataArray): - di: np.ndarray = dai.to_numpy() - elif isinstance(dai, np.ndarray): # TODO is this too restrictive? - di = dai - d: np.ndarray = di[i, :] if has_time_axis else di - d[np.isnan(d)] = deletevalue - darray = d.astype(np.float32) - self._dfs.WriteItemTimeStepNext(0, darray) - - def close(self): - "Finalize write for a dfsu file opened with `write(...,keep_open=True)`" - self._dfs.Close() - - def __enter__(self): - return self - - def __exit__(self, type, value, traceback): - self._dfs.Close() + # def _write( + # self, + # filename, + # data, + # start_time=None, + # dt=None, + # items=None, + # elements=None, + # title=None, + # keep_open=False, + # ): + # """Write a new dfsu file + + # Parameters + # ----------- + # filename: str + # full path to the new dfsu file + # data: list[np.array] or Dataset + # list of matrices, one for each item. Matrix dimension: time, x + # start_time: datetime, optional, deprecated + # start date of type datetime. + # dt: float, optional, deprecated + # The time step (in seconds) + # items: list[ItemInfo], optional, deprecated + # elements: list[int], optional + # write only these element ids to file + # title: str + # title of the dfsu file. Default is blank. + # keep_open: bool, optional + # Keep file open for appending + # """ + # raise NotImplementedError("use _write_dfsu() instead") + + # if self.is_spectral: + # raise ValueError("write() is not supported for spectral dfsu!") + + # if dt and not keep_open: + # warnings.warn( + # "argument dt is deprecated, please supply data in the form of a Dataset", + # FutureWarning, + # ) + + # filename = str(filename) + + # if isinstance(data, Dataset): + # items = data.items + # start_time = data.time[0] + # if dt is None and len(data.time) > 1: + # if not data.is_equidistant: + # raise ValueError( + # "Data is not equidistant in time. Dfsu requires equidistant temporal axis!" + # ) + # dt = (data.time[1] - data.time[0]).total_seconds() + # if data.geometry.is_layered: + # zn_dynamic = data[0]._zn + + # # data needs to be a list so we can fit zn later + # data = [np.atleast_2d(x.to_numpy()) for x in data] + + # n_items = len(data) + # n_time_steps = 0 + # if n_items > 0: + # n_time_steps = np.shape(data[0])[0] + + # if dt is None: + # if ( + # self.timestep is None + # ): # TODO this is a sign that this method needs to be removed + # dt = 1 + # else: + # dt = self.timestep # 1 # Arbitrary if there is only a single timestep + + # if start_time is None: + # if self.start_time is None: + # start_time = datetime.now() + # warnings.warn( + # f"No start time supplied. Using current time: {start_time} as start time." + # ) + # else: + # start_time = self.start_time + # warnings.warn( + # f"No start time supplied. Using start time from source: {start_time} as start time." + # ) + + # if items is None: + # if n_items == 0: + # raise ValueError( + # "Number of items unknown. Add (..., items=[ItemInfo(...)]" + # ) + # items = [ItemInfo(f"Item {i + 1}") for i in range(n_items)] + + # if title is None: + # title = "" + + # file_start_time = start_time + + # # spatial subset + # if elements is None: + # geometry = self.geometry + # else: + # geometry = self.geometry.elements_to_geometry(elements) + # if (not self.is_2d) and (geometry._type == DfsuFileType.Dfsu2D): + # # redo extraction as 2d: + # # print("will redo extraction in 2d!") + # geometry = self.geometry.elements_to_geometry( + # elements, node_layers="bottom" + # ) + # if (items[0].name == "Z coordinate") and ( + # items[0].type == EUMType.ItemGeometry3D + # ): + # # get rid of z-item + # items = items[1 : (n_items + 1)] + # n_items = n_items - 1 + # new_data = [] + # for j in range(n_items): + # new_data.append(data[j + 1]) + # data = new_data + + # if geometry.is_layered: + # z_item = ItemInfo( + # "Z coordinate", itemtype=EUMType.ItemGeometry3D, unit=EUMUnit.meter + # ) + # items.insert(0, z_item) + # n_items = len(items) + # zn_dynamic = geometry.node_coordinates[:, 2] + # data.insert(0, zn_dynamic) + + # # Default filetype; + # if geometry._type is None: # == DfsuFileType.Mesh: + # # create dfs2d from mesh + # dfsu_filetype = DfsuFileType.Dfsu2D + # else: + # # # TODO: if subset is slice... + # dfsu_filetype = geometry._type.value + + # if dfsu_filetype != DfsuFileType.Dfsu2D: + # if (items[0].name != "Z coordinate") and ( + # items[0].type == EUMType.ItemGeometry3D + # ): + # raise Exception("First item must be z coordinates of the nodes!") + + # xn = geometry.node_coordinates[:, 0] + # yn = geometry.node_coordinates[:, 1] + + # # zn have to be Single precision?? + # zn = geometry.node_coordinates[:, 2] + + # # TODO verify this + # # elem_table = geometry.element_table + # elem_table = [] + # for j in range(geometry.n_elements): + # elem_nodes = geometry.element_table[j] + # elem_nodes = [nd + 1 for nd in elem_nodes] + # elem_table.append(np.array(elem_nodes)) + # elem_table = elem_table + + # builder = DfsuBuilder.Create(dfsu_filetype) + + # builder.SetNodes(xn, yn, zn, geometry.codes) + # builder.SetElements(elem_table) + # # builder.SetNodeIds(geometry.node_ids+1) + # # builder.SetElementIds(geometry.elements+1) + + # factory = DfsFactory() + # proj = factory.CreateProjection(geometry.projection_string) + # builder.SetProjection(proj) + # builder.SetTimeInfo(file_start_time, dt) + # builder.SetZUnit(eumUnit.eumUmeter) + + # if dfsu_filetype != DfsuFileType.Dfsu2D: + # builder.SetNumberOfSigmaLayers(geometry.n_sigma_layers) + + # for item in items: + # if item.name != "Z coordinate": + # builder.AddDynamicItem( + # item.name, eumQuantity.Create(item.type, item.unit) + # ) + + # builder.ApplicationTitle = "mikeio" + # builder.ApplicationVersion = __dfs_version__ + + # try: + # # TODO self._dfs is used by append, can we handle this better? + # self._dfs = builder.CreateFile(filename) + # except IOError: + # print("cannot create dfsu file: ", filename) + + # deletevalue = self._dfs.DeleteValueFloat + + # try: + # # Add data for all item-timesteps, copying from source + + # for i in trange(n_time_steps, disable=not self.show_progress): + # if geometry.is_layered and len(data) > 0: + # self._dfs.WriteItemTimeStepNext(0, data[0].astype(np.float32)) + + # for item in range(len(items)): + # if items[item].name != "Z coordinate": + # d = data[item][i, :] + # d[np.isnan(d)] = deletevalue + # darray = d + # self._dfs.WriteItemTimeStepNext(0, darray.astype(np.float32)) + # if not keep_open: + # self._dfs.Close() + # else: + # return self + + # except Exception as e: + # print(e) + # self._dfs.Close() + # os.remove(filename) + + # def append(self, data: List[np.ndarray] | Dataset) -> None: + # """Append to a dfsu file opened with `write(...,keep_open=True)` + + # Parameters + # ----------- + # data: list[np.array] or Dataset + # list of matrices, one for each item. Matrix dimension: time, x + # """ + + # deletevalue = self._dfs.DeleteValueFloat + # n_items = len(data) + # has_time_axis = len(np.shape(data[0])) == 2 # type: ignore + # n_timesteps = np.shape(data[0])[0] if has_time_axis else 1 # type: ignore + # for i in trange(n_timesteps, disable=not self.show_progress): + # if self.geometry.is_layered: + # zn = self.geometry.node_coordinates[:, 2] + # self._dfs.WriteItemTimeStepNext(0, zn.astype(np.float32)) + # for item in range(n_items): + # dai: np.ndarray | DataArray | Dataset = data[item] + # if isinstance(dai, DataArray): + # di: np.ndarray = dai.to_numpy() + # elif isinstance(dai, np.ndarray): # TODO is this too restrictive? + # di = dai + # d: np.ndarray = di[i, :] if has_time_axis else di + # d[np.isnan(d)] = deletevalue + # darray = d.astype(np.float32) + # self._dfs.WriteItemTimeStepNext(0, darray) + + # def close(self): + # "Finalize write for a dfsu file opened with `write(...,keep_open=True)`" + # self._dfs.Close() + + # def __enter__(self): + # return self + + # def __exit__(self, type, value, traceback): + # self._dfs.Close() def to_mesh(self, outfilename): """write object to mesh file @@ -1287,7 +1249,7 @@ def extract_track(self, track, items=None, method="nearest", dtype=np.float32): item_numbers = _valid_item_numbers(dfs.ItemInfo, items) items = _get_item_info(dfs.ItemInfo, item_numbers) - self._n_timesteps = dfs.NumberOfTimeSteps + # self._n_timesteps = dfs.NumberOfTimeSteps _, time_steps = _valid_timesteps(dfs, time_steps=None) res = _extract_track( diff --git a/mikeio/dfsu/_layered.py b/mikeio/dfsu/_layered.py index b08ce4ce6..3a886ff06 100644 --- a/mikeio/dfsu/_layered.py +++ b/mikeio/dfsu/_layered.py @@ -154,8 +154,6 @@ def read( # TODO: add more checks that this is actually still the same file # (could have been replaced in the meantime) - self._n_timesteps = dfs.NumberOfTimeSteps - single_time_selected, time_steps = _valid_timesteps(dfs, time) self._validate_elements_and_geometry_sel( diff --git a/mikeio/dfsu/_spectral.py b/mikeio/dfsu/_spectral.py index 70ff941b7..672b93af8 100644 --- a/mikeio/dfsu/_spectral.py +++ b/mikeio/dfsu/_spectral.py @@ -1,5 +1,5 @@ from __future__ import annotations -from typing import Tuple +from typing import Sized, Tuple import numpy as np import pandas as pd @@ -13,6 +13,13 @@ class DfsuSpectral(_Dfsu): + + def __init__(self, filename: str): + super().__init__(filename) + dfs = DfsuFile.Open(filename) + self._type = DfsuFileType(dfs.DfsuFileType) + dfs.Close() + @property def n_frequencies(self): """Number of frequencies""" @@ -33,7 +40,9 @@ def directions(self): """Directional axis""" return self.geometry._directions - def _get_spectral_data_shape(self, n_steps: int, elements): + def _get_spectral_data_shape( + self, n_steps: int, elements: Sized | None, dfsu_type: DfsuFileType + ) -> Tuple[Tuple[int, ...], Tuple[int, ...], Tuple[str, ...]]: dims = [] if n_steps == 1 else ["time"] n_freq = self.n_frequencies n_dir = self.n_directions @@ -42,9 +51,9 @@ def _get_spectral_data_shape(self, n_steps: int, elements): shape = (n_freq,) elif n_freq == 0: shape = (n_dir,) - if self._type == DfsuFileType.DfsuSpectral0D: + if dfsu_type == DfsuFileType.DfsuSpectral0D: read_shape = (n_steps, *shape) - elif self._type == DfsuFileType.DfsuSpectral1D: + elif dfsu_type == DfsuFileType.DfsuSpectral1D: # node-based, FE-style n_nodes = self.n_nodes if elements is None else len(elements) if n_nodes == 1: @@ -136,8 +145,6 @@ def read( # self._read_dfsu_header(self._filename) dfs = DfsuFile.Open(self._filename) - self._n_timesteps = dfs.NumberOfTimeSteps - single_time_selected, time_steps = _valid_timesteps(dfs, time) if self._type == DfsuFileType.DfsuSpectral2D: @@ -163,7 +170,9 @@ def read( data_list = [] n_steps = len(time_steps) - read_shape, shape, dims = self._get_spectral_data_shape(n_steps, pts) + read_shape, shape, dims = self._get_spectral_data_shape( + n_steps, pts, self._type + ) for item in range(n_items): # Initialize an empty data block data: np.ndarray = np.ndarray(shape=read_shape, dtype=dtype) diff --git a/tests/test_dfsu.py b/tests/test_dfsu.py index 8bb7d524f..7b0950fdd 100644 --- a/tests/test_dfsu.py +++ b/tests/test_dfsu.py @@ -535,73 +535,73 @@ def test_write_from_dfsu(tmp_path): assert dfs.end_time == newdfs.end_time -def test_incremental_write_from_dfsu(tmp_path): - "Useful for writing datasets with many timesteps to avoid problems with out of memory" +# def test_incremental_write_from_dfsu(tmp_path): +# "Useful for writing datasets with many timesteps to avoid problems with out of memory" - sourcefilename = "tests/testdata/HD2D.dfsu" - fp = tmp_path / "simple.dfsu" - dfs = mikeio.open(sourcefilename) +# sourcefilename = "tests/testdata/HD2D.dfsu" +# fp = tmp_path / "simple.dfsu" +# dfs = mikeio.open(sourcefilename) - nt = dfs.n_timesteps +# nt = dfs.n_timesteps - ds = dfs.read(time=[0], keepdims=True) +# ds = dfs.read(time=[0], keepdims=True) - dfs.write(fp, ds, keep_open=True) +# dfs.write(fp, ds, keep_open=True) - for i in range(1, nt): - ds = dfs.read(time=[i], keepdims=True) - dfs.append(ds) +# for i in range(1, nt): +# ds = dfs.read(time=[i], keepdims=True) +# dfs.append(ds) - dfs.close() +# dfs.close() - newdfs = mikeio.open(fp) - assert dfs.start_time == newdfs.start_time - assert dfs.timestep == newdfs.timestep - assert dfs.end_time == newdfs.end_time +# newdfs = mikeio.open(fp) +# assert dfs.start_time == newdfs.start_time +# assert dfs.timestep == newdfs.timestep +# assert dfs.end_time == newdfs.end_time -def test_incremental_write_from_dfsu_context_manager(tmp_path): - sourcefilename = "tests/testdata/HD2D.dfsu" - fp = tmp_path / "simple.dfsu" - dfs = mikeio.open(sourcefilename) +# def test_incremental_write_from_dfsu_context_manager(tmp_path): +# sourcefilename = "tests/testdata/HD2D.dfsu" +# fp = tmp_path / "simple.dfsu" +# dfs = mikeio.open(sourcefilename) - nt = dfs.n_timesteps +# nt = dfs.n_timesteps - ds = dfs.read(time=[0], keepdims=True) +# ds = dfs.read(time=[0], keepdims=True) - with dfs.write(fp, ds, keep_open=True) as f: - for i in range(1, nt): - ds = dfs.read(time=[i], keepdims=True) - f.append(ds) +# with dfs.write(fp, ds, keep_open=True) as f: +# for i in range(1, nt): +# ds = dfs.read(time=[i], keepdims=True) +# f.append(ds) - # dfs.close() # should be called automagically by context manager +# # dfs.close() # should be called automagically by context manager - newdfs = mikeio.open(fp) - assert dfs.start_time == newdfs.start_time - assert dfs.timestep == newdfs.timestep - assert dfs.end_time == newdfs.end_time +# newdfs = mikeio.open(fp) +# assert dfs.start_time == newdfs.start_time +# assert dfs.timestep == newdfs.timestep +# assert dfs.end_time == newdfs.end_time -def test_incremental_write_from_dfsu_context_manager_3d(tmp_path): - sourcefilename = "tests/testdata/oresund_sigma_z.dfsu" - fp = tmp_path / "3d.dfsu" - dfs = mikeio.open(sourcefilename) +# def test_incremental_write_from_dfsu_context_manager_3d(tmp_path): +# sourcefilename = "tests/testdata/oresund_sigma_z.dfsu" +# fp = tmp_path / "3d.dfsu" +# dfs = mikeio.open(sourcefilename) - nt = dfs.n_timesteps +# nt = dfs.n_timesteps - ds = dfs.read(time=[0], keepdims=True) +# ds = dfs.read(time=[0], keepdims=True) - with dfs.write(fp, ds, keep_open=True) as f: - for i in range(1, nt): - ds = dfs.read(time=[i], keepdims=True) - f.append(ds) +# with dfs.write(fp, ds, keep_open=True) as f: +# for i in range(1, nt): +# ds = dfs.read(time=[i], keepdims=True) +# f.append(ds) - # dfs.close() # should be called automagically by context manager +# # dfs.close() # should be called automagically by context manager - newdfs = mikeio.open(fp) - assert dfs.start_time == newdfs.start_time - assert dfs.timestep == newdfs.timestep - assert dfs.end_time == newdfs.end_time +# newdfs = mikeio.open(fp) +# assert dfs.start_time == newdfs.start_time +# assert dfs.timestep == newdfs.timestep +# assert dfs.end_time == newdfs.end_time # TODO add workaround to write big file @@ -936,8 +936,6 @@ def test_dataset_write_dfsu(tmp_path): dfs = mikeio.open(fp) - assert dfs._source.ApplicationTitle == "mikeio" - ds2 = dfs.read() assert ds2.n_timesteps == 2 From 1758d333a5ab65f6adedca3053b181b0ca907092 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 11:43:48 +0100 Subject: [PATCH 05/20] Remove Dfsu.write_header() --- mikeio/dfsu/_dfsu.py | 98 ++++++++++++++++++++++---------------------- 1 file changed, 49 insertions(+), 49 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 133ea145a..36918114b 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -783,58 +783,58 @@ def _parse_geometry_sel(self, area, x, y): return elements - def write_header( - self, - filename, - start_time=None, - dt=None, - items=None, - elements=None, - title=None, - ): - """Write the header of a new dfsu file (for writing huge files) + # def write_header( + # self, + # filename, + # start_time=None, + # dt=None, + # items=None, + # elements=None, + # title=None, + # ): + # """Write the header of a new dfsu file (for writing huge files) - Parameters - ----------- - filename: str - full path to the new dfsu file - start_time: datetime, optional - start datetime, default is datetime.now() - dt: float, optional - The time step (in seconds) - items: list[mikeio.ItemInfo], optional - elements: list[int], optional - write only these element ids to file - title: str - title of the dfsu file. Default is blank. + # Parameters + # ----------- + # filename: str + # full path to the new dfsu file + # start_time: datetime, optional + # start datetime, default is datetime.now() + # dt: float, optional + # The time step (in seconds) + # items: list[mikeio.ItemInfo], optional + # elements: list[int], optional + # write only these element ids to file + # title: str + # title of the dfsu file. Default is blank. - Examples - -------- - >>> from datetime import datetime - >>> meshfilename = "tests/testdata/north_sea_2.mesh" - >>> outfilename = "bigfile.dfsu" - >>> dfs = mikeio.Dfsu(meshfilename) - >>> n_elements = dfs.n_elements - >>> nt = 1000 - >>> n_items = 10 - >>> items = [mikeio.ItemInfo(f"Item {i+1}") for i in range(n_items)] - >>> with dfs.write_header(outfilename, items=items, start_time=datetime(2000,1,1), dt=3600) as f: - ... for _ in range(nt): - ... # get a list of data - ... data = [np.random.random((1, n_elements)) for _ in range(n_items)] - ... f.append(data) - """ + # Examples + # -------- + # >>> from datetime import datetime + # >>> meshfilename = "tests/testdata/north_sea_2.mesh" + # >>> outfilename = "bigfile.dfsu" + # >>> dfs = mikeio.Dfsu(meshfilename) + # >>> n_elements = dfs.n_elements + # >>> nt = 1000 + # >>> n_items = 10 + # >>> items = [mikeio.ItemInfo(f"Item {i+1}") for i in range(n_items)] + # >>> with dfs.write_header(outfilename, items=items, start_time=datetime(2000,1,1), dt=3600) as f: + # ... for _ in range(nt): + # ... # get a list of data + # ... data = [np.random.random((1, n_elements)) for _ in range(n_items)] + # ... f.append(data) + # """ - return self._write( - filename=filename, - data=[], - start_time=start_time, - dt=dt, - items=items, - elements=elements, - title=title, - keep_open=True, - ) + # return self._write( + # filename=filename, + # data=[], + # start_time=start_time, + # dt=dt, + # items=items, + # elements=elements, + # title=title, + # keep_open=True, + # ) def write( self, From bffb4acdaea3b4ac8a9a960418ee391dc5aea861 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 11:54:09 +0100 Subject: [PATCH 06/20] Remove deprecated Dfsu.plot and tests --- mikeio/dfsu/_dfsu.py | 421 +--------------------------------------- tests/test_dfsu_plot.py | 94 +-------- 2 files changed, 5 insertions(+), 510 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 36918114b..55713b88d 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -15,7 +15,7 @@ from mikeio.spatial._utils import xy_to_bbox from .. import __dfs_version__ -from ..dataset import DataArray, Dataset +from ..dataset import Dataset from ..dfs._dfs import ( _get_item_info, _read_item_time_step, @@ -31,7 +31,6 @@ GeometryFMPointSpectrum, GeometryFMVerticalProfile, ) -from ..spatial._FM_utils import _plot_map from ..spatial import Grid2D from .._track import _extract_track from ._common import get_elements_from_source, get_nodes_from_source @@ -481,68 +480,6 @@ def to_shapely(self): def get_node_centered_data(self, data, extrapolate=True): return self.geometry.get_node_centered_data(data, extrapolate) - def plot( - self, - z=None, - elements=None, - plot_type="patch", - title=None, - label=None, - cmap=None, - vmin=None, - vmax=None, - levels=None, - n_refinements=0, - show_mesh=True, - show_outline=True, - figsize=None, - ax=None, - add_colorbar=True, - ): - warnings.warn( - FutureWarning( - "Dfsu.plot() have been deprecated, please use DataArray.plot() instead" - ) - ) - if elements is None: - geometry = self.geometry.geometry2d - else: - # spatial subset - # TODO split subset and plot - if self.is_2d: - geometry = self.geometry.elements_to_geometry(elements) - else: - geometry = self.geometry.elements_to_geometry( - elements, node_layers="bottom" - ) - if z is not None: - if isinstance(z, DataArray): - z = z.to_numpy().copy() - if isinstance(z, Dataset) and len(z) == 1: # if single-item Dataset - z = z[0].to_numpy().copy() - - return _plot_map( - node_coordinates=geometry.node_coordinates, - element_table=geometry.element_table, - element_coordinates=geometry.element_coordinates, - boundary_polylines=self.boundary_polylines, - projection=geometry.projection, - z=z, - plot_type=plot_type, - title=title, - label=label, - cmap=cmap, - vmin=vmin, - vmax=vmax, - levels=levels, - n_refinements=n_refinements, - show_mesh=show_mesh, - show_outline=show_outline, - figsize=figsize, - ax=ax, - add_colorbar=add_colorbar, - ) - @property def deletevalue(self): """File delete value""" @@ -577,24 +514,11 @@ def timestep(self): def end_time(self): """File end time""" return self._time[-1] - # return self.start_time + timedelta( - # seconds=((self.n_timesteps - 1) * self.timestep) - # ) @property def time(self): return self._time - # @property - # def time(self): - # """File all datetimes""" - # return pd.to_datetime( - # [ - # self.start_time + timedelta(seconds=i * self.timestep) - # for i in range(self.n_timesteps) - # ] - # ) - def _read( self, *, @@ -783,349 +707,6 @@ def _parse_geometry_sel(self, area, x, y): return elements - # def write_header( - # self, - # filename, - # start_time=None, - # dt=None, - # items=None, - # elements=None, - # title=None, - # ): - # """Write the header of a new dfsu file (for writing huge files) - - # Parameters - # ----------- - # filename: str - # full path to the new dfsu file - # start_time: datetime, optional - # start datetime, default is datetime.now() - # dt: float, optional - # The time step (in seconds) - # items: list[mikeio.ItemInfo], optional - # elements: list[int], optional - # write only these element ids to file - # title: str - # title of the dfsu file. Default is blank. - - # Examples - # -------- - # >>> from datetime import datetime - # >>> meshfilename = "tests/testdata/north_sea_2.mesh" - # >>> outfilename = "bigfile.dfsu" - # >>> dfs = mikeio.Dfsu(meshfilename) - # >>> n_elements = dfs.n_elements - # >>> nt = 1000 - # >>> n_items = 10 - # >>> items = [mikeio.ItemInfo(f"Item {i+1}") for i in range(n_items)] - # >>> with dfs.write_header(outfilename, items=items, start_time=datetime(2000,1,1), dt=3600) as f: - # ... for _ in range(nt): - # ... # get a list of data - # ... data = [np.random.random((1, n_elements)) for _ in range(n_items)] - # ... f.append(data) - # """ - - # return self._write( - # filename=filename, - # data=[], - # start_time=start_time, - # dt=dt, - # items=items, - # elements=elements, - # title=title, - # keep_open=True, - # ) - - def write( - self, - filename, - data, - dt=None, - elements=None, - title=None, - keep_open=False, - ): - """Write a new dfsu file - - Parameters - ----------- - filename: str - full path to the new dfsu file - data: Dataset - list of matrices, one for each item. Matrix dimension: time, x - dt: float, optional - The time step (in seconds) - elements: list[int], optional - write only these element ids to file - title: str - title of the dfsu file. Default is blank. - keep_open: bool, optional - Keep file open for appending - """ - if isinstance(data, list): - raise TypeError( - "supplying data as a list of numpy arrays is deprecated, please supply data in the form of a Dataset" - ) - - return self._write( - filename=filename, - data=data, - dt=dt, - elements=elements, - title=title, - keep_open=keep_open, - ) - - # def _write( - # self, - # filename, - # data, - # start_time=None, - # dt=None, - # items=None, - # elements=None, - # title=None, - # keep_open=False, - # ): - # """Write a new dfsu file - - # Parameters - # ----------- - # filename: str - # full path to the new dfsu file - # data: list[np.array] or Dataset - # list of matrices, one for each item. Matrix dimension: time, x - # start_time: datetime, optional, deprecated - # start date of type datetime. - # dt: float, optional, deprecated - # The time step (in seconds) - # items: list[ItemInfo], optional, deprecated - # elements: list[int], optional - # write only these element ids to file - # title: str - # title of the dfsu file. Default is blank. - # keep_open: bool, optional - # Keep file open for appending - # """ - # raise NotImplementedError("use _write_dfsu() instead") - - # if self.is_spectral: - # raise ValueError("write() is not supported for spectral dfsu!") - - # if dt and not keep_open: - # warnings.warn( - # "argument dt is deprecated, please supply data in the form of a Dataset", - # FutureWarning, - # ) - - # filename = str(filename) - - # if isinstance(data, Dataset): - # items = data.items - # start_time = data.time[0] - # if dt is None and len(data.time) > 1: - # if not data.is_equidistant: - # raise ValueError( - # "Data is not equidistant in time. Dfsu requires equidistant temporal axis!" - # ) - # dt = (data.time[1] - data.time[0]).total_seconds() - # if data.geometry.is_layered: - # zn_dynamic = data[0]._zn - - # # data needs to be a list so we can fit zn later - # data = [np.atleast_2d(x.to_numpy()) for x in data] - - # n_items = len(data) - # n_time_steps = 0 - # if n_items > 0: - # n_time_steps = np.shape(data[0])[0] - - # if dt is None: - # if ( - # self.timestep is None - # ): # TODO this is a sign that this method needs to be removed - # dt = 1 - # else: - # dt = self.timestep # 1 # Arbitrary if there is only a single timestep - - # if start_time is None: - # if self.start_time is None: - # start_time = datetime.now() - # warnings.warn( - # f"No start time supplied. Using current time: {start_time} as start time." - # ) - # else: - # start_time = self.start_time - # warnings.warn( - # f"No start time supplied. Using start time from source: {start_time} as start time." - # ) - - # if items is None: - # if n_items == 0: - # raise ValueError( - # "Number of items unknown. Add (..., items=[ItemInfo(...)]" - # ) - # items = [ItemInfo(f"Item {i + 1}") for i in range(n_items)] - - # if title is None: - # title = "" - - # file_start_time = start_time - - # # spatial subset - # if elements is None: - # geometry = self.geometry - # else: - # geometry = self.geometry.elements_to_geometry(elements) - # if (not self.is_2d) and (geometry._type == DfsuFileType.Dfsu2D): - # # redo extraction as 2d: - # # print("will redo extraction in 2d!") - # geometry = self.geometry.elements_to_geometry( - # elements, node_layers="bottom" - # ) - # if (items[0].name == "Z coordinate") and ( - # items[0].type == EUMType.ItemGeometry3D - # ): - # # get rid of z-item - # items = items[1 : (n_items + 1)] - # n_items = n_items - 1 - # new_data = [] - # for j in range(n_items): - # new_data.append(data[j + 1]) - # data = new_data - - # if geometry.is_layered: - # z_item = ItemInfo( - # "Z coordinate", itemtype=EUMType.ItemGeometry3D, unit=EUMUnit.meter - # ) - # items.insert(0, z_item) - # n_items = len(items) - # zn_dynamic = geometry.node_coordinates[:, 2] - # data.insert(0, zn_dynamic) - - # # Default filetype; - # if geometry._type is None: # == DfsuFileType.Mesh: - # # create dfs2d from mesh - # dfsu_filetype = DfsuFileType.Dfsu2D - # else: - # # # TODO: if subset is slice... - # dfsu_filetype = geometry._type.value - - # if dfsu_filetype != DfsuFileType.Dfsu2D: - # if (items[0].name != "Z coordinate") and ( - # items[0].type == EUMType.ItemGeometry3D - # ): - # raise Exception("First item must be z coordinates of the nodes!") - - # xn = geometry.node_coordinates[:, 0] - # yn = geometry.node_coordinates[:, 1] - - # # zn have to be Single precision?? - # zn = geometry.node_coordinates[:, 2] - - # # TODO verify this - # # elem_table = geometry.element_table - # elem_table = [] - # for j in range(geometry.n_elements): - # elem_nodes = geometry.element_table[j] - # elem_nodes = [nd + 1 for nd in elem_nodes] - # elem_table.append(np.array(elem_nodes)) - # elem_table = elem_table - - # builder = DfsuBuilder.Create(dfsu_filetype) - - # builder.SetNodes(xn, yn, zn, geometry.codes) - # builder.SetElements(elem_table) - # # builder.SetNodeIds(geometry.node_ids+1) - # # builder.SetElementIds(geometry.elements+1) - - # factory = DfsFactory() - # proj = factory.CreateProjection(geometry.projection_string) - # builder.SetProjection(proj) - # builder.SetTimeInfo(file_start_time, dt) - # builder.SetZUnit(eumUnit.eumUmeter) - - # if dfsu_filetype != DfsuFileType.Dfsu2D: - # builder.SetNumberOfSigmaLayers(geometry.n_sigma_layers) - - # for item in items: - # if item.name != "Z coordinate": - # builder.AddDynamicItem( - # item.name, eumQuantity.Create(item.type, item.unit) - # ) - - # builder.ApplicationTitle = "mikeio" - # builder.ApplicationVersion = __dfs_version__ - - # try: - # # TODO self._dfs is used by append, can we handle this better? - # self._dfs = builder.CreateFile(filename) - # except IOError: - # print("cannot create dfsu file: ", filename) - - # deletevalue = self._dfs.DeleteValueFloat - - # try: - # # Add data for all item-timesteps, copying from source - - # for i in trange(n_time_steps, disable=not self.show_progress): - # if geometry.is_layered and len(data) > 0: - # self._dfs.WriteItemTimeStepNext(0, data[0].astype(np.float32)) - - # for item in range(len(items)): - # if items[item].name != "Z coordinate": - # d = data[item][i, :] - # d[np.isnan(d)] = deletevalue - # darray = d - # self._dfs.WriteItemTimeStepNext(0, darray.astype(np.float32)) - # if not keep_open: - # self._dfs.Close() - # else: - # return self - - # except Exception as e: - # print(e) - # self._dfs.Close() - # os.remove(filename) - - # def append(self, data: List[np.ndarray] | Dataset) -> None: - # """Append to a dfsu file opened with `write(...,keep_open=True)` - - # Parameters - # ----------- - # data: list[np.array] or Dataset - # list of matrices, one for each item. Matrix dimension: time, x - # """ - - # deletevalue = self._dfs.DeleteValueFloat - # n_items = len(data) - # has_time_axis = len(np.shape(data[0])) == 2 # type: ignore - # n_timesteps = np.shape(data[0])[0] if has_time_axis else 1 # type: ignore - # for i in trange(n_timesteps, disable=not self.show_progress): - # if self.geometry.is_layered: - # zn = self.geometry.node_coordinates[:, 2] - # self._dfs.WriteItemTimeStepNext(0, zn.astype(np.float32)) - # for item in range(n_items): - # dai: np.ndarray | DataArray | Dataset = data[item] - # if isinstance(dai, DataArray): - # di: np.ndarray = dai.to_numpy() - # elif isinstance(dai, np.ndarray): # TODO is this too restrictive? - # di = dai - # d: np.ndarray = di[i, :] if has_time_axis else di - # d[np.isnan(d)] = deletevalue - # darray = d.astype(np.float32) - # self._dfs.WriteItemTimeStepNext(0, darray) - - # def close(self): - # "Finalize write for a dfsu file opened with `write(...,keep_open=True)`" - # self._dfs.Close() - - # def __enter__(self): - # return self - - # def __exit__(self, type, value, traceback): - # self._dfs.Close() - def to_mesh(self, outfilename): """write object to mesh file diff --git a/tests/test_dfsu_plot.py b/tests/test_dfsu_plot.py index f716c020d..f383b4e4e 100644 --- a/tests/test_dfsu_plot.py +++ b/tests/test_dfsu_plot.py @@ -9,8 +9,6 @@ mpl.rcParams.update({"figure.max_open_warning": 100}) - - ################################################## # these tests will not run if matplotlib is not installed ################################################## @@ -21,54 +19,6 @@ def hd2d_dfs(): return mikeio.open("tests/testdata/HD2D.dfsu") -def test_plot_bathymetry(): - filename = "tests/testdata/oresund_sigma_z.dfsu" - dfs = mikeio.open(filename) - with pytest.warns(FutureWarning): - dfs.plot() - assert True - - -def test_plot_bathymetry_no_colorbar(): - filename = "tests/testdata/oresund_sigma_z.dfsu" - dfs = mikeio.open(filename) - with pytest.warns(FutureWarning): - dfs.plot(add_colorbar=False) - assert True - - -def test_plot_2d(hd2d_dfs): - dfs = hd2d_dfs - with pytest.warns(FutureWarning): - dfs.plot(cmap="plasma") - assert True - - -def test_plot_3d(): - filename = "tests/testdata/oresund_sigma_z.dfsu" - dfs = mikeio.open(filename) - with pytest.warns(FutureWarning): - dfs.plot() - assert True - - -def test_plot_dfsu_contour(hd2d_dfs): - dfs = hd2d_dfs - with pytest.warns(FutureWarning): - dfs.plot(plot_type="contour", levels=5) - assert True - - -def test_plot_dfsu_contourf_levels(hd2d_dfs): - dfs = hd2d_dfs - cmap = mpl.colors.ListedColormap(["red", "green", "blue"]) - bounds = [-3, 1, 2, 100] - with pytest.warns(FutureWarning): - dfs.plot(levels=bounds, cmap=cmap) - with pytest.warns(FutureWarning): - dfs.plot(plot_type="contourf", levels=bounds, cmap=cmap) - assert True - def test_plot_dfsu_contour_mixedmesh(): dfs = mikeio.open("tests/testdata/FakeLake.dfsu") @@ -90,18 +40,6 @@ def test_plot_dfsu_n_refinements(): assert True -def test_plot_dfsu_shaded(hd2d_dfs): - dfs = hd2d_dfs - da = dfs.read(items="Surface elevation", time=0)[0] - elem40 = np.arange(40) - - ax = da.plot(elements=elem40) # this is ok - assert ax is not None - - wl_40 = da.values[elem40] - with pytest.warns(FutureWarning): - dfs.plot(wl_40, elements=elem40, plot_type="shaded", levels=5) - def test_plot_dfsu_contour_subset_not_allowed(hd2d_dfs): dfs = hd2d_dfs da = dfs.read(items="Surface elevation", time=0)[0] @@ -110,31 +48,6 @@ def test_plot_dfsu_contour_subset_not_allowed(hd2d_dfs): da.plot.contour(elements=elem40) - -def test_plot_dfsu(hd2d_dfs): - dfs = hd2d_dfs - data = dfs.read() - with pytest.warns(FutureWarning): - dfs.plot(z=data[1][0, :], figsize=(3, 3), plot_type="mesh_only") - assert True - - -def test_plot_dfsu_squeeze(hd2d_dfs): - dfs = hd2d_dfs - data = dfs.read(items=0, time=0) - with pytest.warns(FutureWarning): - dfs.plot(z=data) # 1 item-dataset - assert True - - -def test_plot_dfsu_arguments(): - dfs = mikeio.open("tests/testdata/NorthSea_HD_and_windspeed.dfsu") - dfs.read() - with pytest.warns(FutureWarning): - dfs.plot(title="test", label="test", vmin=-23, vmax=23) - assert True - - def test_plot_mesh(): msh = Mesh("tests/testdata/odense_rough.mesh") msh.plot(show_mesh=False) @@ -208,7 +121,7 @@ def test_da_plot(): da.plot() da.plot(show_mesh=True) da.plot.contour() - da.plot.contourf(show_mesh=True,cmap='terrain', levels=[-30,-20,-10,0]) + da.plot.contourf(show_mesh=True, cmap="terrain", levels=[-30, -20, -10, 0]) da.plot.outline() dam = da.max() @@ -220,8 +133,9 @@ def test_da_plot(): plt.close("all") + def test_plot_non_utm_file(): - + ds = mikeio.read("tests/testdata/FakeLake_NONUTM.dfsu") da = ds[0] - da.plot() \ No newline at end of file + da.plot() From 48ba8164078c21086e9013be515dea90005b3340 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 12:56:12 +0100 Subject: [PATCH 07/20] Dfsu map to types --- mikeio/dataset/_dataset.py | 4 +- mikeio/dfsu/__init__.py | 4 +- mikeio/dfsu/_dfsu.py | 11 +++++- mikeio/dfsu/_factory.py | 79 ++++++++++---------------------------- mikeio/dfsu/_spectral.py | 6 --- 5 files changed, 34 insertions(+), 70 deletions(-) diff --git a/mikeio/dataset/_dataset.py b/mikeio/dataset/_dataset.py index 2c1fed3b5..087c0639f 100644 --- a/mikeio/dataset/_dataset.py +++ b/mikeio/dataset/_dataset.py @@ -1883,9 +1883,9 @@ def _to_dfs1(self, filename: str | Path) -> None: write_dfs1(filename=filename, ds=self) def _to_dfsu(self, filename: str | Path) -> None: - from ..dfsu._dfsu import _write_dfsu + from ..dfsu import write_dfsu - _write_dfsu(filename, self) + write_dfsu(filename, self) def to_xarray(self) -> "xarray.Dataset": """Export to xarray.Dataset""" diff --git a/mikeio/dfsu/__init__.py b/mikeio/dfsu/__init__.py index 3a11c06b1..abe595dd8 100644 --- a/mikeio/dfsu/__init__.py +++ b/mikeio/dfsu/__init__.py @@ -1,4 +1,4 @@ -from ._dfsu import _write_dfsu, Dfsu2DH +from ._dfsu import write_dfsu, Dfsu2DH from ._mesh import Mesh from ._factory import Dfsu from ._layered import Dfsu2DV, Dfsu3D @@ -7,7 +7,7 @@ __all__ = [ "Mesh", "Dfsu", - "_write_dfsu", + "write_dfsu", "Dfsu2DH", "Dfsu2DV", "Dfsu3D", diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 55713b88d..f96b2872e 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -36,7 +36,16 @@ from ._common import get_elements_from_source, get_nodes_from_source -def _write_dfsu(filename: str | Path, data: Dataset) -> None: +def write_dfsu(filename: str | Path, data: Dataset) -> None: + """Write a dfsu file + + Parameters + ---------- + filename: str + dfsu filename + data: Dataset + Dataset to be written + """ filename = str(filename) if len(data.time) == 1: diff --git a/mikeio/dfsu/_factory.py b/mikeio/dfsu/_factory.py index ebb99d968..76f29a1b0 100644 --- a/mikeio/dfsu/_factory.py +++ b/mikeio/dfsu/_factory.py @@ -1,69 +1,30 @@ -from pathlib import Path - -from mikecore.DfsuFile import DfsuFile, DfsuFileType # type: ignore +from mikecore.DfsuFile import DfsuFile, DfsuFileType from ._dfsu import Dfsu2DH from ._layered import Dfsu2DV, Dfsu3D from ._spectral import DfsuSpectral +DFSU_MAPPING = { + # DfsuFileType.Dfsu1D: None, + DfsuFileType.Dfsu2D: Dfsu2DH, + # DfsuFileType.DfsuVerticalColumn: None, + DfsuFileType.DfsuVerticalProfileSigma: Dfsu2DV, + DfsuFileType.DfsuVerticalProfileSigmaZ: Dfsu2DV, + DfsuFileType.Dfsu3DSigma: Dfsu3D, + DfsuFileType.Dfsu3DSigmaZ: Dfsu3D, + DfsuFileType.DfsuSpectral0D: DfsuSpectral, + DfsuFileType.DfsuSpectral1D: DfsuSpectral, + DfsuFileType.DfsuSpectral2D: DfsuSpectral, +} + + class Dfsu: def __new__(self, filename, *args, **kwargs): filename = str(filename) - type, dfs = self._get_DfsuFileType_n_Obj(filename) - - if self._type_is_spectral(type): - return DfsuSpectral(filename, *args, **kwargs) - elif self._type_is_2d_horizontal(type): - return Dfsu2DH(filename, *args, **kwargs) - elif self._type_is_2d_vertical(type): - return Dfsu2DV(filename, *args, **kwargs) - elif self._type_is_3d(type): - return Dfsu3D(filename, *args, **kwargs) - else: - raise ValueError(f"Type {type} is unsupported!") - - @staticmethod - def _get_DfsuFileType_n_Obj(filename: str): - ext = Path(filename).suffix.lower() - if "dfs" in ext: - dfs = DfsuFile.Open(filename) - type = DfsuFileType(dfs.DfsuFileType) - # dfs.Close() - elif "mesh" in ext: - type = None - dfs = None - else: - raise ValueError(f"{ext} is an unsupported extension") - return type, dfs - - @staticmethod - def _type_is_2d_horizontal(type): - return type in ( - DfsuFileType.Dfsu2D, - DfsuFileType.DfsuSpectral2D, - None, - ) - - @staticmethod - def _type_is_2d_vertical(type): - return type in ( - DfsuFileType.DfsuVerticalProfileSigma, - DfsuFileType.DfsuVerticalProfileSigmaZ, - ) - - @staticmethod - def _type_is_3d(type): - return type in ( - DfsuFileType.Dfsu3DSigma, - DfsuFileType.Dfsu3DSigmaZ, - ) + dfs = DfsuFile.Open(filename) + type = DfsuFileType(dfs.DfsuFileType) + dfs.Close() - @staticmethod - def _type_is_spectral(type): - """Type is spectral dfsu (point, line or area spectrum)""" - return type in ( - DfsuFileType.DfsuSpectral0D, - DfsuFileType.DfsuSpectral1D, - DfsuFileType.DfsuSpectral2D, - ) + klass = DFSU_MAPPING.get(type) + return klass(filename, *args, **kwargs) diff --git a/mikeio/dfsu/_spectral.py b/mikeio/dfsu/_spectral.py index 672b93af8..1fc7d6f21 100644 --- a/mikeio/dfsu/_spectral.py +++ b/mikeio/dfsu/_spectral.py @@ -14,12 +14,6 @@ class DfsuSpectral(_Dfsu): - def __init__(self, filename: str): - super().__init__(filename) - dfs = DfsuFile.Open(filename) - self._type = DfsuFileType(dfs.DfsuFileType) - dfs.Close() - @property def n_frequencies(self): """Number of frequencies""" From ebb69cae8ddc044309b3d18d397a2f1ee6093fb3 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 13:58:06 +0100 Subject: [PATCH 08/20] Factory refactored --- mikeio/dfsu/_factory.py | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/mikeio/dfsu/_factory.py b/mikeio/dfsu/_factory.py index 76f29a1b0..079de65db 100644 --- a/mikeio/dfsu/_factory.py +++ b/mikeio/dfsu/_factory.py @@ -1,3 +1,5 @@ +from pathlib import Path +from typing import Any from mikecore.DfsuFile import DfsuFile, DfsuFileType from ._dfsu import Dfsu2DH @@ -19,12 +21,20 @@ } +def dfsu(filename: str | Path, *args: Any, **kwargs: Any) -> Any: + filename = str(filename) + dfs = DfsuFile.Open(filename) + type = DfsuFileType(dfs.DfsuFileType) + dfs.Close() + + klass = DFSU_MAPPING.get(type) + + if klass is None: + raise ValueError(f"Unsupported dfsu type: {type}") + + return klass(filename, *args, **kwargs) + + class Dfsu: - def __new__(self, filename, *args, **kwargs): - filename = str(filename) - dfs = DfsuFile.Open(filename) - type = DfsuFileType(dfs.DfsuFileType) - dfs.Close() - - klass = DFSU_MAPPING.get(type) - return klass(filename, *args, **kwargs) + def __new__(self, filename: str | Path, *args: Any, **kwargs: Any): + return dfsu(filename, *args, **kwargs) From 1ad63a3ccaf50fe10d01b383520d731d67f37548 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 13:58:15 +0100 Subject: [PATCH 09/20] Unsupported notebook --- notebooks/Dfsu - Write huge file.ipynb | 267 ------------------------- 1 file changed, 267 deletions(-) delete mode 100644 notebooks/Dfsu - Write huge file.ipynb diff --git a/notebooks/Dfsu - Write huge file.ipynb b/notebooks/Dfsu - Write huge file.ipynb deleted file mode 100644 index 691bd43db..000000000 --- a/notebooks/Dfsu - Write huge file.ipynb +++ /dev/null @@ -1,267 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Dfsu - Write huge file\n", - "\n", - "The Dataset.to_dfs() method is the primary way of writing dfs files in MIKE IO. In some case, however, the data we want to write to a file is larger than the system memory and we will therefore not be able to store it in a Dataset before writing to disk. \n", - "\n", - "This notebook shows how to write larger-than-memory data to a dfsu file." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import mikeio" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Flexible Mesh Geometry: Dfsu2D\n", - "number of nodes: 1296\n", - "number of elements: 2259\n", - "projection: LONG/LAT" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mesh_file = \"../tests/testdata/north_sea_2.mesh\"\n", - "msh = mikeio.open(mesh_file)\n", - "msh.geometry" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "time = pd.date_range(\"2018-1-1\", end=\"2018-2-1\", freq=\"D\")\n", - "dt_seconds = (time[1] - time[0]).total_seconds()\n", - "xy = msh.geometry.element_coordinates[:,:2]" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# the \"data\" to be written to file\n", - "item1 = mikeio.ItemInfo(\"Item1\", mikeio.EUMType.Water_Level)\n", - "def func1(t, x, y):\n", - " t = np.atleast_1d(t)\n", - " data = np.zeros(shape=(len(t), len(x)))\n", - " for j in range(len(t)):\n", - " data[j,:] = 0.01*t[j]*np.cos(0.2*x)*np.sin(2*y)\n", - " return data\n", - "\n", - "item2 = mikeio.ItemInfo(\"Item2\", mikeio.EUMType.Water_Level)\n", - "def func2(t, x, y):\n", - " t = np.atleast_1d(t)\n", - " data = np.zeros(shape=(len(t), len(x)))\n", - " for j in range(len(t)):\n", - " data[j,:] = 0.01*(3-t[j])*np.cos(0.4*x)*np.sin(0.8*y) \n", - " return data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Option 1: Dataset with one timestep and append()\n", - "\n", - "1. Create first a Dataset ds only containing the first timestep\n", - "2. Use dfs.write(..., keep_open=True) to write the header and the first time step to disk\n", - "3. Write additional timesteps with dfs.append(...)\n", - "4. close with dfs.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "data10 = func1(t=0, x=xy[:,0], y=xy[:,1])\n", - "da1 = mikeio.DataArray(data=data10, time=time[0], geometry=msh.geometry, item=item1)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data20 = func2(t=0, x=xy[:,0], y=xy[:,1])\n", - "da2 = mikeio.DataArray(data=data20, time=time[0], geometry=msh.geometry, item=item2)\n", - "da2.plot();" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "dims: (time:1, element:2259)\n", - "time: 2018-01-01 00:00:00 (time-invariant)\n", - "geometry: Dfsu2D (2259 elements, 1296 nodes)\n", - "items:\n", - " 0: Item1 (meter)\n", - " 1: Item2 (meter)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds = mikeio.Dataset([da1, da2])\n", - "ds" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "dfs = mikeio.Dfsu(mesh_file)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "fn = \"bigfile1.dfsu\"\n", - "with dfs.write(fn, data=ds, dt=dt_seconds, keep_open=True) as f:\n", - " for tj in time[1:]:\n", - " t = (tj - time[0]).total_seconds()\n", - " ds[0].values = func1(t, x=xy[:,0], y=xy[:,1])\n", - " ds[1].values = func2(t, x=xy[:,0], y=xy[:,1])\n", - " ds.time = tj\n", - " f.append(ds)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Option 2: Dfsu.write_header()\n", - "\n", - "The older option is to use dfs.write_header() " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "dfs = mikeio.Dfsu(mesh_file)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "fn = \"bigfile2.dfsu\"\n", - "with dfs.write_header(fn, start_time=time[0], dt=dt_seconds, items=[item1, item2]) as f:\n", - " for tj in time:\n", - " t = (tj - time[0]).total_seconds()\n", - " data1 = func1(t, x=xy[:,0], y=xy[:,1])\n", - " data2 = func2(t, x=xy[:,0], y=xy[:,1])\n", - " f.append(data=[data1, data2])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Clean up" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "os.remove(\"bigfile1.dfsu\")\n", - "os.remove(\"bigfile2.dfsu\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.10.8 ('base')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.8" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "7aec4f91c09090e98e6ae8203c38529831bb4a3ce54cd1b69639b53cb01a6aa9" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 4f373e991b95ed5f099559c6aed5550cb5c32114 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 13:58:22 +0100 Subject: [PATCH 10/20] Spectral --- mikeio/_spectral.py | 9 -- mikeio/dfsu/_spectral.py | 166 ++++++++++++++++++------------------ tests/test_dfsu_spectral.py | 27 +++--- 3 files changed, 96 insertions(+), 106 deletions(-) diff --git a/mikeio/_spectral.py b/mikeio/_spectral.py index 99778eb5a..c05da274e 100644 --- a/mikeio/_spectral.py +++ b/mikeio/_spectral.py @@ -61,15 +61,6 @@ def plot_2dspectrum( Returns ------- - - Examples - -------- - >>> dfs = Dfsu("area_spectrum.dfsu") - >>> ds = dfs.read(items="Energy density") - >>> spectrum = ds[0][0, 0, :, :] # first timestep, element 0 - >>> dfs.plot_spectrum(spectrum, plot_type="patch") - - >>> dfs.plot_spectrum(spectrum, rmax=9, title="Wave spectrum T<9s") """ import matplotlib.pyplot as plt diff --git a/mikeio/dfsu/_spectral.py b/mikeio/dfsu/_spectral.py index 1fc7d6f21..945f2f5be 100644 --- a/mikeio/dfsu/_spectral.py +++ b/mikeio/dfsu/_spectral.py @@ -8,7 +8,7 @@ from ..dataset import DataArray, Dataset from ..dfs._dfs import _get_item_info, _valid_item_numbers, _valid_timesteps -from .._spectral import calc_m0_from_spectrum, plot_2dspectrum +from .._spectral import calc_m0_from_spectrum from ._dfsu import _Dfsu @@ -241,88 +241,88 @@ def _parse_elements_nodes(self, elements, nodes): geometry = self.geometry.elements_to_geometry(elements) return geometry, elements - def plot_spectrum( - self, - spectrum, - plot_type="contourf", - title=None, - label=None, - cmap="Reds", - vmin=1e-5, - vmax=None, - r_as_periods=True, - rmin=None, - rmax=None, - levels=None, - figsize=(7, 7), - add_colorbar=True, - ): - """ - Plot spectrum in polar coordinates - - Parameters - ---------- - spectrum: np.array - spectral values as 2d array with dimensions: directions, frequencies - plot_type: str, optional - type of plot: 'contour', 'contourf', 'patch', 'shaded', - by default: 'contourf' - title: str, optional - axes title - label: str, optional - colorbar label (or title if contour plot) - cmap: matplotlib.cm.cmap, optional - colormap, default Reds - vmin: real, optional - lower bound of values to be shown on plot, default: 1e-5 - vmax: real, optional - upper bound of values to be shown on plot, default:None - r_as_periods: bool, optional - show radial axis as periods instead of frequency, default: True - rmin: float, optional - mininum frequency/period to be shown, default: None - rmax: float, optional - maximum frequency/period to be shown, default: None - levels: int, list(float), optional - for contour plots: how many levels, default:10 - or a list of discrete levels e.g. [0.03, 0.04, 0.05] - figsize: (float, float), optional - specify size of figure, default (7, 7) - add_colorbar: bool, optional - Add colorbar to plot, default True - - Returns - ------- - - - Examples - -------- - >>> dfs = mikeio.Dfsu("tests/testdata/area_spectra.dfsu") - >>> ds = dfs.read(items="Energy density") - >>> spectrum = ds[0][0, 0, :, :] # first timestep, element 0 - >>> ax = dfs.plot_spectrum(spectrum, plot_type="patch") - >>> ax = dfs.plot_spectrum(spectrum, rmax=9, title="Wave spectrum T<9s"); - """ - if isinstance(spectrum, DataArray): - spectrum = spectrum.to_numpy() - - return plot_2dspectrum( - spectrum, - frequencies=self.frequencies, - directions=self.directions, - plot_type=plot_type, - title=title, - label=label, - cmap=cmap, - vmin=vmin, - vmax=vmax, - r_as_periods=r_as_periods, - rmin=rmin, - rmax=rmax, - levels=levels, - figsize=figsize, - add_colorbar=add_colorbar, - ) + # def plot_spectrum( + # self, + # spectrum, + # plot_type="contourf", + # title=None, + # label=None, + # cmap="Reds", + # vmin=1e-5, + # vmax=None, + # r_as_periods=True, + # rmin=None, + # rmax=None, + # levels=None, + # figsize=(7, 7), + # add_colorbar=True, + # ): + # """ + # Plot spectrum in polar coordinates + + # Parameters + # ---------- + # spectrum: np.array + # spectral values as 2d array with dimensions: directions, frequencies + # plot_type: str, optional + # type of plot: 'contour', 'contourf', 'patch', 'shaded', + # by default: 'contourf' + # title: str, optional + # axes title + # label: str, optional + # colorbar label (or title if contour plot) + # cmap: matplotlib.cm.cmap, optional + # colormap, default Reds + # vmin: real, optional + # lower bound of values to be shown on plot, default: 1e-5 + # vmax: real, optional + # upper bound of values to be shown on plot, default:None + # r_as_periods: bool, optional + # show radial axis as periods instead of frequency, default: True + # rmin: float, optional + # mininum frequency/period to be shown, default: None + # rmax: float, optional + # maximum frequency/period to be shown, default: None + # levels: int, list(float), optional + # for contour plots: how many levels, default:10 + # or a list of discrete levels e.g. [0.03, 0.04, 0.05] + # figsize: (float, float), optional + # specify size of figure, default (7, 7) + # add_colorbar: bool, optional + # Add colorbar to plot, default True + + # Returns + # ------- + # + + # Examples + # -------- + # >>> dfs = mikeio.Dfsu("tests/testdata/area_spectra.dfsu") + # >>> ds = dfs.read(items="Energy density") + # >>> spectrum = ds[0][0, 0, :, :] # first timestep, element 0 + # >>> ax = dfs.plot_spectrum(spectrum, plot_type="patch") + # >>> ax = dfs.plot_spectrum(spectrum, rmax=9, title="Wave spectrum T<9s"); + # """ + # if isinstance(spectrum, DataArray): + # spectrum = spectrum.to_numpy() + + # return plot_2dspectrum( + # spectrum, + # frequencies=self.frequencies, + # directions=self.directions, + # plot_type=plot_type, + # title=title, + # label=label, + # cmap=cmap, + # vmin=vmin, + # vmax=vmax, + # r_as_periods=r_as_periods, + # rmin=rmin, + # rmax=rmax, + # levels=levels, + # figsize=figsize, + # add_colorbar=add_colorbar, + # ) def calc_Hm0_from_spectrum( self, spectrum: np.ndarray | DataArray, tail=True diff --git a/tests/test_dfsu_spectral.py b/tests/test_dfsu_spectral.py index ac74061bc..55cf7f64f 100644 --- a/tests/test_dfsu_spectral.py +++ b/tests/test_dfsu_spectral.py @@ -369,23 +369,22 @@ def test_calc_Hm0_from_spectrum_area(dfsu_area): def test_plot_spectrum(dfsu_pt): dfs = dfsu_pt ds = dfs.read(time=0) - spec = ds[0].to_numpy() - dfs.plot_spectrum(spec, levels=3, add_colorbar=False) - dfs.plot_spectrum(spec, vmin=0, cmap="Greys") - dfs.plot_spectrum(spec, title="pt", plot_type="shaded") - dfs.plot_spectrum(spec, r_as_periods=False, plot_type="contour") + da = ds[0] + da.plot(levels=3, add_colorbar=False) + da.plot(levels=3, vmin=0, cmap="Greys") + da.plot(title="pt", plot_type="shaded") + da.plot(r_as_periods=False, plot_type="contour") plt.close("all") -def test_plot_spectrum_sector(dfsu_area_sector): - dfs = dfsu_area_sector - ds = dfs.read(time=0) - spec = ds[0].to_numpy()[0] - dfs.plot_spectrum(spec) - dfs.plot_spectrum(spec, rmax=10, vmin=0) - dfs.plot_spectrum(spec, rmin=0, plot_type="patch") - dfs.plot_spectrum(spec, r_as_periods=False, plot_type="contour") - plt.close("all") +# def test_plot_spectrum_sector(dfsu_area_sector): +# dfs = dfsu_area_sector +# ds = dfs.read(time=0) +# da = ds[0] +# da.plot(rmax=10, vmin=0) +# da.plot(rmin=0, plot_type="patch") +# da.plot(r_as_periods=False, plot_type="contour") +# plt.close("all") def test_plot_da_spectrum(dfsu_pt): From d8f94b45cbf0d9c5561714758e3679e430f7a988 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 15:40:39 +0100 Subject: [PATCH 11/20] Read geometry --- mikeio/dfsu/_dfsu.py | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index f96b2872e..6d5de458f 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -124,13 +124,13 @@ def __init__(self, filename: str | Path) -> None: """ self._filename = str(filename) ( - self._geometry, self._time, self._timestep, self._items, self._type, self._deletevalue, ) = self._read_header(filename) + self._geometry = self._read_geometry(filename) def __repr__(self): out = [] @@ -172,18 +172,10 @@ def __repr__(self): out.append(f" {self.start_time} -- {self.end_time}") return str.join("\n", out) - # TODO return type DfsHeader? - def _read_header( - self, input: str | Path - ) -> Tuple[Any, pd.DatetimeIndex, float, List[ItemInfo], DfsuFileType, float]: - filename = input - path = Path(input) - if not path.exists(): - raise FileNotFoundError(f"file {path} does not exist!") - + def _read_geometry(self, input: str | Path) -> Any: + filename = str(input) dfs = DfsuFile.Open(filename) dfsu_type = DfsuFileType(dfs.DfsuFileType) - deletevalue = dfs.DeleteValueFloat if self._is_spectral(dfsu_type): dir = dfs.Directions @@ -257,6 +249,21 @@ def _read_header( node_ids=node_table.ids, validate=False, ) + dfs.Close() + return geometry + + def _read_header( + self, input: str | Path + ) -> Tuple[pd.DatetimeIndex, float, List[ItemInfo], DfsuFileType, float]: + filename = input + path = Path(input) + if not path.exists(): + raise FileNotFoundError(f"file {path} does not exist!") + + filename = str(input) + dfs = DfsuFile.Open(filename) + dfsu_type = DfsuFileType(dfs.DfsuFileType) + deletevalue = dfs.DeleteValueFloat # items n_items = len(dfs.ItemInfo) @@ -276,7 +283,7 @@ def _read_header( timestep = dfs.TimeStepInSeconds dfs.Close() - return geometry, time, timestep, items, dfsu_type, deletevalue + return time, timestep, items, dfsu_type, deletevalue @property def type_name(self): From 7638f3bcf10dd803b037f185ab1c0336fbcdc0b3 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 15:46:15 +0100 Subject: [PATCH 12/20] Spectral geometry --- mikeio/dfsu/_dfsu.py | 102 ++++++++++++--------------------------- mikeio/dfsu/_spectral.py | 58 +++++++++++++++++++++- 2 files changed, 88 insertions(+), 72 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 6d5de458f..af34fc989 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -177,78 +177,40 @@ def _read_geometry(self, input: str | Path) -> Any: dfs = DfsuFile.Open(filename) dfsu_type = DfsuFileType(dfs.DfsuFileType) - if self._is_spectral(dfsu_type): - dir = dfs.Directions - directions = None if dir is None else dir * (180 / np.pi) - frequencies = dfs.Frequencies - - # geometry - if dfsu_type == DfsuFileType.DfsuSpectral0D: - geometry: Any = GeometryFMPointSpectrum( - frequencies=frequencies, directions=directions + node_table = get_nodes_from_source(dfs) + el_table = get_elements_from_source(dfs) + + if self._is_layered(dfsu_type): + geom_cls: Any = GeometryFM3D + if dfsu_type in ( + DfsuFileType.DfsuVerticalProfileSigma, + DfsuFileType.DfsuVerticalProfileSigmaZ, + ): + geom_cls = GeometryFMVerticalProfile + + geometry = geom_cls( + node_coordinates=node_table.coordinates, + element_table=el_table.connectivity, + codes=node_table.codes, + projection=dfs.Projection.WKTString, + dfsu_type=dfsu_type, + element_ids=el_table.ids, + node_ids=node_table.ids, + n_layers=dfs.NumberOfLayers, + n_sigma=min(dfs.NumberOfSigmaLayers, dfs.NumberOfLayers), + validate=False, ) else: - # nc, codes, node_ids = get_nodes_from_source(dfs) - node_table = get_nodes_from_source(dfs) - el_table = get_elements_from_source(dfs) - - if self._is_layered(dfsu_type): - geom_cls: Any = GeometryFM3D - if dfsu_type in ( - DfsuFileType.DfsuVerticalProfileSigma, - DfsuFileType.DfsuVerticalProfileSigmaZ, - ): - geom_cls = GeometryFMVerticalProfile - - geometry = geom_cls( - node_coordinates=node_table.coordinates, - element_table=el_table.connectivity, - codes=node_table.codes, - projection=dfs.Projection.WKTString, - dfsu_type=dfsu_type, - element_ids=el_table.ids, - node_ids=node_table.ids, - n_layers=dfs.NumberOfLayers, - n_sigma=min(dfs.NumberOfSigmaLayers, dfs.NumberOfLayers), - validate=False, - ) - elif dfsu_type == DfsuFileType.DfsuSpectral1D: - geometry = GeometryFMLineSpectrum( - node_coordinates=node_table.coordinates, - element_table=el_table.connectivity, - codes=node_table.codes, - projection=dfs.Projection.WKTString, - dfsu_type=dfsu_type, - element_ids=el_table.ids, - node_ids=node_table.ids, - validate=False, - frequencies=frequencies, - directions=directions, - ) - elif dfsu_type == DfsuFileType.DfsuSpectral2D: - geometry = GeometryFMAreaSpectrum( - node_coordinates=node_table.coordinates, - element_table=el_table.connectivity, - codes=node_table.codes, - projection=dfs.Projection.WKTString, - dfsu_type=dfsu_type, - element_ids=el_table.ids, - node_ids=node_table.ids, - validate=False, - frequencies=frequencies, - directions=directions, - ) - else: - geometry = GeometryFM2D( - node_coordinates=node_table.coordinates, - element_table=el_table.connectivity, - codes=node_table.codes, - projection=dfs.Projection.WKTString, - dfsu_type=dfsu_type, - element_ids=el_table.ids, - node_ids=node_table.ids, - validate=False, - ) + geometry = GeometryFM2D( + node_coordinates=node_table.coordinates, + element_table=el_table.connectivity, + codes=node_table.codes, + projection=dfs.Projection.WKTString, + dfsu_type=dfsu_type, + element_ids=el_table.ids, + node_ids=node_table.ids, + validate=False, + ) dfs.Close() return geometry diff --git a/mikeio/dfsu/_spectral.py b/mikeio/dfsu/_spectral.py index 945f2f5be..f7b878f51 100644 --- a/mikeio/dfsu/_spectral.py +++ b/mikeio/dfsu/_spectral.py @@ -1,5 +1,6 @@ from __future__ import annotations -from typing import Sized, Tuple +from typing import Sized, Tuple, Any +from pathlib import Path import numpy as np import pandas as pd @@ -9,11 +10,64 @@ from ..dataset import DataArray, Dataset from ..dfs._dfs import _get_item_info, _valid_item_numbers, _valid_timesteps from .._spectral import calc_m0_from_spectrum -from ._dfsu import _Dfsu +from ._dfsu import _Dfsu, get_elements_from_source, get_nodes_from_source +from ..spatial import ( + GeometryFMAreaSpectrum, + GeometryFMLineSpectrum, + GeometryFMPointSpectrum, +) class DfsuSpectral(_Dfsu): + def _read_geometry(self, input: str | Path) -> Any: + filename = str(input) + dfs = DfsuFile.Open(filename) + dfsu_type = DfsuFileType(dfs.DfsuFileType) + + dir = dfs.Directions + directions = None if dir is None else dir * (180 / np.pi) + frequencies = dfs.Frequencies + + # geometry + if dfsu_type == DfsuFileType.DfsuSpectral0D: + geometry: Any = GeometryFMPointSpectrum( + frequencies=frequencies, directions=directions + ) + else: + # nc, codes, node_ids = get_nodes_from_source(dfs) + node_table = get_nodes_from_source(dfs) + el_table = get_elements_from_source(dfs) + + if dfsu_type == DfsuFileType.DfsuSpectral1D: + geometry = GeometryFMLineSpectrum( + node_coordinates=node_table.coordinates, + element_table=el_table.connectivity, + codes=node_table.codes, + projection=dfs.Projection.WKTString, + dfsu_type=dfsu_type, + element_ids=el_table.ids, + node_ids=node_table.ids, + validate=False, + frequencies=frequencies, + directions=directions, + ) + elif dfsu_type == DfsuFileType.DfsuSpectral2D: + geometry = GeometryFMAreaSpectrum( + node_coordinates=node_table.coordinates, + element_table=el_table.connectivity, + codes=node_table.codes, + projection=dfs.Projection.WKTString, + dfsu_type=dfsu_type, + element_ids=el_table.ids, + node_ids=node_table.ids, + validate=False, + frequencies=frequencies, + directions=directions, + ) + dfs.Close() + return geometry + @property def n_frequencies(self): """Number of frequencies""" From 46d750cc58c55b0d2e9791e017524668b9e316fd Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 15:53:38 +0100 Subject: [PATCH 13/20] Delegate to subcliasses --- mikeio/dfsu/_dfsu.py | 64 ++++++++++++++++------------------------- mikeio/dfsu/_layered.py | 37 ++++++++++++++++++++++-- 2 files changed, 58 insertions(+), 43 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index af34fc989..d6b5f98a7 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -1,4 +1,5 @@ from __future__ import annotations +from abc import abstractmethod from pathlib import Path import warnings from functools import wraps @@ -172,47 +173,9 @@ def __repr__(self): out.append(f" {self.start_time} -- {self.end_time}") return str.join("\n", out) + @abstractmethod def _read_geometry(self, input: str | Path) -> Any: - filename = str(input) - dfs = DfsuFile.Open(filename) - dfsu_type = DfsuFileType(dfs.DfsuFileType) - - node_table = get_nodes_from_source(dfs) - el_table = get_elements_from_source(dfs) - - if self._is_layered(dfsu_type): - geom_cls: Any = GeometryFM3D - if dfsu_type in ( - DfsuFileType.DfsuVerticalProfileSigma, - DfsuFileType.DfsuVerticalProfileSigmaZ, - ): - geom_cls = GeometryFMVerticalProfile - - geometry = geom_cls( - node_coordinates=node_table.coordinates, - element_table=el_table.connectivity, - codes=node_table.codes, - projection=dfs.Projection.WKTString, - dfsu_type=dfsu_type, - element_ids=el_table.ids, - node_ids=node_table.ids, - n_layers=dfs.NumberOfLayers, - n_sigma=min(dfs.NumberOfSigmaLayers, dfs.NumberOfLayers), - validate=False, - ) - else: - geometry = GeometryFM2D( - node_coordinates=node_table.coordinates, - element_table=el_table.connectivity, - codes=node_table.codes, - projection=dfs.Projection.WKTString, - dfsu_type=dfsu_type, - element_ids=el_table.ids, - node_ids=node_table.ids, - validate=False, - ) - dfs.Close() - return geometry + pass def _read_header( self, input: str | Path @@ -697,6 +660,27 @@ def to_mesh(self, outfilename): class Dfsu2DH(_Dfsu): + def _read_geometry(self, input: str | Path) -> Any: + filename = str(input) + dfs = DfsuFile.Open(filename) + dfsu_type = DfsuFileType(dfs.DfsuFileType) + + node_table = get_nodes_from_source(dfs) + el_table = get_elements_from_source(dfs) + + geometry = GeometryFM2D( + node_coordinates=node_table.coordinates, + element_table=el_table.connectivity, + codes=node_table.codes, + projection=dfs.Projection.WKTString, + dfsu_type=dfsu_type, + element_ids=el_table.ids, + node_ids=node_table.ids, + validate=False, + ) + dfs.Close() + return geometry + def read( self, *, diff --git a/mikeio/dfsu/_layered.py b/mikeio/dfsu/_layered.py index 3a886ff06..caff20782 100644 --- a/mikeio/dfsu/_layered.py +++ b/mikeio/dfsu/_layered.py @@ -1,5 +1,6 @@ from __future__ import annotations -from typing import Collection +from pathlib import Path +from typing import Any, Collection from functools import wraps import warnings @@ -18,12 +19,42 @@ from ..eum import EUMType, ItemInfo from ..exceptions import InvalidGeometry from .._interpolation import get_idw_interpolant, interp2d -from ..spatial import GeometryFM3D +from ..spatial import GeometryFM3D, GeometryFMVerticalProfile from ..spatial._FM_utils import _plot_vertical_profile -from ._dfsu import _Dfsu +from ._dfsu import _Dfsu, get_nodes_from_source, get_elements_from_source class DfsuLayered(_Dfsu): + def _read_geometry(self, input: str | Path) -> Any: + filename = str(input) + dfs = DfsuFile.Open(filename) + dfsu_type = DfsuFileType(dfs.DfsuFileType) + + node_table = get_nodes_from_source(dfs) + el_table = get_elements_from_source(dfs) + + geom_cls: Any = GeometryFM3D + if dfsu_type in ( + DfsuFileType.DfsuVerticalProfileSigma, + DfsuFileType.DfsuVerticalProfileSigmaZ, + ): + geom_cls = GeometryFMVerticalProfile + + geometry = geom_cls( + node_coordinates=node_table.coordinates, + element_table=el_table.connectivity, + codes=node_table.codes, + projection=dfs.Projection.WKTString, + dfsu_type=dfsu_type, + element_ids=el_table.ids, + node_ids=node_table.ids, + n_layers=dfs.NumberOfLayers, + n_sigma=min(dfs.NumberOfSigmaLayers, dfs.NumberOfLayers), + validate=False, + ) + dfs.Close() + return geometry + @property def n_layers(self): """Maximum number of layers""" From 853d906f43802523c4d54b690229ed0234ca7d95 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 16:48:37 +0100 Subject: [PATCH 14/20] Inline read_header --- mikeio/dfsu/_dfsu.py | 131 ++++++++++++++++----------------------- mikeio/dfsu/_layered.py | 22 ++++++- mikeio/dfsu/_spectral.py | 10 ++- 3 files changed, 81 insertions(+), 82 deletions(-) diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index d6b5f98a7..11c03ea81 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -1,9 +1,8 @@ from __future__ import annotations -from abc import abstractmethod from pathlib import Path import warnings from functools import wraps -from typing import Any, Collection, List, Tuple +from typing import Any, Collection, Sequence, Tuple import numpy as np import pandas as pd @@ -23,18 +22,13 @@ _valid_item_numbers, _valid_timesteps, ) -from ..eum import ItemInfo from ..spatial import ( GeometryFM2D, - GeometryFM3D, - GeometryFMAreaSpectrum, - GeometryFMLineSpectrum, - GeometryFMPointSpectrum, - GeometryFMVerticalProfile, ) from ..spatial import Grid2D from .._track import _extract_track from ._common import get_elements_from_source, get_nodes_from_source +from ..eum import ItemInfo def write_dfsu(filename: str | Path, data: Dataset) -> None: @@ -123,15 +117,24 @@ def __init__(self, filename: str | Path) -> None: filename: str dfsu filename """ - self._filename = str(filename) - ( - self._time, - self._timestep, - self._items, - self._type, - self._deletevalue, - ) = self._read_header(filename) - self._geometry = self._read_geometry(filename) + filename = str(filename) + self._filename = filename + path = Path(filename) + if not path.exists(): + raise FileNotFoundError(f"file {path} does not exist!") + + dfs = DfsuFile.Open(filename) + self._type = DfsuFileType(dfs.DfsuFileType) + self._deletevalue = dfs.DeleteValueFloat + + self._time = pd.date_range( + start=dfs.StartDateTime, + periods=dfs.NumberOfTimeSteps, + freq=f"{dfs.TimeStepInSeconds}S", + ) + self._timestep = dfs.TimeStepInSeconds + dfs.Close() + self._items = self._read_items(filename) def __repr__(self): out = [] @@ -149,7 +152,7 @@ def __repr__(self): out.append(f"number of frequencies: {self.n_frequencies}") if self.geometry.projection_string: out.append(f"projection: {self.projection_string}") - if self.is_layered: + if self.geometry.is_layered: out.append(f"number of sigma layers: {self.n_sigma_layers}") if ( self._type == DfsuFileType.DfsuVerticalProfileSigmaZ @@ -173,42 +176,11 @@ def __repr__(self): out.append(f" {self.start_time} -- {self.end_time}") return str.join("\n", out) - @abstractmethod - def _read_geometry(self, input: str | Path) -> Any: - pass - - def _read_header( - self, input: str | Path - ) -> Tuple[pd.DatetimeIndex, float, List[ItemInfo], DfsuFileType, float]: - filename = input - path = Path(input) - if not path.exists(): - raise FileNotFoundError(f"file {path} does not exist!") - - filename = str(input) + def _read_items(self, filename: str) -> list[ItemInfo]: dfs = DfsuFile.Open(filename) - dfsu_type = DfsuFileType(dfs.DfsuFileType) - deletevalue = dfs.DeleteValueFloat - - # items - n_items = len(dfs.ItemInfo) - first_idx = 1 if self._is_layered(dfsu_type) else 0 - items = _get_item_info( - dfs.ItemInfo, - list(range(n_items - first_idx)), - ignore_first=self._is_layered(dfsu_type), - ) - - # time - time = pd.date_range( - start=dfs.StartDateTime, - periods=dfs.NumberOfTimeSteps, - freq=f"{dfs.TimeStepInSeconds}S", - ) - timestep = dfs.TimeStepInSeconds - + items = _get_item_info(dfs.ItemInfo) dfs.Close() - return time, timestep, items, dfsu_type, deletevalue + return items @property def type_name(self): @@ -292,12 +264,10 @@ def max_nodes_per_element(self): return self.geometry.max_nodes_per_element @property - def is_2d(self): - """Type is either mesh or Dfsu2D (2 horizontal dimensions)""" + def is_2d(self) -> bool: return self._type in ( DfsuFileType.Dfsu2D, DfsuFileType.DfsuSpectral2D, - None, ) @staticmethod @@ -310,7 +280,7 @@ def _is_layered(dfsu_type: DfsuFileType) -> bool: ) @property - def is_layered(self): + def is_layered(self) -> bool: """Type is layered dfsu (3d, vertical profile or vertical column)""" return self._is_layered(self._type) @@ -323,12 +293,12 @@ def _is_spectral(dfsu_type: DfsuFileType) -> bool: ) @property - def is_spectral(self): + def is_spectral(self) -> bool: """Type is spectral dfsu (point, line or area spectrum)""" return self._is_spectral(self._type) @property - def is_tri_only(self): + def is_tri_only(self) -> bool: """Does the mesh consist of triangles only?""" return self.geometry.is_tri_only @@ -463,16 +433,16 @@ def time(self): def _read( self, *, - items=None, - time=None, + items: str | int | Sequence[str | int] | None = None, + time: int | str | slice | None = None, elements: Collection[int] | None = None, - area=None, - x=None, - y=None, - keepdims=False, - dtype=np.float32, - error_bad_data=True, - fill_bad_data_value=np.nan, + area: Tuple[float, float, float, float] | None = None, + x: float | None = None, + y: float | None = None, + keepdims: bool = False, + dtype: Any = np.float32, + error_bad_data: bool = True, + fill_bad_data_value: float = np.nan, ) -> Dataset: if dtype not in [np.float32, np.float64]: raise ValueError("Invalid data type. Choose np.float32 or np.float64") @@ -660,8 +630,13 @@ def to_mesh(self, outfilename): class Dfsu2DH(_Dfsu): - def _read_geometry(self, input: str | Path) -> Any: - filename = str(input) + + def __init__(self, filename: str | Path) -> None: + super().__init__(filename) + self._geometry = self._read_geometry(self._filename) + + @staticmethod + def _read_geometry(filename: str) -> GeometryFM2D: dfs = DfsuFile.Open(filename) dfsu_type = DfsuFileType(dfs.DfsuFileType) @@ -684,16 +659,16 @@ def _read_geometry(self, input: str | Path) -> Any: def read( self, *, - items=None, - time=None, + items: str | int | Sequence[str | int] | None = None, + time: int | str | slice | None = None, elements: Collection[int] | None = None, - area=None, - x=None, - y=None, - keepdims=False, - dtype=np.float32, - error_bad_data=True, - fill_bad_data_value=np.nan, + area: Tuple[float, float, float, float] | None = None, + x: float | None = None, + y: float | None = None, + keepdims: bool = False, + dtype: Any = np.float32, + error_bad_data: bool = True, + fill_bad_data_value: float = np.nan, ) -> Dataset: """ Read data from a dfsu file diff --git a/mikeio/dfsu/_layered.py b/mikeio/dfsu/_layered.py index caff20782..cf7654fde 100644 --- a/mikeio/dfsu/_layered.py +++ b/mikeio/dfsu/_layered.py @@ -25,8 +25,26 @@ class DfsuLayered(_Dfsu): - def _read_geometry(self, input: str | Path) -> Any: - filename = str(input) + def __init__(self, filename: str | Path) -> None: + super().__init__(filename) + self._geometry = self._read_geometry(self._filename) + self._items = self._read_items(self._filename) + + @staticmethod + def _read_items(filename: str) -> list[ItemInfo]: + dfs = DfsuFile.Open(filename) + n_items = len(dfs.ItemInfo) + first_idx = 1 + items = _get_item_info( + dfs.ItemInfo, + list(range(n_items - first_idx)), + ignore_first=True, + ) + dfs.Close() + return items + + @staticmethod + def _read_geometry(filename: str) -> GeometryFM3D | GeometryFMVerticalProfile: dfs = DfsuFile.Open(filename) dfsu_type = DfsuFileType(dfs.DfsuFileType) diff --git a/mikeio/dfsu/_spectral.py b/mikeio/dfsu/_spectral.py index f7b878f51..286ad00c6 100644 --- a/mikeio/dfsu/_spectral.py +++ b/mikeio/dfsu/_spectral.py @@ -20,8 +20,14 @@ class DfsuSpectral(_Dfsu): - def _read_geometry(self, input: str | Path) -> Any: - filename = str(input) + def __init__(self, filename: str | Path) -> None: + super().__init__(filename) + self._geometry = self._read_geometry(self._filename) + + @staticmethod + def _read_geometry( + filename: str, + ) -> GeometryFMPointSpectrum | GeometryFMLineSpectrum | GeometryFMAreaSpectrum: dfs = DfsuFile.Open(filename) dfsu_type = DfsuFileType(dfs.DfsuFileType) From 515db3e40830779c46da160feea3e1328a566b16 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 16:52:30 +0100 Subject: [PATCH 15/20] Future --- mikeio/dfsu/_factory.py | 1 + 1 file changed, 1 insertion(+) diff --git a/mikeio/dfsu/_factory.py b/mikeio/dfsu/_factory.py index 079de65db..1e18e929e 100644 --- a/mikeio/dfsu/_factory.py +++ b/mikeio/dfsu/_factory.py @@ -1,3 +1,4 @@ +from __future__ import annotations from pathlib import Path from typing import Any from mikecore.DfsuFile import DfsuFile, DfsuFileType From 5a78ad79c9873cc607422a72431cf61aca5bb2da Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 17:02:16 +0100 Subject: [PATCH 16/20] Factory need no args/kwargs --- mikeio/dfsu/_factory.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/mikeio/dfsu/_factory.py b/mikeio/dfsu/_factory.py index 1e18e929e..6c637555a 100644 --- a/mikeio/dfsu/_factory.py +++ b/mikeio/dfsu/_factory.py @@ -22,7 +22,7 @@ } -def dfsu(filename: str | Path, *args: Any, **kwargs: Any) -> Any: +def dfsu(filename: str | Path) -> Any: filename = str(filename) dfs = DfsuFile.Open(filename) type = DfsuFileType(dfs.DfsuFileType) @@ -33,9 +33,9 @@ def dfsu(filename: str | Path, *args: Any, **kwargs: Any) -> Any: if klass is None: raise ValueError(f"Unsupported dfsu type: {type}") - return klass(filename, *args, **kwargs) + return klass(filename) class Dfsu: - def __new__(self, filename: str | Path, *args: Any, **kwargs: Any): - return dfsu(filename, *args, **kwargs) + def __new__(self, filename: str | Path) -> Any: + return dfsu(filename) From 82f9da4232cd6e2120bbd28d78dc82c314c25015 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 17:14:04 +0100 Subject: [PATCH 17/20] Remove Dfsu.plot_spectrum (use DataArray) --- mikeio/dfsu/_spectral.py | 85 +--------------------------------------- 1 file changed, 1 insertion(+), 84 deletions(-) diff --git a/mikeio/dfsu/_spectral.py b/mikeio/dfsu/_spectral.py index 286ad00c6..aa6ec204c 100644 --- a/mikeio/dfsu/_spectral.py +++ b/mikeio/dfsu/_spectral.py @@ -301,91 +301,8 @@ def _parse_elements_nodes(self, elements, nodes): geometry = self.geometry.elements_to_geometry(elements) return geometry, elements - # def plot_spectrum( - # self, - # spectrum, - # plot_type="contourf", - # title=None, - # label=None, - # cmap="Reds", - # vmin=1e-5, - # vmax=None, - # r_as_periods=True, - # rmin=None, - # rmax=None, - # levels=None, - # figsize=(7, 7), - # add_colorbar=True, - # ): - # """ - # Plot spectrum in polar coordinates - - # Parameters - # ---------- - # spectrum: np.array - # spectral values as 2d array with dimensions: directions, frequencies - # plot_type: str, optional - # type of plot: 'contour', 'contourf', 'patch', 'shaded', - # by default: 'contourf' - # title: str, optional - # axes title - # label: str, optional - # colorbar label (or title if contour plot) - # cmap: matplotlib.cm.cmap, optional - # colormap, default Reds - # vmin: real, optional - # lower bound of values to be shown on plot, default: 1e-5 - # vmax: real, optional - # upper bound of values to be shown on plot, default:None - # r_as_periods: bool, optional - # show radial axis as periods instead of frequency, default: True - # rmin: float, optional - # mininum frequency/period to be shown, default: None - # rmax: float, optional - # maximum frequency/period to be shown, default: None - # levels: int, list(float), optional - # for contour plots: how many levels, default:10 - # or a list of discrete levels e.g. [0.03, 0.04, 0.05] - # figsize: (float, float), optional - # specify size of figure, default (7, 7) - # add_colorbar: bool, optional - # Add colorbar to plot, default True - - # Returns - # ------- - # - - # Examples - # -------- - # >>> dfs = mikeio.Dfsu("tests/testdata/area_spectra.dfsu") - # >>> ds = dfs.read(items="Energy density") - # >>> spectrum = ds[0][0, 0, :, :] # first timestep, element 0 - # >>> ax = dfs.plot_spectrum(spectrum, plot_type="patch") - # >>> ax = dfs.plot_spectrum(spectrum, rmax=9, title="Wave spectrum T<9s"); - # """ - # if isinstance(spectrum, DataArray): - # spectrum = spectrum.to_numpy() - - # return plot_2dspectrum( - # spectrum, - # frequencies=self.frequencies, - # directions=self.directions, - # plot_type=plot_type, - # title=title, - # label=label, - # cmap=cmap, - # vmin=vmin, - # vmax=vmax, - # r_as_periods=r_as_periods, - # rmin=rmin, - # rmax=rmax, - # levels=levels, - # figsize=figsize, - # add_colorbar=add_colorbar, - # ) - def calc_Hm0_from_spectrum( - self, spectrum: np.ndarray | DataArray, tail=True + self, spectrum: np.ndarray | DataArray, tail: bool = True ) -> np.ndarray: """Calculate significant wave height (Hm0) from spectrum From 388377006047fc995cb79e255bd6d37fd4a7a877 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 17:59:32 +0100 Subject: [PATCH 18/20] Fix 3d notebook --- notebooks/Dfsu - 3D sigma-z.ipynb | 93 ++++++++++++++----------------- 1 file changed, 42 insertions(+), 51 deletions(-) diff --git a/notebooks/Dfsu - 3D sigma-z.ipynb b/notebooks/Dfsu - 3D sigma-z.ipynb index c7ddd5ce2..04ce58ec8 100644 --- a/notebooks/Dfsu - 3D sigma-z.ipynb +++ b/notebooks/Dfsu - 3D sigma-z.ipynb @@ -18,10 +18,7 @@ }, "outputs": [], "source": [ - "import mikeio\n", - "\n", - "from matplotlib_inline.backend_inline import set_matplotlib_formats\n", - "set_matplotlib_formats('png')" + "import mikeio\n" ] }, { @@ -41,7 +38,7 @@ "items:\n", " 0: Temperature (degree Celsius)\n", " 1: Salinity (PSU)\n", - "time: 3 steps with dt=10800.0s\n", + "time: 1997-09-15 21:00:00 - 1997-09-16 03:00:00 (3 records)\n", " 1997-09-15 21:00:00 -- 1997-09-16 03:00:00" ] }, @@ -63,14 +60,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" } ], @@ -168,19 +163,17 @@ "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": [ - "ax = dfs.plot(z=ds['Temperature'][timestep], figsize=(6,7))\n", + "ax = ds['Temperature'].isel(time=timestep).plot()\n", "ax.plot(max_x, max_y, marker='*', markersize=20);" ] }, @@ -199,14 +192,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" } ], @@ -231,14 +222,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" } ], @@ -262,14 +251,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" } ], @@ -320,14 +307,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" } ], @@ -349,14 +334,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" } ], @@ -397,7 +380,12 @@ "\n", "dims: (time:3, element:7400)\n", "time: 1997-09-15 21:00:00 - 1997-09-16 03:00:00 (3 records)\n", - "geometry: Dfsu3DSigma (7400 elements, 2 sigma-layers, 0 z-layers)\n", + "geometry: Flexible Mesh Geometry: Dfsu3DSigmaZ\n", + "number of nodes: 6270\n", + "number of elements: 7400\n", + "number of layers: 2\n", + "number of sigma layers: 2\n", + "projection: UTM-33\n", "items:\n", " 0: Temperature (degree Celsius)\n", " 1: Salinity (PSU)" @@ -441,7 +429,12 @@ "\n", "dims: (time:3, element:441)\n", "time: 1997-09-15 21:00:00 - 1997-09-16 03:00:00 (3 records)\n", - "geometry: DfsuVerticalProfileSigmaZ (441 elements, 4 sigma-layers, 5 z-layers)\n", + "geometry: Flexible Mesh Geometry: DfsuVerticalProfileSigmaZ\n", + "number of nodes: 550\n", + "number of elements: 441\n", + "number of layers: 9\n", + "number of sigma layers: 4\n", + "projection: UTM-33\n", "items:\n", " 0: Temperature (degree Celsius)\n", " 1: Salinity (PSU)" @@ -483,19 +476,17 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "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" } ], @@ -512,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -542,7 +533,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.10.12" } }, "nbformat": 4, From 0b33cfa4fb5de2a8690b1a217a87b3ae8cc28e44 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 18:05:30 +0100 Subject: [PATCH 19/20] Delegate to geometry --- mikeio/dataset/_dataarray.py | 5 +- mikeio/dfsu/_dfsu.py | 144 +++++++++---------------- mikeio/dfsu/_spectral.py | 2 +- mikeio/spatial/_FM_geometry.py | 16 ++- mikeio/spatial/_FM_geometry_layered.py | 75 +++++++------ 5 files changed, 113 insertions(+), 129 deletions(-) diff --git a/mikeio/dataset/_dataarray.py b/mikeio/dataset/_dataarray.py index fc618fffd..d5e0913da 100644 --- a/mikeio/dataset/_dataarray.py +++ b/mikeio/dataset/_dataarray.py @@ -92,7 +92,10 @@ def __call__(self, tail: bool = True) -> "DataArray": item = ItemInfo(EUMType.Significant_wave_height) g = self.da.geometry if isinstance(g, GeometryFMPointSpectrum): - geometry: Any = GeometryPoint2D(x=g.x, y=g.y) + if g.x is not None and g.y is not None: + geometry: Any = GeometryPoint2D(x=g.x, y=g.y) + else: + geometry = GeometryUndefined() elif isinstance(g, GeometryFMLineSpectrum): geometry = Grid1D( nx=g.n_nodes, diff --git a/mikeio/dfsu/_dfsu.py b/mikeio/dfsu/_dfsu.py index 11c03ea81..d3336d609 100644 --- a/mikeio/dfsu/_dfsu.py +++ b/mikeio/dfsu/_dfsu.py @@ -127,10 +127,12 @@ def __init__(self, filename: str | Path) -> None: self._type = DfsuFileType(dfs.DfsuFileType) self._deletevalue = dfs.DeleteValueFloat + freq = pd.Timedelta(seconds=dfs.TimeStepInSeconds) + self._time = pd.date_range( start=dfs.StartDateTime, periods=dfs.NumberOfTimeSteps, - freq=f"{dfs.TimeStepInSeconds}S", + freq=freq, ) self._timestep = dfs.TimeStepInSeconds dfs.Close() @@ -270,32 +272,15 @@ def is_2d(self) -> bool: DfsuFileType.DfsuSpectral2D, ) - @staticmethod - def _is_layered(dfsu_type: DfsuFileType) -> bool: - return dfsu_type in ( - DfsuFileType.DfsuVerticalProfileSigma, - DfsuFileType.DfsuVerticalProfileSigmaZ, - DfsuFileType.Dfsu3DSigma, - DfsuFileType.Dfsu3DSigmaZ, - ) - @property def is_layered(self) -> bool: """Type is layered dfsu (3d, vertical profile or vertical column)""" - return self._is_layered(self._type) - - @staticmethod - def _is_spectral(dfsu_type: DfsuFileType) -> bool: - return dfsu_type in ( - DfsuFileType.DfsuSpectral0D, - DfsuFileType.DfsuSpectral1D, - DfsuFileType.DfsuSpectral2D, - ) + return self.geometry.is_layered @property def is_spectral(self) -> bool: """Type is spectral dfsu (point, line or area spectrum)""" - return self._is_spectral(self._type) + return self.geometry.is_spectral @property def is_tri_only(self) -> bool: @@ -307,29 +292,6 @@ def boundary_polylines(self): """Lists of closed polylines defining domain outline""" return self.geometry.boundary_polylines - def get_node_coords(self, code=None): - """Get the coordinates of each node. - - Parameters - ---------- - code: int - Get only nodes with specific code, e.g. land == 1 - - Returns - ------- - np.array - x,y,z of each node - """ - nc = self.node_coordinates - if code is not None: - if code not in self.geometry.valid_codes: - print( - f"Selected code: {code} is not valid. Valid codes: {self.valid_codes}" - ) - raise Exception - return nc[self.geometry.codes == code] - return nc - @wraps(GeometryFM2D.elements_to_geometry) def elements_to_geometry(self, elements, node_layers="all"): return self.geometry.elements_to_geometry(elements, node_layers) @@ -343,42 +305,6 @@ def element_coordinates(self): def contains(self, points): return self.geometry.contains(points) - def get_overset_grid(self, dx=None, dy=None, nx=None, ny=None, buffer=None): - """get a 2d grid that covers the domain by specifying spacing or shape - - Parameters - ---------- - dx : float, optional - grid resolution in x-direction (or in x- and y-direction) - dy : float, optional - grid resolution in y-direction - nx : int, optional - number of points in x-direction, - by default None (the value will be inferred) - ny : int, optional - number of points in y-direction, - by default None (the value will be inferred) - buffer : float, optional - positive to make the area larger, default=0 - can be set to a small negative value to avoid NaN - values all around the domain. - - Returns - ------- - - 2d grid - """ - nc = self.geometry.geometry2d.node_coordinates - bbox = xy_to_bbox(nc, buffer=buffer) - return Grid2D( - bbox=bbox, - dx=dx, - dy=dy, - nx=nx, - ny=ny, - projection=self.geometry.projection_string, - ) - @wraps(GeometryFM2D.get_element_area) def get_element_area(self): return self.geometry.get_element_area() @@ -392,42 +318,42 @@ def get_node_centered_data(self, data, extrapolate=True): return self.geometry.get_node_centered_data(data, extrapolate) @property - def deletevalue(self): + def deletevalue(self) -> float: """File delete value""" return self._deletevalue @property - def n_items(self): + def n_items(self) -> int: """Number of items""" return len(self.items) @property - def items(self): + def items(self) -> list[ItemInfo]: """List of items""" return self._items @property - def start_time(self): + def start_time(self) -> pd.Timestamp: """File start time""" return self._time[0] @property - def n_timesteps(self): + def n_timesteps(self) -> int: """Number of time steps""" return len(self._time) @property - def timestep(self): + def timestep(self) -> float: """Time step size in seconds""" return self._timestep @property - def end_time(self): + def end_time(self) -> pd.Timestamp: """File end time""" return self._time[-1] @property - def time(self): + def time(self) -> pd.DatetimeIndex: return self._time def _read( @@ -716,7 +642,45 @@ def read( fill_bad_data_value=fill_bad_data_value, ) - def _dfs_read_item_time_func(self, item: int, step: int): + def get_overset_grid(self, dx=None, dy=None, nx=None, ny=None, buffer=None): + """get a 2d grid that covers the domain by specifying spacing or shape + + Parameters + ---------- + dx : float, optional + grid resolution in x-direction (or in x- and y-direction) + dy : float, optional + grid resolution in y-direction + nx : int, optional + number of points in x-direction, + by default None (the value will be inferred) + ny : int, optional + number of points in y-direction, + by default None (the value will be inferred) + buffer : float, optional + positive to make the area larger, default=0 + can be set to a small negative value to avoid NaN + values all around the domain. + + Returns + ------- + + 2d grid + """ + nc = self.geometry.geometry2d.node_coordinates + bbox = xy_to_bbox(nc, buffer=buffer) + return Grid2D( + bbox=bbox, + dx=dx, + dy=dy, + nx=nx, + ny=ny, + projection=self.geometry.projection_string, + ) + + def _dfs_read_item_time_func( + self, item: int, step: int + ) -> Tuple[np.ndarray, pd.Timestamp]: dfs = DfsuFile.Open(self._filename) itemdata = dfs.ReadItemTimeStep(item + 1, step) @@ -760,14 +724,10 @@ def extract_track(self, track, items=None, method="nearest", dtype=np.float32): 2: Surface elevation (meter) 3: Wind speed (meter per sec) """ - if self.is_spectral: - raise ValueError("Method not supported for spectral dfsu!") - dfs = DfsuFile.Open(self._filename) item_numbers = _valid_item_numbers(dfs.ItemInfo, items) items = _get_item_info(dfs.ItemInfo, item_numbers) - # self._n_timesteps = dfs.NumberOfTimeSteps _, time_steps = _valid_timesteps(dfs, time_steps=None) res = _extract_track( diff --git a/mikeio/dfsu/_spectral.py b/mikeio/dfsu/_spectral.py index aa6ec204c..51196528f 100644 --- a/mikeio/dfsu/_spectral.py +++ b/mikeio/dfsu/_spectral.py @@ -39,7 +39,7 @@ def _read_geometry( if dfsu_type == DfsuFileType.DfsuSpectral0D: geometry: Any = GeometryFMPointSpectrum( frequencies=frequencies, directions=directions - ) + ) # No x,y coordinates else: # nc, codes, node_ids = get_nodes_from_source(dfs) node_table = get_nodes_from_source(dfs) diff --git a/mikeio/spatial/_FM_geometry.py b/mikeio/spatial/_FM_geometry.py index 2290a6aab..120fa9e8b 100644 --- a/mikeio/spatial/_FM_geometry.py +++ b/mikeio/spatial/_FM_geometry.py @@ -27,7 +27,13 @@ class GeometryFMPointSpectrum(_Geometry): - def __init__(self, frequencies=None, directions=None, x=None, y=None) -> None: + def __init__( + self, + frequencies: np.ndarray, + directions: np.ndarray | None = None, + x: float | None = None, + y: float | None = None, + ) -> None: super().__init__() self.n_nodes = 0 self.n_elements = 0 @@ -39,6 +45,10 @@ def __init__(self, frequencies=None, directions=None, x=None, y=None) -> None: self.x = x self.y = y + @property + def is_layered(self) -> bool: + return False + @property def type_name(self): """Type name: DfsuSpectral0D""" @@ -300,6 +310,10 @@ def _reindex(self): self._node_ids = new_node_ids self._element_ids = new_element_ids + @property + def is_spectral(self) -> bool: + return False + @property def n_nodes(self) -> int: """Number of nodes""" diff --git a/mikeio/spatial/_FM_geometry_layered.py b/mikeio/spatial/_FM_geometry_layered.py index 260dbac4e..8dfd1445d 100644 --- a/mikeio/spatial/_FM_geometry_layered.py +++ b/mikeio/spatial/_FM_geometry_layered.py @@ -22,7 +22,7 @@ def __init__( node_coordinates, element_table, codes=None, - projection:str = "LONG/LAT", + projection: str = "LONG/LAT", dfsu_type=DfsuFileType.Dfsu3DSigma, element_ids=None, node_ids=None, @@ -129,43 +129,48 @@ def elements_to_geometry( node_coords = self.node_coordinates[node_ids] codes = self.codes[node_ids] elem_ids = self._element_ids[sorted_elements] - + if new_type == DfsuFileType.Dfsu2D: - return GeometryFM2D(node_coordinates=node_coords, - codes=codes, - node_ids=node_ids, - projection=self.projection_string, - element_table=elem_tbl, - element_ids=elem_ids, - dfsu_type=DfsuFileType.Dfsu2D, - reindex=True) + return GeometryFM2D( + node_coordinates=node_coords, + codes=codes, + node_ids=node_ids, + projection=self.projection_string, + element_table=elem_tbl, + element_ids=elem_ids, + dfsu_type=DfsuFileType.Dfsu2D, + reindex=True, + ) else: lowest_sigma = self.n_layers - self.n_sigma_layers n_sigma = sum(unique_layer_ids >= lowest_sigma) if n_layers == len(elem_tbl): - return GeometryFMVerticalColumn(node_coordinates=node_coords, - codes=codes, - node_ids=node_ids, - projection=self.projection_string, - element_table=elem_tbl, - element_ids=elem_ids, - dfsu_type=self._type, - reindex=True, - n_layers=n_layers, - n_sigma=n_sigma) + return GeometryFMVerticalColumn( + node_coordinates=node_coords, + codes=codes, + node_ids=node_ids, + projection=self.projection_string, + element_table=elem_tbl, + element_ids=elem_ids, + dfsu_type=self._type, + reindex=True, + n_layers=n_layers, + n_sigma=n_sigma, + ) else: klass = self.__class__ - return klass(node_coordinates=node_coords, - codes=codes, - node_ids=node_ids, - projection=self.projection_string, - element_table=elem_tbl, - element_ids=elem_ids, - dfsu_type=self._type, - reindex=True, - n_layers=n_layers, - n_sigma=n_sigma) - + return klass( + node_coordinates=node_coords, + codes=codes, + node_ids=node_ids, + projection=self.projection_string, + element_table=elem_tbl, + element_ids=elem_ids, + dfsu_type=self._type, + reindex=True, + n_layers=n_layers, + n_sigma=n_sigma, + ) @cached_property def element_coordinates(self): @@ -603,7 +608,9 @@ def _find_3d_from_2d_points(self, elem2d, z=None, layer=None): id = row[list(layer_ids).index(layer)] idx[j] = id except IndexError: - raise IndexError(f"Layer {layer} not present for 2d element {elem2d[j]}") + raise IndexError( + f"Layer {layer} not present for 2d element {elem2d[j]}" + ) else: # sigma layer idx = self.get_layer_elements(layer)[elem2d] @@ -669,7 +676,7 @@ def __init__( node_coordinates, element_table, codes=None, - projection:str = "LONG/LAT", + projection: str = "LONG/LAT", dfsu_type=DfsuFileType.Dfsu3DSigma, element_ids=None, node_ids=None, @@ -749,7 +756,7 @@ def __init__( node_coordinates, element_table, codes=None, - projection:str = "LONG/LAT", + projection: str = "LONG/LAT", dfsu_type=None, element_ids=None, node_ids=None, From a9ff6e704e378ff4606852248245264ee8533605 Mon Sep 17 00:00:00 2001 From: Henrik Andersson Date: Thu, 29 Feb 2024 18:40:28 +0100 Subject: [PATCH 20/20] Append with mikecore --- tests/test_dfsu.py | 153 ++++++--------------------------------------- 1 file changed, 18 insertions(+), 135 deletions(-) diff --git a/tests/test_dfsu.py b/tests/test_dfsu.py index 7b0950fdd..bac3e0ccb 100644 --- a/tests/test_dfsu.py +++ b/tests/test_dfsu.py @@ -1,5 +1,6 @@ from pathlib import Path from datetime import datetime +import shutil import numpy as np import pandas as pd @@ -535,117 +536,28 @@ def test_write_from_dfsu(tmp_path): assert dfs.end_time == newdfs.end_time -# def test_incremental_write_from_dfsu(tmp_path): -# "Useful for writing datasets with many timesteps to avoid problems with out of memory" +def test_incremental_write_using_mikecore(tmp_path): + from mikecore.DfsFileFactory import DfsFileFactory -# sourcefilename = "tests/testdata/HD2D.dfsu" -# fp = tmp_path / "simple.dfsu" -# dfs = mikeio.open(sourcefilename) - -# nt = dfs.n_timesteps - -# ds = dfs.read(time=[0], keepdims=True) - -# dfs.write(fp, ds, keep_open=True) - -# for i in range(1, nt): -# ds = dfs.read(time=[i], keepdims=True) -# dfs.append(ds) - -# dfs.close() - -# newdfs = mikeio.open(fp) -# assert dfs.start_time == newdfs.start_time -# assert dfs.timestep == newdfs.timestep -# assert dfs.end_time == newdfs.end_time - - -# def test_incremental_write_from_dfsu_context_manager(tmp_path): -# sourcefilename = "tests/testdata/HD2D.dfsu" -# fp = tmp_path / "simple.dfsu" -# dfs = mikeio.open(sourcefilename) - -# nt = dfs.n_timesteps - -# ds = dfs.read(time=[0], keepdims=True) - -# with dfs.write(fp, ds, keep_open=True) as f: -# for i in range(1, nt): -# ds = dfs.read(time=[i], keepdims=True) -# f.append(ds) - -# # dfs.close() # should be called automagically by context manager - -# newdfs = mikeio.open(fp) -# assert dfs.start_time == newdfs.start_time -# assert dfs.timestep == newdfs.timestep -# assert dfs.end_time == newdfs.end_time - - -# def test_incremental_write_from_dfsu_context_manager_3d(tmp_path): -# sourcefilename = "tests/testdata/oresund_sigma_z.dfsu" -# fp = tmp_path / "3d.dfsu" -# dfs = mikeio.open(sourcefilename) - -# nt = dfs.n_timesteps - -# ds = dfs.read(time=[0], keepdims=True) - -# with dfs.write(fp, ds, keep_open=True) as f: -# for i in range(1, nt): -# ds = dfs.read(time=[i], keepdims=True) -# f.append(ds) - -# # dfs.close() # should be called automagically by context manager - -# newdfs = mikeio.open(fp) -# assert dfs.start_time == newdfs.start_time -# assert dfs.timestep == newdfs.timestep -# assert dfs.end_time == newdfs.end_time - - -# TODO add workaround to write big file -# def test_write_big_file(tmp_path): -# fp = tmp_path / "big.dfsu" -# meshfilename = "tests/testdata/odense_rough.mesh" - -# msh = Mesh(meshfilename) - -# n_elements = msh.n_elements - -# dfs = Dfsu(meshfilename) - -# nt = 5 # or some big number 50000 - -# n_items = 10 - -# das = [ -# DataArray( -# data=np.random.random((1, n_elements)), -# geometry=msh.geometry, -# time="2000-1-1", -# item=f"Item {i+1}", -# ) -# for i in range(n_items) -# ] + sourcefilename = "tests/testdata/HD2D.dfsu" -# ds = Dataset(das) + # copy to tmp_path + fp = str(tmp_path / "simple.dfsu") + shutil.copy(sourcefilename, fp) -# with dfs.write(fp, data=ds, dt=3600, keep_open=True) as f: -# for _ in range(1, nt): -# data = [] -# for i in range(n_items): -# d = np.random.random((1, n_elements)) -# da = DataArray(data=d, geometry=msh.geometry, item=f"Item {i+1}") -# data.append(da) -# dst = Dataset(data) -# f.append(dst) + nt = 10 -# dfsu = mikeio.open(fp) + dfs = DfsFileFactory.DfsGenericOpenEdit(fp) + n_items = len(dfs.ItemInfo) + n_elements = dfs.ItemInfo[0].ElementCount -# assert dfsu.n_items == n_items -# assert dfsu.n_timesteps == nt -# assert dfsu.start_time.year == 2000 + for _ in range(nt): + for _ in range(n_items): + data = np.random.random(size=n_elements).astype( + np.float32 + ) # Replace with actual data + dfs.WriteItemTimeStepNext(0.0, data) + dfs.Close() def test_write_from_dfsu_2_time_steps(tmp_path): @@ -1067,35 +979,6 @@ def test_interp_like_fm_dataset(): assert isinstance(dsi.geometry, GeometryFM2D) -# TODO add workaround to write big file -# def test_write_header(tmp_path): -# meshfilename = "tests/testdata/north_sea_2.mesh" -# fp = tmp_path / "NS_write_header.dfsu" -# dfs = mikeio.Dfsu(meshfilename) -# n_elements = dfs.n_elements -# nt = 3 -# n_items = 2 -# items = [ItemInfo(f"Item {i+1}") for i in range(n_items)] -# time0 = datetime(2021, 1, 1) -# with dfs.write_header(fp, items=items, start_time=time0, dt=3600) as f: -# for _ in range(nt): -# data = [] -# for _ in range(n_items): -# d = np.random.random((1, n_elements)) # 2d -# data.append(d) -# f.append(data) - -# # append also works for data without time axis -# fp = tmp_path / "NS_write_header2.dfsu" -# with dfs.write_header(fp, items=items, start_time=time0, dt=3600) as f: -# for _ in range(nt): -# data = [] -# for _ in range(n_items): -# d = np.random.random((n_elements)) # 1d -# data.append(d) -# f.append(data) - - def test_writing_non_equdistant_dfsu_is_not_possible(tmp_path): ds = mikeio.read("tests/testdata/wind_north_sea.dfsu") dss = ds.isel(time=[0, 2, 3])