structsolve 0.6.1__tar.gz → 0.8.0__tar.gz

{structsolve-0.6.1/structsolve.egg-info → structsolve-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.6.1
+Version: 0.8.0
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -54,6 +54,8 @@ Structural analysis solvers tailored for semi-analytical models
 - Nonlinear statics using Newton-Raphson 
 - Nonlinear statics using the Arc-Length method
 - Support for unsymmetric problems, such as those involving follower forces
+- Load vectors that depend on the load factor, e.g. prescribed displacements
+  imposed exactly as linear constraints
 
 Currently these solvers are pretty much compatible with my other repositories
 [panels](https://github.com/saullocastro/panels), 
@@ -63,7 +65,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.6.1). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.8.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -78,6 +80,10 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
+* version 0.8.0 (2026-10-14)
+    - Fewer evaluations and factorizations, same solutions: `dR/dlbd` is evaluated together with the tangent stiffness matrix only, Newton-Raphson reuses the factorization of the tangent while it is not updated, the follower linear static analysis factorizes `K0` once, and `lb` estimates its shift and the inertia of `K` once for all its attempts
+* version 0.7.0 (2026-10-13)
+    - `calc_fext` may declare the keyword argument `lbd` and then receives the current load factor with the configuration, for prescribed displacements imposed exactly as linear constraints; the solvers use `dR/dlbd` for the arc-length scale, the first Newton-Raphson predictor and the relative convergence criterion. Callables without `lbd` behave as before
 * version 0.6.1 (2026-10-08)
     - Pyodide support: `await micropip.install("structsolve")` in the browser, and the whole test suite runs in Pyodide in GitHub Actions
     - `lb` and `freq` always run the sparse solvers first, whatever the size of the problem, with verified results; the dense solvers are only a last resort within `max_dense_size`, with a `DenseFallbackWarning`

{structsolve-0.6.1 → structsolve-0.8.0}/README.md

@@ -18,6 +18,8 @@ Structural analysis solvers tailored for semi-analytical models
 - Nonlinear statics using Newton-Raphson 
 - Nonlinear statics using the Arc-Length method
 - Support for unsymmetric problems, such as those involving follower forces
+- Load vectors that depend on the load factor, e.g. prescribed displacements
+  imposed exactly as linear constraints
 
 Currently these solvers are pretty much compatible with my other repositories
 [panels](https://github.com/saullocastro/panels), 
@@ -27,7 +29,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.6.1). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.8.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -42,6 +44,10 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
+* version 0.8.0 (2026-10-14)
+    - Fewer evaluations and factorizations, same solutions: `dR/dlbd` is evaluated together with the tangent stiffness matrix only, Newton-Raphson reuses the factorization of the tangent while it is not updated, the follower linear static analysis factorizes `K0` once, and `lb` estimates its shift and the inertia of `K` once for all its attempts
+* version 0.7.0 (2026-10-13)
+    - `calc_fext` may declare the keyword argument `lbd` and then receives the current load factor with the configuration, for prescribed displacements imposed exactly as linear constraints; the solvers use `dR/dlbd` for the arc-length scale, the first Newton-Raphson predictor and the relative convergence criterion. Callables without `lbd` behave as before
 * version 0.6.1 (2026-10-08)
     - Pyodide support: `await micropip.install("structsolve")` in the browser, and the whole test suite runs in Pyodide in GitHub Actions
     - `lb` and `freq` always run the sparse solvers first, whatever the size of the problem, with verified results; the dense solvers are only a last resort within `max_dense_size`, with a `DenseFallbackWarning`

{structsolve-0.6.1 → structsolve-0.8.0}/pyproject.toml

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

{structsolve-0.6.1 → structsolve-0.8.0}/structsolve/analysis.py

@@ -2,7 +2,7 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from .static import solve
+from .static import solve, _factorize
 from .logger import msg, warn
 from . import callbacks
 from .newton_raphson import _check_convergence
@@ -120,7 +120,8 @@ class Analysis(object):
         ``calc_fext(inc=1., silent=False)``, must return a 1-D array with the
         external force vector. Required for linear and non-linear static
         analyses. The non-linear solvers call it with ``inc=1.`` and scale the
-        returned vector by the load factor.
+        returned vector by the load factor. It may declare the optional
+        keyword arguments ``c`` and ``lbd``, see the notes below.
     calc_fint : callable, optional
         ``calc_fint(c, silent=False)``, must return a 1-D array with the
         internal force vector for the solution vector ``c``. Required for
@@ -150,6 +151,16 @@ class Analysis(object):
       configuration ``c`` for a unit load factor, the derivative of the
       residual with respect to the load factor, used by the arc-length
       solvers.
+    - ``calc_fext(inc=1., c=c, lbd=lbd)`` also receives the current load
+      factor when it declares ``lbd``, for a derivative `\partial
+      R/\partial \lambda` that depends on the load factor, e.g. prescribed
+      displacements imposed exactly as linear constraints, where the
+      reference vector ``calc_fext(inc=1.)`` may be null. The solvers then
+      use `\partial R/\partial \lambda` for the displacement scale of the
+      arc-length methods, for the predictor of the first Newton-Raphson
+      increment and as a reference of the relative convergence criterion,
+      see :mod:`.callbacks`. The linear static analysis never passes
+      ``lbd``.
 
     The tangent stiffness matrix may then be unsymmetric, which the solvers
     support, since they use LU factorizations.
@@ -291,6 +302,8 @@ class Analysis(object):
         configuration-dependent load, see :meth:`.static`"""
         msg('Configuration-dependent load: load correction iterations',
             level=2, silent=silent)
+        # k0 is factorized once for all the corrections
+        solve_k0 = None
         for iteration in range(1, self.maxNumIter + 1):
             fext = self.calc_fext(inc=1., c=c, silent=True)
             fint = k0 @ c
@@ -302,7 +315,12 @@ class Analysis(object):
                 return c
             if not np.isfinite(Rnorm):
                 break
-            c = c + solve(k0, R, silent=True)
+            if solve_k0 is None:
+                try:
+                    solve_k0 = _factorize(k0)
+                except RuntimeError:
+                    break
+            c = c + solve_k0(R)
         warn('The load correction iterations did not converge, the load may '
              'exceed the critical load of the linearized problem', level=1,
              silent=silent)

{structsolve-0.6.1 → structsolve-0.8.0}/structsolve/arc_length.py

@@ -8,12 +8,9 @@ control the arc-length scaling and adaptation.
 
 """
 import numpy as np
-from scipy.sparse import csc_matrix
-from scipy.sparse.linalg import splu
 
 from .logger import msg, warn
-from .static import solve
-from .sparseutils import remove_null_cols
+from .static import solve, _factorize
 from . import callbacks
 from .newton_raphson import (_check_convergence, _check_divergence,
                              _NR_iterations, INC_CUT_FACTOR)
@@ -31,34 +28,6 @@ MIN_GROWTH_FACTOR = 0.5
 MAX_NUM_STEPS = 1000
 
 
-def _factorize(kT):
-    """LU factorization of the tangent stiffness matrix
-
-    Null rows and columns are removed, the corresponding values of the
-    solution are zero.
-
-    Parameters
-    ----------
-    kT : sparse matrix
-        Tangent stiffness matrix.
-
-    Returns
-    -------
-    solve_kT : callable
-        Function that returns the solution ``x`` of ``kT x = b``.
-
-    """
-    kT_red, used_cols = remove_null_cols(kT, silent=True)
-    lu = splu(csc_matrix(kT_red))
-
-    def solve_kT(b):
-        x = np.zeros(b.shape[0], dtype=np.result_type(b, lu.U.dtype))
-        x[used_cols] = lu.solve(b[used_cols])
-        return x
-
-    return solve_kT
-
-
 def _solver_arc_length(an, method, silent=False):
     r"""Arc-length solver
 
@@ -110,6 +79,21 @@ def _solver_arc_length(an, method, silent=False):
     solution of the reference vector. The callables that accept ``inc``
     receive the current load factor, see :mod:`.callbacks`.
 
+    When ``calc_fext`` also accepts the keyword argument ``lbd``, e.g. for
+    prescribed displacements imposed exactly, it receives the load factor
+    together with the configuration, `\{F_{ext}\}` above being then
+    `\partial R/\partial \lambda` at the current `c` and `\lambda`;
+    `\{u_{ref}\}` is the linear solution of `\partial R/\partial \lambda`
+    at `c = 0`, `\lambda = 0`, since the reference vector may be null, e.g.
+    under a prescribed displacement alone; and `\lambda \, \partial
+    R/\partial \lambda` is an additional reference of the relative
+    convergence criterion. `\partial R/\partial \lambda` is evaluated
+    together with the tangent stiffness matrix, at the same iterate, i.e.
+    once per update of the tangent stiffness matrix, and used in the
+    bordered solution; the last one evaluated is the reference of the next
+    convergence checks. At the converged state it is kept with the tangent
+    stiffness matrix when the step is repeated with a shorter arc length.
+
     The initial arc length corresponds to a load factor increment of
     ``an.initialInc`` along the initial tangent. The convergence and
     divergence checks are the same as in the Newton-Raphson solver, see
@@ -136,7 +120,13 @@ def _solver_arc_length(an, method, silent=False):
 
     fext = an.calc_fext(inc=1., silent=True)
     kC0 = an.calc_kC(silent=silent)
-    u_ref = solve(kC0, fext, silent=True)
+    lbd_dependent = callbacks.is_load_factor_dependent(an)
+    if lbd_dependent:
+        # dR/dlbd at c = 0 and lbd = 0
+        q0 = callbacks.calc_load_vector(an, np.zeros_like(fext), fext, 0.)
+        u_ref = solve(kC0, q0, silent=True)
+    else:
+        u_ref = solve(kC0, fext, silent=True)
     scale2 = u_ref.dot(u_ref)
     if not scale2 > 0:
         scale2 = 1.
@@ -174,8 +164,13 @@ def _solver_arc_length(an, method, silent=False):
                 warn('Singular tangent stiffness matrix at the last converged state! Analysis stopped',
                      level=1, silent=silent)
                 break
-        # load vector of the converged configuration, dR/dlbd
-        dc_q_conv = solve_kT_conv(callbacks.calc_load_vector(an, c, fext))
+            # load vector of the converged configuration, dR/dlbd, kept with
+            # the tangent stiffness matrix when the step is repeated
+            if step_num == 1 and lbd_dependent:
+                q_conv = q0
+            else:
+                q_conv = callbacks.calc_load_vector(an, c, fext, lbd)
+        dc_q_conv = solve_kT_conv(q_conv)
         norm_q = np.sqrt(inner(dc_q_conv, 1., dc_q_conv, 1.))
         if arc_length is None:
             arc_length = an.initialInc*norm_q
@@ -197,6 +192,8 @@ def _solver_arc_length(an, method, silent=False):
         Rnorms = []
         solve_kT = solve_kT_conv
         dc_q = dc_q_conv
+        # the last dR/dlbd evaluated, with the tangent stiffness matrix
+        q_iter = q_conv
         iter_kT = 0
         iteration = 0
         while True:
@@ -204,8 +201,12 @@ def _solver_arc_length(an, method, silent=False):
             fint = callbacks.calc_fint(an, c + dc, lbd + dlbd)
             fext_total = (lbd + dlbd)*fext
             R = fext_total - fint
+            q_ref = None
+            if lbd_dependent:
+                q_ref = (lbd + dlbd)*q_iter
             conv, Rnorm, Rrel = _check_convergence(an, R, fint, fext_total,
-                                                   fext_ref=dlbd*fext)
+                                                   fext_ref=dlbd*fext,
+                                                   q_ref=q_ref)
             msg('Iteration: %d, lbd %1.5f, max(|R|) = %1.3e, relative ||R|| = %1.3e'
                 % (iteration, lbd + dlbd, np.abs(R).max(), Rrel), level=2, silent=silent)
             if conv:
@@ -225,7 +226,14 @@ def _solver_arc_length(an, method, silent=False):
                 except RuntimeError:
                     warn('Singular tangent stiffness matrix', level=2, silent=silent)
                     break
-                dc_q = solve_kT(callbacks.calc_load_vector(an, c + dc, fext))
+                if lbd_dependent:
+                    # dR/dlbd at the iterate of the tangent stiffness matrix
+                    q_iter = callbacks.calc_load_vector(an, c + dc, fext,
+                                                        lbd + dlbd)
+                    dc_q = solve_kT(q_iter)
+                else:
+                    dc_q = solve_kT(callbacks.calc_load_vector(an, c + dc,
+                                                               fext))
                 iter_kT = 1
             dc_R = solve_kT(R)
 
@@ -261,7 +269,9 @@ def _solver_arc_length(an, method, silent=False):
         if converged and lbd + dlbd > 1. and lbd < 1.:
             msg('Load factor 1.0 exceeded, correcting to load factor 1.0...', level=1, silent=silent)
             t = (1. - lbd)/dlbd
-            converged, dc1 = _NR_iterations(an, c, t*dc, 1., fext, kT0=None, silent=silent)
+            converged, dc1, _ = _NR_iterations(an, c, t*dc, 1., fext,
+                    kT0=None, silent=silent, lbd_dependent=lbd_dependent,
+                    q=q_iter)
             if converged:
                 msg('Converged at load factor 1.00000', level=2, silent=silent)
                 an.cs.append((c + dc1).copy())

structsolve-0.8.0/structsolve/callbacks.py

@@ -0,0 +1,160 @@
+r"""Calls to the callables of :class:`.Analysis` used by the non-linear solvers
+
+The callables may depend on the load factor `\lambda` and on the
+configuration through their optional keyword arguments, which are passed only
+when the callable declares them explicitly in its signature (a ``**kwargs``
+does not count), such that the callables written for the previous versions
+are called exactly as before:
+
+- ``inc``: the current load factor `\lambda`, passed to ``calc_fint``,
+  ``calc_kC`` and ``calc_kG``. It allows configuration-dependent loads, e.g.
+  follower pressures, whose configuration-dependent part enters
+  ``calc_fint`` and whose load stiffness enters ``calc_kC`` or ``calc_kG``,
+  both scaled by `\lambda`. The residual remains
+
+  .. math::
+
+      \{R(c, \lambda)\} = \lambda \{F_{ext}\} - \{F_{int}(c, \lambda)\}
+
+  with ``calc_kC + calc_kG`` its exact Jacobian `-\partial R/\partial c`.
+
+- ``c``: the current configuration, passed to ``calc_fext``, which must then
+  return the load vector of that configuration for a unit load factor, i.e.
+  `\partial R/\partial \lambda` at `c`. The arc-length solvers use it in the
+  predictor and in the constraint instead of the constant reference vector
+  ``calc_fext(inc=1.)``.
+
+- ``lbd``: the current load factor `\lambda`, passed to ``calc_fext``
+  together with ``c``, for a load vector `\partial R/\partial \lambda` that
+  depends on the load factor as well, e.g. prescribed displacements imposed
+  exactly as linear constraints `c = [T] c_r + \{c_{p0}\} + \lambda
+  \{c_{p1}\}`, whose reduced residual
+
+  .. math::
+
+      \{R_r(c_r, \lambda)\} = [T]^T \left( \lambda \{F_{ext}\} -
+      \{F_{int}([T] c_r + \{c_{p0}\} + \lambda \{c_{p1}\})\} \right)
+
+  has `\partial R_r/\partial \lambda = [T]^T(\{F_{ext}\} - [K_T]
+  \{c_{p1}\})`, with `[K_T]` evaluated at the current configuration and
+  load factor. The keyword ``inc`` keeps its meaning, the factor that
+  multiplies the returned vector, and the solvers keep calling
+  ``calc_fext(inc=1., ...)``. When ``calc_fext`` declares ``lbd``:
+
+  - the arc-length solvers pass ``lbd`` with ``c`` in the predictor and in
+    the constraint;
+  - the arc-length solvers scale the displacements with the linear solution
+    of `\partial R/\partial \lambda` at `c = 0, \lambda = 0`, instead of
+    the linear solution of the reference vector ``calc_fext(inc=1.)``, and
+    the Newton-Raphson solver uses this linear solution as the predictor of
+    its first step;
+  - the relative convergence criterion also considers the norm of
+    `\lambda \, \partial R/\partial \lambda`, see
+    :func:`.newton_raphson._check_convergence`, since under a prescribed
+    displacement alone the reference vector and the reduced internal force
+    vector both vanish at equilibrium;
+  - ``calc_fext(c=c, lbd=lbd)`` is called at the configurations where the
+    tangent stiffness matrix is updated, right after ``calc_kC`` and
+    ``calc_kG`` at the same ``c`` and load factor, such that the callables
+    may share their computations, and the last `\partial R/\partial
+    \lambda` evaluated is the reference of the convergence checks until the
+    next update.
+
+  ``lbd`` is never passed by the linear static analysis,
+  ``Analysis.static(NLgeom=False)``.
+
+"""
+import inspect
+
+
+def accepts_kwarg(func, name):
+    """Tell whether ``func`` declares the keyword argument ``name``"""
+    try:
+        sig = inspect.signature(func)
+    except (TypeError, ValueError):
+        return False
+    par = sig.parameters.get(name)
+    return par is not None and par.kind in (par.POSITIONAL_OR_KEYWORD,
+                                           par.KEYWORD_ONLY)
+
+
+def calc_fint(an, c, lbd):
+    r"""``an.calc_fint`` at ``c``, with ``inc=lbd`` when accepted"""
+    kwargs = dict(inc=lbd) if accepts_kwarg(an.calc_fint, 'inc') else {}
+    return an.calc_fint(c=c, silent=True, **kwargs)
+
+
+def calc_kT(an, c, lbd):
+    r"""Tangent stiffness matrix ``calc_kC + calc_kG`` at ``c``, with
+    ``inc=lbd`` passed to the callables that accept it"""
+    kwC = dict(inc=lbd) if accepts_kwarg(an.calc_kC, 'inc') else {}
+    kwG = dict(inc=lbd) if accepts_kwarg(an.calc_kG, 'inc') else {}
+    kC = an.calc_kC(c=c, NLgeom=True, silent=True, **kwC)
+    kG = an.calc_kG(c=c, NLgeom=True, silent=True, **kwG)
+    return kC + kG
+
+
+def is_load_configuration_dependent(an):
+    """Tell whether ``an.calc_fext`` accepts the configuration ``c``"""
+    return accepts_kwarg(an.calc_fext, 'c')
+
+
+def is_load_factor_dependent(an):
+    """Tell whether ``an.calc_fext`` accepts the load factor ``lbd``"""
+    return accepts_kwarg(an.calc_fext, 'lbd')
+
+
+def calc_load_vector(an, c, fext, lbd=None):
+    r"""Derivative of the residual with respect to the load factor
+
+    Returns `\{q\} = \partial R/\partial \lambda` at the configuration ``c``
+    and the load factor ``lbd``, used by the solvers in the predictors, in
+    the arc-length constraint and in the convergence criterion. It is the
+    external load vector only for loads that do not depend on the
+    configuration; with prescribed displacements imposed exactly it also
+    contains `-[T]^T [K_T] \{c_{p1}\}`, see the module docstring.
+
+    With prescribed displacements, `\{q\}` is not their reaction force: it
+    has the size of the reduced problem and acts on the free degrees of
+    freedom. It is the out-of-balance force produced by a unit increment of
+    the load factor at the current configuration, with the free degrees of
+    freedom held fixed. The reaction is a quantity of the full problem,
+    e.g. the generalized reaction work-conjugate to `\lambda`, `P =
+    \{c_{p1}\}^T (\{F_{int}(c)\} - \lambda \{F_{ext}\})`. ``structsolve``
+    does not compute it; see for instance ``MultiDomain.reaction_pd`` of
+    `panels`.
+
+    ``an.calc_fext`` is called with ``inc=1.`` and only with the keyword
+    arguments that it declares:
+
+    - ``c=c``, when it declares ``c``;
+    - ``lbd=lbd``, when it declares ``lbd`` and ``lbd`` is not ``None``.
+
+    When none of them is passed, `\{q\}` is the constant reference vector,
+    and ``fext`` is returned without calling ``an.calc_fext``.
+
+    Parameters
+    ----------
+    an : :class:`.Analysis`
+        Analysis object.
+    c : array-like
+        Configuration.
+    fext : array-like
+        Reference vector ``an.calc_fext(inc=1.)``.
+    lbd : float or None, optional
+        Load factor.
+
+    Returns
+    -------
+    q : array-like
+        `\partial R/\partial \lambda`.
+
+    """
+    kwargs = {}
+    if is_load_configuration_dependent(an):
+        kwargs['c'] = c
+    if lbd is not None and is_load_factor_dependent(an):
+        kwargs['lbd'] = lbd
+    if not kwargs:
+        return fext
+    return an.calc_fext(inc=1., silent=True, **kwargs)

{structsolve-0.6.1 → structsolve-0.8.0}/structsolve/linear_buckling.py

@@ -27,23 +27,11 @@ SHIFT_SEARCH_MAX_GROWTH = 1e10
 PARITY_REL_GAP = 1e-4
 
 
-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.
-
-    """
+def _estimate_mu_max(K, KG, max_iter=50, rel_tol=1e-3):
+    r"""Largest `|\mu|` of ``KG u = mu K u``, estimated by power
+    iterations, see :func:`_estimate_sigma`, or ``None`` when ``K`` is
+    singular, not positive definite, or the linear solution is
+    inaccurate"""
     try:
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -54,7 +42,7 @@ def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3):
         for i in range(max_iter):
             xKx = x @ Kx
             if not np.isfinite(xKx) or xKx <= 0:
-                return 1.
+                return None
             x = x / np.sqrt(xKx)
             rhs = KG @ x
             y = lu.solve(rhs)
@@ -62,19 +50,45 @@ def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3):
             if i == 0:
                 residual = np.linalg.norm(Ky - rhs)
                 if not residual <= 1e-6 * np.linalg.norm(rhs):
-                    return 1.
+                    return None
             # ||y||_K / ||x||_K, with ||x||_K = 1
             ratio = np.sqrt(abs(y @ Ky))
             if not np.isfinite(ratio) or ratio == 0:
-                return 1.
+                return None
             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
+        return mu_max
     except Exception:
+        return None
+
+
+def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3,
+                   mu_max=False):
+    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. An estimate of :func:`_estimate_mu_max` may be
+    given as ``mu_max``, e.g. to try another ``safety`` factor.
+
+    """
+    if mu_max is False:
+        mu_max = _estimate_mu_max(K, KG, max_iter=max_iter, rel_tol=rel_tol)
+    if mu_max is None:
         return 1.
+    return safety * mu_max
 
 
 def _negative_pivots(A):
@@ -135,7 +149,7 @@ def _lu_solve(lu, b):
 
 
 def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
-                      check_inertia=True):
+                      check_inertia=True, K_positive_definite=None):
     r"""Verify the eigenpairs of `([K] + \lambda [K_G])\{u\} = \{0\}`
 
     The eigenpairs may be real or complex.
@@ -155,6 +169,10 @@ def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
       symmetric matrices, ``check_inertia=True``, the complex `\lambda` are
       ignored. Missing negative load multipliers are not detected.
 
+    Whether ``K`` is positive definite may be given as
+    ``K_positive_definite``, a boolean or a function returning it, e.g. to
+    verify several solutions with one factorization of ``K``.
+
     Returns
     -------
     error : str or None
@@ -181,7 +199,11 @@ def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
         return None
     lam = lam[np.isreal(lam)].real
     positive = lam[lam > 0]
-    if positive.size and _is_positive_definite(K):
+    if K_positive_definite is None:
+        K_positive_definite = _is_positive_definite
+    if positive.size and (K_positive_definite(K) if
+                          callable(K_positive_definite) else
+                          K_positive_definite):
         s = positive.max()*(1 - min_rel_gap)
         expected = int(np.count_nonzero(positive < s))
         count = _negative_pivots(K + s*KG) if expected else None
@@ -599,15 +621,16 @@ def _eigs_shift_search(K, KG, k, tol, check_rtol, silent):
     return mu, eigvecs
 
 
-def _eigsh_cayley(K, KG, k, tol, silent, safety=10.):
+def _eigsh_cayley(K, KG, k, tol, silent, safety=10., mu_max=False):
     r"""Solution with :func:`scipy.sparse.linalg.eigsh` in Cayley mode
 
     The shift is estimated with :func:`_estimate_sigma` and the given
-    ``safety`` factor. ARPACK's ``ncv`` is chosen by
+    ``safety`` factor, from the estimate ``mu_max`` of
+    :func:`_estimate_mu_max` when given. ARPACK's ``ncv`` is chosen by
     :func:`.arpackutils.capped_eigsh`, which avoids the Intel MKL bug.
 
     """
-    sigma = _estimate_sigma(K, KG, safety=safety)
+    sigma = _estimate_sigma(K, KG, safety=safety, mu_max=mu_max)
     msg('sigma={0}'.format(sigma), level=4, silent=silent)
     k = min(k, K.shape[0] - 2)
     mu, eigvecs = capped_eigsh(A=KG, k=k, M=K, sigma=sigma, which='SM',
@@ -901,16 +924,32 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
         msg('{0} of {1} rows of KG are non-null'.format(num_active,
             K.shape[0]), level=3, silent=silent)
 
+        # the estimate of the shift and the inertia of K are computed once
+        # for all the attempts
+        once = {}
+
+        def mu_max():
+            if 'mu_max' not in once:
+                once['mu_max'] = _estimate_mu_max(K, KG)
+            return once['mu_max']
+
+        def K_positive_definite(K):
+            if 'pd' not in once:
+                once['pd'] = _is_positive_definite(K)
+            return once['pd']
+
         def verify(mu, eigvecs):
             with np.errstate(divide='ignore', invalid='ignore'):
-                return _check_eigenpairs(K, KG, -1./mu, eigvecs, check_rtol)
+                return _check_eigenpairs(K, KG, -1./mu, eigvecs, check_rtol,
+                        K_positive_definite=K_positive_definite)
 
         strategies = [
             ('eigsh() in Cayley mode',
-             lambda: _eigsh_cayley(K, KG, num_eigvalues, tol, silent)),
+             lambda: _eigsh_cayley(K, KG, num_eigvalues, tol, silent,
+                                   mu_max=mu_max())),
             ('eigsh() in Cayley mode with a 10 times larger shift',
              lambda: _eigsh_cayley(K, KG, num_eigvalues, tol, silent,
-                                   safety=100.)),
+                                   safety=100., mu_max=mu_max())),
         ]
         dense = ('eigh() with condensed dofs',
                  lambda: _eigh_condensed(K, KG, num_eigvalues))