emerge 0.4.10__tar.gz → 0.4.11__tar.gz

{emerge-0.4.10 → emerge-0.4.11}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.4.10"
+current_version = "0.4.11"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-0.4.10 → emerge-0.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.4.10
+Version: 0.4.11
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues
@@ -10,13 +10,12 @@ Requires-Dist: gmsh>=4.13.1
 Requires-Dist: joblib>=1.5.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: mkl!=2024.0; platform_machine == 'x86_64' or platform_machine == 'AMD64'
 Requires-Dist: numba-progress>=1.1.3
 Requires-Dist: numba>=0.57.0
 Requires-Dist: numpy<2.3,>=1.24
 Requires-Dist: pyvista>=0.45.2
 Requires-Dist: scipy>=1.14.0
-Provides-Extra: pypardiso
-Requires-Dist: pypardiso; (platform_machine == 'x86_64' or platform_machine == 'AMD64') and extra == 'pypardiso'
 Provides-Extra: umfpack
 Requires-Dist: scikit-umfpack; (sys_platform != 'win32') and extra == 'umfpack'
 Description-Content-Type: text/markdown

{emerge-0.4.10 → emerge-0.4.11}/emerge/__init__.py

@@ -20,8 +20,8 @@ import os
 
 NTHREADS = "1"
 
-os.environ["OMP_NUM_THREADS"] = NTHREADS
-os.environ["MKL_NUM_THREADS"] = NTHREADS
+os.environ["OMP_NUM_THREADS"] = "4"
+os.environ["MKL_NUM_THREADS"] = "4"
 os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS

emerge-0.4.11/emerge/_emerge/pardiso/pardiso_solver.py

@@ -0,0 +1,455 @@
+# Copyright (c) 2016 Adrian Haas and ETH Zürich
+# Modifications Copyright (c) 2025 Robert Fennis
+#
+# SPDX-License-Identifier: BSD-3-Clause AND GPL-2.0-or-later
+#
+# This file incorporates code from the PyPardiso project, which is
+# distributed under the BSD 3-Clause License.  You may redistribute
+# and/or modify this file under either
+#
+#   * the terms of the BSD 3-Clause License (see below), or
+#   * the terms of the GNU General Public License, version 2 or later.
+#
+# ----------------------------------------------------------------------
+# BSD 3-Clause License
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. Neither the name of ETH Zürich nor the names of its contributors
+#    may be used to endorse or promote products derived from this
+#    software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+# DAMAGE.
+# ----------------------------------------------------------------------
+
+# coding: utf-8
+import scipy.sparse as sp
+# coding: utf-8
+import os
+import sys
+import glob
+import ctypes
+import warnings
+import hashlib
+import site
+from ctypes.util import find_library
+
+import numpy as np
+import scipy.sparse as sp
+from scipy.sparse import SparseEfficiencyWarning, csr_matrix
+
+
+_PARDISO_ERROR_CODES = """
+   0 | No error.
+  -1 | Input inconsistent.
+  -2 | Not enough memory.
+  -3 | Reordering problem.
+  -4 | Zero pivot, numerical fac. or iterative refinement problem.
+  -5 | Unclassified (internal) error.
+  -6 | Preordering failed (matrix types 11(real and nonsymmetric), 13(complex and nonsymmetric) only).
+  -7 | Diagonal Matrix problem.
+  -8 | 32-bit integer overflow problem.
+ -10 | No license file pardiso.lic found.
+ -11 | License is expired.
+ -12 | Wrong username or hostname.
+-100 | Reached maximum number of Krylov-subspace iteration in iterative solver.
+-101 | No sufficient convergence in Krylov-subspace iteration within 25 iterations.
+-102 | Error in Krylov-subspace iteration.
+-103 | Bread-Down in Krylov-subspace iteration
+"""
+
+class MKL_Complex16(ctypes.Structure):
+    _fields_ = [("real", ctypes.c_double),
+                ("imag", ctypes.c_double)]
+
+cpx16_p = ctypes.POINTER(MKL_Complex16)
+
+class PyPardisoSolver:
+    """
+    Python interface to the Intel MKL PARDISO library for solving large sparse linear systems of equations Ax=b.
+
+    Pardiso documentation: https://software.intel.com/en-us/node/470282
+
+    --- Basic usage ---
+    matrix type: real (float64) and nonsymetric
+    methods: solve, factorize
+
+    - use the "solve(A,b)" method to solve Ax=b for x, where A is a sparse CSR (or CSC) matrix and b is a numpy array
+    - use the "factorize(A)" method first, if you intend to solve the system more than once for different right-hand
+      sides, the factorization will be reused automatically afterwards
+
+
+    --- Advanced usage ---
+    methods: get_iparm, get_iparms, set_iparm, set_matrix_type, set_phase
+
+    - additional options can be accessed by setting the iparms (see Pardiso documentation for description)
+    - other matrix types can be chosen with the "set_matrix_type" method. complex matrix types are currently not
+      supported. pypardiso is only teste for mtype=11 (real and nonsymetric)
+    - the solving phases can be set with the "set_phase" method
+    - The out-of-core (OOC) solver either fails or crashes my computer, be careful with iparm[60]
+
+
+    --- Statistical info ---
+    methods: set_statistical_info_on, set_statistical_info_off
+
+    - the Pardiso solver writes statistical info to the C stdout if desired
+    - if you use pypardiso from within a jupyter notebook you can turn the statistical info on and capture the output
+      real-time by wrapping your call to "solve" with wurlitzer.sys_pipes() (https://github.com/minrk/wurlitzer,
+      https://pypi.python.org/pypi/wurlitzer/)
+    - wurlitzer dosen't work on windows, info appears in notebook server console window if used from jupyter notebook
+
+
+    --- Memory usage ---
+    methods: remove_stored_factorization, free_memory
+
+    - remove_stored_factorization can be used to delete the wrapper's copy of matrix A
+    - free_memory releases the internal memory of the solver
+
+    """
+
+    def __init__(self, mtype=11, phase=13, size_limit_storage=5e7):
+
+        self.libmkl = None
+
+        # custom mkl_rt path in environment variable
+        mkl_rt = os.environ.get('PYPARDISO_MKL_RT')
+
+        # Look for the mkl_rt shared library with ctypes.util.find_library
+        if mkl_rt is None:
+            mkl_rt = find_library('mkl_rt')
+        # also look for mkl_rt.1, Windows-specific, see
+        # https://github.com/haasad/PyPardisoProject/issues/12
+        if mkl_rt is None:
+            mkl_rt = find_library('mkl_rt.1')
+
+        # If we can't find mkl_rt with find_library, we search the directory
+        # tree, using a few assumptions:
+        # - the shared library can be found in a subdirectory of sys.prefix
+        #   https://docs.python.org/3.9/library/sys.html#sys.prefix
+        #   or in the user site in case of user-local installation like
+        #   `pip install --user`
+        #   https://peps.python.org/pep-0370/
+        #   https://docs.python.org/3/library/site.html#site.USER_BASE
+        # - either in `lib` (linux and macOS) or `Library\bin` (windows)
+        # - if there are multiple matches for `mkl_rt`, try shorter paths
+        #   first
+        if mkl_rt is None:
+            globs = glob.glob(
+                f'{sys.prefix}/[Ll]ib*/**/*mkl_rt*', recursive=True
+            ) or glob.glob(
+                f'{site.USER_BASE}/[Ll]ib*/**/*mkl_rt*', recursive=True
+            )
+            for path in sorted(globs, key=len):
+                try:
+                    self.libmkl = ctypes.CDLL(path)
+                    break
+                except (OSError, ImportError):
+                    pass
+
+            if self.libmkl is None:
+                raise ImportError(
+                    'Shared library mkl_rt not found. '
+                    'Use environment variable PYPARDISO_MKL_RT to provide a custom path.'
+                )
+        else:
+            self.libmkl = ctypes.CDLL(mkl_rt)
+
+        self._mkl_pardiso = self.libmkl.pardiso
+
+        # determine 32bit or 64bit architecture
+        if ctypes.sizeof(ctypes.c_void_p) == 8:
+            self._pt_type = (ctypes.c_int64, np.int64)
+        else:
+            self._pt_type = (ctypes.c_int32, np.int32)
+
+        self._mkl_pardiso.argtypes = [ctypes.POINTER(self._pt_type[0]),    # pt
+                                      ctypes.POINTER(ctypes.c_int32),      # maxfct
+                                      ctypes.POINTER(ctypes.c_int32),      # mnum
+                                      ctypes.POINTER(ctypes.c_int32),      # mtype
+                                      ctypes.POINTER(ctypes.c_int32),      # phase
+                                      ctypes.POINTER(ctypes.c_int32),      # n
+                                      ctypes.POINTER(None),                # a
+                                      ctypes.POINTER(ctypes.c_int32),      # ia
+                                      ctypes.POINTER(ctypes.c_int32),      # ja
+                                      ctypes.POINTER(ctypes.c_int32),      # perm
+                                      ctypes.POINTER(ctypes.c_int32),      # nrhs
+                                      ctypes.POINTER(ctypes.c_int32),      # iparm
+                                      ctypes.POINTER(ctypes.c_int32),      # msglvl
+                                      ctypes.POINTER(None),                # b
+                                      ctypes.POINTER(None),                # x
+                                      ctypes.POINTER(ctypes.c_int32)]      # error
+
+        self._mkl_pardiso.restype = None
+
+        self.pt = np.zeros(64, dtype=self._pt_type[1])
+        self.iparm = np.zeros(64, dtype=np.int32)
+        self.perm = np.zeros(0, dtype=np.int32)
+
+        self.mtype = mtype
+        self.phase = phase
+        self.msglvl = False
+
+        self.factorized_A = csr_matrix((0, 0))
+        self.size_limit_storage = size_limit_storage
+        self._solve_transposed = False
+
+    def factorize(self, A):
+        """
+        Factorize the matrix A, the factorization will automatically be used if the same matrix A is passed to the
+        solve method. This will drastically increase the speed of solve, if solve is called more than once for the
+        same matrix A
+
+        --- Parameters ---
+        A: sparse square CSR matrix (scipy.sparse.csr.csr_matrix), CSC matrix also possible
+        """
+
+        self._check_A(A)
+
+        if A.nnz > self.size_limit_storage:
+            self.factorized_A = self._hash_csr_matrix(A)
+        else:
+            self.factorized_A = A.copy()
+
+        self.set_phase(12)
+        b = np.zeros((A.shape[0], 1))
+        self._call_pardiso(A, b)
+
+    def solve(self, A, b):
+        """
+        solve Ax=b for x
+
+        --- Parameters ---
+        A: sparse square CSR matrix (scipy.sparse.csr.csr_matrix), CSC matrix also possible
+        b: numpy ndarray
+           right-hand side(s), b.shape[0] needs to be the same as A.shape[0]
+
+        --- Returns ---
+        x: numpy ndarray
+           solution of the system of linear equations, same shape as input b
+        """
+
+        self._check_A(A)
+        b = self._check_b(A, b)
+
+        if self._is_already_factorized(A):
+            self.set_phase(33)
+        else:
+            self.set_phase(13)
+
+        x = self._call_pardiso(A, b)
+
+        # it is possible to call the solver with empty columns, but computationally expensive to check this
+        # beforehand, therefore only the result is checked for infinite elements.
+        # if not np.isfinite(x).all():
+        #    warnings.warn('The result contains infinite elements. Make sure that matrix A contains no empty columns.',
+        #                  PyPardisoWarning)
+        # --> this check doesn't work consistently, maybe add an advanced input check method for A
+
+        return x
+
+    def _is_already_factorized(self, A):
+        if isinstance(self.factorized_A, str):
+            return self._hash_csr_matrix(A) == self.factorized_A
+        else:
+            return self._csr_matrix_equal(A, self.factorized_A)
+
+    def _csr_matrix_equal(self, a1, a2):
+        return all((np.array_equal(a1.indptr, a2.indptr),
+                    np.array_equal(a1.indices, a2.indices),
+                    np.array_equal(a1.data, a2.data)))
+
+    def _hash_csr_matrix(self, matrix):
+        return (hashlib.sha1(matrix.indices).hexdigest() +
+                hashlib.sha1(matrix.indptr).hexdigest() +
+                hashlib.sha1(matrix.data).hexdigest())
+
+    def _check_A(self, A):
+        if A.shape[0] != A.shape[1]:
+            raise ValueError('Matrix A needs to be square, but has shape: {}'.format(A.shape))
+
+        if sp.issparse(A) and A.format == "csr":
+            self._solve_transposed = False
+            self.set_iparm(12, 1)
+        elif sp.issparse(A) and A.format == "csc":
+            self._solve_transposed = True
+            self.set_iparm(12, 0)
+        else:
+            msg = 'PyPardiso requires matrix A to be in CSR or CSC format, but matrix A is: {}'.format(type(A))
+            raise TypeError(msg)
+
+        # scipy allows unsorted csr-indices, which lead to completely wrong pardiso results
+        if not A.has_sorted_indices:
+            A.sort_indices()
+
+        # scipy allows csr matrices with empty rows. a square matrix with an empty row is singular. calling
+        # pardiso with a matrix A that contains empty rows leads to a segfault, same applies for csc with
+        # empty columns
+        if not np.diff(A.indptr).all():
+            row_col = 'column' if self._solve_transposed else 'row'
+            raise ValueError('Matrix A is singular, because it contains empty {}(s)'.format(row_col))
+
+    def _check_b(self, A, b):
+        if sp.issparse(b):
+            warnings.warn('PyPardiso requires the right-hand side b to be a dense array for maximum efficiency',
+                          SparseEfficiencyWarning)
+            b = b.todense()
+
+        # pardiso expects fortran (column-major) order for b
+        if not b.flags.f_contiguous:
+            b = np.asfortranarray(b)
+
+        if b.shape[0] != A.shape[0]:
+            raise ValueError("Dimension mismatch: Matrix A {} and array b {}".format(A.shape, b.shape))
+
+        if b.dtype != np.float64:
+            if b.dtype in [np.float16, np.float32, np.int16, np.int32, np.int64]:
+                warnings.warn("Array b's data type was converted from {} to float64".format(str(b.dtype)),
+                              PyPardisoWarning)
+                b = b.astype(np.float64)
+            elif b.dtype in (np.complex128, np.complex64):
+                b = b.astype(np.complex128)
+            else:
+                raise TypeError('Dtype {} for array b is not supported'.format(str(b.dtype)))
+
+        return b
+
+    def _call_pardiso(self, A, b):
+        self.set_iparm(2,3)
+        self.set_iparm(3,6)
+        self.set_iparm(10,13)
+        self.set_iparm(13,2)
+
+        x = np.zeros_like(b)
+        pardiso_error = ctypes.c_int32(0)
+        c_int32_p = ctypes.POINTER(ctypes.c_int32)
+        c_float64_p = ctypes.POINTER(ctypes.c_double)
+
+        # 1-based indexing
+        ia = A.indptr + 1
+        ja = A.indices + 1
+
+        mtype = 3
+        
+        if A.dtype == np.complex128:
+            val_ptr = A.data.ctypes.data_as(cpx16_p)
+            rhs_ptr = b.ctypes.data_as(cpx16_p)
+            x_ptr = x.ctypes.data_as(cpx16_p)
+        else:
+            val_ptr = A.data.ctypes.data_as(c_float64_p)
+            rhs_ptr = b.ctypes.data_as(c_float64_p)
+            x_ptr = x.ctypes.data_as(c_float64_p)
+
+        self._mkl_pardiso(self.pt.ctypes.data_as(ctypes.POINTER(self._pt_type[0])),  # pt
+                          ctypes.byref(ctypes.c_int32(1)),  # maxfct
+                          ctypes.byref(ctypes.c_int32(1)),  # mnum
+                          ctypes.byref(ctypes.c_int32(mtype)),  # mtype -> 11 for real-nonsymetric
+                          ctypes.byref(ctypes.c_int32(self.phase)),  # phase -> 13
+                          ctypes.byref(ctypes.c_int32(A.shape[0])),  # N -> number of equations/size of matrix
+                          val_ptr,  # A -> non-zero entries in matrix
+                          ia.ctypes.data_as(c_int32_p),  # ia -> csr-indptr
+                          ja.ctypes.data_as(c_int32_p),  # ja -> csr-indices
+                          self.perm.ctypes.data_as(c_int32_p),  # perm -> empty
+                          ctypes.byref(ctypes.c_int32(1 if b.ndim == 1 else b.shape[1])),  # nrhs
+                          self.iparm.ctypes.data_as(c_int32_p),  # iparm-array
+                          ctypes.byref(ctypes.c_int32(self.msglvl)),  # msg-level -> 1: statistical info is printed
+                          rhs_ptr,  # b -> right-hand side vector/matrix
+                          x_ptr,  # x -> output
+                          ctypes.byref(pardiso_error))  # pardiso error
+
+        if pardiso_error.value != 0:
+            raise PyPardisoError(pardiso_error.value)
+        else:
+            return np.ascontiguousarray(x)  # change memory-layout back from fortran to c order
+
+    def get_iparms(self):
+        """Returns a dictionary of iparms"""
+        return dict(enumerate(self.iparm, 1))
+
+    def get_iparm(self, i):
+        """Returns the i-th iparm (1-based indexing)"""
+        return self.iparm[i-1]
+
+    def set_iparm(self, i, value):
+        """set the i-th iparm to 'value' (1-based indexing)"""
+        if i not in {1, 2, 3, 4, 5, 6, 8, 10, 11, 12, 13, 18, 19, 21, 24, 25, 27, 28, 31, 34, 35, 36, 37, 56, 60}:
+            warnings.warn('{} is no input iparm. See the Pardiso documentation.'.format(value), PyPardisoWarning)
+        self.iparm[i-1] = value
+
+    def set_matrix_type(self, mtype):
+        """Set the matrix type (see Pardiso documentation)"""
+        self.mtype = mtype
+
+    def set_statistical_info_on(self):
+        """Display statistical info (appears in notebook server console window if pypardiso is
+        used from jupyter notebook, use wurlitzer to redirect info to the notebook)"""
+        self.msglvl = 1
+
+    def set_statistical_info_off(self):
+        """Turns statistical info off"""
+        self.msglvl = 0
+
+    def set_phase(self, phase):
+        """Set the phase(s) for the solver. See the Pardiso documentation for details."""
+        self.phase = phase
+
+    def remove_stored_factorization(self):
+        """removes the stored factorization, this will free the memory in python, but the factorization in pardiso
+        is still accessible with a direct call to self._call_pardiso(A,b) with phase=33"""
+        self.factorized_A = sp.csr_matrix((0, 0))
+
+    def free_memory(self, everything=False):
+        """release mkl's internal memory, either only for the factorization (ie the LU-decomposition) or all of
+        mkl's internal memory if everything=True"""
+        self.remove_stored_factorization()
+        A = sp.csr_matrix((0, 0))
+        b = np.zeros(0)
+        self.set_phase(-1 if everything else 0)
+        self._call_pardiso(A, b)
+        self.set_phase(13)
+
+    def pardiso_solve(self, A: csr_matrix, b: np.ndarray):
+        if sp.issparse(A) and A.format == "csc":
+            A = A.tocsr()  
+
+        self._check_A(A)
+
+        if not self._is_already_factorized(A):
+            self.factorize(A)
+
+        try:
+            x = self.solve(A, b)
+        except PyPardisoError as e:
+            print('Error Codes:')
+            print(_PARDISO_ERROR_CODES)
+
+        return x.squeeze()
+
+class PyPardisoWarning(UserWarning):
+    pass
+
+
+class PyPardisoError(Exception):
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return ('The Pardiso solver failed with error code {}. '
+                'See Pardiso documentation for details.'.format(self.value))

{emerge-0.4.10 → emerge-0.4.11}/emerge/_emerge/solver.py

@@ -32,32 +32,14 @@ from enum import Enum
 
 _PARDISO_AVAILABLE = False
 _UMFPACK_AVAILABLE = False
-_PARDISO_ERROR_CODES = """
-   0 | No error.
-  -1 | Input inconsistent.
-  -2 | Not enough memory.
-  -3 | Reordering problem.
-  -4 | Zero pivot, numerical fac. or iterative refinement problem.
-  -5 | Unclassified (internal) error.
-  -6 | Preordering failed (matrix types 11(real and nonsymmetric), 13(complex and nonsymmetric) only).
-  -7 | Diagonal Matrix problem.
-  -8 | 32-bit integer overflow problem.
- -10 | No license file pardiso.lic found.
- -11 | License is expired.
- -12 | Wrong username or hostname.
--100 | Reached maximum number of Krylov-subspace iteration in iterative solver.
--101 | No sufficient convergence in Krylov-subspace iteration within 25 iterations.
--102 | Error in Krylov-subspace iteration.
--103 | Bread-Down in Krylov-subspace iteration
-"""
+
 """ Check if the PC runs on a non-ARM architechture
 If so, attempt to import PyPardiso (if its installed)
 """
 
 if 'arm' not in platform.processor():
     try:
-        from pypardiso import spsolve as pardiso_solve
-        from pypardiso.pardiso_wrapper import PyPardisoError
+        from .pardiso.pardiso_solver import PyPardisoSolver, PyPardisoError
         _PARDISO_AVAILABLE = True
     except ModuleNotFoundError as e:
         logger.info('Pardiso not found, defaulting to SuperLU')
@@ -426,12 +408,12 @@ class SolverUMFPACK(Solver):
 
 class SolverPardiso(Solver):
     """ Implements the PARDISO solver through PyPardiso. """
-    real_only: bool = True
+    real_only: bool = False
     req_sorter: bool = False
 
     def __init__(self):
         super().__init__()
-
+        self.solver: PyPardisoSolver = PyPardisoSolver()
         self.A: np.ndarray = None
         self.b: np.ndarray = None
     
@@ -439,11 +421,7 @@ class SolverPardiso(Solver):
         logger.info(f'Calling Pardiso Solver. ID={id}')
         self.A = A
         self.b = b
-        try:
-            x = pardiso_solve(A, b)
-        except PyPardisoError as e:
-            print('Error Codes:')
-            print(_PARDISO_ERROR_CODES)
+        x = self.solver.solve(A, b)
         return x, 0
     
 ## -----  DIRECT EIG SOLVERS --------------------------------------

{emerge-0.4.10 → emerge-0.4.11}/pyproject.toml

@@ -3,7 +3,7 @@ allow-direct-references = true
 
 [project]
 name = "emerge"
-version = "0.4.10"
+version = "0.4.11"
 description = "An open source EM FEM simulator in Python"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
@@ -17,6 +17,7 @@ dependencies = [
     "numpy>=1.24, <2.3",
     "pyvista>=0.45.2",
     "scipy>=1.14.0",
+    "mkl!=2024.0; platform_machine == \"x86_64\" or platform_machine == \"AMD64\""
 ]
 
 [project.scripts]
@@ -26,9 +27,6 @@ emerge = "emerge.cli:main"
 "src/emerge"  = "emerge"
 
 [project.optional-dependencies]
-pypardiso = [
-  "pypardiso; platform_machine == 'x86_64' or platform_machine == 'AMD64'",
-]
 umfpack = [
   "scikit-umfpack; sys_platform != 'win32'",
 ]

{emerge-0.4.10 → emerge-0.4.11}/uv.lock

@@ -164,13 +164,14 @@ wheels = [
 
 [[package]]
 name = "emerge"
-version = "0.4.10"
+version = "0.4.11"
 source = { editable = "." }
 dependencies = [
     { name = "gmsh" },
     { name = "joblib" },
     { name = "loguru" },
     { name = "matplotlib" },
+    { name = "mkl", marker = "platform_machine == 'AMD64' or platform_machine == 'x86_64'" },
     { name = "numba" },
     { name = "numba-progress" },
     { name = "numpy" },
@@ -179,9 +180,6 @@ dependencies = [
 ]
 
 [package.optional-dependencies]
-pypardiso = [
-    { name = "pypardiso", marker = "platform_machine == 'AMD64' or platform_machine == 'x86_64'" },
-]
 umfpack = [
     { name = "scikit-umfpack", marker = "sys_platform != 'win32'" },
 ]
@@ -199,15 +197,15 @@ requires-dist = [
     { name = "joblib", specifier = ">=1.5.1" },
     { name = "loguru", specifier = ">=0.7.3" },
     { name = "matplotlib", specifier = ">=3.8.0" },
+    { name = "mkl", marker = "platform_machine == 'AMD64' or platform_machine == 'x86_64'", specifier = "!=2024.0" },
     { name = "numba", specifier = ">=0.57.0" },
     { name = "numba-progress", specifier = ">=1.1.3" },
     { name = "numpy", specifier = ">=1.24,<2.3" },
-    { name = "pypardiso", marker = "(platform_machine == 'AMD64' and extra == 'pypardiso') or (platform_machine == 'x86_64' and extra == 'pypardiso')" },
     { name = "pyvista", specifier = ">=0.45.2" },
     { name = "scikit-umfpack", marker = "sys_platform != 'win32' and extra == 'umfpack'" },
     { name = "scipy", specifier = ">=1.14.0" },
 ]
-provides-extras = ["pypardiso", "umfpack"]
+provides-extras = ["umfpack"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -300,26 +298,26 @@ wheels = [
 
 [[package]]
 name = "intel-cmplr-lib-ur"
-version = "2025.1.1"
+version = "2025.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "umf" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/db/0b/f29540ba90d60e06a497f1fa9af969bfaf05acf8619358c9c7ecc1750a6b/intel_cmplr_lib_ur-2025.1.1-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:b34ddb46fc70e21209297ac13f800e37be390df1589f4dd22e194b289871f30e", size = 26333678, upload-time = "2025-04-30T09:16:14.695Z" },
-    { url = "https://files.pythonhosted.org/packages/00/17/aec63daf936af18354de6af8f4d8f8956b0964ff442248bd29bbafd6c6b3/intel_cmplr_lib_ur-2025.1.1-py2.py3-none-win_amd64.whl", hash = "sha256:a4d2fd91930ea017e9c8dd757b8159352aa7852344eb609d8f855b9efea11cea", size = 1063878, upload-time = "2025-04-30T09:15:30.784Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/1c/9e06795a34f56d23198aa9aa1c096791b5fa844d88ca99b5baabc5803197/intel_cmplr_lib_ur-2025.2.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:bd65263be09d66c750900cb7753d4dcb8eb41fe1f6ad2db6658d3f83126f5078", size = 29313819, upload-time = "2025-06-24T13:14:26.312Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/89e0d199fc210fbd321114d58ae0278ce8b8b71d2ef8e716e64412de0d10/intel_cmplr_lib_ur-2025.2.0-py2.py3-none-win_amd64.whl", hash = "sha256:30cd6026858808f885395b27e3da8eb90aaf62838933932bab62e8533f65b9df", size = 1169341, upload-time = "2025-06-24T13:20:02.174Z" },
 ]
 
 [[package]]
 name = "intel-openmp"
-version = "2025.1.1"
+version = "2025.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "intel-cmplr-lib-ur" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cf/f8/839c84fc630e868b6ed4322c9c5bd5ed8ee8a30a27985cb027d627e25886/intel_openmp-2025.1.1-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:c3d3255f4076b86b6fb7e556492c4722be583bb958f095adc92d7a0e3807ec51", size = 48598966, upload-time = "2025-04-30T09:16:04.462Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/b8/0fb9f8562a73ff5a5d469c7faed422899618ab496a4ef629c1a73a92bb30/intel_openmp-2025.1.1-py2.py3-none-win_amd64.whl", hash = "sha256:4a63f6e0a302f08f8fab1109b91b4678f790e0ef508942ee4b2438ce1a253a60", size = 12713497, upload-time = "2025-04-30T09:15:27.877Z" },
+    { url = "https://files.pythonhosted.org/packages/39/17/45e67730f8757a00d665095338b21ca04890d2a3d52a44d725fb5393a044/intel_openmp-2025.2.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:57f52a5f374e70dce56591ab23bf274252a68128d5b8de8f897f3683f65374c8", size = 73412223, upload-time = "2025-06-24T13:14:46.866Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/37/bab8e9283407798d8782f4d9b374436e51c7a297e1b6dc05073df550c010/intel_openmp-2025.2.0-py2.py3-none-win_amd64.whl", hash = "sha256:1710356ae0db744ca028ed380759a2007548ad1819f743be9d675603cb127377", size = 34021989, upload-time = "2025-06-24T13:20:19.438Z" },
 ]
 
 [[package]]
@@ -513,15 +511,15 @@ wheels = [
 
 [[package]]
 name = "mkl"
-version = "2025.1.0"
+version = "2025.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "intel-openmp" },
     { name = "tbb" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/9a/97f134eaed418266751410793104782052e66c2002eaaf557f55afa72414/mkl-2025.1.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:1c201bc314304760d995a2b5cc7df9175afba2d3eb7aa70c4917ebe35c2f48de", size = 186817693, upload-time = "2025-03-21T15:23:24.393Z" },
-    { url = "https://files.pythonhosted.org/packages/20/01/34d98bfa40019e5ce3731efe1a25da4f5dd6d25090b143916b866a877733/mkl-2025.1.0-py2.py3-none-win_amd64.whl", hash = "sha256:6f459efc394360675efa78c9e9e6fdfa2883f1c730b0323bca414e8df47d4598", size = 151134738, upload-time = "2025-03-21T15:25:33.053Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7b/f5b1b84eb0a2a6e145fc31b4e6b1c59690dcb088734197da8f299caf7c67/mkl-2025.2.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:974b4e222cc94e8d3b67213a361c8ac25d432cc4fccc5f2f00aa15c4e67cc203", size = 190225238, upload-time = "2025-06-24T13:16:12.866Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ae/025174ee141432b974f97ecd2aea529a3bdb547392bde3dd55ce48fe7827/mkl-2025.2.0-py2.py3-none-win_amd64.whl", hash = "sha256:b6ec153e4a073421dbb52ef99c7be97e66cde0272e4a1e3569b090b6f0130253", size = 153630290, upload-time = "2025-06-24T13:18:06.053Z" },
 ]
 
 [[package]]
@@ -781,20 +779,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
 ]
 
-[[package]]
-name = "pypardiso"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mkl" },
-    { name = "numpy" },
-    { name = "scipy" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/01/8b/a88f8ee0b4a98d15737b728d6306682a1c8aaa588600a906ccde35965361/pypardiso-0.4.6.tar.gz", hash = "sha256:ff13eff486a2246d9c5bc9cec9f5bc8009f1b8831b2d10767787d768d98afa06", size = 15545, upload-time = "2024-03-28T21:32:54.668Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/e8/29b96e539ff24c3425e90003e69a24296009ac8c6280665ea1a08bdd61f6/pypardiso-0.4.6-py3-none-any.whl", hash = "sha256:43d370a91ab97062bce1862e76387def1732ad944c5882024c5c3be2c6e9e77c", size = 10744, upload-time = "2024-03-28T21:32:48.311Z" },
-]
-
 [[package]]
 name = "pyparsing"
 version = "3.2.3"
@@ -953,23 +937,23 @@ wheels = [
 
 [[package]]
 name = "tbb"
-version = "2022.1.0"
+version = "2022.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "tcmlib" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/64/3d24181aaea3fb892d4a46f8171845782ee364d60e9494426daf31d12f47/tbb-2022.1.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:4992a3f2268b33f9a7b4c274af9d7001f550e74246436647b267d58e4947628a", size = 3614726, upload-time = "2025-03-21T15:26:50.39Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/e5/09786318a0fcd5a9b9589759ec91fe1815db064ab6bb6d4083ea24dbb859/tbb-2022.1.0-py3-none-win_amd64.whl", hash = "sha256:ae9cc327606f604324441abf3ab984c12ea4f6f1ea2a84230874fc40036d0913", size = 299568, upload-time = "2025-03-21T15:28:27.22Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/5c/019acaccf0038b8e05b0a54189439d0987891017a84ca43675589f7e460c/tbb-2022.2.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:522189f3e370a6b9c92b8a7fbdecf3633f7c53f0ea4eb8d6891a7f5f00c78099", size = 6393815, upload-time = "2025-06-24T13:15:13.482Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/d2/01e2a93f9c644585088188840bf453f23ed1a2838ec51d5ba1ada1ebca71/tbb-2022.2.0-py3-none-win_amd64.whl", hash = "sha256:acbce7632d4d7acc6bdfe9849a57ab1624490198699eb16ea63243cfb4fd4cfa", size = 420638, upload-time = "2025-06-24T13:19:44.515Z" },
 ]
 
 [[package]]
 name = "tcmlib"
-version = "1.3.0"
+version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/bb/09a6dc2f1110b409d6d2f96429969d7466bde9bf4ad8b2e682d851ef104b/tcmlib-1.3.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:c328ba464c556e46174879c694cafd17ba17c3e7406a79fee47bb3e8c9c6a6c5", size = 4158009, upload-time = "2025-03-21T15:29:35.675Z" },
-    { url = "https://files.pythonhosted.org/packages/07/d2/11754d24c4ee4a78e11da4fd34ccdc948261b359e525ee74fc9aae485fd0/tcmlib-1.3.0-py2.py3-none-win_amd64.whl", hash = "sha256:878c9ce2ae5705da3964b7d00ff721c0c61b23a0aa93960629b2119c2921a1e2", size = 356902, upload-time = "2025-03-21T15:24:46.837Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9d/97d81fa340b9f1a0e33d6260daeb8bd7bbc2ef5b686be193491de5c9880a/tcmlib-1.4.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:b2a2b68c100cc2a6163d394353b3013ab2479e70300b9bc1cb7f7822bcc38a40", size = 2731275, upload-time = "2025-06-24T13:15:40.134Z" },
+    { url = "https://files.pythonhosted.org/packages/91/7b/e30c461a27b97e0090e4db822eeb1d37b310863241f8c3ee56f68df3e76e/tcmlib-1.4.0-py2.py3-none-win_amd64.whl", hash = "sha256:ab24f73c52b224cb744a0c0c28fcef8e51aec3c88aa6b39202c149495d6d2ea0", size = 370349, upload-time = "2025-06-24T13:13:59.825Z" },
 ]
 
 [[package]]
@@ -1034,14 +1018,14 @@ wheels = [
 
 [[package]]
 name = "umf"
-version = "0.10.0"
+version = "0.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "tcmlib" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/a4/1d289b37333a7c9a54d590d04a4d83aefa0e3d1ab1ad98e592d22080347a/umf-0.10.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:a27a368c614fd9d0e67e9ef77de391a7080697d7a4d51b9035707f629d81dc7c", size = 314530, upload-time = "2025-03-21T15:26:41.295Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/27/0baa776232aac436568b3ad8ab1d906c383ed0956a9052f374e88f33e6a8/umf-0.10.0-py2.py3-none-win_amd64.whl", hash = "sha256:7b3ee402f1a5bbe418d661970338f75b25a441cb59bb084dca916040f5c3c303", size = 193945, upload-time = "2025-03-21T15:28:59.666Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/3a/63b40f833c7b27ba767e467fdf52cf972cdd149aab72d3d9761ec200fc9f/umf-0.11.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:9f2a6be0de4202fdcdddf9045c54ae6eb4c4afaec38e1871a603db3f72d36bab", size = 329971, upload-time = "2025-06-24T13:19:35.567Z" },
+    { url = "https://files.pythonhosted.org/packages/33/a0/c8d755f08f50ddd99cb4a29a7e950ced7a0903cb72253e57059063609103/umf-0.11.0-py2.py3-none-win_amd64.whl", hash = "sha256:24b2ec23b6716f39dde53d1b29f8de1ec73c33a1e3b137dae9caf0caeaf50201", size = 231697, upload-time = "2025-06-24T13:13:15.432Z" },
 ]
 
 [[package]]