PyNiteFEA 3.0.0__tar.gz → 3.1.0__tar.gz

{pynitefea-3.0.0 → pynitefea-3.1.0}/PKG-INFO

@@ -1,55 +1,42 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 3.0.0
-Summary: A simple elastic 3D structural finite element library for Python.
-Home-page: https://github.com/JWock82/Pynite.git
-Author: D. Craig Brinck, PE, SE
-Author-email: Building.Code@outlook.com
+Version: 3.1.0
+Summary: A simple 3D structural finite element library for Python.
+Author-email: "D. Craig Brinck, PE, SE" <Building.Code@outlook.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/JWock82/Pynite
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: matplotlib
 Requires-Dist: numpy>=2.4.0
-Requires-Dist: PrettyTable
+Requires-Dist: prettytable
 Requires-Dist: scipy
-Requires-Dist: matplotlib
 Provides-Extra: all
-Requires-Dist: Ipython; extra == "all"
-Requires-Dist: vtk>=9.3.0; extra == "all"
-Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "all"
-Requires-Dist: trame_jupyter_extension; extra == "all"
+Requires-Dist: ipython; extra == "all"
 Requires-Dist: ipywidgets; extra == "all"
-Requires-Dist: pdfkit; extra == "all"
-Requires-Dist: Jinja2; extra == "all"
+Requires-Dist: jinja2; extra == "all"
+Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "all"
+Requires-Dist: trame-jupyter-extension; extra == "all"
+Requires-Dist: vtk>=9.3.0; extra == "all"
 Provides-Extra: vtk
-Requires-Dist: IPython; extra == "vtk"
+Requires-Dist: ipython; extra == "vtk"
 Requires-Dist: vtk>=9.3.0; extra == "vtk"
 Provides-Extra: pyvista
-Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "pyvista"
-Requires-Dist: trame_jupyter_extension; extra == "pyvista"
 Requires-Dist: ipywidgets; extra == "pyvista"
+Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "pyvista"
+Requires-Dist: trame-jupyter-extension; extra == "pyvista"
 Provides-Extra: reporting
-Requires-Dist: pdfkit; extra == "reporting"
-Requires-Dist: Jinja2; extra == "reporting"
+Requires-Dist: jinja2; extra == "reporting"
 Provides-Extra: derivations
 Requires-Dist: jupyterlab; extra == "derivations"
 Requires-Dist: sympy; extra == "derivations"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 <div align="center">
   <img src="https://github.com/JWock82/Pynite/raw/main/Resources/Full Logo No Buffer.png" width=40% align="center"/>
@@ -122,6 +109,10 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+3.1.0
+* Improved detection of unstable structures.
+* Bug fix for shear walls. Shear walls were erroneously tracking other plates in the model for internal pier/coupling beam force summations, rather than just the plates related to the individual shear wall.
+
 3.0.0
 * Added pushover analysis! Currently, only steel sections are supported for pushover analysis. The assumed interaction equation used to estimate plastic behavior is currently calibrated toward I-shaped members.
 * Refactored all elastic stiffness matrix references from `K` and `k` to `Ke` and `ke`. Most users will not notice this change. Power users who were accessing the stiffness matrices directly will want to note this refactor.  This clarifies the code base by indicating which type of stiffness these matrices represent, and reduces ambiguity in preparation for addition of further geometric `Kg/kg` and plastic `Km/km` stiffness matrices.

{pynitefea-3.0.0 → pynitefea-3.1.0}/PyNiteFEA.egg-info/PKG-INFO

@@ -1,55 +1,42 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 3.0.0
-Summary: A simple elastic 3D structural finite element library for Python.
-Home-page: https://github.com/JWock82/Pynite.git
-Author: D. Craig Brinck, PE, SE
-Author-email: Building.Code@outlook.com
+Version: 3.1.0
+Summary: A simple 3D structural finite element library for Python.
+Author-email: "D. Craig Brinck, PE, SE" <Building.Code@outlook.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/JWock82/Pynite
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: matplotlib
 Requires-Dist: numpy>=2.4.0
-Requires-Dist: PrettyTable
+Requires-Dist: prettytable
 Requires-Dist: scipy
-Requires-Dist: matplotlib
 Provides-Extra: all
-Requires-Dist: Ipython; extra == "all"
-Requires-Dist: vtk>=9.3.0; extra == "all"
-Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "all"
-Requires-Dist: trame_jupyter_extension; extra == "all"
+Requires-Dist: ipython; extra == "all"
 Requires-Dist: ipywidgets; extra == "all"
-Requires-Dist: pdfkit; extra == "all"
-Requires-Dist: Jinja2; extra == "all"
+Requires-Dist: jinja2; extra == "all"
+Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "all"
+Requires-Dist: trame-jupyter-extension; extra == "all"
+Requires-Dist: vtk>=9.3.0; extra == "all"
 Provides-Extra: vtk
-Requires-Dist: IPython; extra == "vtk"
+Requires-Dist: ipython; extra == "vtk"
 Requires-Dist: vtk>=9.3.0; extra == "vtk"
 Provides-Extra: pyvista
-Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "pyvista"
-Requires-Dist: trame_jupyter_extension; extra == "pyvista"
 Requires-Dist: ipywidgets; extra == "pyvista"
+Requires-Dist: pyvista[all,trame]>=0.43.4; extra == "pyvista"
+Requires-Dist: trame-jupyter-extension; extra == "pyvista"
 Provides-Extra: reporting
-Requires-Dist: pdfkit; extra == "reporting"
-Requires-Dist: Jinja2; extra == "reporting"
+Requires-Dist: jinja2; extra == "reporting"
 Provides-Extra: derivations
 Requires-Dist: jupyterlab; extra == "derivations"
 Requires-Dist: sympy; extra == "derivations"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 <div align="center">
   <img src="https://github.com/JWock82/Pynite/raw/main/Resources/Full Logo No Buffer.png" width=40% align="center"/>
@@ -122,6 +109,10 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+3.1.0
+* Improved detection of unstable structures.
+* Bug fix for shear walls. Shear walls were erroneously tracking other plates in the model for internal pier/coupling beam force summations, rather than just the plates related to the individual shear wall.
+
 3.0.0
 * Added pushover analysis! Currently, only steel sections are supported for pushover analysis. The assumed interaction equation used to estimate plastic behavior is currently calibrated toward I-shaped members.
 * Refactored all elastic stiffness matrix references from `K` and `k` to `Ke` and `ke`. Most users will not notice this change. Power users who were accessing the stiffness matrices directly will want to note this refactor.  This clarifies the code base by indicating which type of stiffness these matrices represent, and reduces ambiguity in preparation for addition of further geometric `Kg/kg` and plastic `Km/km` stiffness matrices.

{pynitefea-3.0.0 → pynitefea-3.1.0}/PyNiteFEA.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 LICENSE
 README.md
-setup.py
+pyproject.toml
 PyNiteFEA.egg-info/PKG-INFO
 PyNiteFEA.egg-info/SOURCES.txt
 PyNiteFEA.egg-info/dependency_links.txt

{pynitefea-3.0.0 → pynitefea-3.1.0}/PyNiteFEA.egg-info/requires.txt

@@ -1,30 +1,28 @@
+matplotlib
 numpy>=2.4.0
-PrettyTable
+prettytable
 scipy
-matplotlib
 
 [all]
-Ipython
-vtk>=9.3.0
-pyvista[all,trame]>=0.43.4
-trame_jupyter_extension
+ipython
 ipywidgets
-pdfkit
-Jinja2
+jinja2
+pyvista[all,trame]>=0.43.4
+trame-jupyter-extension
+vtk>=9.3.0
 
 [derivations]
 jupyterlab
 sympy
 
 [pyvista]
-pyvista[all,trame]>=0.43.4
-trame_jupyter_extension
 ipywidgets
+pyvista[all,trame]>=0.43.4
+trame-jupyter-extension
 
 [reporting]
-pdfkit
-Jinja2
+jinja2
 
 [vtk]
-IPython
+ipython
 vtk>=9.3.0

{pynitefea-3.0.0 → pynitefea-3.1.0}/Pynite/Analysis.py

@@ -2,8 +2,10 @@ from __future__ import annotations  # Allows more recent type hints features
 from typing import TYPE_CHECKING
 from math import isclose
 
-from numpy import array, atleast_2d, zeros, subtract, matmul, divide, seterr, nanmax
-from numpy.linalg import solve
+import warnings
+
+from numpy import array, atleast_2d, zeros, subtract, matmul, divide, seterr, nanmax, asarray, isfinite
+from numpy.linalg import solve, norm, LinAlgError
 
 from Pynite.LoadCombo import LoadCombo
 
@@ -166,6 +168,79 @@ def _check_stability(model: FEModel3D, K: NDArray[float64]) -> None:
     return
 
 
+# Exception message shared by the global-instability checks below
+_SINGULAR_MSG = ('The stiffness matrix is singular, which implies rigid body motion. The structure '
+                 'is unstable. Aborting analysis.')
+
+
+def _solve_unknown_disp(K11, rhs, sparse: bool = True, check_stability: bool = True, tol: float = 1e-6):
+    """Solves ``K11 @ x = rhs`` for the unknown displacements, raising on a singular stiffness matrix.
+
+    The nodal stability check (:func:`_check_stability`) only catches degrees of freedom with a zero
+    stiffness on the diagonal. It does not catch *global* instability, where every diagonal term is
+    non-zero but the assembled matrix is still rank-deficient -- for example a mechanism created by
+    member end releases (a beam with an internal hinge and no support there), or a structure with
+    insufficient supports (rigid body motion). In those cases the underlying solvers do not reliably
+    report the problem: ``scipy.sparse.linalg.spsolve`` may return ``NaN`` (with only a
+    ``MatrixRankWarning``) or even finite-but-meaningless values, and ``numpy.linalg.solve`` may miss
+    the singularity due to floating point round-off. The model then silently reports erroneous
+    results.
+
+    When ``check_stability`` is ``True`` the computed displacements are verified against equilibrium
+    by measuring the relative residual ``||K11 @ x - rhs|| / ||rhs||``. A stable structure -- even a
+    numerically ill-conditioned one -- solves to within round-off (the direct solvers are backward
+    stable), whereas a singular system yields ``NaN``/``inf`` or finite values with an O(1) residual.
+    For the homogeneous ``rhs == 0`` edge case, an invertible system has the unique solution
+    ``x == 0``; a non-zero solved displacement is therefore treated as unstable. These checks are
+    robust indicators of global instability that, unlike inspecting the factorization's pivot
+    magnitudes, do not misclassify legitimately ill-conditioned but stable models. When
+    ``check_stability`` is ``False`` the bare solvers are used unchanged.
+
+    :param K11: The partitioned stiffness matrix for the unknown displacements (square, ``n``x``n``).
+    :param rhs: The right-hand side vector (shape ``(n, 1)``).
+    :param sparse: Whether ``K11`` is a SciPy sparse matrix. Defaults to ``True``.
+    :param check_stability: Whether to check for global instability after solving. Defaults to ``True``.
+    :param tol: Relative residual above which the matrix is treated as singular. Defaults to ``1e-6``.
+    :raises Exception: If the stiffness matrix is singular (the structure is unstable).
+    :return: The solved displacement vector, shape ``(n, 1)``.
+    """
+
+    singular_warning = False
+    if sparse:
+        from scipy.sparse.linalg import MatrixRankWarning, spsolve
+
+        K = K11.tocsr()
+        # A singular matrix makes `spsolve` emit a `MatrixRankWarning`; we detect that case below via
+        # the residual/finiteness check and raise a descriptive error, so suppress the bare warning.
+        with warnings.catch_warnings(record=True) as caught_warnings:
+            warnings.simplefilter('always', MatrixRankWarning)
+            x = spsolve(K, rhs)
+        singular_warning = any(warning.category is MatrixRankWarning for warning in caught_warnings)
+    else:
+        K = asarray(K11, dtype=float)
+        try:
+            x = solve(K, rhs)
+        except LinAlgError as exc:
+            raise Exception(_SINGULAR_MSG) from exc
+
+    x = asarray(x, dtype=float).reshape(len(x), 1)
+
+    if check_stability:
+        residual = norm(K @ x - rhs)
+        rhs_norm = norm(rhs)
+        if rhs_norm > 0:
+            unstable = residual > tol * rhs_norm
+        else:
+            # For a homogeneous system, an invertible matrix has the unique solution x == 0, so an
+            # absolute displacement tolerance is appropriate here.
+            unstable = norm(x) > tol
+
+        if (sparse and singular_warning) or not isfinite(x).all() or unstable:
+            raise Exception(_SINGULAR_MSG)
+
+    return x
+
+
 def _first_order(model: FEModel3D, combo_name: str, P1: NDArray[float64], FER1: NDArray[float64], D1_indices: List[int], D2_indices: List[int], D2: NDArray[float64], log: bool = True, sparse: bool = True, check_stability: bool = False, max_iter: int = 30, spring_tolerance: float = 0, member_tolerance: float = 0, num_steps: int = 1) -> None:
     """Performs the shared first-order elastic/tension-compression-only solution path.
 
@@ -173,10 +248,6 @@ def _first_order(model: FEModel3D, combo_name: str, P1: NDArray[float64], FER1:
     first-order workflow lives in one place.
     """
 
-    # Import `scipy` features if the sparse solver is being used
-    if sparse == True:
-        from scipy.sparse.linalg import spsolve
-
     # Calculate the incremental enforced displacement vector
     Delta_D2 = D2/num_steps
 
@@ -217,19 +288,15 @@ def _first_order(model: FEModel3D, combo_name: str, P1: NDArray[float64], FER1:
                 # All displacements are known, so Delta_D1 is an empty vector
                 Delta_D1 = []
             else:
-                try:
-                    # Calculate the unknown displacements Delta_D1
-                    if sparse == True:
-                        # The partitioned stiffness matrix originates as `coo` and is converted to `csr`
-                        # format for mathematical operations. The `@` operator performs matrix multiplication
-                        # on sparse matrices.
-                        Delta_D1 = spsolve(K11, subtract(subtract(Delta_P1, Delta_FER1), K12 @ Delta_D2))
-                        Delta_D1 = Delta_D1.reshape(len(Delta_D1), 1)
-                    else:
-                        Delta_D1 = solve(K11, subtract(subtract(Delta_P1, Delta_FER1), matmul(K12, Delta_D2)))
-                except:
-                    # Return out of the method if 'K' is singular and provide an error message
-                    raise Exception('The stiffness matrix is singular, which implies rigid body motion. The structure is unstable. Aborting analysis.')
+                # Calculate the unknown displacements Delta_D1. The partitioned stiffness matrix
+                # originates as `coo` and is converted to `csr`/`csc` for mathematical operations.
+                # `_solve_unknown_disp` also detects global instability (a singular matrix) that
+                # the bare solvers can silently miss.
+                if sparse == True:
+                    rhs = subtract(subtract(Delta_P1, Delta_FER1), K12 @ Delta_D2)
+                else:
+                    rhs = subtract(subtract(Delta_P1, Delta_FER1), matmul(K12, Delta_D2))
+                Delta_D1 = _solve_unknown_disp(K11, rhs, sparse, check_stability)
 
             # Store or sum the calculated displacements to the model and the nodes in the model
             if load_step == 1:
@@ -603,19 +670,12 @@ def _pushover_step(model: FEModel3D, combo_name: str, push_combo: str, step_num:
 
                     # Calculate change in the local end force vector for this load step
                     Delta_f = sub_member.f(combo_name, Delta_d, Delta_fer)
-                    
-                    sub_member._fxi[combo_name] += Delta_f[0, 0]
-                    sub_member._fyi[combo_name] += Delta_f[1, 0]
-                    sub_member._fzi[combo_name] += Delta_f[2, 0]
-                    sub_member._mxi[combo_name] += Delta_f[3, 0]
-                    sub_member._myi[combo_name] += Delta_f[4, 0]
-                    sub_member._mzi[combo_name] += Delta_f[5, 0]
-                    sub_member._fxj[combo_name] += Delta_f[6, 0]
-                    sub_member._fyj[combo_name] += Delta_f[7, 0]
-                    sub_member._fzj[combo_name] += Delta_f[8, 0]
-                    sub_member._mxj[combo_name] += Delta_f[9, 0]
-                    sub_member._myj[combo_name] += Delta_f[10, 0]
-                    sub_member._mzj[combo_name] += Delta_f[11, 0]
+
+                    # TODO: Before accepting `Delta_f`, check if we've overshot any member section
+                    # capacity interaction curves, and adjust the load step if necessary
+
+                    # Store the change in the local end force vector for this load step
+                    sub_member.f_nonlin[combo_name] += Delta_f.reshape(12)
 
         else:
 
@@ -633,6 +693,120 @@ def _pushover_step(model: FEModel3D, combo_name: str, push_combo: str, step_num:
                     print('- Restarting load step due to plastic load reversal')
 
 
+def _load_step_ratio(model: FEModel3D, combo_name: str, Delta_f: NDArray[float64]) -> float:
+    """
+    Determines the fraction of the pushover load step that should be applied.
+
+    It is desirable to ensure plastic hinges occur at the end of a load step. This method checks
+    if the current load step has caused any plastic hinges to form. If so, it calculates the
+    fraction of the load step that should be applied to ensure the hinge forms at the end of the
+    load step.
+
+    See Section 12.6 of `Matrix Structural Analysis, Second Edition` for more information.
+    """
+    
+    # Define a local helper method for this method
+    def tal(p, my, mz, dp, dmy, dmz, Phi):
+
+        # Initial guesses
+        tal_l = 0.0  # Lower bound guess
+        tal_u = 1.0  # Upper bound guess
+        tal_r = tal_u  # Assumed initial value of the root we are seeking
+
+        # Counter variable
+        num_iter = 0
+
+        while (not isclose(Phi(p + tal_r*dp, my + tal_r*dmy, mz + tal_r*dmz) - 1.0, 0.0) 
+               and num_iter < 100):
+
+            # Increment the iteration counter
+            num_iter += 1
+
+            # Calculate `Phi` (the utilization ratio) for the lower and upper guesses
+            Phi_tal_l = Phi(p + tal_l*dp, my + tal_l*dmy, mz + tal_l*dmz)
+            Phi_tal_u = Phi(p + tal_u*dp, my + tal_u*dmy, mz + tal_u*dmz)
+
+            # Estimate the root and its `Phi` value
+            tal_r = 1 - (Phi_tal_u - 1.0)*(tal_l - tal_u)/(Phi_tal_l - Phi_tal_u)
+            Phi_tal_r = Phi(p + tal_r*dp, my + tal_r*dmy, mz + tal_r*dmz)
+
+            # Replace the lower or upper guess with the new estimate depending on which (Phi - 1)
+            # one has the same sign as (Phi - 1) for the new root estimate.
+            if (Phi_tal_l - 1.0)*(Phi_tal_r - 1.0) < 0:
+                tal_u = tal_r
+            elif (Phi_tal_u - 1.0)*(Phi_tal_r - 1.0) < 0:
+                tal_l = tal_r
+
+            # Cap the number of iterations to avoid infinite loops
+            if num_iter >= 100:
+                raise Exception('Unable to determine the fraction of the pushover load step that should be applied.')
+
+        # Return the fraction of the pushover load step that should be applied
+        return tal_r
+    
+    # Initilize the lowest value for the fraction of the pushover load step that should be applied
+    tal_min = 1.0
+
+    # Step through each physical member in the model
+    for phys_member in model.members.values():
+
+        # Step through each sub-member of the physical member
+        for sub_member in phys_member.sub_members.values():
+            
+            # Obtain the member's plastic load capacities
+            section = sub_member.section
+            Py = section.material.fy*section.A
+            Mpy = section.material.fy*section.Zy
+            Mpz = section.material.fy*section.Zz
+
+            # Obtain member end forces for the latest load step
+            fxi = sub_member.f_nonlin[combo_name][0]
+            myi = sub_member.f_nonlin[combo_name][4]
+            mzi = sub_member.f_nonlin[combo_name][5]
+            fxj = sub_member.f_nonlin[combo_name][6]
+            myj = sub_member.f_nonlin[combo_name][10]
+            mzj = sub_member.f_nonlin[combo_name][11]
+
+            # Check if the yield surface has been exceeded at the i-end of the member
+            if sub_member.section.Phi(fxi, myi, mzi) > 1.0:
+
+                # Convert the member end forces to nondiminensionalized values
+                p = abs(fxi/Py)
+                m_y = abs(myi/Mpy)
+                m_z = abs(mzi/Mpz)
+
+                dp = abs(Delta_f[0, 0]/Py)
+                dmy = abs(Delta_f[4, 0]/Mpy)
+                dmz = abs(Delta_f[5, 0]/Mpz)
+
+                tal_i = tal(p, m_y, m_z, dp, dmy, dmz, sub_member.section.Phi)
+
+            else: tal_i = 1.0
+
+            # Check if the yield surface has been exceeded at the j-end of the member
+            if sub_member.section.Phi(fxj, myj, mzj) > 1.0:
+
+                # Convert the member end forces to nondiminensionalized values
+                p = abs(fxj/Py)
+                m_y = abs(myj/Mpy)
+                m_z = abs(mzj/Mpz)
+
+                dp = abs(Delta_f[6, 0]/Py)
+                dmy = abs(Delta_f[10, 0]/Mpy)
+                dmz = abs(Delta_f[11, 0]/Mpz)
+
+                tal_j = tal(p, m_y, m_z, dp, dmy, dmz, sub_member.section.Phi)
+
+            else: tal_j = 1.0
+
+            if tal_i < tal_min:
+                tal_min = tal_i
+            if tal_j < tal_min:
+                tal_min = tal_j
+
+    # Return the fraction of the pushover load step that should be applied
+    return tal_min
+
 def _unpartition(model: FEModel3D, V1: NDArray[float64], V2: NDArray[float64], V1_indices: List[int], V2_indices: List[int]) -> NDArray[float64]:
     """Unpartitions a vector and returns it as a global vector including all dofs.
 

{pynitefea-3.0.0 → pynitefea-3.1.0}/Pynite/FEModel3D.py

@@ -1843,7 +1843,7 @@ class FEModel3D():
                     else:
                         if self.solution == 'Pushover':
                             # Use the axial force at the current nonlinear/inelastic load step
-                            P = member._fxj[combo_name] - member._fxi[combo_name]
+                            P = member.f_nonlin[combo_name][6] - member.f_nonlin[combo_name][0]
                         else:
                             # Calculate the member axial force due to linear/elastic axial strain
                             d = member.d(combo_name)
@@ -2266,10 +2266,6 @@ class FEModel3D():
             print('| Analyzing: Linear |')
             print('+-------------------+')
 
-        # Import `scipy` features if the sparse solver is being used
-        if sparse == True:
-            from scipy.sparse.linalg import spsolve
-
         # Prepare the model for analysis
         Analysis._prepare_model(self)
 
@@ -2307,19 +2303,15 @@ class FEModel3D():
                 # All displacements are known, so D1 is an empty vector
                 D1 = []
             else:
-                try:
-                    # Calculate the unknown displacements D1
-                    if sparse == True:
-                        # The partitioned stiffness matrix originates as `coo` and is converted
-                        # to `csr` format for mathematical operations. The `@` operator performs
-                        # matrix multiplication on sparse matrices.
-                        D1 = spsolve(K11.tocsr(), np.subtract(np.subtract(P1, FER1), K12.tocsr() @ D2))
-                        D1 = D1.reshape(len(D1), 1)
-                    else:
-                        D1 = solve(K11, np.subtract(np.subtract(P1, FER1), np.matmul(K12, D2)))
-                except:
-                    # Return out of the method if 'K' is singular and provide an error message
-                    raise Exception('The stiffness matrix is singular, which implies rigid body motion. The structure is unstable. Aborting analysis.')
+                # Calculate the unknown displacements D1. The partitioned stiffness matrix
+                # originates as `coo` and is converted to `csr`/`csc` for mathematical
+                # operations. `_solve_unknown_disp` also detects global instability (a singular
+                # matrix) that the bare solvers can silently miss.
+                if sparse == True:
+                    rhs = np.subtract(np.subtract(P1, FER1), K12.tocsr() @ D2)
+                else:
+                    rhs = np.subtract(np.subtract(P1, FER1), np.matmul(K12, D2))
+                D1 = Analysis._solve_unknown_disp(K11, rhs, sparse, check_stability)
 
             # Store the calculated displacements to the model and the nodes in the model
             Analysis._store_displacements(self, D1, D2, D1_indices, D2_indices, combo)
@@ -2657,13 +2649,12 @@ class FEModel3D():
 
         return fig, ax, save_path
 
-    def analyze_pushover(self, log=False, check_stability=True, push_combo='Push', max_iter=30, tol=0.01, sparse=True, combo_tags=None, control_node=None, control_direction='DX', control_limit=None, traces=None):
-        """Performs a pushover analysis using first-order preload and pushover steps.
+    def analyze_pushover(self, log=False, check_stability=True, push_combo='Push', max_iter=30, tol=0.01, sparse=True, combo_tags=None, control_node=None, control_direction='DX', control_limit=None, traces=None, P_Delta=False):
+        """Performs a pushover analysis with optional second-order P-Delta effects.
 
-        Note for future development:
-        Pushover + P-Delta infrastructure is intentionally retained internally, but the public
-        pushover API currently does not expose a P-Delta option until the implementation is
-        production-ready.
+        By default, the initial preload state is established using first-order analysis and the
+        incremental pushover steps omit the geometric stiffness matrix. Set ``P_Delta=True`` to
+        opt into second-order behavior for both the preload and the subsequent pushover steps.
 
         :param log: Prints updates to the console if set to True. Default is False.
         :type log: bool, optional
@@ -2690,6 +2681,9 @@ class FEModel3D():
         :type control_limit: float | None, optional
         :param traces: Optional dictionary of trace names mapped to callables that accept combo_name.
         :type traces: dict | None, optional
+        :param P_Delta: Set to True to include geometric stiffness and second-order effects during
+                pushover analysis. Defaults to False.
+        :type P_Delta: bool, optional
         """
 
         if control_limit is not None and control_node is None:
@@ -2744,9 +2738,7 @@ class FEModel3D():
         # Initialize per-combo pushover result state.
         self._pushover_state = {}
         self._pushover_traces = {}
-        # Keep this internal flag for future developer work on pushover + P-Delta support.
-        # User-facing pushover is currently first-order only.
-        self._pushover_P_Delta = False
+        self._pushover_P_Delta = P_Delta
 
         # Step through each load combination
         for combo in combo_list:
@@ -2759,10 +2751,7 @@ class FEModel3D():
             # Set member end force summations to zero
             for phys_member in self.members.values():
                 for sub_member in phys_member.sub_members.values():
-                    sub_member._fxi, sub_member._fyi, sub_member._fzi = {}, {}, {}
-                    sub_member._mxi, sub_member._myi, sub_member._mzi = {}, {}, {}
-                    sub_member._fxj, sub_member._fyj, sub_member._fzj = {}, {}, {}
-                    sub_member._mxj, sub_member._myj, sub_member._mzj = {}, {}, {}
+                    sub_member.f_nonlin = {}
 
             # Get the partitioned global fixed end reaction vector for the load combination
             FER1, FER2 = Analysis._partition(self, self.FER(combo.name), D1_indices, D2_indices)
@@ -2771,29 +2760,22 @@ class FEModel3D():
             P1, P2 = Analysis._partition(self, self.P(combo.name), D1_indices, D2_indices)
 
             # Preload the primary load combination before any pushover increments are applied.
-            # User-facing pushover currently uses first-order preload only.
+            # By default, pushover uses the first-order analysis path. Set `P_Delta=True` to opt
+            # into a second-order preload state.
             if log:
-                print('- Preloading the primary combination using first-order analysis')
+                print('- Preloading the primary combination using ' + ('P-Delta' if P_Delta else 'first-order') + ' analysis')
 
-            Analysis._first_order(self, combo.name, P1, FER1, D1_indices, D2_indices, D2, False, sparse, check_stability, max_iter)
+            if P_Delta:
+                Analysis._PDelta(self, combo.name, P1, FER1, D1_indices, D2_indices, D2, False, sparse, check_stability, max_iter)
+            else:
+                Analysis._first_order(self, combo.name, P1, FER1, D1_indices, D2_indices, D2, False, sparse, check_stability, max_iter)
 
             # Seed the nonlinear end-force history with the elastic preload state from the
             # primary load combination before any pushover increments are applied.
             for phys_member in self.members.values():
                 for sub_member in phys_member.sub_members.values():
                     f = sub_member.f(combo.name)
-                    sub_member._fxi[combo.name] = f[0, 0]
-                    sub_member._fyi[combo.name] = f[1, 0]
-                    sub_member._fzi[combo.name] = f[2, 0]
-                    sub_member._mxi[combo.name] = f[3, 0]
-                    sub_member._myi[combo.name] = f[4, 0]
-                    sub_member._mzi[combo.name] = f[5, 0]
-                    sub_member._fxj[combo.name] = f[6, 0]
-                    sub_member._fyj[combo.name] = f[7, 0]
-                    sub_member._fzj[combo.name] = f[8, 0]
-                    sub_member._mxj[combo.name] = f[9, 0]
-                    sub_member._myj[combo.name] = f[10, 0]
-                    sub_member._mzj[combo.name] = f[11, 0]
+                    sub_member.f_nonlin[combo.name] = f.reshape(12)
 
             # The P-Delta analysis above flagged the solution as a P-Delta solution, but we need to
             # indicate that this is actually a Pushover solution so that the calls to Member3D.f()
@@ -2820,7 +2802,7 @@ class FEModel3D():
             # each load step and can be queried for results during or after the pushover analysis.
             self._pushover_state[combo.name] = {
                 'push_combo': push_combo,
-                'P_Delta': False,
+                'P_Delta': P_Delta,
                 'status': 'running',
                 'step_num': 0,
                 'load_factor': 0.0,
@@ -2841,8 +2823,7 @@ class FEModel3D():
 
                 # Run the next pushover load step
                 # Note: The validity of the pushover step is checked and handled within the _pushover_step method
-                # Keep the internal _pushover_step P_Delta argument for future developer work.
-                Analysis._pushover_step(self, combo.name, push_combo, step_num, P1_push, FER1_push, FER2_push, D1_indices, D2_indices, D2, log, sparse, check_stability, tol, False, max_iter)
+                Analysis._pushover_step(self, combo.name, push_combo, step_num, P1_push, FER1_push, FER2_push, D1_indices, D2_indices, D2, log, sparse, check_stability, tol, P_Delta, max_iter)
 
                 control_displacement = None
                 if control_node is not None: