structsolve 0.4.0__tar.gz → 0.4.2__tar.gz

{structsolve-0.4.0/structsolve.egg-info → structsolve-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.4.0
+Version: 0.4.2
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -41,8 +41,7 @@ Github Actions status:
 
 Coverage status:
 [![codecov](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml/badge.svg)](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml)
-[![Codecov Status](https://codecov.io/gh/saullocastro/structsolve/branch/master/graph/badge.svg)](https://codecov.io/gh/saullocastro/structsolve)
-
+[![Codecov Status](https://codecov.io/gh/saullocastro/structsolve/branch/main/graph/badge.svg?token=NNHK0SFZNH)](https://codecov.io/gh/saullocastro/structsolve)
 
 Structural analysis solvers tailored for semi-analytical models
 ===============================================================
@@ -61,7 +60,7 @@ Currently these solvers are pretty much compatible with my other repositories
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.2). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -76,7 +75,18 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.4.0 (2026-09-17)
+* version 0.4.2 (2026-09-17)
+    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
+      return buckling loads higher than the critical ones
+    - Fixed wrong buckling loads of the sparse solver of `lb` when SciPy is
+      linked against Intel MKL 2024.2.0 to 2025.0.0 (e.g. Anaconda on
+      Windows), whose `dsteqr` routine breaks ARPACK
+    - `lb` condenses out the dofs where `KG` is null and solves small
+      condensed problems with a dense solver
+    - `lb` verifies the eigenpairs of the sparse solver, raising an error
+      instead of returning wrong results
+    - The sparse solver of `lb` returns the load multipliers sorted as the
+      dense solver
     - Newton-Raphson with full Newton iterations and a relative convergence
       criterion by default, reaching quadratic convergence with exact tangent
       stiffness matrices

{structsolve-0.4.0 → structsolve-0.4.2}/README.md

@@ -4,8 +4,7 @@ Github Actions status:
 
 Coverage status:
 [![codecov](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml/badge.svg)](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml)
-[![Codecov Status](https://codecov.io/gh/saullocastro/structsolve/branch/master/graph/badge.svg)](https://codecov.io/gh/saullocastro/structsolve)
-
+[![Codecov Status](https://codecov.io/gh/saullocastro/structsolve/branch/main/graph/badge.svg?token=NNHK0SFZNH)](https://codecov.io/gh/saullocastro/structsolve)
 
 Structural analysis solvers tailored for semi-analytical models
 ===============================================================
@@ -24,7 +23,7 @@ Currently these solvers are pretty much compatible with my other repositories
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.2). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -39,7 +38,18 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.4.0 (2026-09-17)
+* version 0.4.2 (2026-09-17)
+    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
+      return buckling loads higher than the critical ones
+    - Fixed wrong buckling loads of the sparse solver of `lb` when SciPy is
+      linked against Intel MKL 2024.2.0 to 2025.0.0 (e.g. Anaconda on
+      Windows), whose `dsteqr` routine breaks ARPACK
+    - `lb` condenses out the dofs where `KG` is null and solves small
+      condensed problems with a dense solver
+    - `lb` verifies the eigenpairs of the sparse solver, raising an error
+      instead of returning wrong results
+    - The sparse solver of `lb` returns the load multipliers sorted as the
+      dense solver
     - Newton-Raphson with full Newton iterations and a relative convergence
       criterion by default, reaching quadratic convergence with exact tangent
       stiffness matrices

{structsolve-0.4.0 → structsolve-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structsolve"
-version = "0.4.0"
+version = "0.4.2"
 description = "Structural analysis solvers"
 readme = "README.md"
 license = {text = "BSD-2-Clause"}

structsolve-0.4.2/structsolve/linear_buckling.py

@@ -0,0 +1,357 @@
+import warnings
+
+import numpy as np
+from scipy.sparse import csc_matrix, csr_matrix
+from scipy.sparse.linalg import eigsh, splu
+from scipy.linalg import eigh, LinAlgError
+
+from .logger import msg, warn
+from .sparseutils import remove_null_cols
+
+
+def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3):
+    r"""Shift of the Cayley mode used by :func:`lb`
+
+    With ``sigma > 0``, ``eigsh(A=KG, M=K, sigma=sigma, mode='cayley',
+    which='SM')`` returns the eigenvalues `\mu` of ``KG u = mu K u`` with the
+    smallest `|(\mu + \sigma)/(\mu - \sigma)|`. This ordering selects the most
+    negative `\mu`, i.e. the lowest positive load multipliers `-1/\mu`, only
+    when `\sigma` is larger than `|\mu|` of these critical eigenvalues.
+    Otherwise the eigenvalues closest to `-\sigma` are returned.
+
+    The largest `|\mu|` is estimated with power iterations on
+    `[K]^{-1}[K_G]`, whose norm ratio in the `[K]`-norm increases towards the
+    largest `|\mu|`, and multiplied by ``safety``. The default shift ``1.`` is
+    returned when ``K`` is singular, not positive definite, or the linear
+    solution is inaccurate.
+
+    """
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            lu = splu(csc_matrix(K))
+        x = np.random.RandomState(42).randn(K.shape[0])
+        Kx = K @ x
+        mu_max = 0.
+        for i in range(max_iter):
+            xKx = x @ Kx
+            if not np.isfinite(xKx) or xKx <= 0:
+                return 1.
+            x = x / np.sqrt(xKx)
+            rhs = KG @ x
+            y = lu.solve(rhs)
+            Ky = K @ y
+            if i == 0:
+                residual = np.linalg.norm(Ky - rhs)
+                if not residual <= 1e-6 * np.linalg.norm(rhs):
+                    return 1.
+            # ||y||_K / ||x||_K, with ||x||_K = 1
+            ratio = np.sqrt(abs(y @ Ky))
+            if not np.isfinite(ratio) or ratio == 0:
+                return 1.
+            converged = i > 0 and ratio - mu_max <= rel_tol * ratio
+            mu_max = max(mu_max, ratio)
+            if converged:
+                break
+            x, Kx = y, Ky
+        return safety * mu_max
+    except Exception:
+        return 1.
+
+
+def _is_positive_definite(A):
+    """Tells if the symmetric sparse matrix ``A`` is positive definite
+
+    ``A`` is factorized with a symmetric permutation and without row
+    interchanges. The Gaussian elimination of a positive definite matrix
+    never finds a zero or negative pivot, and by Sylvester's law of inertia
+    any negative pivot means a negative eigenvalue of ``A``.
+
+    """
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            lu = splu(csc_matrix(A), permc_spec='MMD_AT_PLUS_A',
+                      diag_pivot_thresh=0., options=dict(SymmetricMode=True))
+    except RuntimeError:
+        # exactly singular
+        return False
+    if not np.array_equal(lu.perm_r, lu.perm_c):
+        # a zero pivot forced a row interchange
+        return False
+    return bool(np.all(lu.U.diagonal() > 0))
+
+
+def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4):
+    r"""Verify the eigenpairs of `([K] + \lambda [K_G])\{u\} = \{0\}`
+
+    - The relative residual
+      `||K u + \lambda K_G u|| / (||K u|| + |\lambda| ||K_G u||)` of every
+      eigenpair with a finite `\lambda` must not be larger than ``rtol``.
+    - No load multiplier is missing below the lowest positive `\lambda_1`
+      of ``eigvals``: when ``K`` is positive definite, `[K] + s [K_G]` with
+      `s = \lambda_1 (1 - min\_rel\_gap)` must also be positive definite.
+
+    Returns
+    -------
+    error : str or None
+        Description of the failed check, ``None`` when all checks passed.
+
+    """
+    finite = np.isfinite(eigvals)
+    if not np.any(finite):
+        return 'no finite load multiplier was found'
+    lam = eigvals[finite]
+    u = eigvecs[:, finite]
+    Ku = K @ u
+    KGu = KG @ u
+    num = np.linalg.norm(Ku + KGu*lam, axis=0)
+    den = np.linalg.norm(Ku, axis=0) + np.abs(lam)*np.linalg.norm(KGu, axis=0)
+    residual = np.full(lam.shape, np.inf)
+    np.divide(num, den, out=residual, where=den > 0)
+    if not np.all(residual <= rtol):
+        i = np.argmax(np.nan_to_num(residual, nan=np.inf))
+        return ('relative residual {0:.2e} > {1:.1e} for the load multiplier '
+                '{2}'.format(residual[i], rtol, lam[i]))
+    positive = lam[lam > 0]
+    if positive.size and _is_positive_definite(K):
+        s = positive.min()*(1 - min_rel_gap)
+        if not _is_positive_definite(K + s*KG):
+            return ('at least one load multiplier lower than {0} is missing'
+                    .format(positive.min()))
+    return None
+
+
+def _sort_eigenpairs(mu, eigvecs):
+    r"""Sort by increasing `\mu`, i.e. the positive `\lambda = -1/\mu` first
+    in increasing order, as returned by :func:`scipy.linalg.eigh`"""
+    order = np.argsort(mu, kind='stable')
+    return mu[order], eigvecs[:, order]
+
+
+def _eigh_condensed(K, KG, k):
+    r"""Dense solution after condensing out the dofs where ``KG`` is null
+
+    With the dofs split in `b`, where `[K_G]` has non-null rows, and `a`,
+    where it does not, the static condensation of the `a` dofs gives:
+
+    .. math::
+
+        ([K_{bb}] - [K_{ba}][K_{aa}]^{-1}[K_{ab}]
+         + \lambda [K_{G_{bb}}])\{u_b\} = \{0\}, \qquad
+        \{u_a\} = -[K_{aa}]^{-1}[K_{ab}]\{u_b\}
+
+    solved with :func:`scipy.linalg.eigh`, which requires a positive
+    definite Schur complement. Returns the ``k`` lowest eigenvalues `\mu` of
+    `K_G u = \mu K u` and the corresponding eigenvectors.
+
+    """
+    active = np.asarray(abs(KG).sum(axis=1)).ravel() > 0
+    b = np.flatnonzero(active)
+    a = np.flatnonzero(~active)
+    if b.size == 0:
+        raise ValueError('KG is a null matrix')
+    K = csr_matrix(K)
+    KGbb = csr_matrix(KG)[b, :][:, b].toarray()
+    S = K[b, :][:, b].toarray()
+    if a.size:
+        Kab = csc_matrix(K[a, :][:, b])
+        Kba = K[b, :][:, a]
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            lu = splu(csc_matrix(K[a, :][:, a]))
+        # solving blocks of right-hand sides with at most ~1e7 entries
+        chunk = max(1, int(1e7) // a.size)
+        for j0 in range(0, b.size, chunk):
+            j1 = min(j0 + chunk, b.size)
+            X = lu.solve(Kab[:, j0:j1].toarray())
+            S[:, j0:j1] -= Kba @ X
+    mu, ub = eigh(a=0.5*(KGbb + KGbb.T), b=0.5*(S + S.T))
+    k = min(k, b.size)
+    ub = ub[:, :k]
+    eigvecs = np.zeros((K.shape[0], k), dtype=ub.dtype)
+    eigvecs[b, :] = ub
+    if a.size:
+        eigvecs[a, :] = -lu.solve(np.asarray(Kab @ ub))
+    return mu[:k], eigvecs
+
+
+def _eigsh_cayley(K, KG, k, tol, silent):
+    """Solution with :func:`scipy.sparse.linalg.eigsh` in Cayley mode"""
+    sigma = _estimate_sigma(K, KG)
+    msg('sigma={0}'.format(sigma), level=4, silent=silent)
+    k = min(k, K.shape[0] - 2)
+    mu, eigvecs = eigsh(A=KG, k=k, which='SM', M=K, tol=tol, sigma=sigma,
+                        mode='cayley')
+    return _sort_eigenpairs(mu, eigvecs)
+
+
+def lb(K, KG, tol=0, sparse_solver=True, silent=False,
+       num_eigvalues=25, num_eigvalues_print=5,
+       skip_null_cols=False, max_dense_size=2000, check_rtol=1e-3):
+    r"""Linear buckling analysis
+
+    Calculates the eigenvalues `\lambda` and eigenvectors `\{u\}` of the
+    eigenvalue problem:
+
+    .. math::
+
+        ([K] + \lambda [K_G])\{u\} = \{0\}
+
+    where `\lambda` is the load multiplier of the load state that generated
+    `[K_G]`. It can also be used for more general eigenvalue analyses, e.g.
+    if ``K`` is the tangent stiffness matrix of a given load state. The null
+    rows and columns of ``K`` are removed from both matrices before solving
+    the eigenvalue problem, unless ``skip_null_cols=True``.
+
+    Parameters
+    ----------
+    K : sparse_matrix
+        Stiffness matrix. Should include all constant terms of the initial
+        stress stiffness matrix, aerodynamic matrix and so forth when
+        applicable.
+    KG : sparse_matrix
+        Initial stress stiffness matrix that multiplies the load multiplier
+        `\lambda` of the eigenvalue problem.
+    tol : float, optional
+        A float tolerance passed to :func:`scipy.sparse.linalg.eigsh`.
+    sparse_solver : bool, optional
+        With ``True``, when ``KG`` has at most ``max_dense_size`` non-null
+        rows, the other dofs (typically the in-plane dofs) are condensed out
+        with a sparse factorization of ``K`` and the condensed problem is
+        solved with :func:`scipy.linalg.eigh`. Otherwise, or when this
+        solution fails, :func:`scipy.sparse.linalg.eigsh` solves the full
+        problem in Cayley mode, with a shift estimated from the matrices.
+        The eigenpairs are verified as described in the Notes, and
+        ``num_eigvalues`` load multipliers are returned.
+        With ``False``, :func:`scipy.linalg.eigh` solves the full problem,
+        returning all load multipliers, and requires a positive definite
+        ``K``.
+    silent : bool, optional
+        A boolean to tell whether the log messages should be printed.
+    num_eigvalues : int, optional
+        Number of load multipliers calculated with the sparse solver, and
+        number of returned eigenvectors.
+    num_eigvalues_print : int, optional
+        Number of eigenvalues to print.
+    skip_null_cols : bool, optional
+        If True, skip the removal of null columns from the matrices.
+        Use only when K is known to be non-singular.
+    max_dense_size : int, optional
+        Maximum number of non-null rows of ``KG`` for which the sparse solver
+        solves the condensed problem with :func:`scipy.linalg.eigh`. Use
+        ``0`` to always use :func:`scipy.sparse.linalg.eigsh`.
+    check_rtol : float, optional
+        Maximum relative residual of the eigenpairs of the sparse solver,
+        see the Notes.
+
+    Returns
+    -------
+    eigvals : ndarray
+        The load multipliers `\lambda`, calculated as ``-1/eigval`` from the
+        eigenvalues ``eigval`` of ``KG u = eigval K u``. The positive load
+        multipliers come first in increasing order, followed by the negative
+        ones, for both solvers.
+    eigvecs : ndarray
+        The `i^{th}` eigenvector is ``eigvecs[:, i]``, with the size of the
+        original matrices. Only ``num_eigvalues`` eigenvectors are returned.
+
+    Raises
+    ------
+    RuntimeError
+        When no eigenpairs of the sparse solver pass the verification.
+
+    Notes
+    -----
+    The eigenpairs of the sparse solver are verified as follows:
+
+    - the relative residual
+      `||K u + \lambda K_G u|| / (||K u|| + |\lambda| ||K_G u||)` of each
+      eigenpair must not be larger than ``check_rtol``;
+    - when ``K`` is positive definite, `[K] + s [K_G]` must also be positive
+      definite for `s` slightly lower than the lowest positive load
+      multiplier found, i.e. no lower load multiplier was missed. The
+      factorization is done with SuperLU, without row interchanges.
+
+    When the condensed dense solution fails the verification,
+    :func:`scipy.sparse.linalg.eigsh` is tried, and a ``RuntimeError`` is
+    raised when it also fails.
+
+    ARPACK, used by :func:`scipy.sparse.linalg.eigsh`, returns wrong
+    eigenpairs at random, without any error, when linked against Intel MKL
+    2024.2.0 to 2025.0.0, e.g. in some Anaconda builds of SciPy: the
+    ``dsteqr`` routine of these MKL versions returns wrong eigenvectors for
+    matrices larger than 32 x 32. MKL 2025.0.1 or newer is not affected.
+
+    """
+    msg('Running linear buckling analysis...', silent=silent)
+
+    msg('Eigenvalue solver... ', level=2, silent=silent)
+
+    size = KG.shape[0]
+    if skip_null_cols:
+        used_cols = None
+    else:
+        K, KG, used_cols = remove_null_cols(K, KG, silent=silent)
+    if sparse_solver:
+        K = csr_matrix(K)
+        KG = csr_matrix(KG)
+        num_active = int(np.count_nonzero(abs(KG).sum(axis=1)))
+        solvers = []
+        if num_active <= max_dense_size:
+            solvers.append(('eigh() with condensed dofs',
+                            lambda: _eigh_condensed(K, KG, num_eigvalues)))
+        solvers.append(('eigsh()',
+                        lambda: _eigsh_cayley(K, KG, num_eigvalues, tol,
+                                              silent)))
+        errors = []
+        for name, solver in solvers:
+            msg('{0} solver ({1} of {2} rows of KG are non-null)...'.format(
+                name, num_active, K.shape[0]), level=3, silent=silent)
+            try:
+                eigvals, peigvecs = solver()
+                with np.errstate(divide='ignore'):
+                    error = _check_eigenpairs(K, KG, -1./eigvals, peigvecs,
+                                              check_rtol)
+            except (LinAlgError, RuntimeError, ValueError) as e:
+                error = '{0}: {1}'.format(type(e).__name__, e)
+            if error is None:
+                msg('finished!', level=3, silent=silent)
+                break
+            warn('{0} solver failed: {1}'.format(name, error), level=3,
+                 silent=silent)
+            errors.append('{0} solver: {1}'.format(name, error))
+        else:
+            raise RuntimeError(
+                'Linear buckling analysis failed, no eigenvalue solver passed '
+                'the verification ({0}). When ARPACK is linked against Intel '
+                'MKL 2024.2.0 to 2025.0.0, update MKL to 2025.0.1 or newer. '
+                'Otherwise, try sparse_solver=False or a larger '
+                'max_dense_size.'.format('; '.join(errors)))
+
+    else:
+        K = K.toarray()
+        KG = KG.toarray()
+        msg('eigh() solver...', level=3, silent=silent)
+        eigvals, peigvecs = eigh(a=KG, b=K)
+        msg('finished!', level=3, silent=silent)
+
+    num_eigvecs = min(num_eigvalues, peigvecs.shape[1])
+    if used_cols is not None:
+        eigvecs = np.zeros((size, num_eigvecs), dtype=peigvecs.dtype)
+        eigvecs[used_cols, :] = peigvecs[:, :num_eigvecs]
+    else:
+        eigvecs = peigvecs[:, :num_eigvecs]
+
+    with np.errstate(divide='ignore'):
+        eigvals = -1./eigvals
+
+    msg('finished!', level=2, silent=silent)
+
+    msg('first {0} eigenvalues:'.format(num_eigvalues_print), level=1,
+        silent=silent)
+
+    for eig in eigvals[:num_eigvalues_print]:
+        msg('{0}'.format(eig), level=2, silent=silent)
+
+    return eigvals, eigvecs

{structsolve-0.4.0 → structsolve-0.4.2/structsolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.4.0
+Version: 0.4.2
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -41,8 +41,7 @@ Github Actions status:
 
 Coverage status:
 [![codecov](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml/badge.svg)](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml)
-[![Codecov Status](https://codecov.io/gh/saullocastro/structsolve/branch/master/graph/badge.svg)](https://codecov.io/gh/saullocastro/structsolve)
-
+[![Codecov Status](https://codecov.io/gh/saullocastro/structsolve/branch/main/graph/badge.svg?token=NNHK0SFZNH)](https://codecov.io/gh/saullocastro/structsolve)
 
 Structural analysis solvers tailored for semi-analytical models
 ===============================================================
@@ -61,7 +60,7 @@ Currently these solvers are pretty much compatible with my other repositories
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.2). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -76,7 +75,18 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.4.0 (2026-09-17)
+* version 0.4.2 (2026-09-17)
+    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
+      return buckling loads higher than the critical ones
+    - Fixed wrong buckling loads of the sparse solver of `lb` when SciPy is
+      linked against Intel MKL 2024.2.0 to 2025.0.0 (e.g. Anaconda on
+      Windows), whose `dsteqr` routine breaks ARPACK
+    - `lb` condenses out the dofs where `KG` is null and solves small
+      condensed problems with a dense solver
+    - `lb` verifies the eigenpairs of the sparse solver, raising an error
+      instead of returning wrong results
+    - The sparse solver of `lb` returns the load multipliers sorted as the
+      dense solver
     - Newton-Raphson with full Newton iterations and a relative convergence
       criterion by default, reaching quadratic convergence with exact tangent
       stiffness matrices

structsolve-0.4.2/tests/test_linear_buckling.py

@@ -0,0 +1,352 @@
+"""Tests for structsolve.linear_buckling: lb()"""
+import os
+
+import numpy as np
+import pytest
+from scipy.sparse import csc_matrix
+
+from structsolve import lb
+
+
+def test_lb_simple_eigenvalue():
+    """Test linear buckling with a well-conditioned system
+
+    lb solves: [K] + lambda[KG] = 0
+    For K = diag(2,4,6,...) and KG = I, lambda_i = -K_ii
+    lb returns -1/eigvals from eigsh(A=KG, M=K), giving positive load factors.
+    """
+    n = 10
+    k_diag = np.arange(2, 2 * n + 2, 2, dtype=float)
+    K = csc_matrix(np.diag(k_diag))
+    KG = csc_matrix(np.eye(n))
+
+    eigvals, eigvecs = lb(K, KG, silent=True, num_eigvalues=5,
+                          sparse_solver=True)
+    # lb returns eigenvalues (load multipliers), verify we get results
+    assert len(eigvals) >= 5
+    assert eigvecs.shape[0] == n
+
+
+def test_lb_dense_solver():
+    """Test lb with sparse_solver=False
+
+    lb solves [K] + lambda[KG] = 0, returning -1/eigvals.
+    For K=2I, KG=I: eigsh gives eigval=0.5, so lb returns -1/0.5 = -2.
+    The dense solver (eigh) with b=K gives eigvals with the same sign convention.
+    """
+    n = 10
+    K = csc_matrix(np.eye(n) * 2.0)
+    KG = csc_matrix(np.eye(n))
+
+    eigvals, eigvecs = lb(K, KG, silent=True, num_eigvalues=5,
+                          sparse_solver=False)
+    np.testing.assert_allclose(eigvals[:5], -2.0, rtol=1e-6)
+
+
+@pytest.mark.parametrize('max_dense_size', [0, 2000])
+def test_lb_sparse_shift_mixed_spectrum(max_dense_size):
+    """Sparse and dense lb agree when the load multipliers have mixed signs
+
+    Regression test: the shift of the sparse solver was a single Rayleigh
+    quotient, in which the positive and negative eigenvalues of
+    ``KG u = mu K u`` cancel. The shift landed below the critical ``|mu|``
+    and eigsh returned the load multipliers near ``1/sigma`` instead of the
+    lowest ones. With ``max_dense_size=0`` eigsh is always used.
+    """
+    from scipy.sparse import diags
+    from structsolve.linear_buckling import _estimate_sigma
+
+    n = 80
+    k = np.linspace(1e6, 5e6, n)
+    lambdas = np.concatenate([[1.0, 1.0, 1.1, 1.2],
+                              np.linspace(1.5, 4., 36),
+                              -np.linspace(1.5, 4., 40)])
+    mu = -1. / lambdas
+    K = diags(k).tocsc()
+    KG = diags(mu * k).tocsc()
+
+    # the shift must bound the largest |mu| of the critical eigenvalues
+    assert _estimate_sigma(K, KG) >= np.abs(mu).max()
+
+    eig_sparse, _ = lb(K, KG, silent=True, num_eigvalues=10,
+                       max_dense_size=max_dense_size)
+    eig_dense, _ = lb(K, KG, silent=True, sparse_solver=False)
+    np.testing.assert_allclose(eig_sparse[:4], [1.0, 1.0, 1.1, 1.2],
+                               rtol=1e-8)
+    np.testing.assert_allclose(eig_sparse[:4], eig_dense[:4], rtol=1e-8)
+
+
+DATA = os.path.join(os.path.dirname(__file__), 'data')
+
+# K and KG of panels models, null rows and columns removed, with the
+# critical load multipliers of the dense solver
+SAVED_MATRICES = [
+    ('plate_ssss_Nxx', [157.5386, 226.3470, 232.5623]),
+    ('cylinder_5panels', [473.1924, 473.1924, 478.6168]),
+]
+
+
+def load_saved_matrices(name):
+    from scipy.sparse import load_npz
+    K = load_npz(os.path.join(DATA, '%s_K.npz' % name)).tocsr()
+    KG = load_npz(os.path.join(DATA, '%s_KG.npz' % name)).tocsr()
+    return K, KG
+
+
+def relative_residuals(K, KG, eigvals, eigvecs):
+    Ku = K @ eigvecs
+    KGu = KG @ eigvecs
+    return (np.linalg.norm(Ku + KGu*eigvals, axis=0)
+            / (np.linalg.norm(Ku, axis=0)
+               + np.abs(eigvals)*np.linalg.norm(KGu, axis=0)))
+
+
+@pytest.mark.parametrize('name, ref', SAVED_MATRICES)
+def test_lb_saved_matrices_sparse_solver(name, ref):
+    """Regression test: ARPACK linked against Intel MKL 2024.2.0 to 2025.0.0
+    returned wrong load multipliers at random, e.g. with the Anaconda builds
+    of SciPy. The default sparse solver condenses out the dofs where KG is
+    null and verifies the eigenpairs"""
+    K, KG = load_saved_matrices(name)
+    eig_dense, _ = lb(K, KG, silent=True, sparse_solver=False)
+    np.testing.assert_allclose(eig_dense[:3], ref, rtol=1e-5)
+    for trial in range(3):
+        eigvals, eigvecs = lb(K, KG, silent=True)
+        assert eigvals.shape == (25,)
+        assert eigvecs.shape == (K.shape[0], 25)
+        np.testing.assert_allclose(eigvals, eig_dense[:25], rtol=1e-6)
+        assert np.all(relative_residuals(K, KG, eigvals, eigvecs) < 1e-6)
+
+
+@pytest.mark.parametrize('name, ref', SAVED_MATRICES)
+def test_lb_saved_matrices_eigsh_never_wrong(name, ref):
+    """With max_dense_size=0 only eigsh is used, which either returns the
+    correct load multipliers or raises a RuntimeError, when the eigenpairs
+    returned by ARPACK are wrong"""
+    K, KG = load_saved_matrices(name)
+    for trial in range(3):
+        try:
+            eigvals, eigvecs = lb(K, KG, silent=True, max_dense_size=0)
+        except RuntimeError as e:
+            assert 'verification' in str(e)
+            continue
+        np.testing.assert_allclose(eigvals[:3], ref, rtol=1e-5)
+        assert np.all(eigvals[:-1] <= eigvals[1:])
+
+
+def test_lb_check_eigenpairs():
+    """The verification detects wrong eigenpairs and a missing lowest load
+    multiplier"""
+    from structsolve.linear_buckling import _check_eigenpairs, _eigh_condensed
+
+    K, KG = load_saved_matrices('plate_ssss_Nxx')
+    mu, eigvecs = _eigh_condensed(K, KG, 10)
+    eigvals = -1./mu
+    assert _check_eigenpairs(K, KG, eigvals, eigvecs, 1e-3) is None
+
+    # eigenvectors of other eigenvalues
+    error = _check_eigenpairs(K, KG, eigvals, eigvecs[:, ::-1], 1e-3)
+    assert 'relative residual' in error
+
+    # wrong eigenvalues
+    error = _check_eigenpairs(K, KG, eigvals*1.01, eigvecs, 1e-3)
+    assert 'relative residual' in error
+
+    # lowest load multiplier missing
+    error = _check_eigenpairs(K, KG, eigvals[1:], eigvecs[:, 1:], 1e-3)
+    assert 'missing' in error
+
+    # both equal critical load multipliers missing
+    K, KG = load_saved_matrices('cylinder_5panels')
+    mu, eigvecs = _eigh_condensed(K, KG, 10)
+    eigvals = -1./mu
+    assert _check_eigenpairs(K, KG, eigvals, eigvecs, 1e-3) is None
+    error = _check_eigenpairs(K, KG, eigvals[2:], eigvecs[:, 2:], 1e-3)
+    assert 'missing' in error
+
+
+def test_lb_sparse_raises_when_verification_fails(monkeypatch):
+    """A RuntimeError is raised instead of returning wrong eigenpairs"""
+    import structsolve.linear_buckling as linear_buckling
+
+    K, KG = load_saved_matrices('plate_ssss_Nxx')
+
+    def wrong_eigsh(K, KG, k, tol, silent):
+        rng = np.random.RandomState(0)
+        return -rng.rand(k), rng.randn(K.shape[0], k)
+
+    monkeypatch.setattr(linear_buckling, '_eigsh_cayley', wrong_eigsh)
+    with pytest.raises(RuntimeError, match='verification'):
+        lb(K, KG, silent=True, max_dense_size=0)
+    # the condensed dense solution is used first
+    eigvals, _ = lb(K, KG, silent=True)
+    np.testing.assert_allclose(eigvals[0], 157.5386, rtol=1e-5)
+
+
+@pytest.mark.parametrize('max_dense_size', [0, 2000])
+def test_lb_sparse_sorted_as_dense(max_dense_size):
+    """The sparse solver returns the positive load multipliers first, in
+    increasing order, followed by the negative ones, as the dense solver"""
+    from scipy.sparse import diags
+
+    n = 40
+    k = np.linspace(1., 3., n)
+    rng = np.random.RandomState(1)
+    lambdas = rng.permutation(np.concatenate([np.linspace(1., 20., 5),
+                                              -np.linspace(1., 20., n - 5)]))
+    K = diags(k).tocsr()
+    KG = diags(-k/lambdas).tocsr()
+    eig_sparse, eigvecs = lb(K, KG, silent=True, num_eigvalues=10,
+                             max_dense_size=max_dense_size)
+    eig_dense, _ = lb(K, KG, silent=True, sparse_solver=False)
+    np.testing.assert_allclose(eig_sparse, eig_dense[:10], rtol=1e-8)
+    np.testing.assert_allclose(eig_sparse[:5], np.linspace(1., 20., 5),
+                               rtol=1e-8)
+    assert np.all(eig_sparse[5:] < 0)
+    assert np.all(relative_residuals(K, KG, eig_sparse, eigvecs) < 1e-8)
+
+
+def test_lb_sparse_null_KG_rows_and_null_cols():
+    """Condensed solution with null rows of KG and null rows of K, returning
+    eigenvectors with the size of the original matrices"""
+    from scipy.sparse import random as sprandom, identity, bmat
+
+    n = 60
+    A = sprandom(n, n, density=0.1, random_state=2)
+    K = (A @ A.T + identity(n)).tocsr()
+    B = sprandom(n//3, n//3, density=0.3, random_state=3)
+    KG = bmat([[-(B @ B.T + 0.1*identity(n//3)), None],
+               [None, csc_matrix((n - n//3, n - n//3))]]).tocsr()
+    # adding two null dofs
+    Z = csc_matrix((2, 2))
+    K2 = bmat([[K, None], [None, Z]]).tocsr()
+    KG2 = bmat([[KG, None], [None, Z]]).tocsr()
+    eig_sparse, eigvecs = lb(K2, KG2, silent=True, num_eigvalues=10)
+    eig_dense, _ = lb(K2, KG2, silent=True, sparse_solver=False)
+    np.testing.assert_allclose(eig_sparse, eig_dense[:10], rtol=1e-8)
+    assert eigvecs.shape == (n + 2, 10)
+    assert np.all(eigvecs[n:, :] == 0)
+    assert np.all(relative_residuals(K2, KG2, eig_sparse, eigvecs) < 1e-8)
+
+
+def test_lb_sparse_singular_K():
+    """The shift falls back to 1 when K is singular"""
+    from structsolve.linear_buckling import _estimate_sigma
+
+    K = csc_matrix(np.diag([1., 2., 0., 4., 5.]))
+    KG = csc_matrix(np.eye(5))
+    assert _estimate_sigma(K, KG) == 1.
+
+
+def test_lb_plate_buckling_fsdt():
+    """Test plate buckling (FSDT) based on semi-analytical Ritz method.
+
+    Reference: notebook BucklingPlates-FSDT.ipynb from the buckling repository.
+    Uses Legendre polynomials as basis functions with Gauss-Legendre quadrature.
+    """
+    from scipy.special import roots_legendre
+    from composites import isotropic_plate
+    from buckling.legendre import vecf, vecfxi
+
+    m1 = 20
+    m2 = 10
+    N = 3 * m1 * m2
+
+    pts1, weights1 = roots_legendre(2 * m1 - 1)
+    pts2, weights2 = roots_legendre(2 * m2 - 1)
+
+    E = 200.e9
+    nu = 0.3
+
+    # BCs: w simply supported, phi free
+    wxit1, wxir1, wxit2, wxir2 = 0, 1, 0, 1
+    wetat1, wetar1, wetat2, wetar2 = 0, 1, 0, 1
+    xit1, xir1, xit2, xir2 = 1, 1, 1, 1
+    etat1, etar1, etat2, etar2 = 1, 1, 1, 1
+
+    a, b, h = 0.3, 0.1, 0.003
+    prop = isotropic_plate(thickness=h, E=E, nu=nu)
+
+    Nxxhat = -100.
+
+    Swx = np.zeros(N)
+    Swy = np.zeros(N)
+    Sphix = np.zeros(N)
+    Sphiy = np.zeros(N)
+    Sphixx = np.zeros(N)
+    Sphixy = np.zeros(N)
+    Sphiyx = np.zeros(N)
+    Sphiyy = np.zeros(N)
+
+    buff = np.zeros((N, N))
+    K = np.zeros((N, N))
+    KG = np.zeros((N, N))
+
+    def addouter(matrix, vec1, vec2):
+        np.outer(vec1, vec2, out=buff)
+        matrix += buff
+
+    for xi, wxi in zip(pts1, weights1):
+        wP_xi = vecf(m1, xi, wxit1, wxir1, wxit2, wxir2)
+        wPx_xi = vecfxi(m1, xi, wxit1, wxir1, wxit2, wxir2)
+        P_xi = vecf(m1, xi, xit1, xir1, xit2, xir2)
+        Px_xi = vecfxi(m1, xi, xit1, xir1, xit2, xir2)
+
+        for eta, weta in zip(pts2, weights2):
+            wP_eta = vecf(m2, eta, wetat1, wetar1, wetat2, wetar2)
+            wPx_eta = vecfxi(m2, eta, wetat1, wetar1, wetat2, wetar2)
+            P_eta = vecf(m2, eta, etat1, etar1, etat2, etar2)
+            Px_eta = vecfxi(m2, eta, etat1, etar1, etat2, etar2)
+
+            weight = wxi * weta
+
+            Pi, Pj = np.meshgrid(P_xi, P_eta, indexing='ij')
+            Sphix[m1*m2:2*m1*m2] = (Pi * Pj).flatten()
+            Sphiy[2*m1*m2:] = (Pi * Pj).flatten()
+
+            Pxi, Pj = np.meshgrid(wPx_xi, wP_eta, indexing='ij')
+            Swx[:m1*m2] = (Pxi * Pj * (2 / a)).flatten()
+
+            Pxi, Pj = np.meshgrid(Px_xi, P_eta, indexing='ij')
+            Sphixx[m1*m2:2*m1*m2] = (Pxi * Pj * (2 / a)).flatten()
+            Sphiyx[2*m1*m2:] = (Pxi * Pj * (2 / a)).flatten()
+
+            Pi, Pxj = np.meshgrid(wP_xi, wPx_eta, indexing='ij')
+            Swy[:m1*m2] = (Pi * Pxj * (2 / b)).flatten()
+
+            Pi, Pxj = np.meshgrid(P_xi, Px_eta, indexing='ij')
+            Sphixy[m1*m2:2*m1*m2] = (Pi * Pxj * (2 / b)).flatten()
+            Sphiyy[2*m1*m2:] = (Pi * Pxj * (2 / b)).flatten()
+
+            e1xx = Sphixx
+            e1yy = Sphiyy
+            e1xy = Sphixy + Sphiyx
+
+            g0yz = Sphiy + Swy
+            g0xz = Sphix + Swx
+
+            Mxx = prop.D11 * e1xx + prop.D12 * e1yy + prop.D16 * e1xy
+            Myy = prop.D12 * e1xx + prop.D22 * e1yy + prop.D26 * e1xy
+            Mxy = prop.D16 * e1xx + prop.D26 * e1yy + prop.D66 * e1xy
+
+            Qy = prop.A44 * g0yz + prop.A45 * g0xz
+            Qx = prop.A45 * g0yz + prop.A55 * g0xz
+
+            detJ = a * b / 4
+
+            addouter(K, detJ * weight * Mxx, e1xx)
+            addouter(K, detJ * weight * Myy, e1yy)
+            addouter(K, detJ * weight * Mxy, e1xy)
+            addouter(K, detJ * weight * Qy, g0yz)
+            addouter(K, detJ * weight * Qx, g0xz)
+
+            addouter(KG, detJ * weight * Nxxhat * Swx, Swx)
+
+    eigvals, eigvecs = lb(csc_matrix(K), csc_matrix(KG), silent=True)
+
+    D = E * h**3 / (12 * (1 - nu**2))
+    Ncr_analytical = 4 * np.pi**2 * D / b**2
+    Ncr_computed = eigvals[0] * abs(Nxxhat)
+
+    # FSDT gives slightly lower Ncr than CLPT due to shear deformation
+    np.testing.assert_allclose(Ncr_computed, Ncr_analytical, rtol=0.02)

structsolve-0.4.0/structsolve/linear_buckling.py

@@ -1,132 +0,0 @@
-import warnings
-
-import numpy as np
-from scipy.sparse.linalg import eigsh, spsolve
-from scipy.linalg import eigh
-
-from .logger import msg, warn
-from .sparseutils import remove_null_cols
-
-
-def _estimate_sigma(K, KG):
-    try:
-        rhs = KG @ np.random.RandomState(42).randn(K.shape[0])
-        with warnings.catch_warnings(record=True) as caught:
-            warnings.simplefilter("always")
-            y = spsolve(K, rhs)
-        if any(issubclass(w.category, (RuntimeWarning, Warning))
-               and "singular" in str(w.message).lower() for w in caught):
-            return 1.
-        residual = np.linalg.norm(K @ y - rhs)
-        if residual > 1e-6 * np.linalg.norm(rhs):
-            return 1.
-        sigma = abs((y @ KG @ y) / (y @ K @ y))
-        if not np.isfinite(sigma) or sigma == 0:
-            return 1.
-        return sigma
-    except Exception:
-        return 1.
-
-def lb(K, KG, tol=0, sparse_solver=True, silent=False,
-       num_eigvalues=25, num_eigvalues_print=5,
-       skip_null_cols=False):
-    r"""Linear buckling analysis
-
-    Calculates the eigenvalues `\lambda` and eigenvectors `\{u\}` of the
-    eigenvalue problem:
-
-    .. math::
-
-        ([K] + \lambda [K_G])\{u\} = \{0\}
-
-    where `\lambda` is the load multiplier of the load state that generated
-    `[K_G]`. It can also be used for more general eigenvalue analyses, e.g.
-    if ``K`` is the tangent stiffness matrix of a given load state. The null
-    rows and columns of ``K`` are removed from both matrices before solving
-    the eigenvalue problem, unless ``skip_null_cols=True``.
-
-    Parameters
-    ----------
-    K : sparse_matrix
-        Stiffness matrix. Should include all constant terms of the initial
-        stress stiffness matrix, aerodynamic matrix and so forth when
-        applicable.
-    KG : sparse_matrix
-        Initial stress stiffness matrix that multiplies the load multiplier
-        `\lambda` of the eigenvalue problem.
-    tol : float, optional
-        A float tolerance passed to the eigenvalue solver.
-    sparse_solver : bool, optional
-        Tells if solver :func:`scipy.sparse.linalg.eigsh` (``True``) or
-        :func:`scipy.linalg.eigh` (``False``) should be used. The sparse
-        solver uses the Cayley mode with a shift estimated from the matrices
-        and calculates ``num_eigvalues`` eigenvalues. The dense solver
-        calculates all eigenvalues and requires a positive definite ``K``.
-    silent : bool, optional
-        A boolean to tell whether the log messages should be printed.
-    num_eigvalues : int, optional
-        Number of calculated eigenvalues with the sparse solver, limited to
-        the size of ``KG`` minus 2, and number of returned eigenvectors.
-    num_eigvalues_print : int, optional
-        Number of eigenvalues to print.
-    skip_null_cols : bool, optional
-        If True, skip the removal of null columns from the matrices.
-        Use only when K is known to be non-singular.
-
-    Returns
-    -------
-    eigvals : ndarray
-        The load multipliers `\lambda`, calculated as ``-1/eigval`` from the
-        eigenvalues ``eigval`` of ``KG u = eigval K u``. The dense solver
-        returns all load multipliers, the positive ones first in increasing
-        order.
-    eigvecs : ndarray
-        The `i^{th}` eigenvector is ``eigvecs[:, i]``, with the size of the
-        original matrices. Only ``num_eigvalues`` eigenvectors are returned.
-
-    """
-    msg('Running linear buckling analysis...', silent=silent)
-
-    msg('Eigenvalue solver... ', level=2, silent=silent)
-
-    k = min(num_eigvalues, KG.shape[0]-2)
-    size = KG.shape[0]
-    if skip_null_cols:
-        used_cols = None
-    else:
-        K, KG, used_cols = remove_null_cols(K, KG, silent=silent)
-    if sparse_solver:
-        mode = 'cayley'
-        sigma = _estimate_sigma(K, KG)
-        msg('eigsh() solver (sigma={0})...'.format(sigma), level=3, silent=silent)
-        eigvals, peigvecs = eigsh(A=KG, k=k,
-                which='SM', M=K, tol=tol, sigma=sigma, mode=mode)
-        msg('finished!', level=3, silent=silent)
-
-    else:
-        K = K.toarray()
-        KG = KG.toarray()
-        msg('eigh() solver...', level=3, silent=silent)
-        eigvals, peigvecs = eigh(a=KG, b=K)
-        msg('finished!', level=3, silent=silent)
-
-    if used_cols is not None:
-        eigvecs = np.zeros((size, num_eigvalues), dtype=peigvecs.dtype)
-        eigvecs[used_cols, :] = peigvecs[:, :num_eigvalues]
-    else:
-        eigvecs = peigvecs[:, :num_eigvalues]
-
-    eigvals = -1./eigvals
-
-    eigvals = eigvals
-    eigvecs = eigvecs
-
-    msg('finished!', level=2, silent=silent)
-
-    msg('first {0} eigenvalues:'.format(num_eigvalues_print), level=1,
-        silent=silent)
-
-    for eig in eigvals[:num_eigvalues_print]:
-        msg('{0}'.format(eig), level=2, silent=silent)
-
-    return eigvals, eigvecs

structsolve-0.4.0/tests/test_linear_buckling.py

@@ -1,155 +0,0 @@
-"""Tests for structsolve.linear_buckling: lb()"""
-import numpy as np
-import pytest
-from scipy.sparse import csc_matrix
-
-from structsolve import lb
-
-
-def test_lb_simple_eigenvalue():
-    """Test linear buckling with a well-conditioned system
-
-    lb solves: [K] + lambda[KG] = 0
-    For K = diag(2,4,6,...) and KG = I, lambda_i = -K_ii
-    lb returns -1/eigvals from eigsh(A=KG, M=K), giving positive load factors.
-    """
-    n = 10
-    k_diag = np.arange(2, 2 * n + 2, 2, dtype=float)
-    K = csc_matrix(np.diag(k_diag))
-    KG = csc_matrix(np.eye(n))
-
-    eigvals, eigvecs = lb(K, KG, silent=True, num_eigvalues=5,
-                          sparse_solver=True)
-    # lb returns eigenvalues (load multipliers), verify we get results
-    assert len(eigvals) >= 5
-    assert eigvecs.shape[0] == n
-
-
-def test_lb_dense_solver():
-    """Test lb with sparse_solver=False
-
-    lb solves [K] + lambda[KG] = 0, returning -1/eigvals.
-    For K=2I, KG=I: eigsh gives eigval=0.5, so lb returns -1/0.5 = -2.
-    The dense solver (eigh) with b=K gives eigvals with the same sign convention.
-    """
-    n = 10
-    K = csc_matrix(np.eye(n) * 2.0)
-    KG = csc_matrix(np.eye(n))
-
-    eigvals, eigvecs = lb(K, KG, silent=True, num_eigvalues=5,
-                          sparse_solver=False)
-    np.testing.assert_allclose(eigvals[:5], -2.0, rtol=1e-6)
-
-
-def test_lb_plate_buckling_fsdt():
-    """Test plate buckling (FSDT) based on semi-analytical Ritz method.
-
-    Reference: notebook BucklingPlates-FSDT.ipynb from the buckling repository.
-    Uses Legendre polynomials as basis functions with Gauss-Legendre quadrature.
-    """
-    from scipy.special import roots_legendre
-    from composites import isotropic_plate
-    from buckling.legendre import vecf, vecfxi
-
-    m1 = 20
-    m2 = 10
-    N = 3 * m1 * m2
-
-    pts1, weights1 = roots_legendre(2 * m1 - 1)
-    pts2, weights2 = roots_legendre(2 * m2 - 1)
-
-    E = 200.e9
-    nu = 0.3
-
-    # BCs: w simply supported, phi free
-    wxit1, wxir1, wxit2, wxir2 = 0, 1, 0, 1
-    wetat1, wetar1, wetat2, wetar2 = 0, 1, 0, 1
-    xit1, xir1, xit2, xir2 = 1, 1, 1, 1
-    etat1, etar1, etat2, etar2 = 1, 1, 1, 1
-
-    a, b, h = 0.3, 0.1, 0.003
-    prop = isotropic_plate(thickness=h, E=E, nu=nu)
-
-    Nxxhat = -100.
-
-    Swx = np.zeros(N)
-    Swy = np.zeros(N)
-    Sphix = np.zeros(N)
-    Sphiy = np.zeros(N)
-    Sphixx = np.zeros(N)
-    Sphixy = np.zeros(N)
-    Sphiyx = np.zeros(N)
-    Sphiyy = np.zeros(N)
-
-    buff = np.zeros((N, N))
-    K = np.zeros((N, N))
-    KG = np.zeros((N, N))
-
-    def addouter(matrix, vec1, vec2):
-        np.outer(vec1, vec2, out=buff)
-        matrix += buff
-
-    for xi, wxi in zip(pts1, weights1):
-        wP_xi = vecf(m1, xi, wxit1, wxir1, wxit2, wxir2)
-        wPx_xi = vecfxi(m1, xi, wxit1, wxir1, wxit2, wxir2)
-        P_xi = vecf(m1, xi, xit1, xir1, xit2, xir2)
-        Px_xi = vecfxi(m1, xi, xit1, xir1, xit2, xir2)
-
-        for eta, weta in zip(pts2, weights2):
-            wP_eta = vecf(m2, eta, wetat1, wetar1, wetat2, wetar2)
-            wPx_eta = vecfxi(m2, eta, wetat1, wetar1, wetat2, wetar2)
-            P_eta = vecf(m2, eta, etat1, etar1, etat2, etar2)
-            Px_eta = vecfxi(m2, eta, etat1, etar1, etat2, etar2)
-
-            weight = wxi * weta
-
-            Pi, Pj = np.meshgrid(P_xi, P_eta, indexing='ij')
-            Sphix[m1*m2:2*m1*m2] = (Pi * Pj).flatten()
-            Sphiy[2*m1*m2:] = (Pi * Pj).flatten()
-
-            Pxi, Pj = np.meshgrid(wPx_xi, wP_eta, indexing='ij')
-            Swx[:m1*m2] = (Pxi * Pj * (2 / a)).flatten()
-
-            Pxi, Pj = np.meshgrid(Px_xi, P_eta, indexing='ij')
-            Sphixx[m1*m2:2*m1*m2] = (Pxi * Pj * (2 / a)).flatten()
-            Sphiyx[2*m1*m2:] = (Pxi * Pj * (2 / a)).flatten()
-
-            Pi, Pxj = np.meshgrid(wP_xi, wPx_eta, indexing='ij')
-            Swy[:m1*m2] = (Pi * Pxj * (2 / b)).flatten()
-
-            Pi, Pxj = np.meshgrid(P_xi, Px_eta, indexing='ij')
-            Sphixy[m1*m2:2*m1*m2] = (Pi * Pxj * (2 / b)).flatten()
-            Sphiyy[2*m1*m2:] = (Pi * Pxj * (2 / b)).flatten()
-
-            e1xx = Sphixx
-            e1yy = Sphiyy
-            e1xy = Sphixy + Sphiyx
-
-            g0yz = Sphiy + Swy
-            g0xz = Sphix + Swx
-
-            Mxx = prop.D11 * e1xx + prop.D12 * e1yy + prop.D16 * e1xy
-            Myy = prop.D12 * e1xx + prop.D22 * e1yy + prop.D26 * e1xy
-            Mxy = prop.D16 * e1xx + prop.D26 * e1yy + prop.D66 * e1xy
-
-            Qy = prop.A44 * g0yz + prop.A45 * g0xz
-            Qx = prop.A45 * g0yz + prop.A55 * g0xz
-
-            detJ = a * b / 4
-
-            addouter(K, detJ * weight * Mxx, e1xx)
-            addouter(K, detJ * weight * Myy, e1yy)
-            addouter(K, detJ * weight * Mxy, e1xy)
-            addouter(K, detJ * weight * Qy, g0yz)
-            addouter(K, detJ * weight * Qx, g0xz)
-
-            addouter(KG, detJ * weight * Nxxhat * Swx, Swx)
-
-    eigvals, eigvecs = lb(csc_matrix(K), csc_matrix(KG), silent=True)
-
-    D = E * h**3 / (12 * (1 - nu**2))
-    Ncr_analytical = 4 * np.pi**2 * D / b**2
-    Ncr_computed = eigvals[0] * abs(Nxxhat)
-
-    # FSDT gives slightly lower Ncr than CLPT due to shear deformation
-    np.testing.assert_allclose(Ncr_computed, Ncr_analytical, rtol=0.02)