PyNiteFEA 2.2.1__tar.gz → 2.3.0__tar.gz

{pynitefea-2.2.1 → pynitefea-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.2.1
+Version: 2.3.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
@@ -121,6 +121,14 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.3.0
+* Added enveloping to member diagrams. Set `combo_name` to a list of combo tags and the member diagram will show an envelope of all the combos that have any of those tags.
+* Bug fix: Quadrilateral element displacements had corners swapped during VTK visualization. This was a relic from the old MITC4 formulation that has been corrected.
+* Bug fix: Added shear wall and mat foundation load cases to `FEModel3D.load_cases()`. The list of load cases was sometimes incomplete if these meshes had not yet been generated.
+* Added bending moment end releases to visualizations.
+* Bug fix for shear walls with flanges having an origin with their origin at Y != 0.
+* Rectangular meshes now filter out user defined control points that erroneously lie outside their boudaries.
+
 v2.2.1
 * Normalized member force diagrams across the entire model for visual clarity.
 * Made mesh auto-regeneration smarter and more efficient, targeting only meshes that have been altered since the last run.

{pynitefea-2.2.1 → pynitefea-2.3.0}/PyNiteFEA.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.2.1
+Version: 2.3.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
@@ -121,6 +121,14 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.3.0
+* Added enveloping to member diagrams. Set `combo_name` to a list of combo tags and the member diagram will show an envelope of all the combos that have any of those tags.
+* Bug fix: Quadrilateral element displacements had corners swapped during VTK visualization. This was a relic from the old MITC4 formulation that has been corrected.
+* Bug fix: Added shear wall and mat foundation load cases to `FEModel3D.load_cases()`. The list of load cases was sometimes incomplete if these meshes had not yet been generated.
+* Added bending moment end releases to visualizations.
+* Bug fix for shear walls with flanges having an origin with their origin at Y != 0.
+* Rectangular meshes now filter out user defined control points that erroneously lie outside their boudaries.
+
 v2.2.1
 * Normalized member force diagrams across the entire model for visual clarity.
 * Made mesh auto-regeneration smarter and more efficient, targeting only meshes that have been altered since the last run.

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/FEModel3D.py

@@ -194,6 +194,25 @@ class FEModel3D():
                 # Get the load case for each plate/quad pressure
                 cases.append(load[1])
 
+        # Step through each shear wall helper
+        for shear_wall in self.shear_walls.values():
+            # Step through each shear wall shear load
+            for load in shear_wall._shears:
+                # Get the load case for each shear wall shear
+                cases.append(load[2])
+
+            # Step through each shear wall axial load
+            for load in shear_wall._axials:
+                # Get the load case for each shear wall axial
+                cases.append(load[2])
+
+        # Step through each mat foundation helper
+        for mat in self.mats.values():
+            # Step through each mat point load
+            for load in mat.pt_loads:
+                # Get the load case for each mat point load
+                cases.append(load[3])
+
         # Remove duplicates and return the list (sorted ascending)
         return sorted(list(dict.fromkeys(cases)))
 
@@ -2415,7 +2434,7 @@ class FEModel3D():
                                 # 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.tocsr(), np.subtract(np.subtract(Delta_P1, Delta_FER1), K12.tocsr() @ Delta_D2))
+                                Delta_D1 = spsolve(K11, np.subtract(np.subtract(Delta_P1, Delta_FER1), K12 @ Delta_D2))
                                 Delta_D1 = Delta_D1.reshape(len(Delta_D1), 1)
                             else:
                                 Delta_D1 = solve(K11, np.subtract(np.subtract(Delta_P1, Delta_FER1), np.matmul(K12, Delta_D2)))

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/Member3D.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Literal, Union, List
 from math import isclose
 
 from numpy import array, zeros, add, subtract, matmul, insert, dot, cross, divide, count_nonzero, concatenate
-from numpy import linspace, vstack, hstack, allclose, radians, sin, cos
+from numpy import linspace, vstack, hstack, allclose, radians, sin, cos, maximum, minimum
 from numpy.linalg import inv, pinv, norm
 
 import Pynite.FixedEndReactions
@@ -1292,42 +1292,62 @@ class Member3D():
         # Return 0 if no valid combos were found
         return Vmin_global if Vmin_global is not None else 0
 
-    def plot_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the shear diagram for the member
+        Plots the shear diagram for the member.
 
         Parameters
         ----------
         Direction : string
-            The direction in which to find the moment. Must be one of the following:
+            The direction in which to plot the shear force. Must be one of the following:
                 'Fy' = Shear acting on the local y-axis.
                 'Fz' = Shear acting on the local z-axis.
-        combo_name : string
-            The name of the load combination to get the results for (not the load combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
 
-        # Segment the member if necessary
-        if self._solved_combo is None or combo_name != self._solved_combo.name:
-            self._segment_member(combo_name)
-            self._solved_combo = self.model.load_combos[combo_name]
-
         # Import 'pyplot' if not already done
         if Member3D.__plt is None:
             from matplotlib import pyplot as plt
             Member3D.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = Member3D.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        x, V = self.shear_array(Direction, n_points, combo_name)
-
-        Member3D.__plt.plot(x, V)
-        Member3D.__plt.ylabel('Shear')
-        Member3D.__plt.xlabel('Location')
-        Member3D.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            # Segment the member if necessary
+            if self._solved_combo is None or combo_names[0] != self._solved_combo.name:
+                self._segment_member(combo_names[0])
+                self._solved_combo = self.model.load_combos[combo_names[0]]
+            x, V = self.shear_array(Direction, n_points, combo_names[0])
+            ax.plot(x, V)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, V = self.shear_array(Direction, n_points, name)
+                ax.plot(x, V, label=name)
+                env_max = V if env_max is None else maximum(env_max, V)
+                env_min = V if env_min is None else minimum(env_min, V)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Shear')
+        ax.set_xlabel('Location')
         Member3D.__plt.show()
 
     def shear_array(self, Direction: Literal['Fy', 'Fz'], n_points: int, combo_name='Combo 1', x_array=None) -> NDArray[float64]:
@@ -1581,9 +1601,9 @@ class Member3D():
         return Mmin_global if Mmin_global is not None else 0
 
 
-    def plot_moment(self, Direction: Literal['My', 'Mz'], combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_moment(self, Direction: Literal['My', 'Mz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the moment diagram for the member
+        Plots the moment diagram for the member.
 
         Parameters
         ----------
@@ -1591,33 +1611,52 @@ class Member3D():
             The direction in which to plot the moment. Must be one of the following:
                 'My' = Moment about the local y-axis.
                 'Mz' = moment about the local z-axis.
-        combo_name : string
-            The name of the load combination to get the results for (not the combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
 
-        # Segment the member if necessary
-        if self._solved_combo is None or combo_name != self._solved_combo.name:
-            self._segment_member(combo_name)
-            self._solved_combo = self.model.load_combos[combo_name]
-
         # Import 'pyplot' if not already done
         if Member3D.__plt is None:
             from matplotlib import pyplot as plt
             Member3D.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = Member3D.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        # Generate the moment diagram coordinates
-        x, M = self.moment_array(Direction, n_points, combo_name)
-
-        Member3D.__plt.plot(x, M)
-        Member3D.__plt.ylabel('Moment')
-        Member3D.__plt.xlabel('Location')
-        Member3D.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            # Segment the member if necessary
+            if self._solved_combo is None or combo_names[0] != self._solved_combo.name:
+                self._segment_member(combo_names[0])
+                self._solved_combo = self.model.load_combos[combo_names[0]]
+            x, M = self.moment_array(Direction, n_points, combo_names[0])
+            ax.plot(x, M)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, M = self.moment_array(Direction, n_points, name)
+                ax.plot(x, M, label=name)
+                env_max = M if env_max is None else maximum(env_max, M)
+                env_min = M if env_min is None else minimum(env_min, M)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Moment')
+        ax.set_xlabel('Location')
         Member3D.__plt.show()
 
     def moment_array(self, Direction: Literal['My', 'Mz'], n_points: int, combo_name: str = 'Combo 1', x_array: Optional[NDArray[float64]] = None) -> NDArray[float64]:
@@ -1825,38 +1864,58 @@ class Member3D():
         # Return global minimum or 0 if nothing found
         return Tmin_global if Tmin_global is not None else 0
 
-    def plot_torque(self, combo_name='Combo 1', n_points=20):
+    def plot_torque(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
         Plots the torque diagram for the member.
 
-        Paramters
-        ---------
-        combo_name : string
-            The name of the load combination to get the results for (not the load combination itself).
+        Parameters
+        ----------
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
 
-        # Segment the member if necessary
-        if self._solved_combo is None or combo_name != self._solved_combo.name:
-            self._segment_member(combo_name)
-            self._solved_combo = self.model.load_combos[combo_name]
-
         # Import 'pyplot' if not already done
         if Member3D.__plt is None:
             from matplotlib import pyplot as plt
             Member3D.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = Member3D.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        x, T = self.torque_array(n_points, combo_name)
-
-        Member3D.__plt.plot(x, T)
-        Member3D.__plt.ylabel('Torsional Moment (Warping Torsion Not Included)') # Torsion results are for pure torsion. Torsional warping has not been considered
-        Member3D.__plt.xlabel('Location')
-        Member3D.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            # Segment the member if necessary
+            if self._solved_combo is None or combo_names[0] != self._solved_combo.name:
+                self._segment_member(combo_names[0])
+                self._solved_combo = self.model.load_combos[combo_names[0]]
+            x, T = self.torque_array(n_points, combo_names[0])
+            ax.plot(x, T)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, T = self.torque_array(n_points, name)
+                ax.plot(x, T, label=name)
+                env_max = T if env_max is None else maximum(env_max, T)
+                env_min = T if env_min is None else minimum(env_min, T)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Torsional Moment (Warping Torsion Not Included)')
+        ax.set_xlabel('Location')
         Member3D.__plt.show()
 
     def torque_array(self, n_points, combo_name='Combo 1', x_array = None) -> NDArray[float64]:
@@ -2039,38 +2098,58 @@ class Member3D():
         # Return the global minimum, or 0 if nothing was found
         return Pmin_global if Pmin_global is not None else 0
 
-    def plot_axial(self, combo_name: str = 'Combo 1', n_points=20) -> None:
+    def plot_axial(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
         Plots the axial force diagram for the member.
 
         Parameters
         ----------
-        combo_name : string
-            The name of the load combination to get the results for (not the load combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
 
-        # Segment the member if necessary
-        if self._solved_combo is None or combo_name != self._solved_combo.name:
-            self._segment_member(combo_name)
-            self._solved_combo = self.model.load_combos[combo_name]
-
         # Import 'pyplot' if not already done
         if Member3D.__plt is None:
             from matplotlib import pyplot as plt
             Member3D.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = Member3D.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        x, P = self.axial_array(n_points, combo_name)
-
-        Member3D.__plt.plot(x, P)
-        Member3D.__plt.ylabel('Axial Force')
-        Member3D.__plt.xlabel('Location')
-        Member3D.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            # Segment the member if necessary
+            if self._solved_combo is None or combo_names[0] != self._solved_combo.name:
+                self._segment_member(combo_names[0])
+                self._solved_combo = self.model.load_combos[combo_names[0]]
+            x, P = self.axial_array(n_points, combo_names[0])
+            ax.plot(x, P)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, P = self.axial_array(n_points, name)
+                ax.plot(x, P, label=name)
+                env_max = P if env_max is None else maximum(env_max, P)
+                env_min = P if env_min is None else minimum(env_min, P)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Axial Force')
+        ax.set_xlabel('Location')
         Member3D.__plt.show()
 
     def axial_array(self, n_points: int, combo_name: str = 'Combo 1', x_array: Optional[NDArray[float64]] = None) -> NDArray[float64]:
@@ -2309,43 +2388,63 @@ class Member3D():
         # Return global minimum or 0 if nothing found
         return dmin_global if dmin_global is not None else 0
 
-    def plot_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the deflection diagram for the member
+        Plots the deflection diagram for the member.
 
         Parameters
         ----------
         Direction : string
-            The direction in which to find the deflection. Must be one of the following:
+            The direction in which to plot the deflection. Must be one of the following:
                 'dx' = Deflection in the local x-axis.
                 'dy' = Deflection in the local y-axis.
                 'dz' = Deflection in the local z-axis.
-        combo_name : string
-            The name of the load combination to get the results for (not the load combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
 
-        # Segment the member if necessary
-        if self._solved_combo is None or combo_name != self._solved_combo.name:
-            self._segment_member(combo_name)
-            self._solved_combo = self.model.load_combos[combo_name]
-
         # Import 'pyplot' if not already done
         if Member3D.__plt is None:
             from matplotlib import pyplot as plt
             Member3D.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = Member3D.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        x, d = self.deflection_array(Direction, n_points, combo_name)
-
-        Member3D.__plt.plot(x, d)
-        Member3D.__plt.ylabel('Deflection')
-        Member3D.__plt.xlabel('Location')
-        Member3D.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            # Segment the member if necessary
+            if self._solved_combo is None or combo_names[0] != self._solved_combo.name:
+                self._segment_member(combo_names[0])
+                self._solved_combo = self.model.load_combos[combo_names[0]]
+            x, d = self.deflection_array(Direction, n_points, combo_names[0])
+            ax.plot(x, d)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, d = self.deflection_array(Direction, n_points, name)
+                ax.plot(x, d, label=name)
+                env_max = d if env_max is None else maximum(env_max, d)
+                env_min = d if env_min is None else minimum(env_min, d)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Deflection')
+        ax.set_xlabel('Location')
         Member3D.__plt.show()
 
     def deflection_array(self, Direction: Literal['dx', 'dy', 'dz'], n_points: int, combo_name: str = 'Combo 1', x_array: Optional[NDArray[float64]] = None) -> NDArray[float64]:

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/Mesh.py

@@ -816,6 +816,11 @@ class RectangleMesh(Mesh):
                 unique_list.append(y_control[i])
         unique_list.append(y_control[-1])
         y_control = unique_list
+
+        # Remove any control points that fall outside the mesh boundaries
+        # Control points outside [0, width] or [0, height] would create elements outside the intended mesh
+        x_control = [val for val in x_control if val >= -1e-10 and val <= width + 1e-10]
+        y_control = [val for val in y_control if val >= -1e-10 and val <= height + 1e-10]
     
         # Each node number will be increased by the offset calculated below
         node_offset = int(self.start_node[1:]) - 1

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/PhysMember.py

@@ -1,5 +1,5 @@
 from __future__ import annotations # Allows more recent type hints features
-from typing import Dict, List, Literal, Tuple, TYPE_CHECKING
+from typing import Dict, List, Literal, Tuple, Union, TYPE_CHECKING
 from Pynite.Member3D import Member3D
 
 if TYPE_CHECKING:
@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from numpy import float64
     from numpy.typing import NDArray
 
-from numpy import array, dot, linspace, hstack, empty
+from numpy import array, dot, linspace, hstack, empty, maximum, minimum
 from numpy.linalg import norm
 from math import isclose, acos
 
@@ -257,9 +257,9 @@ class PhysMember(Member3D):
                 Vmin = V
         return Vmin
 
-    def plot_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the shear diagram for the member
+        Plots the shear diagram for the member.
 
         Parameters
         ----------
@@ -267,8 +267,10 @@ class PhysMember(Member3D):
             The direction in which to plot the shear force. Must be one of the following:
                 'Fy' = Shear in the local y-axis.
                 'Fz' = Shear in the local z-axis.
-        combo_name : string
-            The name of the load combination to get the results for (not the combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
@@ -278,19 +280,35 @@ class PhysMember(Member3D):
             from matplotlib import pyplot as plt
             PhysMember.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = PhysMember.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        # Generate the shear diagram
-        V_array = self.shear_array(Direction, n_points, combo_name)
-        x = V_array[0]
-        V = V_array[1]
-
-        PhysMember.__plt.plot(x, V)
-        PhysMember.__plt.ylabel('Shear')
-        PhysMember.__plt.xlabel('Location')
-        PhysMember.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            x, V = self.shear_array(Direction, n_points, combo_names[0])
+            ax.plot(x, V)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, V = self.shear_array(Direction, n_points, name)
+                ax.plot(x, V, label=name)
+                env_max = V if env_max is None else maximum(env_max, V)
+                env_min = V if env_min is None else minimum(env_min, V)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Shear')
+        ax.set_xlabel('Location')
         PhysMember.__plt.show()
 
     def shear_array(self, Direction: Literal['Fy', 'Fz'], n_points: int, combo_name='Combo 1', x_array=None) -> NDArray[float64]:
@@ -429,19 +447,20 @@ class PhysMember(Member3D):
                 Mmin = M
         return Mmin
 
-    def plot_moment(self, Direction: Literal['My', 'Mz'], combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_moment(self, Direction: Literal['My', 'Mz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the moment diagram for the member
+        Plots the moment diagram for the member.
 
         Parameters
         ----------
-
         Direction : string
             The direction in which to plot the moment. Must be one of the following:
                 'My' = Moment about the local y-axis.
-                'Mz' = moment about the local z-axis.
-        combo_name : string
-            The name of the load combination to get the results for (not the combination itself).
+                'Mz' = Moment about the local z-axis.
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
@@ -451,19 +470,35 @@ class PhysMember(Member3D):
             from matplotlib import pyplot as plt
             PhysMember.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = PhysMember.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        # Generate the moment diagram
-        M_array = self.moment_array(Direction, n_points, combo_name)
-        x = M_array[0]
-        M = M_array[1]
-
-        PhysMember.__plt.plot(x, M)
-        PhysMember.__plt.ylabel('Moment')
-        PhysMember.__plt.xlabel('Location')
-        PhysMember.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            x, M = self.moment_array(Direction, n_points, combo_names[0])
+            ax.plot(x, M)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, M = self.moment_array(Direction, n_points, name)
+                ax.plot(x, M, label=name)
+                env_max = M if env_max is None else maximum(env_max, M)
+                env_min = M if env_min is None else minimum(env_min, M)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Moment')
+        ax.set_xlabel('Location')
         PhysMember.__plt.show()
 
     def moment_array(self, Direction: Literal['My', 'Mz'], n_points: int, combo_name='Combo 1', x_array=None) -> NDArray[float64]:
@@ -589,14 +624,16 @@ class PhysMember(Member3D):
                 Tmin = T
         return Tmin
 
-    def plot_torque(self, combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_torque(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the torque diagram for the member
+        Plots the torque diagram for the member.
 
         Parameters
         ----------
-        combo_name : string
-            The name of the load combination to get the results for (not the combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
@@ -606,19 +643,35 @@ class PhysMember(Member3D):
             from matplotlib import pyplot as plt
             PhysMember.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = PhysMember.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        # Generate the torque diagram
-        T_array = self.torque_array(n_points, combo_name)
-        x = T_array[0]
-        T = T_array[1]
-
-        PhysMember.__plt.plot(x, T)
-        PhysMember.__plt.ylabel('Torque')
-        PhysMember.__plt.xlabel('Location')
-        PhysMember.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            x, T = self.torque_array(n_points, combo_names[0])
+            ax.plot(x, T)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, T = self.torque_array(n_points, name)
+                ax.plot(x, T, label=name)
+                env_max = T if env_max is None else maximum(env_max, T)
+                env_min = T if env_min is None else minimum(env_min, T)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Torque')
+        ax.set_xlabel('Location')
         PhysMember.__plt.show()
 
     def torque_array(self, n_points: int, combo_name='Combo 1', x_array=None) -> NDArray[float64]:
@@ -721,14 +774,16 @@ class PhysMember(Member3D):
                 Pmin = P
         return Pmin
 
-    def plot_axial(self, combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_axial(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the axial force diagram for the member
+        Plots the axial force diagram for the member.
 
         Parameters
         ----------
-        combo_name : string
-            The name of the load combination to get the results for (not the combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
@@ -738,19 +793,35 @@ class PhysMember(Member3D):
             from matplotlib import pyplot as plt
             PhysMember.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = PhysMember.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        # Generate the axial force array
-        P_array = self.axial_array(n_points, combo_name)
-        x = P_array[0]
-        P = P_array[1]
-
-        PhysMember.__plt.plot(x, P)
-        PhysMember.__plt.ylabel('Axial Force')
-        PhysMember.__plt.xlabel('Location')
-        PhysMember.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            x, P = self.axial_array(n_points, combo_names[0])
+            ax.plot(x, P)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, P = self.axial_array(n_points, name)
+                ax.plot(x, P, label=name)
+                env_max = P if env_max is None else maximum(env_max, P)
+                env_min = P if env_min is None else minimum(env_min, P)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Axial')
+        ax.set_xlabel('Location')
         PhysMember.__plt.show()
 
     def axial_array(self, n_points: int, combo_name='Combo 1', x_array=None) -> NDArray[float64]:
@@ -897,9 +968,9 @@ class PhysMember(Member3D):
         member, x_mod = self.find_member(x)
         return member.rel_deflection(Direction, x_mod, combo_name)
 
-    def plot_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_name: str = 'Combo 1', n_points: int = 20) -> None:
+    def plot_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
-        Plots the deflection diagram for the member
+        Plots the deflection diagram for the member.
 
         Parameters
         ----------
@@ -907,8 +978,10 @@ class PhysMember(Member3D):
             The direction in which to plot the deflection. Must be one of the following:
                 'dy' = Deflection in the local y-axis.
                 'dz' = Deflection in the local z-axis.
-        combo_name : string
-            The name of the load combination to get the results for (not the combination itself).
+        combo_name : string or list of strings
+            A single load combination name, or a list of combo tags. When a
+            list of tags is provided, each matching combo is plotted and a
+            max/min envelope is shown.
         n_points: int
             The number of points used to generate the plot
         """
@@ -918,18 +991,35 @@ class PhysMember(Member3D):
             from matplotlib import pyplot as plt
             PhysMember.__plt = plt
 
+        if isinstance(combo_name, str):
+            combo_names = [combo_name]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_name)]
+
         fig, ax = PhysMember.__plt.subplots()
         ax.axhline(0, color='black', lw=1)
         ax.grid()
 
-        d_array = self.deflection_array(Direction, n_points, combo_name)
-        x = d_array[0]
-        d = d_array[1]
-
-        PhysMember.__plt.plot(x, d)
-        PhysMember.__plt.ylabel('Deflection')
-        PhysMember.__plt.xlabel('Location')
-        PhysMember.__plt.title('Member ' + self.name + '\n' + combo_name)
+        if len(combo_names) == 1:
+            x, d = self.deflection_array(Direction, n_points, combo_names[0])
+            ax.plot(x, d)
+            ax.set_title('Member ' + self.name + '\n' + combo_names[0])
+        else:
+            env_max = None
+            env_min = None
+            for name in combo_names:
+                x, d = self.deflection_array(Direction, n_points, name)
+                ax.plot(x, d, label=name)
+                env_max = d if env_max is None else maximum(env_max, d)
+                env_min = d if env_min is None else minimum(env_min, d)
+            ax.plot(x, env_max, color='green', alpha=0.4, lw=3, label='Max Envelope')
+            ax.plot(x, env_min, color='red', alpha=0.4, lw=3, label='Min Envelope')
+            ax.legend(fontsize='small')
+            ax.set_title('Member ' + self.name + '\nEnvelope')
+
+        ax.set_ylabel('Deflection')
+        ax.set_xlabel('Location')
         PhysMember.__plt.show()
 
     def deflection_array(self, Direction: Literal['dx', 'dy', 'dz'], n_points: int, combo_name='Combo 1', x_array=None) -> NDArray[float64]:

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/Rendering.py

@@ -405,7 +405,7 @@ class Renderer:
                 vis_spring.add_to_plotter(self.plotter)
 
         if self.model.members:
-            vis_members = [VisMember(member, self.theme) for member in self.model.members.values()]
+            vis_members = [VisMember(member, self.theme, self.annotation_size) for member in self.model.members.values()]
             for vis_member in vis_members:
                 vis_member.add_to_plotter(self.plotter)
 
@@ -425,16 +425,19 @@ class Renderer:
         if self.show_labels and vis_nodes:
             label_points = [vis_node.label_point for vis_node in vis_nodes]
             labels = [vis_node.label for vis_node in vis_nodes]
+            label_points = np.asarray(label_points, dtype=float)
             self.plotter.add_point_labels(label_points, labels, bold=False, text_color='black', show_points=True, point_color='grey', point_size=5, shape=None, render_points_as_spheres=True)
 
         if self.show_labels and vis_springs:
             self._spring_label_points = [vis_spring.label_point for vis_spring in vis_springs]
             self._spring_labels = [vis_spring.label for vis_spring in vis_springs]
-            self.plotter.add_point_labels(self._spring_label_points, self._spring_labels, text_color='black', bold=False, shape=None, render_points_as_spheres=False)
+            spring_label_points = np.asarray(self._spring_label_points, dtype=float)
+            self.plotter.add_point_labels(spring_label_points, self._spring_labels, text_color='black', bold=False, shape=None, render_points_as_spheres=False)
 
         if self.show_labels and vis_members:
             label_points = [vis_member.label_point for vis_member in vis_members]
             labels = [vis_member.label for vis_member in vis_members]
+            label_points = np.asarray(label_points, dtype=float)
             self.plotter.add_point_labels(label_points, labels, bold=False, text_color='black', show_points=False, shape=None, render_points_as_spheres=False)
 
         # Render the loads if requested
@@ -444,7 +447,8 @@ class Renderer:
             self.plot_loads()
 
             # Plot the load labels
-            self.plotter.add_point_labels(self._load_label_points, self._load_labels, bold=False, text_color='green', show_points=False, shape=None, render_points_as_spheres=False)
+            load_label_points = np.asarray(self._load_label_points, dtype=float)
+            self.plotter.add_point_labels(load_label_points, self._load_labels, bold=False, text_color='green', show_points=False, shape=None, render_points_as_spheres=False)
 
         # Render the plates and quads, if present
         if self.model.quads or self.model.plates:
@@ -829,7 +833,7 @@ class Renderer:
             i+=1
 
         # Add the vertices and the faces to our lists
-        plate_vertices = np.array(plate_vertices)
+        plate_vertices = np.array(plate_vertices, dtype=float)
         plate_faces = np.array(plate_faces)
 
         # Create a new PyVista dataset to store plate data
@@ -1058,7 +1062,7 @@ class Renderer:
         v2 = _PerpVector(v1)
 
         # Generate the arc for the moment
-        arc = pv.CircularArcFromNormal(center, resolution=20, normal=v1, angle=215, polar=v2*radius)
+        arc = pv.CircularArcFromNormal(center=center, resolution=20, normal=v1, angle=215, polar=v2*radius)
 
         # Add the arc to the plot
         self.plotter.add_mesh(arc, line_width=2, color=color)
@@ -1837,15 +1841,18 @@ class VisSpring:
 class VisMember:
     """Visual wrapper for a Member3D as a simple line."""
 
-    def __init__(self, member: 'Member3D', theme: str) -> None:
+    def __init__(self, member: 'Member3D', theme: str, annotation_size: float) -> None:
         """Build visual elements for a member.
 
         :param Member3D member: Member to visualize.
         :param str theme: Rendering theme (``'default'`` or ``'print'``).
+        :param float annotation_size: Base size for release symbols.
         """
         self.member = member
         self.theme = theme
+        self.annotation_size = annotation_size
         self.mesh: pv.PolyData = self._build_geometry()
+        self.release_meshes: List[pv.PolyData] = self._build_release_meshes()
         self.label = member.name
         self.label_point = [(member.i_node.X + member.j_node.X) / 2,
                             (member.i_node.Y + member.j_node.Y) / 2,
@@ -1857,6 +1864,63 @@ class VisMember:
         line.points[1] = [self.member.j_node.X, self.member.j_node.Y, self.member.j_node.Z]
         return line
 
+    def _build_release_meshes(self) -> List[pv.PolyData]:
+        releases = self.member.Releases
+        if not releases:
+            return []
+
+        show_i_ry = releases[4]
+        show_i_rz = releases[5]
+        show_j_ry = releases[10]
+        show_j_rz = releases[11]
+
+        if not (show_i_ry or show_i_rz or show_j_ry or show_j_rz):
+            return []
+
+        T = self.member.T()[0:3, 0:3]
+        local_x = T[0, 0:3]
+        local_y = T[1, 0:3]
+        local_z = T[2, 0:3]
+
+        local_x = local_x / np.linalg.norm(local_x)
+        local_y = local_y / np.linalg.norm(local_y)
+        local_z = local_z / np.linalg.norm(local_z)
+
+        radius = self.annotation_size * 0.3
+        member_length = self.member.L()
+        default_offset = self.annotation_size * 1.2
+        short_offset = member_length * 0.05
+        offset = short_offset if default_offset > short_offset else default_offset
+        num_segments = 24
+
+        i_point = np.array([self.member.i_node.X, self.member.i_node.Y, self.member.i_node.Z])
+        j_point = np.array([self.member.j_node.X, self.member.j_node.Y, self.member.j_node.Z])
+
+        release_meshes: List[pv.PolyData] = []
+
+        def add_circle(center: np.ndarray, axis1: np.ndarray, axis2: np.ndarray) -> None:
+            angles = np.linspace(0.0, 2 * np.pi, num_segments, endpoint=False)
+            points = [center + radius * (np.cos(a) * axis1 + np.sin(a) * axis2) for a in angles]
+            release_meshes.append(pv.lines_from_points(np.array(points), close=True))
+
+        if show_i_ry:
+            center = i_point + local_x * offset
+            add_circle(center, local_x, local_z)
+
+        if show_i_rz:
+            center = i_point + local_x * offset
+            add_circle(center, local_x, local_y)
+
+        if show_j_ry:
+            center = j_point - local_x * offset
+            add_circle(center, local_x, local_z)
+
+        if show_j_rz:
+            center = j_point - local_x * offset
+            add_circle(center, local_x, local_y)
+
+        return release_meshes
+
     def add_to_plotter(self, plotter: pv.Plotter) -> None:
         """Add the member line to the plotter.
 
@@ -1864,6 +1928,8 @@ class VisMember:
         """
         color = 'black' if self.theme == 'print' else 'black'
         plotter.add_mesh(self.mesh, color=color, line_width=2)
+        for release_mesh in self.release_meshes:
+            plotter.add_mesh(release_mesh, color=color, line_width=2)
 
 
 class VisDeformedMember:

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/ShearWall.py

@@ -214,7 +214,7 @@ class ShearWall():
             # Identify the global origin for the flange mesh
             if self.plane == 'XY':
                 Xof = self.origin[0] + x
-                Yof = self.origin[0] + y_start
+                Yof = self.origin[1] + y_start
                 Zof = self.origin[2] + z
                 flg_plane = 'YZ'
             elif self.plane == 'XZ':

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/VTKWriter.py

@@ -203,6 +203,34 @@ class VTKWriter:
         ugrid_members.SetPoints(points)
         ugrid_members.SetCells(vtk.VTK_LINE, lines)
 
+        #### MEMBER RELEASES DATA ####
+        # Add member end releases as cell data
+        member_releases = vtk.vtkIntArray()
+        member_releases.SetName("End Releases")
+        member_releases.SetNumberOfComponents(12)  # 12 DOFs (Rx, Ry, Rz, Mx, My, Mz for each end)
+        
+        for i, name in enumerate(["DXi", "DYi", "DZi", "RXi", "RYi", "RZi", "DXj", "DYj", "DZj", "RXj", "RYj", "RZj"]):
+            member_releases.SetComponentName(i, name)
+        
+        cell_id = 0
+        for member in self.model.members.values():
+            if len(member.sub_members) == 0:
+                # Single uninformed element
+                member_releases.InsertTuple(cell_id, tuple(int(r) for r in member.Releases))
+                cell_id += 1
+            else:
+                # Member releases are defined once on the full member (i/j ends).
+                # They are NOT applied per sub-member segment. We only duplicate the
+                # same 12 release flags onto every exported line cell so the metadata is
+                # available regardless of which segment is selected in post-processing.
+                for subm in member.sub_members.values():
+                    n = 11  # Number of segments
+                    for _ in range(n - 1):
+                        member_releases.InsertTuple(cell_id, tuple(int(r) for r in member.Releases))
+                        cell_id += 1
+        
+        ugrid_members.GetCellData().AddArray(member_releases)
+
         #### MEMBER Data ####
         for combo in self.model.load_combos.keys():
             # Displacement

{pynitefea-2.2.1 → pynitefea-2.3.0}/Pynite/Visualization.py

@@ -475,6 +475,10 @@ class Renderer():
             # Add the actor for the member
             renderer.AddActor(vis_member.actor)
 
+            # Add visualization for member end releases
+            for release_actor in vis_member.release_actors:
+                renderer.AddActor(release_actor)
+
             if self.labels == True:
 
                 # Add the actor for the member label
@@ -950,6 +954,9 @@ class VisMember():
         :param str theme: ``'default'`` or ``'print'`` to control colors.
         """
 
+        self.member = member
+        self.release_actors = []
+
         # Generate a line for the member
         line = vtk.vtkLineSource()
 
@@ -997,6 +1004,96 @@ class VisMember():
             self.actor.GetProperty().SetColor(0/255, 0/255, 0/255)  # Black
             self.lblActor.GetProperty().SetColor(0/255, 0/255, 0/255) # Black
 
+        # Add visualization for member end releases
+        self._create_release_actors(annotation_size)
+
+    def _create_release_actors(self, annotation_size):
+        """Create VTK actors for rotational end releases.
+
+        Only local y/z rotational releases are shown.
+        
+        :param float annotation_size: Base size for symbol scaling.
+        """
+        from numpy import array, cos, sin, linalg
+        
+        releases = self.member.Releases
+        if not releases:
+            return
+
+        show_i_ry = releases[4]
+        show_i_rz = releases[5]
+        show_j_ry = releases[10]
+        show_j_rz = releases[11]
+
+        if not (show_i_ry or show_i_rz or show_j_ry or show_j_rz):
+            return
+
+        T = self.member.T()[0:3, 0:3]
+        local_x = T[0, 0:3]
+        local_y = T[1, 0:3]
+        local_z = T[2, 0:3]
+
+        local_x = local_x / linalg.norm(local_x)
+        local_y = local_y / linalg.norm(local_y)
+        local_z = local_z / linalg.norm(local_z)
+
+        radius = annotation_size * 0.3
+        member_length = self.member.L()
+        default_offset = annotation_size * 1.2
+        short_offset = member_length * 0.05
+        offset = short_offset if default_offset > short_offset else default_offset
+        num_segments = 24
+
+        i_point = array([self.member.i_node.X, self.member.i_node.Y, self.member.i_node.Z])
+        j_point = array([self.member.j_node.X, self.member.j_node.Y, self.member.j_node.Z])
+        member_color = self.actor.GetProperty().GetColor()
+
+        def create_circle_actor(center, axis1, axis2):
+            angles = linspace(0.0, 2 * 3.14159265, num_segments, endpoint=False)
+            points = vtk.vtkPoints()
+            lines = vtk.vtkCellArray()
+            
+            for i, a in enumerate(angles):
+                pt = center + radius * (cos(a) * axis1 + sin(a) * axis2)
+                points.InsertNextPoint(pt[0], pt[1], pt[2])
+            
+            # Close the circle
+            for i in range(num_segments):
+                line = vtk.vtkLine()
+                line.GetPointIds().SetId(0, i)
+                line.GetPointIds().SetId(1, (i + 1) % num_segments)
+                lines.InsertNextCell(line)
+            
+            polydata = vtk.vtkPolyData()
+            polydata.SetPoints(points)
+            polydata.SetLines(lines)
+            
+            mapper = vtk.vtkPolyDataMapper()
+            mapper.SetInputData(polydata)
+            
+            actor = vtk.vtkActor()
+            actor.SetMapper(mapper)
+            actor.GetProperty().SetColor(*member_color)
+            actor.GetProperty().SetLineWidth(2)
+            
+            return actor
+
+        if show_i_ry:
+            center = i_point + local_x * offset
+            self.release_actors.append(create_circle_actor(center, local_x, local_z))
+
+        if show_i_rz:
+            center = i_point + local_x * offset
+            self.release_actors.append(create_circle_actor(center, local_x, local_y))
+
+        if show_j_ry:
+            center = j_point - local_x * offset
+            self.release_actors.append(create_circle_actor(center, local_x, local_z))
+
+        if show_j_rz:
+            center = j_point - local_x * offset
+            self.release_actors.append(create_circle_actor(center, local_x, local_y))
+
 # Converts a node object into a node in its deformed position for the viewer
 class VisDeformedNode():
     """Sphere representing a node in its deformed position."""

{pynitefea-2.2.1 → pynitefea-2.3.0}/README.md

@@ -68,6 +68,14 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.3.0
+* Added enveloping to member diagrams. Set `combo_name` to a list of combo tags and the member diagram will show an envelope of all the combos that have any of those tags.
+* Bug fix: Quadrilateral element displacements had corners swapped during VTK visualization. This was a relic from the old MITC4 formulation that has been corrected.
+* Bug fix: Added shear wall and mat foundation load cases to `FEModel3D.load_cases()`. The list of load cases was sometimes incomplete if these meshes had not yet been generated.
+* Added bending moment end releases to visualizations.
+* Bug fix for shear walls with flanges having an origin with their origin at Y != 0.
+* Rectangular meshes now filter out user defined control points that erroneously lie outside their boudaries.
+
 v2.2.1
 * Normalized member force diagrams across the entire model for visual clarity.
 * Made mesh auto-regeneration smarter and more efficient, targeting only meshes that have been altered since the last run.

{pynitefea-2.2.1 → pynitefea-2.3.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="PyNiteFEA",
-    version="2.2.1",
+    version="2.3.0",
     author="D. Craig Brinck, PE, SE",
     author_email="Building.Code@outlook.com",
     description="A simple elastic 3D structural finite element library for Python.",