PyNiteFEA 2.4.0__tar.gz → 3.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.4.0
+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
@@ -60,7 +60,7 @@ Dynamic: summary
 ![Build Status](https://github.com/JWock82/Pynite/actions/workflows/build-and-test.yml/badge.svg)
 [![codecov](https://codecov.io/gh/JWock82/Pynite/branch/main/graph/badge.svg?token=ZH18US3A7P)](https://codecov.io/gh/JWock82/Pynite)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/PyniteFEA)
-![PyPI - Downloads](https://img.shields.io/pypi/dm/PyNiteFEA?cacheSeconds=86400)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/PyNiteFEA?cacheSeconds=172800)
 <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/JWock82/Pynite">
 ![GitHub last commit](https://img.shields.io/github/last-commit/JWock82/Pynite)
 ![GitHub](https://img.shields.io/github/license/JWock82/Pynite)
@@ -77,6 +77,7 @@ For a more detailed discussion on installation options and dependencies see http
 * 3D static analysis of elastic structures.
 * P-&Delta; analysis of frame type structures.
 * Modal analysis of frame type structures.
+* Nonlinear pushover analysis of steel frames.
 * Member point loads, linearly varying distributed loads, and nodal loads are supported.
 * Classify loads by load case and create load combinations from load cases.
 * Produces shear, moment, and deflection results and diagrams for each member.
@@ -121,6 +122,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.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.
+* User's can now control the size of member plots.
+* Improved `ShearWall.screenshots()` method. Added coupling beam plots. Added the ability to use the `VTK` renderer instead of the `pyvista` renderer for screenshots.
+* Removed individual load combo plots from member plots when an envelope plot is requested. They cluttered the plots without adding much value.
+
+2.4.1
+* Fixed a bug where enveloped results did not work if both tagged and untagged combos were in a model.
+
 2.4.0
 * Member `max` and `min` methods now return governing load combination along with the member max/min forces.
 * Bug fix: Quadrilateral element displacements had corners swapped during VTK visualization. This was a relic from the old MITC4 formulation that has been corrected.
@@ -144,7 +155,7 @@ v2.2.0
 * Updated documentation for rendering.
 
 v2.1.0
-* Major speed boost and leaner memory usage: the global stiffness/mass assembly plus the nodal load and fixed-end reaction builders now use block-based vectorized writes instead of Python loops, which keeps data in contiguous NumPy buffers rather than thousands of temporary Python objects. The dense solver sees ~15-25% faster `K`/`M` builds in our targeted benchmarks, while sparse solver runs see ~30% faster stiffness assembly in our benchmarks.
+* Major speed boost and leaner memory usage: the global stiffness/mass assembly plus the nodal load and fixed-end reaction builders now use block-based vectorized writes instead of Python loops, which keeps data in contiguous NumPy buffers rather than thousands of temporary Python objects. The dense solver sees ~15-25% faster `Ke`/`M` builds in our targeted benchmarks, while sparse solver runs see ~30% faster stiffness assembly in our benchmarks.
 * Meshes can now be regenerated with the `FEModel3D.meshes[mesh_name].generate()` command. This command removes the old mesh and replaces it with an updated one. The mesh will not remove nodes needed by other elements outside the mesh. Note that any loads applied to the old mesh will be lost when its elements and nodes are deleted. This makes meshes truly parametric.
 * Added `FEModel3D.delete_mesh()` to help deleting old meshes properly.
 * Renderers now automatically set the annotation size as 5% of the minimum distance between nodes. You still have the option of overiding this by setting the annotation size manually.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.4.0
+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
@@ -60,7 +60,7 @@ Dynamic: summary
 ![Build Status](https://github.com/JWock82/Pynite/actions/workflows/build-and-test.yml/badge.svg)
 [![codecov](https://codecov.io/gh/JWock82/Pynite/branch/main/graph/badge.svg?token=ZH18US3A7P)](https://codecov.io/gh/JWock82/Pynite)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/PyniteFEA)
-![PyPI - Downloads](https://img.shields.io/pypi/dm/PyNiteFEA?cacheSeconds=86400)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/PyNiteFEA?cacheSeconds=172800)
 <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/JWock82/Pynite">
 ![GitHub last commit](https://img.shields.io/github/last-commit/JWock82/Pynite)
 ![GitHub](https://img.shields.io/github/license/JWock82/Pynite)
@@ -77,6 +77,7 @@ For a more detailed discussion on installation options and dependencies see http
 * 3D static analysis of elastic structures.
 * P-&Delta; analysis of frame type structures.
 * Modal analysis of frame type structures.
+* Nonlinear pushover analysis of steel frames.
 * Member point loads, linearly varying distributed loads, and nodal loads are supported.
 * Classify loads by load case and create load combinations from load cases.
 * Produces shear, moment, and deflection results and diagrams for each member.
@@ -121,6 +122,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.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.
+* User's can now control the size of member plots.
+* Improved `ShearWall.screenshots()` method. Added coupling beam plots. Added the ability to use the `VTK` renderer instead of the `pyvista` renderer for screenshots.
+* Removed individual load combo plots from member plots when an envelope plot is requested. They cluttered the plots without adding much value.
+
+2.4.1
+* Fixed a bug where enveloped results did not work if both tagged and untagged combos were in a model.
+
 2.4.0
 * Member `max` and `min` methods now return governing load combination along with the member max/min forces.
 * Bug fix: Quadrilateral element displacements had corners swapped during VTK visualization. This was a relic from the old MITC4 formulation that has been corrected.
@@ -144,7 +155,7 @@ v2.2.0
 * Updated documentation for rendering.
 
 v2.1.0
-* Major speed boost and leaner memory usage: the global stiffness/mass assembly plus the nodal load and fixed-end reaction builders now use block-based vectorized writes instead of Python loops, which keeps data in contiguous NumPy buffers rather than thousands of temporary Python objects. The dense solver sees ~15-25% faster `K`/`M` builds in our targeted benchmarks, while sparse solver runs see ~30% faster stiffness assembly in our benchmarks.
+* Major speed boost and leaner memory usage: the global stiffness/mass assembly plus the nodal load and fixed-end reaction builders now use block-based vectorized writes instead of Python loops, which keeps data in contiguous NumPy buffers rather than thousands of temporary Python objects. The dense solver sees ~15-25% faster `Ke`/`M` builds in our targeted benchmarks, while sparse solver runs see ~30% faster stiffness assembly in our benchmarks.
 * Meshes can now be regenerated with the `FEModel3D.meshes[mesh_name].generate()` command. This command removes the old mesh and replaces it with an updated one. The mesh will not remove nodes needed by other elements outside the mesh. Note that any loads applied to the old mesh will be lost when its elements and nodes are deleted. This makes meshes truly parametric.
 * Added `FEModel3D.delete_mesh()` to help deleting old meshes properly.
 * Renderers now automatically set the annotation size as 5% of the minimum distance between nodes. You still have the option of overiding this by setting the annotation size manually.

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

@@ -166,6 +166,99 @@ def _check_stability(model: FEModel3D, K: NDArray[float64]) -> None:
     return
 
 
+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.
+
+    This helper is used by both ``FEModel3D.analyze`` and pushover preload so the normal
+    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
+
+    # Calculate the incremental global fixed end reaction vector
+    Delta_FER1 = FER1/num_steps
+
+    # Calculate the incremental global nodal force vector
+    Delta_P1 = P1/num_steps
+
+    # Apply the load incrementally
+    load_step = 1
+    while load_step <= num_steps:
+
+        # Keep track of the number of iterations in this load step
+        iter_count = 1
+        convergence = False
+        divergence = False
+
+        # Iterate until convergence or divergence occurs
+        while convergence == False and divergence == False:
+
+            # Check for tension/compression-only divergence
+            if iter_count > max_iter:
+                divergence = True
+                raise Exception('Model diverged during tension/compression-only analysis')
+
+            # Report which load step we are on
+            if log:
+                print(f'- Analyzing load step #{str(load_step)}')
+
+            # Get the partitioned global stiffness matrix K11, K12, K21, K22
+            if sparse == True:
+                K11, K12, K21, K22 = _partition(model, model.Ke(combo_name, log, check_stability, sparse).tocsr(), D1_indices, D2_indices)
+            else:
+                K11, K12, K21, K22 = _partition(model, model.Ke(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
+
+            if K11.shape == (0, 0):
+                # 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.')
+
+            # Store or sum the calculated displacements to the model and the nodes in the model
+            if load_step == 1:
+                _store_displacements(model, Delta_D1, Delta_D2, D1_indices, D2_indices, model.load_combos[combo_name])
+            else:
+                _sum_displacements(model, Delta_D1, Delta_D2, D1_indices, D2_indices, model.load_combos[combo_name])
+
+            # Check for tension/compression-only convergence at this load step
+            convergence = _check_TC_convergence(model, combo_name, log=log, spring_tolerance=spring_tolerance, member_tolerance=member_tolerance)
+
+            if convergence == False:
+
+                if log:
+                    print(f'- Undoing load step #{load_step} due to failed convergence.')
+
+                # Undo the latest analysis step to prepare for re-analysis of the load step
+                _sum_displacements(model, -Delta_D1, -Delta_D2, D1_indices, D2_indices, model.load_combos[combo_name])
+
+            else:
+                # Move on to the next load step
+                load_step += 1
+
+            # Keep track of the number of tension/compression only iterations
+            iter_count += 1
+
+    # Flag the model as solved
+    model.solution = 'Nonlinear TC'
+
+
 def _PDelta(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) -> None:
     """Performs second order (P-Delta) analysis. This type of analysis is appropriate for most models using beams, columns and braces. Second order analysis is usually required by material-specific codes. Models with slender members and/or members with combined bending and axial loads will generally have more significant P-Delta effects. P-Delta effects in plates/quads are not considered by Pynite at this time.
 
@@ -219,7 +312,7 @@ def _PDelta(model: FEModel3D, combo_name: str, P1: NDArray[float64], FER1: NDArr
                     # Calculate the partitioned initial stiffness matrices. These matrices must be recalculated on each T/C iteration due to tension/compression-only members deactivating or reactivating.
                     if log:
                         print('- Calculating initial stiffness matrix')
-                    K11, K12, K21, K22 = _partition(model, model.K(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
+                    K11, K12, K21, K22 = _partition(model, model.Ke(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
 
                     # The initial stiffness matrices are in `coo` format from construction. They will be converted to `csr` format for efficient mathematical operations.
                     K11 = K11.tocsr()
@@ -247,13 +340,13 @@ def _PDelta(model: FEModel3D, combo_name: str, P1: NDArray[float64], FER1: NDArr
                 if solution_step == 1:
 
                     # Calculate the partitioned initial stiffness matrices. These matrices must be recalculated on each T/C iteration due to tension/compression-only members deactivating or reactivating.
-                    K11, K12, K21, K22 = _partition(model, model.K(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
+                    K11, K12, K21, K22 = _partition(model, model.Ke(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
 
                 # Check if we are ready to calculate the geometric stiffness
                 if solution_step == 2:
 
                     # After the first iteration, the geometric stiffness matrix will be added to the linear elastic stiffness matrix.
-                    Kg11, Kg12, Kg21, Kg22 = _partition(model.Kg(combo_name, log, sparse, False), D1_indices, D2_indices)
+                    Kg11, Kg12, Kg21, Kg22 = _partition(model, model.Kg(combo_name, log, sparse, False), D1_indices, D2_indices)
 
                     K11 = K11 + Kg11
                     K12 = K12 + Kg12
@@ -311,28 +404,41 @@ def _PDelta(model: FEModel3D, combo_name: str, P1: NDArray[float64], FER1: NDArr
     model.solution = 'P-Delta'
 
 
-def _pushover_step(model: FEModel3D, combo_name: str, push_combo: str, step_num: int, 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) -> None:
+def _pushover_step(model: FEModel3D, combo_name: str, push_combo: str, step_num: int, Delta_P1: NDArray[float64], Delta_FER1: NDArray[float64], Delta_FER2: NDArray[float64], D1_indices: List[int], D2_indices: List[int], D2: NDArray[float64], log: bool = True, sparse: bool = True, check_stability: bool = False, tol: float = 0, P_Delta: bool = False, max_iter: int = 30) -> None:
 
     # Run at least one iteration
     run_step = True
+    iter_count = 0
+    tc_changed_last = False
+    reversal_locations_last = []
 
     # Run/rerun the load step until convergence occurs
     while run_step == True:
 
+        iter_count += 1
+        if iter_count > max_iter:
+            reasons = []
+            if tc_changed_last:
+                reasons.append('tension/compression-only status changes')
+            if reversal_locations_last:
+                reasons.append('plastic load reversal at ' + ', '.join(reversal_locations_last))
+            if not reasons:
+                reasons.append('non-convergent step validation checks')
+            raise RuntimeError(
+                f"Pushover load step {step_num} for load combination '{combo_name}' did not converge "
+                f"after {max_iter} retries ({'; '.join(reasons)}). "
+                "Reduce the pushover increment, relax nonlinear demands, or increase max_iter."
+            )
+
         # Calculate the partitioned global stiffness matrices
         # Sparse solver
         if sparse == True:
 
             from scipy.sparse.linalg import spsolve
 
-            # Calculate the initial stiffness matrix
+            # Calculate the elastic stiffness matrix
             if log: print('- Calculating elastic stiffness matrix [Ke]')
-            K11, K12, K21, K22 = _partition(model, model.K(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
-
-            # Calculate the geometric stiffness matrix
-            # The `combo_name` variable in the code below is not the name of the pushover load combination. Rather it is the name of the primary combination that the pushover load will be added to. Axial loads used to develop Kg are calculated from the displacements stored in `combo_name`.
-            if log: print('- Calculating geometric stiffness matrix [Kg]')
-            Kg11, Kg12, Kg21, Kg22 = _partition(model, model.Kg(combo_name, log, sparse, False), D1_indices, D2_indices)
+            Ke11, Ke12, Ke21, Ke22 = _partition(model, model.Ke(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
 
             # Calculate the stiffness reduction matrix
             if log: print('- Calculating plastic reduction matrix [Km]')
@@ -341,31 +447,44 @@ def _pushover_step(model: FEModel3D, combo_name: str, push_combo: str, step_num:
             # The stiffness matrices are in `coo` format from construction. They will be
             # converted to `csr` format for efficient operations. The `+` operator
             # performs matrix addition on `csr` matrices.
-            K11 = K11.tocsr() + Kg11.tocsr() + Km11.tocsr()
-            K12 = K12.tocsr() + Kg12.tocsr() + Km12.tocsr()
-            K21 = K21.tocsr() + Kg21.tocsr() + Km21.tocsr()
-            K22 = K22.tocsr() + Kg22.tocsr() + Km22.tocsr()
+            K11 = Ke11.tocsr() + Km11.tocsr()
+            K12 = Ke12.tocsr() + Km12.tocsr()
+            # K21 = Ke21.tocsr() + Km21.tocsr()  # This matrix is not used
+            # K22 = Ke22.tocsr() + Km22.tocsr()  # This matrix is not used
+
+            if P_Delta:
+                # The `combo_name` variable in the code below is not the name of the pushover load combination. Rather it is the name of the primary combination that the pushover load will be added to. Axial loads used to develop Kg are calculated from the displacements stored in `combo_name`.
+                if log: print('- Calculating geometric stiffness matrix [Kg]')
+                Kg11, Kg12, Kg21, Kg22 = _partition(model, model.Kg(combo_name, log, sparse, False), D1_indices, D2_indices)
+                K11 = K11 + Kg11.tocsr()
+                K12 = K12 + Kg12.tocsr()
+                # K21 = K21 + Kg21.tocsr()  # This matrix is not used
+                # K22 = K22 + Kg22.tocsr()  # This matrix is not used
 
         # Dense solver
         else:
 
             # Initial stiffness matrix
             if log: print('- Calculating elastic stiffness matrix [Ke]')
-            K11, K12, K21, K22 = _partition(model, model.K(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
-
-            # Geometric stiffness matrix
-            # The `combo_name` variable in the code below is not the name of the pushover load combination. Rather it is the name of the primary combination that the pushover load will be added to. Axial loads used to develop Kg are calculated from the displacements stored in `combo_name`.
-            if log: print('Calculating geometric stiffness matrix [Kg]')
-            Kg11, Kg12, Kg21, Kg22 = _partition(model.Kg(combo_name, log, sparse, False), D1_indices, D2_indices)
+            Ke11, Ke12, Ke21, Ke22 = _partition(model, model.Ke(combo_name, log, check_stability, sparse), D1_indices, D2_indices)
 
             # Calculate the stiffness reduction matrix
             if log: print('Calculating plastic reduction matrix [Km]')
             Km11, Km12, Km21, Km22 = _partition(model, model.Km(combo_name, push_combo, step_num, log, sparse), D1_indices, D2_indices)
 
-            K11 = K11 + Kg11 + Km11
-            K12 = K12 + Kg12 + Km12
-            K21 = K21 + Kg21 + Km21
-            K22 = K22 + Kg22 + Km22
+            K11 = Ke11 + Km11
+            K12 = Ke12 + Km12
+            # K21 = Ke21 + Km21  # This matrix is not used
+            # K22 = Ke22 + Km22  # This matrix is not used
+
+            if P_Delta:
+                # The `combo_name` variable in the code below is not the name of the pushover load combination. Rather it is the name of the primary combination that the pushover load will be added to. Axial loads used to develop Kg are calculated from the displacements stored in `combo_name`.
+                if log: print('Calculating geometric stiffness matrix [Kg]')
+                Kg11, Kg12, Kg21, Kg22 = _partition(model, model.Kg(combo_name, log, sparse, False), D1_indices, D2_indices)
+                K11 = K11 + Kg11
+                K12 = K12 + Kg12
+                # K21 = K21 + Kg21  # This matrix is not used
+                # K22 = K22 + Kg22  # This matrix is not used
 
         # Calculate the changes to the global displacement vector
         if log: print('- Calculating changes to the global displacement vector')
@@ -378,81 +497,160 @@ def _pushover_step(model: FEModel3D, combo_name: str, push_combo: str, step_num:
                 if sparse == True:
                     # The partitioned stiffness matrix is already in `csr` format. The `@`
                     # operator performs matrix multiplication on sparse matrices.
-                    Delta_D1 = spsolve(K11.tocsr(), subtract(subtract(P1, FER1), K12.tocsr() @ D2))
+                    Delta_D1 = spsolve(K11.tocsr(), subtract(subtract(Delta_P1, Delta_FER1), K12.tocsr() @ D2))
                     Delta_D1 = Delta_D1.reshape(len(Delta_D1), 1)
                 else:
                     # The partitioned stiffness matrix is in `csr` format. It will be
                     # converted to a 2D dense array for mathematical operations.
-                    Delta_D1 = solve(K11, subtract(subtract(P1, FER1), matmul(K12, D2)))
+                    Delta_D1 = solve(K11, subtract(subtract(Delta_P1, Delta_FER1), K12 @ D2))
 
             except:
                 # Return out of the method if 'K' is singular and provide an error message
                 raise ValueError('The structure is unstable. Unable to proceed any further with analysis.')
 
-        # Unpartition the displacement results from the analysis step
-        Delta_D = _unpartition_disp(model, Delta_D1, D2, D1_indices, D2_indices)
+        # Tentatively apply the load step so step-validation checks see the current state.
+        _sum_displacements(model, Delta_D1, D2, D1_indices, D2_indices, model.load_combos[combo_name])
 
-        # Assume no need to rerun this load step due to plastic load reversal until we prove it otherwise
+        # Assume no need to rerun this load step until one of the validation checks says otherwise.
         run_step = False
+        tc_changed = False
+        reversal = False
+        reversal_locations = []
+
+        # Check for tension/compression-only status changes caused by this tentative load step.
+        if _check_TC_convergence(model, combo_name, log, spring_tolerance=tol, member_tolerance=tol) == False:
+            tc_changed = True
+            run_step = True
+
+        # Unpartition the displacement results from the analysis step for the `lamb` calculations below
+        Delta_D = _unpartition(model, Delta_D1, D2, D1_indices, D2_indices)
+        Delta_FER = _unpartition(model, Delta_FER1, Delta_FER2, D1_indices, D2_indices)
 
-        # Step through each member in the model and check for plastic load reversal
+        # Step through each member in the model and check for plastic load reversal.
         for phys_member in model.members.values():
 
             for sub_member in phys_member.sub_members.values():
 
-                # print(f'Member {sub_member.name} lambda = {sub_member.lamb(Delta_D, combo_name, push_combo, step_num)}')
+                lamb = sub_member.lamb(Delta_D, combo_name, push_combo, step_num)
 
                 # Check for plastic load reversal at the i-node in this load step
-                if sub_member.lamb(Delta_D, combo_name, push_combo, step_num)[0, 0] < 0:
+                if lamb[0, 0] < 0:
 
                     # Flag the load step for reanalysis
                     sub_member.i_reversal = True
+                    reversal = True
                     run_step = True
-                    print(f'-Plastic load reversal encountered at member {sub_member.name} i-node')
+                    reversal_locations.append(f'{sub_member.name} i-node')
+                    if log: print(f'- Plastic load reversal encountered at member {sub_member.name} i-node')
 
                 else:
 
                     sub_member.i_reversal = False
 
                 # Check for plastic load reversal at the j-node in this load step
-                if sub_member.lamb(Delta_D, combo_name, push_combo, step_num)[1, 0] < 0:
+                if lamb[1, 0] < 0:
 
                     # Flag the load step for reanalysis
                     sub_member.j_reversal = True
+                    reversal = True
                     run_step = True
-                    print(f'-Plastic load reversal encountered at member {sub_member.name} j-node')
+                    reversal_locations.append(f'{sub_member.name} j-node')
+                    if log: print(f'- Plastic load reversal encountered at member {sub_member.name} j-node')
 
                 else:
 
                     sub_member.j_reversal = False
 
-        # Undo the last loadstep if plastic load reversal was discovered. We'll rerun it with the corresponding gradients set to zero vectors.
-        if run_step == True:
-            _sum_displacements(model, -Delta_D1, D2, D1_indices, D2_indices, model.load_combos[combo_name])
-            if log: print('- Restarting load step due to plastic load reversal')
+        # Check if this iteration was valid
+        if run_step == False:
+
+            # Step through each physical member in the model
+            for phys_member in model.members.values():
 
-    # Sum the calculated displacements
-    _sum_displacements(model, Delta_D1, D2, D1_indices, D2_indices, model.load_combos[combo_name])
+                # Step through each sub-member of the physical member
+                for sub_member in phys_member.sub_members.values():
 
+                    # Extract the change in the global displacement and fixed end reaction vectors for this member from the full global vectors. The `reshape` method is used to ensure these are column vectors for the matrix operations below.
+                    Delta_D_member = array([Delta_D[sub_member.i_node.ID*6 + 0, 0],
+                                            Delta_D[sub_member.i_node.ID*6 + 1, 0],
+                                            Delta_D[sub_member.i_node.ID*6 + 2, 0],
+                                            Delta_D[sub_member.i_node.ID*6 + 3, 0],
+                                            Delta_D[sub_member.i_node.ID*6 + 4, 0],
+                                            Delta_D[sub_member.i_node.ID*6 + 5, 0],
+                                            Delta_D[sub_member.j_node.ID*6 + 0, 0],
+                                            Delta_D[sub_member.j_node.ID*6 + 1, 0],
+                                            Delta_D[sub_member.j_node.ID*6 + 2, 0],
+                                            Delta_D[sub_member.j_node.ID*6 + 3, 0],
+                                            Delta_D[sub_member.j_node.ID*6 + 4, 0],
+                                            Delta_D[sub_member.j_node.ID*6 + 5, 0]]).reshape(12, 1)
+                    
+                    Delta_FER_member = array([Delta_FER[sub_member.i_node.ID*6 + 0, 0],
+                                              Delta_FER[sub_member.i_node.ID*6 + 1, 0],
+                                              Delta_FER[sub_member.i_node.ID*6 + 2, 0],
+                                              Delta_FER[sub_member.i_node.ID*6 + 3, 0],
+                                              Delta_FER[sub_member.i_node.ID*6 + 4, 0],
+                                              Delta_FER[sub_member.i_node.ID*6 + 5, 0],
+                                              Delta_FER[sub_member.j_node.ID*6 + 0, 0],
+                                              Delta_FER[sub_member.j_node.ID*6 + 1, 0],
+                                              Delta_FER[sub_member.j_node.ID*6 + 2, 0],
+                                              Delta_FER[sub_member.j_node.ID*6 + 3, 0],
+                                              Delta_FER[sub_member.j_node.ID*6 + 4, 0],
+                                              Delta_FER[sub_member.j_node.ID*6 + 5, 0]]).reshape(12, 1)
+                    
+                    # Convert the global displacement and fixed end reaction vectors to local member vectors
+                    Delta_d = sub_member.T() @ Delta_D_member
+                    Delta_fer = sub_member.T() @ Delta_FER_member
+
+                    # 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]
 
-def _unpartition_disp(model: FEModel3D, D1: NDArray[float64], D2: NDArray[float64], D1_indices: List[int], D2_indices: List[int]) -> NDArray[float64]:
-    """Unpartitions displacements from the solver and returns them as a global displacement vector
+        else:
+
+            tc_changed_last = tc_changed
+            reversal_locations_last = list(dict.fromkeys(reversal_locations))
+
+            # Undo the tentative load step
+            _sum_displacements(model, -Delta_D1, D2, D1_indices, D2_indices, model.load_combos[combo_name])
+            if log:
+                if tc_changed and reversal:
+                    print('- Restarting load step due to tension/compression-only status change and plastic load reversal')
+                elif tc_changed:
+                    print('- Restarting load step due to tension/compression-only status change')
+                else:
+                    print('- Restarting load step due to plastic load reversal')
+
+
+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.
 
     :param model: The finite element model being evaluated
     :type model: FEModel3D
-    :param D1: An array of calculated displacements
-    :type D1: array
-    :param D2: An array of enforced displacements
-    :type D2: array
-    :param D1_indices: A list of the degree of freedom indices for each displacement in D1
-    :type D1_indices: list
-    :param D2_indices: A list of the degree of freedom indices for each displacement in D2
-    :type D2_indices: list
-    :return: Global displacement matrix
+    :param V1: An array of vector terms corresponding to the unrestrained degrees of freedom.
+    :type V1: array
+    :param V2: An array of vector terms corresponding to the degrees of freedom with boundary conditions.
+    :type V2: array
+    :param V1_indices: A list of the degree of freedom indices for each term in V1
+    :type V1_indices: list
+    :param V2_indices: A list of the degree of freedom indices for each term in V2
+    :type V2_indices: list
+    :return: Expanded vector
     :rtype: array
     """
 
-    D = zeros((len(model.nodes)*6, 1))
+    V = zeros((len(model.nodes)*6, 1))
 
     # Step through each node in the model
     for node in model.nodes.values():
@@ -460,16 +658,16 @@ def _unpartition_disp(model: FEModel3D, D1: NDArray[float64], D2: NDArray[float6
         # Step through each degree of freedom at the node
         for i in range(6):
 
-            # Check if the dof is in the list of enforced displacements
-            if node.ID*6 + i in D2_indices:
-                # Get the enforced displacement
-                D[(node.ID*6 + i, 0)] = D2[D2_indices.index(node.ID*6 + i), 0]
+            # Check if the dof is in the list of known vector terms
+            if node.ID*6 + i in V2_indices:
+                # Get the vector term for the bounded dof
+                V[(node.ID*6 + i, 0)] = V2[V2_indices.index(node.ID*6 + i), 0]
             else:
-                # Get the calculated displacement
-                D[(node.ID*6 + i, 0)] = D1[D1_indices.index(node.ID*6 + i), 0]
+                # Get the vector term for the unbounded dof
+                V[(node.ID*6 + i, 0)] = V1[V1_indices.index(node.ID*6 + i), 0]
 
-    # Return the displacement vector
-    return D
+    # Return the vector
+    return V
 
 
 def _store_displacements(model: FEModel3D, D1: NDArray[float64], D2: NDArray[float64], D1_indices: List[int], D2_indices: List[int], combo: LoadCombo) -> None:
@@ -490,7 +688,7 @@ def _store_displacements(model: FEModel3D, D1: NDArray[float64], D2: NDArray[flo
     """
 
     # The raw results from the solver are partitioned. Unpartition them.
-    D = _unpartition_disp(model, D1, D2, D1_indices, D2_indices)
+    D = _unpartition(model, D1, D2, D1_indices, D2_indices)
 
     if combo != None:
 
@@ -526,7 +724,7 @@ def _sum_displacements(model: FEModel3D, Delta_D1: NDArray[float64], Delta_D2: N
     """
 
     # The raw results from the solver are partitioned. Unpartition them.
-    Delta_D = _unpartition_disp(model, Delta_D1, Delta_D2, D1_indices, D2_indices)
+    Delta_D = _unpartition(model, Delta_D1, Delta_D2, D1_indices, D2_indices)
 
     # Sum the load step's global displacement vector with the model's global displacement vector
     model._D[combo.name] += Delta_D
@@ -541,6 +739,7 @@ def _sum_displacements(model: FEModel3D, Delta_D1: NDArray[float64], Delta_D2: N
         node.RY[combo.name] += Delta_D[node.ID*6 + 4, 0]
         node.RZ[combo.name] += Delta_D[node.ID*6 + 5, 0]
 
+
 def _check_TC_convergence(model: FEModel3D, combo_name: str = "Combo 1", log: bool = True, spring_tolerance: float = 0, member_tolerance: float = 0) -> bool:
     """Checks for convergence in tension-only and compression-only analysis.
 

{pynitefea-2.4.0 → pynitefea-3.0.0}/Pynite/BeamSegY.py

@@ -4,6 +4,9 @@ from Pynite.BeamSegZ import BeamSegZ
 # %%
 class BeamSegY(BeamSegZ):
 
+    def __repr__(self) -> str:
+        return f"BeamSegY(x1={self.x1}, x2={self.x2})"
+
     # Returns the moment at a location on the segment
     def moment(self, x: float, P_delta: bool = False) -> float:
         '''
@@ -20,15 +23,16 @@ class BeamSegY(BeamSegZ):
         P1 = self.P1
         w1 = self.w1
         w2 = self.w2
-        L = self.Length()
+        L = self.length()
 
         # M = M1 + V1*x + w1*x**2/2 + x**3*(-w1 + w2)/(6*L)
         M = -M1 - V1*x - w1*x**2/2 - x**3*(-w1 + w2)/(6*L)
 
         if P_delta == True:
-            delta1 = self.delta1
-            delta = self.deflection(x)
-            M += P1*(delta - delta1)
+
+            delta_1 = self.delta1
+            delta_x = self.deflection(x, P_delta)
+            M += P1*(delta_x - delta_1)
 
         return M
 
@@ -50,7 +54,7 @@ class BeamSegY(BeamSegZ):
         w2 = self.w2
         theta_1 = self.theta1
 
-        L = self.Length()
+        L = self.length()
         EI = self.EI
 
         if P_delta == True:
@@ -70,7 +74,7 @@ class BeamSegY(BeamSegZ):
         w2 = self.w2
         theta_1 = self.theta1
         delta_1 = self.delta1
-        L = self.Length()
+        L = self.length()
         EI = self.EI
 
         # Check if a P-delta solution is requested
@@ -90,7 +94,7 @@ class BeamSegY(BeamSegZ):
         w1 = self.w1
         w2 = self.w2
         V1 = self.V1
-        L = self.Length()
+        L = self.length()
 
         # Find the quadratic equation parameters
         a = (w2-w1)/(2*L)
@@ -135,7 +139,7 @@ class BeamSegY(BeamSegZ):
         w1 = self.w1
         w2 = self.w2
         V1 = self.V1
-        L = self.Length()
+        L = self.length()
 
         # Find the quadratic equation parameters
         a = (w2-w1)/(2*L)