PyHOPE 0.9.0__tar.gz → 0.10.0__tar.gz

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

@@ -20,5 +20,6 @@ are listed in alphabetical order:
 * Stephen Copplestone
 * Patrick Kopper
 * Marius Kurz
+* Leon Teichröb
 * Felix Rodach
 * Anna Schwarz

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

@@ -1,17 +1,16 @@
 Metadata-Version: 2.4
 Name: PyHOPE
-Version: 0.9.0
+Version: 0.10.0
 Summary: Python High-Order Preprocessing Environment
-License: GPL-3.0-only
+License-Expression: 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
 Requires-Python: >=3.10
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Operating System :: POSIX :: Linux
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -35,6 +34,12 @@ Project-URL: Homepage, https://numericsresearchgroup.org
 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)
+[![Documentation](https://github.com/hopr-framework/PyHOPE/actions/workflows/github-pages.yml/badge.svg)](https://github.com/hopr-framework/PyHOPE/actions/workflows/github-pages.yml)
+[![JOSS](https://joss.theoj.org/papers/39eb3be78f37c78588fe6dc443785024/status.svg)](https://joss.theoj.org/papers/39eb3be78f37c78588fe6dc443785024)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12060/badge)](https://www.bestpractices.dev/projects/12060)
+[![OpenSSF Baseline](https://www.bestpractices.dev/projects/12060/baseline)](https://www.bestpractices.dev/projects/12060)
+
 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.
 
 PyHOPE has been developed by the Numerics Research Group (NRG) lead by Prof. Andrea Beck at the Institute of Aerodynamics and Gas Dynamics at the University of Stuttgart, Germany.
@@ -73,6 +78,7 @@ PyHOPE features internal health checks to verify that everything works as expect
 pyhope --verify [tutorials]          # Run all health checks
 pyhope --verify-health               # Run Python health checks
 pyhope --verify-install [tutorials]  # Run PyHOPE mesh generation checks
+pyhope --verify-unittest             # Run PyHOPE unit tests
 ```
 
 > [!NOTE]  
@@ -169,6 +175,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├────
 │               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
+│                Processing Sides |█████████████████████████████████| 3072/3072 [100%] in 0.0s (24000.00/s)
 ├────
 │  Number of sides                :         3072
 │  Number of inner sides          :         2688
@@ -219,7 +226,7 @@ $ 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](https://github.com/hopr-framework/PyHOPE/blob/main/pyhope/__init__.py).
+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 [PyHOPE documentation](https://hopr-framework.github.io/PyHOPE/user-guide/library_usage).
 ```python
 from pyhope import Basis, Mesh
 with Mesh('1-01-cartbox_mesh.h5') as m:

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

@@ -1,3 +1,9 @@
+[![CI](https://github.com/hopr-framework/PyHOPE/actions/workflows/ci.yml/badge.svg)](https://github.com/hopr-framework/PyHOPE/actions/workflows/ci.yml)
+[![Documentation](https://github.com/hopr-framework/PyHOPE/actions/workflows/github-pages.yml/badge.svg)](https://github.com/hopr-framework/PyHOPE/actions/workflows/github-pages.yml)
+[![JOSS](https://joss.theoj.org/papers/39eb3be78f37c78588fe6dc443785024/status.svg)](https://joss.theoj.org/papers/39eb3be78f37c78588fe6dc443785024)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12060/badge)](https://www.bestpractices.dev/projects/12060)
+[![OpenSSF Baseline](https://www.bestpractices.dev/projects/12060/baseline)](https://www.bestpractices.dev/projects/12060)
+
 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.
 
 PyHOPE has been developed by the Numerics Research Group (NRG) lead by Prof. Andrea Beck at the Institute of Aerodynamics and Gas Dynamics at the University of Stuttgart, Germany.
@@ -36,6 +42,7 @@ PyHOPE features internal health checks to verify that everything works as expect
 pyhope --verify [tutorials]          # Run all health checks
 pyhope --verify-health               # Run Python health checks
 pyhope --verify-install [tutorials]  # Run PyHOPE mesh generation checks
+pyhope --verify-unittest             # Run PyHOPE unit tests
 ```
 
 > [!NOTE]  
@@ -132,6 +139,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├────
 │               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
+│                Processing Sides |█████████████████████████████████| 3072/3072 [100%] in 0.0s (24000.00/s)
 ├────
 │  Number of sides                :         3072
 │  Number of inner sides          :         2688
@@ -182,7 +190,7 @@ $ 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](https://github.com/hopr-framework/PyHOPE/blob/main/pyhope/__init__.py).
+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 [PyHOPE documentation](https://hopr-framework.github.io/PyHOPE/user-guide/library_usage).
 ```python
 from pyhope import Basis, Mesh
 with Mesh('1-01-cartbox_mesh.h5') as m:

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

@@ -28,32 +28,72 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 from collections import namedtuple
 from contextlib import contextmanager
+from functools import update_wrapper
+from typing import final
 # ----------------------------------------------------------------------------------------------------------------------------------
 # 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
 # ==================================================================================================================================
 
 
+def _staticwrapper(func):
+    """ Custom helper to lift the (annotations, doc, etc.) to the staticmethod
+    """
+    # Create a wrapper that carries the metadata
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    # Lift metadata (annotations, doc, etc.) to the wrapper
+    update_wrapper(wrapper, func)
+
+    # Convert the metadata-rich wrapper into a staticmethod
+    return staticmethod(wrapper)
+
+
+@final
 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)
+    # Local imports ----------------------------------------
+    from pyhope.basis.basis_basis import legendre_gauss_nodes, legendre_gauss_lobatto_nodes
+    from pyhope.basis.basis_basis import barycentric_weights
+    from pyhope.basis.basis_basis import polynomial_derivative_matrix, polynomial_derivative_matrix_prism
+    from pyhope.basis.basis_basis import polynomial_derivative_matrix_pyram, polynomial_derivative_matrix_tetra
+    from pyhope.basis.basis_basis import lagrange_interpolation_polys, calc_vandermonde
+    from pyhope.basis.basis_basis import change_basis_3D, change_basis_2D, change_basis_1D
+    from pyhope.basis.basis_basis import equi_nodes_prism, equi_nodes_pyram, equi_nodes_tetra
+    from pyhope.basis.basis_basis import evaluate_jacobian, evaluate_jacobian_simplex
+    # ------------------------------------------------------
+    legendre_gauss_nodes               = _staticwrapper(legendre_gauss_nodes)
+    legendre_gauss_lobatto_nodes       = _staticwrapper(legendre_gauss_lobatto_nodes)
+    barycentric_weights                = _staticwrapper(barycentric_weights)
+    polynomial_derivative_matrix       = _staticwrapper(polynomial_derivative_matrix)
+    polynomial_derivative_matrix_prism = _staticwrapper(polynomial_derivative_matrix_prism)
+    polynomial_derivative_matrix_pyram = _staticwrapper(polynomial_derivative_matrix_pyram)
+    polynomial_derivative_matrix_tetra = _staticwrapper(polynomial_derivative_matrix_tetra)
+    lagrange_interpolation_polys       = _staticwrapper(lagrange_interpolation_polys)
+    calc_vandermonde                   = _staticwrapper(calc_vandermonde)
+    change_basis_3D                    = _staticwrapper(change_basis_3D)
+    change_basis_2D                    = _staticwrapper(change_basis_2D)
+    change_basis_1D                    = _staticwrapper(change_basis_1D)
+    equi_nodes_prism                   = _staticwrapper(equi_nodes_prism)
+    equi_nodes_pyram                   = _staticwrapper(equi_nodes_pyram)
+    equi_nodes_tetra                   = _staticwrapper(equi_nodes_tetra)
+    evaluate_jacobian                  = _staticwrapper(evaluate_jacobian)
+    evaluate_jacobian_simplex          = _staticwrapper(evaluate_jacobian_simplex)
+
+
+@final
+class Mapping:
+    """ Mapping class to hold all mapping related functions and variables
+    """
+    # Local imports ----------------------------------------
+    from pyhope.mesh.mesh_common import LINMAP
+    # ------------------------------------------------------
+    mesh_format_to_tensor_product      = _staticwrapper(LINMAP)
 
 
 # Define a named tuple to hold the mesh data
@@ -61,12 +101,13 @@ MeshContainer = namedtuple('Mesh',
                           ['mesh',   # The generated mesh object
                            'nGeo',   # Polynomial order
                            'bcs',    # Boundary conditions
+                           'vvs',    # Periodic vectors
                            'elems',  # Elements
                            'sides'   # Sides
                           ])
 
 
-@contextmanager  # pragma: no cover
+@contextmanager
 def Mesh(*args: str, stdout: bool = False, stderr: bool = True):
     """ Mesh context manager to generate a mesh from a given file
 
@@ -139,10 +180,11 @@ def Mesh(*args: str, stdout: bool = False, stderr: bool = True):
                 ConnectMesh()
 
         # Export mesh variables
-        mesh = mesh_vars.mesh
+        mesh  = mesh_vars.mesh
 
         nGeo  = mesh_vars.nGeo
         bcs   = mesh_vars.bcs
+        vvs   = mesh_vars.vvs
 
         elems = mesh_vars.elems
         sides = mesh_vars.sides
@@ -150,6 +192,7 @@ def Mesh(*args: str, stdout: bool = False, stderr: bool = True):
         yield MeshContainer(mesh  = mesh,   # noqa: E251
                             nGeo  = nGeo,   # noqa: E251
                             bcs   = bcs,    # noqa: E251
+                            vvs   = vvs,    # noqa: E251
                             elems = elems,  # noqa: E251
                             sides = sides   # noqa: E251
                            )

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

@@ -25,8 +25,9 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
+from __future__ import annotations
 from functools import cache
-from typing import Final, Union
+from typing import Any, Final
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -34,31 +35,38 @@ import numpy as np
 import scipy as sp
 # from threadpoolctl import ThreadpoolController
 # ----------------------------------------------------------------------------------------------------------------------------------
-# Local imports
+# Typing libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
+import typing
 from pyhope.common.common_numba import NUMBA_AVAILABLE
+if typing.TYPE_CHECKING or NUMBA_AVAILABLE:
+    import numpy.typing as npt
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Local imports
+# ----------------------------------------------------------------------------------------------------------------------------------
 from pyhope.common.common_numba import jit, types
 from pyhope.mesh.mesh_common import NDOFS_ELEM
 # ==================================================================================================================================
 
 
-def legendre_gauss_lobatto_nodes(order: int) -> tuple[np.ndarray, np.ndarray]:
+@jit(types.Tuple((types.float64[:], types.float64[:]))(types.int64), nopython=True, cache=True, nogil=True)
+def legendre_gauss_lobatto_nodes(order: int) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
     """ Return Legendre-Gauss-Lobatto nodes and weights for a given order in 1D
     """
     order -= 1
     # Special cases for small N
     if order == 1:
-        return np.array((-1, 1)), np.array((1, 1))
+        return np.array((-1, 1), dtype=np.float64), np.array((1, 1), dtype=np.float64)
 
     # Compute the initial guess for the LGL nodes (roots of P'_N)
     nodes = np.cos(np.pi * np.arange(order+1) / order)
 
     # Initialize the Legendre polynomial and its derivative
-    p = np.zeros((order+1, order+1))
+    p = np.zeros((order+1, order+1), dtype=np.float64)
 
     # Iteratively solve for the LGL nodes using Newton's method
     xOld = 2 * np.ones_like(nodes)
-    tol = 1e-14
+    tol  = 1e-14
     while np.max(np.abs(nodes - xOld)) > tol:
         xOld = nodes.copy()
         p[:, 0] = 1
@@ -76,7 +84,8 @@ def legendre_gauss_lobatto_nodes(order: int) -> tuple[np.ndarray, np.ndarray]:
     return nodes, weights
 
 
-def legendre_gauss_nodes(order: int) -> tuple[np.ndarray, np.ndarray]:
+@cache
+def legendre_gauss_nodes(order: int) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
     """ Return Legendre-Gauss nodes and weights for a given order in 1D
     """
     nodes, weights = np.polynomial.legendre.leggauss(order)
@@ -84,7 +93,7 @@ def legendre_gauss_nodes(order: int) -> tuple[np.ndarray, np.ndarray]:
 
 
 @cache
-def equi_nodes_prism(order: int) -> np.ndarray:
+def equi_nodes_prism(order: int) -> npt.NDArray[np.float64]:
     """ Return equidistant nodes on a wedge/prism
     """
     xEq = np.linspace(-1, 1, num=order, dtype=np.float64)
@@ -94,7 +103,7 @@ def equi_nodes_prism(order: int) -> np.ndarray:
 
 
 @cache
-def equi_nodes_pyram(order: int) -> np.ndarray:
+def equi_nodes_pyram(order: int) -> npt.NDArray[np.float64]:
     """ Return equidistant nodes on a pyramid
     """
     xEq = np.linspace(-1, 1, num=order, dtype=np.float64)
@@ -104,7 +113,7 @@ def equi_nodes_pyram(order: int) -> np.ndarray:
 
 
 @cache
-def equi_nodes_tetra(order: int) -> np.ndarray:
+def equi_nodes_tetra(order: int) -> npt.NDArray[np.float64]:
     """ Return equidistant nodes on a tetrahedron
     """
     xEq = np.linspace(-1, 1, num=order, dtype=np.float64)
@@ -113,26 +122,49 @@ def equi_nodes_tetra(order: int) -> np.ndarray:
     return np.vstack((xEq[iXI[mask]], xEq[iETA[mask]], xEq[iZETA[mask]]))
 
 
-def barycentric_weights(_: int, xGP: np.ndarray) -> np.ndarray:
-    """ Compute the barycentric weights for a given node set
-        > Algorithm 30, Kopriva
-    """
-    # Create a difference matrix (x_i - x_j) for all i, j
-    diff_matrix = xGP[:, np.newaxis] - xGP[np.newaxis, :]
+if not NUMBA_AVAILABLE:
+    def barycentric_weights(_: int, xGP: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+        """ Compute the barycentric weights for a given node set
+            > Algorithm 30, Kopriva
+        """
+        # Create a difference matrix (x_i - x_j) for all i, j
+        diff_matrix = xGP[:, np.newaxis] - xGP[np.newaxis, :]
 
-    # Set the diagonal to 1 to avoid division by zero (diagonal elements will not be used)
-    np.fill_diagonal(diff_matrix, 1.0)
+        # Set the diagonal to 1 to avoid division by zero (diagonal elements will not be used)
+        np.fill_diagonal(diff_matrix, 1.0)
 
-    # Compute the product of all differences for each row (excluding the diagonal)
-    wBary = np.prod(diff_matrix, axis=1)
+        # Compute the product of all differences for each row (excluding the diagonal)
+        wBary = np.prod(diff_matrix, axis=1)
 
-    # Take the reciprocal to get the final barycentric weights
-    # wBary = 1.0 / wBary
+        # Take the reciprocal to get the final barycentric weights
+        # wBary = 1.0 / wBary
 
-    return 1.0 / wBary
+        return 1.0 / wBary
+else:
+    @jit(types.float64[:](types.int64, types.float64[:]), nopython=True, cache=True, nogil=True)
+    def barycentric_weights(_, xGP):
+        """ Compute the barycentric weights for a given node set
+            > Algorithm 30, Kopriva
+        """
+        n = xGP.shape[0]
+        w_bary = np.ones(n, dtype=np.float64)
+
+        # Create a difference matrix (x_i - x_j) for all i, j
+        for i in range(n):
+            # Set the diagonal to 1 to avoid division by zero (diagonal elements will not be used)
+            p = 1.0
+
+            # Compute the product of all differences for each row (excluding the diagonal)
+            for j in range(n):
+                if i != j:
+                    p *= (xGP[i] - xGP[j])
+            w_bary[i] = p
 
+        # Take the reciprocal to get the final barycentric weights
+        return 1.0 / w_bary
 
-def polynomial_derivative_matrix(order: int, xGP: np.ndarray) -> np.ndarray:
+
+def polynomial_derivative_matrix(order: int, xGP: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     """ Compute the polynomial derivative matrix for a given node set
         > Algorithm 37, Kopriva
     """
@@ -148,12 +180,17 @@ def polynomial_derivative_matrix(order: int, xGP: np.ndarray) -> np.ndarray:
     return D
 
 
-def lagrange_interpolation_polys(x: Union[float, np.ndarray], order: int, xGP: np.ndarray, wBary: np.ndarray) -> np.ndarray:
+@jit(types.float64[:](types.float64, types.int64, types.float64[:], types.float64[:]),
+     nopython=True, cache=True, nogil=True)
+def lagrange_interpolation_polys(x:     float,
+                                 order: int,
+                                 xGP:   npt.NDArray[np.float64],
+                                 wBary: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     """ Computes all Lagrange functions evaluated at position x in [-1;1]
         > Algorithm 34, Kopriva
     """
     # Equal points need special treatment
-    lagrange = np.zeros(order)
+    lagrange = np.zeros(order, dtype=np.float64)
     for iGP in range(order):
         if abs(x - xGP[iGP]) < 1.E-14:
             lagrange[iGP] = 1
@@ -170,11 +207,17 @@ def lagrange_interpolation_polys(x: Union[float, np.ndarray], order: int, xGP: n
     return lagrange/tmp
 
 
-def calc_vandermonde(n_In: int, n_Out: int, wBary_In: np.ndarray, xi_In: np.ndarray, xi_Out: np.ndarray) -> np.ndarray:
+@jit(types.float64[:, :](types.int64, types.int64, types.float64[:], types.float64[:], types.float64[:]),
+     nopython=True, cache=True, nogil=True)
+def calc_vandermonde(n_In:     int,
+                     n_Out:    int,
+                     wBary_In: npt.NDArray[np.float64],
+                     xi_In:    npt.NDArray[np.float64],
+                     xi_Out:   npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     """ Build a 1D Vandermonde matrix using the Lagrange basis functions of degree N_In,
         evaluated at the interpolation points xi_Out
     """
-    Vdm = np.zeros((n_Out, n_In))
+    Vdm = np.zeros((n_Out, n_In), dtype=np.float64)
     for iXI in range(n_Out):
         Vdm[iXI, :] = lagrange_interpolation_polys(xi_Out[iXI], n_In, xi_In, wBary_In)
     return Vdm
@@ -254,7 +297,7 @@ def calc_vandermonde(n_In: int, n_Out: int, wBary_In: np.ndarray, xi_In: np.ndar
 #      return Vdm
 
 
-def polynomial_derivative_matrix_prism(order: int, xGP: np.ndarray) -> np.ndarray:
+def polynomial_derivative_matrix_prism(order: int, xGP: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     """ Compute the polynomial derivative matrix for a prism
     """
     a: Final[np.ndarray]  = xGP[0, :]
@@ -262,19 +305,19 @@ def polynomial_derivative_matrix_prism(order: int, xGP: np.ndarray) -> np.ndarra
     c: Final[np.ndarray]  = xGP[2, :]
 
     nDOFs = NDOFS_ELEM(106, order-1)
-    Vdm = np.zeros((   nDOFs, nDOFs))
-    Vr  = np.zeros((   nDOFs, nDOFs))
-    Vs  = np.zeros((   nDOFs, nDOFs))
-    Vt  = np.zeros((   nDOFs, nDOFs))
-    D   = np.zeros((3, nDOFs, nDOFs))
+    Vdm = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vr  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vs  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vt  = np.zeros((   nDOFs, nDOFs), dtype=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([          sp.special.eval_jacobi(i  , 0, 0, c) for i in range(order)])
-    dfZETA_all = np.array([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)
-    fETA_all   = np.array([          sp.special.eval_jacobi(j  , 0, 0, b) for j in range(order)])
-    dfETA_all  = np.array([0.5*(j+1)*sp.special.eval_jacobi(j-1, 1, 1, b) for j in range(order)])
+    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)))
 
     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]
@@ -347,7 +390,7 @@ def polynomial_derivative_matrix_prism(order: int, xGP: np.ndarray) -> np.ndarra
     return D
 
 
-def polynomial_derivative_matrix_pyram(order: int, xGP: np.ndarray) -> np.ndarray:
+def polynomial_derivative_matrix_pyram(order: int, xGP: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     """ Compute the polynomial derivative matrix for a pyramid
     """
     a  = np.where((1 - xGP[2, :]) <= 1.e-12, -1.0, 2 * (1 + xGP[0, :]) / (1. - xGP[2, :] + 1.e-20) - 1.)
@@ -355,11 +398,11 @@ def polynomial_derivative_matrix_pyram(order: int, xGP: np.ndarray) -> np.ndarra
     c  = xGP[2, :]
 
     nDOFs = NDOFS_ELEM(105, order-1)
-    Vdm = np.zeros((   nDOFs, nDOFs))
-    Vr  = np.zeros((   nDOFs, nDOFs))
-    Vs  = np.zeros((   nDOFs, nDOFs))
-    Vt  = np.zeros((   nDOFs, nDOFs))
-    D   = np.zeros((3, nDOFs, nDOFs))
+    Vdm = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vr  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vs  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vt  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    D   = np.zeros((3, nDOFs, nDOFs), dtype=np.float64)
 
     iX = 0
     for iZETA in range(order):
@@ -421,7 +464,7 @@ def polynomial_derivative_matrix_pyram(order: int, xGP: np.ndarray) -> np.ndarra
     return D
 
 
-def polynomial_derivative_matrix_tetra(order: int, xGP: np.ndarray) -> np.ndarray:
+def polynomial_derivative_matrix_tetra(order: int, xGP: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     """ Compute the polynomial derivative matrix for a tetra
     """
     a  = np.where(np.abs(xGP[1, :] + xGP[2, :]) <= 1.e-12, -1.0, 2 * (1 + xGP[0, :]) / (- xGP[1, :] - xGP[2, :] + 1.e-20) - 1.)
@@ -429,11 +472,11 @@ def polynomial_derivative_matrix_tetra(order: int, xGP: np.ndarray) -> np.ndarra
     c  = xGP[2, :]
 
     nDOFs = NDOFS_ELEM(104, order-1)
-    Vdm = np.zeros((   nDOFs, nDOFs))
-    Vr  = np.zeros((   nDOFs, nDOFs))
-    Vs  = np.zeros((   nDOFs, nDOFs))
-    Vt  = np.zeros((   nDOFs, nDOFs))
-    D   = np.zeros((3, nDOFs, nDOFs))
+    Vdm = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vr  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vs  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    Vt  = np.zeros((   nDOFs, nDOFs), dtype=np.float64)
+    D   = np.zeros((3, nDOFs, nDOFs), dtype=np.float64)
 
     # Precompute constants
     sqrt2    = np.sqrt(2.)
@@ -504,7 +547,7 @@ def polynomial_derivative_matrix_tetra(order: int, xGP: np.ndarray) -> np.ndarra
 
 
 if not NUMBA_AVAILABLE:
-    def change_basis_3D(Vdm: np.ndarray, x3D_In: np.ndarray) -> np.ndarray:
+    def change_basis_3D(Vdm: npt.NDArray[np.float64], x3D_In: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
         """ Interpolate a 3D tensor product Lagrange basis defined by (N_in+1) 1D interpolation point positions xi_In(0:N_In)
             to another 3D tensor product node positions (number of nodes N_out+1)
             defined by (N_out+1) interpolation point  positions xi_Out(0:N_Out)
@@ -533,7 +576,7 @@ if not NUMBA_AVAILABLE:
 
 else:
     @jit((types.float64[:, :, :, ::1])(types.float64[:, ::1], types.float64[:, :, :, :]), nopython=True, cache=True, nogil=True)
-    def change_basis_3D(Vdm: np.ndarray, x3D_In: np.ndarray) -> np.ndarray:
+    def change_basis_3D(Vdm: npt.NDArray[np.float64], x3D_In: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
         """ Interpolate a 3D tensor product Lagrange basis defined by (N_in+1) 1D interpolation point positions xi_In(0:N_In)
             to another 3D tensor product node positions (number of nodes N_out+1)
             defined by (N_out+1) interpolation point  positions xi_Out(0:N_Out)
@@ -561,7 +604,7 @@ else:
 
 
 if not NUMBA_AVAILABLE:
-    def change_basis_2D(Vdm: np.ndarray, x2D_In: np.ndarray) -> np.ndarray:
+    def change_basis_2D(Vdm: npt.NDArray[np.float64], x2D_In: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
         """ Interpolate a 2D tensor product Lagrange basis defined by (N_in+1) 1D interpolation point positions xi_In(0:N_In)
             to another 2D tensor product node positions (number of nodes N_out+1)
             defined by (N_out+1) interpolation point positions xi_Out(0:N_Out)
@@ -584,7 +627,7 @@ if not NUMBA_AVAILABLE:
 
 else:
     @jit((types.float64[:, :, ::1])(types.float64[:, ::1], types.float64[:, :, :]), nopython=True, cache=True, nogil=True)
-    def change_basis_2D(Vdm: np.ndarray, x2D_In: np.ndarray) -> np.ndarray:
+    def change_basis_2D(Vdm: npt.NDArray[np.float64], x2D_In: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
         """ Interpolate a 2D tensor product Lagrange basis defined by (N_in+1) 1D interpolation point positions xi_In(0:N_In)
             to another 2D tensor product node positions (number of nodes N_out+1)
             defined by (N_out+1) interpolation point positions xi_Out(0:N_Out)
@@ -607,7 +650,18 @@ else:
         return x2D_Out.reshape(dim1, n_Out, n_Out)
 
 
-def evaluate_jacobian(xGeo_In: np.ndarray, VdmGLtoAP: np.ndarray, D_EqToGL: np.ndarray) -> np.ndarray:
+def change_basis_1D(Vdm: npt.NDArray[np.float64], x1D_In: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    """ Interpolate a 1D tensor product Lagrange basis defined by (N_in+1) 1D interpolation point positions xi_In(0:N_In)
+        to another 1D tensor product node positions (number of nodes N_out+1)
+        defined by (N_out+1) interpolation point positions xi_Out(0:N_Out)
+        xi is defined in the 1D reference element xi=[-1,1]
+    """
+    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]
@@ -622,7 +676,7 @@ def evaluate_jacobian(xGeo_In: np.ndarray, VdmGLtoAP: np.ndarray, D_EqToGL: np.n
 
     # Perform tensor contraction for the second derivative (Eta direction)
     dXdEtaGL  = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 2))
-    dXdEtaGL  = np.moveaxis(dXdEtaGL , 1, 0)  # Correct the shape to (3, n_Out, n_In, n_In)
+    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)
 
@@ -656,7 +710,9 @@ def evaluate_jacobian(xGeo_In: np.ndarray, VdmGLtoAP: np.ndarray, D_EqToGL: np.n
     return np.einsum('ijkl,ijkl->jkl', dXdXiAP, cross_eta_zeta)
 
 
-def evaluate_jacobian_simplex(xGeo_In: np.ndarray, _: np.ndarray, D_EqToGL: np.ndarray) -> np.ndarray:
+def evaluate_jacobian_simplex(xGeo_In:  npt.NDArray[np.float64],
+                              _:        Any,
+                              D_EqToGL: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
     # Perform tensor contraction for each derivative
     # Change basis for each direction
     dXdXiAP   = xGeo_In[:, :] @ D_EqToGL[0, :, :]

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

@@ -25,6 +25,7 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
+from __future__ import annotations
 import re
 import sys
 from typing import Final, Optional, cast
@@ -167,14 +168,15 @@ def CheckConnect() -> None:
     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))))),
+        res     = run_in_parallel(process_chunk,                                                           # noqa: E251
+                                  elems,                                                                   # noqa: E251
+                                  chunk_size  = max(1, min(1000, max(10, int(len(elems)/(40.*np_mtp))))),  # noqa: E251
+                                  ordering    = False,                                                     # noqa: E251
                                  )
     else:
         res     = [elem for elem in elems if check_sides(elem, failed_only=True)]
 
-    if len(res) > 0:
+    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