PyHOPE 0.0.2__tar.gz → 0.0.4__tar.gz

{pyhope-0.0.2 → pyhope-0.0.4}/LICENSE.md

@@ -630,7 +630,6 @@ attach them to the start of each source file to most effectively state
 the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 
-        <one line to give the program's name and a brief idea of what it does.>
         Copyright (c) 2024 Numerics Research Group, University of Stuttgart, Prof. Andrea Beck
 
         This program is free software: you can redistribute it and/or modify
@@ -652,7 +651,7 @@ mail.
 If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-        <program>  Copyright (c) 2024 Numerics Research Group, University of Stuttgart, Prof. Andrea Beck
+        PyHOPE  Copyright (c) 2024 Numerics Research Group, University of Stuttgart, Prof. Andrea Beck
         This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
         This is free software, and you are welcome to redistribute it
         under certain conditions; type `show c' for details.

{pyhope-0.0.2 → pyhope-0.0.4}/PKG-INFO

@@ -1,22 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: PyHOPE
-Version: 0.0.2
-Summary: Coming soon
-Home-page: https://gitlab.iag.uni-stuttgart.de/flexi/codes/pyhope
-License: GPL-3.0
+Version: 0.0.4
+Summary: Python High-Order Preprocessing Environment
+Home-page: https://numericsresearchgroup.org
+License: GPL-3.0-only
 Keywords: PyHOPE,mesh generator
 Author: Numerics Research Group (NRG)
 Author-email: numerics@iag.uni-stuttgart.de
+Requires-Python: >=3.8
 Classifier: Development Status :: 3 - Alpha
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -28,7 +23,7 @@ Requires-Dist: gmsh
 Requires-Dist: h5py
 Requires-Dist: hilbertcurve
 Requires-Dist: meshio
-Requires-Dist: numpy
+Requires-Dist: numpy (>=2.0.0)
 Requires-Dist: packaging
 Requires-Dist: plotext
 Requires-Dist: pygmsh
@@ -40,7 +35,7 @@ PyHOPE (Python High-Order Preprocessing Environment) is an open-source Python fr
 
 PyHOPE has been developed by the Numerics Research Group (NRG) lead by Prof. Andrea Beck at the Institute of Aerodynamics and Gas Dynamics at the University of Stuttgart, Germany.
 
-PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and share the same input/output format. For more information and tutorials, please visit the [HOPR documentation](https://hopr.readthedocs.io)
+PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. For more information and tutorials, please visit the [HOPR documentation](https://hopr.readthedocs.io)
 
 This is a scientific project. If you use pyHOPE for publications or presentations in science, please support the project by citing our publications given at [numericsresearchgroup.org](https://numericsresearchgroup.org/publications.html).
 
@@ -58,7 +53,7 @@ PyHOPE is invoked from the command line. Run parameters are read from a configur
 $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ P y H O P E — Python High-Order Preprocessing Environment
-┃ PyHOPE version 0.0.2
+┃ PyHOPE version x.x.x
 ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ├─────────────────────────────────────────────
 │ INIT PROGRAM...

{pyhope-0.0.2 → pyhope-0.0.4}/README.md

@@ -2,7 +2,7 @@ PyHOPE (Python High-Order Preprocessing Environment) is an open-source Python fr
 
 PyHOPE has been developed by the Numerics Research Group (NRG) lead by Prof. Andrea Beck at the Institute of Aerodynamics and Gas Dynamics at the University of Stuttgart, Germany.
 
-PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and share the same input/output format. For more information and tutorials, please visit the [HOPR documentation](https://hopr.readthedocs.io)
+PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. For more information and tutorials, please visit the [HOPR documentation](https://hopr.readthedocs.io)
 
 This is a scientific project. If you use pyHOPE for publications or presentations in science, please support the project by citing our publications given at [numericsresearchgroup.org](https://numericsresearchgroup.org/publications.html).
 
@@ -20,7 +20,7 @@ PyHOPE is invoked from the command line. Run parameters are read from a configur
 $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ P y H O P E — Python High-Order Preprocessing Environment
-┃ PyHOPE version 0.0.2
+┃ PyHOPE version x.x.x
 ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ├─────────────────────────────────────────────
 │ INIT PROGRAM...

{pyhope-0.0.2 → pyhope-0.0.4}/pyhope/basis/basis_jacobian.py

@@ -342,16 +342,16 @@ def CheckJacobians() -> None:
 
     for iElem, elem in enumerate(elems):
         # Only consider hexahedrons
-        if int(elem['Type']) % 100 != 8:
+        if int(elem.type) % 100 != 8:
             continue
 
         # Get the mapping
-        linMap = LINMAP(elem['Type'], order=mesh_vars.nGeo)
+        linMap = LINMAP(elem.type, order=mesh_vars.nGeo)
         mapLin = {k: v for v, k in enumerate(linMap)}
 
         # Fill the NodeCoords
         nodeCoords = np.zeros((nGeo ** 3, 3), dtype=np.float64)
-        for iNode, nodeID in enumerate(elem['Nodes']):
+        for iNode, nodeID in enumerate(elem.nodes):
             nodeCoords[mapLin[iNode], :] = nodes[nodeID]
 
         xGeo = np.zeros((3, nGeo, nGeo, nGeo))

{pyhope-0.0.2 → pyhope-0.0.4}/pyhope/common/common.py

@@ -145,16 +145,29 @@ def PkgsMetaVersion(pkgs) -> Union[str, None]:
 def PkgsCheckGmsh() -> None:
     # Local imports ----------------------------------------
     import pyhope.output.output as hopout
+    from pyhope.common.common_vars import Gitlab
     # ------------------------------------------------------
+
+    # Check the current platform
+    system = platform.system().lower()
+    arch   = platform.machine().lower()
+
     gmsh_version  = PkgsMetaVersion('gmsh')
     if gmsh_version is None:
         # Gmsh is not installed
         if IsInteractive():
-            warning = 'Gmsh is not installed. For compatibility, the NRG Gmsh version will be installed. Continue? (Y/n):'
-            response = input('\n' + hopout.warn(warning) + '\n')
-            if response.lower() in ['yes', 'y', '']:
-                PkgsInstallGmsh()
-                return None
+            if system in Gitlab.LIB_SUPPORT and arch in Gitlab.LIB_SUPPORT[system]:
+                warning = 'Gmsh is not installed. For compatibility, the NRG Gmsh version will be installed. Continue? (Y/n):'
+                response = input('\n' + hopout.warn(warning) + '\n')
+                if response.lower() in ['yes', 'y', '']:
+                    PkgsInstallGmsh(system,arch,version='nrg')
+                    return None
+            else:
+                warning = 'Gmsh is not installed. As NRG does not provide a compatible Gmsh version, the PyPI Gmsh version will be installed. Continue? (Y/n):'
+                response = input('\n' + hopout.warn(warning) + '\n')
+                if response.lower() in ['yes', 'y', '']:
+                    PkgsInstallGmsh(system,arch,version='pypi')
+                    return None
         else:
             hopout.warning('Gmsh is not installed, exiting...')
             sys.exit(1)
@@ -166,27 +179,23 @@ def PkgsCheckGmsh() -> None:
         return None
 
     # Check if the installed version is the NRG version
-    if PkgsMetaData('gmsh', 'Intended Audience: NRG'):
+    if PkgsMetaData('gmsh', 'Intended Audience :: NRG'):
         return None
 
-    # Check the current platform
-    system = platform.system()
-    arch   = platform.machine()
-
-    if system != 'Linux' or arch != 'x86_64':
+    if system not in Gitlab.LIB_SUPPORT or arch not in Gitlab.LIB_SUPPORT[system]:
         warning = hopout.warn(f'Detected non-NRG Gmsh version on unsupported platform [{system}/{arch}]. ' +
                               'Functionality may be limited.')
         print(warning)
         return None
 
-    if not PkgsMetaData('gmsh', 'Intended Audience: NRG'):
+    if not PkgsMetaData('gmsh', 'Intended Audience :: NRG'):
         if IsInteractive():
             warning  = 'Detected Gmsh package uses an outdated CGNS (v3.4). For compatibility, ' \
                        'the package will be uninstalled and replaced with the updated NRG GMSH ' \
                        'version. Continue? (Y/n):'
             response = input('\n' + hopout.warn(warning) + '\n')
             if response.lower() in ['yes', 'y', '']:
-                PkgsInstallGmsh()
+                PkgsInstallGmsh(system,arch,version='nrg')
                 return None
         else:
             warning = hopout.warn('Detected Gmsh package uses an outdated CGNS (v3.4). Functionality may be limited.')
@@ -194,7 +203,7 @@ def PkgsCheckGmsh() -> None:
             return None
 
 
-def PkgsInstallGmsh():
+def PkgsInstallGmsh(system: str, arch: str, version: str):
     # Local imports ----------------------------------------
     import hashlib
     import tempfile
@@ -202,41 +211,52 @@ def PkgsInstallGmsh():
     from pyhope.common.common_vars import Gitlab
     # ------------------------------------------------------
 
-    # Gitlab "python-gmsh" access
-    lfs = 'yes'
-    lib = 'gmsh-{}-py3-none-linux_x86_64.whl'.format(Gitlab.LIB_VERSION)
-
-    # Create a temporary directory
-    with tempfile.TemporaryDirectory() as path:
-        pkgs = os.path.join(path, lib)
-        curl = [f'curl https://{Gitlab.LIB_GITLAB}/api/v4/projects/{Gitlab.LIB_PROJECT}/repository/files/{lib}/raw?lfs={lfs} --output {pkgs}']  # noqa: E501
-        subprocess.run(curl, check=True, shell=True)
-
-        # Compare the hash
-        # > Initialize a new sha256 hash
-        sha256 = hashlib.sha256()
-        with open(pkgs, 'rb') as f:
-            # Read and update hash string value in blocks of 4K
-            for chunk in iter(lambda: f.read(4096), b""):
-                sha256.update(chunk)
-
-        if sha256.hexdigest() == Gitlab.LIB_HASH:
-            hopout.info('Hash matches, installing Gmsh wheel...')
-        else:
-            hopout.warning('Hash mismatch, exiting...')
-            sys.exit(1)
-
-        # Remove the old version
-        try:
-            meta = metadata.metadata('gmsh')
-            if meta is not None:
-                subprocess.run([sys.executable, '-m', 'pip', 'uninstall', '-y', 'gmsh'], check=True)
+    if version == 'nrg':
+        # Gitlab "python-gmsh" access
+        lfs = 'yes'
+        lib = 'gmsh-{}-py3-none-{}_{}.whl'.format(Gitlab.LIB_VERSION,system,arch)
+
+        # Create a temporary directory
+        with tempfile.TemporaryDirectory() as path:
+            # On macOS add major version string to filename an rename darwin to macosx in whl filename
+            if system == 'darwin':
+                mac_ver = platform.mac_ver()[0].split('.')[0]
+                lib  = lib.replace('darwin','macosx')
+                pkgs = os.path.join(path, lib.replace('macosx_',f'macosx_{mac_ver}_0_'))
+            else:
+                pkgs = os.path.join(path, lib)
+
+            curl = [f'curl https://{Gitlab.LIB_GITLAB}/api/v4/projects/{Gitlab.LIB_PROJECT}/repository/files/{lib}/raw?lfs={lfs} --output {pkgs}']  # noqa: E501
+            subprocess.run(curl, check=True, shell=True)
+
+            # Compare the hash
+            # > Initialize a new sha256 hash
+            sha256 = hashlib.sha256()
+            with open(pkgs, 'rb') as f:
+                # Read and update hash string value in blocks of 4K
+                for chunk in iter(lambda: f.read(4096), b""):
+                    sha256.update(chunk)
+
+            if sha256.hexdigest() == Gitlab.LIB_SUPPORT[system][arch]:
+                hopout.info('Hash matches, installing Gmsh wheel...')
+            else:
+                hopout.warning('Hash mismatch, exiting...')
+                sys.exit(1)
+
+            # Remove the old version
+            try:
+                meta = metadata.metadata('gmsh')
+                if meta is not None:
+                    subprocess.run([sys.executable, '-m', 'pip', 'uninstall', '-y', 'gmsh'], check=True)
 
-        except metadata.PackageNotFoundError:
-            pass
+            except metadata.PackageNotFoundError:
+                pass
 
+            # Install the package in the current environment
+            subprocess.run([sys.executable, '-m', 'pip', 'install', pkgs], check=True)
+    else:
         # Install the package in the current environment
-        subprocess.run([sys.executable, '-m', 'pip', 'install', pkgs], check=True)
+        subprocess.run([sys.executable, '-m', 'pip', 'install', 'gmsh'], check=True)
 
 
 # > https://stackoverflow.com/a/5419576/23851165

{pyhope-0.0.2 → pyhope-0.0.4}/pyhope/common/common_vars.py

@@ -25,6 +25,10 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
+import importlib.metadata
+import pathlib
+import re
+from typing import Self
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -38,12 +42,55 @@ from packaging.version import Version
 # ==================================================================================================================================
 
 
+# PEP 318 – Decorators for Functions and Methods
+# > https://peps.python.org/pep-0318/
+def singleton(cls):
+    instances = {}
+
+    def getinstance():
+        if cls not in instances:
+            instances[cls] = cls()
+        return instances[cls]
+    return getinstance
+
+
+@singleton
 class Common():
-    __version__ = Version('0.0.2')
-    __program__ = 'PyHOPE'
+    def __init__(self: Self) -> None:
+        self._version = self.__version__
+        self._program = self.__program__
+
+    @property
+    def __version__(self):
+        # Retrieve version from package metadata
+        try:
+            package = pathlib.Path(__file__).parent.parent.name
+            version = importlib.metadata.version(package)
+        # Fallback to pyproject.toml
+        except importlib.metadata.PackageNotFoundError:
+            pyproject = pathlib.Path(__file__).parent.parent.parent / 'pyproject.toml'
+            if not pyproject.exists():
+                raise FileNotFoundError(f'pyproject.toml not found at {pyproject}')
+
+            with pyproject.open('r') as p:
+                match = re.search(r'version\s*=\s*["\'](.+?)["\']', p.read())
+            if not match:
+                raise ValueError('Version not found in pyproject.toml')
+            version = match.group(1)
+
+        return Version(version)
+
+    @property
+    def __program__(self):
+        return 'PyHOPE'
+
+    @property
+    def program(self):
+        return str(self._program)
 
-    program: str = str(__program__)
-    version: str = str(__version__)
+    @property
+    def version(self):
+        return str(self._version)
 
 
 class Gitlab():
@@ -52,7 +99,15 @@ class Gitlab():
     # LIB_PROJECT  = 'libs/python-gmsh'
     LIB_PROJECT: str = '797'
     LIB_VERSION: str = '4.13.1'
-    LIB_HASH:    str = '82f655d3a7d97da5b4de06fd0af2198a95b8098a10b3f89edc99764f635c5d4d'
+    LIB_SUPPORT         = {
+        "linux": {
+            "x86_64" : "00a42b3b9c9ae51297052a9e9a16646d34743fa0b0742d1998df297c48a212ce",
+            "aarch64": "c57abb56759cc476752c21b6b19127888bd3fed67c4a0dd38f6755603d8d6b74"
+        },
+        "darwin": {
+            "arm64"  : "ed03477fa3cdee5594a18e46a450acadf63b3d41c7bd575ef71192f221719361"
+        }
+    }
 
 
-np_mtp : int                                     # Number of threads for multiprocessing
+np_mtp : int  # Number of threads for multiprocessing

{pyhope-0.0.2 → pyhope-0.0.4}/pyhope/io/io.py

@@ -147,10 +147,10 @@ def DefineIO() -> None:
 
     CreateSection('Output')
     CreateStr('ProjectName', help='Name of output files')
-    CreateIntFromString('OutputFormat', default=0    , help='Mesh output format')
+    CreateIntFromString('OutputFormat', default='HDF5', help='Mesh output format')
     CreateIntOption(    'OutputFormat', number=MeshFormat.FORMAT_HDF5, name='HDF5')
     CreateIntOption(    'OutputFormat', number=MeshFormat.FORMAT_VTK , name='VTK')
-    CreateLogical(      'DebugVisu'   , default=False, help='Launch the GMSH GUI to visualize the mesh')
+    CreateLogical(      'DebugVisu'   , default=False , help='Launch the GMSH GUI to visualize the mesh')
 
 
 def InitIO() -> None:
@@ -191,7 +191,7 @@ def IO() -> None:
 
             nElems = len(elems)
             nSides = len(sides)
-            nNodes = np.sum([s['Nodes'].size for s in elems])  # number of non-unique nodes
+            nNodes = np.sum([s.nodes.size for s in elems])  # number of non-unique nodes
 
             bcs   = mesh_vars.bcs
             nBCs  = len(bcs)
@@ -213,8 +213,9 @@ def IO() -> None:
 
             with h5py.File(fname, mode='w') as f:
                 # Store same basic information
-                f.attrs['HoprVersion'   ] = Common.version
-                f.attrs['HoprVersionInt'] = Common.__version__.micro + Common.__version__.minor*100 + Common.__version__.major*10000
+                common = Common()
+                f.attrs['HoprVersion'   ] = common.version
+                f.attrs['HoprVersionInt'] = common.__version__.micro + common.__version__.minor*100 + common.__version__.major*10000
 
                 # Store mesh information
                 f.attrs['Ngeo'          ] = mesh_vars.nGeo
@@ -229,10 +230,10 @@ def IO() -> None:
 
                 # Store boundary information
                 f.attrs['nBCs'          ] = nBCs
-                bcNames = [f'{s["Name"]:<255}' for s in bcs]
+                bcNames = [f'{s.name:<255}' for s in bcs]
                 bcTypes = np.zeros((nBCs, 4), dtype=np.int32)
                 for iBC, bc in enumerate(bcs):
-                    bcTypes[iBC, :] = bc['Type']
+                    bcTypes[iBC, :] = bc.type
 
                 f.create_dataset('BCNames'   , data=np.bytes_(bcNames))
                 f.create_dataset('BCType'    , data=bcTypes)
@@ -265,7 +266,7 @@ def getMeshInfo() -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, dict]
 
     nElems = len(elems)
     nSides = len(sides)
-    nNodes = np.sum([s['Nodes'].size for s in elems])  # number of non-unique nodes
+    nNodes = np.sum([s.nodes.size for s in elems])  # number of non-unique nodes
 
     # Create the ElemCounter
     elemCounter = dict()
@@ -278,44 +279,44 @@ def getMeshInfo() -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, dict]
     nodeCount = 0  # elem['Nodes'] contains the unique nodes
 
     for iElem, elem in enumerate(elems):
-        elemInfo[iElem, ELEM.TYPE     ] = elem['Type']
+        elemInfo[iElem, ELEM.TYPE     ] = elem.type
         elemInfo[iElem, ELEM.ZONE     ] = 1  # FIXME
 
         elemInfo[iElem, ELEM.FIRSTSIDE] = sideCount
-        elemInfo[iElem, ELEM.LASTSIDE ] = sideCount + len(elem['Sides'])
-        sideCount += len(elem['Sides'])
+        elemInfo[iElem, ELEM.LASTSIDE ] = sideCount + len(elem.sides)
+        sideCount += len(elem.sides)
 
         elemInfo[iElem, ELEM.FIRSTNODE] = nodeCount
-        elemInfo[iElem, ELEM.LASTNODE ] = nodeCount + len(elem['Nodes'])
-        nodeCount += len(elem['Nodes'])
+        elemInfo[iElem, ELEM.LASTNODE ] = nodeCount + len(elem.nodes)
+        nodeCount += len(elem.nodes)
 
-        elemCounter[elem['Type']] += 1
+        elemCounter[elem.type] += 1
 
     # Fill the SideInfo
     sideInfo  = np.zeros((nSides, SIDE.INFOSIZE), dtype=np.int32)
 
     for iSide, side in enumerate(sides):
-        sideInfo[iSide, SIDE.TYPE     ] = side['Type'  ]
-        sideInfo[iSide, SIDE.ID       ] = side['GlobalSideID']
+        sideInfo[iSide, SIDE.TYPE     ] = side.sideType
+        sideInfo[iSide, SIDE.ID       ] = side.globalSideID
         # Connected sides
-        if 'Connection' in side:
-            nbSideID = side['Connection']
-            nbElemID = sides[nbSideID]['ElemID'] + 1  # Python -> HOPR index
+        if side.connection is not None:
+            nbSideID = side.connection
+            nbElemID = sides[nbSideID].elemID + 1  # Python -> HOPR index
             sideInfo[iSide, SIDE.NBELEMID      ] = nbElemID
-            if side['Flip'] == 0:  # Master side
-                sideInfo[iSide, SIDE.NBLOCSIDE_FLIP] = sides[nbSideID]['LocSide']*10
+            if side.flip == 0:  # Master side
+                sideInfo[iSide, SIDE.NBLOCSIDE_FLIP] = sides[nbSideID].locSide*10
             else:
-                sideInfo[iSide, SIDE.NBLOCSIDE_FLIP] = sides[nbSideID]['LocSide']*10 + side['Flip']
+                sideInfo[iSide, SIDE.NBLOCSIDE_FLIP] = sides[nbSideID].locSide*10 + side.flip
 
             # Periodic sides still have a BCID
-            if 'BCID' in side:
-                sideInfo[iSide, SIDE.BCID      ] = side['BCID'] + 1
+            if side.bcid is not None:
+                sideInfo[iSide, SIDE.BCID      ] = side.bcid + 1
             else:
                 sideInfo[iSide, SIDE.BCID      ] = 0
         else:
             sideInfo[iSide, SIDE.NBELEMID      ] = 0
             sideInfo[iSide, SIDE.NBLOCSIDE_FLIP] = 0
-            sideInfo[iSide, SIDE.BCID          ] = side['BCID'] + 1
+            sideInfo[iSide, SIDE.BCID          ] = side.bcid + 1
 
     # Fill the NodeInfo
     nodeInfo = np.zeros((ELEM.INFOSIZE, nNodes), dtype=np.int32)
@@ -326,11 +327,11 @@ def getMeshInfo() -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, dict]
 
     for iElem, elem in enumerate(elems):
         # Mesh coordinates are stored in meshIO sorting
-        linMap    = LINMAP(elem['Type'], order=mesh_vars.nGeo)
+        linMap    = LINMAP(elem.type, order=mesh_vars.nGeo)
         # meshio accesses them in their own ordering
         # > need to reverse the mapping
         mapLin    = {k: v for v, k in enumerate(linMap)}
-        elemNodes = elem['Nodes']
+        elemNodes = elem.nodes
 
         # Access the actual nodeCoords and reorder them
         for iNode, nodeID in enumerate(elemNodes):

{pyhope-0.0.2 → pyhope-0.0.4}/pyhope/mesh/mesh.py

@@ -44,26 +44,32 @@ def DefineMesh() -> None:
     """
     # Local imports ----------------------------------------
     from pyhope.readintools.readintools import CreateInt, CreateIntArray, CreateRealArray, CreateSection, CreateStr, CreateLogical
+    from pyhope.readintools.readintools import CreateIntFromString, CreateIntOption
+    from pyhope.mesh.mesh_vars import ELEMTYPE
     # ------------------------------------------------------
 
     CreateSection('Mesh')
-    CreateInt(      'Mode',                              help='Mesh generation mode (1 - Internal, 2 - External [MeshIO])')
+    CreateInt(      'Mode',                               help='Mesh generation mode (1 - Internal, 2 - External [MeshIO])')
     # Internal mesh generator
-    CreateInt(      'nZones',                            help='Number of mesh zones')
-    CreateRealArray('Corner',         24, multiple=True, help='Corner node positions: (/ x_1,y_1,z_1,, x_2,y_2,z_2,, '
-                                                                                       '... ,, x_8,y_8,z_8/)')  # noqa: E127
-    CreateIntArray( 'nElems',          3, multiple=True, help='Number of elements in each direction')
-    CreateStr(      'BoundaryName',       multiple=True, help='Name of domain boundary')
-    CreateIntArray( 'BoundaryType',    4, multiple=True, help='(/ Type, curveIndex, State, alpha /)')
-    CreateIntArray( 'BCIndex',         6, multiple=True, help='Index of BC for each boundary face')
-    CreateRealArray('vv',              3, multiple=True, help='Vector for periodic BC')
+    CreateInt(      'nZones',                             help='Number of mesh zones')
+    CreateRealArray('Corner',         24,  multiple=True, help='Corner node positions: (/ x_1,y_1,z_1,, x_2,y_2,z_2,, '
+                                                                                        '... ,, x_8,y_8,z_8/)')  # noqa: E127
+    CreateIntArray( 'nElems',          3,  multiple=True, help='Number of elements in each direction')
+    CreateIntFromString('ElemType'      ,  multiple=True, default='hexahedron', help='Element type')
+    for key, val in ELEMTYPE.name.items():
+        CreateIntOption('ElemType', number=val, name=key)
+    CreateStr(      'BoundaryName',        multiple=True, help='Name of domain boundary')
+    CreateIntArray( 'BoundaryType',    4,  multiple=True, help='(/ Type, curveIndex, State, alpha /)')
+    CreateIntArray( 'BCIndex',         6,  multiple=True, help='Index of BC for each boundary face')
+    CreateRealArray('vv',              3,  multiple=True, help='Vector for periodic BC')
     # External mesh readin through GMSH
-    CreateStr(      'Filename',           multiple=True, help='Name of external mesh file')
-    CreateLogical(  'MeshIsAlreadyCurved',default=False, help='Enables mesh agglomeration')
+    CreateStr(      'Filename',            multiple=True, help='Name of external mesh file')
+    CreateLogical(  'MeshIsAlreadyCurved', default=False, help='Enables mesh agglomeration')
     # Common settings
-    CreateInt(      'BoundaryOrder',      default=2,     help='Order of spline-reconstruction for curved surfaces')
-    CreateLogical(  'doSortIJK',          default=False, help='Sort the mesh elements along the I,J,K directions')
-    CreateLogical(  'CheckElemJacobians', default=True,  help='Check the Jacobian and scaled Jacobian for each element')
+    CreateInt(      'NGeo'         ,       default=1,     help='Order of spline-reconstruction for curved surfaces')
+    CreateInt(      'BoundaryOrder',       default=2,     help='Order of spline-reconstruction for curved surfaces (legacy)')
+    CreateLogical(  'doSortIJK',           default=False, help='Sort the mesh elements along the I,J,K directions')
+    CreateLogical(  'CheckElemJacobians',  default=True,  help='Check the Jacobian and scaled Jacobian for each element')
 
 
 def InitMesh() -> None:
@@ -72,17 +78,28 @@ def InitMesh() -> None:
     # Local imports ----------------------------------------
     import pyhope.mesh.mesh_vars as mesh_vars
     import pyhope.output.output as hopout
-    from pyhope.readintools.readintools import GetInt
+    from pyhope.readintools.readintools import GetInt, CountOption
     # ------------------------------------------------------
 
     hopout.separator()
     hopout.info('INIT MESH...')
 
     mesh_vars.mode = GetInt('Mode')
-    mesh_vars.nGeo = GetInt('BoundaryOrder') - 1
-    if mesh_vars.nGeo < 1:
-        hopout.warning('Effective boundary order < 1. Try increasing the BoundaryOrder parameter!')
+
+    NGeo     = GetInt('NGeo')          if CountOption('NGeo')          else None
+    BCOrder  = GetInt('BoundaryOrder') if CountOption('BoundaryOrder') else None
+
+    if not NGeo and not BCOrder:
+        mesh_vars.nGeo = 1
+    elif NGeo and BCOrder and NGeo != BCOrder - 1:
+        hopout.warning('NGeo / BoundaryOrder must be equal to NGeo + 1!')
         sys.exit(1)
+    else:
+        mesh_vars.nGeo = NGeo or (BCOrder - 1)
+
+        if mesh_vars.nGeo < 1:
+            hopout.warning('Effective boundary order < 1. Try increasing the NGeo / BoundaryOrder parameter!')
+            sys.exit(1)
 
     hopout.info('INIT MESH DONE!')