frd2vtu 0.1.0__tar.gz

frd2vtu-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 wr1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frd2vtu-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: frd2vtu
+Version: 0.1.0
+Summary: converter from calculix frd to vtu
+License: MIT
+Author: wr1
+Author-email: 8971152+wr1@users.noreply.github.com
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: fire (>=0.6.0,<0.7.0)
+Requires-Dist: numpy (==1.26.4)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: pyvista (>=0.44.1,<0.45.0)
+Requires-Dist: vtk (>=9.3.1,<10.0.0)
+Description-Content-Type: text/markdown
+
+
+
+# frd converter

frd2vtu-0.1.0/README.md

@@ -0,0 +1,3 @@
+
+
+# frd converter

frd2vtu-0.1.0/frd2vtu/frd2vtu.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python
+import numpy as np
+import re
+import pyvista as pv
+import vtk
+import fire
+import time
+import pandas as pd
+import multiprocessing
+
+
+e2nn = {
+    1: 8,
+    2: 6,
+    3: 4,
+    5: 15,
+    6: 10,
+    4: 20,
+    7: 3,
+    8: 6,
+    9: 4,
+    10: 8,
+    12: 3,
+    11: 2,
+}
+
+
+def split_blocks(buf):
+    patterns = [
+        b"    2C(.*?)3\n",
+        b"    3C(.*?)\n",
+        b"    1PSTEP(.*?)\n",
+        b"1ALL\n",
+        b"3    1\n",
+        b"0    0\n",
+        b" 9999",
+    ]
+
+    out = [
+        [(m.start(), m.end(), m[0]) for m in re.finditer(pattern, buf)]
+        for pattern in patterns
+    ]
+    if out[0] == []:
+        print(f"frd format not binary")
+        return None
+
+    # out = [i for i in out if i != []]
+    # out.sort(key=lambda x: x[0][0])
+    return out
+
+
+def frdbin2vtu(file_path):
+    starttime = time.time()
+    print(f"Converting {file_path}")
+    buf = open(file_path, "rb").read()
+    lcs = split_blocks(buf)
+    if lcs is None:
+        return None
+
+    nodes = pd.DataFrame(
+        np.frombuffer(
+            buf[lcs[0][0][1] : lcs[1][0][0]],
+            dtype=np.dtype([("i", "i4"), ("x", "f8"), ("y", "f8"), ("z", "f8")]),
+        )
+    )
+
+    # print(nodes)
+
+    elm = np.frombuffer(
+        buf[lcs[1][0][1] : lcs[2][0][0]],
+        dtype=np.dtype("i4"),
+    )
+    nz = np.zeros(nodes["i"].max() + 1, dtype=int)
+
+    nz[nodes["i"]] = np.arange(len(nodes))
+
+    els, nn = {}, 0
+    eid, emat = [], []
+    while True:
+        if nn >= len(elm):
+            break
+
+        nid = elm[1 + nn]
+
+        # print(elm)
+        ni = e2nn[nid]
+        elmarr = elm[0 + nn : ni + 4 + nn]
+        eid.append(elmarr[0])
+        emat.append(elmarr[3])
+        # deal with 20 node hexahedron
+        if nid == 4:
+            if vtk.VTK_QUADRATIC_HEXAHEDRON not in els:
+                els[vtk.VTK_QUADRATIC_HEXAHEDRON] = []
+            e = elmarr[4:].tolist()
+            els[vtk.VTK_QUADRATIC_HEXAHEDRON].append(nz[e[:12] + e[16:] + e[12:16]])
+            nn += 24
+        elif nid == 1:
+            if vtk.VTK_HEXAHEDRON not in els:
+                els[vtk.VTK_HEXAHEDRON] = []
+            e = elmarr[4:].tolist()
+            els[vtk.VTK_HEXAHEDRON].append(nz[e[:8]])
+            nn += 12
+        elif nid == 11:
+            if vtk.VTK_LINE not in els:
+                els[vtk.VTK_LINE] = []
+            e = elmarr[4:].tolist()
+            els[vtk.VTK_LINE].append(nz[e[:2]])
+            nn += 6
+        elif nid == 12:
+            if vtk.VTK_QUADRATIC_EDGE not in els:
+                els[vtk.VTK_QUADRATIC_EDGE] = []
+            e = elmarr[4:].tolist()
+            els[vtk.VTK_QUADRATIC_EDGE].append(nz[e[:3]])
+            nn += 7
+        elif nid == 10:
+            if vtk.VTK_QUADRATIC_QUAD not in els:
+                els[vtk.VTK_QUADRATIC_QUAD] = []
+            e = elmarr[4:].tolist()
+            els[vtk.VTK_QUADRATIC_QUAD].append(nz[e[:8]])
+            nn += 12
+        elif nid == 6:
+            if vtk.VTK_QUADRATIC_TETRA not in els:
+                els[vtk.VTK_QUADRATIC_TETRA] = []
+            e = elmarr[4:].tolist()
+            els[vtk.VTK_QUADRATIC_TETRA].append(nz[e[:10]])
+            nn += 14
+        elif nid == 9:
+            if vtk.VTK_QUAD not in els:
+                els[vtk.VTK_QUAD] = []
+            e = elmarr[4:].tolist()
+            els[vtk.VTK_QUAD].append(nz[e[:4]])
+            nn += 8
+        else:
+            print(f"Unknown element type: {nid}")
+            break
+
+    # convert list of lists to numpy arrays
+    for i in els:
+        els[i] = np.array(els[i])
+
+    ogrid = pv.UnstructuredGrid(els, nodes[["x", "y", "z"]].values)
+
+    ogrid.cell_data["ccx_id"] = np.array(eid)
+    ogrid.cell_data["ccx_mat"] = np.array(emat)
+
+    ogrid.point_data["ccx_id"] = nodes["i"]
+
+    endblocks = lcs[3] + lcs[4] + lcs[5]  #  if len(lcs) > 4 else lcs[3] + lcs[4]
+
+    endblocks.sort(key=lambda x: x[0])
+
+    # print(len(lcs[2]), len(endblocks))
+
+    headers = [buf[j[0][0] : j[1][1]] for j in zip(lcs[2], endblocks)]
+
+    # print(headers)
+
+    for n, bl in enumerate(headers):
+        # print(f"Block {bl}", "\n" * 5)
+
+        lns = bl.decode("ascii").split("\n")
+
+        if bl.find(b"MODAL") != -1 and bl.find(b"DISP") != -1:
+            # fix for modal analysis
+            # print("true")
+            lns = lns[5:]
+            # print(lns)
+
+        timestamp, nn = lns[1].split()[2:4]
+        name = lns[2].split()[1]
+
+        if name in ["NORM", "SENMISE", "SENPS1", "SDV"]:
+            continue
+
+        ncomp = int(lns[2].split()[2])
+        print(f"timestamp: {timestamp}, nn: {nn}, name: {name}")
+
+        # set the start of the binary block to the end of the ascii block
+        startblock = endblocks[n][1]
+
+        # print(ncomp)
+        ncl = {6: 6, 4: 3, 1: 1, 20: 20}
+
+        nms = [("c_" + str(i), "f4") for i in range(ncl[ncomp])]
+        dt = np.dtype([("id", "i4")] + nms)
+
+        endblock = dt.itemsize * int(nn) + startblock
+
+        na = pd.DataFrame(np.frombuffer(buf[startblock:endblock], dtype=dt))
+
+        # print(len(na), len(nodes))
+        if len(na) != len(nodes):
+            missing_values = nodes[~nodes["i"].isin(na["id"])]["i"]
+            padding = pd.DataFrame({"id": missing_values})
+            for col in na.columns:
+                if col != "id":
+                    padding[col] = 0
+
+            na = pd.concat([na, padding], ignore_index=True)
+
+        arrn = f"{name}_{timestamp}"
+        # if name not in ["PE"]:
+        ogrid.point_data[arrn] = na[[i[0] for i in nms]].values
+
+    of = file_path.replace(".frd", ".vtu")
+    # ogrid.save(of, binary=False)
+    ogrid.save(of)
+    print(f"Saved {of}")
+    endtime = time.time()
+    print(f"Elapsed time: {endtime - starttime} seconds")
+
+
+def frd2vtu(*frd):
+    parr = True
+    if parr:
+        p = multiprocessing.Pool()
+        p.map(frdbin2vtu, frd)
+        p.close()
+    else:
+        for f in frd:
+            frdbin2vtu(f)
+
+
+def main():
+    fire.Fire(frd2vtu)
+
+
+if __name__ == "__main__":
+    main()

frd2vtu-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "frd2vtu"
+version = "0.1.0"
+description = "converter from calculix frd to vtu"
+authors = ["wr1 <8971152+wr1@users.noreply.github.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+fire = "^0.6.0"
+pyvista = "^0.44.1"
+vtk = "^9.3.1"
+pandas = "^2.2.2"
+numpy = "1.26.4"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry.scripts]
+frd2vtu = "frd2vtu.frd2vtu:main"