structsolve 0.9.1__tar.gz → 0.9.3__tar.gz

{structsolve-0.9.1/structsolve.egg-info → structsolve-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.9.1
+Version: 0.9.3
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License-Expression: BSD-3-Clause
@@ -63,7 +63,7 @@ Currently these solvers are pretty much compatible with my other repository
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.9.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.9.3). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -78,12 +78,15 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.9.1 (2026-10-24)
-    - documentation published again: pandoc installed in the documentation workflow
-* version 0.9.0 (2026-10-24)
+* version 0.9.3 (2026-10-26)
     - Crisfield's convergence criterion is the default of the non-linear analyses, `Analysis.convergence = 'crisfield'`, with `relTOL = 1e-9`: the residual and the reference forces are measured with the norm scaled by the diagonal of `calc_kC()` over the free degrees of freedom; the former check is kept with `convergence = 'relative'`
+    - With both convergence criteria, an iteration also converges at the round-off floor of its residual, `3 eps ||(|K_C0| |c|)||`: the arc-length methods trace the snap-through of a low arch at `relTOL = 1e-9` through the null load where they stopped
     - `lb` returns the negative load multipliers closest to zero after the positive ones, and a tensile reference load no longer needs the dense fallback
-    - `freq(sort=True)` sorts and filters `lambda2` together with the eigenvectors, and rigid-body modes no longer fail the verification of the residuals
+    - `freq(sort=True)` sorts and filters `lambda2` together with the eigenvectors, and neither rigid-body modes nor eigenpairs with an eigenvalue close to zero whose backward error is at the round-off, e.g. pre-stressed close to buckling, fail the verification of the residuals any more
+    - arc-length solvers: a converged step that points back along the path is repeated with half the arc length, instead of being accepted
+    - documentation published again: pandoc installed in the documentation workflow
+    - `lb` and `freq` no longer reset the registry of the warnings already shown, which made a warning of the caller under the `'default'` action be shown again after each call
+    - The residual is `R = Fint - lbd*Fext`, the convention of `pyfe3d.solver` and `panels`, with `K_T dc = -R` in the Newton-Raphson corrections and `dR/dlbd = -Fext`; the solutions are bitwise identical
 * 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)

{structsolve-0.9.1 → structsolve-0.9.3}/README.md

@@ -28,7 +28,7 @@ Currently these solvers are pretty much compatible with my other repository
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.9.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.9.3). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -43,12 +43,15 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.9.1 (2026-10-24)
-    - documentation published again: pandoc installed in the documentation workflow
-* version 0.9.0 (2026-10-24)
+* version 0.9.3 (2026-10-26)
     - Crisfield's convergence criterion is the default of the non-linear analyses, `Analysis.convergence = 'crisfield'`, with `relTOL = 1e-9`: the residual and the reference forces are measured with the norm scaled by the diagonal of `calc_kC()` over the free degrees of freedom; the former check is kept with `convergence = 'relative'`
+    - With both convergence criteria, an iteration also converges at the round-off floor of its residual, `3 eps ||(|K_C0| |c|)||`: the arc-length methods trace the snap-through of a low arch at `relTOL = 1e-9` through the null load where they stopped
     - `lb` returns the negative load multipliers closest to zero after the positive ones, and a tensile reference load no longer needs the dense fallback
-    - `freq(sort=True)` sorts and filters `lambda2` together with the eigenvectors, and rigid-body modes no longer fail the verification of the residuals
+    - `freq(sort=True)` sorts and filters `lambda2` together with the eigenvectors, and neither rigid-body modes nor eigenpairs with an eigenvalue close to zero whose backward error is at the round-off, e.g. pre-stressed close to buckling, fail the verification of the residuals any more
+    - arc-length solvers: a converged step that points back along the path is repeated with half the arc length, instead of being accepted
+    - documentation published again: pandoc installed in the documentation workflow
+    - `lb` and `freq` no longer reset the registry of the warnings already shown, which made a warning of the caller under the `'default'` action be shown again after each call
+    - The residual is `R = Fint - lbd*Fext`, the convention of `pyfe3d.solver` and `panels`, with `K_T dc = -R` in the Newton-Raphson corrections and `dR/dlbd = -Fext`; the solutions are bitwise identical
 * 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)

{structsolve-0.9.1 → structsolve-0.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structsolve"
-version = "0.9.1"
+version = "0.9.3"
 description = "Structural analysis solvers"
 readme = "README.md"
 license = "BSD-3-Clause"

{structsolve-0.9.1 → structsolve-0.9.3}/structsolve/analysis.py

@@ -15,7 +15,7 @@ import numpy as np
 from .static import solve, _factorize
 from .logger import msg, warn
 from . import callbacks
-from .newton_raphson import _check_convergence, _weights
+from .newton_raphson import _check_convergence, _weights, _abs_matrix
 from .newton_raphson import _solver_NR
 from .arc_length_riks import _solver_arc_length_riks
 from .arc_length_crisfield import _solver_arc_length_crisfield
@@ -172,19 +172,20 @@ class Analysis(object):
     Notes
     -----
     For non-linear analyses, the internal force vector
-    `\{F_{int}(c)\}` must be in equilibrium with the external force
+    `\boldsymbol{F}_{int}(\boldsymbol{c})` must be in equilibrium with the external force
     vector scaled by the load factor `\lambda`:
 
     .. math::
 
-        \{R\} = \lambda \{F_{ext}\} - \{F_{int}(c)\} = \{0\}
+        \boldsymbol{R} = \boldsymbol{F}_{int}(\boldsymbol{c}) - \lambda \boldsymbol{F}_{ext} = \boldsymbol{0}
 
-    and the tangent stiffness matrix `[K_T] = [K_C] + [K_G]`, given by the
+    and the tangent stiffness matrix `\boldsymbol{K}_T = \boldsymbol{K}_C + \boldsymbol{K}_G`, given by the
     callables ``calc_kC`` and ``calc_kG``, should be the exact derivative of
-    `\{F_{int}\}` with respect to `\{c\}`, such that the Newton-Raphson
-    iterations converge quadratically. The convergence is checked by
-    default with Crisfield's criterion, the residual and the reference
-    force vectors scaled with the diagonal of the linear stiffness matrix
+    `\boldsymbol{F}_{int}` with respect to `\boldsymbol{c}`, `\boldsymbol{K}_T = \partial
+    \boldsymbol{R}/\partial \boldsymbol{c}`, such that the Newton-Raphson
+    iterations, `\boldsymbol{K}_T \delta \boldsymbol{c} = -\boldsymbol{R}`, converge
+    quadratically. The convergence is checked by default with Crisfield's
+    criterion, the residual and the reference force vectors scaled with the diagonal of the linear stiffness matrix
     ``calc_kC()`` over the free degrees of freedom, such that it does not
     depend on the units of each degree of freedom, e.g. translations and
     rotations, see :mod:`.convergence`; ``convergence = 'relative'`` keeps
@@ -209,15 +210,15 @@ class Analysis(object):
       such that ``calc_fint`` may contain the configuration-dependent part of
       the load, scaled by ``inc``, and ``calc_kC + calc_kG`` its derivative.
     - ``calc_fext(inc=1., c=c)`` must return the load vector of the
-      configuration ``c`` for a unit load factor, the derivative of the
-      residual with respect to the load factor, used by the arc-length
-      solvers.
+      configuration ``c`` for a unit load factor, minus the derivative of
+      the residual with respect to the load factor, `-\partial
+      \boldsymbol{R}/\partial \lambda`, 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
+      \boldsymbol{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
+      use `-\partial \boldsymbol{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 convergence criterion, see
       :mod:`.callbacks`. The linear static analysis never passes
@@ -313,29 +314,29 @@ class Analysis(object):
 
         Notes
         -----
-        The linear analysis solves `[K_C]\{c\} = \{F_{ext}\}`. When the load
+        The linear analysis solves `\boldsymbol{K}_C \boldsymbol{c} = \boldsymbol{F}_{ext}`. When the load
         depends on the configuration, the structure is still geometrically
         linear but the load is evaluated in the current configuration,
-        `[K_C]\{c\} = \{F_{ext}(c)\}`, which is solved by the load
+        `\boldsymbol{K}_C \boldsymbol{c} = \boldsymbol{F}_{ext}(\boldsymbol{c})`, which is solved by the load
         correction iterations
 
         .. math::
 
-            \{c_{k+1}\} = \{c_k\} + [K_C]^{-1}(\{F_{ext}(c_k)\}
-                          - [K_C]\{c_k\})
+            \boldsymbol{c}_{k+1} = \boldsymbol{c}_k + \boldsymbol{K}_C^{-1}(\boldsymbol{F}_{ext}(\boldsymbol{c}_k)
+                          - \boldsymbol{K}_C \boldsymbol{c}_k)
 
-        starting from `\{c_0\} = [K_C]^{-1}\{F_{ext}\}`, the solution of the
-        reference load ``calc_fext()``, with `\{F_{ext}(c_k)\}` given by
+        starting from `\boldsymbol{c}_0 = \boldsymbol{K}_C^{-1} \boldsymbol{F}_{ext}`, the solution of the
+        reference load ``calc_fext()``, with `\boldsymbol{F}_{ext}(\boldsymbol{c}_k)` given by
         ``calc_fext(inc=1., c=c_k)``. This is a fixed-point iteration
         without the load stiffness in the iteration matrix. For a follower
-        load whose force vector is affine in `c`, `\{F(c)\} = \{F_0\} -
-        [K_f]\{c\}`, this is the solution of `([K_C] + [K_f])\{c\} =
-        \{F_0\}`, with the convergence rate of the spectral radius of
-        `[K_C]^{-1}[K_f]`, i.e. of the ratio of the load to the lowest
+        load whose force vector is affine in `c`, `\boldsymbol{F}(\boldsymbol{c}) = \boldsymbol{F}_0 -
+        \boldsymbol{K}_f \boldsymbol{c}`, this is the solution of `(\boldsymbol{K}_C + \boldsymbol{K}_f) \boldsymbol{c} =
+        \boldsymbol{F}_0`, with the convergence rate of the spectral radius of
+        `\boldsymbol{K}_C^{-1} \boldsymbol{K}_f`, i.e. of the ratio of the load to the lowest
         critical load of the linearized problem; beyond it the iterations
-        diverge. The error is multiplied by `-[K_C]^{-1}[K_f]` at each
+        diverge. The error is multiplied by `-\boldsymbol{K}_C^{-1} \boldsymbol{K}_f` at each
         iteration, whose spectral radius is `1/\min|\lambda|` over the load
-        multipliers `\lambda` of `([K_C] + \lambda [K_f])\{u\} = \{0\}`,
+        multipliers `\lambda` of `(\boldsymbol{K}_C + \lambda \boldsymbol{K}_f) \boldsymbol{u} = \boldsymbol{0}`,
         including the negative and complex ones.
 
         """
@@ -378,15 +379,18 @@ class Analysis(object):
         msg('Configuration-dependent load: load correction iterations',
             level=2, silent=silent)
         w = _weights(self, k0)
+        k0_abs = _abs_matrix(k0)
         # 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
-            R = fext - fint
-            conv, Rnorm, Rrel = _check_convergence(self, R, fint, fext, w=w)
-            msg('Iteration: %d, %s = %1.3e' % (iteration, 'zeta' if
-                self.convergence == 'crisfield' else 'relative ||R||', Rrel),
+            R = fint - fext
+            conv, Rnorm, Rrel, roundoff = _check_convergence(self, R, fint,
+                    fext, w=w, Kc_abs=k0_abs @ np.abs(c), full_output=True)
+            msg('Iteration: %d, %s = %1.3e%s' % (iteration, 'zeta' if
+                self.convergence == 'crisfield' else 'relative ||R||', Rrel,
+                ', converged at the round-off floor' if roundoff else ''),
                 level=3, silent=silent)
             if conv:
                 return c
@@ -397,7 +401,7 @@ class Analysis(object):
                     solve_k0 = _factorize(k0)
                 except RuntimeError:
                     break
-            c = c + solve_k0(R)
+            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.9.1 → structsolve-0.9.3}/structsolve/arc_length.py

@@ -14,7 +14,7 @@ from .static import solve, _factorize
 from . import callbacks
 from .newton_raphson import (_check_convergence, _check_divergence,
                              _NR_iterations, _log_iteration, _weights,
-                             INC_CUT_FACTOR)
+                             _abs_matrix, INC_CUT_FACTOR)
 
 
 #: Scaling factor of the load-factor term in the arc-length constraint
@@ -75,65 +75,67 @@ def _solver_arc_length(an, method, silent=False):
 
     Notes
     -----
-    The equilibrium path `\{F_{int}(c)\} = \lambda \{F_{ext}\}` is traced with
+    The equilibrium path `\boldsymbol{F}_{int}(\boldsymbol{c}) = \lambda \boldsymbol{F}_{ext}` is traced with
     the arc-length constraint
 
     .. math::
 
-        \frac{\{\Delta c\}^T\{\Delta c\}}{\{u_{ref}\}^T\{u_{ref}\}}
+        \frac{\Delta \boldsymbol{c}^\top \Delta \boldsymbol{c}}{\boldsymbol{u}_{ref}^\top \boldsymbol{u}_{ref}}
         + \psi^2 \Delta\lambda^2 = \Delta s^2
 
-    where `\{\Delta c\}` and `\Delta\lambda` are the increments of the current
-    step and `\{u_{ref}\}` is the linear solution for `\lambda=1`, which makes
+    where `\Delta \boldsymbol{c}` and `\Delta\lambda` are the increments of the current
+    step and `\boldsymbol{u}_{ref}` is the linear solution for `\lambda=1`, which makes
     the arc length `\Delta s` independent of the units of the model. In the
     linear regime `\Delta s \approx \sqrt{1 + \psi^2} \Delta\lambda`. It is
     the spherical arc-length constraint of [4]_ (Section 9.3.2, Eq. (9.19),
     p. 271), where the displacement term is not scaled and the load term is
-    `\psi^2 \Delta\lambda^2 \{F_{ext}\}^T\{F_{ext}\}`. `\psi` is the
+    `\psi^2 \Delta\lambda^2 \boldsymbol{F}_{ext}^\top \boldsymbol{F}_{ext}`. `\psi` is the
     constant ``PSI``,
-    and `\{u_{ref}\}^T\{u_{ref}\}` is
+    and `\boldsymbol{u}_{ref}^\top \boldsymbol{u}_{ref}` is
     replaced by 1 when it is null. With the inner product
 
     .. math::
 
         \langle (a, \alpha), (b, \beta) \rangle =
-        \frac{\{a\}^T\{b\}}{\{u_{ref}\}^T\{u_{ref}\}} + \psi^2 \alpha \beta
+        \frac{\boldsymbol{a}^\top \boldsymbol{b}}{\boldsymbol{u}_{ref}^\top \boldsymbol{u}_{ref}} + \psi^2 \alpha \beta
 
     the constraint reads `g = \frac{1}{2}(\langle (\Delta c, \Delta\lambda),
     (\Delta c, \Delta\lambda) \rangle - \Delta s^2) = 0`.
 
     Each step starts from a tangent predictor, whose direction follows the
     previous increment, allowing limit points to be passed. With
-    `\{\delta c_q\} = [K_T]^{-1}\{F_{ext}\}` at the last converged state,
+    `\delta \boldsymbol{c}_q = \boldsymbol{K}_T^{-1} \boldsymbol{F}_{ext}` at the last converged state,
     the predictor
 
     .. math::
 
         \Delta\lambda = \pm \frac{\Delta s}{\sqrt{\langle (\delta c_q, 1),
         (\delta c_q, 1) \rangle}}, \qquad
-        \{\Delta c\} = \Delta\lambda \{\delta c_q\}
+        \Delta \boldsymbol{c} = \Delta\lambda \delta \boldsymbol{c}_q
 
     satisfies the constraint, with the sign of `\langle (\delta c_q, 1),
     (\Delta c_{prev}, \Delta\lambda_{prev}) \rangle`, where
     `(\Delta c_{prev}, \Delta\lambda_{prev})` is the increment of the
     previous converged step, and a positive sign at the first step. The
-    initial arc length, `\Delta s_0 = initialInc \sqrt{\langle (\delta c_q,
-    1), (\delta c_q, 1) \rangle}` at the origin, corresponds to a load factor
+    initial arc length, `\Delta s_0 = initialInc \sqrt{\langle (\delta \boldsymbol{c}_q,
+    1), (\delta \boldsymbol{c}_q, 1) \rangle}` at the origin, corresponds to a load factor
     increment of ``an.initialInc`` along the initial tangent.
 
-    At each iteration, the residual is `\{R\} = (\lambda + \Delta\lambda)
-    \{F_{ext}\} - \{F_{int}(c + \Delta c)\}`, and the bordered system is
+    At each iteration, the residual is `\boldsymbol{R} = \boldsymbol{F}_{int}(\boldsymbol{c} +
+    \Delta \boldsymbol{c}) - (\lambda + \Delta\lambda) \boldsymbol{F}_{ext}`, with `\partial
+    \boldsymbol{R}/\partial \lambda = -\boldsymbol{F}_{ext}`, and the bordered system
+    `\boldsymbol{K}_T \delta \boldsymbol{c} - \delta\lambda \, \boldsymbol{F}_{ext} = -\boldsymbol{R}` is
     solved with two solutions of the tangent stiffness matrix,
-    `\{\delta c_R\} = [K_T]^{-1}\{R\}` and `\{\delta c_q\} =
-    [K_T]^{-1}\{F_{ext}\}`; the increment is updated to `(\Delta c +
-    \delta c_R + \delta\lambda \, \delta c_q, \Delta\lambda +
+    `\delta \boldsymbol{c}_R = -\boldsymbol{K}_T^{-1} \boldsymbol{R}` and `\delta \boldsymbol{c}_q =
+    \boldsymbol{K}_T^{-1} \boldsymbol{F}_{ext}`; the increment is updated to `(\Delta \boldsymbol{c} +
+    \delta \boldsymbol{c}_R + \delta\lambda \, \delta \boldsymbol{c}_q, \Delta\lambda +
     \delta\lambda)`, where the correction of the load factor
     `\delta\lambda` comes from the constraint:
 
     - ``method='riks'``: the constraint is linearized at the current
       increment (updated normal plane), which is Newton-Raphson applied to
       the augmented system of the equilibrium equations and the constraint
-      ([4]_, Section 9.3.2, p. 272), with quadratic convergence when `[K_T]`
+      ([4]_, Section 9.3.2, p. 272), with quadratic convergence when `\boldsymbol{K}_T`
       is updated at every iteration and is the exact Jacobian. It follows
       Riks [1]_, who applies Newton's method to the equilibrium equations
       augmented with an equation that controls the arc length, and states
@@ -158,7 +160,7 @@ def _solver_arc_length(an, method, silent=False):
     - ``method='crisfield'``: the quadratic (spherical) constraint is solved
       exactly, choosing the root with the smallest angle to the current
       increment. When the roots are complex, the linearized constraint is
-      used, see [2]_. With `\{u\} = \{\Delta c\} + \{\delta c_R\}`, the
+      used, see [2]_. With `\boldsymbol{u} = \Delta \boldsymbol{c} + \delta \boldsymbol{c}_R`, the
       constraint
       `\langle (u + \delta\lambda \, \delta c_q, \Delta\lambda +
       \delta\lambda), (u + \delta\lambda \, \delta c_q, \Delta\lambda +
@@ -174,8 +176,20 @@ def _solver_arc_length(an, method, silent=False):
       angle, since both have the length `\Delta s`.
 
     The step fails when `\delta\lambda` cannot be computed or is not
-    finite. With full Newton-Raphson, `[K_T]` is updated at every iteration
-    at the current iterate `(c + \Delta c, \lambda + \Delta\lambda)`; with
+    finite, and when the converged increment points against the tangent
+    predictor `(\Delta c_{pred}, \Delta\lambda_{pred})` of the step,
+    `\langle (\Delta c, \Delta\lambda), (\Delta c_{pred},
+    \Delta\lambda_{pred}) \rangle \le 0`. The previous converged point is
+    also at the distance `\Delta s` from the last one, and with long steps
+    or near a limit point the iterations may converge to it and then trace
+    the path backwards, the "doubling back" that [2]_ (p. 56) avoids with
+    the choice of the root. The accepted points are thus on the side of the
+    tangent predictor of the hyperplane normal to it, in the inner product
+    above, through the last converged point, as the points of the plane of
+    Riks [1]_, normal to the tangent at the distance `\Delta s` from the
+    last converged point. With full Newton-Raphson, `\boldsymbol{K}_T` is updated at
+    every iteration at the current iterate `(c + \Delta c, \lambda +
+    \Delta\lambda)`; with
     ``an.modified_NR = True`` the factorization at the last converged state
     is used for the first ``an.compute_every_n`` iterations and the tangent
     is then updated every ``an.compute_every_n`` iterations; at the first
@@ -198,27 +212,27 @@ def _solver_arc_length(an, method, silent=False):
     `\lambda < 1` to `\lambda + \Delta\lambda > 1`, the step is replaced by
     Newton-Raphson iterations at exactly `\lambda = 1`, see
     :func:`.newton_raphson._NR_iterations`, from the predictor
-    `t \{\Delta c\}` with `t = (1 - \lambda)/\Delta\lambda`. When these
+    `t \Delta \boldsymbol{c}` with `t = (1 - \lambda)/\Delta\lambda`. When these
     iterations do not converge, the step is repeated with a shorter arc
     length.
 
     When the load depends on the configuration, i.e. ``calc_fext`` accepts
-    the keyword argument ``c``, `\{F_{ext}\}` in `\{\delta c_q\}` and in the
+    the keyword argument ``c``, `\boldsymbol{F}_{ext}` in `\delta \boldsymbol{c}_q` and in the
     tangent predictor is the load vector of the current configuration
-    ``calc_fext(inc=1., c=c)``, the derivative `\partial R/\partial
-    \lambda` of the residual, whereas `\{u_{ref}\}` remains the linear
+    ``calc_fext(inc=1., c=c)``, minus the derivative `\partial \boldsymbol{R}/\partial
+    \lambda` of the residual, whereas `\boldsymbol{u}_{ref}` remains the linear
     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`
+    together with the configuration, `\boldsymbol{F}_{ext}` above being then
+    `-\partial \boldsymbol{R}/\partial \lambda` at the current `c` and `\lambda`;
+    `\boldsymbol{u}_{ref}` is the linear solution of `-\partial \boldsymbol{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
+    under a prescribed displacement alone; and `-\lambda \, \partial
+    \boldsymbol{R}/\partial \lambda` is an additional reference of the relative
+    convergence criterion. `-\partial \boldsymbol{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
@@ -249,9 +263,10 @@ def _solver_arc_length(an, method, silent=False):
     fext = an.calc_fext(inc=1., silent=True)
     kC0 = an.calc_kC(silent=silent)
     w = _weights(an, kC0)
+    K0_abs = _abs_matrix(kC0)
     lbd_dependent = callbacks.is_load_factor_dependent(an)
     if lbd_dependent:
-        # dR/dlbd at c = 0 and lbd = 0
+        # -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:
@@ -293,7 +308,7 @@ 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, kept with
+            # 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
@@ -313,6 +328,9 @@ def _solver_arc_length(an, method, silent=False):
                 sign = 1.
         dlbd = sign*arc_length/norm_q
         dc = dlbd*dc_q_conv
+        # tangent predictor, the forward direction of the step
+        dc_pred = dc
+        dlbd_pred = dlbd
 
         msg('Step %d, lbd %1.5f, arc-length increment %1.5f' % (step_num, lbd, arc_length),
             level=1, silent=silent)
@@ -321,7 +339,7 @@ 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
+        # the last -dR/dlbd evaluated, with the tangent stiffness matrix
         q_iter = q_conv
         iter_kT = 0
         iteration = 0
@@ -329,14 +347,15 @@ def _solver_arc_length(an, method, silent=False):
             iteration += 1
             fint = callbacks.calc_fint(an, c + dc, lbd + dlbd)
             fext_total = (lbd + dlbd)*fext
-            R = fext_total - fint
+            R = fint - fext_total
             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,
-                                                   q_ref=q_ref, w=w)
-            _log_iteration(an, iteration, R, Rrel, silent, lbd=lbd + dlbd)
+            conv, Rnorm, Rrel, roundoff = _check_convergence(an, R, fint,
+                    fext_total, fext_ref=dlbd*fext, q_ref=q_ref, w=w,
+                    Kc_abs=K0_abs @ np.abs(c + dc), full_output=True)
+            _log_iteration(an, iteration, R, Rrel, silent, lbd=lbd + dlbd,
+                           roundoff=roundoff)
             if conv:
                 converged = True
                 break
@@ -355,7 +374,7 @@ def _solver_arc_length(an, method, silent=False):
                     warn('Singular tangent stiffness matrix', level=2, silent=silent)
                     break
                 if lbd_dependent:
-                    # dR/dlbd at the iterate of the tangent stiffness matrix
+                    # -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)
@@ -363,7 +382,7 @@ def _solver_arc_length(an, method, silent=False):
                     dc_q = solve_kT(callbacks.calc_load_vector(an, c + dc,
                                                                fext))
                 iter_kT = 1
-            dc_R = solve_kT(R)
+            dc_R = solve_kT(-R)
 
             # linearized constraint
             den = inner(dc, dlbd, dc_q, 1.)
@@ -393,13 +412,20 @@ def _solver_arc_length(an, method, silent=False):
             dc = dc + dc_R + varlbd*dc_q
             dlbd = dlbd + varlbd
 
+        if converged and inner(dc, dlbd, dc_pred, dlbd_pred) <= 0:
+            # the increment points backwards, e.g. to the previous converged
+            # point, which is also at the distance arc_length
+            warn('Diverged - the step returned along the path already traced',
+                 level=2, silent=silent)
+            converged = False
+
         finished = 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, lbd_dependent=lbd_dependent,
-                    q=q_iter, w=w)
+                    q=q_iter, w=w, K0_abs=K0_abs)
             if converged:
                 msg('Converged at load factor 1.00000', level=2, silent=silent)
                 an.cs.append((c + dc1).copy())

{structsolve-0.9.1 → structsolve-0.9.3}/structsolve/arpackutils.py

@@ -37,7 +37,6 @@ import io
 import os
 import re
 import sys
-import warnings
 
 import numpy as np
 from scipy.linalg import cholesky, eigh, solve_triangular
@@ -407,27 +406,27 @@ def _rayleigh_ritz(A, M, V):
     Notes
     -----
     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
+    `\boldsymbol{M}`-orthogonal to the accuracy of ARPACK, e.g. `10^{-6}` between
+    close eigenvalues of different passes. `\boldsymbol{V}` is `\boldsymbol{M}`-orthonormalized
+    with the Cholesky factor `\boldsymbol{L}` of `\boldsymbol{V}^\top \boldsymbol{M} \boldsymbol{V}`, and the projected
+    problem `\boldsymbol{W}^\top \boldsymbol{A} \boldsymbol{W} \boldsymbol{y} = w \boldsymbol{y}`, with `\boldsymbol{W} = \boldsymbol{V} \boldsymbol{L}^{-\top}`, 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. `[V]^T[M][V]` and
-    `[W]^T[A][W]` are symmetrized, `\frac{1}{2}([B] + [B]^T)`, before the
+    :func:`dsteqr_is_faulty`. The returned eigenvectors `\boldsymbol{W} \boldsymbol{y}` are
+    `\boldsymbol{M}`-orthonormal to the rounding errors, and the Ritz values are at
+    least as accurate as the eigenvalues of the passes. `\boldsymbol{V}^\top \boldsymbol{M} \boldsymbol{V}` and
+    `\boldsymbol{W}^\top \boldsymbol{A} \boldsymbol{W}` are symmetrized, `\frac{1}{2}(\boldsymbol{B} + \boldsymbol{B}^\top)`, before the
     Cholesky factorization and the eigenvalue solution.
 
     The Ritz values are the optimal approximations of the eigenvalues that
-    can be obtained from the subspace spanned by the columns of `[V]`
+    can be obtained from the subspace spanned by the columns of `\boldsymbol{V}`
     ([1]_, Chapter 11, "Approximations from a Subspace", Section 11.4,
     "Optimality", Eq. (11.5) and Theorem 11.4.1, p. 236): the `j`-th
     Ritz value is the minimum over the `j`-dimensional subspaces of the span
     of the maximum of the Rayleigh quotient, so it can only improve when the
     span grows, and the span contains the eigenvectors of every pass. The
     theorem is stated for the standard problem; it holds for the pencil in
-    the `[M]` inner product, through the Cholesky factor of `[V]^T[M][V]`.
+    the `\boldsymbol{M}` inner product, through the Cholesky factor of `\boldsymbol{V}^\top \boldsymbol{M} \boldsymbol{V}`.
 
     References
     ----------
@@ -446,7 +445,7 @@ def _rayleigh_ritz(A, M, V):
 def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
     r""":func:`scipy.sparse.linalg.eigsh` with ``ncv`` from :func:`arpack_ncv`
 
-    Solves `[A]\{x\} = w [M]\{x\}` with a positive definite ``M`` about the
+    Solves `\boldsymbol{A} \boldsymbol{x} = w \boldsymbol{M} \boldsymbol{x}` with a positive definite ``M`` about the
     shift ``sigma``, in the shift-invert (``mode='normal'``) or Cayley
     (``mode='cayley'``) mode, selecting the eigenvalues by increasing `w`,
     e.g. the Cayley mode with ``which='SM'`` and ``sigma`` larger than all
@@ -490,7 +489,7 @@ def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
     Returns
     -------
     w, x : ndarray
-        The eigenvalues and the `[M]`-orthonormal eigenvectors, by
+        The eigenvalues and the `\boldsymbol{M}`-orthonormal eigenvectors, by
         increasing `w` when computed in passes. ``w`` is a 1-D array of size
         ``k`` and ``x`` an array of shape ``(n, k)``.
 
@@ -502,7 +501,7 @@ def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
     -----
     In the shift-invert mode ARPACK computes the eigenvalues
     `\nu = 1/(w - \sigma)` of largest modulus of the operator
-    `([A] - \sigma [M])^{-1}[M]`, i.e. the `w` nearest `\sigma` ([1]_,
+    `(\boldsymbol{A} - \sigma \boldsymbol{M})^{-1} \boldsymbol{M}`, i.e. the `w` nearest `\sigma` ([1]_,
     Chapter 3, Section 3.2, Eq. (3.2.2)).
     The passes keep ``k <= (max_ncv - 1)//2``, i.e. ``ncv >= 2 k + 1``.
     With ``k`` close to ``ncv`` ARPACK converges very slowly, not at all, or
@@ -510,22 +509,22 @@ def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
 
     The passes after the first one use the shift-invert mode about
     `\sigma_d`, the middle of the largest gap between the last five
-    eigenvalues found, with the eigenvectors `[V]` of the previous passes
+    eigenvalues found, with the eigenvectors `\boldsymbol{V}` of the previous passes
     deflated from the operator:
 
     .. math::
 
-        \{y\} = ([I] - [V][V]^T[M])([A] - \sigma_d [M])^{-1}\{x\}
+        \boldsymbol{y} = (\boldsymbol{I} - \boldsymbol{V} \boldsymbol{V}^\top \boldsymbol{M})(\boldsymbol{A} - \sigma_d \boldsymbol{M})^{-1} \boldsymbol{x}
 
-    such that the eigenvalues of `[V]`, already found, become null and are
+    such that the eigenvalues of `\boldsymbol{V}`, already found, become null and are
     not found again. Each pass therefore returns the eigenvalues nearest
     `\sigma_d` among those not found yet, i.e. the next ones by increasing
     `w`. A shift close to them, instead of ``sigma``, separates them better:
     in the study of the panels cylinders it was 30 to 45% faster and gave
     eigenvalues 5 to 10 times more accurate. ARPACK applies the operator
-    to `[M]\{x\}`; for an eigenvector `\{v_i\}` of `[V]`,
-    `([A] - \sigma_d [M])^{-1}[M]\{v_i\} = \{v_i\}/(w_i - \sigma_d)` and,
-    `[V]` being `[M]`-orthonormal, `([I] - [V][V]^T[M])\{v_i\} = \{0\}`.
+    to `\boldsymbol{M} \boldsymbol{x}`; for an eigenvector `\boldsymbol{v}_i` of `\boldsymbol{V}`,
+    `(\boldsymbol{A} - \sigma_d \boldsymbol{M})^{-1} \boldsymbol{M} \boldsymbol{v}_i = \boldsymbol{v}_i/(w_i - \sigma_d)` and,
+    `\boldsymbol{V}` being `\boldsymbol{M}`-orthonormal, `(\boldsymbol{I} - \boldsymbol{V} \boldsymbol{V}^\top \boldsymbol{M}) \boldsymbol{v}_i = \boldsymbol{0}`.
 
     References
     ----------
@@ -557,9 +556,7 @@ def capped_eigsh(A, k, M, sigma, which, mode='normal', tol=0):
         order = np.argsort(w, kind='stable')
         w, V = w[order], V[:, order]
         sigma_d = _deflation_shift(w, far_shift)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            lu = splu(csc_matrix(A - sigma_d*M))
+        lu = splu(csc_matrix(A - sigma_d*M))
         MV = M @ V
 
         def matvec(x, V=V, MV=MV, lu=lu):