PyHOPE 0.0.4__tar.gz → 0.0.7__tar.gz

{pyhope-0.0.4 → pyhope-0.0.7}/PKG-INFO

@@ -1,19 +1,16 @@
 Metadata-Version: 2.3
 Name: PyHOPE
-Version: 0.0.4
+Version: 0.0.7
 Summary: Python High-Order Preprocessing Environment
-Home-page: https://numericsresearchgroup.org
 License: GPL-3.0-only
 Keywords: PyHOPE,mesh generator
 Author: Numerics Research Group (NRG)
 Author-email: numerics@iag.uni-stuttgart.de
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Classifier: Development Status :: 3 - Alpha
 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.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -26,8 +23,9 @@ Requires-Dist: meshio
 Requires-Dist: numpy (>=2.0.0)
 Requires-Dist: packaging
 Requires-Dist: plotext
-Requires-Dist: pygmsh
 Requires-Dist: scipy
+Requires-Dist: typing-extensions
+Project-URL: Homepage, https://numericsresearchgroup.org
 Project-URL: Repository, https://gitlab.iag.uni-stuttgart.de/flexi/codes/pyhope
 Description-Content-Type: text/markdown
 
@@ -35,7 +33,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)
+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).
 
 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).
 
@@ -55,21 +53,17 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┃ P y H O P E — Python High-Order Preprocessing Environment
 ┃ PyHOPE version x.x.x
 ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-├─────────────────────────────────────────────
 │ INIT PROGRAM...
-│                        nThreads │ 4                               │ DEFAULT │
-│ INIT PROGRAM DONE!
+│                        nThreads │ 10                              │ DEFAULT │
 ├─────────────────────────────────────────────
 │ INIT OUTPUT...
 │                     ProjectName │ 1-01-cartbox                    │ *CUSTOM │
 │                    OutputFormat │ 0 [HDF5]                        │ *CUSTOM │
 │                       DebugVisu │ F                               │ *CUSTOM │
-│ INIT OUTPUT DONE!
 ├─────────────────────────────────────────────
 │ INIT MESH...
-│                            Mode │ 1                               │ *CUSTOM │
-│                   BoundaryOrder │ 2                               │ DEFAULT │
-│ INIT MESH DONE!
+│                            Mode │ 1 [Internal]                    │ *CUSTOM │
+│                            NGeo │ 4                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ GENERATE MESH...
 ├────
@@ -77,6 +71,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├── Generating zone 1
 │                          Corner │ (/0.,0.,0. ,,1.,0.,0. ,,1.,1... │ *CUSTOM │
 │                          nElems │ (/8,8,8/)                       │ *CUSTOM │
+│                     StretchType │ (/0,0,0/)                       │ DEFAULT │
 │                         BCIndex │ (/1,2,3,4,5,6/)                 │ *CUSTOM │
 ├────
 ├── Setting boundary conditions
@@ -94,28 +89,51 @@ $ 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 │
+├────
+│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
+├────
 ├── Generated mesh with 512 cells
+├─────────────────────────────────────────────
+├── BUILD DATA STRUCTURE...
+├────
+├── Removing duplicate points
+├── Ensuring normals point outward
+├────
+│             CheckSurfaceNormals │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├────
-│ GENERATE MESH DONE!
+├── Generating sides
 ├─────────────────────────────────────────────
+│ SORT MESH...
+├────
 │                       doSortIJK │ False                           │ DEFAULT │
 ├────
 ├── Sorting elements along space-filling curve
 ├─────────────────────────────────────────────
 │ CONNECT MESH...
-├─────────────────────────────────────────────
 ├────
-│  Number of sides          :         3072
-│  Number of inner sides    :         2688
-│  Number of boundary sides :          384
-│  Number of periodic sides :            0
+│               doPeriodicCorrect │ True                            │ DEFAULT │
+│                       doMortars │ True                            │ DEFAULT │
 ├────
-│ CONNECT MESH DONE!
+│  Number of sides                :         3072
+│  Number of inner sides          :         2688
+│  Number of mortar sides (big)   :            0
+│  Number of mortar sides (small) :            0
+│  Number of boundary sides       :          384
+│  Number of periodic sides       :            0
+├─────────────────────────────────────────────
+│ CHECK WATERTIGHTNESS...
+├────
+│             CheckWatertightness │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├─────────────────────────────────────────────
 │ CHECK JACOBIANS...
 ├────
 │              CheckElemJacobians │ True                            │ DEFAULT │
-│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (30004.72/s)
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├────
 │ Scaled Jacobians
 ├─────────────────
@@ -134,13 +152,11 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ OUTPUT MESH...
 ├────
-│   Planar-faced Hexahedra  :          512
+│         Curved Hexahedra  :          512
 ├────
 ├── Writing HDF5 mesh to "1-01-cartbox_mesh.h5"
-├────
-│ OUTPUT MESH DONE!
 ┢━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ PyHOPE completed in [0.18 sec]
+┃ PyHOPE completed in [0.25 sec]
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 

{pyhope-0.0.4 → pyhope-0.0.7}/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)
+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).
 
 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).
 
@@ -22,21 +22,17 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ┃ P y H O P E — Python High-Order Preprocessing Environment
 ┃ PyHOPE version x.x.x
 ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-├─────────────────────────────────────────────
 │ INIT PROGRAM...
-│                        nThreads │ 4                               │ DEFAULT │
-│ INIT PROGRAM DONE!
+│                        nThreads │ 10                              │ DEFAULT │
 ├─────────────────────────────────────────────
 │ INIT OUTPUT...
 │                     ProjectName │ 1-01-cartbox                    │ *CUSTOM │
 │                    OutputFormat │ 0 [HDF5]                        │ *CUSTOM │
 │                       DebugVisu │ F                               │ *CUSTOM │
-│ INIT OUTPUT DONE!
 ├─────────────────────────────────────────────
 │ INIT MESH...
-│                            Mode │ 1                               │ *CUSTOM │
-│                   BoundaryOrder │ 2                               │ DEFAULT │
-│ INIT MESH DONE!
+│                            Mode │ 1 [Internal]                    │ *CUSTOM │
+│                            NGeo │ 4                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ GENERATE MESH...
 ├────
@@ -44,6 +40,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├── Generating zone 1
 │                          Corner │ (/0.,0.,0. ,,1.,0.,0. ,,1.,1... │ *CUSTOM │
 │                          nElems │ (/8,8,8/)                       │ *CUSTOM │
+│                     StretchType │ (/0,0,0/)                       │ DEFAULT │
 │                         BCIndex │ (/1,2,3,4,5,6/)                 │ *CUSTOM │
 ├────
 ├── Setting boundary conditions
@@ -61,28 +58,51 @@ $ 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 │
+├────
+│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
+├────
 ├── Generated mesh with 512 cells
+├─────────────────────────────────────────────
+├── BUILD DATA STRUCTURE...
+├────
+├── Removing duplicate points
+├── Ensuring normals point outward
+├────
+│             CheckSurfaceNormals │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├────
-│ GENERATE MESH DONE!
+├── Generating sides
 ├─────────────────────────────────────────────
+│ SORT MESH...
+├────
 │                       doSortIJK │ False                           │ DEFAULT │
 ├────
 ├── Sorting elements along space-filling curve
 ├─────────────────────────────────────────────
 │ CONNECT MESH...
-├─────────────────────────────────────────────
 ├────
-│  Number of sides          :         3072
-│  Number of inner sides    :         2688
-│  Number of boundary sides :          384
-│  Number of periodic sides :            0
+│               doPeriodicCorrect │ True                            │ DEFAULT │
+│                       doMortars │ True                            │ DEFAULT │
 ├────
-│ CONNECT MESH DONE!
+│  Number of sides                :         3072
+│  Number of inner sides          :         2688
+│  Number of mortar sides (big)   :            0
+│  Number of mortar sides (small) :            0
+│  Number of boundary sides       :          384
+│  Number of periodic sides       :            0
+├─────────────────────────────────────────────
+│ CHECK WATERTIGHTNESS...
+├────
+│             CheckWatertightness │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├─────────────────────────────────────────────
 │ CHECK JACOBIANS...
 ├────
 │              CheckElemJacobians │ True                            │ DEFAULT │
-│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (30004.72/s)
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
 ├────
 │ Scaled Jacobians
 ├─────────────────
@@ -101,12 +121,10 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ OUTPUT MESH...
 ├────
-│   Planar-faced Hexahedra  :          512
+│         Curved Hexahedra  :          512
 ├────
 ├── Writing HDF5 mesh to "1-01-cartbox_mesh.h5"
-├────
-│ OUTPUT MESH DONE!
 ┢━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ PyHOPE completed in [0.18 sec]
+┃ PyHOPE completed in [0.25 sec]
 ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```

pyhope-0.0.7/pyhope/__main__.py

@@ -0,0 +1,43 @@
+#!/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
+# ----------------------------------------------------------------------------------------------------------------------------------
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Third-party libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Local imports
+# ----------------------------------------------------------------------------------------------------------------------------------
+from pyhope.script.pyhope_cli import main
+# ==================================================================================================================================
+
+
+if __name__ == '__main__':
+    """ Main routine of PyHOPE
+        > __main__ to execute as a module
+    """
+    main()

pyhope-0.0.4/pyhope/basis/basis_jacobian.py → pyhope-0.0.7/pyhope/basis/basis_basis.py

@@ -25,11 +25,6 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
-from multiprocessing import Pool, Queue
-import plotext as plt
-from alive_progress import alive_bar
-from typing import Tuple
-import threading
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -40,7 +35,7 @@ import numpy as np
 # ==================================================================================================================================
 
 
-def legendre_gauss_lobatto_nodes(order: int) -> Tuple[np.ndarray, np.ndarray]:
+def legendre_gauss_lobatto_nodes(order: int) -> tuple[np.ndarray, np.ndarray]:
     """ Return Legendre-Gauss-Lobatto nodes and weights for a given order in 1D
     """
     order -= 1
@@ -74,14 +69,14 @@ 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]:
+def legendre_gauss_nodes(order: int) -> tuple[np.ndarray, np.ndarray]:
     """ Return Legendre-Gauss nodes and weights for a given order in 1D
     """
     nodes, weights = np.polynomial.legendre.leggauss(order)
     return nodes, weights
 
 
-def barycentric_weights(order: int, xGP: np.ndarray) -> np.ndarray:
+def barycentric_weights(_: int, xGP: np.ndarray) -> np.ndarray:
     """ Compute the barycentric weights for a given node set
         > Algorithm 30, Kopriva
     """
@@ -121,20 +116,20 @@ def lagrange_interpolation_polys(x: float, order: int, xGP: np.ndarray, wBary: n
         > Algorithm 34, Kopriva
     """
     # Equal points need special treatment
-    L   = np.zeros(order)
+    lagrange = np.zeros(order)
     for iGP in range(order):
         if abs(x - xGP[iGP]) < 1.E-14:
-            L[iGP] = 1
-            return L
+            lagrange[iGP] = 1
+            return lagrange
 
     tmp = 0.
     for iGP in range(order):
-        L[iGP] = wBary[iGP] / (x-xGP[iGP])
-        tmp   += L[iGP]
+        lagrange[iGP] = wBary[iGP] / (x-xGP[iGP])
+        tmp   += lagrange[iGP]
 
     # Normalize
-    L = L/tmp
-    return L
+    lagrange = lagrange/tmp
+    return lagrange
 
 
 def calc_vandermonde(n_In: int, n_Out: int, wBary_In: np.ndarray, xi_In: np.ndarray, xi_Out: np.ndarray) -> np.ndarray:
@@ -164,23 +159,40 @@ 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, 1)  # Correct the shape to (dim1, n_Out, n_Out, n_Out)
+    x3D_Out  = np.moveaxis(x3D_Out , 0, 3)  # Correct the shape to (dim1, n_Out, n_Out, n_Out)
 
     return x3D_Out
 
 
+def change_basis_2D(Vdm: np.ndarray, x2D_In: np.ndarray) -> np.ndarray:
+    """ 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)
+        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 x2D_In)
+    x2D_Buf1 = np.tensordot(Vdm, x2D_In, axes=(1, 1))
+    x2D_Buf1 = np.moveaxis(x2D_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 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)
+
+    return x2D_Out
+
+
 def evaluate_jacobian(xGeo_In: np.ndarray, VdmGLtoAP: np.ndarray, D_EqToGL: np.ndarray) -> np.ndarray:
     # Perform tensor contraction for the first derivative (Xi direction)
     dXdXiGL   = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 1))
-    dXdXiGL   = np.moveaxis(dXdXiGL  , 0, -3)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+    dXdXiGL   = np.moveaxis(dXdXiGL  , 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
 
     # Perform tensor contraction for the second derivative (Eta direction)
     dXdEtaGL  = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 2))
-    dXdEtaGL  = np.moveaxis(dXdEtaGL , 0, -3)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+    dXdEtaGL  = np.moveaxis(dXdEtaGL , 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
 
     # Perform tensor contraction for the third derivative (Zeta direction)
     dXdZetaGL = np.tensordot(D_EqToGL, xGeo_In, axes=(1, 3))
-    dXdZetaGL = np.moveaxis(dXdZetaGL, 0, -3)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+    dXdZetaGL = np.moveaxis(dXdZetaGL, 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
 
     # Change basis for each direction
     dXdXiAP   = change_basis_3D(VdmGLtoAP, dXdXiGL  )
@@ -196,186 +208,34 @@ def evaluate_jacobian(xGeo_In: np.ndarray, VdmGLtoAP: np.ndarray, D_EqToGL: np.n
     return jacOut
 
 
-def plot_histogram(data: np.ndarray) -> None:
-    """ Plot a histogram of all Jacobians
-    """
-    # Local imports ----------------------------------------
-    import pyhope.output.output as hopout
-    from pyhope.output.output import STD_LENGTH
-    # ------------------------------------------------------
-
-    ticks = ['│<0.0      │',
-             '│ 0.0-0.1  │',
-             '│ 0.1-0.2  │',
-             '│ 0.2-0.3  │',
-             '│ 0.3-0.4  │',
-             '│ 0.4-0.5  │',
-             '│ 0.5-0.6  │',
-             '│ 0.6-0.7  │',
-             '│ 0.7-0.8  │',
-             '│ 0.8-0.9  │',
-             # '│ 0.9-0.99 │',
-             '│>0.9-1.0  │']
-
-    # Define the bins for categorizing jacobians
-    # bins     = [ -np.inf, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.99, np.inf]
-    bins     = [ -np.inf, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,       np.inf]
-
-    # Use np.histogram to count jacobians in the defined bins
-    count, _ = np.histogram(data, bins=bins)
-
-    # Setup plot
-    hopout.sep()
-    hopout.info('Scaled Jacobians')
-    hopout.separator(18)
-    plt.simple_bar(ticks, count, width=STD_LENGTH)
-    plt.show()
-    hopout.separator(18)
-
-
-def process_chunk(chunk):
-    """Process a chunk of elements by evaluating the Jacobian for each
-    """
-    chunk_results = []
-    for elem in chunk:
-        # nodeCoords, nGeoRef, VdmGLtoAP, D_EqToGL = elem
-        nodeCoords, _, VdmGLtoAP, D_EqToGL = elem
-        jac    = evaluate_jacobian(nodeCoords, VdmGLtoAP, D_EqToGL)
-        maxJac = np.max(np.abs(jac))
-        minJac = np.min(jac)
-        chunk_results.append(minJac / maxJac)
-    return chunk_results
-
-
-def distribute_work(elems, chunk_size):
-    """Distribute elements into chunks of a given size
-    """
-    return [elems[i:i + chunk_size] for i in range(0, len(elems), chunk_size)]
-
-
-def run_in_parallel(elems, chunk_size=10):
-    """Run the element processing in parallel using a specified number of processes
-    """
-    # Local imports ----------------------------------------
-    from pyhope.common.common_vars import np_mtp
-    # ------------------------------------------------------
-
-    chunks = distribute_work(elems, chunk_size)
-    total_elements = len(elems)
-    progress_queue = Queue()
-
-    # Use a separate thread for the progress bar
-    progress_thread = threading.Thread(target=update_progress, args=(progress_queue, total_elements))
-    progress_thread.start()
-
-    # Use multiprocessing Pool for parallel processing
-    with Pool(processes=np_mtp) as pool:
-        # Map work across processes in chunks
-        results = []
-        for chunk_result in pool.imap_unordered(process_chunk, chunks):
-            results.extend(chunk_result)
-            # Update progress for each processed element in the chunk
-            for _ in chunk_result:
-                progress_queue.put(1)
-
-    # Wait for the progress bar thread to finish
-    progress_thread.join()
-
-    return results
-
-
-def update_progress(progress_queue, total_elements):
-    """ Function to update the progress bar from the queue
-    """
-    with alive_bar(total_elements, title='│             Processing Elements', length=33) as bar:
-        for _ in range(total_elements):
-            # Block until we receive a progress update from the queue
-            progress_queue.get()
-            bar()
-
-
-def CheckJacobians() -> None:
-    # Local imports ----------------------------------------
-    from pyhope.common.common_vars import np_mtp
-    from pyhope.io.io import LINMAP
-    import pyhope.mesh.mesh_vars as mesh_vars
-    import pyhope.output.output as hopout
-    from pyhope.readintools.readintools import GetLogical
-    # ------------------------------------------------------
-
-    hopout.separator()
-    hopout.info('CHECK JACOBIANS...')
-    hopout.sep()
-
-    checkElemJacobians = GetLogical('CheckElemJacobians')
-    if not checkElemJacobians:
-        return None
-
-    nGeo = mesh_vars.nGeo + 1
-
-    # Compute the equidistant point set used by meshIO
-    xEq = np.zeros(nGeo)
-    for i in range(nGeo):
-        xEq[i] = 2.*float(i)/float(nGeo-1) - 1.
-    wBaryEq   = barycentric_weights(nGeo, xEq)
-
-    xGL, _    = legendre_gauss_lobatto_nodes(nGeo)
-    DGL       = polynomial_derivative_matrix(nGeo, xGL)
-    VdmEqToGL = calc_vandermonde(nGeo, nGeo, wBaryEq, xEq, xGL)
-    wbaryGL   = barycentric_weights(nGeo, xGL)
-
-    D_EqToGL  = np.matmul(DGL, VdmEqToGL)
-
-    # Interpolate derivatives on GL (N) to nGeoRef points
-    nGeoRef = 3*(nGeo-1)+1
-    xAP     = np.zeros(nGeoRef)
-    for i in range(nGeoRef):
-        xAP[i] = 2. * float(i)/float(nGeoRef-1) - 1.
-    VdmGLtoAP = calc_vandermonde(nGeo, nGeoRef, wbaryGL, xGL, xAP)
-
-    # Map all points to tensor product
-    elems = mesh_vars.elems
-    nodes = mesh_vars.mesh.points
-
-    # Prepare elements for parallel processing
-    jacobian_tasks = []
-
-    for iElem, elem in enumerate(elems):
-        # Only consider hexahedrons
-        if int(elem.type) % 100 != 8:
-            continue
-
-        # Get the mapping
-        linMap = LINMAP(elem.type, order=mesh_vars.nGeo)
-        mapLin = {k: v for v, k in enumerate(linMap)}
-
-        # Fill the NodeCoords
-        nodeCoords = np.zeros((nGeo ** 3, 3), dtype=np.float64)
-        for iNode, nodeID in enumerate(elem.nodes):
-            nodeCoords[mapLin[iNode], :] = nodes[nodeID]
-
-        xGeo = np.zeros((3, nGeo, nGeo, nGeo))
-        iNode = 0
-        for k in range(nGeo):
-            for j in range(nGeo):
-                for i in range(nGeo):
-                    xGeo[:, i, j, k] = nodeCoords[iNode, :]
-                    iNode += 1
-
-        if np_mtp > 0:
-            # Add tasks for parallel processing
-            jacobian_tasks.append((xGeo, nGeoRef, VdmGLtoAP, D_EqToGL))
-        else:
-            jac = evaluate_jacobian(xGeo, VdmGLtoAP, D_EqToGL)
-            maxJac =  np.max(np.abs(jac))
-            minJac =  np.min(       jac)
-            jacobian_tasks.append(minJac / maxJac)
-
-    if np_mtp > 0:
-        # Run in parallel with a chunk size
-        jacs = run_in_parallel(jacobian_tasks, chunk_size=10)
-    else:
-        jacs = np.array(jacobian_tasks)
-
-    # Plot the histogram of the Jacobians
-    plot_histogram(np.array(jacs))
+# INFO: ALTERNATIVE VERSION, CACHING VDM, D
+# class JacobianEvaluator:
+#     def __init__(self, VdmGLtoAP: np.ndarray, D_EqToGL: np.ndarray) -> None:
+#         self.VdmGLtoAP: Final[np.ndarray] = VdmGLtoAP
+#         self.D_EqToGL:  Final[np.ndarray] = D_EqToGL
+#
+#     def evaluate_jacobian(self, xGeo_In: np.ndarray) -> np.ndarray:
+#         # Perform tensor contraction for the first derivative (Xi direction)
+#         dXdXiGL   = np.tensordot(self.D_EqToGL, xGeo_In, axes=(1, 1))
+#         dXdXiGL   = np.moveaxis(dXdXiGL  , 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+#
+#         # Perform tensor contraction for the second derivative (Eta direction)
+#         dXdEtaGL  = np.tensordot(self.D_EqToGL, xGeo_In, axes=(1, 2))
+#         dXdEtaGL  = np.moveaxis(dXdEtaGL , 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+#
+#         # Perform tensor contraction for the third derivative (Zeta direction)
+#         dXdZetaGL = np.tensordot(self.D_EqToGL, xGeo_In, axes=(1, 3))
+#         dXdZetaGL = np.moveaxis(dXdZetaGL, 1, 0)  # Correct the shape to (3, nGeoRef, nGeoRef, nGeoRef)
+#
+#         # Change basis for each direction
+#         dXdXiAP   = change_basis_3D(self.VdmGLtoAP, dXdXiGL  )
+#         dXdEtaAP  = change_basis_3D(self.VdmGLtoAP, dXdEtaGL )
+#         dXdZetaAP = change_basis_3D(self.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)
+#
+#         # Fill output Jacobian array
+#         jacOut = np.einsum('ijkl,ijkl->jkl', dXdXiAP, cross_eta_zeta)
+#
+#         return jacOut