sgio 0.2.14__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/_version.py

@@ -1 +1 @@
-__version__ = "0.2.14"
+__version__ = "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/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/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/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/iofunc/gmsh/_gmsh.py

@@ -1,18 +1,87 @@
 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):
-    ...
-#     return mgmsh.read_buffer(file, format_version=format_version)
+    """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(

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")
+
+