PyHOPE 0.0.9__tar.gz → 0.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PyHOPE
-Version: 0.0.9
+Version: 0.1.0
 Summary: Python High-Order Preprocessing Environment
 License: GPL-3.0-only
 Keywords: PyHOPE,mesh generator
@@ -81,7 +81,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ INIT MESH...
 │                            Mode │ 1 [Internal]                    │ *CUSTOM │
-│                            NGeo │ 4                               │ *CUSTOM │
+│                            NGeo │ 9                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ GENERATE MESH...
 ├────
@@ -89,6 +89,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 │
+│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
 │                     StretchType │ (/0,0,0/)                       │ DEFAULT │
 │                         BCIndex │ (/1,2,3,4,5,6/)                 │ *CUSTOM │
 ├────
@@ -111,8 +112,6 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │                              vv │ (/0., 1., 0./)                  │ *CUSTOM │
 │                              vv │ (/0., 0., 1./)                  │ *CUSTOM │
 ├────
-│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
-├────
 ├── Generated mesh with 512 cells
 ├─────────────────────────────────────────────
 ├── BUILD DATA STRUCTURE...
@@ -133,7 +132,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ CONNECT MESH...
 ├────
-│               doPeriodicCorrect │ True                            │ DEFAULT │
+│               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
 ├────
 │  Number of sides                :         3072
@@ -143,6 +142,11 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │  Number of boundary sides       :          384
 │  Number of periodic sides       :            0
 ├─────────────────────────────────────────────
+│ CHECK CONNECTIVITY...
+├────
+│               CheckConnectivity │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
+├─────────────────────────────────────────────
 │ CHECK WATERTIGHTNESS...
 ├────
 │             CheckWatertightness │ True                            │ DEFAULT │

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

@@ -49,7 +49,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ INIT MESH...
 │                            Mode │ 1 [Internal]                    │ *CUSTOM │
-│                            NGeo │ 4                               │ *CUSTOM │
+│                            NGeo │ 9                               │ *CUSTOM │
 ├─────────────────────────────────────────────
 │ GENERATE MESH...
 ├────
@@ -57,6 +57,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 │
+│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
 │                     StretchType │ (/0,0,0/)                       │ DEFAULT │
 │                         BCIndex │ (/1,2,3,4,5,6/)                 │ *CUSTOM │
 ├────
@@ -79,8 +80,6 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │                              vv │ (/0., 1., 0./)                  │ *CUSTOM │
 │                              vv │ (/0., 0., 1./)                  │ *CUSTOM │
 ├────
-│                        ElemType │ 108 [hexahedron]                │ *CUSTOM │
-├────
 ├── Generated mesh with 512 cells
 ├─────────────────────────────────────────────
 ├── BUILD DATA STRUCTURE...
@@ -101,7 +100,7 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 ├─────────────────────────────────────────────
 │ CONNECT MESH...
 ├────
-│               doPeriodicCorrect │ True                            │ DEFAULT │
+│               doPeriodicCorrect │ False                           │ DEFAULT │
 │                       doMortars │ True                            │ DEFAULT │
 ├────
 │  Number of sides                :         3072
@@ -111,6 +110,11 @@ $ pyhope tutorials/1-01-cartbox/parameter.ini
 │  Number of boundary sides       :          384
 │  Number of periodic sides       :            0
 ├─────────────────────────────────────────────
+│ CHECK CONNECTIVITY...
+├────
+│               CheckConnectivity │ True                            │ DEFAULT │
+│             Processing Elements |█████████████████████████████████| 512/512 [100%] in 0.0s (24000.00/s)
+├─────────────────────────────────────────────
 │ CHECK WATERTIGHTNESS...
 ├────
 │             CheckWatertightness │ True                            │ DEFAULT │

pyhope-0.1.0/pyhope/__init__.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+# This file is part of PyHOPE
+#
+# Copyright (c) 2024 Numerics Research Group, University of Stuttgart, Prof. Andrea Beck
+#
+# PyHOPE is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# PyHOPE is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# PyHOPE. If not, see <http://www.gnu.org/licenses/>.
+
+
+# ==================================================================================================================================
+# Mesh generation library
+# ==================================================================================================================================
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Standard libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+from collections import namedtuple
+from contextlib import contextmanager
+# ----------------------------------------------------------------------------------------------------------------------------------
+# 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
+# ==================================================================================================================================
+
+
+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)
+
+
+# Define a named tuple to hold the mesh data
+MeshContainer = namedtuple('Mesh',
+                          ['mesh',   # The generated mesh object
+                           'nGeo',   # Polynomial order
+                           'bcs',    # Boundary conditions
+                           'elems',  # Elements
+                           'sides'   # Sides
+                          ])
+
+
+@contextmanager
+def Mesh(*args, stdout=False, stderr=True):
+    """ Mesh context manager to generate a mesh from a given file
+
+        Args:
+            *args: The mesh file path(s) to be processed
+            stdout (bool): If False, standard output is suppressed
+            stderr (bool): If False, standard error  is suppressed
+
+        Yields:
+            Mesh: An object containing the generated mesh and its properties
+    """
+    # Standard libraries -----------------------------------
+    import os
+    # Third-party libraries --------------------------------
+    import h5py
+    from contextlib import redirect_stdout, redirect_stderr, ExitStack
+    # Local imports ----------------------------------------
+    import pyhope.config.config as config
+    import pyhope.mesh.mesh_vars as mesh_vars
+    from pyhope.common.common import DefineCommon, InitCommon
+    from pyhope.io.io import DefineIO, InitIO
+    from pyhope.mesh.connect.connect import ConnectMesh
+    from pyhope.mesh.mesh import DefineMesh, InitMesh, GenerateMesh
+    from pyhope.mesh.mesh_sides import GenerateSides
+    from pyhope.readintools.readintools import DefineConfig, ReadConfig
+    # ------------------------------------------------------
+
+    try:
+        # Check if the arguments provided are valid mesh files
+        if not args:
+            raise ValueError('No mesh file provided.')
+
+        for arg in args:
+            # Check if the argument is a valid file path
+            if not os.path.isfile(arg):
+                raise FileNotFoundError(f'Mesh file not found: {arg}')
+
+            # Check if the argument is a valid HDF5 file
+            if not h5py.is_hdf5(arg):
+                raise ValueError(f'Mesh file not a valid HDF5 file: {arg}')
+
+        # Suppress output to standard output
+        with ExitStack() as stack:
+            with open(os.devnull, 'w') as null:
+                if not stdout:
+                    stack.enter_context(redirect_stdout(null))
+                if not stderr:
+                    stack.enter_context(redirect_stderr(null))
+
+                # Perform the reduced PyHOPE initialization
+                with DefineConfig() as dc:
+                    config.prms = dc
+                    DefineCommon()
+                    DefineIO()
+                    DefineMesh()
+
+                with ReadConfig(args[0]) as rc:
+                    config.params = rc
+
+                # Read-in required parameters
+                InitCommon()
+                InitIO()
+                InitMesh()
+
+                # Generate the actual mesh
+                GenerateMesh()
+
+                # Build our data structures
+                GenerateSides()
+                ConnectMesh()
+
+        # Export mesh variables
+        mesh = mesh_vars.mesh
+
+        nGeo  = mesh_vars.nGeo
+        bcs   = mesh_vars.bcs
+
+        elems = mesh_vars.elems
+        sides = mesh_vars.sides
+
+        yield MeshContainer(mesh  = mesh,   # noqa: E251
+                            nGeo  = nGeo,   # noqa: E251
+                            bcs   = bcs,    # noqa: E251
+                            elems = elems,  # noqa: E251
+                            sides = sides   # noqa: E251
+                           )
+
+    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

pyhope-0.1.0/pyhope/basis/basis_connect.py

@@ -0,0 +1,190 @@
+#!/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
+# ----------------------------------------------------------------------------------------------------------------------------------
+import re
+import sys
+from typing import Final
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Third-party libraries
+# ----------------------------------------------------------------------------------------------------------------------------------
+import numpy as np
+import numpy.typing as npt
+# ----------------------------------------------------------------------------------------------------------------------------------
+# Local imports
+# ----------------------------------------------------------------------------------------------------------------------------------
+import pyhope.mesh.mesh_vars as mesh_vars
+from pyhope.mesh.mesh_common import sidetovol2
+from pyhope.mesh.mesh_common import face_to_nodes
+# ==================================================================================================================================
+
+
+def check_sides(elem,
+                ) -> list[bool | int | np.ndarray]:
+    results = []
+    elems:  Final[list]  = mesh_vars.elems
+    sides:  Final[list]  = mesh_vars.sides
+    nGeo:   Final[int]   = mesh_vars.nGeo
+    bcs:    Final[list]  = mesh_vars.bcs
+    # Tolerance for physical comparison
+    tol:    Final[float] = mesh_vars.tolPeriodic
+    vvs:    Final[list]  = mesh_vars.vvs
+    points: Final[npt.NDArray] = mesh_vars.mesh.points
+
+    for SideID in elem.sides:
+        master = sides[SideID]
+        # Only connected sides that are master sides and not small mortar sides
+        if master.connection is None \
+        or master.connection < 0     \
+        or master.MS != 1            \
+        or master.sideType < 0:  # noqa: E271
+            continue
+
+        side   = (master, sides[master.connection])
+
+        # Only actual element sides
+        if side[0].face is None      \
+        or side[1].face is None:  # noqa: E271
+            continue
+
+        # Sanity check the flip with the other nodes
+        elem0  = elems[side[0].elemID]
+        elem1  = elems[side[1].elemID]
+        if elem1.type % 100 != 8:
+            continue
+
+        # Map the meshio nodes to the tensor-product nodes
+        elemType = elem0.type
+        nodes    = elem0.nodes[sidetovol2(nGeo, 0           , side[0].face, elemType)]
+        nbNodes  = elem1.nodes[sidetovol2(nGeo, side[1].flip, side[1].face, elemType)]
+
+        # INFO: THIS CURRENTLY MIGHT NOT WORK SINCE WE POTENTIALLY ONLY HAVE THE CORNER NODES AVAILABLE
+        try:
+            # Translate to periodic nodes if required
+            if side[0].bcid is not None and side[1].bcid is not None and bcs[side[1].bcid].type[0] == 1:
+                nbNodes = np.vectorize(lambda s: mesh_vars.periNodes[(s, bcs[side[1].bcid].name)], otypes=[int])(nbNodes)
+            # Check if the node IDs match
+            success = np.array_equal(nodes, nbNodes)
+        # Fallback to comparison of physical coordinates
+        except KeyError:
+            # Check if periodic vector matches using vectorized np.allclose
+            iVV = bcs[side[0].bcid].type[3]
+            vv  = vvs[np.abs(iVV) - 1]['Dir'] * np.sign(iVV)
+            success = np.allclose(points[nodes] + vv, points[nbNodes], rtol=tol, atol=tol)
+
+        results.append((success, SideID))
+    return results
+
+
+def process_chunk(chunk) -> np.ndarray:
+    """Process a chunk of elements by checking surface normal orientation
+    """
+    chunk_results    = np.empty(len(chunk), dtype=object)
+    chunk_results[:] = [check_sides(elem_data) for elem_data in chunk]
+    return chunk_results
+
+
+def CheckConnect() -> None:
+    """ Check if the mesh is correctly connected
+    """
+    # Local imports ----------------------------------------
+    import pyhope.output.output as hopout
+    import pyhope.mesh.mesh_vars as mesh_vars
+    from pyhope.common.common_parallel import run_in_parallel
+    from pyhope.common.common_vars import np_mtp
+    from pyhope.readintools.readintools import GetLogical
+    # ------------------------------------------------------
+
+    hopout.separator()
+    hopout.info('CHECK CONNECTIVITY...')
+    hopout.sep()
+
+    checkConnectivity  = GetLogical('CheckConnectivity')
+    if not checkConnectivity:
+        return None
+
+    # Check all sides
+    elems:     Final[list] = mesh_vars.elems
+
+    # Only consider hexahedrons
+    if any(e.type % 100 != 8 for e in elems):
+        elemTypes = list(set([e.type for e in elems if e.type % 100 != 8]))
+        print(hopout.warn('Ignored element type: {}'.format(
+            [re.sub(r"\d+$", "", mesh_vars.ELEMTYPE.inam[e][0]) for e in elemTypes]
+        )))
+        return
+
+    # Prepare elements for parallel processing
+    if np_mtp > 0:
+        tasks  = tuple((elem)
+                        for elem in elems)
+        # 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, tasks, chunk_size=max(1, min(1000, max(10, int(len(tasks)/(40.*np_mtp))))))
+    else:
+        res    = np.empty(len(elems), dtype=object)
+        res[:] = [check_sides(elem) for elem in elems]
+
+    results = tuple(tuple(result for r in res for result in r if not bool(result[0]))
+)
+    if len(results) > 0:
+        nGeo:      Final[int]        = mesh_vars.nGeo
+        sides:     Final[list]       = mesh_vars.sides
+        points:    Final[np.ndarray] = mesh_vars.mesh.points
+
+        nconn = len(tuple(tuple(result for r in res for result in r)))
+
+        for result in results:
+            # Unpack the results
+            side    = sides[result[1]]
+            elem    = elems[side.elemID]
+            nbside  = sides[side.connection]
+            nbelem  = elems[nbside.elemID]
+
+            nodes   =   elem.nodes[face_to_nodes(  side.face,   elem.type, nGeo)]
+            nbnodes = nbelem.nodes[face_to_nodes(nbside.face, nbelem.type, nGeo)]
+
+            print()
+            # Check if side is oriented inwards
+            errStr = 'Side connectivity does not match the calculated neighbour side'
+            print(hopout.warn(errStr, length=len(errStr)+16))
+
+            # Print the information
+            strLen  = max(len(str(side.sideID+1)), len(str(nbside.sideID+1)))
+            print(hopout.warn(f'> Element {  elem.elemID+1:>{strLen}}, Side {  side.face}, Side {  side.sideID+1:>{strLen}}'))  # noqa: E501
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1, -1]]) + ']'))    # noqa: E271
+            # print()
+            print(hopout.warn(f'> Element {nbelem.elemID+1:>{strLen}}, Side {nbside.face}, Side {nbside.sideID+1:>{strLen}}'))  # noqa: E501
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
+
+        hopout.warning(f'Connectivity check failed for {len(results)} / {nconn} connections!')
+        sys.exit(1)

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

@@ -26,7 +26,6 @@
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
 import re
-import sys
 from typing import Final
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
@@ -76,8 +75,6 @@ def check_sides(elem,
                 weights  : np.ndarray,
                 # sides    : list
                 ) -> list[bool | int | np.ndarray]:
-    # Local imports ----------------------------------------
-    # ------------------------------------------------------
     results = []
     points  = mesh_vars.mesh.points
     elems   = mesh_vars.elems
@@ -276,5 +273,4 @@ def CheckWatertight() -> None:
             print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
             print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
 
-        hopout.warning(f'Watertightness check failed for {len(results)} / {nconn} connections!')
-        sys.exit(1)
+        hopout.error(f'Watertightness check failed for {len(results)} / {nconn} connections!')

{pyhope-0.0.9 → pyhope-0.1.0}/pyhope/common/common.py

@@ -26,7 +26,6 @@
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
 import os
-import sys
 from io import TextIOWrapper
 from typing import cast
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -104,6 +103,9 @@ def DebugEnabled() -> bool:
     """ Check if program runs with debugger attached
         > https://stackoverflow.com/a/77627075/23851165
     """
+    # Standard libraries -----------------------------------
+    import sys
+    # ------------------------------------------------------
     try:
         if sys.gettrace() is not None:
             return True
@@ -120,12 +122,20 @@ def DebugEnabled() -> bool:
 
 
 def IsInteractive() -> bool:
-    return cast(TextIOWrapper, sys.__stdin__).isatty()
+    """ Check if the program is running in an interactive terminal
+    """
+    # Standard libraries -----------------------------------
+    import sys
+    # ------------------------------------------------------
+    return cast(TextIOWrapper, sys.__stdin__).isatty() and cast(TextIOWrapper, sys.__stdout__).isatty()
 
 
 def IsDisplay() -> bool:
     """ Check if the program is running in a display environment
     """
+    # Standard libraries -----------------------------------
+    import sys
+    # ------------------------------------------------------
     # Check if running on Linux, otherwise assume a display
     if not sys.platform.startswith('linux'):
         return True

{pyhope-0.0.9 → pyhope-0.1.0}/pyhope/common/common_parallel.py

@@ -58,6 +58,7 @@ def run_in_parallel(process_chunk: Callable, elems: tuple, chunk_size: int = 10)
     """Run the element processing in parallel using a specified number of processes
     """
     # Local imports ----------------------------------------
+    from pyhope.common.common import IsInteractive
     from pyhope.common.common_vars import np_mtp
     # ------------------------------------------------------
 
@@ -65,8 +66,11 @@ def run_in_parallel(process_chunk: Callable, elems: tuple, chunk_size: int = 10)
     total_elements = len(elems)
     progress_queue = Queue()
 
+    # Create a progress bar target
+    target = update_progress if IsInteractive() else None
+
     # Use a separate thread for the progress bar
-    progress_thread = threading.Thread(target=update_progress, args=(progress_queue, total_elements))
+    progress_thread = threading.Thread(target=target, args=(progress_queue, total_elements))
     progress_thread.start()
 
     # Use multiprocessing Pool for parallel processing

{pyhope-0.0.9 → pyhope-0.1.0}/pyhope/common/common_progress.py

@@ -45,14 +45,19 @@ class ProgressBar:
     """ Provide a progress bar outside of the context manager
     """
     def __init__(self, title: Optional[str], value: int, length: int = 33, threshold: int = barElems) -> None:
+        # Local imports ----------------------------------------
+        from pyhope.common.common import IsInteractive
+        # ------------------------------------------------------
+        if value <= threshold or not IsInteractive():
+            self.bar = None
+            return None
+
         self._cm   : Final         = alive_bar(title=title, total=value, length=length)
         self._title: Optional[str] = title
         self._len  : int           = length
 
-        if value > threshold:
-            self.bar = self._cm.__enter__()
-        else:
-            self.bar = None
+        # Initialize the progress bar
+        self.bar = self._cm.__enter__()
 
     def step(self, steps: int = 1) -> None:
         if self.bar is not None:

{pyhope-0.0.9 → pyhope-0.1.0}/pyhope/gmsh/gmsh_install.py

@@ -29,7 +29,6 @@ import os
 import shutil
 import platform
 import subprocess
-import sys
 from importlib import metadata
 from packaging.version import Version
 from typing import Optional, cast
@@ -97,8 +96,7 @@ def PkgsCheckGmsh() -> None:
                     PkgsInstallGmsh(system, arch, version='pypi')
                     return None
         else:
-            hopout.warning('Gmsh is not installed, exiting...')
-            sys.exit(1)
+            hopout.error('Gmsh is not installed, exiting...')
 
     gmsh_version = cast(str, gmsh_version)
     # Assume that newer versions have updated CGNS
@@ -132,9 +130,11 @@ def PkgsCheckGmsh() -> None:
 
 
 def PkgsInstallGmsh(system: str, arch: str, version: str) -> None:
-    # Local imports ----------------------------------------
+    # Standard libraries -----------------------------------
+    import sys
     import hashlib
     import tempfile
+    # Local imports ----------------------------------------
     import pyhope.output.output as hopout
     from pyhope.common.common_vars import Gitlab
     # ------------------------------------------------------
@@ -185,8 +185,7 @@ def PkgsInstallGmsh(system: str, arch: str, version: str) -> None:
             if sha256.hexdigest() == Gitlab.LIB_SUPPORT[system][arch]:
                 hopout.info('Hash matches, installing Gmsh wheel...')
             else:
-                hopout.warning('Hash mismatch, exiting...')
-                sys.exit(1)
+                hopout.error('Hash mismatch, exiting...')
 
             # Remove the old version
             try:

{pyhope-0.0.9 → pyhope-0.1.0}/pyhope/io/formats/meshio.py

@@ -27,7 +27,6 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 from functools import cache
 from typing import Tuple
-import sys
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 import numpy as np
@@ -144,7 +143,7 @@ def edgePointMESHIO(start: int, end: int, edge: int, node: int) -> np.ndarray:
         case 11:
             return np.array((start         , end   , node   ), dtype=int)
         case _:
-            sys.exit(1)
+            raise ValueError(f'Invalid edge index: {edge}.')
 
 
 @cache
@@ -171,7 +170,7 @@ def facePointMESHIO(start: int, end: int, face: int, pos: int) -> np.ndarray:
             index = facePointMatrix(end-start-1, pos, orient=False)
             return np.array((start+index[0]+1 , start+index[1]+1 , end             ), dtype=int)
         case _:
-            sys.exit(1)
+            raise ValueError(f'Invalid face index: {face}.')
 
 
 @cache

{pyhope-0.0.9 → pyhope-0.1.0}/pyhope/io/io.py

@@ -25,13 +25,11 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
-import sys
 from collections import OrderedDict
 from typing import Final
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 import h5py
-import heapq
 import numpy as np
 # ----------------------------------------------------------------------------------------------------------------------------------
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -197,8 +195,7 @@ def IO() -> None:
             mesh.write(fname, file_format='gmsh')
 
         case _:  # Default
-            hopout.warning('Unknown output format {}, exiting...'.format(io_vars.outputformat))
-            sys.exit(1)
+            hopout.error('Unknown output format {}, exiting...'.format(io_vars.outputformat))
 
     # hopout.sep()
     # hopout.info('OUTPUT MESH DONE!')
@@ -215,6 +212,8 @@ def getMeshInfo() -> tuple[np.ndarray,         # ElemInfo
                            np.ndarray | None,  # Optional[EdgeConnectInfo]
                            dict[int, int]
                           ]:
+    # Standard libraries -----------------------------------
+    import heapq
     # Local imports ----------------------------------------
     import pyhope.mesh.mesh_vars as mesh_vars
     from pyhope.mesh.fem.fem import getFEMInfo