PyHOPE 0.1.0__tar.gz → 0.8.0__tar.gz

pyhope-0.8.0/AUTHORS.md

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

{pyhope-0.1.0 → pyhope-0.8.0}/PKG-INFO

@@ -1,8 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: PyHOPE
-Version: 0.1.0
+Version: 0.8.0
 Summary: Python High-Order Preprocessing Environment
 License: GPL-3.0-only
+License-File: AUTHORS.md
+License-File: LICENSE.md
 Keywords: PyHOPE,mesh generator
 Author: Numerics Research Group (NRG)
 Author-email: numerics@iag.uni-stuttgart.de
@@ -24,17 +26,17 @@ Requires-Dist: numpy (>=2.0.0)
 Requires-Dist: packaging
 Requires-Dist: plotext
 Requires-Dist: scipy
-Requires-Dist: sortedcontainers
 Requires-Dist: typing-extensions
+Project-URL: Documentation, https://hopr-framework.github.io/PyHOPE
 Project-URL: Homepage, https://numericsresearchgroup.org
-Project-URL: Repository, https://gitlab.iag.uni-stuttgart.de/flexi/codes/pyhope
+Project-URL: Repository, https://github.com/hopr-framework/pyhope
 Description-Content-Type: text/markdown
 
 PyHOPE (Python High-Order Preprocessing Environment) is an open-source Python framework for the generation of three-dimensional unstructured high-order meshes. These meshes are needed by high-order numerical methods like Discontinuous Galerkin, Spectral Element Methods, or pFEM, in order to retain their accuracy if the computational domain includes curved boundaries.
 
 PyHOPE has been developed by the Numerics Research Group (NRG) lead by Prof. Andrea Beck at the Institute of Aerodynamics and Gas Dynamics at the University of Stuttgart, Germany.
 
-PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. For more information and tutorials, please visit the [HOPR documentation](https://hopr.readthedocs.io). Furthermore, PyHOPE utilizes [Gmsh](https://gmsh.info) for the initial mesh generation and conversion before converting it to its internal representation.
+PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. Furthermore, PyHOPE utilizes [Gmsh](https://gmsh.info) for the initial mesh generation and conversion before converting it to its internal representation. The internal representation is loosely based on [meshio](https://github.com/nschloe/meshio) but augmented with additional information required for high-order meshes.
 
 This is a scientific project. If you use PyHOPE for publications or presentations in science, please support the project by citing our publications given at [numericsresearchgroup.org](https://numericsresearchgroup.org/publications.html).
 
@@ -49,22 +51,47 @@ PyHOPE is built using standard Python packages. You can install PyHOPE by follow
     ```
     If you choose not to use a virtual environment, skip this step and proceed directly to the installation of PyHOPE.
 
+> [!IMPORTANT]  
+> For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+
 2.  **Install PyHOPE**  
     PyHOPE is installed using `pip`, the Python package installer. This command fetches the PyHOPE package and its dependencies from PyPI (Python Package Index) and installs them.
     ```bash
     python -m pip install pyhope
     ```
 
-3. **Run PyHOPE**
-    PyHOPE is available as a command-line tool. After installation, its functionalities can be accessed directly from the terminal.
-    ```bash
-    pyhope --help
-    ```
+# Testing
+PyHOPE features internal health checks to verify that everything works as expected. The checks can be invoked directly from the terminal.
+```bash
+pyhope --verify [tutorials]          # Run all health checks
+pyhope --verify-health               # Run Python health checks
+pyhope --verify-install [tutorials]  # Run PyHOPE mesh generation checks
+```
+
+> [!NOTE]  
+>  By default, PyHOPE looks for the `tutorials` directory relative to the current working directory or the git root. If neither exists, PyHOPE downloads the tests from GitHub while using available authentication methods.
+
+> [!IMPORTANT]  
+> Be aware that the PyHOPE repository uses [Git Large File Storage (LFS)](https://git-lfs.com) for some of its larger mesh files.
 
-    > 🛈 Remark: For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+# Getting Help
+PyHOPE help output is formatted to serve as self-hosting [INI format](https://hopr-framework.github.io/PyHOPE/user-guide/parameter-file). A list of all options and the default values can be accessed by running the following command.
+```bash
+pyhope --help
+```
+
+# Documentation
+Refer to the [PyHOPE documentation](https://hopr-framework.github.io/PyHOPE) for the getting started guide, examples, and usage instructions. PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. For technical details and the reference mesh format specification, see the [HOPR documentation](https://hopr.readthedocs.io).
 
 # Usage
-PyHOPE is invoked from the command line. Run parameters are read from a configuration file. The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
+PyHOPE can either be invoked directly from the command line or used as a Python library.
+
+## Command Line Usage
+PyHOPE can be invoked from the command line. After installation, its functionalities can be accessed directly from the terminal by passing a valid configuration file.
+```bash
+pyhope [parameter.ini]
+```
+The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
 ```
 $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -72,11 +99,12 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┃ PyHOPE version x.x.x
 ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 │ INIT PROGRAM...
-│                        nThreads │ 10                              │ DEFAULT │
+│                        nThreads │ nProcs-2                        │ DEFAULT │
 ├─────────────────────────────────────────────
 │ INIT OUTPUT...
 │                     ProjectName │ 1-01-cartbox                    │ *CUSTOM │
 │                    OutputFormat │ 0 [HDF5]                        │ *CUSTOM │
+│                       DebugMesh │ T                               │ *CUSTOM │
 │                       DebugVisu │ F                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ INIT MESH...
@@ -87,7 +115,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├────
 │                          nZones │ 1                               │ *CUSTOM │
 ├── Generating zone 1
-│                          Corner │ (/0.,0.,0. ,,1.,0.,0. ,,1.,1... │ *CUSTOM │
+│                          Corner │ (/0.,0.,0.,,1.,0.,0.,,1.,1.,... │ *CUSTOM │
 │                          nElems │ (/8,8,8/)                       │ *CUSTOM │
 │                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
 │                     StretchType │ (/0,0,0/)                       │ DEFAULT │
@@ -108,9 +136,9 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │                    BoundaryName │ BC_zplus                        │ *CUSTOM │
 │                    BoundaryType │ (/9,0,0,0/)                     │ *CUSTOM │
 ├────
-│                              vv │ (/1., 0., 0./)                  │ *CUSTOM │
-│                              vv │ (/0., 1., 0./)                  │ *CUSTOM │
-│                              vv │ (/0., 0., 1./)                  │ *CUSTOM │
+│                              vv │ (/1.,0.,0./)                    │ *CUSTOM │
+│                              vv │ (/0.,1.,0./)                    │ *CUSTOM │
+│                              vv │ (/0.,0.,1./)                    │ *CUSTOM │
 ├────
 ├── Generated mesh with 512 cells
 ├─────────────────────────────────────────────
@@ -126,7 +154,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ SORT MESH...
 ├────
-│                       doSortIJK │ False                           │ DEFAULT │
+│                     MeshSorting │ 1 [SFC]                         │ DEFAULT │
 ├────
 ├── Sorting elements along space-filling curve
 ├─────────────────────────────────────────────
@@ -177,8 +205,18 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │         Curved Hexahedra  :          512
 ├────
 ├── Writing HDF5 mesh to "1-01-cartbox_mesh.h5"
+├── Writing XDMF mesh to "1-01-cartbox_DebugMesh.xdmf"
 ┢━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ PyHOPE completed in [0.25 sec]
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
+## Python Library Usage
+PyHOPE can be included in other Python libraries. PyHOPE exposes its functionally via runtime contexts defined by [Context Managers](https://docs.python.org/3/library/stdtypes.html#typecontextmanager). The following Python code loads a HOPR HDF5 mesh and derived quantities. For a complete list of currently implemented functions, see the [source code](https://github.com/hopr-framework/PyHOPE/blob/main/pyhope/__init__.py).
+```python
+from pyhope import Basis, Mesh
+with Mesh('1-01-cartbox_mesh.h5') as m:
+    elems = m.elems
+    lobatto_nodes = Basis.legendre_gauss_lobatto_nodes(order=m.nGeo)
+```
+

{pyhope-0.1.0 → pyhope-0.8.0}/README.md

@@ -2,7 +2,7 @@ PyHOPE (Python High-Order Preprocessing Environment) is an open-source Python fr
 
 PyHOPE has been developed by the Numerics Research Group (NRG) lead by Prof. Andrea Beck at the Institute of Aerodynamics and Gas Dynamics at the University of Stuttgart, Germany.
 
-PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. For more information and tutorials, please visit the [HOPR documentation](https://hopr.readthedocs.io). Furthermore, PyHOPE utilizes [Gmsh](https://gmsh.info) for the initial mesh generation and conversion before converting it to its internal representation.
+PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. Furthermore, PyHOPE utilizes [Gmsh](https://gmsh.info) for the initial mesh generation and conversion before converting it to its internal representation. The internal representation is loosely based on [meshio](https://github.com/nschloe/meshio) but augmented with additional information required for high-order meshes.
 
 This is a scientific project. If you use PyHOPE for publications or presentations in science, please support the project by citing our publications given at [numericsresearchgroup.org](https://numericsresearchgroup.org/publications.html).
 
@@ -17,22 +17,47 @@ PyHOPE is built using standard Python packages. You can install PyHOPE by follow
     ```
     If you choose not to use a virtual environment, skip this step and proceed directly to the installation of PyHOPE.
 
+> [!IMPORTANT]  
+> For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+
 2.  **Install PyHOPE**  
     PyHOPE is installed using `pip`, the Python package installer. This command fetches the PyHOPE package and its dependencies from PyPI (Python Package Index) and installs them.
     ```bash
     python -m pip install pyhope
     ```
 
-3. **Run PyHOPE**
-    PyHOPE is available as a command-line tool. After installation, its functionalities can be accessed directly from the terminal.
-    ```bash
-    pyhope --help
-    ```
+# Testing
+PyHOPE features internal health checks to verify that everything works as expected. The checks can be invoked directly from the terminal.
+```bash
+pyhope --verify [tutorials]          # Run all health checks
+pyhope --verify-health               # Run Python health checks
+pyhope --verify-install [tutorials]  # Run PyHOPE mesh generation checks
+```
+
+> [!NOTE]  
+>  By default, PyHOPE looks for the `tutorials` directory relative to the current working directory or the git root. If neither exists, PyHOPE downloads the tests from GitHub while using available authentication methods.
+
+> [!IMPORTANT]  
+> Be aware that the PyHOPE repository uses [Git Large File Storage (LFS)](https://git-lfs.com) for some of its larger mesh files.
 
-    > 🛈 Remark: For new shell sessions, the virtual environment must be re-sourced using `source venv/bin/activate` before using `pyhope` commands.
+# Getting Help
+PyHOPE help output is formatted to serve as self-hosting [INI format](https://hopr-framework.github.io/PyHOPE/user-guide/parameter-file). A list of all options and the default values can be accessed by running the following command.
+```bash
+pyhope --help
+```
+
+# Documentation
+Refer to the [PyHOPE documentation](https://hopr-framework.github.io/PyHOPE) for the getting started guide, examples, and usage instructions. PyHOPE is heavily inspired by [HOPR (High Order Preprocessor)](https://github.com/hopr-framework/hopr) and shares the same input/output format. For technical details and the reference mesh format specification, see the [HOPR documentation](https://hopr.readthedocs.io).
 
 # Usage
-PyHOPE is invoked from the command line. Run parameters are read from a configuration file. The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
+PyHOPE can either be invoked directly from the command line or used as a Python library.
+
+## Command Line Usage
+PyHOPE can be invoked from the command line. After installation, its functionalities can be accessed directly from the terminal by passing a valid configuration file.
+```bash
+pyhope [parameter.ini]
+```
+The following output is obtained when running the example configuration file `tutorials/1-01-cartbox/parameter.ini`.
 ```
 $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -40,11 +65,12 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┃ PyHOPE version x.x.x
 ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 │ INIT PROGRAM...
-│                        nThreads │ 10                              │ DEFAULT │
+│                        nThreads │ nProcs-2                        │ DEFAULT │
 ├─────────────────────────────────────────────
 │ INIT OUTPUT...
 │                     ProjectName │ 1-01-cartbox                    │ *CUSTOM │
 │                    OutputFormat │ 0 [HDF5]                        │ *CUSTOM │
+│                       DebugMesh │ T                               │ *CUSTOM │
 │                       DebugVisu │ F                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ INIT MESH...
@@ -55,7 +81,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├────
 │                          nZones │ 1                               │ *CUSTOM │
 ├── Generating zone 1
-│                          Corner │ (/0.,0.,0. ,,1.,0.,0. ,,1.,1... │ *CUSTOM │
+│                          Corner │ (/0.,0.,0.,,1.,0.,0.,,1.,1.,... │ *CUSTOM │
 │                          nElems │ (/8,8,8/)                       │ *CUSTOM │
 │                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
 │                     StretchType │ (/0,0,0/)                       │ DEFAULT │
@@ -76,9 +102,9 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │                    BoundaryName │ BC_zplus                        │ *CUSTOM │
 │                    BoundaryType │ (/9,0,0,0/)                     │ *CUSTOM │
 ├────
-│                              vv │ (/1., 0., 0./)                  │ *CUSTOM │
-│                              vv │ (/0., 1., 0./)                  │ *CUSTOM │
-│                              vv │ (/0., 0., 1./)                  │ *CUSTOM │
+│                              vv │ (/1.,0.,0./)                    │ *CUSTOM │
+│                              vv │ (/0.,1.,0./)                    │ *CUSTOM │
+│                              vv │ (/0.,0.,1./)                    │ *CUSTOM │
 ├────
 ├── Generated mesh with 512 cells
 ├─────────────────────────────────────────────
@@ -94,7 +120,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ SORT MESH...
 ├────
-│                       doSortIJK │ False                           │ DEFAULT │
+│                     MeshSorting │ 1 [SFC]                         │ DEFAULT │
 ├────
 ├── Sorting elements along space-filling curve
 ├─────────────────────────────────────────────
@@ -145,7 +171,17 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │         Curved Hexahedra  :          512
 ├────
 ├── Writing HDF5 mesh to "1-01-cartbox_mesh.h5"
+├── Writing XDMF mesh to "1-01-cartbox_DebugMesh.xdmf"
 ┢━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ┃ PyHOPE completed in [0.25 sec]
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
+
+## Python Library Usage
+PyHOPE can be included in other Python libraries. PyHOPE exposes its functionally via runtime contexts defined by [Context Managers](https://docs.python.org/3/library/stdtypes.html#typecontextmanager). The following Python code loads a HOPR HDF5 mesh and derived quantities. For a complete list of currently implemented functions, see the [source code](https://github.com/hopr-framework/PyHOPE/blob/main/pyhope/__init__.py).
+```python
+from pyhope import Basis, Mesh
+with Mesh('1-01-cartbox_mesh.h5') as m:
+    elems = m.elems
+    lobatto_nodes = Basis.legendre_gauss_lobatto_nodes(order=m.nGeo)
+```

{pyhope-0.1.0 → pyhope-0.8.0}/pyhope/__init__.py

@@ -66,8 +66,8 @@ MeshContainer = namedtuple('Mesh',
                           ])
 
 
-@contextmanager
-def Mesh(*args, stdout=False, stderr=True):
+@contextmanager  # pragma: no cover
+def Mesh(*args: str, stdout: bool = False, stderr: bool = True):
     """ Mesh context manager to generate a mesh from a given file
 
         Args:
@@ -156,8 +156,8 @@ def Mesh(*args, stdout=False, stderr=True):
 
     finally:
         # Cleanup resources after exiting the context
-        mesh_vars.mesh  = None
-        mesh_vars.nGeo  = None
-        mesh_vars.bcs   = None
-        mesh_vars.elems = None
-        mesh_vars.sides = None
+        del mesh_vars.mesh
+        del mesh_vars.nGeo
+        del mesh_vars.bcs
+        del mesh_vars.elems
+        del mesh_vars.sides

{pyhope-0.1.0 → pyhope-0.8.0}/pyhope/basis/basis_basis.py

@@ -25,6 +25,7 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
+from typing import Union
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -111,7 +112,7 @@ def polynomial_derivative_matrix(order: int, xGP: np.ndarray) -> np.ndarray:
     return D
 
 
-def lagrange_interpolation_polys(x: float, order: int, xGP: np.ndarray, wBary: np.ndarray) -> np.ndarray:
+def lagrange_interpolation_polys(x: Union[float, np.ndarray], order: int, xGP: np.ndarray, wBary: np.ndarray) -> np.ndarray:
     """ Computes all Lagrange functions evaluated at position x in [-1;1]
         > Algorithm 34, Kopriva
     """
@@ -147,10 +148,10 @@ def change_basis_3D(Vdm: np.ndarray, x3D_In: np.ndarray) -> np.ndarray:
     """ 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)
-        xi is defined in the 1DrefElem xi=[-1,1]
+        xi is defined in the 1D reference element xi=[-1,1]
     """
     # First contraction along the iN_In axis (axis 1 of Vdm, axis 1 of x3D_In)
-    x3D_Buf1 = np.tensordot(Vdm, x3D_In, axes=(1, 1))
+    x3D_Buf1 = np.tensordot(Vdm, x3D_In , axes=(1, 1))
     x3D_Buf1 = np.moveaxis(x3D_Buf1, 0, 1)  # Correct the shape to (dim1, n_Out, n_In, n_In)
 
     # Second contraction along the jN_In axis (axis 1 of Vdm, axis 2 of x3D_Buf1)
@@ -160,6 +161,8 @@ def change_basis_3D(Vdm: np.ndarray, x3D_In: np.ndarray) -> np.ndarray:
     # Third contraction along the kN_In axis (axis 1 of Vdm, axis 3 of x3D_Buf2)
     x3D_Out  = np.tensordot(Vdm, x3D_Buf2, axes=(1, 3))
     x3D_Out  = np.moveaxis(x3D_Out , 0, 3)  # Correct the shape to (dim1, n_Out, n_Out, n_Out)
+    # PERF: This is actually slower than the individual contractions
+    # x3D_Out  = np.einsum('pi,qj,rk,dijk->dpqr', Vdm, Vdm, Vdm, x3D_In, optimize=True)
 
     return x3D_Out
 
@@ -177,22 +180,32 @@ def change_basis_2D(Vdm: np.ndarray, x2D_In: np.ndarray) -> np.ndarray:
     # Second contraction along the jN_In axis (axis 1 of Vdm, axis 2 of x2D_Buf1)
     x2D_Out = np.tensordot(Vdm, x2D_Buf1, axes=(1, 2))
     x2D_Out = np.moveaxis(x2D_Out, 0, 2)  # Correct the shape to  (dim1, n_Out, n_Out, n_In)
+    # PERF: This is actually slower than the individual contractions
+    # x2D_Out = np.einsum('pi,qj,dij->dpq', Vdm, Vdm, x2D_In, optimize=True)
 
     return x2D_Out
 
 
 def evaluate_jacobian(xGeo_In: np.ndarray, VdmGLtoAP: np.ndarray, D_EqToGL: np.ndarray) -> np.ndarray:
+    """ Calculate the Jacobian of the mapping for a given element
+    """
     # 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)
+    # PERF: This is actually slower than the individual contractions
+    # dXdXiGL   = np.einsum('pi,dijk->dpjk', D_EqToGL, xGeo_In, optimize=True)
 
     # 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, nGeoRef, nGeoRef, nGeoRef)
+    # 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)
+    # 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  )
@@ -200,10 +213,17 @@ def evaluate_jacobian(xGeo_In: np.ndarray, VdmGLtoAP: np.ndarray, D_EqToGL: np.n
     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)
+    # 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)
 
     return jacOut
 

{pyhope-0.1.0 → pyhope-0.8.0}/pyhope/basis/basis_connect.py

@@ -27,12 +27,17 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 import re
 import sys
-from typing import Final
+from typing import Final, cast
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
 import numpy as np
-import numpy.typing as npt
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Typing libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+import typing
+if typing.TYPE_CHECKING:
+    import numpy.typing as npt
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Local imports
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -43,7 +48,7 @@ from pyhope.mesh.mesh_common import face_to_nodes
 
 
 def check_sides(elem,
-                ) -> list[bool | int | np.ndarray]:
+               ) -> list[bool | int | np.ndarray]:
     results = []
     elems:  Final[list]  = mesh_vars.elems
     sides:  Final[list]  = mesh_vars.sides
@@ -130,7 +135,7 @@ def CheckConnect() -> None:
     elems:     Final[list] = mesh_vars.elems
 
     # Only consider hexahedrons
-    if any(e.type % 100 != 8 for e in elems):
+    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]))
         print(hopout.warn('Ignored element type: {}'.format(
             [re.sub(r"\d+$", "", mesh_vars.ELEMTYPE.inam[e][0]) for e in elemTypes]

{pyhope-0.1.0 → pyhope-0.8.0}/pyhope/basis/basis_jacobian.py

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

{pyhope-0.1.0 → pyhope-0.8.0}/pyhope/basis/basis_watertight.py

@@ -57,7 +57,12 @@ def eval_nsurf(XGeo: np.ndarray, Vdm: np.ndarray, DGP: np.ndarray, weights: np.n
 
     # Compute the cross product at each Gauss point
     VDMSize  = Vdm.shape[-1]
-    nVec     = np.cross(dXdxiGP, dXdetaGP, axis=0)  # Shape: (3, N_GP*N_GP)
+    # nVec     = np.cross(dXdxiGP, dXdetaGP, axis=0)  # Shape: (3, N_GP*N_GP)
+    # > Manually compute cross product
+    nVec = np.empty_like(dXdxiGP)
+    nVec[0] = dXdxiGP[1] * dXdetaGP[2] - dXdxiGP[2] * dXdetaGP[1]
+    nVec[1] = dXdxiGP[2] * dXdetaGP[0] - dXdxiGP[0] * dXdetaGP[2]
+    nVec[2] = dXdxiGP[0] * dXdetaGP[1] - dXdxiGP[1] * dXdetaGP[0]
     nVec     = nVec.reshape(3, VDMSize, VDMSize)    # Reshape to (3, N_GP+1, N_GP+1)
 
     # Compute the weighted normals
@@ -86,10 +91,6 @@ def check_sides(elem,
     elemType = elem.type
 
     for SideID in elem.sides:
-        # TODO: THIS IS CURRENTLY IGNORED, MEANING WE CHECK EVERY CONNECTION DOUBLE
-        # if checked[SideID]:
-        #     continue
-
         side   = sides[SideID]
 
         # Only connected sides and not small mortar sides
@@ -109,7 +110,6 @@ def check_sides(elem,
             # Calculate the L2 norm of the side and take the maximum
             sideTol = np.linalg.norm(nSurf, ord=2)
             tol     = np.max((elemTol, sideTol)) * mesh_vars.tolInternal
-            # checked[SideID] = True
 
             # Mortar sides are the following virtual sides
             nMortar = 4 if mortarType == 1 else 2
@@ -122,7 +122,6 @@ def check_sides(elem,
                 nbelem   = elems[nbside.elemID]
                 idx      = nbelem.nodes[face_to_nodes(nbside.face, nbelem.type, nGeo)]
                 nnbSurf += eval_nsurf(np.transpose(points[idx], axes=(2, 0, 1)), VdmEqToGP, DGP, weights)
-                # checked[nbside] = True
 
             # Check if side normals are within tolerance
             nSurfErr = np.sum(np.abs(nnbSurf + nSurf))
@@ -130,6 +129,10 @@ def check_sides(elem,
 
         # Internal side
         elif side.connection >= 0:
+            # Only process the side with the smaller ID
+            if SideID > side.connection:
+                continue
+
             # Ignore the virtual mortar sides
             if side.locMortar is not None:
                 continue
@@ -142,7 +145,6 @@ def check_sides(elem,
             # Calculate the L2 norm of the side and take the maximum
             sideTol = np.linalg.norm(nSurf, ord=2)
             tol     = np.max((elemTol, sideTol)) * mesh_vars.tolInternal
-            # checked[SideID] = True
 
             # Connected side
             nbside  = sides[side.connection]
@@ -151,7 +153,6 @@ def check_sides(elem,
             # nnbSurf = eval_nsurf(np.moveaxis(points[nbnodes], 2, 0), VdmEqToGP, DGP, weights)
             idx     = nbelem.nodes[face_to_nodes(nbside.face, nbelem.type, nGeo)]
             nnbSurf = eval_nsurf(np.transpose(points[idx]), VdmEqToGP, DGP, weights)
-            # checked[nbside] = True
 
             # Check if side normals are within tolerance
             nSurfErr = np.sum(np.abs(nnbSurf + nSurf))