diff --git a/CHANGELOG.md b/CHANGELOG.md index 130cd4e..ef1301e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- `DfsuFile.SubMeshType` tells whether a dfsu file from MIKE 2027 has a + local refinement submesh: 1 if it has, 0 if not, and `None` for a file + without a submesh type. Compare it with `None`, as a plain truth test is + false for submesh type 0 + ([#54](https://github.com/DHI/mikecore-python/issues/54)). +- `DfsuBuilder.SetSubMeshType(None | 0 | 1)` writes a dfsu file with a + submesh type, as MIKE 2027 does. Without it, older mikecore releases can + still open the file. With it, they can only open a 2D file with submesh + type 0. - `MIKECORE_PYTHON_BIN`: set it to a MIKE installation's `bin` folder to have mikecore use that installation's native libraries instead of its bundled ones, at your own risk (see README). @@ -29,6 +38,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed +- `DfsuFile` opens dfsu files from MIKE 2027 with a submesh type, such as 3D + files and locally refined meshes, which raised "not a valid dfsu file". + Files from later MIKE versions with more custom block values also open. + Legacy Spectral0D (rose-plot) files still open as `DfsuSpectral0D`, + including files with frequencies only or directions only + ([#54](https://github.com/DHI/mikecore-python/issues/54)). - A failed open of a dfs file shorter than 4 bytes, such as an empty file, no longer leaves the file open. Each such open used up a file handle, so after about 500 of them no file could be opened (Error code 2003) diff --git a/mikecore/DfsuBuilder.py b/mikecore/DfsuBuilder.py index e2a8820..23e5e37 100644 --- a/mikecore/DfsuBuilder.py +++ b/mikecore/DfsuBuilder.py @@ -16,6 +16,12 @@ from mikecore.eum import eumUnit, eumQuantity, eumItem from mikecore.Projections import MapProjection +spectralDfsuFileTypes = ( + DfsuFileType.DfsuSpectral0D, + DfsuFileType.DfsuSpectral1D, + DfsuFileType.DfsuSpectral2D, +) + # / # / Builder for creating a dfsu file. @@ -48,6 +54,7 @@ def __init__(self, dfsuFileType): self.__dfsuFileType = dfsuFileType self.__numberOfSigmaLayers = -1 + self.__subMeshType: int | None = None # Projection variables self.__dfsProjection: DfsProjection | None = None @@ -125,6 +132,31 @@ def SetNumberOfSigmaLayers(self, numberOfSigmaLayers: int): else: raise Exception("dfsuFileType") + def SetSubMeshType(self, subMeshType: int | np.integer | None): + """ + Set the submesh type: 1 for a local refinement submesh, 0 otherwise. + The mesh is not checked against it. + + None (default) writes the pre-2027 5-value custom block; 0 or 1 writes + the MIKE 2027 6-value block. Older mikecore releases can open such a + file only if it is 2D with type 0. MIKE before 2027 is untested. + + Raises ValueError for values other than None, 0 or 1, and an exception + for spectral file types. + """ + # True is an int, but not a submesh type + isInteger = isinstance(subMeshType, (int, np.integer)) and not isinstance( + subMeshType, bool + ) + if self.__dfsuFileType in spectralDfsuFileTypes: + raise Exception("Can not set submesh type on a spectral dfsu file") + elif subMeshType is None: + self.__subMeshType = None + elif isInteger and subMeshType in (0, 1): + self.__subMeshType = int(subMeshType) + else: + raise ValueError(f"Submesh type must be None, 0 or 1, not {subMeshType!r}") + def SetFrequencies(self, frequencies): self.__frequencies = frequencies @@ -400,11 +432,7 @@ def Validate(self, dieOnError: bool = False): errors.append( "The minimum number of layers is smaller than the number of sigma layers. Element table is invalid" ) - elif self.__dfsuFileType in ( - DfsuFileType.DfsuSpectral0D, - DfsuFileType.DfsuSpectral1D, - DfsuFileType.DfsuSpectral2D, - ): + elif self.__dfsuFileType in spectralDfsuFileTypes: # TODO do we need to check frequency or directions? pass else: @@ -497,11 +525,15 @@ def SetupBuilder(self): ) dfsBuilder.DeleteValueFloat = np.float32(1e-35) - # Set up custom block + # Set up custom block, with the submesh type as an optional 6th value + subMeshTypeValues = [] if self.__subMeshType is None else [self.__subMeshType] if self.__dfsuFileType == DfsuFileType.Dfsu2D: dfsBuilder.AddCreateCustomBlock( "MIKE_FM", - np.array([nodes.x.size, len(connectivity), 2, 0, 0], np.int32), + np.array( + [nodes.x.size, len(connectivity), 2, 0, 0, *subMeshTypeValues], + np.int32, + ), ) elif self.__dfsuFileType == DfsuFileType.DfsuVerticalColumn: maxNumberOfLayers = len(connectivity) @@ -514,6 +546,7 @@ def SetupBuilder(self): 1, maxNumberOfLayers, self.__numberOfSigmaLayers, + *subMeshTypeValues, ], np.int32, ), @@ -529,6 +562,7 @@ def SetupBuilder(self): 2, maxNumberOfLayers, self.__numberOfSigmaLayers, + *subMeshTypeValues, ], np.int32, ), @@ -546,6 +580,7 @@ def SetupBuilder(self): 2, maxNumberOfLayers, self.__numberOfSigmaLayers, + *subMeshTypeValues, ], np.int32, ), @@ -561,6 +596,7 @@ def SetupBuilder(self): 3, maxNumberOfLayers, self.__numberOfSigmaLayers, + *subMeshTypeValues, ], np.int32, ), @@ -578,6 +614,7 @@ def SetupBuilder(self): 3, maxNumberOfLayers, self.__numberOfSigmaLayers, + *subMeshTypeValues, ], np.int32, ), @@ -782,6 +819,7 @@ def CreateDfsu(self, dfsBuilder, elementType, nodesPerElmt, connectivityArray): self.__zUnit, frequencyItem, directionItem, + self.__subMeshType, ) return dfsuFile diff --git a/mikecore/DfsuFile.py b/mikecore/DfsuFile.py index 9e8883d..2bbcf39 100644 --- a/mikecore/DfsuFile.py +++ b/mikecore/DfsuFile.py @@ -48,6 +48,19 @@ class DfsuFile: Use the DfsuBuilder to create a new dfsu file. You can read, write and append item-timesteps to the file. The geometry can be altered, by moving the nodes, but the element connectivity can not be changed. + + The "MIKE_FM" custom block (dfsu file specification, section 4.3) of a + data type 2001 file is read as: + + 1. 5 values or fewer (before MIKE 2027): value 5, if present, is the + number of sigma layers, otherwise it equals the number of layers. + 2. Exactly 6 values in a legacy Spectral0D file: values 5 and 6 are the + number of frequencies and directions. This undocumented layout has one + static item per axis after the 9 of section 4.4. + 3. Otherwise (MIKE 2027 and later): value 5 is the number of sigma layers, + value 6 the submesh type. Values from 7 on are ignored. + + Other data types are read by their own fixed layouts. """ def __init__(self, dfsFile=None): @@ -58,6 +71,7 @@ def __init__(self, dfsFile=None): self.NumberOfSigmaLayers = -1 self.NumberOfFrequencies = -1 self.NumberOfDirections = -1 + self.__subMeshType: int | None = None # Static item self.__nodeIdItem = None @@ -94,7 +108,7 @@ def __init__(self, dfsFile=None): if dfsFile is not None: self.__Init(dfsFile) - def __Init(self, dfsFile, build=False): + def __Init(self, dfsFile, build=False, subMeshType=None): """ Wrap a dfs file in the DfsuFile object. It will throw an exception if file is not a dfsu file. @@ -131,15 +145,31 @@ def __Init(self, dfsFile, build=False): self.NumberOfSigmaLayers = customBlock[4] else: self.NumberOfSigmaLayers = self.NumberOfLayers + self.NumberOfFrequencies = 0 + self.NumberOfDirections = 0 + self.__subMeshType = None - if self.FileInfo.DataType in (2002, 2003) or ( - self.FileInfo.DataType == 2001 and (customBlock.Count == 6) - ): + if self.FileInfo.DataType in (2002, 2003): self.NumberOfFrequencies = customBlock[4] self.NumberOfDirections = customBlock[5] - else: - self.NumberOfFrequencies = 0 - self.NumberOfDirections = 0 + elif self.FileInfo.DataType == 2001 and customBlock.Count >= 6: + if build: + # Static items are not written yet. DfsuBuilder writes 6 + # values only with a submesh type, never for Spectral0D. + if subMeshType is None: + raise Exception( + "DfsuBuilder wrote 6 custom block values without a submesh type" + ) + isLegacySpectral0D = False + else: + isLegacySpectral0D = self.__IsLegacySpectral0D(dfsFile, customBlock) + if isLegacySpectral0D: + self.NumberOfFrequencies = customBlock[4] + self.NumberOfDirections = customBlock[5] + else: + # MIKE 2027 layout + self.NumberOfSigmaLayers = customBlock[4] + self.__subMeshType = int(customBlock[5]) # Figuring out dfsu file type from custom block MIKE_FM if dimensions == 1: @@ -193,7 +223,8 @@ def __Init(self, dfsFile, build=False): # "Frequency" , double # "Direction" , double - self.__nodeIdItem = self.dfsFile.ReadStaticItemNext() + # Read by number, __IsLegacySpectral0D may have moved the file pointer + self.__nodeIdItem = self.dfsFile.ReadStaticItem(1) CheckForNull(self.__nodeIdItem) self.NodeIds = self.__nodeIdItem.Data @@ -257,11 +288,11 @@ def __Init(self, dfsFile, build=False): k1 = k2 # Spectral Dfsu - if self.NumberOfFrequencies: + if self.NumberOfFrequencies > 0: frequency = self.dfsFile.ReadStaticItemNext() CheckForNull(frequency) self.Frequencies = frequency.Data - if self.NumberOfDirections: + if self.NumberOfDirections > 0: direction = self.dfsFile.ReadStaticItemNext() CheckForNull(direction) self.Directions = direction.Data @@ -277,6 +308,48 @@ def __Init(self, dfsFile, build=False): if not build and self.dfsFile.FileMode == DfsFileMode.Append: self.dfsFile.FindTimeStep(self.NumberOfTimeSteps) + def __IsLegacySpectral0D(self, dfsFile, customBlock): + """ + Check if a 2001 file is a legacy Spectral0D (rose-plot) file: exactly + 6 custom block values, [..., NumberOfFrequencies, NumberOfDirections], + at least one of them above 0, and after the 9 static items of section + 4.4 exactly one static item per such axis: frequencies in hertz, then + directions in radians or degrees. + """ + if customBlock.Count != 6: + return False + + numberOfFrequencies = customBlock[4] + numberOfDirections = customBlock[5] + if numberOfFrequencies <= 0 and numberOfDirections <= 0: + return False + + itemNumber = 10 + if numberOfFrequencies > 0: + frequency = dfsFile.ReadStaticItem(itemNumber) + itemNumber += 1 + if not ( + frequency is not None + and frequency.Quantity.Item + in (eumItem.eumIWaveFrequency, eumItem.eumIFrequency) + and frequency.Quantity.Unit == eumUnit.eumUhertz + and frequency.ElementCount == numberOfFrequencies + ): + return False + if numberOfDirections > 0: + direction = dfsFile.ReadStaticItem(itemNumber) + itemNumber += 1 + if not ( + direction is not None + and direction.Quantity.Item + in (eumItem.eumIWaveDirection, eumItem.eumIDirection) + and direction.Quantity.Unit in (eumUnit.eumUradian, eumUnit.eumUdegree) + and direction.ElementCount == numberOfDirections + ): + return False + + return dfsFile.ReadStaticItem(itemNumber) is None + def Dispose(self): """ Close file and release ressources on the unmanaged side. @@ -335,10 +408,6 @@ def OpenAppend(fileName): dfs.Open(fileName, DfsFileMode.Append) return DfsuFile(dfs) - """ - Internal factory method, used by the DfsuBuilder - """ - def DfsuFileBuild( self, dfsFile, @@ -359,7 +428,11 @@ def DfsuFileBuild( zUnit, freqItem, dirItem, + subMeshType=None, ): + """ + Internal factory method, used by the DfsuBuilder + """ self.dfsFile = dfsFile self.__nodeIdItem = nodeIdItem @@ -379,7 +452,7 @@ def DfsuFileBuild( self.ZUnit = zUnit self.__freqItem = freqItem self.__dirItem = dirItem - self.__Init(dfsFile, build=True) + self.__Init(dfsFile, build=True, subMeshType=subMeshType) def __GetFileName(self): return self.FileInfo.FileName @@ -467,6 +540,14 @@ def __SetDeleteValueFloat(self, value): def IsSpectral(self): return (self.NumberOfFrequencies > 0) or (self.NumberOfDirections > 0) + @property + def SubMeshType(self) -> int | None: + """ + Submesh type: 1 for a local refinement submesh, 0 otherwise, None if + the file has none. Compare with None, as type 0 is falsy. + """ + return self.__subMeshType + @staticmethod def CreateEmptyItemDatas(dfsFile: DfsFile): """ diff --git a/testdata/submesh/Dfsu2D_CustomBlock6_Submesh0.dfsu b/testdata/submesh/Dfsu2D_CustomBlock6_Submesh0.dfsu new file mode 100644 index 0000000..5906c04 Binary files /dev/null and b/testdata/submesh/Dfsu2D_CustomBlock6_Submesh0.dfsu differ diff --git a/testdata/submesh/Dfsu2D_CustomBlock6_Submesh1_LocallyRefined.dfsu b/testdata/submesh/Dfsu2D_CustomBlock6_Submesh1_LocallyRefined.dfsu new file mode 100644 index 0000000..3883559 Binary files /dev/null and b/testdata/submesh/Dfsu2D_CustomBlock6_Submesh1_LocallyRefined.dfsu differ diff --git a/testdata/submesh/Dfsu3DSigmaZ_CustomBlock5.dfsu b/testdata/submesh/Dfsu3DSigmaZ_CustomBlock5.dfsu new file mode 100644 index 0000000..c4cee0f Binary files /dev/null and b/testdata/submesh/Dfsu3DSigmaZ_CustomBlock5.dfsu differ diff --git a/testdata/submesh/Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu b/testdata/submesh/Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu new file mode 100644 index 0000000..5a817a7 Binary files /dev/null and b/testdata/submesh/Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu differ diff --git a/testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu b/testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu new file mode 100644 index 0000000..d35a479 Binary files /dev/null and b/testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu differ diff --git a/tests/test_dfsu_builder.py b/tests/test_dfsu_builder.py index 45d50f1..f712754 100644 --- a/tests/test_dfsu_builder.py +++ b/tests/test_dfsu_builder.py @@ -398,3 +398,88 @@ def test_spectral_0d_file_has_one_spectrum(tmp_path): assert_array_equal(directions, dfsu.Directions) assert len(frequencies) * len(directions) == dfsu.ItemInfo[0].ElementCount dfsu.Close() + + +def _builder_3d_sigma_z(): + # Small 3D sigma-z mesh with 3 layers, 1 of them sigma layers + source = DfsuFile.Open("testdata/submesh/Dfsu3DSigmaZ_CustomBlock5.dfsu") + builder = _builder(DfsuFileType.Dfsu3DSigmaZ) + builder.SetNodes(source.X, source.Y, source.Z, source.Code) + builder.SetElements(source.ElementTable) + builder.SetNumberOfSigmaLayers(source.NumberOfSigmaLayers) + source.Close() + return builder + + +def _builder_2d(): + builder = _builder() + builder.SetNodes(X, Y, Z, CODE) + builder.SetElements(ELEMENTS) + return builder + + +@pytest.mark.parametrize( + "createBuilder, customBlock", + [(_builder_2d, [4, 2, 2, 0, 0]), (_builder_3d_sigma_z, [30, 8, 3, 3, 1])], +) +@pytest.mark.parametrize( + "subMeshType, subMeshTypeValues", [(None, []), (0, [0]), (1, [1])] +) +def test_submesh_type_is_written( + tmp_path, createBuilder, customBlock, subMeshType, subMeshTypeValues +): + filename = str(tmp_path / "submesh.dfsu") + builder = createBuilder() + builder.SetSubMeshType(subMeshType) + created = builder.CreateFile(filename) + createdType = created.DfsuFileType + createdSubMeshType = created.SubMeshType + created.Close() + + # Read as a generic dfs file, independent of DfsuFile + dfs = DfsFileFactory.DfsGenericOpen(filename) + assert_array_equal( + customBlock + subMeshTypeValues, dfs.FileInfo.CustomBlocks[0].Values + ) + dfs.Close() + + dfsu = DfsuFile.Open(filename) + assert subMeshType == dfsu.SubMeshType + assert subMeshType == createdSubMeshType + assert dfsu.DfsuFileType is createdType + assert customBlock[4] == dfsu.NumberOfSigmaLayers + dfsu.Close() + + +def test_submesh_type_can_be_reset_to_none(tmp_path): + filename = str(tmp_path / "submesh_none.dfsu") + builder = _builder_2d() + builder.SetSubMeshType(1) + builder.SetSubMeshType(None) + builder.CreateFile(filename).Close() + + dfsu = DfsuFile.Open(filename) + assert dfsu.SubMeshType is None + assert 5 == dfsu.FileInfo.CustomBlocks[0].Count + dfsu.Close() + + +@pytest.mark.parametrize("subMeshType", [-1, 2, True, 0.0, "1"]) +def test_submesh_type_must_be_none_0_or_1(subMeshType): + builder = _builder() + with pytest.raises(ValueError): + builder.SetSubMeshType(subMeshType) + + +@pytest.mark.parametrize( + "fileType", + [ + DfsuFileType.DfsuSpectral0D, + DfsuFileType.DfsuSpectral1D, + DfsuFileType.DfsuSpectral2D, + ], +) +def test_submesh_type_can_not_be_set_on_spectral_files(fileType): + builder = _builder(fileType) + with pytest.raises(Exception, match="submesh type"): + builder.SetSubMeshType(0) diff --git a/tests/test_dfsu_file.py b/tests/test_dfsu_file.py index 10ba0dc..22884cb 100644 --- a/tests/test_dfsu_file.py +++ b/tests/test_dfsu_file.py @@ -1,7 +1,10 @@ import unittest import datetime +import os +import numpy as np import pytest +from numpy.testing import assert_array_equal from mikecore.DfsFileFactory import * from mikecore.DfsuBuilder import * @@ -189,6 +192,469 @@ def Read3DSigmaOdenseTest(self, filename, original): # endregion + # region Submesh files + + # Test files in testdata/submesh, all data type 2001: + # + # File MIKE_FM custom block + # Dfsu2D_CustomBlock6_Submesh0.dfsu [ 9, 4, 2, 0, 0, 0] + # Dfsu2D_CustomBlock6_Submesh1_LocallyRefined.dfsu [ 31, 40, 2, 0, 0, 1] + # Dfsu3DSigmaZ_CustomBlock5.dfsu [ 30, 8, 3, 3, 1] + # Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu [ 30, 8, 3, 3, 1, 0] + # DfsuSpectral0D_CustomBlock6_Legacy.dfsu [416, 400, 2, 0, 25, 16] + # + # The two Dfsu3DSigmaZ files hold the same mesh, and the same data to + # within float32 rounding (separate model runs). + + # / + # / Reading a 2D dfsu file with submesh type 0. + # / + def test_Read2DSubmesh0Test(self): + self.SubmeshCustomBlockTester( + "testdata/submesh/Dfsu2D_CustomBlock6_Submesh0.dfsu", [9, 4, 2, 0, 0, 0] + ) + dfsFile = DfsuFile.Open("testdata/submesh/Dfsu2D_CustomBlock6_Submesh0.dfsu") + Assert.AreEqual(DfsuFileType.Dfsu2D, dfsFile.DfsuFileType) + Assert.AreEqual(9, dfsFile.NumberOfNodes) + Assert.AreEqual(4, dfsFile.NumberOfElements) + Assert.AreEqual(0, dfsFile.NumberOfLayers) + Assert.AreEqual(0, dfsFile.NumberOfSigmaLayers) + Assert.AreEqual(0, dfsFile.SubMeshType) + Assert.AreEqual(0, dfsFile.NumberOfFrequencies) + Assert.AreEqual(0, dfsFile.NumberOfDirections) + Assert.AreEqual(4, dfsFile.ReadItemTimeStep(1, 0).Data.size) + dfsFile.Close() + + # / + # / Reading a 3D sigma-z dfsu file with submesh type 0, the same as the + # / 5-value file. + # / + def test_Read3DSubmesh0Test(self): + self.SubmeshCustomBlockTester( + "testdata/submesh/Dfsu3DSigmaZ_CustomBlock5.dfsu", [30, 8, 3, 3, 1] + ) + self.SubmeshCustomBlockTester( + "testdata/submesh/Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu", + [30, 8, 3, 3, 1, 0], + ) + oldFile = DfsuFile.Open("testdata/submesh/Dfsu3DSigmaZ_CustomBlock5.dfsu") + newFile = DfsuFile.Open( + "testdata/submesh/Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu" + ) + Assert.AreEqual(DfsuFileType.Dfsu3DSigmaZ, newFile.DfsuFileType) + Assert.AreEqual(oldFile.NumberOfNodes, newFile.NumberOfNodes) + Assert.AreEqual(oldFile.NumberOfElements, newFile.NumberOfElements) + Assert.AreEqual(oldFile.NumberOfLayers, newFile.NumberOfLayers) + Assert.AreEqual(oldFile.NumberOfSigmaLayers, newFile.NumberOfSigmaLayers) + Assert.IsNull(oldFile.SubMeshType) + Assert.AreEqual(0, newFile.SubMeshType) + Assert.AreEqual(oldFile.NumberOfFrequencies, newFile.NumberOfFrequencies) + Assert.AreEqual(oldFile.NumberOfDirections, newFile.NumberOfDirections) + assert_array_equal( + oldFile.ReadItemTimeStep(1, 0).Data, newFile.ReadItemTimeStep(1, 0).Data + ) + oldFile.Close() + newFile.Close() + + # / + # / Reading a locally refined 2D dfsu file, submesh type 1. + # / + # TODO: Only checks that it reads as an ordinary 2D mesh, not full + # submesh support. + def test_Read2DSubmesh1LocallyRefinedTest(self): + self.SubmeshCustomBlockTester( + "testdata/submesh/Dfsu2D_CustomBlock6_Submesh1_LocallyRefined.dfsu", + [31, 40, 2, 0, 0, 1], + ) + dfsFile = DfsuFile.Open( + "testdata/submesh/Dfsu2D_CustomBlock6_Submesh1_LocallyRefined.dfsu" + ) + Assert.AreEqual(DfsuFileType.Dfsu2D, dfsFile.DfsuFileType) + Assert.AreEqual(31, dfsFile.NumberOfNodes) + Assert.AreEqual(40, dfsFile.NumberOfElements) + Assert.AreEqual(1, dfsFile.SubMeshType) + Assert.AreEqual(0, dfsFile.NumberOfFrequencies) + Assert.AreEqual(0, dfsFile.NumberOfDirections) + Assert.AreEqual(40, dfsFile.ReadItemTimeStep(1, 0).Data.size) + dfsFile.Close() + + # / + # / Reading a legacy Spectral0D (rose-plot) file, not as a submesh file. + # / + def test_ReadLegacySpectral0DTest(self): + self.SubmeshCustomBlockTester( + "testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu", + [416, 400, 2, 0, 25, 16], + ) + dfsFile = DfsuFile.Open( + "testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu" + ) + Assert.AreEqual(DfsuFileType.DfsuSpectral0D, dfsFile.DfsuFileType) + Assert.AreEqual(416, dfsFile.NumberOfNodes) + Assert.AreEqual(400, dfsFile.NumberOfElements) + Assert.IsNull(dfsFile.SubMeshType) + Assert.AreEqual(25, dfsFile.NumberOfFrequencies) + Assert.AreEqual(16, dfsFile.NumberOfDirections) + assert dfsFile.Frequencies is not None + assert dfsFile.Directions is not None + Assert.AreEqual(25, len(dfsFile.Frequencies)) + Assert.AreEqual(16, len(dfsFile.Directions)) + Assert.AreEqual(400, dfsFile.ReadItemTimeStep(1, 0).Data.size) + dfsFile.Close() + + # / + # / Reading a legacy Spectral0D file with directions in degrees. + # / + def test_ReadLegacySpectral0DDegreesTest(self): + filename = "testdata/testtmp/test_DfsuSpectral0D_CustomBlock6_Degrees.dfsu" + self.RewriteDfsu( + "testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu", + filename, + staticQuantities={ + 11: eumQuantity(eumItem.eumIWaveDirection, eumUnit.eumUdegree) + }, + ) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.DfsuSpectral0D, dfsFile.DfsuFileType) + Assert.IsNull(dfsFile.SubMeshType) + Assert.AreEqual(25, dfsFile.NumberOfFrequencies) + Assert.AreEqual(16, dfsFile.NumberOfDirections) + assert dfsFile.Directions is not None + Assert.AreEqual(16, len(dfsFile.Directions)) + dfsFile.Close() + + # / + # / Reading a legacy Spectral0D file with generic EUM item types. + # / + def test_ReadLegacySpectral0DGenericItemTypesTest(self): + filename = "testdata/testtmp/test_DfsuSpectral0D_CustomBlock6_Generic.dfsu" + self.RewriteDfsu( + "testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu", + filename, + staticQuantities={ + 10: eumQuantity(eumItem.eumIFrequency, eumUnit.eumUhertz), + 11: eumQuantity(eumItem.eumIDirection, eumUnit.eumUradian), + }, + ) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.DfsuSpectral0D, dfsFile.DfsuFileType) + Assert.IsNull(dfsFile.SubMeshType) + Assert.AreEqual(25, dfsFile.NumberOfFrequencies) + Assert.AreEqual(16, dfsFile.NumberOfDirections) + assert dfsFile.Frequencies is not None + Assert.AreEqual(25, len(dfsFile.Frequencies)) + assert dfsFile.Directions is not None + Assert.AreEqual(16, len(dfsFile.Directions)) + dfsFile.Close() + + # / + # / A legacy Spectral0D file with 7 values reads with the MIKE 2027 layout. + # / + def test_ReadLegacySpectral0DCustomBlock7Test(self): + filename = "testdata/testtmp/test_DfsuSpectral0D_CustomBlock7.dfsu" + self.RewriteDfsu( + "testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu", + filename, + customBlockValues=[416, 400, 2, 0, 25, 16, 0], + ) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.Dfsu2D, dfsFile.DfsuFileType) + Assert.AreEqual(25, dfsFile.NumberOfSigmaLayers) + Assert.AreEqual(16, dfsFile.SubMeshType) + Assert.AreEqual(0, dfsFile.NumberOfFrequencies) + Assert.AreEqual(0, dfsFile.NumberOfDirections) + dfsFile.Close() + + # / + # / Reading a legacy Spectral0D file with frequencies only. + # / + def test_ReadLegacySpectral0DFrequencyOnlyTest(self): + filename = "testdata/testtmp/test_DfsuSpectral0D_FrequencyOnly.dfsu" + self.CreateSingleAxisSpectral0D( + filename, + [6, 5, 1, 0, 5, 0], + eumQuantity(eumItem.eumIWaveFrequency, eumUnit.eumUhertz), + [0.05, 0.06, 0.07, 0.08, 0.09], + ) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.DfsuSpectral0D, dfsFile.DfsuFileType) + Assert.AreEqual(6, dfsFile.NumberOfNodes) + Assert.AreEqual(5, dfsFile.NumberOfElements) + Assert.IsNull(dfsFile.SubMeshType) + Assert.AreEqual(5, dfsFile.NumberOfFrequencies) + Assert.AreEqual(0, dfsFile.NumberOfDirections) + assert dfsFile.Frequencies is not None + np.testing.assert_allclose( + dfsFile.Frequencies, [0.05, 0.06, 0.07, 0.08, 0.09], rtol=1e-6 + ) + Assert.IsNull(dfsFile.Directions) + Assert.AreEqual(5, dfsFile.ReadItemTimeStep(1, 0).Data.size) + dfsFile.Close() + + # / + # / Reading a legacy Spectral0D file with directions only. + # / + def test_ReadLegacySpectral0DDirectionOnlyTest(self): + filename = "testdata/testtmp/test_DfsuSpectral0D_DirectionOnly.dfsu" + self.CreateSingleAxisSpectral0D( + filename, + [5, 4, 1, 0, 0, 4], + eumQuantity(eumItem.eumIWaveDirection, eumUnit.eumUdegree), + [0, 90, 180, 270], + ) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.DfsuSpectral0D, dfsFile.DfsuFileType) + Assert.AreEqual(5, dfsFile.NumberOfNodes) + Assert.AreEqual(4, dfsFile.NumberOfElements) + Assert.IsNull(dfsFile.SubMeshType) + Assert.AreEqual(0, dfsFile.NumberOfFrequencies) + Assert.AreEqual(4, dfsFile.NumberOfDirections) + Assert.IsNull(dfsFile.Frequencies) + assert_array_equal([0, 90, 180, 270], dfsFile.Directions) + Assert.AreEqual(4, dfsFile.ReadItemTimeStep(1, 0).Data.size) + dfsFile.Close() + + # / + # / A 6-value file whose 10th static item is not a frequency reads with + # / the MIKE 2027 layout. + # / + def test_ReadSingleAxisNotFrequencyTest(self): + filename = "testdata/testtmp/test_Dfsu1D_CustomBlock6_NotFrequency.dfsu" + self.CreateSingleAxisSpectral0D( + filename, + [6, 5, 1, 0, 5, 0], + eumQuantity(eumItem.eumIWaterLevel, eumUnit.eumUmeter), + [1, 2, 3, 4, 5], + ) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.Dfsu1D, dfsFile.DfsuFileType) + Assert.AreEqual(5, dfsFile.NumberOfSigmaLayers) + Assert.AreEqual(0, dfsFile.SubMeshType) + Assert.AreEqual(0, dfsFile.NumberOfFrequencies) + Assert.AreEqual(0, dfsFile.NumberOfDirections) + Assert.IsNull(dfsFile.Frequencies) + dfsFile.Close() + + # / + # / A frequency-only file with an extra static item reads with the MIKE + # / 2027 layout. + # / + def test_ReadSingleAxisExtraStaticItemTest(self): + filename = "testdata/testtmp/test_Dfsu1D_CustomBlock6_ExtraStaticItem.dfsu" + self.CreateSingleAxisSpectral0D( + filename, + [6, 5, 1, 0, 5, 0], + eumQuantity(eumItem.eumIWaveFrequency, eumUnit.eumUhertz), + [0.05, 0.06, 0.07, 0.08, 0.09], + extraStaticItem=True, + ) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.Dfsu1D, dfsFile.DfsuFileType) + Assert.AreEqual(5, dfsFile.NumberOfSigmaLayers) + Assert.AreEqual(0, dfsFile.SubMeshType) + Assert.AreEqual(0, dfsFile.NumberOfFrequencies) + dfsFile.Close() + + # / + # / Appending a time step to files with a 6-value custom block, including + # / legacy Spectral0D files, whose static items are read first. + # / + def test_AppendSubmeshTest(self): + frequencyOnly = "testdata/testtmp/test_DfsuSpectral0D_FrequencyOnly_Source.dfsu" + self.CreateSingleAxisSpectral0D( + frequencyOnly, + [6, 5, 1, 0, 5, 0], + eumQuantity(eumItem.eumIWaveFrequency, eumUnit.eumUhertz), + [0.05, 0.06, 0.07, 0.08, 0.09], + ) + for source, subMeshType in ( + ("testdata/submesh/Dfsu2D_CustomBlock6_Submesh1_LocallyRefined.dfsu", 1), + ("testdata/submesh/Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu", 0), + ("testdata/submesh/DfsuSpectral0D_CustomBlock6_Legacy.dfsu", None), + (frequencyOnly, None), + ): + filename = "testdata/testtmp/test_append_" + os.path.basename(source) + testUtil.copy_file(source, filename) + dfsFile = DfsuFile.OpenAppend(filename) + Assert.AreEqual(subMeshType, dfsFile.SubMeshType) + numberOfTimeSteps = dfsFile.NumberOfTimeSteps + for itemInfo in dfsFile.ItemInfo: + dfsFile.WriteItemTimeStepNext( + 0, np.ones(itemInfo.ElementCount, np.float32) + ) + dfsFile.Close() + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(numberOfTimeSteps + 1, dfsFile.NumberOfTimeSteps) + Assert.AreEqual(subMeshType, dfsFile.SubMeshType) + for itemNumber in range(1, len(dfsFile.ItemInfo) + 1): + assert_array_equal( + 1, dfsFile.ReadItemTimeStep(itemNumber, numberOfTimeSteps).Data + ) + dfsFile.Close() + + # / + # / A 3D sigma-z file with 7 values reads with the MIKE 2027 layout; + # / values from 7 on are ignored. + # / + def test_Read3DCustomBlock7Test(self): + filename = "testdata/testtmp/test_Dfsu3DSigmaZ_CustomBlock7.dfsu" + self.RewriteDfsu( + "testdata/submesh/Dfsu3DSigmaZ_CustomBlock6_Submesh0.dfsu", + filename, + customBlockValues=[30, 8, 3, 3, 1, 0, 0], + ) + self.SubmeshCustomBlockTester(filename, [30, 8, 3, 3, 1, 0, 0]) + dfsFile = DfsuFile.Open(filename) + Assert.AreEqual(DfsuFileType.Dfsu3DSigmaZ, dfsFile.DfsuFileType) + Assert.AreEqual(30, dfsFile.NumberOfNodes) + Assert.AreEqual(8, dfsFile.NumberOfElements) + Assert.AreEqual(3, dfsFile.NumberOfLayers) + Assert.AreEqual(1, dfsFile.NumberOfSigmaLayers) + Assert.AreEqual(0, dfsFile.SubMeshType) + Assert.AreEqual(0, dfsFile.NumberOfFrequencies) + Assert.AreEqual(0, dfsFile.NumberOfDirections) + Assert.AreEqual(8, dfsFile.ReadItemTimeStep(2, 0).Data.size) + dfsFile.Close() + + # / + # / Copies a dfsu file, optionally replacing its custom block values and + # / the quantity of static items by number. + # / + def RewriteDfsu( + self, sourcefilename, filename, customBlockValues=None, staticQuantities=None + ): + os.makedirs(os.path.dirname(filename), exist_ok=True) + source = DfsFileFactory.DfsGenericOpen(sourcefilename) + fileInfo = source.FileInfo + + builder = DfsBuilder.Create( + fileInfo.FileTitle, fileInfo.ApplicationTitle, fileInfo.ApplicationVersion + ) + builder.SetDataType(fileInfo.DataType) + builder.SetGeographicalProjection(fileInfo.Projection) + timeAxis = fileInfo.TimeAxis + assert timeAxis is not None + builder.SetTemporalAxis(timeAxis) + builder.DeleteValueFloat = fileInfo.DeleteValueFloat + customBlock = fileInfo.CustomBlocks[0] + if customBlockValues is None: + builder.AddCustomBlock(customBlock) + else: + builder.AddCreateCustomBlock( + customBlock.Name, np.array(customBlockValues, np.int32) + ) + for itemInfo in source.ItemInfo: + builder.AddDynamicItem(itemInfo) + builder.CreateFile(filename) + + staticItemNumber = 1 + staticItem = source.ReadStaticItemNext() + while staticItem is not None: + if staticQuantities and staticItemNumber in staticQuantities: + staticItem.Quantity = staticQuantities[staticItemNumber] + builder.AddStaticItem(staticItem) + staticItemNumber += 1 + staticItem = source.ReadStaticItemNext() + + file = builder.GetFile() + itemData = source.ReadItemTimeStepNext() + while itemData is not None: + file.WriteItemTimeStepNext(itemData.Time, itemData.Data) + itemData = source.ReadItemTimeStepNext() + source.Close() + file.Close() + + # / + # / Creates a legacy single-axis Spectral0D file (dimension 1, one node + # / more than elements) with the axis as static item 10, optionally + # / repeated as item 11. + # / + def CreateSingleAxisSpectral0D( + self, + filename, + customBlockValues, + axisQuantity, + axisValues, + extraStaticItem=False, + ): + os.makedirs(os.path.dirname(filename), exist_ok=True) + numberOfElements = len(axisValues) + numberOfNodes = numberOfElements + 1 + factory = DfsFactory() + builder = DfsBuilder.Create("Single axis Spectral0D", "MIKE Core Python", 1) + builder.SetDataType(2001) + builder.SetGeographicalProjection(factory.CreateProjection("LONG/LAT")) + builder.SetTemporalAxis(factory.CreateTemporalEqTimeAxis(eumUnit.eumUsec, 0, 1)) + builder.AddCreateCustomBlock("MIKE_FM", np.array(customBlockValues, np.int32)) + builder.AddCreateDynamicItem( + "Water level", + eumQuantity(eumItem.eumIWaterLevel, eumUnit.eumUmeter), + spatialAxis=factory.CreateAxisEqD1( + eumUnit.eumUmeter, numberOfElements, 0, 1 + ), + ) + builder.CreateFile(filename) + + intCode = eumQuantity(eumItem.eumIIntegerCode, eumUnit.eumUintCode) + xyQuantity = eumQuantity(eumItem.eumILatLong, eumUnit.eumUdegree) + nodeIds = np.arange(1, numberOfNodes + 1, dtype=np.int32) + elementIds = np.arange(1, numberOfElements + 1, dtype=np.int32) + builder.AddCreateStaticItem("Node id", intCode, nodeIds) + builder.AddCreateStaticItem( + "X-coord", xyQuantity, np.arange(numberOfNodes, dtype=np.float64) + ) + builder.AddCreateStaticItem( + "Y-coord", xyQuantity, np.zeros(numberOfNodes, np.float64) + ) + builder.AddCreateStaticItem( + "Z-coord", + eumQuantity(eumItem.eumIItemGeometry3D, eumUnit.eumUmeter), + np.full(numberOfNodes, -10, np.float32), + ) + builder.AddCreateStaticItem("Code", intCode, np.zeros(numberOfNodes, np.int32)) + builder.AddCreateStaticItem("Element id", intCode, elementIds) + builder.AddCreateStaticItem( + "Element type", intCode, np.full(numberOfElements, 11, np.int32) + ) + builder.AddCreateStaticItem( + "No of nodes", intCode, np.full(numberOfElements, 2, np.int32) + ) + builder.AddCreateStaticItem( + "Connectivity", + intCode, + np.column_stack([elementIds, elementIds + 1]).ravel().astype(np.int32), + ) + builder.AddCreateStaticItem( + "Axis", axisQuantity, np.array(axisValues, np.float32) + ) + if extraStaticItem: + builder.AddCreateStaticItem( + "Extra", axisQuantity, np.array(axisValues, np.float32) + ) + + file = builder.GetFile() + file.WriteItemTimeStepNext(0, np.ones(numberOfElements, np.float32)) + file.Close() + + # / + # / Checks the custom block values, read as a generic dfs file. + # / + def SubmeshCustomBlockTester(self, filename, expectedValues): + dfsFile = DfsFileFactory.DfsGenericOpen(filename) + fileInfo = dfsFile.FileInfo + Assert.AreEqual(2001, fileInfo.DataType) + Assert.AreEqual(1, len(fileInfo.CustomBlocks)) + customBlock = fileInfo.CustomBlocks[0] + Assert.AreEqual(DfsSimpleType.Int, customBlock.SimpleType) + Assert.AreEqual("MIKE_FM", customBlock.Name) + Assert.AreEqual(len(expectedValues), customBlock.Count) + for i in range(customBlock.Count): + Assert.AreEqual(expectedValues[i], customBlock[i]) + + dfsFile.Close() + + # endregion + def CreateDfsu3DFromSource(self, sourcefilename, filename): source = DfsuFile.Open(sourcefilename)