PyNiteFEA 2.3.0__tar.gz → 2.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.3.0
+Version: 2.4.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,9 +121,12 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+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.
+
 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.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.3.0
+Version: 2.4.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,9 +121,12 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+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.
+
 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.

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

@@ -1154,7 +1154,7 @@ class Member3D():
 
             return 0
 
-    def max_shear(self, Direction: Literal['Fy', 'Fz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def max_shear(self, Direction: Literal['Fy', 'Fz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the maximum shear force in the member for the specified direction
         and load combination(s).
@@ -1174,16 +1174,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The maximum shear value in the specified direction for the given
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
-
-        Notes
-        -----
-        - Unlike moments, shear does not depend on P-Delta effects.
-        - Automatically segments the member if it has not yet been segmented
-        for a load combination.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum shear value.
+            If a list of tags is provided, returns a tuple of the maximum shear
+            value and the name of the governing load combination.
         """
         # Normalize input: single name vs list of tags
         if isinstance(combo_tags, str):
@@ -1196,6 +1190,7 @@ class Member3D():
             ]
 
         Vmax_global = None  # will store the global maximum across combos
+        governing_combo = None
 
         for combo_name in combo_names:
             # Skip inactive combos
@@ -1219,11 +1214,16 @@ class Member3D():
             # Update global maximum
             if Vmax_global is None or Vmax > Vmax_global:
                 Vmax_global = Vmax
+                governing_combo = combo_name
 
-        # Return 0 if no valid combos were found
-        return Vmax_global if Vmax_global is not None else 0
+        # Return result
+        if Vmax_global is None:
+            Vmax_global = 0
+        if isinstance(combo_tags, list):
+            return (Vmax_global, governing_combo)
+        return Vmax_global
 
-    def min_shear(self, Direction: Literal['Fy', 'Fz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def min_shear(self, Direction: Literal['Fy', 'Fz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the minimum shear force in the member for the specified direction
         and load combination(s).
@@ -1243,16 +1243,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The minimum shear value in the specified direction for the given
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
-
-        Notes
-        -----
-        - Unlike moments, shear does not depend on P-Delta effects.
-        - Automatically segments the member if it has not yet been segmented
-        for a load combination.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum shear value.
+            If a list of tags is provided, returns a tuple of the minimum shear
+            value and the name of the governing load combination.
         """
         # Normalize input: single name vs list of tags
         if isinstance(combo_tags, str):
@@ -1265,6 +1259,7 @@ class Member3D():
             ]
 
         Vmin_global = None  # will store the global minimum across combos
+        governing_combo = None
 
         for combo_name in combo_names:
             # Skip inactive combos
@@ -1288,9 +1283,14 @@ class Member3D():
             # Update global minimum
             if Vmin_global is None or Vmin < Vmin_global:
                 Vmin_global = Vmin
+                governing_combo = combo_name
 
-        # Return 0 if no valid combos were found
-        return Vmin_global if Vmin_global is not None else 0
+        # Return result
+        if Vmin_global is None:
+            Vmin_global = 0
+        if isinstance(combo_tags, list):
+            return (Vmin_global, governing_combo)
+        return Vmin_global
 
     def plot_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
@@ -1456,7 +1456,7 @@ class Member3D():
 
             return 0
 
-    def max_moment(self, Direction: Literal['My', 'Mz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def max_moment(self, Direction: Literal['My', 'Mz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the maximum bending moment in the member for the specified direction
         and load combination(s).
@@ -1476,16 +1476,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The maximum moment value in the specified direction for the given
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
-
-        Notes
-        -----
-        - Includes P-Delta effects if the model's solution is 'P-Delta' or 'Pushover'.
-        - Automatically segments the member if it has not yet been segmented
-        for a load combination.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum moment value.
+            If a list of tags is provided, returns a tuple of the maximum moment
+            value and the name of the governing load combination.
         """
         # Normalize input: single name vs list of tags
         if isinstance(combo_tags, str):
@@ -1498,6 +1492,7 @@ class Member3D():
             ]
 
         Mmax_global = None  # will store the global maximum across combos
+        governing_combo = None
 
         for combo_name in combo_names:
             # Skip inactive combos
@@ -1524,11 +1519,16 @@ class Member3D():
             # Update global maximum
             if Mmax_global is None or Mmax > Mmax_global:
                 Mmax_global = Mmax
+                governing_combo = combo_name
 
-        # Return 0 if no valid combos were found
-        return Mmax_global if Mmax_global is not None else 0
+        # Return result
+        if Mmax_global is None:
+            Mmax_global = 0
+        if isinstance(combo_tags, list):
+            return (Mmax_global, governing_combo)
+        return Mmax_global
 
-    def min_moment(self, Direction: Literal['My', 'Mz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def min_moment(self, Direction: Literal['My', 'Mz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the minimum bending moment in the member for the specified direction
         and load combination(s).
@@ -1548,16 +1548,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The minimum moment value in the specified direction for the given
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
-
-        Notes
-        -----
-        - Includes P-Delta effects if the model's solution is 'P-Delta' or 'Pushover'.
-        - Automatically segments the member if it has not yet been segmented
-        for a load combination.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum moment value.
+            If a list of tags is provided, returns a tuple of the minimum moment
+            value and the name of the governing load combination.
         """
         # Normalize input: single name vs list of tags
         if isinstance(combo_tags, str):
@@ -1570,6 +1564,7 @@ class Member3D():
             ]
 
         Mmin_global = None  # will store the global minimum across combos
+        governing_combo = None
 
         for combo_name in combo_names:
             # Skip inactive combos
@@ -1596,9 +1591,14 @@ class Member3D():
             # Update global minimum
             if Mmin_global is None or Mmin < Mmin_global:
                 Mmin_global = Mmin
+                governing_combo = combo_name
 
-        # Return 0 if no valid combos were found
-        return Mmin_global if Mmin_global is not None else 0
+        # Return result
+        if Mmin_global is None:
+            Mmin_global = 0
+        if isinstance(combo_tags, list):
+            return (Mmin_global, governing_combo)
+        return Mmin_global
 
 
     def plot_moment(self, Direction: Literal['My', 'Mz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
@@ -1747,7 +1747,7 @@ class Member3D():
 
             return 0
 
-    def max_torque(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def max_torque(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the maximum torsional moment in the member across the
         specified load combination(s).
@@ -1763,10 +1763,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The maximum torsional moment in the member for the specified
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum torsion value.
+            If a list of tags is provided, returns a tuple of the maximum torsion
+            value and the name of the governing load combination.
         """
         # Normalize input: single combo name or list of tags
         if isinstance(combo_tags, str):
@@ -1779,6 +1779,7 @@ class Member3D():
 
         # Track global maximum torsion across all combos
         Tmax_global = None
+        governing_combo = None
 
         # Loop through each candidate combo
         for combo_name in combo_names:
@@ -1801,12 +1802,17 @@ class Member3D():
             # Update global maximum
             if Tmax_global is None or Tmax > Tmax_global:
                 Tmax_global = Tmax
+                governing_combo = combo_name
 
-        # Return global maximum or 0 if nothing found
-        return Tmax_global if Tmax_global is not None else 0
+        # Return result
+        if Tmax_global is None:
+            Tmax_global = 0
+        if isinstance(combo_tags, list):
+            return (Tmax_global, governing_combo)
+        return Tmax_global
 
 
-    def min_torque(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def min_torque(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the minimum torsional moment in the member across the
         specified load combination(s).
@@ -1822,10 +1828,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The minimum torsional moment in the member for the specified
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum torsion value.
+            If a list of tags is provided, returns a tuple of the minimum torsion
+            value and the name of the governing load combination.
         """
         # Normalize input: single combo name or list of tags
         if isinstance(combo_tags, str):
@@ -1838,6 +1844,7 @@ class Member3D():
 
         # Track global minimum torsion across all combos
         Tmin_global = None
+        governing_combo = None
 
         # Loop through each candidate combo
         for combo_name in combo_names:
@@ -1860,9 +1867,14 @@ class Member3D():
             # Update global minimum
             if Tmin_global is None or Tmin < Tmin_global:
                 Tmin_global = Tmin
+                governing_combo = combo_name
 
-        # Return global minimum or 0 if nothing found
-        return Tmin_global if Tmin_global is not None else 0
+        # Return result
+        if Tmin_global is None:
+            Tmin_global = 0
+        if isinstance(combo_tags, list):
+            return (Tmin_global, governing_combo)
+        return Tmin_global
 
     def plot_torque(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
@@ -1980,7 +1992,7 @@ class Member3D():
 
             return 0
 
-    def max_axial(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def max_axial(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the maximum axial force in the member across the specified
         load combination(s).
@@ -1996,10 +2008,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The maximum axial force in the member for the specified
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum axial value.
+            If a list of tags is provided, returns a tuple of the maximum axial
+            value and the name of the governing load combination.
         """
         # Normalize input: if a string is passed, treat it as a single combo name
         if isinstance(combo_tags, str):
@@ -2013,6 +2025,7 @@ class Member3D():
 
         # Track the global maximum axial force across all combos
         Pmax_global = None
+        governing_combo = None
 
         # Loop through each candidate combo
         for combo_name in combo_names:
@@ -2035,11 +2048,16 @@ class Member3D():
             # Update the global maximum
             if Pmax_global is None or Pmax > Pmax_global:
                 Pmax_global = Pmax
+                governing_combo = combo_name
 
-        # Return the global maximum, or 0 if nothing was found
-        return Pmax_global if Pmax_global is not None else 0
+        # Return result
+        if Pmax_global is None:
+            Pmax_global = 0
+        if isinstance(combo_tags, list):
+            return (Pmax_global, governing_combo)
+        return Pmax_global
 
-    def min_axial(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def min_axial(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the minimum axial force in the member across the specified
         load combination(s).
@@ -2055,10 +2073,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The minimum axial force in the member for the specified
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations or if no segments are available.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum axial value.
+            If a list of tags is provided, returns a tuple of the minimum axial
+            value and the name of the governing load combination.
         """
         # Normalize input: if a string is passed, treat it as a single combo name
         if isinstance(combo_tags, str):
@@ -2072,6 +2090,7 @@ class Member3D():
 
         # Track the global minimum axial force across all combos
         Pmin_global = None
+        governing_combo = None
 
         # Loop through each candidate combo
         for combo_name in combo_names:
@@ -2094,9 +2113,14 @@ class Member3D():
             # Update the global minimum
             if Pmin_global is None or Pmin < Pmin_global:
                 Pmin_global = Pmin
+                governing_combo = combo_name
 
-        # Return the global minimum, or 0 if nothing was found
-        return Pmin_global if Pmin_global is not None else 0
+        # Return result
+        if Pmin_global is None:
+            Pmin_global = 0
+        if isinstance(combo_tags, list):
+            return (Pmin_global, governing_combo)
+        return Pmin_global
 
     def plot_axial(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """
@@ -2257,7 +2281,7 @@ class Member3D():
 
             return 0
 
-    def max_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def max_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the maximum deflection in the member across the specified
         load combination(s).
@@ -2278,10 +2302,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The maximum deflection in the member for the specified
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum deflection.
+            If a list of tags is provided, returns a tuple of the maximum
+            deflection and the name of the governing load combination.
         """
         # Normalize input: single name or list of tags
         if isinstance(combo_tags, str):
@@ -2294,6 +2318,7 @@ class Member3D():
 
         # Track global maximum deflection across all combos
         dmax_global = None
+        governing_combo = None
 
         # Loop through each candidate combo
         for combo_name in combo_names:
@@ -2318,12 +2343,17 @@ class Member3D():
             # Update global maximum
             if dmax_global is None or dmax > dmax_global:
                 dmax_global = dmax
+                governing_combo = combo_name
 
-        # Return global maximum or 0 if nothing found
-        return dmax_global if dmax_global is not None else 0
+        # Return result
+        if dmax_global is None:
+            dmax_global = 0
+        if isinstance(combo_tags, list):
+            return (dmax_global, governing_combo)
+        return dmax_global
 
 
-    def min_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> float:
+    def min_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the minimum deflection in the member across the specified
         load combination(s).
@@ -2344,10 +2374,10 @@ class Member3D():
 
         Returns
         -------
-        float
-            The minimum deflection in the member for the specified
-            combination(s). Returns 0 if the member is inactive for all
-            specified combinations.
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum deflection.
+            If a list of tags is provided, returns a tuple of the minimum
+            deflection and the name of the governing load combination.
         """
         # Normalize input: single name or list of tags
         if isinstance(combo_tags, str):
@@ -2360,6 +2390,7 @@ class Member3D():
 
         # Track global minimum deflection across all combos
         dmin_global = None
+        governing_combo = None
 
         # Loop through each candidate combo
         for combo_name in combo_names:
@@ -2384,9 +2415,14 @@ class Member3D():
             # Update global minimum
             if dmin_global is None or dmin < dmin_global:
                 dmin_global = dmin
-
-        # Return global minimum or 0 if nothing found
-        return dmin_global if dmin_global is not None else 0
+                governing_combo = combo_name
+
+        # Return result
+        if dmin_global is None:
+            dmin_global = 0
+        if isinstance(combo_tags, list):
+            return (dmin_global, governing_combo)
+        return dmin_global
 
     def plot_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
         """

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

@@ -215,9 +215,9 @@ class PhysMember(Member3D):
         member, x_mod = self.find_member(x)
         return member.shear(Direction, x_mod, combo_name)
 
-    def max_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: str = 'Combo 1') -> float:
+    def max_shear(self, Direction: Literal['Fy', 'Fz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
-        Returns the maximum shear in the member for the given direction
+        Returns the maximum shear in the member for the given direction.
 
         Parameters
         ----------
@@ -225,20 +225,41 @@ class PhysMember(Member3D):
             The direction in which to find the maximum shear. 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 combination itself).
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum shear value.
+            If a list of tags is provided, returns a tuple of the maximum shear
+            value and the name of the governing load combination.
         """
 
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         Vmax = None
-        for member in self.sub_members.values():
-            V = member.max_shear(Direction, combo_name)
-            if Vmax is None or V > Vmax:
-                Vmax = V
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                V = member.max_shear(Direction, name)
+                if Vmax is None or V > Vmax:
+                    Vmax = V
+                    governing_combo = name
+
+        if Vmax is None:
+            Vmax = 0
+        if isinstance(combo_tags, list):
+            return (Vmax, governing_combo)
         return Vmax
 
-    def min_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: str = 'Combo 1') -> float:
+    def min_shear(self, Direction: Literal['Fy', 'Fz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
-        Returns the minimum shear in the member for the given direction
+        Returns the minimum shear in the member for the given direction.
 
         Parameters
         ----------
@@ -246,15 +267,36 @@ class PhysMember(Member3D):
             The direction in which to find the minimum shear. 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_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum shear value.
+            If a list of tags is provided, returns a tuple of the minimum shear
+            value and the name of the governing load combination.
         """
 
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         Vmin = None
-        for member in self.sub_members.values():
-            V = member.min_shear(Direction, combo_name)
-            if Vmin is None or V < Vmin:
-                Vmin = V
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                V = member.min_shear(Direction, name)
+                if Vmin is None or V < Vmin:
+                    Vmin = V
+                    governing_combo = name
+
+        if Vmin is None:
+            Vmin = 0
+        if isinstance(combo_tags, list):
+            return (Vmin, governing_combo)
         return Vmin
 
     def plot_shear(self, Direction: Literal['Fy', 'Fz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
@@ -405,46 +447,88 @@ class PhysMember(Member3D):
         member, x_mod = self.find_member(x)
         return member.moment(Direction, x_mod, combo_name)
 
-    def max_moment(self, Direction: Literal['My', 'Mz'], combo_name: str = 'Combo 1') -> float:
+    def max_moment(self, Direction: Literal['My', 'Mz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the maximum moment in the member for the given direction.
-        
+
         Parameters
         ----------
         Direction : string
             The direction in which to find the maximum 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_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum moment value.
+            If a list of tags is provided, returns a tuple of the maximum moment
+            value and the name of the governing load combination.
         """
 
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         Mmax = None
-        for member in self.sub_members.values():
-            M = member.max_moment(Direction, combo_name)
-            if Mmax is None or M > Mmax:
-                Mmax = M
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                M = member.max_moment(Direction, name)
+                if Mmax is None or M > Mmax:
+                    Mmax = M
+                    governing_combo = name
+
+        if Mmax is None:
+            Mmax = 0
+        if isinstance(combo_tags, list):
+            return (Mmax, governing_combo)
         return Mmax
 
-    def min_moment(self, Direction: Literal['My', 'Mz'], combo_name: str = 'Combo 1') -> float:
+    def min_moment(self, Direction: Literal['My', 'Mz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
-        Returns the minimum moment in the member for the given direction
-        
+        Returns the minimum moment in the member for the given direction.
+
         Parameters
         ----------
         Direction : string
             The direction in which to find the minimum 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 load combination itself).
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum moment value.
+            If a list of tags is provided, returns a tuple of the minimum moment
+            value and the name of the governing load combination.
         """
-        
+
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         Mmin = None
-        for member in self.sub_members.values():
-            M = member.min_moment(Direction, combo_name)
-            if Mmin is None or M < Mmin:
-                Mmin = M
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                M = member.min_moment(Direction, name)
+                if Mmin is None or M < Mmin:
+                    Mmin = M
+                    governing_combo = name
+
+        if Mmin is None:
+            Mmin = 0
+        if isinstance(combo_tags, list):
+            return (Mmin, governing_combo)
         return Mmin
 
     def plot_moment(self, Direction: Literal['My', 'Mz'], combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
@@ -598,30 +682,80 @@ class PhysMember(Member3D):
         member, x_mod = self.find_member(x)
         return member.torque(x_mod, combo_name)
 
-    def max_torque(self, combo_name: str = 'Combo 1') -> float:
-        
+    def max_torque(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
+        """
+        Returns the maximum torsional moment in the member.
+
+        Parameters
+        ----------
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum torque value.
+            If a list of tags is provided, returns a tuple of the maximum torque
+            value and the name of the governing load combination.
+        """
+
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         Tmax = None
-        for member in self.sub_members.values():
-            T = member.max_torque(combo_name)
-            if Tmax is None or T > Tmax:
-                Tmax = T
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                T = member.max_torque(name)
+                if Tmax is None or T > Tmax:
+                    Tmax = T
+                    governing_combo = name
+
+        if Tmax is None:
+            Tmax = 0
+        if isinstance(combo_tags, list):
+            return (Tmax, governing_combo)
         return Tmax
 
-    def min_torque(self, combo_name: str = 'Combo 1') -> float:
+    def min_torque(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the minimum torsional moment in the member.
 
         Parameters
         ----------
-        combo_name : string
-            The name of the load combination to get the results for (not the load combination itself).
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum torque value.
+            If a list of tags is provided, returns a tuple of the minimum torque
+            value and the name of the governing load combination.
         """
 
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         Tmin = None
-        for member in self.sub_members.values():
-            T = member.min_torque(combo_name)
-            if Tmin is None or T < Tmin:
-                Tmin = T
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                T = member.min_torque(name)
+                if Tmin is None or T < Tmin:
+                    Tmin = T
+                    governing_combo = name
+
+        if Tmin is None:
+            Tmin = 0
+        if isinstance(combo_tags, list):
+            return (Tmin, governing_combo)
         return Tmin
 
     def plot_torque(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
@@ -756,22 +890,80 @@ class PhysMember(Member3D):
         member, x_mod = self.find_member(x)
         return member.axial(x_mod, combo_name)
 
-    def max_axial(self, combo_name: str = 'Combo 1') -> float:
-        
+    def max_axial(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
+        """
+        Returns the maximum axial force in the member.
+
+        Parameters
+        ----------
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum axial value.
+            If a list of tags is provided, returns a tuple of the maximum axial
+            value and the name of the governing load combination.
+        """
+
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         Pmax = None
-        for member in self.sub_members.values():
-            P = member.max_axial(combo_name)
-            if Pmax is None or P > Pmax:
-                Pmax = P
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                P = member.max_axial(name)
+                if Pmax is None or P > Pmax:
+                    Pmax = P
+                    governing_combo = name
+
+        if Pmax is None:
+            Pmax = 0
+        if isinstance(combo_tags, list):
+            return (Pmax, governing_combo)
         return Pmax
 
-    def min_axial(self, combo_name: str = 'Combo 1') -> float:
+    def min_axial(self, combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
+        """
+        Returns the minimum axial force in the member.
+
+        Parameters
+        ----------
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum axial value.
+            If a list of tags is provided, returns a tuple of the minimum axial
+            value and the name of the governing load combination.
+        """
+
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
 
         Pmin = None
-        for member in self.sub_members.values():
-            P = member.min_axial(combo_name)
-            if Pmin is None or P < Pmin:
-                Pmin = P
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                P = member.min_axial(name)
+                if Pmin is None or P < Pmin:
+                    Pmin = P
+                    governing_combo = name
+
+        if Pmin is None:
+            Pmin = 0
+        if isinstance(combo_tags, list):
+            return (Pmin, governing_combo)
         return Pmin
 
     def plot_axial(self, combo_name: Union[str, List[str]] = 'Combo 1', n_points: int = 20) -> None:
@@ -910,42 +1102,84 @@ class PhysMember(Member3D):
         member, x_mod = self.find_member(x)
         return member.deflection(Direction, x_mod, combo_name)
 
-    def max_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_name: str = 'Combo 1') -> float:
+    def max_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the maximum deflection in the member.
-        
+
         Parameters
         ----------
-        Direction : {'dy', 'dz'}
+        Direction : {'dx', 'dy', 'dz'}
             The direction in which to find the maximum deflection.
-        combo_name : string
-            The name of the load combination to get the results for (not the load combination itself).
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the maximum deflection.
+            If a list of tags is provided, returns a tuple of the maximum
+            deflection and the name of the governing load combination.
         """
 
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         dmax = None
-        for member in self.sub_members.values():
-            d = member.max_deflection(Direction, combo_name)
-            if dmax is None or d > dmax:
-                dmax = d
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                d = member.max_deflection(Direction, name)
+                if dmax is None or d > dmax:
+                    dmax = d
+                    governing_combo = name
+
+        if dmax is None:
+            dmax = 0
+        if isinstance(combo_tags, list):
+            return (dmax, governing_combo)
         return dmax
 
-    def min_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_name: str = 'Combo 1') -> float:
+    def min_deflection(self, Direction: Literal['dx', 'dy', 'dz'], combo_tags: Union[str, List[str]] = 'Combo 1') -> Union[float, tuple[float, str]]:
         """
         Returns the minimum deflection in the member.
-        
+
         Parameters
         ----------
-        Direction : {'dy', 'dz'}
+        Direction : {'dx', 'dy', 'dz'}
             The direction in which to find the minimum deflection.
-        combo_name : string
-            The name of the load combination to get the results for (not the load combination itself).
+        combo_tags : str or list of str
+            A single load combination name, or a list of combo tags.
+
+        Returns
+        -------
+        float or tuple of (float, str)
+            If a single combo name is provided, returns the minimum deflection.
+            If a list of tags is provided, returns a tuple of the minimum
+            deflection and the name of the governing load combination.
         """
 
+        if isinstance(combo_tags, str):
+            combo_names = [combo_tags]
+        else:
+            combo_names = [name for name, combo in self.model.load_combos.items()
+                           if any(tag in combo.combo_tags for tag in combo_tags)]
+
         dmin = None
-        for member in self.sub_members.values():
-            d = member.min_deflection(Direction, combo_name)
-            if dmin is None or d < dmin:
-                dmin = d
+        governing_combo = None
+        for name in combo_names:
+            for member in self.sub_members.values():
+                d = member.min_deflection(Direction, name)
+                if dmin is None or d < dmin:
+                    dmin = d
+                    governing_combo = name
+
+        if dmin is None:
+            dmin = 0
+        if isinstance(combo_tags, list):
+            return (dmin, governing_combo)
         return dmin
 
     def rel_deflection(self, Direction: Literal['dx', 'dy', 'dz'], x: float, combo_name: str = 'Combo 1') -> float:

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

@@ -1599,12 +1599,9 @@ def _PrepContour(model, stress_type='Mx', combo_name='Combo 1'):
 
             # Determine which stress result has been requested by the user
             if stress_type == 'dz':
-                # Internally Pynite defines the nodes for a rectangular element in the order (i, j, m, n),
-                # while it defines the nodes for a quadrilateral element in the order (m, n, i, j)
-                if element.type == 'Rect':
-                    i, j, m, n = element.d(combo_name)[[2, 8, 14, 20], :]
-                else:
-                    i, j, m, n = element.d(combo_name)[[14, 20, 2, 8], :]
+                # Both rectangular and quadrilateral elements store local displacements in the
+                # order (i, j, m, n) in their d() vectors. Local DZ is at indices 2, 8, 14, 20.
+                i, j, m, n = element.d(combo_name)[[2, 8, 14, 20], :]
                 element.i_node.contour.append(i)
                 element.j_node.contour.append(j)
                 element.m_node.contour.append(m)

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

@@ -68,9 +68,12 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+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.
+
 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.

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

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