sgio 0.2.14__tar.gz → 0.3.0__tar.gz

{sgio-0.2.14 → sgio-0.3.0}/.gitignore

@@ -5,10 +5,22 @@ build*/
 .pytest_cache/
 *.egg-info/
 dist/
+.agents-memory/
+
+.venv/Lib/
+.venv/Scripts/
+.venv/share/
+.venv/.gitignore
+.venv/CASHDIR.TAG
+.venv/pyvenv.cfg
 
 *.pyc
 *.exe
 
+# Abaqus files
+*.rpy*
+*.dmp
+
 *.deb
 SCInt
 SCReal
@@ -39,3 +51,6 @@ tests/*.SM
 tests/*.SN
 tests/*.SMN
 tests/*.ELE
+
+*.rpy*
+ABQ*.dmp

{sgio-0.2.14 → sgio-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sgio
-Version: 0.2.14
+Version: 0.3.0
 Summary: I/O for VABS and SwiftComp
 Project-URL: Homepage, https://github.com/wenbinyugroup/sgio
 Project-URL: Documentation, https://wenbinyugroup.github.io/sgio/
@@ -14,8 +14,15 @@ Requires-Dist: build>=1.3.0
 Requires-Dist: hatchling>=1.27.0
 Requires-Dist: matplotlib
 Requires-Dist: meshio
+Requires-Dist: myst-parser>=3.0.1
+Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml
+Requires-Dist: rich>=14.1.0
 Requires-Dist: scipy
+Requires-Dist: sphinx-copybutton>=0.5.2
+Requires-Dist: sphinx-design>=0.6.1
+Requires-Dist: sphinx-immaterial>=0.12.5
+Requires-Dist: sphinx>=7.4.7
 Requires-Dist: twine>=6.2.0
 Provides-Extra: all
 Requires-Dist: h5py; extra == 'all'

{sgio-0.2.14 → sgio-0.3.0}/pyproject.toml

@@ -1,69 +1,76 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "sgio"
-# version = "0.1.0"
-dynamic = ["version"]
-description = "I/O for VABS and SwiftComp"
-authors = [
-    { name = "Su Tian", email = "sutian@analyswift.com" }
-]
-readme = { file = "README.md", content-type = "text/markdown" }
-requires-python = ">=3.9"
-dependencies = [
-    "meshio",
-    # "importlib_metadata; python_version<'3.8'",
-    # "numpy>=2",
-    # "rich",
-    "matplotlib",
-    "pyyaml",
-    "scipy",
-    "twine>=6.2.0",
-    "build>=1.3.0",
-    "hatchling>=1.27.0",
-]
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "Operating System :: OS Independent",
-]
-license = "MIT"
-license-files = ["LICEN[CS]E*"]
-
-[project.optional-dependencies]
-dev = [
-    "pytest",
-    "pyinstaller",  # For building executables
-]
-all = [
-    "h5py",
-    "netCDF4",
-    "pytest",
-]
-
-[project.scripts]
-sgio = "sgio.__main__:main"
-
-[project.urls]
-Homepage = "https://github.com/wenbinyugroup/sgio"
-Documentation = "https://wenbinyugroup.github.io/sgio/"
-
-[tool.hatch.version]
-source = "regex"
-path = "sgio/_version.py"
-pattern = '^__version__ = "(?P<version>[^"]+)"$'
-
-[tool.hatch.build.targets.sdist]
-only-include = [
-    "sgio",
-    "LICENSE",
-    "README.md",
-    "pyproject.toml",
-]
-
-[tool.uv]
-dev-dependencies = [
-    "pytest>=6.0",
-    "pyinstaller>=5.0",
-]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sgio"
+# version = "0.1.0"
+dynamic = ["version"]
+description = "I/O for VABS and SwiftComp"
+authors = [
+    { name = "Su Tian", email = "sutian@analyswift.com" }
+]
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.9"
+dependencies = [
+    "meshio",
+    # "importlib_metadata; python_version<'3.8'",
+    # "numpy>=2",
+    # "rich",
+    "matplotlib",
+    "pydantic>=2.0",
+    "pyyaml",
+    "scipy",
+    "build>=1.3.0",
+    "hatchling>=1.27.0",
+    "twine>=6.2.0",
+    "rich>=14.1.0",
+    "sphinx>=7.4.7",
+    "myst-parser>=3.0.1",
+    "sphinx-immaterial>=0.12.5",
+    "sphinx-design>=0.6.1",
+    "sphinx-copybutton>=0.5.2",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pyinstaller",  # For building executables
+]
+all = [
+    "h5py",
+    "netCDF4",
+    "pytest",
+]
+
+[project.scripts]
+sgio = "sgio.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/wenbinyugroup/sgio"
+Documentation = "https://wenbinyugroup.github.io/sgio/"
+
+[tool.hatch.version]
+source = "regex"
+path = "sgio/_version.py"
+pattern = '^__version__ = "(?P<version>[^"]+)"$'
+
+[tool.hatch.build.targets.sdist]
+only-include = [
+    "sgio",
+    "LICENSE",
+    "README.md",
+    "pyproject.toml",
+]
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=6.0",
+    "pyinstaller>=5.0",
+]

{sgio-0.2.14 → sgio-0.3.0}/sgio/_global.py

@@ -16,7 +16,7 @@ def pretty_string(v):
     return Pretty(v).__str__()
 
 
-def configure_logging(cout_level='INFO', fout_level='INFO', filename='log.txt'):
+def configure_logging(cout_level='INFO', fout_level='INFO', filename='sgio.log'):
     """Initialization of a logger.
 
     Parameters
@@ -28,7 +28,7 @@ def configure_logging(cout_level='INFO', fout_level='INFO', filename='log.txt'):
     fout_level : {'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'}, optional
         Output level of logs to a file, by default 'INFO'
     filename : str, optional
-        Name of the log file, by default 'log.txt'
+        Name of the log file, by default 'sgio.log'
 
     Returns
     -------

sgio-0.3.0/sgio/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

{sgio-0.2.14 → sgio-0.3.0}/sgio/app.py

@@ -39,7 +39,7 @@ def cli(*args):
         default='info', choices=['debug', 'info', 'warning', 'error', 'critical'])
     logging_args.add_argument(
         '--logfile', help='Logging file name',
-        default='log.txt')
+        default='sgio.log')
 
     sub_parser = root_parser.add_subparsers(
         help='sub-command help'

{sgio-0.2.14 → sgio-0.3.0}/sgio/core/mesh.py

@@ -1,11 +1,20 @@
 from meshio import Mesh, CellBlock
 from typing import Union
+import numpy as np
 
 class SGMesh(Mesh):
     """Extended mesh class that inherits from meshio.Mesh.
-    
+
     This class provides additional functionality and custom format support
     while maintaining compatibility with the original meshio.Mesh class.
+
+    Attributes
+    ----------
+    cell_point_data : dict[str, list[np.ndarray]]
+        Dictionary of element nodal data (data at nodes of each element).
+        Structure: {name: [array_for_cell_block_0, array_for_cell_block_1, ...]}
+        where each array has shape (n_elements, n_nodes_per_element, n_components).
+        This is used for storing element_node data like strain/stress at element nodes.
     """
 
     def __init__(
@@ -18,6 +27,7 @@ class SGMesh(Mesh):
         cell_sets=None,
         gmsh_periodic=None,
         info=None,
+        cell_point_data=None,
         ):
 
         super().__init__(
@@ -31,6 +41,27 @@ class SGMesh(Mesh):
             info=info,
         )
 
+        # Initialize cell_point_data (element nodal data)
+        self.cell_point_data = {} if cell_point_data is None else cell_point_data
+
+        # Validate cell_point_data consistency
+        for key, data in self.cell_point_data.items():
+            if len(data) != len(self.cells):
+                raise ValueError(
+                    f"Incompatible cell_point_data '{key}'. "
+                    f"{len(self.cells)} cell blocks, but '{key}' has {len(data)} blocks."
+                )
+
+            for k in range(len(data)):
+                data[k] = np.asarray(data[k])
+                if len(data[k]) != len(self.cells[k]):
+                    raise ValueError(
+                        "Incompatible cell_point_data. "
+                        + f"Cell block {k} ('{self.cells[k].type}') "
+                        + f"has {len(self.cells[k])} elements, but "
+                        + f"corresponding cell_point_data item has {len(data[k])} elements."
+                    )
+
 
     def get_cell_block_by_type(self, cell_type):
         """

{sgio-0.2.14 → sgio-0.3.0}/sgio/iofunc/_meshio.py

@@ -167,9 +167,9 @@ def addPointDictDataToMesh(name:str|list, dict_data:dict[int, list], mesh:SGMesh
 
 
 def addCellDictDataToMesh(name:str|list, dict_data:dict[int, list], mesh:SGMesh):
-    """Add cell/element data (dictionary) to cell_data of mesh.
+    """Add cell/element data (dictionary) to cell_data or cell_point_data of mesh.
 
-    The mesh should contain a map between (cell_type, index) and element id.    
+    The mesh should contain a map between (cell_type, index) and element id.
 
     Parameters:
     -----------
@@ -177,13 +177,31 @@ def addCellDictDataToMesh(name:str|list, dict_data:dict[int, list], mesh:SGMesh)
         Name(s) of the cell data. If it is a list, then it should have the same length as data list for each element.
     dict_data:
         Data in the dictionary form {eid: data}.
+        For element data: {eid: [comp1, comp2, ...]}
+        For element_node data: {eid: [[comp1_n1, comp2_n1, ...], [comp1_n2, comp2_n2, ...], ...]}
     mesh:
         Mesh where the cell data will be added.
 
+    Note:
+    -----
+    Element data (flat lists) will be added to mesh.cell_data.
+    Element_node data (nested lists) will be added to mesh.cell_point_data.
+
     """
 
     _cell_data_eid = mesh.cell_data['element_id']
 
+    # Detect if data is element_node data (nested lists) or element data (flat lists)
+    # Check the first element's data structure
+    first_eid = next(iter(dict_data))
+    first_data = dict_data[first_eid]
+    is_element_node_data = isinstance(first_data, list) and len(first_data) > 0 and isinstance(first_data[0], list)
+
+    if is_element_node_data:
+        # Add element_node data to cell_point_data
+        _addCellPointDictDataToMesh(name, dict_data, mesh)
+        return
+
     if isinstance(name, str):
         _cell_data = []
 
@@ -212,6 +230,8 @@ def addCellDictDataToMesh(name:str|list, dict_data:dict[int, list], mesh:SGMesh)
 
             for _j, _eid in enumerate(_typei_ids):
                 _data_all = dict_data[_eid]
+                # For element data: {eid: [comp1, comp2, ...]}
+                # _data_all is a flat list of components
                 for _k, _data in enumerate(_data_all):
                     _typei_data_all[_k].append(_data)
 
@@ -225,6 +245,68 @@ def addCellDictDataToMesh(name:str|list, dict_data:dict[int, list], mesh:SGMesh)
     return
 
 
+def _addCellPointDictDataToMesh(name:str|list, dict_data:dict[int, list], mesh:SGMesh):
+    """Add cell point (element nodal) data (dictionary) to cell_point_data of mesh.
+
+    The mesh should contain a map between (cell_type, index) and element id.
+
+    Parameters:
+    -----------
+    name:
+        Name(s) of the cell point data. If it is a list, then it should have the same
+        length as the number of components in the data.
+    dict_data:
+        Data in the dictionary form {eid: [[comp1_n1, comp2_n1, ...], [comp1_n2, comp2_n2, ...], ...]}.
+        Each element has a list of nodes, and each node has a list of component values.
+    mesh:
+        Mesh where the cell point data will be added.
+
+    """
+    import numpy as np
+
+    _cell_data_eid = mesh.cell_data['element_id']
+
+    if isinstance(name, str):
+        # Single component name - store the entire nested structure
+        _cell_point_data = []
+
+        for _i, _typei_ids in enumerate(_cell_data_eid):
+            _typei_data = []
+
+            for _j, _eid in enumerate(_typei_ids):
+                _data = dict_data[_eid]
+                _typei_data.append(_data)
+
+            _cell_point_data.append(np.array(_typei_data))
+
+        mesh.cell_point_data[name] = _cell_point_data
+
+    elif isinstance(name, list):
+        # Multiple component names - transpose the data structure
+        # From: {eid: [[comp1_n1, comp2_n1, ...], [comp1_n2, comp2_n2, ...], ...]}
+        # To: For each component, create: [[[comp_n1_e1, comp_n2_e1, ...], ...], ...]
+
+        ncomps = len(name)
+
+        for comp_idx, comp_name in enumerate(name):
+            _cell_point_data = []
+
+            for _i, _typei_ids in enumerate(_cell_data_eid):
+                _typei_data = []
+
+                for _j, _eid in enumerate(_typei_ids):
+                    _elem_node_data = dict_data[_eid]
+                    # Extract component comp_idx from all nodes of this element
+                    _comp_values = [node_data[comp_idx] for node_data in _elem_node_data]
+                    _typei_data.append(_comp_values)
+
+                _cell_point_data.append(np.array(_typei_data))
+
+            mesh.cell_point_data[comp_name] = _cell_point_data
+
+    return
+
+
 
 
 # ====================================================================
@@ -281,35 +363,35 @@ def _sg_to_meshio_order(cell_type: str, idx: ArrayLike) -> np.ndarray:
 
 
 
-def _meshio_to_sg_order(cell_type:str, idx:ArrayLike):
-    idx_sg = np.asarray(idx) + 1
+# def _meshio_to_sg_order(cell_type:str, idx:ArrayLike):
+#     idx_sg = np.asarray(idx) + 1
 
-    idx_to_insert = None
-    if cell_type == 'triangle6':
-        idx_to_insert = 3
-    elif cell_type == 'tetra10':
-        idx_to_insert = 4
-    elif cell_type == 'wedge15':
-        idx_to_insert = 6
+#     idx_to_insert = None
+#     if cell_type == 'triangle6':
+#         idx_to_insert = 3
+#     elif cell_type == 'tetra10':
+#         idx_to_insert = 4
+#     elif cell_type == 'wedge15':
+#         idx_to_insert = 6
 
-    max_nodes = idx_sg.shape[1]
-    if cell_type.startswith('line'):
-        max_nodes = 5
-    elif cell_type.startswith('triangle') or cell_type.startswith('quad'):
-        max_nodes = 9
-    elif cell_type.startswith('tetra') or cell_type.startswith('wedge') or cell_type.startswith('hexahedron'):
-        max_nodes = 20
+#     max_nodes = idx_sg.shape[1]
+#     if cell_type.startswith('line'):
+#         max_nodes = 5
+#     elif cell_type.startswith('triangle') or cell_type.startswith('quad'):
+#         max_nodes = 9
+#     elif cell_type.startswith('tetra') or cell_type.startswith('wedge') or cell_type.startswith('hexahedron'):
+#         max_nodes = 20
 
-    # Insert 0 for some types of cells
-    if idx_to_insert:
-        idx_sg = np.insert(idx_sg, idx_to_insert, 0, axis=1)
+#     # Insert 0 for some types of cells
+#     if idx_to_insert:
+#         idx_sg = np.insert(idx_sg, idx_to_insert, 0, axis=1)
 
-    # Fill the remaining location with 0s
-    pad_width = max_nodes - idx_sg.shape[1]
-    # logger.debug('pad width = {}'.format(pad_width))
-    idx_sg = np.pad(idx_sg, ((0, 0), (0, pad_width)), 'constant', constant_values=0)
+#     # Fill the remaining location with 0s
+#     pad_width = max_nodes - idx_sg.shape[1]
+#     # logger.debug('pad width = {}'.format(pad_width))
+#     idx_sg = np.pad(idx_sg, ((0, 0), (0, pad_width)), 'constant', constant_values=0)
 
-    return idx_sg
+#     return idx_sg
 
 
 
@@ -398,7 +480,7 @@ def _write_nodes(
 
 def _meshio_to_sg_order(
     cell_type:str, idx:ArrayLike,
-    node_id=[], renumber_nodes:bool=False
+    node_id=[], renumber_nodes:bool=True
     ):
     """Convert meshio cell ordering to SG ordering.
 
@@ -420,9 +502,11 @@ def _meshio_to_sg_order(
     """
     idx_sg = np.asarray(idx)
     if renumber_nodes:
-        idx_map = {v:i+1 for i, v in enumerate(node_id)}
-        idx_sg = np.vectorize(idx_map.get)(idx_sg)
-    # idx_sg = np.asarray(idx) + 1
+        if len(node_id) == 0:
+            idx_sg = np.asarray(idx) + 1
+        else:
+            idx_map = {v: i+1 for i, v in enumerate(node_id)}
+            idx_sg = np.vectorize(idx_map.get)(idx_sg)
 
     idx_to_insert = None
     if cell_type == 'triangle6':

{sgio-0.2.14 → sgio-0.3.0}/sgio/iofunc/gmsh/_common.py

@@ -14,6 +14,10 @@ from meshio.gmsh.common import (
     _read_physical_names,
     _write_physical_names,
 )
+from meshio._common import (
+    num_nodes_per_cell,
+    cell_data_from_raw,
+)
 
 from sgio.iofunc._meshio import (
     WriteError

sgio-0.3.0/sgio/iofunc/gmsh/_gmsh.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import logging
+import struct
+
+import numpy as np
+
+from . import _gmsh22
+# from . import _gmsh40
+from . import _gmsh41
+from ._common import _fast_forward_to_end_block
+from sgio.iofunc._meshio import ReadError
+
+logger = logging.getLogger(__name__)
+
+# Some mesh files use "2" when it should be "2.2" and "4" when it should be "4.1"
+_readers = {"2": _gmsh22, "2.2": _gmsh22, "4": _gmsh41, "4.1": _gmsh41}
+
+
+def _read_header(f):
+    """Read the mesh format block.
+
+    Returns:
+        fmt_version: str
+        data_size: int
+        is_ascii: bool
+    """
+    line = f.readline().decode()
+    str_list = list(filter(None, line.split()))
+    fmt_version = str_list[0]
+    if str_list[1] not in ["0", "1"]:
+        raise ReadError("Invalid file-type in header")
+    is_ascii = str_list[1] == "0"
+    data_size = int(str_list[2])
+    if not is_ascii:
+        # The next line is the integer 1 in bytes for endianness check
+        one = f.read(struct.calcsize("i"))
+        if struct.unpack("i", one)[0] != 1:
+            raise ReadError("Endianness mismatch")
+    _fast_forward_to_end_block(f, "MeshFormat")
+    return fmt_version, data_size, is_ascii
+
+
+def read_buffer(file, format_version="4.1", **kwargs):
+    """Read a Gmsh mesh from a buffer.
+
+    Parameters
+    ----------
+    file : file-like object
+        The file buffer to read from (opened in binary mode).
+    format_version : str
+        The expected format version. If not specified, auto-detect from file.
+
+    Returns
+    -------
+    mesh : meshio.Mesh
+        The mesh data read from the file.
+    """
+    # The format is specified at:
+    # <http://gmsh.info/doc/texinfo/gmsh.html#File-formats>
+
+    line = file.readline().decode().strip()
+
+    # Skip any $Comments/$EndComments sections
+    while line == "$Comments":
+        _fast_forward_to_end_block(file, "Comments")
+        line = file.readline().decode().strip()
+
+    if line != "$MeshFormat":
+        raise ReadError(f"Expected $MeshFormat, got {repr(line)}")
+
+    fmt_version, data_size, is_ascii = _read_header(file)
+
+    try:
+        reader = _readers[fmt_version]
+    except KeyError:
+        try:
+            reader = _readers[fmt_version.split(".")[0]]
+        except KeyError:
+            raise ValueError(
+                f"Need mesh format in {sorted(_readers.keys())} (got {fmt_version})"
+            )
+
+    return reader.read_buffer(file, is_ascii, data_size)
+
+
+def write_buffer(
+    file, mesh, format_version, float_fmt, sgdim,
+    mesh_only, binary,
+    **kwargs):
+    """
+    """
+    logger.debug(locals())
+
+    if format_version == "":
+        format_version = "4.1"
+
+    if format_version == "2.2":
+        _gmsh22.write_buffer(file, mesh, float_fmt=float_fmt, binary=binary)
+    # elif format_version == "4.0":
+    #     _gmsh40.write_buffer(file, mesh, format_version=format_version)
+    elif format_version == "4.1":
+        # handle gmsh:dim_tags
+        # mesh.point_data['gmsh:dim_tags'] = np.array([[sgdim, 0]])
+        mesh.point_data['gmsh:dim_tags'] = np.array([[sgdim, 1] for i in range(len(mesh.points))])
+        # mesh.cell_data['gmsh:geometrical'] = np.array([[i,] for i in range(len(mesh.cells))])
+        mesh.cell_data['gmsh:geometrical'] = [[1,],] * len(mesh.cells)
+        _gmsh41.write_buffer(file, mesh, float_fmt, mesh_only, binary)