PyHOPE 0.0.9__tar.gz → 0.1.1__tar.gz

pyhope-0.1.1/AUTHORS.md

@@ -0,0 +1,24 @@
+<div class="no-extra-css"></div>
+# Authors
+
+PyHOPE's development is coordinated by the Numerics Research Group (NRG) at 
+University of Stuttgart. The primary contact is Patrick Kopper, who is the *principal developer*
+and main contributor. In addition, there are *contributors* who have
+provided substantial additions or modifications. Together, these two groups form
+authors as mentioned in the [LICENSE.md](LICENSE.md) file.
+
+## Principal Developers
+* [Patrick Kopper](https://www.iag.uni-stuttgart.de/en/institute/team/Kopper-00001/),
+  University of Stuttgart, Germany
+
+## Contributors
+The following people contributed major additions or modifications to PyHOPE and
+are listed in alphabetical order:
+
+* Daniel Appel
+* Marcel Blind
+* Stephen Copplestone
+* Patrick Kopper
+* Marius Kurz
+* Felix Rodach
+* Anna Schwarz

{pyhope-0.0.9 → pyhope-0.1.1}/PKG-INFO

@@ -1,8 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: PyHOPE
-Version: 0.0.9
+Version: 0.1.1
 Summary: Python High-Order Preprocessing Environment
 License: GPL-3.0-only
+License-File: AUTHORS.md
+License-File: LICENSE.md
 Keywords: PyHOPE,mesh generator
 Author: Numerics Research Group (NRG)
 Author-email: numerics@iag.uni-stuttgart.de
@@ -24,10 +26,10 @@ Requires-Dist: numpy (>=2.0.0)
 Requires-Dist: packaging
 Requires-Dist: plotext
 Requires-Dist: scipy
-Requires-Dist: sortedcontainers
 Requires-Dist: typing-extensions
+Project-URL: Documentation, https://hopr-framework.github.io/PyHOPE
 Project-URL: Homepage, https://numericsresearchgroup.org
-Project-URL: Repository, https://gitlab.iag.uni-stuttgart.de/flexi/codes/pyhope
+Project-URL: Repository, https://github.com/hopr-framework/pyhope
 Description-Content-Type: text/markdown
 
 PyHOPE (Python High-Order Preprocessing Environment) is an open-source Python framework for the generation of three-dimensional unstructured high-order meshes. These meshes are needed by high-order numerical methods like Discontinuous Galerkin, Spectral Element Methods, or pFEM, in order to retain their accuracy if the computational domain includes curved boundaries.
@@ -49,22 +51,44 @@ PyHOPE is built using standard Python packages. You can install PyHOPE by follow
     ```
     If you choose not to use a virtual environment, skip this step and proceed directly to the installation of PyHOPE.
 
+> [!IMPORTANT]  
+> For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+
 2.  **Install PyHOPE**  
     PyHOPE is installed using `pip`, the Python package installer. This command fetches the PyHOPE package and its dependencies from PyPI (Python Package Index) and installs them.
     ```bash
     python -m pip install pyhope
     ```
 
-3. **Run PyHOPE**
-    PyHOPE is available as a command-line tool. After installation, its functionalities can be accessed directly from the terminal.
-    ```bash
-    pyhope --help
-    ```
+# Testing
+PyHOPE features internal health checks to verify that everything works as expected. The checks can be invoked directly from the terminal.
+```bash
+pyhope --verify [tutorials]          # Run all health checks
+pyhope --verify-health               # Run Python health checks
+pyhope --verify-install [tutorials]  # Run PyHOPE mesh generation checks
+```
 
-    > 🛈 Remark: For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+> [!NOTE]  
+>  By default, PyHOPE looks for the `tutorials` directory relative to the current working directory or the git root. If neither exists, PyHOPE downloads the tests from GitHub while using available authentication methods.
+
+# Getting Help
+PyHOPE help output is formatted to serve as self-hosting INI format. A list of all options and the default values can be accessed by running the following command.
+```bash
+pyhope --help
+```
+
+# Documentation
+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).
 
 # Usage
-PyHOPE is invoked from the command line. Run parameters are read from a configuration file. The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
+PyHOPE can either be invoked directly from the command line or used as a Python library.
+
+## Command Line Usage
+PyHOPE can be invoked from the command line. After installation, its functionalities can be accessed directly from the terminal by passing a valid configuration file.
+```bash
+pyhope [parameter.ini]
+```
+The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
 ```
 $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -81,7 +105,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ INIT MESH...
 │                            Mode │ 1 [Internal]                    │ *CUSTOM │
-│                            NGeo │ 4                               │ *CUSTOM │
+│                            NGeo │ 9                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ GENERATE MESH...
 ├────
@@ -89,6 +113,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├── Generating zone 1
 │                          Corner │ (/0.,0.,0. ,,1.,0.,0. ,,1.,1... │ *CUSTOM │
 │                          nElems │ (/8,8,8/)                       │ *CUSTOM │
+│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
 │                     StretchType │ (/0,0,0/)                       │ DEFAULT │
 │                         BCIndex │ (/1,2,3,4,5,6/)                 │ *CUSTOM │
 ├────
@@ -111,8 +136,6 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │                              vv │ (/0., 1., 0./)                  │ *CUSTOM │
 │                              vv │ (/0., 0., 1./)                  │ *CUSTOM │
 ├────
-│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
-├────
 ├── Generated mesh with 512 cells
 ├─────────────────────────────────────────────
 ├── BUILD DATA STRUCTURE...
@@ -133,7 +156,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ CONNECT MESH...
 ├────
-│               doPeriodicCorrect │ True                            │ DEFAULT │
+│               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
 ├────
 │  Number of sides                :         3072
@@ -143,6 +166,11 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │  Number of boundary sides       :          384
 │  Number of periodic sides       :            0
 ├─────────────────────────────────────────────
+│ CHECK CONNECTIVITY...
+├────
+│               CheckConnectivity │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
+├─────────────────────────────────────────────
 │ CHECK WATERTIGHTNESS...
 ├────
 │             CheckWatertightness │ True                            │ DEFAULT │
@@ -178,3 +206,15 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
+## Python Library Usage
+PyHOPE can be included in other Python libraries. PyHOPE exposes its functionally via runtime contexts defined by [Context Managers](https://docs.python.org/3/library/stdtypes.html#typecontextmanager). The following Python code loads a HOPR HDF5 mesh and derived quantities. For a complete list of currently implemented functions, see the [source code](pyhope/__init__.py).
+```python
+from pyhope import Basis, Mesh
+with Mesh('1-01-cartbox_mesh.h5') as m:
+    elems = m.elems
+    lobatto_nodes = Basis.legendre_gauss_lobatto_nodes(order=m.nGeo)
+```
+
+# Licence
+PyHOPE is licensed under the GPL-3.0 license (see [LICENSE.md](LICENSE.md)).
+

{pyhope-0.0.9 → pyhope-0.1.1}/README.md

@@ -17,22 +17,44 @@ PyHOPE is built using standard Python packages. You can install PyHOPE by follow
     ```
     If you choose not to use a virtual environment, skip this step and proceed directly to the installation of PyHOPE.
 
+> [!IMPORTANT]  
+> For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+
 2.  **Install PyHOPE**  
     PyHOPE is installed using `pip`, the Python package installer. This command fetches the PyHOPE package and its dependencies from PyPI (Python Package Index) and installs them.
     ```bash
     python -m pip install pyhope
     ```
 
-3. **Run PyHOPE**
-    PyHOPE is available as a command-line tool. After installation, its functionalities can be accessed directly from the terminal.
-    ```bash
-    pyhope --help
-    ```
+# Testing
+PyHOPE features internal health checks to verify that everything works as expected. The checks can be invoked directly from the terminal.
+```bash
+pyhope --verify [tutorials]          # Run all health checks
+pyhope --verify-health               # Run Python health checks
+pyhope --verify-install [tutorials]  # Run PyHOPE mesh generation checks
+```
 
-    > 🛈 Remark: For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+> [!NOTE]  
+>  By default, PyHOPE looks for the `tutorials` directory relative to the current working directory or the git root. If neither exists, PyHOPE downloads the tests from GitHub while using available authentication methods.
+
+# Getting Help
+PyHOPE help output is formatted to serve as self-hosting INI format. A list of all options and the default values can be accessed by running the following command.
+```bash
+pyhope --help
+```
+
+# Documentation
+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).
 
 # Usage
-PyHOPE is invoked from the command line. Run parameters are read from a configuration file. The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
+PyHOPE can either be invoked directly from the command line or used as a Python library.
+
+## Command Line Usage
+PyHOPE can be invoked from the command line. After installation, its functionalities can be accessed directly from the terminal by passing a valid configuration file.
+```bash
+pyhope [parameter.ini]
+```
+The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
 ```
 $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -49,7 +71,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ INIT MESH...
 │                            Mode │ 1 [Internal]                    │ *CUSTOM │
-│                            NGeo │ 4                               │ *CUSTOM │
+│                            NGeo │ 9                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ GENERATE MESH...
 ├────
@@ -57,6 +79,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├── Generating zone 1
 │                          Corner │ (/0.,0.,0. ,,1.,0.,0. ,,1.,1... │ *CUSTOM │
 │                          nElems │ (/8,8,8/)                       │ *CUSTOM │
+│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
 │                     StretchType │ (/0,0,0/)                       │ DEFAULT │
 │                         BCIndex │ (/1,2,3,4,5,6/)                 │ *CUSTOM │
 ├────
@@ -79,8 +102,6 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │                              vv │ (/0., 1., 0./)                  │ *CUSTOM │
 │                              vv │ (/0., 0., 1./)                  │ *CUSTOM │
 ├────
-│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
-├────
 ├── Generated mesh with 512 cells
 ├─────────────────────────────────────────────
 ├── BUILD DATA STRUCTURE...
@@ -101,7 +122,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ CONNECT MESH...
 ├────
-│               doPeriodicCorrect │ True                            │ DEFAULT │
+│               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
 ├────
 │  Number of sides                :         3072
@@ -111,6 +132,11 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │  Number of boundary sides       :          384
 │  Number of periodic sides       :            0
 ├─────────────────────────────────────────────
+│ CHECK CONNECTIVITY...
+├────
+│               CheckConnectivity │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
+├─────────────────────────────────────────────
 │ CHECK WATERTIGHTNESS...
 ├────
 │             CheckWatertightness │ True                            │ DEFAULT │
@@ -145,3 +171,15 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┃ PyHOPE completed in [0.25 sec]
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
+
+## Python Library Usage
+PyHOPE can be included in other Python libraries. PyHOPE exposes its functionally via runtime contexts defined by [Context Managers](https://docs.python.org/3/library/stdtypes.html#typecontextmanager). The following Python code loads a HOPR HDF5 mesh and derived quantities. For a complete list of currently implemented functions, see the [source code](pyhope/__init__.py).
+```python
+from pyhope import Basis, Mesh
+with Mesh('1-01-cartbox_mesh.h5') as m:
+    elems = m.elems
+    lobatto_nodes = Basis.legendre_gauss_lobatto_nodes(order=m.nGeo)
+```
+
+# Licence
+PyHOPE is licensed under the GPL-3.0 license (see [LICENSE.md](LICENSE.md)).

pyhope-0.1.1/pyhope/__init__.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+# This file is part of PyHOPE
+#
+# Copyright (c) 2024 Numerics Research Group, University of Stuttgart, Prof. Andrea Beck
+#
+# PyHOPE is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# PyHOPE is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# PyHOPE. If not, see <http://www.gnu.org/licenses/>.
+
+
+# ==================================================================================================================================
+# Mesh generation library
+# ==================================================================================================================================
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Standard libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+from collections import namedtuple
+from contextlib import contextmanager
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Third-party libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Local imports
+# ----------------------------------------------------------------------------------------------------------------------------------
+from pyhope.basis.basis_basis import legendre_gauss_nodes, legendre_gauss_lobatto_nodes
+from pyhope.basis.basis_basis import barycentric_weights, polynomial_derivative_matrix
+from pyhope.basis.basis_basis import lagrange_interpolation_polys, calc_vandermonde
+from pyhope.basis.basis_basis import change_basis_3D, change_basis_2D
+from pyhope.basis.basis_basis import evaluate_jacobian
+# ==================================================================================================================================
+
+
+class Basis:
+    """ Basis class to hold all basis related functions and variables
+    """
+    legendre_gauss_nodes         = staticmethod(legendre_gauss_nodes)
+    legendre_gauss_lobatto_nodes = staticmethod(legendre_gauss_lobatto_nodes)
+    barycentric_weights          = staticmethod(barycentric_weights)
+    polynomial_derivative_matrix = staticmethod(polynomial_derivative_matrix)
+    lagrange_interpolation_polys = staticmethod(lagrange_interpolation_polys)
+    calc_vandermonde             = staticmethod(calc_vandermonde)
+    change_basis_3D              = staticmethod(change_basis_3D)
+    change_basis_2D              = staticmethod(change_basis_2D)
+    evaluate_jacobian            = staticmethod(evaluate_jacobian)
+
+
+# Define a named tuple to hold the mesh data
+MeshContainer = namedtuple('Mesh',
+                          ['mesh',   # The generated mesh object
+                           'nGeo',   # Polynomial order
+                           'bcs',    # Boundary conditions
+                           'elems',  # Elements
+                           'sides'   # Sides
+                          ])
+
+
+@contextmanager  # pragma: no cover
+def Mesh(*args, stdout=False, stderr=True):
+    """ Mesh context manager to generate a mesh from a given file
+
+        Args:
+            *args: The mesh file path(s) to be processed
+            stdout (bool): If False, standard output is suppressed
+            stderr (bool): If False, standard error  is suppressed
+
+        Yields:
+            Mesh: An object containing the generated mesh and its properties
+    """
+    # Standard libraries -----------------------------------
+    import os
+    # Third-party libraries --------------------------------
+    import h5py
+    from contextlib import redirect_stdout, redirect_stderr, ExitStack
+    # Local imports ----------------------------------------
+    import pyhope.config.config as config
+    import pyhope.mesh.mesh_vars as mesh_vars
+    from pyhope.common.common import DefineCommon, InitCommon
+    from pyhope.io.io import DefineIO, InitIO
+    from pyhope.mesh.connect.connect import ConnectMesh
+    from pyhope.mesh.mesh import DefineMesh, InitMesh, GenerateMesh
+    from pyhope.mesh.mesh_sides import GenerateSides
+    from pyhope.readintools.readintools import DefineConfig, ReadConfig
+    # ------------------------------------------------------
+
+    try:
+        # Check if the arguments provided are valid mesh files
+        if not args:
+            raise ValueError('No mesh file provided.')
+
+        for arg in args:
+            # Check if the argument is a valid file path
+            if not os.path.isfile(arg):
+                raise FileNotFoundError(f'Mesh file not found: {arg}')
+
+            # Check if the argument is a valid HDF5 file
+            if not h5py.is_hdf5(arg):
+                raise ValueError(f'Mesh file not a valid HDF5 file: {arg}')
+
+        # Suppress output to standard output
+        with ExitStack() as stack:
+            with open(os.devnull, 'w') as null:
+                if not stdout:
+                    stack.enter_context(redirect_stdout(null))
+                if not stderr:
+                    stack.enter_context(redirect_stderr(null))
+
+                # Perform the reduced PyHOPE initialization
+                with DefineConfig() as dc:
+                    config.prms = dc
+                    DefineCommon()
+                    DefineIO()
+                    DefineMesh()
+
+                with ReadConfig(args[0]) as rc:
+                    config.params = rc
+
+                # Read-in required parameters
+                InitCommon()
+                InitIO()
+                InitMesh()
+
+                # Generate the actual mesh
+                GenerateMesh()
+
+                # Build our data structures
+                GenerateSides()
+                ConnectMesh()
+
+        # Export mesh variables
+        mesh = mesh_vars.mesh
+
+        nGeo  = mesh_vars.nGeo
+        bcs   = mesh_vars.bcs
+
+        elems = mesh_vars.elems
+        sides = mesh_vars.sides
+
+        yield MeshContainer(mesh  = mesh,   # noqa: E251
+                            nGeo  = nGeo,   # noqa: E251
+                            bcs   = bcs,    # noqa: E251
+                            elems = elems,  # noqa: E251
+                            sides = sides   # noqa: E251
+                           )
+
+    finally:
+        # Cleanup resources after exiting the context
+        mesh_vars.mesh  = None
+        mesh_vars.nGeo  = None
+        mesh_vars.bcs   = None
+        mesh_vars.elems = None
+        mesh_vars.sides = None

pyhope-0.1.1/pyhope/basis/basis_connect.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+# This file is part of PyHOPE
+#
+# Copyright (c) 2024 Numerics Research Group, University of Stuttgart, Prof. Andrea Beck
+#
+# PyHOPE is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# PyHOPE is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# PyHOPE. If not, see <http://www.gnu.org/licenses/>.
+
+# ==================================================================================================================================
+# Mesh generation library
+# ==================================================================================================================================
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Standard libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+import re
+import sys
+from typing import Final
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Third-party libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+import numpy as np
+import numpy.typing as npt
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Local imports
+# ----------------------------------------------------------------------------------------------------------------------------------
+import pyhope.mesh.mesh_vars as mesh_vars
+from pyhope.mesh.mesh_common import sidetovol2
+from pyhope.mesh.mesh_common import face_to_nodes
+# ==================================================================================================================================
+
+
+def check_sides(elem,
+                ) -> list[bool | int | np.ndarray]:
+    results = []
+    elems:  Final[list]  = mesh_vars.elems
+    sides:  Final[list]  = mesh_vars.sides
+    nGeo:   Final[int]   = mesh_vars.nGeo
+    bcs:    Final[list]  = mesh_vars.bcs
+    # Tolerance for physical comparison
+    tol:    Final[float] = mesh_vars.tolPeriodic
+    vvs:    Final[list]  = mesh_vars.vvs
+    points: Final[npt.NDArray] = mesh_vars.mesh.points
+
+    for SideID in elem.sides:
+        master = sides[SideID]
+        # Only connected sides that are master sides and not small mortar sides
+        if master.connection is None \
+        or master.connection < 0     \
+        or master.MS != 1            \
+        or master.sideType < 0:  # noqa: E271
+            continue
+
+        side   = (master, sides[master.connection])
+
+        # Only actual element sides
+        if side[0].face is None      \
+        or side[1].face is None:  # noqa: E271
+            continue
+
+        # Sanity check the flip with the other nodes
+        elem0  = elems[side[0].elemID]
+        elem1  = elems[side[1].elemID]
+        if elem1.type % 100 != 8:
+            continue
+
+        # Map the meshio nodes to the tensor-product nodes
+        elemType = elem0.type
+        nodes    = elem0.nodes[sidetovol2(nGeo, 0           , side[0].face, elemType)]
+        nbNodes  = elem1.nodes[sidetovol2(nGeo, side[1].flip, side[1].face, elemType)]
+
+        # INFO: THIS CURRENTLY MIGHT NOT WORK SINCE WE POTENTIALLY ONLY HAVE THE CORNER NODES AVAILABLE
+        try:
+            # Translate to periodic nodes if required
+            if side[0].bcid is not None and side[1].bcid is not None and bcs[side[1].bcid].type[0] == 1:
+                nbNodes = np.vectorize(lambda s: mesh_vars.periNodes[(s, bcs[side[1].bcid].name)], otypes=[int])(nbNodes)
+            # Check if the node IDs match
+            success = np.array_equal(nodes, nbNodes)
+        # Fallback to comparison of physical coordinates
+        except KeyError:
+            # Check if periodic vector matches using vectorized np.allclose
+            iVV = bcs[side[0].bcid].type[3]
+            vv  = vvs[np.abs(iVV) - 1]['Dir'] * np.sign(iVV)
+            success = np.allclose(points[nodes] + vv, points[nbNodes], rtol=tol, atol=tol)
+
+        results.append((success, SideID))
+    return results
+
+
+def process_chunk(chunk) -> np.ndarray:
+    """Process a chunk of elements by checking surface normal orientation
+    """
+    chunk_results    = np.empty(len(chunk), dtype=object)
+    chunk_results[:] = [check_sides(elem_data) for elem_data in chunk]
+    return chunk_results
+
+
+def CheckConnect() -> None:
+    """ Check if the mesh is correctly connected
+    """
+    # Local imports ----------------------------------------
+    import pyhope.output.output as hopout
+    import pyhope.mesh.mesh_vars as mesh_vars
+    from pyhope.common.common_parallel import run_in_parallel
+    from pyhope.common.common_vars import np_mtp
+    from pyhope.readintools.readintools import GetLogical
+    # ------------------------------------------------------
+
+    hopout.separator()
+    hopout.info('CHECK CONNECTIVITY...')
+    hopout.sep()
+
+    checkConnectivity  = GetLogical('CheckConnectivity')
+    if not checkConnectivity:
+        return None
+
+    # Check all sides
+    elems:     Final[list] = mesh_vars.elems
+
+    # Only consider hexahedrons
+    if any(e.type % 100 != 8 for e in elems):
+        elemTypes = list(set([e.type for e in elems if e.type % 100 != 8]))
+        print(hopout.warn('Ignored element type: {}'.format(
+            [re.sub(r"\d+$", "", mesh_vars.ELEMTYPE.inam[e][0]) for e in elemTypes]
+        )))
+        return
+
+    # Prepare elements for parallel processing
+    if np_mtp > 0:
+        tasks  = tuple((elem)
+                        for elem in elems)
+        # Run in parallel with a chunk size
+        # > Dispatch the tasks to the workers, minimum 10 tasks per worker, maximum 1000 tasks per worker
+        res    = run_in_parallel(process_chunk, tasks, chunk_size=max(1, min(1000, max(10, int(len(tasks)/(40.*np_mtp))))))
+    else:
+        res    = np.empty(len(elems), dtype=object)
+        res[:] = [check_sides(elem) for elem in elems]
+
+    results = tuple(tuple(result for r in res for result in r if not bool(result[0]))
+)
+    if len(results) > 0:
+        nGeo:      Final[int]        = mesh_vars.nGeo
+        sides:     Final[list]       = mesh_vars.sides
+        points:    Final[np.ndarray] = mesh_vars.mesh.points
+
+        nconn = len(tuple(tuple(result for r in res for result in r)))
+
+        for result in results:
+            # Unpack the results
+            side    = sides[result[1]]
+            elem    = elems[side.elemID]
+            nbside  = sides[side.connection]
+            nbelem  = elems[nbside.elemID]
+
+            nodes   =   elem.nodes[face_to_nodes(  side.face,   elem.type, nGeo)]
+            nbnodes = nbelem.nodes[face_to_nodes(nbside.face, nbelem.type, nGeo)]
+
+            print()
+            # Check if side is oriented inwards
+            errStr = 'Side connectivity does not match the calculated neighbour side'
+            print(hopout.warn(errStr, length=len(errStr)+16))
+
+            # Print the information
+            strLen  = max(len(str(side.sideID+1)), len(str(nbside.sideID+1)))
+            print(hopout.warn(f'> Element {  elem.elemID+1:>{strLen}}, Side {  side.face}, Side {  side.sideID+1:>{strLen}}'))  # noqa: E501
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1, -1]]) + ']'))    # noqa: E271
+            # print()
+            print(hopout.warn(f'> Element {nbelem.elemID+1:>{strLen}}, Side {nbside.face}, Side {nbside.sideID+1:>{strLen}}'))  # noqa: E501
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
+
+        hopout.warning(f'Connectivity check failed for {len(results)} / {nconn} connections!')
+        sys.exit(1)

{pyhope-0.0.9 → pyhope-0.1.1}/pyhope/basis/basis_jacobian.py

@@ -142,8 +142,18 @@ def CheckJacobians() -> None:
     # Prepare elements for parallel processing
     tasks = []
 
-    # Cache the mapping
-    linCache   = {}
+    # Pre-compute LINTEN mappings for all element types
+    linCache  = {}
+    elemOrder = 100 if mesh_vars.nGeo == 1 else 200
+    elemTypes = tuple([s + elemOrder for s in (4, 5, 6, 8)])
+    for elemType in elemTypes:
+        try:
+            _, mapLin = LINTEN(elemType, order=mesh_vars.nGeo)
+            mapLin    = np.array(tuple(mapLin[np.int64(i)] for i in range(len(mapLin))))
+            linCache[elemType] = mapLin
+        # Only hexahedrons supported for specific nGeo
+        except ValueError:
+            pass
 
     for elem in elems:
         elemType = elem.type
@@ -153,12 +163,7 @@ def CheckJacobians() -> None:
             continue
 
         # Get the mapping
-        if elemType in linCache:
-            mapLin = linCache[elemType]
-        else:
-            _, mapLin = LINTEN(elemType, order=mesh_vars.nGeo)
-            mapLin    = np.array(tuple(mapLin[np.int64(i)] for i in range(len(mapLin))))
-            linCache[elemType] = mapLin
+        mapLin = linCache[elemType]
 
         # Fill the NodeCoords
         nodeCoords         = np.empty((nGeo ** 3, 3), dtype=np.float64)