meshRW 1.0.0__py3-none-any.whl

meshRW/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.0.0'

meshRW/configMESH.py

@@ -0,0 +1,22 @@
+"""
+This file contains the default
+declaration of the keywords
+used to declare/manipulate a mesh in Python
+----
+Luc Laurent - luc.laurent@lecnam.net -- 2021
+"""
+
+DFLT_MESH = 'connectivity'
+DFLT_TYPE_ELEM = 'type'
+DFLT_PHYS_GRP = 'physgrp'
+DFLT_FIELD_DATA = 'data'
+DFLT_FIELD_TYPE = 'type'
+DFLT_FIELD_TYPE_NODAL = 'nodal'
+DFLT_FIELD_TYPE_ELEMENT = 'elemental'
+DFLT_FIELD_TYPE_NODAL_SCALAR = 'nodal_scalar'
+DFLT_FIELD_TYPE_ELEMENT_SCALAR = 'elemental_scalar'
+DFLT_FIELD_DIM = 'dim'
+DFLT_FIELD_NAME = 'name'
+DFLT_FIELD_STEPS = 'steps'
+DFLT_FIELD_NBSTEPS = 'nbsteps'
+DFLT_FIELD_NUMENTITIES = 'numentities'

meshRW/dbmsh.py

@@ -0,0 +1,172 @@
+""" "
+This file includes the definition
+and tools to manipulate MSH format
+Documentation available here:
+https://gmsh.info/doc/texinfo/gmsh.html#MSH-file-format
+----
+Luc Laurent - luc.laurent@lecnam.net -- 2021
+
+"""
+
+from loguru import logger as Logger
+
+
+def loadElementDict():
+    """
+    dictionary from element (string) to msh element number
+    """
+    elementDict = {
+        # 2-nodes line
+        'LIN2': {'code': 1, 'nodes': 2, 'dim': 1},
+        # 3-nodes second order line
+        'LIN3': {'code': 8, 'nodes': 3, 'dim': 1},
+        # 4-nodes third order line
+        'LIN4': None,
+        # 3-nodes triangle
+        'TRI3': {'code': 2, 'nodes': 3, 'dim': 2},
+        # 6-nodes second order triangle (3 vertices, 3 on edges)
+        'TRI6': {'code': 9, 'nodes': 6, 'dim': 2},
+        # 9-nodes cubic order triangle (3 vertices, 3 on edges and 3 inside)
+        'TRI9': None,
+        # 10-nodes higher order triangle (3 vertices, 6 on edges and 1 inside)
+        'TRI10': None,
+        # 12-nodes higher order triangle (3 vertices and 9 on edges)
+        'TRI12': None,
+        # 15-nodes higher order triangle (3 vertices, 9 on edges and 3 inside)
+        'TRI15': None,
+        # 4-nodes quadrangle
+        'QUA4': {'code': 3, 'nodes': 4, 'dim': 2},
+        # 8-nodes second order quadrangle (4 vertices and 4 on edges)
+        'QUA8': {'code': 16, 'nodes': 8, 'dim': 2},
+        # 9-nodes higher order quadrangle (4 vertices, 4 on edges and 1 inside)
+        'QUA9': {'code': 10, 'nodes': 9, 'dim': 2},
+        # 4-nodes tetrahedron
+        'TET4': {'code': 4, 'nodes': 4, 'dim': 3},
+        # 10-nodes second order tetrahedron (4 vertices and 6 on edges)
+        'TET10': {'code': 11, 'nodes': 10, 'dim': 3},
+        # 8-nodes hexahedron
+        'HEX8': {'code': 5, 'nodes': 8, 'dim': 3},
+        # 20-nodes second order hexahedron (8 vertices and 12 on edges)
+        'HEX20': {'code': 17, 'nodes': 20, 'dim': 3},
+        # 27-nodes higher order hexahedron
+        # (8 vertices, 12 on edges, 6 on faces and 1 inside)
+        'HEX27': {'code': 12, 'nodes': 27, 'dim': 3},
+        # 6-nodes prism
+        'PRI6': {'code': 6, 'nodes': 6, 'dim': 3},
+        # 15-nodes second order prism (6 vertices and 9 on edges)
+        'PRI15': {'code': 18, 'nodes': 15, 'dim': 3},
+        # 18-nodes higher order prism (6 vertices, 9 on edges and 3 on faces)
+        'PRI18': {'code': 13, 'nodes': 18, 'dim': 3},
+        # 5-node pyramid
+        'PYR5': {'code': 7, 'nodes': 5, 'dim': 3},
+        # 13-nodes second order pyramid (5 edges and 8 on edges)
+        'PYR13': {'code': 19, 'nodes': 13, 'dim': 3},
+        # 14-nodes higher order pyramid (5 edges, 8 on edges and 1 inside)
+        'PYR14': {'code': 14, 'nodes': 14, 'dim': 3},
+        # 1-node point
+        'NOD1': {'code': 15, 'nodes': 1, 'dim': 0},
+    }
+    return elementDict
+
+
+def getMSHElemType(txtEltype):
+    """
+    Get the element type defined as in gmsh (refer to gmsh documentation for numbering) from text declaration
+    syntax:
+        getMshElemType(txtEltype)
+
+    input:
+        txtEltype: element declared using string (if number is used the function will return it)
+    output:
+        element type defined as gmsh number
+    """
+    elementDict = loadElementDict()
+
+    # depending on the type of txtEltype
+    # - if int: return txtEltype
+    # - else get the number from the dictionary
+    if isinstance(txtEltype, int):
+        elementNum = txtEltype
+    else:
+        elementNum = elementDict[txtEltype.upper()].get('code', None)
+    # show error if the type is not available
+    if not elementNum:
+        Logger.error(f'Element type {txtEltype} not implemented')
+    return elementNum
+
+
+def getElemTypeFromMSH(elementNum):
+    """
+    Get the element type from id (integer) defined in gmsh (refer to gmsh documentation for numbering)
+    syntax:
+        getElemTypeFromMSH(elementNum)
+
+    input:
+        elementNum: integer used in gmsh to declare element
+    output:
+        global name of the element
+    """
+    # load the dictionary
+    elementDict = loadElementDict()
+    globalName = None
+    # get the name of the element using the integer iD along the dictionary
+    for k, v in elementDict.items():
+        if v:
+            if v.get('code', None) == elementNum:
+                globalName = k
+                break
+    # if the name of the element if not available show error
+    if globalName is None:
+        Logger.error(f'Element type not found with id {elementNum}')
+    return globalName
+
+
+def getNumberNodes(txtElemtype):
+    """
+    Get the number of nodes for a specific element type type (declare as string)
+        syntax:
+            getNumberNodes(txtElemtype)
+
+       input:
+            txtElemtype: element declared using string (if number is used the function wil return it)
+        output:
+            number of nodes for txtEltype
+    """
+    # load the dictionary
+    elementDict = loadElementDict()
+    nbNodes = 0
+    # check if the type of element exists
+    if txtElemtype in elementDict.keys():
+        # get the number of nodes for the type of element
+        if elementDict[txtElemtype]:
+            nbNodes = elementDict[txtElemtype].get('nodes', None)
+    else:
+        # show error message if the type of element does not exist
+        Logger.error(f'Element type {txtElemtype} not defined')
+    return nbNodes
+
+
+def getNumberNodesFromNum(elementNum):
+    """
+    Get the number of nodfs for a specific element type type (declare as string)
+        syntax:
+            getNumberNodesFromNum(elementNum)
+
+        input:
+            elementNum: integer used in gmsh to declare element
+        output:
+            number of nodes for txtEltype
+    """
+    return getNumberNodes(getElemTypeFromMSH(elementNum))
+
+
+# DEFAULT VALUES
+ALLOWED_EXTENSIONS = ['.msh', '.msh.bz2', '.msh.gz']
+
+# Keywords MSH
+DFLT_FILE_OPEN_CLOSE = {'open': '$MeshFormat', 'close': '$EndMeshFormat'}
+DFLT_FILE_VERSION = '2.2 0 8'
+DFLT_NODES_OPEN_CLOSE = {'open': '$Nodes', 'close': '$EndNodes'}
+DFLT_ELEMS_OPEN_CLOSE = {'open': '$Elements', 'close': '$EndElements'}
+DFLT_FIELDS_NODES_OPEN_CLOSE = {'open': '$NodeData', 'close': '$EndNodeData'}
+DFLT_FIELDS_ELEMS_OPEN_CLOSE = {'open': '$ElementData', 'close': '$EndElementData'}

meshRW/dbvtk.py

@@ -0,0 +1,261 @@
+""" "
+This file includes the definition and tools to manipulate MSH format
+Documentation available here: https://gmsh.info/doc/texinfo/gmsh.html#MSH-file-format
+----
+Luc Laurent - luc.laurent@lecnam.net -- 2021
+
+"""
+
+import vtk
+from loguru import logger as Logger
+
+
+def loadElementDict():
+    """
+    dictionary from element (string) to VTK number
+    """
+    elementDict = {
+        # 2-nodes line
+        'LIN2': {'code': 3, 'nodes': 2, 'dim': 1, 'vtkobj': vtk.vtkLine()},
+        # 3-nodes second order line
+        'LIN3': {'code': 21, 'nodes': 3, 'dim': 1, 'vtkobj': vtk.vtkQuadraticEdge()},
+        # 4-nodes third order line
+        'LIN4': None,
+        # 3-nodes triangle
+        'TRI3': {'code': 5, 'nodes': 3, 'dim': 2, 'vtkobj': vtk.vtkTriangle()},
+        # 6-nodes second order triangle (3 vertices, 3 on edges)
+        'TRI6': {'code': 22, 'nodes': 6, 'dim': 2, 'vtkobj': vtk.vtkQuadraticTriangle()},
+        # 9-nodes cubic order triangle (3 vertices, 3 on edges and 3 inside)
+        'TRI9': None,
+        # 10-nodes higher order triangle (3 vertices, 6 on edges and 1 inside)
+        'TRI10': None,
+        # 12-nodes higher order triangle (3 vertices and 9 on edges)
+        'TRI12': None,
+        # 15-nodes higher order triangle (3 vertices, 9 on edges and 3 inside)
+        'TRI15': None,
+        # 4-nodes quadrangle
+        'QUA4': {'code': 9, 'nodes': 4, 'dim': 2, 'vtkobj': vtk.vtkQuad()},
+        # 8-nodes second order quadrangle (4 vertices and 4 on edges)
+        'QUA8': {'code': 23, 'nodes': 8, 'dim': 2, 'vtkobj': vtk.vtkQuadraticQuad()},
+        # 9-nodes higher order quadrangle (4 vertices, 4 on edges and 1 inside)
+        'QUA9': None,
+        # 4-nodes tetrahedron
+        'TET4': {'code': 10, 'nodes': 4, 'dim': 3, 'vtkobj': vtk.vtkTetra()},
+        # 10-nodes second order tetrahedron (4 vertices and 6 on edges)
+        'TET10': {'code': 24, 'nodes': 10, 'dim': 3, 'vtkobj': vtk.vtkQuadraticTetra()},
+        # 8-nodes hexahedron
+        'HEX8': {'code': 12, 'nodes': 8, 'dim': 3, 'vtkobj': vtk.vtkHexahedron()},
+        # 20-nodes second order hexahedron (8 vertices and 12 on edges)
+        'HEX20': {'code': 25, 'nodes': 20, 'dim': 3, 'vtkobj': vtk.vtkQuadraticHexahedron()},
+        # 27-nodes higher order hexahedron (8 vertices,
+        # 12 on edges, 6 on faces and 1 inside)
+        'HEX27': None,
+        # 6-nodes prism
+        'PRI6': {'code': 13, 'nodes': 6, 'dim': 3, 'vtkobj': vtk.vtkWedge()},
+        # 15-nodes second order prism (6 vertices and 9 on edges)
+        'PRI15': None,
+        # 18-nodes higher order prism (6 vertices, 9 on edges and 3 on faces)
+        'PRI18': None,
+        # 5-node pyramid
+        'PYR5': {'code': 14, 'nodes': 5, 'dim': 3, 'vtkobj': vtk.vtkPyramid()},
+        # 13-nodes second order pyramid (5 edges and 8 on edges)
+        'PYR13': None,
+        # 14-nodes higher order pyramid (5 edges, 8 on edges and 1 inside)
+        'PYR14': None,
+        # 1-node point
+        'NOD1': {'code': 1, 'nodes': 1, 'dim': 0, 'vtkobj': vtk.vtkVertex()},
+        #
+        # many nodes
+        'NODN': {'code': 2, 'nodes': -1, 'dim': 0, 'vtkobj': vtk.vtkPolyVertex()},
+        # many lines (poly-lines)
+        'LINEN': {'code': 4, 'nodes': -1, 'dim': 1, 'vtkobj': vtk.vtkPolyLine()},
+        # many stripped triangles
+        'TRIN': {'code': 6, 'nodes': -1, 'dim': 2, 'vtkobj': vtk.vtkTriangleStrip()},
+        # polygons
+        'POLY': {'code': 7, 'nodes': -1, 'dim': 2, 'vtkobj': vtk.vtkPolygon()},
+        # pixel
+        'PIXEL': {'code': 8, 'nodes': -1, 'dim': 2, 'vtkobj': vtk.vtkPixel()},
+        # voxel
+        'VOXEL': {'code': 11, 'nodes': -1, 'dim': 3, 'vtkobj': vtk.vtkVoxel()},
+    }
+    return elementDict
+
+
+def getVTKtoElem():
+    """
+    dictionary from VTK element to name of element (string)
+    """
+    VTKtoElem = {
+        'VTK_VERTEX': 'NOD1',
+        'VTK_LINE': 'LIN2',
+        'VTK_TRIANGLE': 'TRI3',
+        'VTK_QUAD': 'QUAD4',
+        'VTK_TETRA': 'TET4',
+        'VTK_HEXAHEDRON': 'HEX8',
+        'VTK_WEDGE': 'PRI6',
+        'VTK_PYRAMID': 'PYR5',
+        'VTK_QUADRATIC_EDGE': 'LIN3',
+        'VTK_QUADRATIC_TRIANGLE': 'TRI6',
+        'VTK_QUADRATIC_QUAD': 'QUA8',
+        'VTK_QUADRATIC_TETRA': 'TET10',
+        'VTK_QUADRATIC_HEXAHEDRON': 'HEX20',
+        #
+        'VTK_POLY_VERTEX': 'NODN',
+        'VTK_POLY_LINE': 'LINEN',
+        'VTK_TRIANGLE_STRIP': 'TRIN',
+        'VTK_POLYGON': 'POLY',
+        'VTK_PIXEL': 'PIXEL',
+        'VTK_VOXEL': 'VOXEL',
+    }
+    return VTKtoElem
+
+
+def getVTKObj(txtEltype):
+    """
+    Get the vtk class from libvtk from text declaration
+    syntax:
+        getVTKEObjType(txtEltype)
+
+    input:
+        txtEltype: element declared using VTK string (if number is used the function wil return it)
+    output:
+        vtk class for the requested element
+        number of nodes on element
+    """
+
+    VTKtoElem = getVTKtoElem()
+    elementDict = loadElementDict()
+
+    # depending on the type of txtEltype
+    numPerElement = -1
+    if txtEltype.upper() in VTKtoElem.keys():
+        txtEltype = VTKtoElem[txtEltype]
+    vtkobj = elementDict[txtEltype.upper()].get('vtkobj', None)
+    numPerElement = getNumberNodes(txtEltype.upper())
+    if not vtkobj:
+        Logger.error(f'Element type {txtEltype} not implemented')
+    return vtkobj, numPerElement
+
+
+def getVTKElemType(txtEltype):
+    """
+    Get the element type defined as in vtk (refer to VTK documentation for numbering) from text declaration
+    syntax:
+        getVTKElemType(txtEltype)
+
+    input:
+        txtEltype: element declared using VTK string (if number is used the function wil return it)
+    output:
+        element type defined as VTK number
+    """
+
+    VTKtoElem = getVTKtoElem()
+    elementDict = loadElementDict()
+
+    # depending on the type of txtEltype
+    numPerElement = -1
+    if isinstance(txtEltype, int):
+        elementNum = txtEltype
+    else:
+        if txtEltype.upper() in VTKtoElem.keys():
+            txtEltype = VTKtoElem[txtEltype]
+        elementNum = elementDict[txtEltype.upper()].get('code', None)
+        numPerElement = getNumberNodes(txtEltype.upper())
+    if not elementNum:
+        Logger.error(f'Element type {txtEltype} not implemented')
+    return elementNum, numPerElement
+
+
+def getElemTypeFromVTK(elementNum):
+    """
+    Get the element type from id (integer) defined in gmsh (refer to gmsh documentation for numbering)
+    syntax:
+        getElemTypeFromVTK(elementNum)
+
+    input:
+        elementNum: integer used in gmsh to declare element
+    output:
+        global name of the element
+    """
+    # load the dictionary
+    elementDict = loadElementDict()
+    globalName = None
+    # get the name of the element using the integer iD along the dictionary
+    for k, v in elementDict.items():
+        if v:
+            if v.get('code', None) == elementNum:
+                globalName = k
+                break
+    # if the name of the element if not available show error
+    if globalName is None:
+        Logger.error(f'Element type not found with id {elementNum}')
+    return globalName
+
+
+def getNumberNodes(txtElemtype):
+    """
+    Get the number of nodes for a specific element type type (declare as string)
+        syntax:
+            getNumberNodes(txtElemtype)
+
+       input:
+            txtElemtype: element declared using string (if number is used the function wil return it)
+        output:
+            number of nodes for txtEltype
+    """
+
+    elementDict = loadElementDict()
+    # check if the type of element exists
+    if txtElemtype in elementDict.keys():
+        # get the number of nodes for the type of element
+        if elementDict[txtElemtype]:
+            nbNodes = elementDict[txtElemtype].get('nodes', None)
+    else:
+        # show error message if the type of element does not exist
+        Logger.error(f'Element type {txtElemtype} not defined')
+    return nbNodes
+
+
+def getNumberNodesFromNum(elementNum):
+    """
+    Get the number of nodfs for a specific element type type (declare as string)
+        syntax:
+            getNumberNodesFromNum(elementNum)
+
+        input:
+            elementNum: integer used in gmsh to declare element
+        output:
+            number of nodes for txtEltype
+    """
+
+    return getNumberNodes(getElemTypeFromVTK(elementNum))
+
+
+# DEFAULT VALUES
+ALLOWED_EXTENSIONS = [
+    '.vtk',
+    '.vtk.bz2',
+    '.vtk.gz',
+    '.vtu',
+    '.vtu.bz2',
+    '.vtu.gz',
+]
+
+
+# Keywords MSH
+DFLT_HEADER_VERSION = '# vtk DataFile Version 2.0'
+DFLT_TYPE_ASCII = 'ASCII'
+DFLT_FILE_VERSION = '2.2 0 8'
+DFLT_TYPE_MESH = 'DATASET UNSTRUCTURED_GRID'
+DFLT_NODES = 'POINTS'
+DFLT_NODES_DATA = 'POINT_DATA'
+DFLT_DOUBLE = 'double'
+DFLT_FLOAT = 'float'
+DFLT_INT = 'int'
+DFLT_ELEMS = 'CELLS'
+DFLT_ELEMS_TYPE = 'CELL_TYPES'
+DFLT_ELEMS_DATA = 'CELL_DATA'
+DFLT_FIELD = 'FIELD'
+DFLT_SCALARS = 'SCALARS'
+DFLT_TABLE = 'LOOKUP_TABLE'
+DFLT_TABLE_DEFAULT = 'default'

meshRW/fileio.py

@@ -0,0 +1,141 @@
+"""
+This file includes the definition and tools to manipulate files
+----
+Luc Laurent - luc.laurent@lecnam.net -- 2021
+"""
+
+import time
+from pathlib import Path
+
+from loguru import logger as Logger
+
+from . import various
+
+
+class fileHandler:
+    def __init__(self, filename=None, append=None, right='w', gz=False, bz2=False, safeMode=False):
+        """
+        create the class
+        arguments:
+            - filename: name of the file to open
+            - append: append to existing file (override 'right')
+            - right: specific right when open the file ('r','a','w'...)
+            - gz: on the fly compress file with gunzip
+            - bz2: on the fly compress file with bunzip2
+            - safeMode: avoid overwritten
+        """
+        self.filename = None
+        self.dirname = None
+        self.fhandle = None
+        self.right = right
+        self.append = None
+        self.compress = None
+        self.startTime = 0
+        #
+        self.fixRight(append=append, right=right)
+
+        # check arguments
+        checkOk = True
+        if not filename:
+            checkOk = False
+            Logger.error('Filename argument missing')
+        if not right and not append:
+            checkOk = False
+            Logger.error('Right(s) not provided')
+        # load the filename
+        self.getFilename(Path(filename), gz, bz2)
+        # open the file
+        self.open(safeMode)
+
+    def getFilename(self, filename, gz=None, bz2=None):
+        """
+        Load the right filename
+        """
+        self.compress = None
+        # check extension for compression
+        if filename.suffix == '.gz':
+            self.compress = 'gz'
+        elif filename.suffix == '.bz2':
+            self.compress = 'bz2'
+        elif gz:
+            filename.with_suffix(filename.suffix + '.gz')
+            self.compress = 'gz'
+        elif bz2:
+            filename.with_suffix(filename.suffix + '.bz2')
+            self.compress = 'bz2'
+        # extract information about filename
+        self.basename = filename.name
+        self.dirname = filename.absolute().parent
+        self.filename = filename
+
+    def open(self, safeMode=False):
+        """
+        Open the file w/- or W/o safe mode (avoid overwrite existing file
+        """
+        # adapt the rights (in case of the file does not exist)
+        if self.append and self.filename.exists():
+            Logger.warning(f'{self.basename} does not exist! Unable to append')
+            self.fixRight(append=False)
+        if not safeMode and self.filename.exists() and not self.append and 'w' in self.right:
+            Logger.warning(f'{self.basename} already exists! It will be overwritten')
+        if safeMode and self.filename.exists() and not self.append and 'w' in self.right:
+            Logger.warning(f'{self.basename} already exists! Not overwrite it')
+        else:
+            #
+            Logger.debug(f'Open {self.basename} in {self.dirname} with right {self.right}')
+            # open file
+            if self.compress == 'gz':
+                Logger.debug('Use GZ lib')
+                import gzip
+
+                self.fhandle = gzip.open(self.filename, self.right)
+            elif self.compress == 'bz2':
+                Logger.debug('Use BZ2 lib')
+                import bz2
+
+                self.fhandle = bz2.open(self.filename, self.right)
+            else:
+                self.fhandle = open(self.filename, self.right)
+        # store timestamp at opening
+        self.startTime = time.perf_counter()
+        return self.fhandle
+
+    def close(self):
+        """
+        Close openned file
+        """
+        if self.fhandle:
+            self.fhandle.close()
+            self.fhandle = None
+            Logger.info(
+                f'Close file {self.basename} with elapsed time {time.perf_counter()-self.startTime:g}s - size {various.convert_size(self.filename.stat().st_size)}'
+            )
+
+    def getHandler(self):
+        """
+        get the file handler
+        """
+        return self.fhandle
+
+    def write(self, txt):
+        """
+        write in the file using handle
+        """
+        return self.fhandle.write(txt)
+
+    def fixRight(self, append=None, right=None):
+        """
+        Fix issue on right to write file
+        """
+        if append is not None:
+            self.append = append
+            if append:
+                self.right = 'a'
+            else:
+                self.right = 'w'
+        else:
+            self.right = right
+            if right[0] == 'w':
+                self.append = False
+            elif right[0] == 'a':
+                self.append = True