PyHOPE 0.10.0__tar.gz → 1.0.0__tar.gz

{pyhope-0.10.0 → pyhope-1.0.0}/AUTHORS.md

@@ -18,8 +18,10 @@ are listed in alphabetical order:
 * Daniel Appel
 * Marcel Blind
 * Stephen Copplestone
+* Justin Du Plessis
 * Patrick Kopper
 * Marius Kurz
 * Leon Teichröb
 * Felix Rodach
 * Anna Schwarz
+* Michel Tirapelle

{pyhope-0.10.0 → pyhope-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyHOPE
-Version: 0.10.0
+Version: 1.0.0
 Summary: Python High-Order Preprocessing Environment
 License-Expression: GPL-3.0-only
 License-File: AUTHORS.md
@@ -8,6 +8,8 @@ License-File: LICENSE.md
 Keywords: PyHOPE,mesh generator
 Author: Numerics Research Group (NRG)
 Author-email: numerics@iag.uni-stuttgart.de
+Maintainer: Patrick Kopper
+Maintainer-email: kopper@iag.uni-stuttgart.de
 Requires-Python: >=3.10
 Classifier: Development Status :: 4 - Beta
 Classifier: Operating System :: POSIX :: Linux
@@ -29,9 +31,11 @@ Requires-Dist: packaging
 Requires-Dist: plotext
 Requires-Dist: scipy
 Requires-Dist: typing-extensions
+Project-URL: Changelog, https://github.com/hopr-framework/PyHOPE/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://hopr-framework.github.io/PyHOPE
 Project-URL: Homepage, https://numericsresearchgroup.org
-Project-URL: Repository, https://github.com/hopr-framework/pyhope
+Project-URL: Issues, https://github.com/hopr-framework/PyHOPE/issues
+Project-URL: Repository, https://github.com/hopr-framework/PyHOPE
 Description-Content-Type: text/markdown
 
 [![CI](https://github.com/hopr-framework/PyHOPE/actions/workflows/ci.yml/badge.svg)](https://github.com/hopr-framework/PyHOPE/actions/workflows/ci.yml)
@@ -61,7 +65,7 @@ PyHOPE is built using standard Python packages. You can install PyHOPE by follow
 > 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.
+    PyHOPE is installed using `pip`, the Python package installer. This command fetches the PyHOPE package and its dependencies from [PyPI](https://pypi.org/project/PyHOPE) (Python Package Index) and installs them.
     ```bash
     python -m pip install pyhope
     ```
@@ -235,7 +239,7 @@ with Mesh('1-01-cartbox_mesh.h5') as m:
 ```
 
 # Cite
-This is a scientific project. If you use PyHOPE for publications or presentations in science, please support the project by citing the following article.
+This is a scientific project. If you use PyHOPE for publications or presentations in science, please support the project by citing the [following article](https://joss.theoj.org/papers/10.21105/joss.08769).
 ```bibtex
 @article{kopper2025pyhope:joss,
   title        = {{PyHOPE}: A Python Toolkit for Three-Dimensional Unstructured High-Order Meshes},

{pyhope-0.10.0 → pyhope-1.0.0}/README.md

@@ -25,7 +25,7 @@ PyHOPE is built using standard Python packages. You can install PyHOPE by follow
 > 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.
+    PyHOPE is installed using `pip`, the Python package installer. This command fetches the PyHOPE package and its dependencies from [PyPI](https://pypi.org/project/PyHOPE) (Python Package Index) and installs them.
     ```bash
     python -m pip install pyhope
     ```
@@ -199,7 +199,7 @@ with Mesh('1-01-cartbox_mesh.h5') as m:
 ```
 
 # Cite
-This is a scientific project. If you use PyHOPE for publications or presentations in science, please support the project by citing the following article.
+This is a scientific project. If you use PyHOPE for publications or presentations in science, please support the project by citing the [following article](https://joss.theoj.org/papers/10.21105/joss.08769).
 ```bibtex
 @article{kopper2025pyhope:joss,
   title        = {{PyHOPE}: A Python Toolkit for Three-Dimensional Unstructured High-Order Meshes},

{pyhope-0.10.0 → pyhope-1.0.0}/pyhope/__init__.py

@@ -26,24 +26,35 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
+from __future__ import annotations
 from collections import namedtuple
+from collections.abc import Callable
 from contextlib import contextmanager
 from functools import update_wrapper
 from typing import final
+from typing import ParamSpec, TypeVar
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
 # ----------------------------------------------------------------------------------------------------------------------------------
+# Typing libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+import typing
+if typing.TYPE_CHECKING:
+    from types import GeneratorType
+# ----------------------------------------------------------------------------------------------------------------------------------
 # Local imports
 # ----------------------------------------------------------------------------------------------------------------------------------
+P = ParamSpec('P')
+R = TypeVar(  'R')
 # ==================================================================================================================================
 
 
-def _staticwrapper(func):
+def _staticwrapper(func: Callable[P, R]) -> Callable[P, R]:
     """ Custom helper to lift the (annotations, doc, etc.) to the staticmethod
     """
     # Create a wrapper that carries the metadata
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         return func(*args, **kwargs)
 
     # Lift metadata (annotations, doc, etc.) to the wrapper
@@ -97,7 +108,7 @@ class Mapping:
 
 
 # Define a named tuple to hold the mesh data
-MeshContainer = namedtuple('Mesh',
+MeshContainer = namedtuple('Mesh',   # ty: ignore [mismatched-type-name]
                           ['mesh',   # The generated mesh object
                            'nGeo',   # Polynomial order
                            'bcs',    # Boundary conditions
@@ -108,7 +119,7 @@ MeshContainer = namedtuple('Mesh',
 
 
 @contextmanager
-def Mesh(*args: str, stdout: bool = False, stderr: bool = True):
+def Mesh(*args: str, stdout: bool = False, stderr: bool = True) -> GeneratorType:
     """ Mesh context manager to generate a mesh from a given file
 
         Args:
@@ -150,34 +161,33 @@ def Mesh(*args: str, stdout: bool = False, stderr: bool = True):
                 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()
+        with ExitStack() as stack, 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

{pyhope-0.10.0 → pyhope-1.0.0}/pyhope/basis/basis_basis.py

@@ -142,7 +142,7 @@ if not NUMBA_AVAILABLE:
         return 1.0 / wBary
 else:
     @jit(types.float64[:](types.int64, types.float64[:]), nopython=True, cache=True, nogil=True)
-    def barycentric_weights(_, xGP):
+    def barycentric_weights(_: Any, xGP: npt.NDArray[np.float64]) -> float:  # noqa: ANN401
         """ Compute the barycentric weights for a given node set
             > Algorithm 30, Kopriva
         """
@@ -312,12 +312,14 @@ def polynomial_derivative_matrix_prism(order: int, xGP: npt.NDArray[np.float64])
     D   = np.zeros((3, nDOFs, nDOFs), dtype=np.float64)
 
     # Precompute required Jacobi polynomials and derivatives
-    # fZETA(i) = P_i^(0,0)(c), dfZETA(i) = 0.5*(i+1)*P_{i-1}^{(1,1)}(c)
-    fZETA_all  = np.array(tuple(          sp.special.eval_jacobi(i  , 0, 0, c) for i in range(order)))
-    dfZETA_all = np.array(tuple(0.5*(i+1)*sp.special.eval_jacobi(i-1, 1, 1, c) for i in range(order)))
-    # fETA(j) = P_j^(0,0)(tuple(), dfETA(j) = 0.5*(j+1)*P_{j-1}^{(1,1)}(b)
-    fETA_all   = np.array(tuple(          sp.special.eval_jacobi(j  , 0, 0, b) for j in range(order)))
-    dfETA_all  = np.array(tuple(0.5*(j+1)*sp.special.eval_jacobi(j-1, 1, 1, b) for j in range(order)))
+    # fZETA(i) = P_i^(0,0)(c), dfZETA(i) = 0.5*(i+1)*P_{i-1}^{(1,1)}(c), with dfZETA(0)=0
+    fZETA_all  = np.array(tuple(sp.special.eval_jacobi(i, 0, 0, c) for i in range(order)))
+    dfZETA_all = np.array(tuple(np.zeros_like(c) if i == 0 else 0.5*(i+1)*sp.special.eval_jacobi(i-1, 1, 1, c)
+                                for i in range(order)))
+    # fETA(j) = P_j^(0,0)(b), dfETA(j) = 0.5*(j+1)*P_{j-1}^{(1,1)}(b), with dfETA(0)=0
+    fETA_all   = np.array(tuple(sp.special.eval_jacobi(j, 0, 0, b) for j in range(order)))
+    dfETA_all  = np.array(tuple(np.zeros_like(b) if j == 0 else 0.5*(j+1)*sp.special.eval_jacobi(j-1, 1, 1, b)
+                                for j in range(order)))
 
     jacobi_xi_polys  = [[sp.special.jacobi(i, 2*j + 1, 0) for i in range(order - j)] for j in range(order)]
     jacobi_xi_derivs = [[p.deriv() for p in row] for row in jacobi_xi_polys]
@@ -711,7 +713,7 @@ def evaluate_jacobian(xGeo_In:   npt.NDArray[np.float64],
 
 
 def evaluate_jacobian_simplex(xGeo_In:  npt.NDArray[np.float64],
-                              _:        Any,
+                              _:        Any,  # noqa: ANN401
                               D_EqToGL: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     # Perform tensor contraction for each derivative
     # Change basis for each direction

{pyhope-0.10.0 → pyhope-1.0.0}/pyhope/basis/basis_connect.py

@@ -39,6 +39,7 @@ import numpy as np
 # ----------------------------------------------------------------------------------------------------------------------------------
 import typing
 if typing.TYPE_CHECKING:
+    from pyhope.mesh.mesh_vars import ELEM
     import numpy.typing as npt
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Local imports
@@ -49,7 +50,7 @@ from pyhope.mesh.mesh_common import face_to_nodes
 # ==================================================================================================================================
 
 
-def check_sides(elem,
+def check_sides(elem       : ELEM,
                 failed_only: bool = False,
                ) -> Optional[list[tuple]]:
     """ Check if connected sides have matching corner nodes
@@ -64,6 +65,9 @@ def check_sides(elem,
     vvs:    Final[list]  = mesh_vars.vvs
     points: Final[npt.NDArray] = mesh_vars.mesh.points
 
+    if elem.sides is None:
+        return None
+
     for SideID in elem.sides:
         master = sides[SideID]
         # Only connected sides that are master sides and not small mortar sides
@@ -83,7 +87,7 @@ def check_sides(elem,
         # Sanity check the flip with the other nodes
         elem0  = elems[side[0].elemID]
         elem1  = elems[side[1].elemID]
-        if elem1.type % 100 != 8:
+        if elem1.type % 10 != 8:
             continue
 
         # Map the meshio nodes to the tensor-product nodes
@@ -95,7 +99,7 @@ def check_sides(elem,
         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)
+                nbNodes = np.vectorize(lambda s, side=side: 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
@@ -121,7 +125,7 @@ def check_sides(elem,
     return results
 
 
-def process_chunk(chunk) -> list:
+def process_chunk(chunk: tuple) -> list:
     """Process a chunk of elements by checking surface normal orientation
     """
     # Only keep failures to reduce memory and avoid building large arrays of successes
@@ -157,8 +161,8 @@ def CheckConnect() -> None:
     elems:     Final[list] = mesh_vars.elems
 
     # Only consider hexahedrons
-    if any(cast(int, e.type) % 100 != 8 for e in elems):
-        elemTypes = list(set([e.type for e in elems if e.type % 100 != 8]))
+    if any(cast(int, e.type) % 10 != 8 for e in elems):
+        elemTypes = list({e.type for e in elems if e.type % 10 != 8})
         print(hopout.warn('Ignored element type: {}'.format(
             [re.sub(r"\d+$", "", mesh_vars.ELEMTYPE.inam[e][0]) for e in elemTypes]
         )))
@@ -192,7 +196,7 @@ def CheckConnect() -> None:
             if side.connection is None or side.sideType < 0:
                 continue
             # Big mortar side is counted once
-            elif side.connection < 0:
+            if side.connection < 0:
                 nconn += 1
             # Internal side: only count the canonical representative and ignore virtual mortar sides
             elif side.connection >= 0:
@@ -220,16 +224,16 @@ def CheckConnect() -> None:
             # 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(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' 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
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' 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.10.0 → pyhope-1.0.0}/pyhope/basis/basis_jacobian.py

@@ -26,6 +26,7 @@
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
 from __future__ import annotations
+from collections.abc import Callable
 from typing import Final
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
@@ -49,13 +50,15 @@ SIMPLEX_TYPES: Final = {4, 5, 6}
 HEX_TYPE:      Final = 8
 
 
-def evaluate_jacobian_dispatch(nodeCoords, VdmGLtoAP, D_EqToGL, elem_type):
+def evaluate_jacobian_dispatch(nodeCoords: npt.NDArray[np.float64],
+                               VdmGLtoAP : npt.NDArray[np.float64],
+                               D_EqToGL  : npt.NDArray[np.float64],
+                               elem_type : int) -> npt.NDArray:
     if elem_type in SIMPLEX_TYPES:
         return evaluate_jacobian_simplex(nodeCoords, VdmGLtoAP, D_EqToGL)
-    elif elem_type == HEX_TYPE:
+    if elem_type == HEX_TYPE:
         return evaluate_jacobian(        nodeCoords, VdmGLtoAP, D_EqToGL)
-    else:
-        raise ValueError(f"Unsupported element type {elem_type}")
+    raise ValueError(f"Unsupported element type {elem_type}")
 
 
 def plot_histogram(data: npt.NDArray[np.float64]) -> None:
@@ -97,14 +100,14 @@ def plot_histogram(data: npt.NDArray[np.float64]) -> None:
 
 
 # Use Pool initializer to attach process-local data to the worker function
-def init_worker(function, VdmGLtoAP: npt.NDArray[np.float64], D_EqToGL: npt.NDArray[np.float64]) -> None:
+def init_worker(function: Callable, VdmGLtoAP: npt.NDArray[np.float64], D_EqToGL: npt.NDArray[np.float64]) -> None:
     """Initializer to set process-local attributes on the worker function
     """
     function.VdmGLtoAP = VdmGLtoAP
     function.D_EqToGL  = D_EqToGL
 
 
-def process_chunk(chunk) -> list[npt.NDArray[np.float64]]:
+def process_chunk(chunk: tuple) -> list[npt.NDArray[np.float64]]:
     """Process a chunk of elements by evaluating the Jacobian for each
     """
     chunk_results = []
@@ -155,7 +158,7 @@ def CheckJacobians() -> None:
     nGeo:      Final[int]  = mesh_vars.nGeo + 1
     elems:     Final[list] = mesh_vars.elems
     nodes:     Final[npt.NDArray[np.float64]] = mesh_vars.mesh.points
-    elemBases: Final[set]  = set([e.type % 100 for e in elems])
+    elemBases: Final[set]  = {e.type % 10 for e in elems}
 
     # Compute the equidistant point set used by meshIO
     xEq_fn      = {4: lambda: equi_nodes_tetra(nGeo),                                          # Tetrahedron
@@ -201,19 +204,19 @@ def CheckJacobians() -> None:
     # 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 elemBases])
+    elemTypes = tuple(s + elemOrder for s in elemBases)
     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:
+        except ValueError:  # noqa: PERF203
             pass
 
     for elem in elems:
         elemType = elem.type
-        elemBase = int(elemType) % 100
+        elemBase = int(elemType) % 10
 
         # Get the mapping
         mapLin = linCache[elemType]
@@ -266,5 +269,5 @@ def CheckJacobians() -> None:
     # Append the Jacobians to the elements
     jacIter = iter(jacs)
     for elem in elems:
-        elemType = elem.type
+        # elemType = elem.type
         elem.jacobian = next(jacIter)

{pyhope-0.10.0 → pyhope-1.0.0}/pyhope/basis/basis_watertight.py

@@ -29,7 +29,7 @@ from __future__ import annotations
 import gc
 import re
 from typing import Final, Optional, cast
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -41,6 +41,7 @@ import typing
 from pyhope.common.common_numba import NUMBA_AVAILABLE
 if typing.TYPE_CHECKING or NUMBA_AVAILABLE:
     import numpy.typing as npt
+    from pyhope.mesh.mesh_vars import ELEM
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Local imports
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -52,7 +53,10 @@ from pyhope.mesh.mesh_common import face_to_nodes
 
 
 # Use Pool initializer to attach process-local data to the worker function
-def init_worker(function, VdmEqToGP, DGP, weights) -> None:
+def init_worker(function : Callable,
+                VdmEqToGP: npt.NDArray[np.float64],
+                DGP      : npt.NDArray[np.float64],
+                weights  : npt.NDArray[np.float64]) -> None:
     """Initializer to set process-local attributes on the worker function
     """
     function.VdmEqToGP = VdmEqToGP
@@ -122,7 +126,7 @@ def eval_nsurf(XGeo:    npt.NDArray[np.float64],
     return np.array((NSurf0, NSurf1, NSurf2), dtype=xGP.dtype)
 
 
-def check_sides(elem,
+def check_sides(elem     : ELEM,
                 # points   : npt.NDArray[np.float64],
                 VdmEqToGP: npt.NDArray[np.float64],
                 DGP      : npt.NDArray[np.float64],
@@ -142,6 +146,9 @@ def check_sides(elem,
     elemTol  = np.cbrt(np.prod(np.ptp(points[elem.nodes], axis=0)))
     elemType = elem.type
 
+    if elem.sides is None:
+        return None
+
     for SideID in elem.sides:
         side   = sides[SideID]
 
@@ -151,12 +158,12 @@ def check_sides(elem,
             continue
 
         # Big mortar side
-        elif side.connection < 0:
+        if side.connection < 0:
             mortarType = abs(side.connection)
             # INFO: This should be faster but I could not confirm the speedup in practice
             # nSurf   = eval_nsurf(np.moveaxis( points[  nodes], 2, 0), VdmEqToGP, DGP, weights)
             # nSurf   = eval_nsurf(np.transpose(np.take(points,   nodes, axis=0), axes=(2, 0, 1)), VdmEqToGP, DGP, weights)
-            idx     = elem.nodes[face_to_nodes(side.face, elemType, nGeo)]
+            idx     = cast(np.ndarray, elem.nodes)[face_to_nodes(side.face, elemType, nGeo)]
             nSurf   = eval_nsurf(points[idx].transpose(2, 0, 1), VdmEqToGP, DGP, weights)
 
             # Calculate the L2 norm of the side and take the maximum
@@ -191,7 +198,7 @@ def check_sides(elem,
 
             # INFO: This should be faster but I could not confirm the speedup in practice
             # nSurf   = eval_nsurf(np.moveaxis( points[  nodes], 2, 0), VdmEqToGP, DGP, weights)
-            idx     = elem.nodes[face_to_nodes(side.face, elemType, nGeo)]
+            idx     = cast(np.ndarray, elem.nodes)[face_to_nodes(side.face, elemType, nGeo)]
             nSurf   = eval_nsurf(np.transpose(points[idx]), VdmEqToGP, DGP, weights)
 
             # Calculate the L2 norm of the side and take the maximum
@@ -229,7 +236,7 @@ def check_sides(elem,
     return results
 
 
-def process_chunk(chunk) -> list:
+def process_chunk(chunk: tuple) -> list:
     """Process a chunk of elements by checking surface normal orientation
     """
     # Only keep failures to reduce memory and avoid building large arrays of successes
@@ -288,8 +295,8 @@ def CheckWatertight() -> None:
     # checked   = np.zeros((len(sides)), dtype=bool)
 
     # 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]))
+    if any(e.type % 10 != 8 for e in elems):
+        elemTypes = list({e.type for e in elems if e.type % 10 != 8})
         print(hopout.warn('Ignored element type: {}'.format(
             [re.sub(r"\d+$", "", mesh_vars.ELEMTYPE.inam[e][0]) for e in elemTypes]
         )))
@@ -323,7 +330,7 @@ def CheckWatertight() -> None:
             if side.connection is None or side.sideType < 0:
                 continue
             # Big mortar side is counted once
-            elif side.connection < 0:
+            if side.connection < 0:
                 nconn += 1
             # Internal side: only count the canonical representative and ignore virtual mortar sides
             elif side.connection >= 0:
@@ -348,24 +355,24 @@ def CheckWatertight() -> None:
             print()
             # Check if side is oriented inwards
             errStr  =      'Side is oriented inwards!' if nSurfErr < 0 \
-                  else 'Surface normals are not within tolerance {:9.6e} > {:9.6e}'.format(nSurfErr, tol)
+                  else f'Surface normals are not within tolerance {nSurfErr:9.6e} > {tol:9.6e}'
             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('> Normal vector: [' + ' '.join('{:12.3f}'.format(s) for s in   nSurf) + ']'))                    # noqa: E271
-            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(hopout.warn('> Normal vector: [' + ' '.join(f'{s:12.3f}' for s in   nSurf) + ']'))                    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' 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('> Normal vector: [' + ' '.join('{:12.3f}'.format(s) for s in nbnSurf) + ']'))                    # noqa: E271
-            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
+            print(hopout.warn('> Normal vector: [' + ' '.join(f'{s:12.3f}' for s in nbnSurf) + ']'))                    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
 
         hopout.error(f'Watertightness check failed for {len(results)} / {nconn} connections!')