PyHOPE 1.0.0__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyHOPE
-Version: 1.0.0
+Version: 1.1.0
 Summary: Python High-Order Preprocessing Environment
 License-Expression: GPL-3.0-only
 License-File: AUTHORS.md
@@ -28,7 +28,8 @@ Requires-Dist: meshio
 Requires-Dist: numba ; extra == "numba"
 Requires-Dist: numpy (>=2.0.0)
 Requires-Dist: packaging
-Requires-Dist: plotext
+Requires-Dist: plotext (>=6.0.0)
+Requires-Dist: requests
 Requires-Dist: scipy
 Requires-Dist: typing-extensions
 Project-URL: Changelog, https://github.com/hopr-framework/PyHOPE/blob/main/CHANGELOG.md
@@ -121,6 +122,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │ INIT OUTPUT...
 │                     ProjectName │ 1-01-cartbox                    │ *CUSTOM │
 │                    OutputFormat │ 0 [HDF5]                        │ *CUSTOM │
+│                     OutputBytes │ 0 [int32]                       │ DEFAULT │
 │                       DebugMesh │ T                               │ *CUSTOM │
 │                       DebugVisu │ F                               │ *CUSTOM │
 ├─────────────────────────────────────────────
@@ -162,23 +164,26 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├── BUILD DATA STRUCTURE...
 ├────
 ├── Removing duplicate points
-├── Ensuring normals point outward
-├────
-│             CheckSurfaceNormals │ True                            │ DEFAULT │
-│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├────
 ├── Generating sides
 ├─────────────────────────────────────────────
 │ SORT MESH...
 ├────
 │                     MeshSorting │ 1 [SFC]                         │ DEFAULT │
+│                  MeshSortingSFC │ 0 [default]                     │ DEFAULT │
 ├────
 ├── Sorting elements along space-filling curve
 ├─────────────────────────────────────────────
+│ CHECK NORMALS POINTING OUTWARDS...
+├────
+│             CheckSurfaceNormals │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
+├─────────────────────────────────────────────
 │ CONNECT MESH...
 ├────
 │               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
+│                 doMortarRebuild │ 1 [auto]                        │ DEFAULT │
 │                Processing Sides |█████████████████████████████████| 3072/3072 [100%] in 0.0s (24000.00/s)
 ├────
 │  Number of sides                :         3072
@@ -246,8 +251,8 @@ This is a scientific project. If you use PyHOPE for publications or presentation
   author       = {Kopper, Patrick and Blind, Marcel P. and Schwarz, Anna and Kurz, Marius and Rodach, Felix and Copplestone, Stephen M. and Beck, Andrea D.},
   journal      = {Journal of Open Source Software},
   year         = {2025},
-  volume       = {10}, 
-  number       = {115}, 
+  volume       = {10},
+  number       = {115},
   pages        = {8769},
   publisher    = {The Open Journal},
   doi          = {10.21105/joss.08769}

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

@@ -81,6 +81,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │ INIT OUTPUT...
 │                     ProjectName │ 1-01-cartbox                    │ *CUSTOM │
 │                    OutputFormat │ 0 [HDF5]                        │ *CUSTOM │
+│                     OutputBytes │ 0 [int32]                       │ DEFAULT │
 │                       DebugMesh │ T                               │ *CUSTOM │
 │                       DebugVisu │ F                               │ *CUSTOM │
 ├─────────────────────────────────────────────
@@ -122,23 +123,26 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├── BUILD DATA STRUCTURE...
 ├────
 ├── Removing duplicate points
-├── Ensuring normals point outward
-├────
-│             CheckSurfaceNormals │ True                            │ DEFAULT │
-│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├────
 ├── Generating sides
 ├─────────────────────────────────────────────
 │ SORT MESH...
 ├────
 │                     MeshSorting │ 1 [SFC]                         │ DEFAULT │
+│                  MeshSortingSFC │ 0 [default]                     │ DEFAULT │
 ├────
 ├── Sorting elements along space-filling curve
 ├─────────────────────────────────────────────
+│ CHECK NORMALS POINTING OUTWARDS...
+├────
+│             CheckSurfaceNormals │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
+├─────────────────────────────────────────────
 │ CONNECT MESH...
 ├────
 │               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
+│                 doMortarRebuild │ 1 [auto]                        │ DEFAULT │
 │                Processing Sides |█████████████████████████████████| 3072/3072 [100%] in 0.0s (24000.00/s)
 ├────
 │  Number of sides                :         3072
@@ -206,8 +210,8 @@ This is a scientific project. If you use PyHOPE for publications or presentation
   author       = {Kopper, Patrick and Blind, Marcel P. and Schwarz, Anna and Kurz, Marius and Rodach, Felix and Copplestone, Stephen M. and Beck, Andrea D.},
   journal      = {Journal of Open Source Software},
   year         = {2025},
-  volume       = {10}, 
-  number       = {115}, 
+  volume       = {10},
+  number       = {115},
   pages        = {8769},
   publisher    = {The Open Journal},
   doi          = {10.21105/joss.08769}

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

@@ -661,55 +661,87 @@ def change_basis_1D(Vdm: npt.NDArray[np.float64], x1D_In: npt.NDArray[np.float64
     return Vdm @ x1D_In
 
 
-def evaluate_jacobian(xGeo_In:   npt.NDArray[np.float64],
-                      VdmGLtoAP: npt.NDArray[np.float64],
-                      D_EqToGL:  npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
-    """ Calculate the Jacobian of the mapping for a given element
-    """
-    dim1  = xGeo_In.shape[0]
-    n_In  = xGeo_In.shape[1]
-    n_Out = D_EqToGL.shape[0]
-
-    # Perform tensor contraction for the first derivative (Xi direction)
-    # dXdXiGL   = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 1))
-    # dXdXiGL   = np.moveaxis(dXdXiGL  , 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
-    _X1     = xGeo_In.reshape(dim1, n_In, n_In * n_In)
-    dXdXiGL = (D_EqToGL @ _X1).reshape(dim1, n_Out, n_In, n_In)
-
-    # Perform tensor contraction for the second derivative (Eta direction)
-    dXdEtaGL  = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 2))
-    dXdEtaGL  = np.transpose(dXdEtaGL, (1, 2, 0, 3))
-    # PERF: This is actually slower than the individual contractions
-    # dXdEtaGL  = np.einsum('qj,dijk->dqik', D_EqToGL, xGeo_In, optimize=True)
-
-    # Perform tensor contraction for the third derivative (Zeta direction)
-    # dXdZetaGL = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 3))
-    # dXdZetaGL = np.moveaxis(dXdZetaGL, 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
-    _X3       = xGeo_In.reshape(dim1, n_In * n_In, n_In)
-    dXdZetaGL = (_X3 @ D_EqToGL.T).reshape(dim1, n_In, n_In, n_Out)
-    dXdZetaGL = np.transpose(dXdZetaGL, (0, 3, 1, 2))
-    # PERF: This is actually slower than the individual contractions
-    # dXdZetaGL = np.einsum('rk,dijk->drij', D_EqToGL, xGeo_In, optimize=True)
+if not NUMBA_AVAILABLE:
+    def evaluate_jacobian(xGeo_In:   npt.NDArray[np.float64],
+                          VdmGLtoAP: npt.NDArray[np.float64],
+                          D_EqToGL:  npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+        """ Calculate the Jacobian of the mapping for a given element
+        """
+        dim1  = xGeo_In.shape[0]
+        n_In  = xGeo_In.shape[1]
+        n_Out = D_EqToGL.shape[0]
+
+        # Perform tensor contraction for the first derivative (Xi direction)
+        # dXdXiGL   = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 1))
+        # dXdXiGL   = np.moveaxis(dXdXiGL  , 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+        _X1     = xGeo_In.reshape(dim1, n_In, n_In * n_In)
+        dXdXiGL = (D_EqToGL @ _X1).reshape(dim1, n_Out, n_In, n_In)
+
+        # Perform tensor contraction for the second derivative (Eta direction)
+        dXdEtaGL  = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 2))
+        dXdEtaGL  = np.transpose(dXdEtaGL, (1, 2, 0, 3))
+        # PERF: This is actually slower than the individual contractions
+        # dXdEtaGL  = np.einsum('qj,dijk->dqik', D_EqToGL, xGeo_In, optimize=True)
+
+        # Perform tensor contraction for the third derivative (Zeta direction)
+        # dXdZetaGL = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 3))
+        # dXdZetaGL = np.moveaxis(dXdZetaGL, 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+        _X3       = xGeo_In.reshape(dim1, n_In * n_In, n_In)
+        dXdZetaGL = (_X3 @ D_EqToGL.T).reshape(dim1, n_In, n_In, n_Out)
+        dXdZetaGL = np.transpose(dXdZetaGL, (0, 3, 1, 2))
+        # PERF: This is actually slower than the individual contractions
+        # dXdZetaGL = np.einsum('rk,dijk->drij', D_EqToGL, xGeo_In, optimize=True)
+
+        # Change basis for each direction
+        dXdXiAP   = change_basis_3D(VdmGLtoAP, dXdXiGL  )
+        dXdEtaAP  = change_basis_3D(VdmGLtoAP, dXdEtaGL )
+        dXdZetaAP = change_basis_3D(VdmGLtoAP, dXdZetaGL)
+
+        # Precompute cross products between dXdEtaAP and dXdZetaAP for all points
+        # cross_eta_zeta = np.cross(dXdEtaAP, dXdZetaAP, axis=0)  # Shape: (3, nGeoRef, nGeoRef, nGeoRef)
+        # > Manually compute cross product
+        cross_eta_zeta = np.empty_like(dXdEtaAP)
+        cross_eta_zeta[0] = dXdEtaAP[1] * dXdZetaAP[2] - dXdEtaAP[2] * dXdZetaAP[1]
+        cross_eta_zeta[1] = dXdEtaAP[2] * dXdZetaAP[0] - dXdEtaAP[0] * dXdZetaAP[2]
+        cross_eta_zeta[2] = dXdEtaAP[0] * dXdZetaAP[1] - dXdEtaAP[1] * dXdZetaAP[0]
+
+        # Fill output Jacobian array
+        # jacOut = np.einsum('ijkl,ijkl->jkl', dXdXiAP, cross_eta_zeta)
+        # PERF: This is actually slower than the individual contractions
+        # jacOut = np.sum(dXdXiAP * cross_eta_zeta, axis=0)
 
-    # Change basis for each direction
-    dXdXiAP   = change_basis_3D(VdmGLtoAP, dXdXiGL  )
-    dXdEtaAP  = change_basis_3D(VdmGLtoAP, dXdEtaGL )
-    dXdZetaAP = change_basis_3D(VdmGLtoAP, dXdZetaGL)
+        return np.einsum('ijkl,ijkl->jkl', dXdXiAP, cross_eta_zeta)
+else:
+    @jit(nopython=True, cache=True, nogil=True)
+    def evaluate_jacobian(xGeo_In:   npt.NDArray[np.float64],
+                          VdmGLtoAP: npt.NDArray[np.float64],
+                          D_EqToGL:  npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+        """ Calculate the Jacobian of the mapping for a given element
+        """
+        dim1  = xGeo_In.shape[0]
+        n_In  = xGeo_In.shape[1]
+        n_Out = D_EqToGL.shape[0]
 
-    # Precompute cross products between dXdEtaAP and dXdZetaAP for all points
-    # cross_eta_zeta = np.cross(dXdEtaAP, dXdZetaAP, axis=0)  # Shape: (3, nGeoRef, nGeoRef, nGeoRef)
-    # > Manually compute cross product
-    cross_eta_zeta = np.empty_like(dXdEtaAP)
-    cross_eta_zeta[0] = dXdEtaAP[1] * dXdZetaAP[2] - dXdEtaAP[2] * dXdZetaAP[1]
-    cross_eta_zeta[1] = dXdEtaAP[2] * dXdZetaAP[0] - dXdEtaAP[0] * dXdZetaAP[2]
-    cross_eta_zeta[2] = dXdEtaAP[0] * dXdZetaAP[1] - dXdEtaAP[1] * dXdZetaAP[0]
+        dXdXiGL = np.zeros((dim1, n_Out, n_In, n_In), dtype=np.float64)
+        for d in range(dim1):
+            _X1 = np.ascontiguousarray(xGeo_In[d]).reshape(n_In, n_In * n_In)
+            dXdXiGL[d] = (D_EqToGL @ _X1).reshape(n_Out, n_In, n_In)
 
-    # Fill output Jacobian array
-    # jacOut = np.einsum('ijkl,ijkl->jkl', dXdXiAP, cross_eta_zeta)
-    # PERF: This is actually slower than the individual contractions
-    # jacOut = np.sum(dXdXiAP * cross_eta_zeta, axis=0)
+        _X2 = np.ascontiguousarray(xGeo_In.transpose(0, 1, 3, 2)).reshape(-1, n_In)
+        dXdEtaGL = (_X2 @ D_EqToGL.T).reshape(dim1, n_In, n_In, n_Out).transpose(0, 1, 3, 2)
+
+        _X3 = np.ascontiguousarray(xGeo_In).reshape(-1, n_In)
+        dXdZetaGL = (_X3 @ D_EqToGL.T).reshape(dim1, n_In, n_In, n_Out).transpose(0, 3, 1, 2)
+
+        dXdXiAP   = change_basis_3D(VdmGLtoAP, dXdXiGL  )
+        dXdEtaAP  = change_basis_3D(VdmGLtoAP, dXdEtaGL )
+        dXdZetaAP = change_basis_3D(VdmGLtoAP, dXdZetaGL)
+
+        cross_0 = dXdEtaAP[1] * dXdZetaAP[2] - dXdEtaAP[2] * dXdZetaAP[1]
+        cross_1 = dXdEtaAP[2] * dXdZetaAP[0] - dXdEtaAP[0] * dXdZetaAP[2]
+        cross_2 = dXdEtaAP[0] * dXdZetaAP[1] - dXdEtaAP[1] * dXdZetaAP[0]
 
-    return np.einsum('ijkl,ijkl->jkl', dXdXiAP, cross_eta_zeta)
+        return dXdXiAP[0] * cross_0 + dXdXiAP[1] * cross_1 + dXdXiAP[2] * cross_2
 
 
 def evaluate_jacobian_simplex(xGeo_In:  npt.NDArray[np.float64],

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

@@ -27,9 +27,9 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 from __future__ import annotations
 import re
-import sys
 from typing import Final, Optional, cast
 from collections.abc import Iterable
+from operator import itemgetter
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -142,10 +142,12 @@ def CheckConnect() -> None:
     """ Check if the mesh is correctly connected
     """
     # Local imports ----------------------------------------
+    import pyhope.io.io_vars as io_vars
     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.io.io_debug import DebugIO
     from pyhope.readintools.readintools import GetLogical
     # ------------------------------------------------------
 
@@ -178,13 +180,13 @@ def CheckConnect() -> None:
                                   ordering    = False,                                                     # noqa: E251
                                  )
     else:
-        res     = [elem for elem in elems if check_sides(elem, failed_only=True)]
+        res     = [check_sides(elem, failed_only=True) for elem in elems]
 
-    if len(res) > 0:  # pragma: no cover
-        # Flatten per-element results (skip None placeholders)
-        results = tuple(result for elem_results in res if isinstance(elem_results, Iterable) and elem_results is not None
-                               for result       in elem_results)  # noqa: E272
+    # Flatten per-element results (skip None placeholders)
+    results = tuple(result for elem_results in res if isinstance(elem_results, Iterable) and elem_results is not None
+                           for result       in elem_results)  # noqa: E272
 
+    if len(results):  # pragma: no cover
         nGeo:      Final[int]        = mesh_vars.nGeo
         sides:     Final[list]       = mesh_vars.sides
         points:    Final[np.ndarray] = mesh_vars.mesh.points
@@ -216,7 +218,7 @@ def CheckConnect() -> None:
             nodes   =   elem.nodes[face_to_nodes(  side.face,   elem.type, nGeo)]
             nbnodes = nbelem.nodes[face_to_nodes(nbside.face, nbelem.type, nGeo)]
 
-            print()
+            hopout.info('')
             # Check if side is oriented inwards
             errStr = 'Side connectivity does not match the calculated neighbour side'
             print(hopout.warn(errStr, length=len(errStr)+16))
@@ -235,5 +237,9 @@ def CheckConnect() -> None:
             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)
+        # Write a low-order debug mesh if requested
+        if io_vars.debugmesh:
+            hopout.info('')
+            DebugIO(errSides=list(map(itemgetter(1), results)))
+
+        hopout.error(f'Connectivity check failed for {len(results)} / {nconn} connections!')

{pyhope-1.0.0 → pyhope-1.1.0}/pyhope/basis/basis_jacobian.py

@@ -94,8 +94,34 @@ def plot_histogram(data: npt.NDArray[np.float64]) -> None:
     hopout.sep()
     hopout.info('Scaled Jacobians')
     hopout.separator(18)
-    plt.simple_bar(ticks, count, width=STD_LENGTH)
-    plt.show()
+
+    # Horizontal bars are stacked from the bottom up, thus reverse the data to keep the first bin on top
+    labels = ticks[::-1]
+    counts = count[::-1]
+
+    # Reserve space at the end of the longest bar for its count label
+    barMax     = max(int(count.max()), 1)
+    barWidth   = STD_LENGTH - len(ticks[0])
+    labelWidth = len(str(barMax)) + 1
+
+    # Assemble the frame-less bar plot from the regular [bar], see https://plotext.readthedocs.io/en/latest/bar.html#simple-bar-style
+    fig = plt.figure
+    fig.clear()
+    fig.theme('simple')
+    fig.plot_size(STD_LENGTH, len(labels))
+    fig.draw(fig.bar(labels, counts, orientation='horizontal', marker='brick', width=0, lines=True))
+
+    # Print the number of elements at the end of each bar
+    for row, c in enumerate(counts, start=1):
+        fig.draw(fig.text(c, row, plt.colorize(f' {c}', pixel=('gray+', None, 'bold')), alignment='left'))
+
+    # Remove the frame and the axis ticks, keeping only the bin labels
+    fig.axes(False)
+    fig.ruler('x').lim(0, barMax * barWidth / max(barWidth - labelWidth, 1))
+    fig.ruler('x').ticks([])
+    fig.ruler('y').alignment(tick='left')
+    fig.show(flush=True)
+
     hopout.separator(18)
 
 

pyhope-1.1.0/pyhope/basis/basis_orient.py

@@ -0,0 +1,195 @@
+#!/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 __future__ import annotations
+import gc
+import re
+from typing import Final, Optional, cast
+from collections.abc import Iterable
+from operator import itemgetter
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Third-party libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+import numpy as np
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Typing libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+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
+# ----------------------------------------------------------------------------------------------------------------------------------
+import pyhope.mesh.mesh_vars as mesh_vars
+from pyhope.basis.basis_watertight import eval_nsurf
+from pyhope.mesh.mesh_common import face_to_nodes, faces
+# ==================================================================================================================================
+
+
+def check_orientation(elem       : ELEM,
+                      VdmEqToGP  : npt.NDArray[np.float64],
+                      DGP        : npt.NDArray[np.float64],
+                      weights    : npt.NDArray[np.float64],
+                      failed_only: bool = False,
+                     ) -> Optional[list[tuple]]:
+    """ Check the orientation of the surface normals
+    """
+    points   = mesh_vars.mesh.points
+    nGeo     = mesh_vars.nGeo
+    elemType = elem.type
+
+    if elemType % 10 != 8:
+        return None
+
+    # Center of element
+    cElem   = points[elem.nodes].reshape(-1, 3).mean(axis=0)
+    results = None
+
+    # Fall back to geometry topology faces if sides array is not initialized
+    sides = getattr(mesh_vars, 'sides', None)
+    sideIter = ((sides[s].face, s) for s in elem.sides) if (elem.sides is not None and sides is not None) else \
+               ((f, None) for f in faces(elemType))
+
+    for face, SideID in sideIter:
+        idx     = cast(np.ndarray, elem.nodes)[face_to_nodes(face, elemType, nGeo)]
+        fpoints = points[idx]
+
+        # Calculate high-order surface normal vector via Gauss integration
+        nSurf   = eval_nsurf(fpoints.transpose(2, 0, 1), VdmEqToGP, DGP, weights)
+
+        # Vector pointing from face center to element center
+        fCenter = fpoints.reshape(-1, 3).mean(axis=0)
+        vCenter = cElem - fCenter
+
+        success = np.dot(nSurf, vCenter) <= 0.
+
+        # If requested, only return errors
+        if failed_only and success:
+            continue
+
+        # Lazily initialize results on first failure
+        if results is None:
+            results = []
+        results.append((success, elem.elemID, face, SideID))
+
+    # Avoid creating empty lists on elem_results
+    if results is None:
+        return None if failed_only else []
+
+    return results
+
+
+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
+    chunk_results = []
+    for elem in chunk:
+        elem_result = check_orientation(elem,
+                                        process_chunk.VdmEqToGP,  # ty: ignore[unresolved-attribute]
+                                        process_chunk.DGP,        # ty: ignore[unresolved-attribute]
+                                        process_chunk.weights,    # ty: ignore[unresolved-attribute]
+                                        failed_only=True)
+        chunk_results.append(elem_result)
+    return chunk_results
+
+
+def CheckOrient() -> None:
+    """ Check if element surface normals point outwards
+    """
+    # Local imports ----------------------------------------
+    import pyhope.io.io_vars as io_vars
+    import pyhope.output.output as hopout
+    import pyhope.mesh.mesh_vars as mesh_vars
+    from pyhope.basis.basis_basis import barycentric_weights, legendre_gauss_nodes
+    from pyhope.basis.basis_basis import calc_vandermonde, polynomial_derivative_matrix
+    from pyhope.basis.basis_watertight import init_worker
+    from pyhope.common.common_parallel import run_in_parallel
+    from pyhope.common.common_vars import np_mtp
+    from pyhope.io.io_debug import DebugIO
+    from pyhope.readintools.readintools import GetLogical
+    # ------------------------------------------------------
+
+    hopout.separator()
+    hopout.info('CHECK NORMALS POINTING OUTWARDS...')
+    hopout.sep()
+
+    checkSurfaceNormals = GetLogical('CheckSurfaceNormals')
+    if not checkSurfaceNormals:
+        return None
+
+    nGeo:  Final[int]  = mesh_vars.nGeo
+    elems: Final[list] = mesh_vars.elems
+
+    # Setup mathematical structures identical to CheckWatertight
+    xEq:       Final[npt.NDArray[np.float64]] = np.linspace(-1., 1., nGeo+1)
+    wBaryEq:   Final[npt.NDArray[np.float64]] = barycentric_weights(nGeo+1, xEq)
+
+    xGP, wGP  = legendre_gauss_nodes(nGeo+1)
+    DGP:       Final[npt.NDArray[np.float64]] = polynomial_derivative_matrix(nGeo+1, xGP)
+    VdmEqToGP: Final[npt.NDArray[np.float64]] = calc_vandermonde(nGeo+1, nGeo+1, wBaryEq, xEq, xGP)
+    weights:   Final[npt.NDArray[np.float64]] = np.outer(wGP, wGP)
+
+    # Prepare elements for parallel processing
+    if np_mtp > 0:
+        # 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,
+                              elems,
+                              chunk_size  = max(1, min(1000, max(10, int(len(elems)/(40.*np_mtp))))),  # noqa: E251
+                              initializer = init_worker,                                               # noqa: E251
+                              init_args   = (process_chunk, VdmEqToGP, DGP, weights),                  # noqa: E251
+                              ordering    = False,                                                     # noqa: E251
+                             )
+    else:
+        res = [check_orientation(elem, VdmEqToGP, DGP, weights, failed_only=True) for elem in elems]
+
+    # Flatten results while filtering empty items
+    results = tuple(result for elem_results in res if isinstance(elem_results, Iterable) and elem_results is not None
+                           for result       in elem_results)  # noqa: E272
+
+    if len(results):
+        for result in cast(tuple[tuple], results):
+            _, elemID, face, sideID = result
+            hopout.info('')
+            print(hopout.warn(f'Side is oriented inwards! Element {elemID + 1}, Face {face}, Side {sideID + 1}'))
+
+        if io_vars.debugmesh:
+            hopout.info('')
+            DebugIO(errSides=list(map(itemgetter(3), results)))
+
+        hopout.error(f'Surface normals check failed for {len(results)} / {len(elems)} elements!')
+
+    # Warn if we passed any element types
+    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])))  # ruff: ignore[line-too-long]
+
+    # Run garbage collector to release memory
+    gc.collect()

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

@@ -30,6 +30,7 @@ import gc
 import re
 from typing import Final, Optional, cast
 from collections.abc import Callable, Iterable
+from operator import itemgetter
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -96,7 +97,7 @@ def eval_nsurf(XGeo:    npt.NDArray[np.float64],
     # # dXdetaGP = np.moveaxis(dXdetaGP, 0, 1).reshape(3, -1)              # Flatten for cross computation (slower)
     # dXdetaGP = dXdetaGP.reshape(3, -1)                                 # Flatten for cross computation
 
-    # Compute derivatives at all Gauss points using matrix multiplications to avoid extra copies
+    # Compute derivatives at all Gauss points
     dXdxiGP  = np.empty_like(xGP)
     dXdetaGP = np.empty_like(xGP)
     DT       = DGP.T
@@ -120,7 +121,7 @@ def eval_nsurf(XGeo:    npt.NDArray[np.float64],
     # Integrate over the Gauss points
     # return -np.sum(nVecW, axis=(1, 2))              # Sum over the last two axes
 
-    # Compute the weighted cross product integral directly
+    # Compute the weighted cross product integral
     NSurf0, NSurf1, NSurf2 = eval_dotprod(dXdetaGP, dXdxiGP, weights)
 
     return np.array((NSurf0, NSurf1, NSurf2), dtype=xGP.dtype)
@@ -243,9 +244,9 @@ def process_chunk(chunk: tuple) -> list:
     chunk_results = []
     for elem in chunk:
         elem_result = check_sides(elem,
-                                   process_chunk.VdmEqToGP,  # pyright: ignore[reportFunctionMemberAccess] # ty: ignore[unresolved-attribute]
-                                   process_chunk.DGP,        # pyright: ignore[reportFunctionMemberAccess] # ty: ignore[unresolved-attribute]
-                                   process_chunk.weights,    # pyright: ignore[reportFunctionMemberAccess] # ty: ignore[unresolved-attribute]
+                                   process_chunk.VdmEqToGP,  # ty: ignore[unresolved-attribute]
+                                   process_chunk.DGP,        # ty: ignore[unresolved-attribute]
+                                   process_chunk.weights,    # ty: ignore[unresolved-attribute]
                                    failed_only=True)
         # Append a lightweight sentinel (None) for successes, actual failure list otherwise
         chunk_results.append(elem_result)
@@ -256,12 +257,14 @@ def CheckWatertight() -> None:
     """ Check if the mesh is watertight
     """
     # Local imports ----------------------------------------
+    import pyhope.io.io_vars as io_vars
     import pyhope.output.output as hopout
     import pyhope.mesh.mesh_vars as mesh_vars
     from pyhope.basis.basis_basis import barycentric_weights, legendre_gauss_nodes
     from pyhope.basis.basis_basis import calc_vandermonde, polynomial_derivative_matrix
     from pyhope.common.common_parallel import run_in_parallel
     from pyhope.common.common_vars import np_mtp
+    from pyhope.io.io_debug import DebugIO
     from pyhope.readintools.readintools import GetLogical
     # ------------------------------------------------------
 
@@ -314,15 +317,13 @@ def CheckWatertight() -> None:
                                   ordering    = False,                                                     # noqa: E251
                                  )
     else:
-        res     = [elem for elem in elems if check_sides(elem,
-                                                         VdmEqToGP, DGP, weights,
-                                                         failed_only=True)]
+        res     = [check_sides(elem, VdmEqToGP, DGP, weights, failed_only=True) for elem in elems]
 
-    if len(res) > 0:  # pragma: no cover
-        # Flatten per-element results (skip None placeholders)
-        results = tuple(result for elem_results in res if isinstance(elem_results, Iterable) and elem_results is not None
-                               for result       in elem_results)  # noqa: E272
+    # Flatten per-element results (skip None placeholders)
+    results = tuple(result for elem_results in res if isinstance(elem_results, Iterable) and elem_results is not None
+                           for result       in elem_results)  # noqa: E272
 
+    if len(results):  # pragma: no cover
         # Compute total number of checked connections without materializing all results
         nconn = 0
         for SideID, side in enumerate(sides):
@@ -352,7 +353,7 @@ def CheckWatertight() -> None:
             nodes   =   elem.nodes[face_to_nodes(  side.face,   elem.type, nGeo)]
             nbnodes = nbelem.nodes[face_to_nodes(nbside.face, nbelem.type, nGeo)]
 
-            print()
+            hopout.info('')
             # Check if side is oriented inwards
             errStr  =      'Side is oriented inwards!' if nSurfErr < 0 \
                   else f'Surface normals are not within tolerance {nSurfErr:9.6e} > {tol:9.6e}'
@@ -374,6 +375,11 @@ def CheckWatertight() -> None:
             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
 
+        # Write a low-order debug mesh if requested
+        if io_vars.debugmesh:
+            hopout.info('')
+            DebugIO(errSides=list(map(itemgetter(1), results)))
+
         hopout.error(f'Watertightness check failed for {len(results)} / {nconn} connections!')
 
     # Run garbage collector to release memory