emerge 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

emerge/_emerge/selection.py

@@ -16,13 +16,13 @@
 # <https://www.gnu.org/licenses/>.
 
 from __future__ import annotations
-import gmsh
+import gmsh # type: ignore
 import numpy as np
-from scipy.spatial import ConvexHull
+from scipy.spatial import ConvexHull # type: ignore
 from .cs import Axis, CoordinateSystem, _parse_vector, Plane
-from typing import Callable, TypeVar
+from typing import Callable, TypeVar, Iterable, Any
 
-def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, np.ndarray]:
+def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, Any]:
     """Tries to find a rectangle as convex-hull of a set of points with a given normal vector.
 
     Args:
@@ -66,9 +66,9 @@ def align_rectangle_frame(pts3d: np.ndarray, normal: np.ndarray) -> dict[str, np
         xmax, ymax = rot.max(axis=0)
         area = (xmax-xmin)*(ymax-ymin)
         if area < best[1]:
-            best = (theta, area, (xmin,xmax,ymin,ymax), R)
+            best = (theta, area, (xmin,xmax,ymin,ymax), R) # type: ignore
 
-    theta, _, (xmin,xmax,ymin,ymax), R = best
+    theta, _, (xmin,xmax,ymin,ymax), R = best # type: ignore
 
     # 6. rectangle axes in 3D
     u =  np.cos(-theta)*e_x + np.sin(-theta)*e_y
@@ -172,9 +172,9 @@ class Selection:
 
     """
     dim: int = -1
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set[int] | tuple[int] | None = None):
 
-        self._tags: set[int] = {}
+        self._tags: set[int] = set()
 
         if tags is not None:
             if not isinstance(tags, (list,set,tuple)):
@@ -182,7 +182,7 @@ class Selection:
             self._tags = set(tags)
     
     @staticmethod
-    def from_dim_tags(dim: int, tags: list[int]) -> DomainSelection | PointSelection | FaceSelection | EdgeSelection:
+    def from_dim_tags(dim: int, tags: list[int] | set[int]) -> Selection:
         if dim==0:
             return PointSelection(tags)
         elif dim==1:
@@ -198,7 +198,7 @@ class Selection:
         return list(self._tags)
     
     @property
-    def color_rgb(self) -> tuple[int,int,int]:
+    def color_rgb(self) -> tuple[float, float, float]:
         return (0.5,0.5,1.0)
     
     @property
@@ -225,14 +225,14 @@ class Selection:
             return [gmsh.model.occ.getCenterOfMass(self.dim, tag) for tag in self.tags]
     
     @property
-    def points(self) -> np.ndarray | list[np.ndarray]:
+    def points(self) -> list[np.ndarray]:
         '''A list of 3D coordinates of all nodes comprising the selection.'''
         points = gmsh.model.get_boundary(self.dimtags, recursive=True)
         coordinates = [gmsh.model.getValue(*p, []) for p in points]
         return coordinates
     
     @property
-    def bounding_box(self) -> tuple[np.ndarray, np.ndarray]:
+    def bounding_box(self) -> tuple[Iterable, Iterable]:
         if len(self.tags)==1:
             return gmsh.model.occ.getBoundingBox(self.dim, self.tags[0])
         else:
@@ -248,7 +248,7 @@ class Selection:
                 maxz = max(maxz, z1)
             return (minx, miny, minz), (maxx, maxy, maxz)
         
-    def exclude(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane = None, axis: Axis = None) -> Selection:
+    def exclude(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane | None = None, axis: Axis | None = None) -> Selection:
         """Exclude points by evaluating a function(x,y,z)-> bool
 
         This modifies the selection such that the selection does not contain elements
@@ -266,10 +266,10 @@ class Selection:
             norm = axis.np
             include2 = [abs(gmsh.model.getNormal(tag, np.array([0,0]))@norm)<0.9 for tag in self.tags]
             include = [i1 for i1, i2 in zip(include, include2) if i1 and i2]
-        self._tags = [t for incl, t in zip(include, self._tags) if incl]
+        self._tags = set([t for incl, t in zip(include, self._tags) if incl])
         return self
     
-    def isolate(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane = None, axis: Axis = None) -> Selection:
+    def isolate(self, xyz_excl_function: Callable = lambda x,y,z: True, plane: Plane | None = None, axis: Axis | None = None) -> Selection:
         """Include points by evaluating a function(x,y,z)-> bool
 
         This modifies the selection such that the selection does not contain elements
@@ -287,7 +287,7 @@ class Selection:
             norm = axis.np
             include2 = [(gmsh.model.getNormal(tag, np.array([0,0]))@norm)>0.99 for tag in self.tags]
             include1 = [i1 for i1, i2 in zip(include1, include2) if i1 and i2]
-        self._tags = [t for incl, t in zip(include1, self._tags) if incl]
+        self._tags = set([t for incl, t in zip(include1, self._tags) if incl])
         return self
 
     def __operable__(self, other: Selection) -> None:
@@ -295,30 +295,28 @@ class Selection:
             raise ValueError(f'Selection dimensions must be equal. Trying to operate on dim {self.dim} and {other.dim}')
         pass
 
-    def __add__(self, other: TSelection) -> TSelection:
+    def __add__(self, other: Selection) -> Selection:
         self.__operable__(other)
-        return Selection.from_dim_tags(self.dim, self._tags + other._tags)
+        return Selection.from_dim_tags(self.dim, self._tags.union(other._tags))
     
-    def __and__(self, other: TSelection) -> TSelection:
+    def __and__(self, other: Selection) -> Selection:
         self.__operable__(other)
         return Selection.from_dim_tags(self.dim, self._tags.intersection(other._tags))
     
-    def __or__(self, other: TSelection) -> TSelection:
+    def __or__(self, other: Selection) -> Selection:
         self.__operable__(other)
         return Selection.from_dim_tags(self.dim, self._tags.union(other._tags))
     
-    def __sub__(self, other: TSelection) -> TSelection:
+    def __sub__(self, other: Selection) -> Selection:
         self.__operable__(other)
         return Selection.from_dim_tags(self.dim, self._tags.difference(other.tags))
-    
-
 
 class PointSelection(Selection):
     """A Class representing a selection of points.
 
     """
     dim: int = 0
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set [int] | None = None):
         super().__init__(tags)
 
 class EdgeSelection(Selection):
@@ -326,7 +324,7 @@ class EdgeSelection(Selection):
 
     """
     dim: int = 1
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set [int] | None = None):
         super().__init__(tags)
 
 class FaceSelection(Selection):
@@ -334,7 +332,7 @@ class FaceSelection(Selection):
 
     """
     dim: int = 2
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set [int] | None = None):
         super().__init__(tags)
 
     @property
@@ -355,14 +353,14 @@ class FaceSelection(Selection):
         
         pts3d = self.points
         normal = self.normal
-        data = align_rectangle_frame(pts3d, normal)
+        data = align_rectangle_frame(np.array(pts3d), normal)
         plane = data['axes'][:2]
         origin = data['origin']
 
         cs = CoordinateSystem(Axis(plane[0]), Axis(plane[1]), Axis(data['axes'][2]), origin)
 
-        size1 = np.linalg.norm(data['corners'][1] - data['corners'][0])
-        size2 = np.linalg.norm(data['corners'][2] - data['corners'][0])
+        size1 = float(np.linalg.norm(data['corners'][1] - data['corners'][0]))
+        size2 = float(np.linalg.norm(data['corners'][2] - data['corners'][0]))
 
         if size1>size2:
             cs.swapxy()
@@ -382,7 +380,7 @@ class FaceSelection(Selection):
                 a NxN numpy array of Y coordinates.
             Z: np.ndarray
                 a NxN numpy array of Z coordinates'''
-        coordset = []
+        coordset: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []
         for tag in self.tags:
             tags, coord, param = gmsh.model.mesh.getNodes(2, tag, includeBoundary=True)
             
@@ -419,17 +417,15 @@ class FaceSelection(Selection):
         Y = [c[1] for c in coordset]
         Z = [c[2] for c in coordset]
         if len(X) == 1:
-            X = X[0]
-            Y = Y[0]
-            Z = Z[0]
-        return X, Y, Z
+            return X[0], Y[0], Z[0]
+        return np.array(X), np.array(Y), np.array(Z)
     
 class DomainSelection(Selection):
     """A Class representing a selection of domains.
 
     """
     dim: int = 3
-    def __init__(self, tags: list[int] = None):
+    def __init__(self, tags: list[int] | set[int] | None = None):
         super().__init__(tags)
 
 SELECT_CLASS: dict[int, type[Selection]] = {
@@ -501,7 +497,7 @@ class Selector:
                 x: float,
                 y: float,
                 z: float,
-                vector: tuple[float, float, float] | np.ndarray | Axis) -> FaceSelection | EdgeSelection | DomainSelection:
+                vector: tuple[float, float, float] | np.ndarray | Axis) -> Selection:
         '''Returns a list of selections that are in the layer defined by the plane normal vector and the point (x,y,z)
         
         The layer is specified by two infinite planes normal to the provided vector. The first plane is originated
@@ -529,7 +525,7 @@ class Selector:
         output = []
         for i, c in enumerate(coords):
             c_local = c - np.array([x,y,z])
-            if 0 < np.dot(vector, c_local) < L:
+            if 0 < np.dot(vector, c_local) < L: # type: ignore
                 output.append(dimtags[i][1])
         return SELECT_CLASS[self._current_dim](output)
     
@@ -565,8 +561,8 @@ class Selector:
         normals = [gmsh.model.get_normal(t, (0,0)) for d,t, in dimtags]
         tags = []
         for (d,t), o, n in zip(dimtags, coords, normals):
-            normdist = np.abs((o-orig)@norm)
-            dotnorm = np.abs(n@norm)
+            normdist = np.abs((o-orig) @ norm)
+            dotnorm = np.abs(n @ norm)
             if normdist < tolerance and dotnorm > 1-tolerance:
                 tags.append(t)
         return FaceSelection(tags)

emerge/_emerge/simmodel.py

@@ -27,12 +27,11 @@ from .plot.pyvista import PVDisplay
 from .dataset import SimulationDataset
 from .periodic import PeriodicCell
 from .bc import BoundaryCondition
-from typing import Literal, Type, Generator, Any
+from typing import Literal, Generator, Any
 from loguru import logger
 import numpy as np
-import sys
-import gmsh
-import joblib
+import gmsh # type: ignore
+import joblib # type: ignore
 import os
 import inspect
 from pathlib import Path
@@ -94,15 +93,14 @@ class Simulation3D:
         
         self.mesh: Mesh3D = Mesh3D(self.mesher)
         self.select: Selector = Selector()
-        self.display: PVDisplay = None
         self.set_loglevel(loglevel)
 
         ## STATES
         self.__active: bool = False
         self._defined_geometries: bool = False
-        self._cell: PeriodicCell = None
+        self._cell: PeriodicCell | None = None
 
-        self.display = PVDisplay(self.mesh)
+        self.display: PVDisplay = PVDisplay(self.mesh)
 
         if logfile:
             self.set_logfile()
@@ -203,7 +201,9 @@ class Simulation3D:
         if self.save_file:
             self.save()
         # Finalize GMSH
-        gmsh.finalize()
+        if gmsh.isInitialized():
+            gmsh.finalize()
+
         logger.debug('GMSH Shut down successful')
         # set the state to active
         self.__active = False
@@ -214,28 +214,22 @@ class Simulation3D:
 
     def all_geometries(self) -> list[GeoObject]:
         """Returns all geometries stored in the simulation file."""
-        return [obj for obj in self.sim.default.values() if isinstance(obj, GeoObject)]
+        return [obj for obj in self.data.sim.default.values() if isinstance(obj, GeoObject)]
     
     def all_bcs(self) -> list[BoundaryCondition]:
         """Returns all boundary condition objects stored in the simulation file"""
-        return [obj for obj in self.sim.default.values() if isinstance(obj, BoundaryCondition)]
+        return [obj for obj in self.data.sim.default.values() if isinstance(obj, BoundaryCondition)]
     
     def _set_mesh(self, mesh: Mesh3D) -> None:
         """Set the current model mesh to a given mesh."""
         self.mesh = mesh
         self.mw.mesh = mesh
-        self.mesher.mesh = mesh
         self.display._mesh = mesh
     
     ############################################################
     #                       PUBLIC FUNCTIONS                  #
     ############################################################
 
-    @property
-    def passed_geometries(self) -> list[GeoObject]:
-        """"""
-        return self.data.sim['geometries']
-    
     def save(self) -> None:
         """Saves the current model in the provided project directory."""
         # Ensure directory exists
@@ -298,7 +292,7 @@ class Simulation3D:
         LOG_CONTROLLER.set_write_file(self.modelpath)
         
     def view(self, 
-             selections: list[Selection] = None, 
+             selections: list[Selection] | None = None, 
              use_gmsh: bool = False,
              volume_opacity: float = 0.1,
              surface_opacity: float = 1,
@@ -316,22 +310,16 @@ class Simulation3D:
             gmsh.model.occ.synchronize()
             gmsh.fltk.run()
             return
-        try:
-            for obj in self.data.sim['geometries']:
-                if obj.dim==2:
-                    opacity=surface_opacity
-                elif obj.dim==3:
-                    opacity=volume_opacity
-                self.display.add_object(obj, show_edges=show_edges, opacity=opacity)
-            if selections:
-                [self.display.add_object(sel, color='red', opacity=0.7) for sel in selections]
-            self.display.show()
-            return
-        except NotImplementedError as e:
-            logger.warning('The provided BaseDisplay class does not support object display. Please make' \
-            'sure that this method is properly implemented.')
+        for geo in _GEOMANAGER.all_geometries():
+            self.display.add_object(geo)
+        if selections:
+            [self.display.add_object(sel, color='red', opacity=0.7) for sel in selections]
+        self.display.show()
+
+        return None
+        
     
-    def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: list[FaceSelection] = None):
+    def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: list[FaceSelection] | None = None):
         """Set the given periodic cell object as the simulations peridicity.
 
         Args:
@@ -341,18 +329,20 @@ class Simulation3D:
         self.mw.bc._cell = cell
         self._cell = cell
 
-    def commit_geometry(self, *geometries: list[GeoObject]) -> None:
+    def commit_geometry(self, *geometries: GeoObject | list[GeoObject]) -> None:
         """Finalizes and locks the current geometry state of the simulation.
 
         The geometries may be provided (legacy behavior) but are automatically managed underwater.
         
         """
+        geometries_parsed: Any = None
         if not geometries:
-            geometries = _GEOMANAGER.all_geometries()
+            geometries_parsed = _GEOMANAGER.all_geometries()
         else:
-            geometries = unpack_lists(geometries + tuple([item for item in self.data.sim.default.values() if isinstance(item, GeoObject)]))
-        self.data.sim['geometries'] = geometries
-        self.mesher.submit_objects(geometries)
+            geometries_parsed = unpack_lists(geometries + tuple([item for item in self.data.sim.default.values() if isinstance(item, GeoObject)]))
+        
+        self.data.sim['geometries'] = geometries_parsed
+        self.mesher.submit_objects(geometries_parsed)
         self._defined_geometries = True
         self.display._facetags = [dt[1] for dt in gmsh.model.get_entities(2)]
           
@@ -438,9 +428,9 @@ class Simulation3D:
 
             logger.info(f'Iterating: {params}')
             if len(dims_flat)==1:
-                yield dims_flat[0][i_iter]
+                yield (dims_flat[0][i_iter],)
             else:
-                yield (dim[i_iter] for dim in dims_flat)
+                yield (dim[i_iter] for dim in dims_flat) # type: ignore
         self.mw.cache_matrices = True
 
     ############################################################

emerge/_emerge/simulation_data.py

@@ -84,7 +84,7 @@ def generate_ndim(
     outer_data: dict[str, list[float]],
     inner_data: list[float],
     outer_labels: tuple[str, ...]
-) -> np.ndarray:
+) -> tuple[np.ndarray,...]:
     """
     Generates an N-dimensional grid of values from flattened data, and returns each axis array plus the grid.
 
@@ -126,7 +126,7 @@ def generate_ndim(
     grid[tuple(idxs)] = values
 
     # Return each axis array followed by the grid
-    return (*axes, grid)
+    return tuple(axes) + (grid,)
 
 
 class DataEntry:
@@ -142,7 +142,7 @@ class DataEntry:
 
     def values(self) -> list[Any]:
         """ Return all values stored in the DataEntry"""
-        return self.data.values()
+        return list(self.data.values())
     
     def keys(self) -> list[str]:
         """ Return all names of data stored in the DataEntry"""
@@ -150,12 +150,15 @@ class DataEntry:
     
     def items(self) -> list[tuple[str, Any]]:
         """ Returns a list of all key: value pairs of the DataEntry."""
+        return list(self.data.items())
     
-    def __eq__(self, other: dict[str, float]) -> bool:
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, dict):
+            return False
         allkeys = set(list(self.vars.keys()) + list(other.keys()))
         return all(self.vars[key]==other[key] for key in allkeys)
     
-    def _dist(self, other: dict[str, float]) -> bool:
+    def _dist(self, other: dict[str, float]) -> float:
         return sum([(abs(self.vars.get(key,1e20)-other[key])/other[key]) for key in other.keys()])
     
     def __getitem__(self, key) -> Any:
@@ -218,18 +221,18 @@ class DataContainer:
     
 
 class BaseDataset(Generic[T,M]):
-    def __init__(self, datatype: T, matrixtype: M, scalar: bool):
+    def __init__(self, datatype: type[T], matrixtype: type[M], scalar: bool):
         self._datatype: type[T] = datatype
         self._matrixtype: type[M] = matrixtype
         self._variables: list[dict[str, float]] = []
         self._data_entries: list[T] = []
         self._scalar: bool = scalar
         
-        self._gritted: bool = None
-        self._axes: dict[str, np.ndarray] = None
-        self._ax_ids: dict[str, int] = None
-        self._ids: np.ndarray = None
-        self._gridobj: M = None
+        self._gritted: bool | None = None
+        self._axes: dict[str, np.ndarray]| None = None
+        self._ax_ids: dict[str, int]| None = None
+        self._ids: np.ndarray| None = None
+        self._gridobj: M | None = None
 
         self._data: dict[str, Any] = dict()
     
@@ -238,11 +241,11 @@ class BaseDataset(Generic[T,M]):
 
     @property
     def _fields(self) -> list[str]:
-        return self._datatype._fields
+        return self._datatype._fields # type: ignore
     
     @property
     def _copy(self) -> list[str]:
-        return self._datatype._copy
+        return self._datatype._copy # type: ignore
     
     def store(self, key: str, value: Any) -> None:
         """Stores a variable with some value in the provided key. 
@@ -335,7 +338,7 @@ class BaseDataset(Generic[T,M]):
         self._data_entries.append(new_entry)
         return new_entry
     
-    def _grid_axes(self) -> None:
+    def _grid_axes(self) -> bool:
         """This method attepmts to create a gritted version of the scalar dataset
 
         Returns:
@@ -405,7 +408,9 @@ class BaseDataset(Generic[T,M]):
         """
         if self._gritted is None:
             self._grid_axes()
+
         if self._gritted is False:
             logger.error('The dataset cannot be cast to a structured grid.')
             raise ValueError('Data not in regular grid')
+        
         return self._gridobj

emerge/_emerge/solve_interfaces/pardiso_interface.py

@@ -24,7 +24,7 @@ import site
 from ctypes.util import find_library
 from enum import Enum
 import numpy as np
-from scipy import sparse
+from scipy import sparse # type: ignore
 from pathlib import Path
 from typing import Iterable, Iterator
 import pickle
@@ -60,7 +60,8 @@ PARDISO_ERROR_CODES = {
 
 
 #: Environment variable that overrides automatic searching
-ENV_VAR = "PYPARDISO_MKL_RT"
+
+ENV_VAR = "EMERGE_PARDISO_PATH"
 
 
 def _candidate_dirs() -> Iterable[Path]:
@@ -71,7 +72,7 @@ def _candidate_dirs() -> Iterable[Path]:
     for p in (                         # likely “local” env first
         Path(sys.prefix),
         Path(getattr(sys, "base_prefix", sys.prefix)),
-        Path(site.USER_BASE),
+        Path(str(site.USER_BASE)),
         *(Path(x) for x in os.getenv("LD_LIBRARY_PATH", "").split(":") if x),
     ):
         if p not in seen:
@@ -93,7 +94,7 @@ def _search_mkl() -> Iterator[Path]:
             if regex.match(path.name):
                 yield path
 
-def cache_path_result(tag: str, compute_fn, force: bool = False):
+def cache_path_result(tag: str, compute_fn, force: bool = False) -> str:
     """
     Retrieve a cached Path object or compute it and store it.
     
@@ -113,13 +114,13 @@ def cache_path_result(tag: str, compute_fn, force: bool = False):
     if not force and cache_file.exists():
         with open(cache_file, "rb") as f:
             filename = pickle.load(f)
-            print(f"Using cached MKL file: {filename}")
-            return filename
+            logger.debug(f"Using cached MKL file: {filename}")
+            return str(filename)
 
     result = compute_fn()
     with open(cache_file, "wb") as f:
         pickle.dump(result, f)
-    return result
+    return str(result)
 
 def search_mkl() -> str:
     """Searches for the file path of the PARDISO MKL executable
@@ -130,11 +131,11 @@ def search_mkl() -> str:
     logger.debug('Searching for MKL executable...')
     for candidate in _search_mkl():
         try:
-            ctypes.CDLL(candidate)
+            ctypes.CDLL(str(candidate))
         except OSError:
             continue  # try the next one
     logger.debug(f'Executable found: {candidate}')
-    return candidate
+    return str(candidate)
 
 def load_mkl() -> ctypes.CDLL:
     """Locate and load **mkl_rt**; raise ImportError on failure."""
@@ -200,6 +201,9 @@ CFLOAT32_P = ctypes.POINTER(CFLOAT32)
 CFLOAT64_P = ctypes.POINTER(CFLOAT64)
 VOID_SIZE = ctypes.sizeof(ctypes.c_void_p)
 
+PT_A: type = CINT32
+PT_B: type = np.int32
+
 if VOID_SIZE == 8:
     PT_A = CINT64
     PT_B = np.int64
@@ -210,7 +214,7 @@ elif VOID_SIZE == 4:
 def c_int(value: int):
     return ctypes.byref(ctypes.c_int32(value))
 
-PARDISO_ARG_TYPES = (ctypes.POINTER(PT_A),CINT32_P,CINT32_P,
+PARDISO_ARG_TYPES: tuple = (ctypes.POINTER(PT_A),CINT32_P,CINT32_P,
     CINT32_P,CINT32_P,CINT32_P,CNONE_P,CINT32_P,CINT32_P,
     CINT32_P,CINT32_P,CINT32_P,CINT32_P,CNONE_P,CNONE_P,CINT32_P,
 )
@@ -314,7 +318,7 @@ class PardisoInterface:
             self.MATRIX_TYPE = PARDISOMType.REAL_SYM_STRUCT
             self.complex = False
 
-    def _prepare_B(self, b: np.ndarray) -> np.ndarray:
+    def _prepare_B(self, b: np.ndarray | sparse.sparray) -> np.ndarray:
         """Fixes the forcing-vector for the solution process
 
         Args:
@@ -324,7 +328,8 @@ class PardisoInterface:
             np.ndarray: The prepared forcing-vector
         """
         if sparse.issparse(b):
-            b = b.todense()
+            b = b.todense() # type: ignore
+        
         if np.iscomplexobj(b):
             b = b.astype(np.complex128)
         else:
@@ -337,7 +342,7 @@ class PardisoInterface:
         Returns:
             int: The error code
         """
-        print("SYMBOLIC FACTORIZATION")
+        
         self._configure(A)
         zerovec = np.zeros_like((A.shape[0], 1), dtype=A.dtype)
         _, error = self._call_solver(A, zerovec, phase=PARDISOPhase.SYMBOLIC_FACTOR)
@@ -349,7 +354,7 @@ class PardisoInterface:
         Returns:
             int: The error code
         """
-        print("NUMERIC FACTORIZATION")
+
         self._configure(A)
         zerovec = np.zeros_like((A.shape[0], 1), dtype=A.dtype)
         _, error = self._call_solver(A, zerovec, phase=PARDISOPhase.NUMERIC_FACTOR)
@@ -372,7 +377,7 @@ class PardisoInterface:
 
     def configure_solver(self, 
         perm_algo: int = 3,
-        nthreads: int = None,
+        nthreads: int | None = None,
         user_perm: int = 0,
         n_refine_steps: int = 0,
         pivot_pert: int = 13,
@@ -388,7 +393,7 @@ class PardisoInterface:
             weighted_matching (int, optional): weighted matching mode. Defaults to 2.
         """
         if nthreads is None:
-            nthreads = int(os.environ.get('OMP_NUM_THREADS'))
+            nthreads = int(os.environ.get('OMP_NUM_THREADS', default="4"))
 
         self.IPARM[1] = perm_algo
         self.IPARM[2] = nthreads
@@ -418,14 +423,15 @@ class PardisoInterface:
         A_indices = A.indices + 1
 
         # Define the appropriate data type (complex vs real)
+
         if self.complex:
             VALUE_P = A.data.ctypes.data_as(CPX16_P)
             RHS_P = b.ctypes.data_as(CPX16_P)
             X_P = x.ctypes.data_as(CPX16_P)
         else:
             VALUE_P = A.data.ctypes.data_as(CFLOAT64_P)
-            RHS_P = b.ctypes.data_as(CFLOAT64_P)
-            X_P = x.ctypes.data_as(CFLOAT64_P)
+            RHS_P = b.ctypes.data_as(CFLOAT64_P) # type: ignore
+            X_P = x.ctypes.data_as(CFLOAT64_P) # type: ignore
 
         # Calls the pardiso function
         self._pardiso_interface(