solidipes-solid-mech-plugin 0.0.1__tar.gz

solidipes_solid_mech_plugin-0.0.1/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: solidipes-solid-mech-plugin
+Version: 0.0.1
+Summary: Plugin for Solidipes with solid mechanics components
+License: GPL-3.0-or-later
+Author: Son Pham-Ba
+Author-email: son.phamba@epfl.ch
+Requires-Python: >=3.9.12,<3.13
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: dev
+Provides-Extra: test
+Requires-Dist: build (>=1.0.3,<2.0.0) ; extra == "dev"
+Requires-Dist: ipython (>=8.18.1,<9.0.0)
+Requires-Dist: pre-commit (>=3.0.4,<4.0.0) ; extra == "dev"
+Requires-Dist: pytest (>=8.1.1,<9.0.0) ; extra == "dev" or extra == "test"
+Requires-Dist: pyvista (>=0.43.3,<0.44.0)
+Requires-Dist: solidipes (>=1.0.1)
+Requires-Dist: solidipes-core-plugin (>=0.0.2)
+Requires-Dist: streamlit (>=1.37.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+Plugin for Solidipes with solid mechanics components.
+
+Meant to be used with [Solidipes](https://gitlab.com/solidipes/solidipes).
+
+
+# Installation for development
+
+```bash
+git clone https://gitlab.com/solidipes/solidipes-solid-mech-plugin.git
+cd solidipes-solid-mech-plugin
+pip install -e .[dev]
+pre-commit install
+```
+

solidipes_solid_mech_plugin-0.0.1/README.md

@@ -0,0 +1,13 @@
+Plugin for Solidipes with solid mechanics components.
+
+Meant to be used with [Solidipes](https://gitlab.com/solidipes/solidipes).
+
+
+# Installation for development
+
+```bash
+git clone https://gitlab.com/solidipes/solidipes-solid-mech-plugin.git
+cd solidipes-solid-mech-plugin
+pip install -e .[dev]
+pre-commit install
+```

solidipes_solid_mech_plugin-0.0.1/pyproject.toml

@@ -0,0 +1,60 @@
+[tool.poetry]
+name = "solidipes-solid-mech-plugin"
+version = "0.0.1"
+description = "Plugin for Solidipes with solid mechanics components"
+authors = [
+	"Son Pham-Ba <son.phamba@epfl.ch>",
+	"Guillaume Anciaux <guillaume.anciaux@epfl.ch>",
+]
+license = "GPL-3.0-or-later"
+readme = "README.md"
+packages = [{include = "solidipes_solid_mech_plugin"}]
+
+[tool.poetry.dependencies]
+python = "^3.9.12,<3.13"
+solidipes = ">=1.0.1"
+solidipes-core-plugin = ">=0.0.2"
+streamlit = "^1.37.0"
+ipython = "^8.18.1"
+pyvista = "^0.43.3"
+pre-commit = {version = "^3.0.4", optional = true}
+build = {version = ">=1.0.3,<2.0.0", optional = true}
+pytest = {version = "^8.1.1", optional = true}
+
+[tool.poetry.extras]
+dev = [
+    "pre-commit",
+	"build",
+	"pytest",
+]
+test = [
+	"pytest",
+]
+
+[tool.poetry.plugins."solidipes.plugins"]
+solid-mech = "solidipes_solid_mech_plugin"
+
+[build-system]
+requires = ["poetry-core", "poetry-dynamic-versioning"]
+build-backend = "poetry_dynamic_versioning.backend"
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+style = "semver"
+
+[tool.poetry-dynamic-versioning.substitution]
+files = [
+	"solidipes_solid_mech_plugin/__init__.py",
+]
+
+[tool.black]
+line-length = 120
+preview = true
+
+[tool.isort]
+line_length = 120
+profile = "black"
+
+[tool.codespell]
+skip = 'poetry.lock,CHANGELOG.md'

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/__init__.py

@@ -0,0 +1,3 @@
+"""Plugin for Solidipes with solid mechanics components"""
+
+__version__ = "0.0.1"

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/loaders/abaqus.py

@@ -0,0 +1,182 @@
+from io import StringIO
+
+import mergedeep
+import meshio
+import numpy as np
+import pandas as pd
+import pyparsing as pp
+from solidipes_core_plugin.loaders.code_snippet import CodeSnippet
+
+
+class ParseAbaqus:
+    _valid_characters = " " + pp.printables
+    _valid_characters = _valid_characters.replace("*", "")
+    ppText = pp.Word(_valid_characters + "\n")
+    ppHead = pp.Word(_valid_characters.replace(",", ""))
+
+    def parseComments(self, toks):
+        cs = [e.strip() for e in toks if e.strip() != ""]
+        if cs:
+            return {"Comment": cs}
+        return None
+
+    comments = pp.OneOrMore(pp.Suppress(pp.Literal("**")) + ppText).addParseAction(parseComments)
+
+    def parseData(self, toks):
+        name = toks[0]
+        data = toks[2].strip()
+        params = [e.strip() for e in toks[1]]
+        res = {}
+        if params:
+            res[":".join(params)] = {"data": data, "@params": params}
+        else:
+            res["data"] = data
+
+        return {name: res}
+
+    def _tag(self, name):
+        return (
+            pp.Suppress(pp.Literal("*"))
+            + name
+            + pp.Group(pp.ZeroOrMore(pp.Suppress(pp.Literal(",")) + self.ppHead))
+            + pp.Suppress(pp.Optional(pp.Literal("\n")))
+        )
+
+    def _data(self, name):
+        return (self._tag(name) + pp.Combine(pp.ZeroOrMore(self.ppText))).addParseAction(self.parseData)
+
+    def parseTag(self, toks):
+        name = toks[0]
+        params = [e.strip() for e in toks[1]]
+        res = {}
+        res[name] = {}
+        for e in toks[2:]:
+            if isinstance(e, str):
+                e = e.strip()
+                if e == "":
+                    continue
+            if isinstance(e, dict):
+                res[name] = mergedeep.merge(res[name], e)
+        # print('aaa', res, conv)
+        if params:
+            res[name]["@params"] = params
+
+        return res
+
+    def _heading(self):
+        _heading = self._tag("Heading") + self.comments()
+        return _heading.addParseAction(self.parseTag)
+
+    def _paragraph(self, name):
+        return self._tag(name) + pp.ZeroOrMore(self.ppText | self.comments())
+
+    def _block(self, name):
+        stag = name
+        etag = "End " + stag
+
+        _block_start = self._tag(stag)
+        _block_content = pp.Forward()
+        _block_end = self._tag(etag)
+        _block = _block_start + _block_content + pp.Suppress(_block_end)
+        _block_content << pp.ZeroOrMore(
+            self._data("Node")
+            | self._data("Element")
+            | self._data("Nset")
+            | self._data("Elset")
+            | self._data("Equation")
+            | self._data("Surface")
+            | self._data("Solid Section")
+            | self.comments()
+        )
+        return _block.addParseAction(self.parseTag)
+
+    def inp_file(self):
+        _file = (
+            self._heading()
+            + pp.Optional(self._tag("Preprint").addParseAction(self.parseTag))
+            + pp.ZeroOrMore(self.comments | self._block("Part"))
+        )
+        _file = _file.leaveWhitespace().addParseAction(
+            lambda toks: {"main": [e for e in toks if (not isinstance(e, str) or e.strip() != "")]}
+        )
+        return _file
+
+    def parse(self, filename):
+        to_parse = open(filename).read()
+        ret = self.inp_file().parseString(to_parse)
+        return ret
+
+
+################################################################
+
+
+class Abaqus(CodeSnippet):
+    supported_mime_types = {"application/fem/abaqus": "inp"}
+
+    def __init__(self, **kwargs):
+        from solidipes_core_plugin.viewers.xml import XML
+
+        from ..viewers.pyvista_plotter import PyvistaPlotter
+
+        super().__init__(**kwargs)
+        self.compatible_viewers[:0] = [PyvistaPlotter, XML]
+
+    @CodeSnippet.loadable
+    def structure(self):
+        try:
+            parser = ParseAbaqus()
+            ret = parser.parse(self.file_info.path)
+            return ret[0]
+        except Exception as e:
+            print(e)
+
+    @property
+    def xml(self):
+        return self.structure
+
+    @property
+    def parts(self):
+        return [e["Part"] for e in self.xml["main"] if "Part" in e]
+
+    def nodes(self, part):
+        p = self.parts[part]
+        if "Node" in p:
+            df = pd.read_csv(StringIO(p["Node"]["data"]), sep=",", header=None)
+            return df.to_numpy()[:, 1:]
+
+    def elements(self, part):
+        p = self.parts[part]
+        cells = []
+        if "Element" in p:
+            for _type, v in p["Element"].items():
+                if _type.startswith("type="):
+                    _type = _type[5:]
+                if _type == "CPE4":
+                    _type = "quad"
+                elif _type == "CPE3":
+                    _type = "triangle"
+                else:
+                    print(f"Do not know element type {_type}")
+                    raise RuntimeError(f"Do not know element type {_type}")
+                conn = pd.read_csv(StringIO(v["data"]), sep=",", header=None).to_numpy()[:, 1:] - 1
+                cells.append((_type, np.array(conn)))
+            return cells
+
+    @CodeSnippet.loadable
+    def meshes(self):
+        import pyvista as pv
+
+        meshes = {}
+        for p, part in enumerate(self.parts):
+            mesh = meshio.Mesh(self.nodes(p), self.elements(p))
+            mesh = pv.from_meshio(mesh)
+            params = part["@params"]
+            for param in params:
+                if param.startswith("name="):
+                    param = param[5:]
+                    meshes[param] = mesh
+        return meshes
+
+    @property
+    def mesh(self):
+        return [v for k, v in self.meshes.items()][0]

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/loaders/geof_mesh.py

@@ -0,0 +1,14 @@
+from .parse_inp import read_geof
+from .pyvista_mesh import PyvistaMesh
+
+
+class GeofMesh(PyvistaMesh):
+    """Mesh file loaded with pyvista"""
+
+    supported_mime_types = {"meshing/z-set": "geof"}
+
+    @PyvistaMesh.loadable
+    def mesh(self):
+        from pyvista.core.utilities import from_meshio
+
+        return from_meshio(read_geof(self.file_info.path))

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/loaders/meshio.py

@@ -0,0 +1,17 @@
+from solidipes.loaders.file import File
+
+
+class Meshio(File):
+    """File loaded with meshio"""
+
+    def __init__(self, **kwargs):
+        from ..viewers.pyvista_plotter import PyvistaPlotter
+
+        super().__init__(**kwargs)
+        self.compatible_viewers[:0] = [PyvistaPlotter]
+
+    @File.loadable
+    def mesh(self):
+        import meshio
+
+        return meshio.read(self.file_info.path)

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/loaders/parse_inp.py

@@ -0,0 +1,221 @@
+import meshio
+import numpy as np
+import pyparsing as pp
+from solidipes.utils import solidipes_logging as logging
+
+print = logging.invalidPrint
+logger = logging.getLogger()
+
+################################################################
+abaqus_to_meshio_permutation = {
+    "C3D10": {0: 0, 1: 1, 2: 2, 3: 9, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7, 9: 8},
+    "C3D10_4": {0: 0, 1: 1, 2: 2, 3: 9, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7, 9: 8},
+    "C3D10R": {0: 0, 1: 1, 2: 2, 3: 9, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7, 9: 8},
+}
+################################################################
+abaqus_to_meshio_type = {
+    # trusses
+    "T2D2": "line",
+    "T2D2H": "line",
+    "T2D3": "line3",
+    "T2D3H": "line3",
+    "T3D2": "line",
+    "T3D2H": "line",
+    "T3D3": "line3",
+    "T3D3H": "line3",
+    # beams
+    "B21": "line",
+    "B21H": "line",
+    "B22": "line3",
+    "B22H": "line3",
+    "B31": "line",
+    "B31H": "line",
+    "B32": "line3",
+    "B32H": "line3",
+    "B33": "line3",
+    "B33H": "line3",
+    # surfaces
+    "CPS4": "quad",
+    "CPS4R": "quad",
+    "S4": "quad",
+    "S4R": "quad",
+    "S4RS": "quad",
+    "S4RSW": "quad",
+    "S4R5": "quad",
+    "S8R": "quad8",
+    "S8R5": "quad8",
+    "S9R5": "quad9",
+    # "QUAD": "quad",
+    # "QUAD4": "quad",
+    # "QUAD5": "quad5",
+    # "QUAD8": "quad8",
+    # "QUAD9": "quad9",
+    #
+    "CPS3": "triangle",
+    "STRI3": "triangle",
+    "S3": "triangle",
+    "S3R": "triangle",
+    "S3RS": "triangle",
+    "R3D3": "triangle",
+    # "TRI7": "triangle7",
+    # 'TRISHELL': 'triangle',
+    # 'TRISHELL3': 'triangle',
+    # 'TRISHELL7': 'triangle',
+    #
+    "STRI65": "triangle6",
+    # 'TRISHELL6': 'triangle6',
+    # volumes
+    "C3D8": "hexahedron",
+    "C3D8H": "hexahedron",
+    "C3D8I": "hexahedron",
+    "C3D8IH": "hexahedron",
+    "C3D8R": "hexahedron",
+    "C3D8RH": "hexahedron",
+    # "HEX9": "hexahedron9",
+    "C3D20": "hexahedron20",
+    "C3D20H": "hexahedron20",
+    "C3D20R": "hexahedron20",
+    "C3D20RH": "hexahedron20",
+    # "HEX27": "hexahedron27",
+    #
+    "C3D4": "tetra",
+    "C3D4H": "tetra4",
+    # "TETRA8": "tetra8",
+    "C3D10": "tetra10",
+    "C3D10_4": "tetra10",
+    "C3D10R": "tetra10",
+    "C3D10H": "tetra10",
+    "C3D10I": "tetra10",
+    "C3D10M": "tetra10",
+    "C3D10MH": "tetra10",
+    # "TETRA14": "tetra14",
+    #
+    # "PYRAMID": "pyramid",
+    "C3D6": "wedge",
+    "C3D15": "wedge15",
+    #
+    # 4-node bilinear displacement and pore pressure
+    "CAX4P": "quad",
+    # 6-node quadratic
+    "CPE6": "triangle6",
+}
+
+################################################################
+
+
+class ParseINP:
+    _valid_characters = "\n " + pp.printables
+    _valid_characters = _valid_characters.replace("*", "")
+    ppText = pp.Word(_valid_characters)
+
+    def parseBlock(self, token, level=None, content=None, tokens=None):
+        # print(f"detected: {token} ({level}) {type(content)} {len(content)}")
+        pass
+
+    def _parseBlock(self, tokens):
+        return self.parseBlock(
+            tokens[1],
+            level=len(tokens[0]),
+            content=tokens[2].strip(),
+            tokens=tokens,
+        )
+
+    def paragraph(self, n):
+        if n == 0:
+            return self.ppText
+        _block_start = pp.Literal("*" * n) + pp.Word(pp.alphas)
+        _block_content = pp.Combine(pp.ZeroOrMore(self.ppText | self.paragraph(n - 1)))
+        _block = _block_start + _block_content
+        _block.leaveWhitespace()
+        _block.addParseAction(lambda toks: self._parseBlock(toks))
+
+        return _block
+
+    def inp_file(self):
+        _p = self.paragraph(4) | self.paragraph(3) | self.paragraph(2) | self.paragraph(1)
+        _file = pp.Combine(pp.OneOrMore(_p).leaveWhitespace())
+        _file.addParseAction(lambda toks: self.final_parse(toks))
+        return _file
+
+    def final_parse(self, toks):
+        pass
+
+    def parse(self, filename):
+        to_parse = open(filename).read()
+        self.inp_file().parseString(to_parse)
+
+
+################################################################
+
+
+class ParseGEOF(ParseINP):
+    def parseBlock(self, token, level=None, content=None, tokens=None):
+        if token == "node":
+            # print(f'{"*"*level}detected {token}')
+            content = content.split("\n")
+            n_nodes, dim = content[0].split()
+            n_nodes = int(n_nodes)
+            dim = int(dim)
+            values = [_l.split() for _l in content[1:]]
+            nodes = np.array(values, dtype=float)
+            assert nodes.shape[0] == n_nodes
+            assert nodes.shape[1] == dim + 1
+            logger.info(f"Loaded {n_nodes} nodes")
+            self.nodes = nodes
+            return "nodes:ok\n"
+        if token == "element":
+            # print(f'{"*"*level}detected {token}')
+            content = content.split("\n")
+            n_elements = int(content[0])
+            values = [_l.split() for _l in content[1:]]
+            values = np.array(values)
+            el_type = np.array(values[:, 1], dtype=str)
+            connectivity = np.array(values[:, 2:], dtype=int) - 1
+            # print(connectivity)
+            self.cells = {}
+            for e, _type in enumerate(el_type):
+                aba_type = _type.upper()
+                _type = abaqus_to_meshio_type[aba_type]
+                if _type not in self.cells:
+                    self.cells[_type] = []
+
+                perm = abaqus_to_meshio_permutation[aba_type]
+                self.cells[_type].append(connectivity[e, :])
+
+            for _type, conn in self.cells.items():
+                permuted = np.zeros_like(conn)
+
+                for i, ii in perm.items():
+                    permuted[:, i] = connectivity[:, ii]
+                self.cells[_type] = permuted
+            # print(self.cells)
+            logger.info(f"Loaded {n_elements} elements")
+            assert n_elements == connectivity.shape[0]
+            return "elements:ok\n"
+        if token == "geometry":
+            # print(f'{"*"*level}detected {token}')
+            # print(content)
+            return content
+        if token == "return":
+            return content
+        # print(f'{"*"*level}ignored {token}')
+        return f'{"*"*level}ignored {token}'
+
+    def final_parse(self, toks):
+        points = self.nodes[:, 1:]
+        cells = [(_type, c) for _type, c in self.cells.items()]
+        self.mesh = meshio.Mesh(points, cells)
+        return "mesh ok\n"
+
+
+################################################################
+
+
+def read_geof(filename):
+    parser = ParseGEOF()
+    parser.parse(filename)
+    # print(parser.mesh)
+    # parser.mesh.write("foo.vtu", file_format='vtu')
+    # parser.mesh.write("foo.vtk", file_format='vtk')
+    # parser.mesh.write("foo.msh", file_format='gmsh')
+    return parser.mesh

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/loaders/pyvista_mesh.py

@@ -0,0 +1,163 @@
+from functools import wraps
+
+import pyvista as pv
+from solidipes.loaders.file import File
+
+DEFAULT_DATA_ID = "_"  #: data name given to implicitly added arrays
+POINT_DATA_SUFFIX = " (point data)"
+CELL_DATA_SUFFIX = " (cell data)"
+
+
+def get_point_data_from_id_or_array(func):
+    """Decorator to give either data_id or array to method accepting data_id"""
+
+    @wraps(func)
+    def wrapper(self, data_id_or_array, *args, **kwargs):
+        if isinstance(data_id_or_array, str):
+            data_id = data_id_or_array
+            if data_id not in self.point_data_names:
+                raise ValueError(f'No point data entry with the name "{data_id}" exists.')
+
+        else:
+            data_id = DEFAULT_DATA_ID
+            self.add_point_data(data_id_or_array, data_id)
+
+        return func(self, data_id, *args, **kwargs)
+
+    return wrapper
+
+
+def get_cell_data_from_id_or_array(func):
+    """Decorator to give either data_id or array to method accepting data_id"""
+
+    @wraps(func)
+    def wrapper(self, data_id_or_array, *args, **kwargs):
+        if isinstance(data_id_or_array, str):
+            data_id = data_id_or_array
+            if data_id not in self.cell_data_names:
+                raise ValueError(f'No cell data entry with the name "{data_id}" exists.')
+
+        else:
+            data_id = DEFAULT_DATA_ID
+            self.add_cell_data(data_id_or_array, data_id)
+
+        return func(self, data_id, *args, **kwargs)
+
+    return wrapper
+
+
+class PyvistaMesh(File):
+    """Mesh file loaded with pyvista"""
+
+    supported_mime_types = {
+        "meshing/GMSH": "msh",
+        "meshing/StepFile": "stl",
+        "meshing/VTK": ["vtu", "pvtu", "vtk"],
+        "meshing/AVS": "avs",
+    }
+
+    def __init__(self, **kwargs):
+        from ..viewers.pyvista_plotter import PyvistaPlotter
+
+        super().__init__(**kwargs)
+        #: Fully loaded pyvista mesh
+        self.compatible_viewers[:0] = [PyvistaPlotter]
+
+    def copy_pyvista_data_to_collection(self):
+        """Add pyvista data to data collection"""
+        for name in self.point_data_names:
+            self.add(name + POINT_DATA_SUFFIX, self.get_point_data(name))
+
+        for name in self.cell_data_names:
+            self.add(name + CELL_DATA_SUFFIX, self.get_cell_data(name))
+
+    @property
+    def data_info(self):
+        """Trigger loading of Pyvista mesh and return info"""
+        self.load_all()
+        return super().data_info
+
+    @File.loadable
+    def pyvista_mesh(self):
+        return pv.read(self.file_info.path)
+
+    @File.loadable
+    def mesh(self):
+        self.copy_pyvista_data_to_collection()
+        return self.pyvista_mesh
+
+    @property
+    def point_data_names(self):
+        return self.pyvista_mesh.point_data.keys()
+
+    @property
+    def cell_data_names(self):
+        return self.pyvista_mesh.cell_data.keys()
+
+    def get_point_data(self, name):
+        return self.pyvista_mesh.point_data.get_array(name)
+
+    def add_point_data(self, array, name):
+        self.pyvista_mesh.point_data.set_array(array, name)
+        self.add(name + POINT_DATA_SUFFIX, array)
+
+    def remove_point_data(self, name):
+        self.pyvista_mesh.point_data.remove(name)
+        self.remove(name + POINT_DATA_SUFFIX)
+
+    def get_cell_data(self, name):
+        return self.pyvista_mesh.cell_data.get_array(name)
+
+    def add_cell_data(self, array, name):
+        self.pyvista_mesh.cell_data.set_array(array, name)
+        self.add(name + CELL_DATA_SUFFIX, array)
+
+    def remove_cell_data(self, name):
+        self.pyvista_mesh.cell_data.remove(name)
+        self.remove(name + CELL_DATA_SUFFIX)
+
+    @get_point_data_from_id_or_array
+    def get_warped(self, data_id, factor=1.0):
+        """
+        Returns another PyvistaMesh with the mesh points displaced by the
+        given data.
+
+        Args:
+            data (string): Name of point data. If data is 1D, the mesh is
+                warped along its normals. Otherwise, the data must have the
+                same number dimensionality as the mesh.
+            factor (float): Factor to multiply the displacements by. Defaults
+                to 1.0.
+        """
+        new_mesh = self.copy()
+        dim = self.get_point_data(data_id).ndim  # 1 if scalar, 2 if vector
+        if dim == 1:
+            new_pyvista_mesh = new_mesh.pyvista_mesh.warp_by_scalar(data_id, factor=factor)
+
+        else:
+            new_pyvista_mesh = new_mesh.pyvista_mesh.warp_by_vector(data_id, factor=factor)
+
+        new_mesh.pyvista_mesh = new_pyvista_mesh
+        new_mesh.copy_pyvista_data_to_collection()
+
+        return new_mesh
+
+    @get_point_data_from_id_or_array
+    def set_point_values(self, data_id):
+        """
+        Sets the point values for plotting to the given data.
+
+        Args:
+            data (string): Name of point data.
+        """
+        self.pyvista_mesh.set_active_scalars(data_id, "point")
+
+    @get_cell_data_from_id_or_array
+    def set_cell_values(self, data_id):
+        """
+        Sets the cell values for plotting to the given data.
+
+        Args:
+            data (string): Name of cell data.
+        """
+        self.pyvista_mesh.set_active_scalars(data_id, "cell")

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/loaders/xdmf.py

@@ -0,0 +1,170 @@
+import os
+
+import h5py
+import numpy as np
+from solidipes.loaders.sequence import Sequence
+from solidipes_core_plugin.loaders.xml import XML
+
+
+class XDMF(Sequence, XML):
+    supported_mime_types = {"mesh/XDMF": "xdmf"}
+
+    def __init__(self, **kwargs):
+        from ..viewers.pyvista_plotter import PyvistaPlotter
+
+        super().__init__(**kwargs)
+        self.compatible_viewers[:0] = [PyvistaPlotter]
+
+    def _load_hdf5_data_item(self, item):
+        if item["@Format"] == "HDF":
+            dimensions = item["@Dimensions"]
+            dimensions = [int(e) for e in dimensions.split(" ")]
+            path, hdf5_path = item["#text"].split(":")
+            path = os.path.join(os.path.dirname(self.path), path)
+            h5 = h5py.File(path)
+            h5 = h5[hdf5_path]
+            h5 = np.array(h5).reshape(dimensions)
+            return h5
+        if item["@Format"] == "XML":
+            return [float(e) for e in item["#text"].split(" ")]
+        return item
+
+    def _load_xdmf_data_item(self, item):
+        if isinstance(item, dict):
+            res = {}
+            for k, v in item.items():
+                if k == "DataItem":
+                    # print(f'LoadasDataItem: {k} {v}\n')
+                    res[k] = self._load_hdf5_data_item(v)
+                else:
+                    res[k] = self._load_xdmf_data_item(v)
+            return res
+        if isinstance(item, list) and not isinstance(item, str):
+            return [self._load_xdmf_data_item(e) for e in item]
+        return item
+
+    def find_dataitem_from_ref(self, ref):
+        ref = [e for e in ref.split("/") if e != "" and e != "Xdmf"]
+        print(ref)
+
+        def extract_label(r):
+            try:
+                name, label = r.split("[")
+                label = label[:-1]
+                label = label.replace(r'"', "")
+                label = label.split("=")
+                return name, label
+            except ValueError:
+                return r, None
+
+        res = self.xdmf
+        for r in ref:
+            name, label = extract_label(r)
+            # print(name, label)
+            res = res[name]
+            if isinstance(res, list):
+                for r in res:
+                    if r[label[0]] != label[1]:
+                        continue
+                    res = r
+                    break
+            # print(res.keys())
+            if label is None:
+                # print(res)
+                continue
+
+            if label[0] not in res:
+                raise RuntimeError(f"Cannot find {name} {label} in {ref}")
+            if res[label[0]] != label[1]:
+                raise RuntimeError(f"Cannot find {name} {label} in {ref}")
+        return res
+
+    def _load_element(self, n):
+        """Load a single frame"""
+
+        grids = self.grids[n]
+        geometry = grids["Geometry"]
+        topology = grids["Topology"]
+
+        if "DataItem" in geometry:
+            geometry = geometry["DataItem"]
+        elif "@Reference" in geometry:
+            ref = geometry["#text"]
+            geometry = self.find_dataitem_from_ref(ref)["DataItem"]
+
+        points = np.array(geometry)
+
+        if "DataItem" in topology:
+            conn = topology["DataItem"]
+        elif "@Reference" in topology:
+            ref = topology["#text"]
+            conn = self.find_dataitem_from_ref(ref)["DataItem"]
+
+        cells = [(topology["@TopologyType"].lower(), np.array(conn))]
+
+        point_data = {}
+        cell_data = {}
+
+        if "Attribute" in grids:
+            for a in grids["Attribute"]:
+                # _type = a['@AttributeType']
+                _center = a["@Center"]
+                _name = a["@Name"]
+                _data = a["DataItem"]
+                if _center == "Node":
+                    point_data[_name] = np.array(_data)
+                if _center == "Cell":
+                    cell_data[_name] = np.array([_data])
+        import meshio
+
+        mesh = meshio.Mesh(points, cells, point_data=point_data, cell_data=cell_data)
+        import pyvista as pv
+
+        mesh = pv.from_meshio(mesh)
+        return mesh
+
+    def select_frame(self, frame):
+        self.select_element(frame)
+
+    # cannot be defined with pre_loaded because it changes on demand
+    @property
+    def mesh(self):
+        return self._current_element
+
+    @XML.loadable
+    def xdmf(self):
+        return self._load_xdmf_data_item(self.xml["Xdmf"])
+
+    @XML.loadable
+    def version(self):
+        return self.xdmf["@Version"]
+
+    @XML.loadable
+    def mesh_name(self):
+        return self.domain["@Name"]
+
+    @XML.loadable
+    def domain(self):
+        return self.xdmf["Domain"]
+
+    @XML.loadable
+    def grid(self):
+        _grid = self.domain["Grid"]
+        keys = [e for e in _grid.keys() if e != "Grid"]
+        grid = {}
+        for e in keys:
+            grid[e] = _grid[e]
+        return grid
+
+    @XML.loadable
+    def n_frames(self):
+        return len(self.grid["Time"]["DataItem"])
+
+    @property
+    def _element_count(self):
+        return self.n_frames
+
+    @XML.loadable
+    def grids(self):
+        _grid = self.domain["Grid"]["Grid"]
+        return _grid

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/viewers/pyvista_plotter.py

@@ -0,0 +1,150 @@
+import pyvista as pv
+from solidipes.loaders.data_container import DataContainer
+from solidipes.utils import viewer_backends
+from solidipes.viewers.viewer import Viewer
+from streamlit_pyvista.mesh_viewer_component import MeshViewerComponent
+from streamlit_pyvista.server_managers import ServerManagerProxified
+from streamlit_pyvista.trame_viewers import get_advanced_viewer_path
+
+
+class PyvistaPlotter(Viewer):
+    """Viewer for pyvista meshes
+
+    Args:
+        **kwargs: keyword arguments passed to the pyvista.Plotter constructor
+    """
+
+    def __init__(self, data_container=None, add_kwargs={}, show_kwargs={}, **kwargs):
+        #: keeps track of whether the plotter has already been shown
+        self.shown = False
+
+        #: Pyvista plotter
+        self.plotter = None
+        if viewer_backends.current_backend == "streamlit":
+            self.plotter = pv.Plotter(off_screen=True, **kwargs)
+        else:  # python or jupyter notebook
+            self.plotter = pv.Plotter(**kwargs)
+
+        self.plotter.background_color = "black"
+        self.meshes = []
+        self.points = []
+        self.path_list = []
+        super().__init__(data_container, add_kwargs=add_kwargs, show_kwargs=show_kwargs)
+
+        self._update_path_list(data_container)
+
+    def add(self, data_container, **kwargs):
+        """Add mesh to the viewer
+
+        Args:
+            **kwargs: keyword arguments passed to the pyvista.Plotter.add_mesh
+                method
+        """
+        from ..loaders.abaqus import Abaqus
+
+        self.check_data_compatibility(data_container)
+
+        if isinstance(data_container, Abaqus):
+            for name, m in data_container.meshes.items():
+                self.meshes.append((m, kwargs))
+
+        elif isinstance(data_container, DataContainer):
+            self.add_mesh(data_container, **kwargs)
+
+    def add_mesh(self, data_container: DataContainer, **kwargs):
+        """Add mesh to the viewer
+
+        Args:
+            **kwargs: keyword arguments passed to the pyvista.Plotter.add_mesh
+                method
+        """
+        data = data_container.mesh
+        self.meshes.append((data, kwargs))
+        self._update_path_list(data_container)
+
+    def _update_path_list(self, data_container):
+        from solidipes.loaders.file_sequence import FileSequence
+
+        if isinstance(data_container, FileSequence):
+            path = data_container.paths.copy()
+            self.path_list.extend(path)
+        else:
+            if data_container is not None:
+                path = data_container.file_info.path
+                self.path_list.append(path)
+
+    def add_points(self, data_container, **kwargs):
+        """Add mesh as points to the viewer
+
+        Args:
+            **kwargs: keyword arguments passed to the
+                pyvista.Plotter.add_points method
+        """
+        data = data_container.mesh
+        self.points.append((data, kwargs))
+
+    def show(self, auto_close=False, **kwargs):
+        """Show the viewer
+
+        Args:
+            auto_close: whether to close the viewer after showing it
+            **kwargs: keyword arguments passed to the pyvista.Plotter.show
+                method
+        """
+
+        for p, _kwargs in self.points:
+            self.plotter.add_points(p, **_kwargs)
+
+        for m, _kwargs in self.meshes:
+            self.plotter.add_mesh(m, **_kwargs)
+
+        if viewer_backends.current_backend == "streamlit":
+            key = f"pyvista_ploter_{self.path_list}"
+            import streamlit as st
+
+            for p, _ in self.points:
+                st.write(p)
+
+            # Display arrays of the raw data
+            for i, (m, kw) in enumerate(self.meshes):
+                options_key = key + f"mesh_{i}_options"
+                if options_key not in st.session_state:
+                    st.session_state[options_key] = ["None"] + m.array_names
+
+                st.write(m)
+
+            if len(self.path_list) == 0:
+                st.error("No mesh passed to the PyvistaPlotter")
+                return
+
+            self.shown = True
+            # Instantiate the viewer
+            MeshViewerComponent(
+                self.path_list,
+                trame_viewer_class=get_advanced_viewer_path(),
+                server_manager_class=ServerManagerProxified,
+            ).show()
+        elif viewer_backends.current_backend == "python":
+            self.shown = True
+            self.plotter.show(kwargs)
+        else:
+            self.shown = True
+            MeshViewerComponent(
+                self.path_list,
+                trame_viewer_class=get_advanced_viewer_path(),
+                server_manager_class=ServerManagerProxified,
+            ).show()
+
+    def save(self, path, **kwargs):
+        """Save the view to a file
+
+        Args:
+            path: path to the file
+            **kwargs: keyword arguments passed to the
+                pyvista.Plotter.screenshot method
+        """
+        # Pyvista Plotter must be shown before saving
+        if not self.shown:
+            self.plotter.show(auto_close=False)  # also for streamlit backend
+            self.shown = True
+        self.plotter.screenshot(path, **kwargs)

solidipes_solid_mech_plugin-0.0.1/solidipes_solid_mech_plugin/viewers/xdmf.py

@@ -0,0 +1,27 @@
+import streamlit as st
+from IPython.display import display
+from solidipes.utils import viewer_backends
+from solidipes_core_plugin.viewers.xml import XML
+
+
+class XDMF(XML):
+    """Viewer for xml text files"""
+
+    def __init__(self, data=None):
+        self.xdmf = None
+        super().__init__(data)
+
+    def add(self, data_container):
+        """Append text to the viewer"""
+        super().check_data_compatibility(data_container)
+        self.xdmf = data_container
+
+    def show(self):
+        content = self.xdmf.mesh
+        if viewer_backends.current_backend == "jupyter notebook":
+            display(content)
+
+        elif viewer_backends.current_backend == "streamlit":
+            st.write(content)
+        else:  # python
+            print(content)