structsolve 0.3.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.3.0
+Version: 0.4.0
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Requires-Python: >=3.8
@@ -57,9 +58,50 @@ Currently these solvers are pretty much compatible with my other repositories
 [buckling](https://github.com/saullocastro/buckling).
 
 
+Citing this library
+===================
+
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+
+
+Documentation
+=============
+
+The documentation is available on: https://saullocastro.github.io/structsolve.
+
+
+
+History
+=======
+
+See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
+
+* version 0.4.0 (2026-09-17)
+    - Newton-Raphson with full Newton iterations and a relative convergence
+      criterion by default, reaching quadratic convergence with exact tangent
+      stiffness matrices
+    - Fixed the load-factor bookkeeping of Newton-Raphson, which could finish
+      before reaching the full load
+    - Arc-length methods (Riks and Crisfield) rewritten, able to trace limit
+      points, snap-through and snap-back until a load factor of exactly 1.0
+    - Sphinx documentation
+* version 0.3.1 (2026-04-09)
+    - Robust estimation of the eigenvalue shift for singular matrices in
+      `freq` and `lb`, and new `skip_null_cols` argument
+    - Python 3.14 support
+    - Estimation of the eigenvalue shift in `freq` and `lb`
+    - Packaging with `pyproject.toml`, GitHub Actions and a test suite
+* version 0.2.2 (2019-03-02)
+    - Release of 0.2.1 with an updated distribution
+    - Fixed the dense solver of `freq`
+    - `freq` returns the eigenvalues `lambda**2` instead of the natural
+      frequencies
+* version 0.1.0 (2018-06-23)
+    - First release, with the solvers from `compmech`
+
 License
 -------
-Distrubuted in the 3-Clause BSD license (https://raw.github.com/saullocastro/structsolve/master/LICENSE).
+Distributed in the 3-Clause BSD license (https://raw.github.com/saullocastro/structsolve/master/LICENSE).
 
 Contact: S.G.P.Castro@tudelft.nl
 

structsolve-0.4.0/README.md

@@ -0,0 +1,70 @@
+Github Actions status:
+[![pytest](https://github.com/saullocastro/structsolve/actions/workflows/pytest.yml/badge.svg)](https://github.com/saullocastro/structsolve/actions/workflows/pytest.yml)
+[![Deploy](https://github.com/saullocastro/structsolve/actions/workflows/pythonpublish.yml/badge.svg)](https://github.com/saullocastro/structsolve/actions/workflows/pythonpublish.yml)
+
+Coverage status:
+[![codecov](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml/badge.svg)](https://github.com/saullocastro/structsolve/actions/workflows/coverage.yml)
+[![Codecov Status](https://codecov.io/gh/saullocastro/structsolve/branch/master/graph/badge.svg)](https://codecov.io/gh/saullocastro/structsolve)
+
+
+Structural analysis solvers tailored for semi-analytical models
+===============================================================
+
+- Linear statics: [K]{u} = {f}
+- Eigensolver for Linear buckling: ([K] + lambda[KG]){u} = 0
+- Eigensolver for dynamics: ([K] + lambda^2[M]){u} = 0
+- Nonlinear statics using Newton-Raphson 
+- Nonlinear statics using the Arc-Length method
+
+Currently these solvers are pretty much compatible with my other repositories
+[panels](https://github.com/saullocastro/panels), 
+[buckling](https://github.com/saullocastro/buckling).
+
+
+Citing this library
+===================
+
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+
+
+Documentation
+=============
+
+The documentation is available on: https://saullocastro.github.io/structsolve.
+
+
+
+History
+=======
+
+See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
+
+* version 0.4.0 (2026-09-17)
+    - Newton-Raphson with full Newton iterations and a relative convergence
+      criterion by default, reaching quadratic convergence with exact tangent
+      stiffness matrices
+    - Fixed the load-factor bookkeeping of Newton-Raphson, which could finish
+      before reaching the full load
+    - Arc-length methods (Riks and Crisfield) rewritten, able to trace limit
+      points, snap-through and snap-back until a load factor of exactly 1.0
+    - Sphinx documentation
+* version 0.3.1 (2026-04-09)
+    - Robust estimation of the eigenvalue shift for singular matrices in
+      `freq` and `lb`, and new `skip_null_cols` argument
+    - Python 3.14 support
+    - Estimation of the eigenvalue shift in `freq` and `lb`
+    - Packaging with `pyproject.toml`, GitHub Actions and a test suite
+* version 0.2.2 (2019-03-02)
+    - Release of 0.2.1 with an updated distribution
+    - Fixed the dense solver of `freq`
+    - `freq` returns the eigenvalues `lambda**2` instead of the natural
+      frequencies
+* version 0.1.0 (2018-06-23)
+    - First release, with the solvers from `compmech`
+
+License
+-------
+Distributed in the 3-Clause BSD license (https://raw.github.com/saullocastro/structsolve/master/LICENSE).
+
+Contact: S.G.P.Castro@tudelft.nl
+

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structsolve"
-version = "0.3.0"
+version = "0.4.0"
 description = "Structural analysis solvers"
 readme = "README.md"
 license = {text = "BSD-2-Clause"}
@@ -28,6 +28,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: Unix",
 ]

structsolve-0.4.0/structsolve/__init__.py

@@ -0,0 +1,24 @@
+r"""
+===============================================
+Structural Analysis Solver (:mod:`structsolve`)
+===============================================
+
+.. currentmodule:: structsolve
+
+Structural analysis solvers tailored for semi-analytical models, available
+directly from the ``structsolve`` namespace:
+
+- :class:`.Analysis`: linear and non-linear static analyses, using the
+  Newton-Raphson or the arc-length methods
+- :func:`.solve`: solution of linear systems removing null rows and columns
+- :func:`.static`: linear static analysis
+- :func:`.lb`: linear buckling analysis
+- :func:`.freq`: frequency analysis
+
+"""
+from __future__ import absolute_import
+
+from .analysis import Analysis
+from .freq import freq
+from .linear_buckling import lb
+from .static import solve, static

structsolve-0.4.0/structsolve/analysis.py

@@ -0,0 +1,243 @@
+from __future__ import absolute_import
+
+from .static import solve
+from .logger import msg
+from .newton_raphson import _solver_NR
+from .arc_length_riks import _solver_arc_length_riks
+from .arc_length_crisfield import _solver_arc_length_crisfield
+
+
+class Analysis(object):
+    r"""Class that embodies all data required for linear/non-linear analysis
+
+    The structural model is defined by the callables passed to the
+    constructor, which return the force vectors and stiffness matrices. The
+    static analysis, linear or non-linear, is run with :meth:`.static`, whose
+    solution is stored in the attributes ``increments`` and ``cs``.
+
+    For non-linear analyses, the internal force vector
+    `\{F_{int}(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\}
+
+    and the tangent stiffness matrix `[K_T] = [K_C] + [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 analysis parameters are attributes of this class, described in the
+    following tables together with their default values:
+
+    ========================  ==================================================
+    Non-Linear Algorithm      Description
+    ========================  ==================================================
+    ``NL_method``             ``str``, ``'NR'`` (default) for the
+                              Newton-Raphson method, see
+                              :func:`.newton_raphson._solver_NR`, or
+                              ``'arc_length_riks'`` and
+                              ``'arc_length_crisfield'`` for the arc-length
+                              methods, see
+                              :func:`.arc_length._solver_arc_length`
+    ``line_search``           ``bool``, activates a safeguarding line-search,
+                              for the Newton-Raphson method only. The full
+                              step is tried first and only reduced when it
+                              fails a sufficient-decrease test on the
+                              residual norm. Default is ``False``
+    ``max_iter_line_search``  ``int``, maximum number of iterations of the
+                              line-search. Default is ``20``
+    ``modified_NR``           ``bool``, activates the modified Newton-Raphson
+                              method, where the tangent stiffness matrix is
+                              not updated at every iteration. Default is
+                              ``False``, i.e. full Newton-Raphson
+    ``compute_every_n``       ``int``, if ``modified_NR=True``, the tangent
+                              stiffness matrix is updated at every `n`
+                              iterations. Default is ``6``
+    ``kT_initial_state``      ``bool``, if ``modified_NR=True``, tells if the
+                              tangent stiffness matrix should be calculated
+                              already at the first iteration of the analysis,
+                              which is required for example when initial
+                              imperfections take place. Otherwise the linear
+                              constitutive stiffness matrix is used. Default
+                              is ``True``
+    ========================  ==================================================
+
+    ================   =================================================
+    Incrementation     Description
+    ================   =================================================
+    ``initialInc``     initial load increment. In the arc-length
+                       methods it defines the initial arc-length
+                       increment, corresponding to a load factor
+                       increment of ``initialInc`` along the initial
+                       tangent. Default is ``0.1``
+    ``minInc``         minimum increment; the analysis stops when the
+                       load increment (Newton-Raphson) or the arc-length
+                       increment (arc-length methods) becomes smaller
+                       than ``minInc``. Default is ``1.e-4``
+    ``maxInc``         maximum load increment, or maximum arc-length
+                       increment for the arc-length methods. Default is
+                       ``1.``
+    ``maxArcLength``   maximum cumulative arc length covered by the
+                       arc-length methods. The arc length is
+                       dimensionless, with displacements scaled by the
+                       linear solution for a load factor of 1, such
+                       that in the linear regime an arc length of
+                       about ``sqrt(2)`` corresponds to a load factor
+                       increment of 1. Default is ``18``
+    ================   =================================================
+
+    ====================    ============================================
+    Convergence Criteria    Description
+    ====================    ============================================
+    ``relTOL``              the convergence is achieved when the norm of
+                            the residual force vector is smaller than
+                            ``relTOL`` times the largest norm between the
+                            external and internal force vectors. Not used
+                            if ``None``. Default is ``1.e-6``
+    ``absTOL``              the convergence is also achieved when the
+                            maximum absolute residual force is smaller
+                            than this value, which depends on the units of
+                            the model. Not used if ``None``. Default is
+                            ``None``
+    ``maxNumIter``          maximum number of iterations (corrections) of a
+                            step; if achieved the increment is reduced.
+                            Default is ``30``
+    ``too_slow_TOL``        a step is considered too slow when the smallest
+                            residual norm is not reduced by this fraction
+                            over the last iterations; the increment is then
+                            reduced. Default is ``0.005``
+    ====================    ============================================
+
+    Parameters
+    ----------
+    calc_fext : callable, optional
+        ``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.
+    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
+        non-linear analyses.
+    calc_kC : callable, optional
+        ``calc_kC(c=None, NLgeom=False, silent=False)``, must return a sparse
+        matrix with the constitutive stiffness matrix. With ``c=None`` and
+        ``NLgeom=False`` it must return the linear stiffness matrix, and with
+        ``NLgeom=True`` the constitutive part of the tangent stiffness matrix
+        at ``c``. Required for linear and non-linear static analyses.
+    calc_kG : callable, optional
+        ``calc_kG(c=None, NLgeom=False, silent=False)``, must return a sparse
+        matrix with the geometric stiffness matrix at ``c``. It is called
+        with ``NLgeom=True``. Required for non-linear analyses.
+
+    Attributes
+    ----------
+    increments : list
+        Load factors of the converged increments, filled by :meth:`.static`.
+    cs : list
+        Solution vectors of the converged increments, filled by
+        :meth:`.static`.
+    last_analysis : str
+        Type of the last analysis run, ``'static'`` after :meth:`.static`.
+
+    """
+    __slots__ = ['NL_method', 'line_search', 'max_iter_line_search',
+            'modified_NR', 'compute_every_n',
+            'kT_initial_state', 'initialInc', 'minInc', 'maxInc',
+            'maxArcLength', 'absTOL', 'relTOL', 'maxNumIter', 'too_slow_TOL',
+            'increments', 'cs', 'last_analysis', 'calc_fext', 'calc_kC',
+            'calc_fint', 'calc_kG']
+
+
+    def __init__(self, calc_fext=None, calc_fint=None, calc_kC=None,
+            calc_kG=None):
+        # non-linear algorithm
+        self.NL_method = 'NR'
+        self.line_search = False
+        self.max_iter_line_search = 20
+        self.modified_NR = False
+        self.compute_every_n = 6
+        self.kT_initial_state = True
+        # incrementation
+        self.initialInc = 0.1
+        self.minInc = 1.e-4
+        self.maxInc = 1.
+        self.maxArcLength = 18
+        # convergence criteria
+        self.absTOL = None
+        self.relTOL = 1.e-6
+        self.maxNumIter = 30
+        self.too_slow_TOL = 0.005
+
+        # required methods
+        self.calc_fext = calc_fext
+        self.calc_fint = calc_fint
+        self.calc_kC = calc_kC
+        self.calc_kG = calc_kG
+
+        # outputs to be filled
+        self.increments = None
+        self.cs = None
+
+        # flag telling the last analysis
+        self.last_analysis = ''
+
+
+    def static(self, NLgeom=False, silent=False):
+        r"""General solver for static analyses
+
+        The linear analysis solves `[K_C]\{c\} = \{F_{ext}\}` using
+        :func:`.solve`. The non-linear analysis uses the solver selected by
+        the ``NL_method`` attribute.
+
+        Parameters
+        ----------
+        NLgeom : bool, optional
+            Flag to indicate whether a linear or a non-linear analysis is to
+            be performed.
+        silent : bool, optional
+            A boolean to tell whether the log messages should be printed.
+
+        Returns
+        -------
+        increments : list
+            Load factors of the converged increments. A linear analysis
+            returns ``[1.]``. Non-linear analyses finish at a load factor of
+            exactly ``1.`` unless they are stopped earlier, see the
+            documentation of each solver.
+        cs : list
+            Solution vectors of the converged increments.
+
+        """
+        self.increments = []
+        self.cs = []
+
+        if NLgeom:
+            self.maxInc = max(self.initialInc, self.maxInc)
+            msg('Started Non-Linear Static Analysis', silent=silent)
+            if self.NL_method == 'NR':
+                _solver_NR(self, silent=silent)
+            elif self.NL_method == 'arc_length_riks':
+                _solver_arc_length_riks(self, silent=silent)
+            elif self.NL_method == 'arc_length_crisfield':
+                _solver_arc_length_crisfield(self, silent=silent)
+            else:
+                raise ValueError('{0} is an invalid NL_method'.format(self.NL_method))
+
+        else:
+            msg('Started Linear Static Analysis', silent=silent)
+            fext = self.calc_fext(silent=silent)
+            k0 = self.calc_kC(silent=silent)
+
+            c = solve(k0, fext, silent=silent)
+
+            self.cs.append(c)
+            self.increments.append(1.)
+            msg('Finished Linear Static Analysis', silent=silent)
+
+        self.last_analysis = 'static'
+
+        return self.increments, self.cs
+