structsolve 0.6.0__tar.gz → 0.7.0__tar.gz

{structsolve-0.6.0/structsolve.egg-info → structsolve-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.6.0
+Version: 0.7.0
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
+Classifier: Environment :: WebAssembly :: Emscripten
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -53,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), 
@@ -62,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.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.7.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -77,9 +80,12 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.6.0 (2026-10-08)
+* 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`
-    - ARPACK's `ncv` is capped at 32 when SciPy is linked against the Intel MKL versions whose `dsteqr` is faulty (new `structsolve.arpackutils`)
+    - ARPACK's `ncv` is capped at 32 when SciPy is linked against the Intel MKL versions whose `dsteqr` is faulty (new `structsolve.arpackutils`), computing more than 15 eigenpairs in passes whose eigenvectors are made orthonormal with a Rayleigh-Ritz projection
     - Unsymmetric `lb`: a shift search finds the lowest positive real load multiplier, instead of silently returning negative or complex ones
     - The test extra no longer requires `buckling` and `composites`
 * version 0.5.3 (2026-10-06)

{structsolve-0.6.0 → structsolve-0.7.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.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.7.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -42,9 +44,12 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.6.0 (2026-10-08)
+* 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`
-    - ARPACK's `ncv` is capped at 32 when SciPy is linked against the Intel MKL versions whose `dsteqr` is faulty (new `structsolve.arpackutils`)
+    - ARPACK's `ncv` is capped at 32 when SciPy is linked against the Intel MKL versions whose `dsteqr` is faulty (new `structsolve.arpackutils`), computing more than 15 eigenpairs in passes whose eigenvectors are made orthonormal with a Rayleigh-Ritz projection
     - Unsymmetric `lb`: a shift search finds the lowest positive real load multiplier, instead of silently returning negative or complex ones
     - The test extra no longer requires `buckling` and `composites`
 * version 0.5.3 (2026-10-06)

{structsolve-0.6.0 → structsolve-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structsolve"
-version = "0.6.0"
+version = "0.7.0"
 description = "Structural analysis solvers"
 readme = "README.md"
 license = {text = "BSD-2-Clause"}
@@ -31,6 +31,7 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: Unix",
+    "Environment :: WebAssembly :: Emscripten",
 ]
 dependencies = [
     "numpy",

{structsolve-0.6.0 → structsolve-0.7.0}/structsolve/analysis.py

@@ -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.

{structsolve-0.6.0 → structsolve-0.7.0}/structsolve/arc_length.py

@@ -110,6 +110,20 @@ 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`, evaluated at the current iterate before each
+    convergence check, is an additional reference of the relative
+    convergence criterion. The same `\partial R/\partial \lambda` is used
+    in the bordered solution when the tangent stiffness matrix is updated at
+    that iterate; with ``an.modified_NR = True`` it is one call to
+    ``calc_fext`` per iteration.
+
     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 +150,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.
@@ -175,7 +195,8 @@ def _solver_arc_length(an, method, silent=False):
                      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))
+        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
@@ -204,8 +225,15 @@ 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:
+                # dR/dlbd at the current iterate
+                q_iter = callbacks.calc_load_vector(an, c + dc, fext,
+                                                    lbd + dlbd)
+                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 +253,11 @@ 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:
+                    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 +293,8 @@ 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)
             if converged:
                 msg('Converged at load factor 1.00000', level=2, silent=silent)
                 an.cs.append((c + dc1).copy())

{structsolve-0.6.0 → structsolve-0.7.0}/structsolve/arpackutils.py

@@ -11,7 +11,9 @@ MKL 2025.0.1 or newer is not affected, neither are the non-symmetric drivers
 of :func:`scipy.sparse.linalg.eigs`, which do not call ``dsteqr``.
 
 :func:`capped_eigsh` keeps ``ncv <= 32`` when :func:`arpack_max_ncv` says so,
-computing more than 15 eigenpairs in several calls with deflation.
+computing more than 15 eigenpairs in several calls with deflation, whose
+eigenvectors are combined with a Rayleigh-Ritz projection such that they
+are orthonormal also across the calls.
 
 The cap is decided by :func:`arpack_max_ncv` and can be overridden with
 the module attribute :data:`ARPACK_MAX_NCV` or the environment variable
@@ -32,6 +34,7 @@ import sys
 import warnings
 
 import numpy as np
+from scipy.linalg import cholesky, eigh, solve_triangular
 from scipy.sparse import csc_matrix
 from scipy.sparse.linalg import LinearOperator, splu
 from scipy.sparse.linalg import eigsh as _scipy_eigsh
@@ -281,6 +284,34 @@ def _deflation_shift(w, far_shift):
     return 0.5*(last[i] + last[i + 1])
 
 
+def _rayleigh_ritz(A, M, V):
+    r"""Rayleigh-Ritz projection of `[A]\{x\} = w [M]\{x\}` onto `[V]`
+
+    The eigenvectors of different passes of :func:`capped_eigsh` are only
+    `[M]`-orthogonal to the accuracy of ARPACK, e.g. `10^{-6}` between
+    close eigenvalues of different passes. `[V]` is `[M]`-orthonormalized
+    with the Cholesky factor `[L]` of `[V]^T[M][V]`, and the projected
+    problem `[W]^T[A][W]\{y\} = w\{y\}`, with `[W] = [V][L]^{-T}`, is
+    solved with the LAPACK driver ``dsyevr`` (``driver='evr'``), which does
+    not use the ``dsteqr`` of Intel MKL broken above 32 x 32 matrices, see
+    :func:`dsteqr_is_faulty`. The returned eigenvectors `[W]\{y\}` are
+    `[M]`-orthonormal to the rounding errors, and the Ritz values are at
+    least as accurate as the eigenvalues of the passes.
+
+    Returns
+    -------
+    w, x : ndarray
+        The Ritz values by increasing value and the Ritz vectors.
+
+    """
+    MV = M @ V
+    L = cholesky(0.5*(V.T @ MV + MV.T @ V), lower=True)
+    W = solve_triangular(L, V.T, lower=True).T
+    H = W.T @ (A @ W)
+    w, Y = eigh(0.5*(H + H.T), driver='evr')
+    return w, W @ Y
+
+
 def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
     r""":func:`scipy.sparse.linalg.eigsh` with ``ncv`` from :func:`arpack_ncv`
 
@@ -312,7 +343,9 @@ def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
     in the study of the panels cylinders it was 30 to 45% faster and gave
     eigenvalues 5 to 10 times more accurate. Each pass factorizes
     `[A] - \sigma_d [M]` with SuperLU, and every call starts from
-    :func:`start_vector`.
+    :func:`start_vector`. The eigenvectors of all the passes are finally
+    combined with a Rayleigh-Ritz projection, see :func:`_rayleigh_ritz`,
+    such that they are `[M]`-orthonormal also across the passes.
 
     Returns
     -------
@@ -359,5 +392,4 @@ def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
         w = np.concatenate((w, wi))
         V = np.hstack((V, Vi))
         release_memory()
-    order = np.argsort(w, kind='stable')
-    return w[order], V[:, order]
+    return _rayleigh_ritz(A, M, V)

structsolve-0.7.0/structsolve/callbacks.py

@@ -0,0 +1,154 @@
+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.
+
+  ``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.0 → structsolve-0.7.0}/structsolve/linear_buckling.py

@@ -862,9 +862,10 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
     MKL versions returns wrong eigenvectors for matrices larger than
     32 x 32, which ARPACK uses with the size ``ncv``. When such a LAPACK is
     detected, ``ncv`` is capped at 32 and more than 15 eigenpairs are
-    computed in several passes, see :mod:`structsolve.arpackutils`, where
-    the cap can be overridden, e.g. with the environment variable
-    ``STRUCTSOLVE_ARPACK_MAX_NCV=0`` to lift it with MKL 2025.0.1 or newer.
+    computed in several passes, combined with a Rayleigh-Ritz projection,
+    see :mod:`structsolve.arpackutils`, where the cap can be overridden,
+    e.g. with the environment variable ``STRUCTSOLVE_ARPACK_MAX_NCV=0`` to
+    lift it with MKL 2025.0.1 or newer.
     The non-symmetric drivers of :func:`scipy.sparse.linalg.eigs` are not
     affected.
 

{structsolve-0.6.0 → structsolve-0.7.0}/structsolve/newton_raphson.py

@@ -32,13 +32,14 @@ INC_GROWTH_FACTOR = 1.1111
 INC_CUT_FACTOR = 0.5
 
 
-def _check_convergence(an, R, fint, fext_total, fext_ref=None):
-    """Check the convergence of the residual force vector
+def _check_convergence(an, R, fint, fext_total, fext_ref=None, q_ref=None):
+    r"""Check the convergence of the residual force vector
 
     The convergence is achieved when either:
 
-    - ``||R|| <= relTOL*max(||fext_total||, ||fint||, ||fext_ref||)``, using
-      the Euclidean norm, if ``an.relTOL`` is not ``None``
+    - ``||R|| <= relTOL*max(||fext_total||, ||fint||, ||fext_ref||,
+      ||q_ref||)``, using the Euclidean norm, if ``an.relTOL`` is not
+      ``None``
     - ``max(|R|) <= absTOL``, if ``an.absTOL`` is not ``None``
 
     Parameters
@@ -54,6 +55,12 @@ def _check_convergence(an, R, fint, fext_total, fext_ref=None):
     fext_ref : array-like or None, optional
         Additional reference force vector, e.g. the external force vector of
         the current increment, useful when the load factor is close to zero.
+    q_ref : array-like or None, optional
+        Additional reference force vector, the load factor times
+        `\partial R/\partial \lambda` when ``calc_fext`` accepts ``lbd``,
+        see :mod:`.callbacks`. Under a prescribed displacement alone, the
+        external and the internal force vectors of the reduced problem both
+        vanish at equilibrium and cannot be the reference.
 
     Returns
     -------
@@ -62,7 +69,8 @@ def _check_convergence(an, R, fint, fext_total, fext_ref=None):
     Rnorm : float
         Euclidean norm of the residual.
     Rrel : float
-        Relative residual ``||R||/max(||fext_total||, ||fint||, ||fext_ref||)``.
+        Relative residual ``||R||/max(||fext_total||, ||fint||, ||fext_ref||,
+        ||q_ref||)``.
 
     """
     if an.relTOL is None and an.absTOL is None:
@@ -71,6 +79,8 @@ def _check_convergence(an, R, fint, fext_total, fext_ref=None):
     ref = max(np.linalg.norm(fext_total), np.linalg.norm(fint))
     if fext_ref is not None:
         ref = max(ref, np.linalg.norm(fext_ref))
+    if q_ref is not None:
+        ref = max(ref, np.linalg.norm(q_ref))
     Rrel = Rnorm/ref if ref > 0 else Rnorm
     converged = False
     if an.relTOL is not None and Rnorm <= an.relTOL*ref:
@@ -128,8 +138,9 @@ def _check_divergence(an, Rnorm, Rnorms, iteration, silent=False):
     return False
 
 
-def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False):
-    """Newton-Raphson iterations at a fixed load factor
+def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False,
+                   lbd_dependent=False):
+    r"""Newton-Raphson iterations at a fixed load factor
 
     Parameters
     ----------
@@ -148,6 +159,11 @@ def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False):
         ``an.modified_NR=True``. If ``None`` it is calculated at ``c + dc``.
     silent : bool, optional
         A boolean to tell whether the log messages should be printed.
+    lbd_dependent : bool, optional
+        Whether ``calc_fext`` accepts ``lbd``, see :mod:`.callbacks`;
+        ``total*q``, with `\{q\} = \partial R/\partial \lambda` evaluated
+        at the current iterate, is then an additional reference of the
+        relative convergence criterion, see :func:`._check_convergence`.
 
     Returns
     -------
@@ -159,6 +175,7 @@ def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False):
     """
     modified_NR = an.modified_NR
     fext_total = total*fext
+    q_ref = None
     Rnorms = []
     iter_kT = 0
     kT = None
@@ -170,8 +187,11 @@ def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False):
         if fint is None:
             fint = callbacks.calc_fint(an, c + dc, total)
         R = fext_total - fint
+        if lbd_dependent:
+            q_ref = total*callbacks.calc_load_vector(an, c + dc, fext, total)
 
-        conv, Rnorm, Rrel = _check_convergence(an, R, fint, fext_total)
+        conv, Rnorm, Rrel = _check_convergence(an, R, fint, fext_total,
+                                               q_ref=q_ref)
         msg('Iteration: %d, max(|R|) = %1.3e, relative ||R|| = %1.3e'
             % (iteration, np.abs(R).max(), Rrel), level=2, silent=silent)
         if conv:
@@ -235,6 +255,17 @@ def _solver_NR(an, silent=False, initialInc=None):
     factor `\lambda` of the step, see :mod:`.callbacks`, which allows
     configuration-dependent loads such as follower pressures.
 
+    When ``calc_fext`` accepts the keyword argument ``lbd``, e.g. for
+    prescribed displacements imposed exactly, see :mod:`.callbacks`, the
+    load vector `\{q\} = \partial R/\partial \lambda` at `c = 0`,
+    `\lambda = 0` gives the predictor of the first increment, its linear
+    solution `[K_0]^{-1}\{q\}`, instead of the linear solution of the
+    reference vector, which is null under a prescribed displacement alone,
+    and `\lambda \|q\|`, with `\{q\}` evaluated at the current iterate
+    before each convergence check, is an additional reference of the
+    relative convergence criterion. With ``an.modified_NR = True`` this is
+    one call to ``calc_fext`` per iteration.
+
     By default full Newton-Raphson is used, i.e. the tangent stiffness matrix
     ``kT = kC + kG`` is rebuilt at every iteration, which gives quadratic
     convergence when ``kT`` is the exact Jacobian of ``fint``. With
@@ -283,8 +314,12 @@ def _solver_NR(an, silent=False, initialInc=None):
 
     fext = an.calc_fext(inc=1., silent=True)
     kC0 = an.calc_kC(silent=silent)
+    q = None
+    if callbacks.is_load_factor_dependent(an):
+        # dR/dlbd at c = 0 and lbd = 0
+        q = callbacks.calc_load_vector(an, np.zeros_like(fext), fext, 0.)
     # predictor of the first step: linear solution scaled by the load factor
-    dc_last = solve(kC0, fext, silent=True)
+    dc_last = solve(kC0, fext if q is None else q, silent=True)
     inc_last = 1.
     c = np.zeros_like(dc_last)
     total_last = 0.
@@ -305,7 +340,8 @@ def _solver_NR(an, silent=False, initialInc=None):
         if an.modified_NR and step_num == 1 and not an.kT_initial_state:
             kT0 = kC0
         converged, dc = _NR_iterations(an, c, dc, total, fext, kT0=kT0,
-                                       silent=silent)
+                                       silent=silent,
+                                       lbd_dependent=q is not None)
 
         if converged:
             msg('Converged at load factor %1.5f' % total, level=2, silent=silent)

{structsolve-0.6.0 → structsolve-0.7.0/structsolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.6.0
+Version: 0.7.0
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
+Classifier: Environment :: WebAssembly :: Emscripten
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -53,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), 
@@ -62,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.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.7.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -77,9 +80,12 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.6.0 (2026-10-08)
+* 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`
-    - ARPACK's `ncv` is capped at 32 when SciPy is linked against the Intel MKL versions whose `dsteqr` is faulty (new `structsolve.arpackutils`)
+    - ARPACK's `ncv` is capped at 32 when SciPy is linked against the Intel MKL versions whose `dsteqr` is faulty (new `structsolve.arpackutils`), computing more than 15 eigenpairs in passes whose eigenvectors are made orthonormal with a Rayleigh-Ritz projection
     - Unsymmetric `lb`: a shift search finds the lowest positive real load multiplier, instead of silently returning negative or complex ones
     - The test extra no longer requires `buckling` and `composites`
 * version 0.5.3 (2026-10-06)

{structsolve-0.6.0 → structsolve-0.7.0}/structsolve.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ tests/test_follower_loads.py
 tests/test_freq.py
 tests/test_linear_buckling.py
 tests/test_linear_buckling_unsymmetric.py
+tests/test_load_factor_dependent_load.py
 tests/test_newton_raphson.py
 tests/test_sparse_first.py
 tests/test_sparseutils.py

{structsolve-0.6.0 → structsolve-0.7.0}/tests/test_linear_buckling_unsymmetric.py

@@ -217,6 +217,9 @@ def test_lb_nearly_symmetric(sparse_solver, max_dense_size):
     assert np.all(relative_residuals(Kn, KG, eigvals, eigvecs) < 1e-8)
 
 
+@pytest.mark.skipif(sys.platform == 'emscripten',
+                    reason='no subprocesses in Pyodide, whose SciPy is not '
+                           'linked to MKL')
 def test_eig_complex_mkl_crash_regression():
     """Regression test: with Intel MKL 2025.0.0, scipy.linalg.eig on these
     real 48 x 48 matrices (LAPACK dggev) corrupts the heap and the process

structsolve-0.7.0/tests/test_load_factor_dependent_load.py

@@ -0,0 +1,298 @@
+r"""Load vector depending on the load factor: prescribed displacements
+
+Three hardening springs in series, `f_i(e) = k_i e + a_i e^3`, between a
+wall and the nodes 1, 2 and 3, with the displacement of node 3 prescribed,
+`x_3 = d_0 + \lambda d_1`, and an optional load `\lambda F` on node 1. The
+constraint is imposed exactly, as in the null-space method of `panels`:
+
+.. math::
+
+    \{c\} = [T]\{c_r\} + \{c_{p0}\} + \lambda \{c_{p1}\}, \qquad
+    [T] = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 0 & 0 \end{bmatrix}, \qquad
+    \{c_{p0}\} = \{0, 0, d_0\}, \qquad \{c_{p1}\} = \{0, 0, d_1\}
+
+such that the reduced problem has two degrees of freedom and the residual
+
+.. math::
+
+    \{R_r(c_r, \lambda)\} = [T]^T \left(\lambda \{F_{ext}\} -
+    \{F_{int}(c)\}\right), \qquad
+    \frac{\partial R_r}{\partial \lambda} = [T]^T \left(\{F_{ext}\} -
+    [K_T(c)] \{c_{p1}\}\right)
+
+whose derivative with respect to the load factor depends on the
+configuration and on the load factor, passed to :class:`structsolve.Analysis`
+with ``calc_fext(inc=1., c=c_r, lbd=lbd)``, see :mod:`structsolve.callbacks`.
+Under the prescribed displacement alone, `F = 0`, the reference vector
+``calc_fext(inc=1.)`` is null.
+
+"""
+import numpy as np
+import pytest
+from scipy.optimize import brentq
+from scipy.sparse import csr_matrix
+
+from structsolve import Analysis
+from structsolve import callbacks
+
+
+T = np.array([[1., 0.], [0., 1.], [0., 0.]])
+
+
+class SpringsProblem(object):
+    def __init__(self, k=(100., 150., 200.), a=(20., 40., 60.), d0=0.,
+                 d1=1., F=0., with_lbd=True):
+        self.k = np.asarray(k)
+        self.a = np.asarray(a)
+        self.cp0 = np.array([0., 0., d0])
+        self.cp1 = np.array([0., 0., d1])
+        self.Fext = np.array([F, 0., 0.])
+        self.with_lbd = with_lbd
+        self.an = None
+        # (lbd, c_r) of each call to calc_fext with lbd, and (inc, ||R_r||,
+        # number of converged increments) of each call to calc_fint
+        self.fext_calls = []
+        self.fint_calls = []
+
+    def full(self, c_r, lbd):
+        return T @ c_r + self.cp0 + lbd*self.cp1
+
+    def elongations(self, c):
+        return np.array([c[0], c[1] - c[0], c[2] - c[1]])
+
+    def fint_full(self, c):
+        k, a = self.k, self.a
+        f = k*self.elongations(c) + a*self.elongations(c)**3
+        return np.array([f[0] - f[1], f[1] - f[2], f[2]])
+
+    def kT_full(self, c):
+        ke = self.k + 3*self.a*self.elongations(c)**2
+        return np.array([[ke[0] + ke[1], -ke[1], 0.],
+                         [-ke[1], ke[1] + ke[2], -ke[2]],
+                         [0., -ke[2], ke[2]]])
+
+    def residual(self, c_r, lbd):
+        return T.T @ (lbd*self.Fext - self.fint_full(self.full(c_r, lbd)))
+
+    def dR_dlbd(self, c_r, lbd):
+        c = self.full(c_r, lbd)
+        return T.T @ (self.Fext - self.kT_full(c) @ self.cp1)
+
+    def reaction(self, c_r, lbd):
+        r"""Force of the support on node 3, `c_{p1}^T r / d_1`, with `r =
+        F_{int}(c) - \lambda F_{ext}`"""
+        c = self.full(c_r, lbd)
+        r = self.fint_full(c) - lbd*self.Fext
+        return self.cp1 @ r/self.cp1[2]
+
+    # callables of structsolve.Analysis
+    def calc_fext(self, inc=1., silent=True, c=None, lbd=None):
+        if c is None:
+            return inc*(T.T @ self.Fext)
+        self.fext_calls.append((lbd, c.copy()))
+        return inc*self.dR_dlbd(c, lbd)
+
+    def calc_fint(self, c, inc=1., silent=True):
+        step = len(self.an.increments) if self.an is not None else 0
+        self.fint_calls.append((inc, np.linalg.norm(self.residual(c, inc)),
+                                step))
+        return T.T @ self.fint_full(self.full(c, inc))
+
+    def calc_kC(self, c=None, NLgeom=False, inc=1., silent=True):
+        if c is None or not NLgeom:
+            return csr_matrix(T.T @ self.kT_full(np.zeros(3)) @ T)
+        return csr_matrix(T.T @ self.kT_full(self.full(c, inc)) @ T)
+
+    def calc_kG(self, c=None, NLgeom=False, silent=True):
+        return csr_matrix((2, 2))
+
+    def analysis(self, **kwargs):
+        if self.with_lbd:
+            calc_fext = self.calc_fext
+        else:
+            calc_fext = lambda inc=1., silent=True: self.calc_fext(inc)
+        an = Analysis(calc_fext, self.calc_fint, self.calc_kC, self.calc_kG)
+        for key, value in kwargs.items():
+            setattr(an, key, value)
+        self.an = an
+        return an
+
+    def exact(self, lbd):
+        r"""Solution without the load on node 1: the three springs carry the
+        same force `P`, found from `\sum_i e_i(P) = x_3`"""
+        assert self.Fext[0] == 0.
+        x3 = self.cp0[2] + lbd*self.cp1[2]
+
+        def e(P, i):
+            return brentq(lambda ei: self.k[i]*ei + self.a[i]*ei**3 - P,
+                          -1e4, 1e4, xtol=1e-15, rtol=1e-15)
+
+        def gap(P):
+            return sum(e(P, i) for i in range(3)) - x3
+
+        P = 0. if x3 == 0 else brentq(gap, -1e4, 1e4, xtol=1e-14,
+                                      rtol=1e-15)
+        e1, e2 = e(P, 0), e(P, 1)
+        return np.array([e1, e1 + e2]), P
+
+    def solve_reference(self, lbd, tol=1e-14):
+        """Dense Newton-Raphson with continuation on the load factor"""
+        c_r = np.zeros(2)
+        for l in np.linspace(0, lbd, 21)[1:]:
+            for _ in range(100):
+                R = self.residual(c_r, l)
+                if np.linalg.norm(R) <= tol*max(1., np.linalg.norm(
+                        self.dR_dlbd(c_r, l))):
+                    break
+                kT = T.T @ self.kT_full(self.full(c_r, l)) @ T
+                c_r = c_r + np.linalg.solve(kT, R)
+        return c_r
+
+
+def test_calc_load_vector_passes_lbd_only_when_declared():
+    fext = np.array([1., 2.])
+    calls = []
+
+    class A(object):
+        calc_fext = None
+
+    def with_c(inc=1., silent=True, c=None):
+        calls.append(('c', c))
+        return fext
+
+    def with_c_lbd(inc=1., silent=True, c=None, lbd=None):
+        calls.append(('c, lbd', c, lbd))
+        return fext
+
+    def with_kwargs(inc=1., silent=True, c=None, **kwargs):
+        calls.append(('c, **kwargs', c, kwargs))
+        return fext
+
+    def without(inc=1., silent=True):
+        calls.append('without')
+        return fext
+
+    an = A()
+    c = np.array([3., 4.])
+    for func in (with_c, with_c_lbd, with_kwargs, without):
+        an.calc_fext = func
+        callbacks.calc_load_vector(an, c, fext, 0.5)
+    assert calls[0] == ('c', c)
+    assert calls[1] == ('c, lbd', c, 0.5)
+    # a **kwargs does not count, as for inc
+    assert calls[2] == ('c, **kwargs', c, {})
+    # the constant reference vector is returned without calling calc_fext
+    assert len(calls) == 3
+    assert not callbacks.is_load_factor_dependent(A())
+    an.calc_fext = with_c_lbd
+    assert callbacks.is_load_factor_dependent(an)
+
+
+@pytest.mark.parametrize('method', ['NR', 'arc_length_riks',
+                                    'arc_length_crisfield'])
+def test_displacement_control_relative_criterion(method):
+    r"""The prescribed displacement alone, with the relative convergence
+    criterion only: every converged increment is the exact solution, and
+    ``calc_fext`` receives the load factor of the configuration"""
+    pb = SpringsProblem(d1=0.8)
+    an = pb.analysis(NL_method=method, initialInc=0.2, relTOL=1e-10,
+                     absTOL=None)
+    an.static(NLgeom=True, silent=True)
+    assert np.isclose(an.increments[-1], 1.)
+    assert len(an.increments) > 2
+    for lbd, c_r in zip(an.increments, an.cs):
+        ref, P = pb.exact(lbd)
+        assert np.allclose(c_r, ref, rtol=1e-8, atol=1e-12), (lbd, c_r, ref)
+        assert np.isclose(pb.reaction(c_r, lbd), P, rtol=1e-8)
+        assert (np.linalg.norm(pb.residual(c_r, lbd))
+                <= 1e-9*np.linalg.norm(lbd*pb.dR_dlbd(c_r, lbd)))
+    # the arc-length solvers evaluate dR/dlbd at the configurations and load
+    # factors of their iterations
+    if method != 'NR':
+        assert len(pb.fext_calls) > len(an.increments)
+        lbds = [lbd for lbd, _ in pb.fext_calls]
+        assert lbds[0] == 0.
+        assert all(lbd is not None for lbd in lbds)
+        assert len(set(lbds)) > 2
+
+
+def test_displacement_control_without_lbd_does_not_converge():
+    r"""The reason for ``lbd``: without it, the reference vector and the
+    reduced internal force vector vanish at equilibrium, and the relative
+    criterion cannot be satisfied"""
+    pb = SpringsProblem(d1=0.8, with_lbd=False)
+    an = pb.analysis(initialInc=0.2, relTOL=1e-10, absTOL=None,
+                     maxNumIter=10, minInc=0.01)
+    an.static(NLgeom=True, silent=True)
+    assert len(an.increments) == 0
+
+
+def test_newton_raphson_first_predictor_is_linear_solution():
+    r"""With linear springs the predictor of the first increment,
+    `[K_0]^{-1} \partial R/\partial \lambda`, is the solution: each
+    increment converges at its first evaluation of the residual"""
+    pb = SpringsProblem(a=(0., 0., 0.), d1=0.5)
+    an = pb.analysis(initialInc=0.3, relTOL=1e-12)
+    an.static(NLgeom=True, silent=True)
+    assert np.isclose(an.increments[-1], 1.)
+    steps = [step for _, _, step in pb.fint_calls]
+    assert steps.count(0) == 1, pb.fint_calls
+    ref, _ = pb.exact(1.)
+    assert np.allclose(an.cs[-1], ref, rtol=1e-12)
+
+
+def orders(errors, floor=1e-12):
+    """Convergence orders log(e2/e1)/log(e1/e0) above the round-off floor"""
+    return [np.log(e2/e1)/np.log(e1/e0)
+            for e0, e1, e2 in zip(errors[:-2], errors[1:-1], errors[2:])
+            if e2 > floor and e0 < 0.1]
+
+
+def test_riks_quadratic_with_load_factor_dependent_load_vector():
+    r"""The bordered system of Riks is Newton-Raphson applied to the
+    augmented system with the exact `\partial R/\partial \lambda`"""
+    pb = SpringsProblem(k=(10., 15., 20.), a=(200., 400., 600.), d1=1.)
+    an = pb.analysis(NL_method='arc_length_riks', initialInc=0.5,
+                     relTOL=1e-13, maxNumIter=60)
+    an.static(NLgeom=True, silent=True)
+    assert np.isclose(an.increments[-1], 1.)
+    first = [e for _, e, step in pb.fint_calls if step == 0]
+    ps = orders(first)
+    assert len(ps) >= 1, first
+    assert min(ps) > 1.7, first
+
+
+@pytest.mark.parametrize('method', ['NR', 'arc_length_riks',
+                                    'arc_length_crisfield'])
+def test_constant_and_incremented_prescriptions(method):
+    r"""A constant prescribed displacement `d_0`, held during the analysis,
+    with a load `\lambda F` on node 1 and an incremented displacement
+    `\lambda d_1`"""
+    pb = SpringsProblem(d0=-0.3, d1=0.6, F=40.)
+    an = pb.analysis(NL_method=method, initialInc=0.2, relTOL=1e-11)
+    an.static(NLgeom=True, silent=True)
+    assert np.isclose(an.increments[-1], 1.)
+    for lbd, c_r in zip(an.increments, an.cs):
+        ref = pb.solve_reference(lbd)
+        assert np.allclose(c_r, ref, rtol=1e-8, atol=1e-12), (lbd, c_r, ref)
+    # at lbd = 0 the constant displacement alone is not in equilibrium with
+    # c_r = 0: the first increment starts from a non-null residual
+    assert np.linalg.norm(pb.residual(np.zeros(2), 0.)) > 1.
+
+
+@pytest.mark.parametrize('method', ['NR', 'arc_length_riks',
+                                    'arc_length_crisfield'])
+def test_null_load_vector_at_the_origin(method):
+    r"""The last spring is purely cubic, `f_3 = a_3 e^3`, such that
+    `\partial R/\partial \lambda = 0` at `c = 0`, `\lambda = 0`: the
+    reference of the relative criterion is `\lambda \partial R/\partial
+    \lambda` at the current iterate, not at the origin"""
+    pb = SpringsProblem(k=(100., 150., 0.), a=(20., 40., 600.), d1=0.5)
+    assert np.linalg.norm(pb.dR_dlbd(np.zeros(2), 0.)) == 0.
+    an = pb.analysis(NL_method=method, initialInc=0.2, relTOL=1e-10,
+                     absTOL=None)
+    an.static(NLgeom=True, silent=True)
+    assert np.isclose(an.increments[-1], 1.)
+    for lbd, c_r in zip(an.increments, an.cs):
+        ref, P = pb.exact(lbd)
+        assert np.allclose(c_r, ref, rtol=1e-8, atol=1e-12), (lbd, c_r, ref)

structsolve-0.6.0/structsolve/callbacks.py

@@ -1,68 +0,0 @@
-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.)``.
-
-"""
-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 calc_load_vector(an, c, fext):
-    r"""`\partial R/\partial \lambda` at ``c``: ``calc_fext(inc=1., c=c)``
-    when ``calc_fext`` accepts ``c``, otherwise the constant ``fext``"""
-    if is_load_configuration_dependent(an):
-        return an.calc_fext(inc=1., c=c, silent=True)
-    return fext