PyNiteFEA 3.0.0__tar.gz → 3.2.0__tar.gz

{pynitefea-3.0.0 → pynitefea-3.2.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.2.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,16 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+3.2.0
+* Added shear wall pier top results and coupling beam right hand side results to the pier/coupling beam force results output.
+* Adjusted shear wall pier and coupling beam internal force results sign convention to match the sign convention used for members.
+* Added targeted testing for shear wall pier and coupling beam sign convention and load magnitudes.
+* Added shear wall docstrings and a readthedocs documentation page.
+
+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.2.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.2.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,16 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+3.2.0
+* Added shear wall pier top results and coupling beam right hand side results to the pier/coupling beam force results output.
+* Adjusted shear wall pier and coupling beam internal force results sign convention to match the sign convention used for members.
+* Added targeted testing for shear wall pier and coupling beam sign convention and load magnitudes.
+* Added shear wall docstrings and a readthedocs documentation page.
+
+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.2.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.2.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.2.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.