sgio 0.2.15__tar.gz → 0.3.0__tar.gz

{sgio-0.2.15 → 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.15 → sgio-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sgio
-Version: 0.2.15
+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,9 +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.15 → sgio-0.3.0}/pyproject.toml

@@ -24,6 +24,12 @@ dependencies = [
     "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",

{sgio-0.2.15 → 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.15 → 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.15 → 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.15 → 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
+
+
 
 
 # ====================================================================
@@ -418,7 +500,6 @@ def _meshio_to_sg_order(
     idx_sg: np.ndarray (n_cells, n_elem_nodes_sg)
         Array of cell connectivity in SG ordering.
     """
-    print(f'{renumber_nodes = }')
     idx_sg = np.asarray(idx)
     if renumber_nodes:
         if len(node_id) == 0:

{sgio-0.2.15 → 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)

{sgio-0.2.15 → sgio-0.3.0}/sgio/iofunc/gmsh/_gmsh22.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import numpy as np
 from meshio import CellBlock
 from meshio.gmsh._gmsh22 import (
@@ -14,6 +15,8 @@ from meshio.gmsh._gmsh22 import (
     _write_periodic,
 )
 
+logger = logging.getLogger(__name__)
+
 from ._common import (
     _fast_forward_over_blank_lines,
     _fast_forward_to_end_block,
@@ -94,6 +97,10 @@ def write_buffer(file, mesh, float_fmt=".16e", binary=False, **kwargs):
     for name, dat in cell_data_raw.items():
         _write_data(file, "ElementData", name, dat, binary)
 
+    # Write cell_point_data (element nodal data) to ElementNodeData sections
+    if hasattr(mesh, 'cell_point_data') and mesh.cell_point_data:
+        _write_cell_point_data(file, mesh, binary)
+
 
 def _write_nodes(fh, points, float_fmt, binary):
     if points.shape[1] == 2:
@@ -188,4 +195,130 @@ def _write_elements(fh, cells: list[CellBlock], tag_data, binary: bool):
         fh.write("$EndElements\n")
 
 
+def _write_cell_point_data(fh, mesh, binary: bool) -> None:
+    """Write cell_point_data (element nodal data) to $ElementNodeData sections.
+
+    Parameters
+    ----------
+    fh : file
+        File handle to write to
+    mesh : SGMesh
+        Mesh object containing cell_point_data
+    binary : bool
+        Whether to write in binary mode
+
+    Notes
+    -----
+    The $ElementNodeData format is:
+        $ElementNodeData
+          numStringTags(ASCII int)
+          stringTag(string) ...
+          numRealTags(ASCII int)
+          realTag(ASCII double) ...
+          numIntegerTags(ASCII int)
+          integerTag(ASCII int) ...
+          elementTag(int) numNodesPerElement(int) value(double) ...
+          ...
+        $EndElementNodeData
+
+    The cell_point_data structure is:
+        {name: [array_for_cell_block_0, array_for_cell_block_1, ...]}
+    where each array has shape (n_elements, n_nodes_per_element) for single component
+    or (n_elements, n_nodes_per_element, n_components) for multi-component data.
+    """
+    # Get element IDs from cell_data
+    if 'element_id' not in mesh.cell_data:
+        logger.warning("Cannot write cell_point_data: mesh.cell_data['element_id'] not found")
+        return
+
+    element_ids = mesh.cell_data['element_id']
+
+    # Process each field in cell_point_data
+    for field_name, cell_blocks_data in mesh.cell_point_data.items():
+        # Determine number of components from the data shape
+        first_block_data = cell_blocks_data[0]
+        if len(first_block_data.shape) == 2:
+            # Shape: (n_elements, n_nodes_per_element) - single component
+            num_components = 1
+        elif len(first_block_data.shape) == 3:
+            # Shape: (n_elements, n_nodes_per_element, n_components)
+            num_components = first_block_data.shape[2]
+        else:
+            logger.warning(f"Unexpected shape for cell_point_data '{field_name}': {first_block_data.shape}")
+            continue
+
+        # Count total number of elements across all cell blocks
+        total_elements = sum(len(block_data) for block_data in cell_blocks_data)
+
+        # Write header
+        if binary:
+            fh.write(b"$ElementNodeData\n")
+            # 1 string tag: field name
+            fh.write(f"{1}\n".encode())
+            fh.write(f'"{field_name}"\n'.encode())
+            # 1 real tag: time value
+            fh.write(f"{1}\n".encode())
+            fh.write(f"{0.0}\n".encode())
+            # 3 integer tags: time step, num components, num elements
+            fh.write(f"{3}\n".encode())
+            fh.write(f"{0}\n".encode())  # time step
+            fh.write(f"{num_components}\n".encode())
+            fh.write(f"{total_elements}\n".encode())
+        else:
+            fh.write("$ElementNodeData\n")
+            # 1 string tag: field name
+            fh.write(f"{1}\n")
+            fh.write(f'"{field_name}"\n')
+            # 1 real tag: time value
+            fh.write(f"{1}\n")
+            fh.write(f"{0.0}\n")
+            # 3 integer tags: time step, num components, num elements
+            fh.write(f"{3}\n")
+            fh.write(f"{0}\n")  # time step
+            fh.write(f"{num_components}\n")
+            fh.write(f"{total_elements}\n")
+
+        # Write data for each element across all cell blocks
+        for block_idx, block_data in enumerate(cell_blocks_data):
+            block_element_ids = element_ids[block_idx]
+
+            for elem_idx, elem_data in enumerate(block_data):
+                elem_id = int(block_element_ids[elem_idx])
+
+                # elem_data shape: (n_nodes_per_element,) or (n_nodes_per_element, n_components)
+                if num_components == 1:
+                    # Single component: elem_data is 1D array
+                    num_nodes = len(elem_data)
+                    if binary:
+                        np.array([elem_id], dtype=c_int).tofile(fh)
+                        np.array([num_nodes], dtype=c_int).tofile(fh)
+                        elem_data.astype(c_double).tofile(fh)
+                    else:
+                        fh.write(f"{elem_id} {num_nodes}")
+                        for val in elem_data:
+                            fh.write(f" {float(val)}")
+                        fh.write("\n")
+                else:
+                    # Multi-component: elem_data is 2D array (n_nodes, n_components)
+                    num_nodes = elem_data.shape[0]
+                    if binary:
+                        np.array([elem_id], dtype=c_int).tofile(fh)
+                        np.array([num_nodes], dtype=c_int).tofile(fh)
+                        # Flatten the data: all components for node 1, then node 2, etc.
+                        elem_data.astype(c_double).flatten().tofile(fh)
+                    else:
+                        fh.write(f"{elem_id} {num_nodes}")
+                        for node_vals in elem_data:
+                            for val in node_vals:
+                                fh.write(f" {float(val)}")
+                        fh.write("\n")
+
+        # Write footer
+        if binary:
+            fh.write(b"\n")
+            fh.write(b"$EndElementNodeData\n")
+        else:
+            fh.write("$EndElementNodeData\n")
+
+