PyNiteFEA 2.0.0__tar.gz → 2.0.2__tar.gz

{pynitefea-2.0.0 → pynitefea-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.0.0
+Version: 2.0.2
 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
@@ -117,6 +117,15 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.0.2
+* Added docstrings to the VTK `Renderer` class to help the user.
+* Enforced use of properties instead of attributes in the VTK `Renderer` and added docstrings to properties help the user make decisions.
+* Removed the VTK `Renderer`'s properties that began with "set_". These were redundant and caused confusion. The prefix "set_" is no longer used to access or set any of the `Renderer`'s properties.
+
+v2.0.1
+* Pynite no longer struggles rendering load cases and combinations when no loads are present. This is especially helpful for rendering modal load combinations, which don't have loads (only masses).
+* The pyvista plotter's "X" button now works just like pressing "q". This was an annoying pyvista-ism that led to error messages when closing the window with the "X" button.
+
 v2.0.0
 * Added modal analysis. You can now find the natural frequencies and mode shapes of frame-type structures (plates not yet supported). A special thanks to @boustrephon for heading up this feature.
 * Dropping support for python < 3.10.
@@ -195,7 +204,3 @@ v1.0.0
 * Added a new `ShearWall` class that assists you in constructing and analyzing shear walls. This tool automatically detects piers and coupling beams, and finds the forces inside them and calculates their ascpect ratios, which can be handy for seismic design. It reports stiffness of multi-story shear walls at each story to help with rigid diaphragm analysis. It allows for modeling walls with openings, steps, and partial depth diaphragm loading.
 * `vtk` and `pyvista` are now optional dependencies. This change streamlines installation for users who don't rely on `Pynite's` built-in visualization tools. From now on, `Pynite` should be installed using `$ pip install PyNiteFEA[all]` for most users.
 * `Pynite` no longer uses auxiliary nodes to define member cross-section rotation. You can now directly specify the rotation (in degrees) when you define a member using the `rotation` argument.
-
-v0.0.98-100
-* Bug fix for `FEModel3D.add_section`. It was throwing exceptions and had not been updated to match the examples.
-* Improvements to spring rendering in `pyvista`. Up until this point spring elements were being rendered as lines. They now render as zigzag lines in `pyvista`. There is still more work for improvement on spring rendering, but this is a good start.

{pynitefea-2.0.0 → pynitefea-2.0.2}/PyNiteFEA.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.0.0
+Version: 2.0.2
 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
@@ -117,6 +117,15 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.0.2
+* Added docstrings to the VTK `Renderer` class to help the user.
+* Enforced use of properties instead of attributes in the VTK `Renderer` and added docstrings to properties help the user make decisions.
+* Removed the VTK `Renderer`'s properties that began with "set_". These were redundant and caused confusion. The prefix "set_" is no longer used to access or set any of the `Renderer`'s properties.
+
+v2.0.1
+* Pynite no longer struggles rendering load cases and combinations when no loads are present. This is especially helpful for rendering modal load combinations, which don't have loads (only masses).
+* The pyvista plotter's "X" button now works just like pressing "q". This was an annoying pyvista-ism that led to error messages when closing the window with the "X" button.
+
 v2.0.0
 * Added modal analysis. You can now find the natural frequencies and mode shapes of frame-type structures (plates not yet supported). A special thanks to @boustrephon for heading up this feature.
 * Dropping support for python < 3.10.
@@ -195,7 +204,3 @@ v1.0.0
 * Added a new `ShearWall` class that assists you in constructing and analyzing shear walls. This tool automatically detects piers and coupling beams, and finds the forces inside them and calculates their ascpect ratios, which can be handy for seismic design. It reports stiffness of multi-story shear walls at each story to help with rigid diaphragm analysis. It allows for modeling walls with openings, steps, and partial depth diaphragm loading.
 * `vtk` and `pyvista` are now optional dependencies. This change streamlines installation for users who don't rely on `Pynite's` built-in visualization tools. From now on, `Pynite` should be installed using `$ pip install PyNiteFEA[all]` for most users.
 * `Pynite` no longer uses auxiliary nodes to define member cross-section rotation. You can now directly specify the rotation (in degrees) when you define a member using the `rotation` argument.
-
-v0.0.98-100
-* Bug fix for `FEModel3D.add_section`. It was throwing exceptions and had not been updated to match the examples.
-* Improvements to spring rendering in `pyvista`. Up until this point spring elements were being rendered as lines. They now render as zigzag lines in `pyvista`. There is still more work for improvement on spring rendering, but this is a good start.

{pynitefea-2.0.0 → pynitefea-2.0.2}/Pynite/Rendering.py

@@ -8,6 +8,10 @@ import numpy as np
 import pyvista as pv
 import math
 
+# Suppress PyVista warnings for clean console output
+warnings.filterwarnings('ignore', category=UserWarning, module='pyvista')
+warnings.filterwarnings('ignore', message='.*Points is not a float type.*')
+
 # For type checking only - these imports are only used during type checking
 if TYPE_CHECKING:
     from typing import List, Union, Tuple, Optional
@@ -54,13 +58,27 @@ class Renderer:
         # (e.g., grid, axes) before render. Each func in this list must accept a `pyvista.Plotter` argument.
         self.post_update_callbacks: List[Callable[[pv.Plotter], None]] = []
 
-        self.plotter: pv.Plotter = pv.Plotter()
+        # Create plotter with off_screen mode if pyvista is set globally to OFF_SCREEN
+        # This is important for headless CI/testing environments
+        self.plotter: pv.Plotter = pv.Plotter(off_screen=pv.OFF_SCREEN)
         self.plotter.set_background('white')  # Setting background color
         # self.plotter.add_logo_widget('./Resources/Full Logo No Buffer - Transparent.png')
-        # self.plotter.view_isometric()
-        self.plotter.view_xy()
-        self.plotter.show_axes()
-        self.plotter.set_viewup((0, 1, 0))  # Set the Y axis to vertical for 3D plots
+        
+        # Only set view and axes in interactive mode (renderer must exist for these calls)
+        # In off-screen/headless mode, these will be set when update() is called
+        if not pv.OFF_SCREEN:
+            # self.plotter.view_isometric()
+            self.plotter.view_xy()
+            self.plotter.show_axes()
+            self.plotter.set_viewup((0, 1, 0))  # Set the Y axis to vertical for 3D plots
+        
+        # Make X button behave like 'q' key - properly exit without destroying plotter
+        # Why: By default, PyVista's X button forcefully destroys the render window,
+        #      causing warnings and preventing clean shutdown. This observer intercepts
+        #      the window close event.
+        # How: When ExitEvent fires (X button clicked), we call TerminateApp() on the
+        #      interactor, which cleanly exits the event loop just like pressing 'q'.
+        self.plotter.iren.add_observer('ExitEvent', lambda obj, event: obj.TerminateApp())
 
         # Initialize load labels
         self._load_label_points: List[List[float]] = []
@@ -178,7 +196,7 @@ class Renderer:
     def scalar_bar_text_size(self, text_size: int) -> None:
         self._scalar_bar_text_size = text_size
 
-    def render_model(self, reset_camera: bool = True) -> None:
+    def render_model(self, reset_camera: bool = True, off_screen: bool = False) -> None:
         """
         Renders the model in a window
 
@@ -186,19 +204,37 @@ class Renderer:
         ----------
         reset_camera : bool
             Resets the camera if set to `True`. Default is `True`.
+        off_screen : bool
+            Renders off-screen without displaying a window. Useful for testing or
+            generating images in headless environments. Default is `False`.
         """
 
+        # Set off-screen mode if requested (for testing/headless environments)
+        # This must be done BEFORE calling update() so the plotter is in off-screen mode
+        # when adding meshes, preventing PyVista camera initialization issues
+        if off_screen:
+            self.plotter.off_screen = True
+
         # Update the plotter with the latest geometry
         self.update(reset_camera)
 
         # Render the model (code execution will pause here until the user closes the window)
-        self.plotter.show(title='Pynite - Simple Finite Element Analysis for Python', auto_close=False)
+        try:
+            self.plotter.show(title='Pynite - Simple Finite Element Analysis for Python', auto_close=False)
+        finally:
+            # Explicitly deep clean the plotter to prevent garbage collection issues
+            # Why: PyVista/VTK objects can have circular references that cause AttributeErrors
+            #      during Python's garbage collection phase when the program exits.
+            # How: deep_clean() forces immediate cleanup of all VTK objects, meshes, and actors
+            #      before Python's garbage collector runs, preventing the "'NoneType' object has
+            #      no attribute 'check_attribute'" exception that would otherwise appear.
+            self.plotter.deep_clean()
 
     def screenshot(self, filepath: str = './Pynite_Image.png', interact: bool = True, reset_camera: bool = False) -> None:
         """
         Saves a screenshot of the rendered model.
 
-        In non-Jupyter notebook environments, if `interact` is set to `True`, the plotter will show a window that allows you to set the scene prior to the screenshot. Press `q` when you are ready to capture the screenshot and close the window. Pressing the `X` button in the corner of the window will ignore your scene changes and will shut down the entire plotter. This is a default setting in pyvista that is a little annoying. Don't press the `X` button.
+        In non-Jupyter notebook environments, if `interact` is set to `True`, the plotter will show a window that allows you to set the scene prior to the screenshot. Press `q` or click the `X` button when you are ready to capture the screenshot and close the window.
 
         For Jupyter notebooks, the scene must be set using `render_model` prior to using `screenshot`.
 
@@ -246,6 +282,15 @@ class Renderer:
 
         # Clear out the old plot (if any)
         self.plotter.clear()
+        
+        # Set up view and axes (works for both interactive and off-screen modes)
+        try:
+            self.plotter.view_xy()
+            self.plotter.show_axes()
+            self.plotter.set_viewup((0, 1, 0))
+        except:
+            # Silently fail if not supported in this context
+            pass
 
         # Clear out internally stored labels (if any)
         self._load_label_points = []
@@ -1063,9 +1108,20 @@ class Renderer:
                         if abs(load[0]) > max_area_load:
                             max_area_load = abs(load[0])
             
+        # Prevent division by zero errors by ensuring max values are never zero
+        # If a load type has no loads, set it to 1 to avoid crashes during normalization
+        if max_pt_load == 0:
+            max_pt_load = 1
+        if max_moment == 0:
+            max_moment = 1
+        if max_dist_load == 0:
+            max_dist_load = 1
+        if max_area_load == 0:
+            max_area_load = 1
+        
         # Return the maximum loads for the load combo or load case
         return max_pt_load, max_moment, max_dist_load, max_area_load
-
+            
     def plot_loads(self):
       
         # Get the maximum load magnitudes that will be used to normalize the display scale

{pynitefea-2.0.0 → pynitefea-2.0.2}/Pynite/Visualization.py

@@ -1,5 +1,4 @@
 from __future__ import annotations # Allows more recent type hints features
-from json import load
 import warnings
 
 from IPython.display import Image
@@ -8,28 +7,83 @@ from numpy.linalg import norm
 import vtk
 
 class Renderer():
-    """Used to render finite element models.
+    """Renderer for visualizing finite element models using VTK.
+    
+    This class provides a flexible interface for rendering 3D finite element models,
+    including nodes, members, springs, plates, and quads. It supports rendering of
+    undeformed and deformed shapes, load visualizations, and stress/force contours.
+    
+    Parameters
+    ----------
+    model : FEModel3D
+        The finite element model to be rendered.
+    
+    Attributes
+    ----------
+    annotation_size : float
+        Controls the size of text labels and visual elements (default: 5).
+    deformed_shape : bool
+        Whether to render the deformed shape of the model (default: False).
+    deformed_scale : float
+        Scale factor for deformation visualization (default: 30).
+    render_nodes : bool
+        Whether to render nodes in the visualization (default: True).
+    render_loads : bool
+        Whether to render applied loads (default: True).
+    color_map : str or None
+        Type of stress/force contour to display on plates/quads. Options:
+        'Qx', 'Qy', 'Mx', 'My', 'Mxy', 'Sx', 'Sy', 'Txy' (default: None).
+    combo_name : str or None
+        Name of load combination to visualize. Mutually exclusive with case.
+    case : str or None
+        Name of load case to visualize. Mutually exclusive with combo_name.
+    labels : bool
+        Whether to display text labels for elements (default: True).
+    scalar_bar : bool
+        Whether to display a scalar bar for contour plots (default: False).
+    scalar_bar_text_size : int
+        Font size for scalar bar text (default: 24).
+    theme : str
+        Visual theme: 'default' or 'print' (default: 'default').
+    window_size : tuple
+        Window dimensions as (width, height).
+    
+    Examples
+    --------
+    >>> from PyNite import FEModel3D
+    >>> model = FEModel3D()
+    >>> # ... build model ...
+    >>> renderer = Renderer(model)
+    >>> renderer.annotation_size = 6
+    >>> renderer.combo_name = 'Load Combo 1'
+    >>> renderer.render_model()
     """
 
     scalar = None
 
     def __init__(self, model):
-
+        """Initialize the renderer with a finite element model.
+        
+        Parameters
+        ----------
+        model : FEModel3D
+            The finite element model to render.
+        """
         self.model = model
 
         # Default settings for rendering
-        self.annotation_size = 5
-        self.deformed_shape = False
-        self.deformed_scale = 30
-        self.render_nodes = True
-        self.render_loads = True
-        self.color_map = None
-        self.combo_name = 'Combo 1'
-        self.case = None
-        self.labels = True
-        self.scalar_bar = False
-        self.scalar_bar_text_size = 24
-        self.theme = 'default'
+        self._annotation_size = 5
+        self._deformed_shape = False
+        self._deformed_scale = 30
+        self._render_nodes = True
+        self._render_loads = True
+        self._color_map = None
+        self._combo_name = 'Combo 1'
+        self._case = None
+        self._labels = True
+        self._scalar_bar = False
+        self._scalar_bar_text_size = 24
+        self._theme = 'default'
 
         # Initialize VTK objects
         self.renderer = vtk.vtkRenderer()
@@ -38,62 +92,134 @@ class Renderer():
         self.window.AddRenderer(self.renderer)
 
     @property
-    def window_width(self):
-        return self.window.GetSize()[0]
-
-    @window_width.setter
-    def window_width(self, width):
-        height = self.window.GetSize()[1]
+    def window_size(self):
+        """Window size as (width, height) tuple."""
+        return self.window.GetSize()
+
+    @window_size.setter
+    def window_size(self, size):
+        """Set window size from tuple or list (width, height)."""
+        width, height = size
         self.window.SetSize(width, height)
 
     @property
-    def window_height(self):
-        return self.window.GetSize()[1]
-
-    @window_height.setter
-    def window_height(self, height):
-        width = self.window.GetSize()[0]
-        self.window.SetSize(width, height)
+    def combo_name(self):
+        """Load combination name. When set, case is automatically set to None."""
+        return self._combo_name
+    
+    @combo_name.setter
+    def combo_name(self, value):
+        self._combo_name = value
+        if value is not None:
+            self._case = None
+    
+    @property
+    def case(self):
+        """Load case name. When set, combo_name is automatically set to None."""
+        return self._case
+    
+    @case.setter
+    def case(self, value):
+        self._case = value
+        if value is not None:
+            self._combo_name = None
 
-    def set_annotation_size(self, size=5):
-        self.annotation_size = size
+    @property
+    def annotation_size(self):
+        """Size of text annotations and visual elements in model units."""
+        return self._annotation_size
+    
+    @annotation_size.setter
+    def annotation_size(self, value):
+        self._annotation_size = value
 
-    def set_deformed_shape(self, deformed_shape=False):
-        self.deformed_shape = deformed_shape
+    @property
+    def deformed_shape(self):
+        """Whether to render the deformed shape of the model."""
+        return self._deformed_shape
+    
+    @deformed_shape.setter
+    def deformed_shape(self, value):
+        self._deformed_shape = value
 
-    def set_deformed_scale(self, scale=30):
-        self.deformed_scale = scale
+    @property
+    def deformed_scale(self):
+        """Scale factor for deformation visualization."""
+        return self._deformed_scale
+    
+    @deformed_scale.setter
+    def deformed_scale(self, value):
+        self._deformed_scale = value
 
-    def set_render_nodes(self, render_nodes=True):
-        self.render_nodes = render_nodes
+    @property
+    def render_nodes(self):
+        """Whether to render nodes in the visualization."""
+        return self._render_nodes
+    
+    @render_nodes.setter
+    def render_nodes(self, value):
+        self._render_nodes = value
 
-    def set_render_loads(self, render_loads=True):
-        self.render_loads = render_loads
+    @property
+    def render_loads(self):
+        """Whether to render applied loads."""
+        return self._render_loads
     
-    def set_color_map(self, color_map=None):
-        """Sets the color map for plate contours.
+    @render_loads.setter
+    def render_loads(self, value):
+        self._render_loads = value
 
-        :param color_map: The color map to use: Valid options are 'Qx', Qy', 'Mx', 'My', 'Mxy', 'Sx', 'Sy' 'Txy'. Qx and Qy are out-of-plane shear forces. Mx, My, and Mxy are local out-of-plane bending moments. 'Sx' and 'Sy' are membrane forces, and 'Txy' is an in-plane shear force. Defaults to None.
-        :type color_map: str, optional
+    @property
+    def color_map(self):
+        """Type of stress/force contour to display on plates/quads.
+        
+        Valid options: 'Qx', 'Qy', 'Mx', 'My', 'Mxy', 'Sx', 'Sy', 'Txy'
+        - Qx, Qy: Out-of-plane shear forces
+        - Mx, My, Mxy: Local out-of-plane bending moments
+        - Sx, Sy: Membrane forces
+        - Txy: In-plane shear force
         """
-        self.color_map = color_map
-
-    def set_combo_name(self, combo_name='Combo 1'):
-        self.case = None
-        self.combo_name = combo_name
+        return self._color_map
+    
+    @color_map.setter
+    def color_map(self, value):
+        self._color_map = value
 
-    def set_case(self, case=None):
-        self.combo_name = None
-        self.case = case
+    @property
+    def labels(self):
+        """Whether to display text labels for elements."""
+        return self._labels
+    
+    @labels.setter
+    def labels(self, value):
+        self._labels = value
 
-    def set_show_labels(self, show_labels=True):
-        self.labels = show_labels
+    @property
+    def scalar_bar(self):
+        """Whether to display a scalar bar legend for contour plots."""
+        return self._scalar_bar
+    
+    @scalar_bar.setter
+    def scalar_bar(self, value):
+        self._scalar_bar = value
 
-    def set_scalar_bar(self, scalar_bar=False):
-        self.scalar_bar = scalar_bar
+    @property
+    def scalar_bar_text_size(self):
+        """Font size for scalar bar text."""
+        return self._scalar_bar_text_size
+    
+    @scalar_bar_text_size.setter
+    def scalar_bar_text_size(self, value):
+        self._scalar_bar_text_size = value
 
-    def set_scalar_bar_text_size(self, text_size=24):
-        self.scalar_bar_text_size = text_size
+    @property
+    def theme(self):
+        """Visual theme: 'default' (dark background) or 'print' (white background)."""
+        return self._theme
+    
+    @theme.setter
+    def theme(self, value):
+        self._theme = value
 
     def render_model(self, interact=True, reset_camera=True):
         """
@@ -198,11 +324,26 @@ class Renderer():
             return
 
     def update(self, reset_camera=True):
-        """Builds (or rebuilds) the VTK renderer
-
-        :param reset_camera: Resets the render window's camera position if set to True. Defaults to True.
-        :type reset_camera: bool, optional
-        :raises Exception: Visualization failed due to an unexpected error.
+        """Build or rebuild the VTK renderer with current settings.
+        
+        This method updates the visualization based on the current renderer settings,
+        including deformed shape, loads, contours, and other visual elements. It is
+        automatically called by render_model() and screenshot().
+        
+        Parameters
+        ----------
+        reset_camera : bool, optional
+            If True, resets the camera to view the entire model (default: True).
+        
+        Raises
+        ------
+        Exception
+            If the model configuration is invalid for the requested visualization.
+        
+        Notes
+        -----
+        This method validates that deformed_shape is not used with a load case,
+        and that render_loads requires either a load combination or load case.
         """
 
         # Input validation
@@ -604,8 +745,9 @@ class VisNode():
         # Set the mapper for the node's actor
         self.actor.SetMapper(mapper)
 
+
 class VisSpring():
-    
+
     def __init__(self, spring, nodes, annotation_size=5, color=None):
 
         # Generate a line source for the spring
@@ -1320,6 +1462,9 @@ def _RenderLoads(model, renderer, annotation_size, combo_name, case, theme='defa
     polygon_points = vtk.vtkPoints()
     polygon_polydata = vtk.vtkPolyData()
 
+    # Track whether any loads have been added to avoid VTK errors with empty append filters
+    has_loads = False
+
     # Get the maximum load magnitudes that will be used to normalize the display scale
     max_pt_load, max_moment, max_dist_load, max_area_load = _MaxLoads(model, combo_name, case)
 
@@ -1365,6 +1510,7 @@ def _RenderLoads(model, renderer, annotation_size, combo_name, case, theme='defa
                 polydata.AddInputData(ptLoad.polydata.GetOutput())
                 renderer.AddActor(ptLoad.lblActor)
                 ptLoad.lblActor.SetCamera(renderer.GetActiveCamera())
+                has_loads = True
 
     # Step through each member
     for member in model.members.values():
@@ -1418,6 +1564,7 @@ def _RenderLoads(model, renderer, annotation_size, combo_name, case, theme='defa
                 polydata.AddInputData(ptLoad.polydata.GetOutput())
                 renderer.AddActor(ptLoad.lblActor)
                 ptLoad.lblActor.SetCamera(renderer.GetActiveCamera())
+                has_loads = True
 
         # Step through each member distributed load
         for load in member.DistLoads:
@@ -1454,6 +1601,7 @@ def _RenderLoads(model, renderer, annotation_size, combo_name, case, theme='defa
                 renderer.AddActor(distLoad.lblActors[1])
                 distLoad.lblActors[0].SetCamera(renderer.GetActiveCamera())
                 distLoad.lblActors[1].SetCamera(renderer.GetActiveCamera())
+                has_loads = True
 
     # Step through each plate
     i = 0
@@ -1489,6 +1637,7 @@ def _RenderLoads(model, renderer, annotation_size, combo_name, case, theme='defa
 
                 # Add the area load's arrows to the overall load polydata
                 polydata.AddInputData(area_load.polydata.GetOutput())
+                has_loads = True
 
                 # Add the 4 points at the corners of this area load to the list of points
                 polygon_points.InsertNextPoint(area_load.p0[0], area_load.p0[1], area_load.p0[2])
@@ -1523,35 +1672,39 @@ def _RenderLoads(model, renderer, annotation_size, combo_name, case, theme='defa
                 polygon_polydata.SetPoints(polygon_points)
                 polygon_polydata.SetPolys(polygons)
 
-    # Set up an actor and mapper for the loads
-    load_mapper = vtk.vtkPolyDataMapper()
-    load_mapper.SetInputConnection(polydata.GetOutputPort())
-    load_actor = vtk.vtkActor()
-    load_actor.SetMapper(load_mapper)
+    # Only create and add actors if there are loads to render (avoids VTK errors with empty append filters)
+    if has_loads:
+        # Set up an actor and mapper for the loads
+        load_mapper = vtk.vtkPolyDataMapper()
+        load_mapper.SetInputConnection(polydata.GetOutputPort())
+        load_actor = vtk.vtkActor()
+        load_actor.SetMapper(load_mapper)
 
-    # Colorize the loads
-    if theme == 'default':
-        load_actor.GetProperty().SetColor(0, 1, 0)  # Green
-    elif theme == 'print':
-        load_actor.GetProperty().SetColor(0, 0.75, 0)  # Dark Green
+        # Colorize the loads
+        if theme == 'default':
+            load_actor.GetProperty().SetColor(0, 1, 0)  # Green
+        elif theme == 'print':
+            load_actor.GetProperty().SetColor(0, 0.75, 0)  # Dark Green
 
-    # Add the load actor to the renderer
-    renderer.AddActor(load_actor)
+        # Add the load actor to the renderer
+        renderer.AddActor(load_actor)
 
-    # Set up an actor and a mapper for the area load polygons
-    polygon_mapper = vtk.vtkPolyDataMapper()
-    polygon_mapper.SetInputData(polygon_polydata)
-    polygon_actor = vtk.vtkActor()
+    # Only create polygon actors if there are area loads (i > 0 means we added polygons)
+    if i > 0:
+        # Set up an actor and a mapper for the area load polygons
+        polygon_mapper = vtk.vtkPolyDataMapper()
+        polygon_mapper.SetInputData(polygon_polydata)
+        polygon_actor = vtk.vtkActor()
 
-    # polygon_actor.GetProperty().SetOpacity(0.5)      # 50% opacity
-    polygon_actor.SetMapper(polygon_mapper)
-    renderer.AddActor(polygon_actor)
+        # polygon_actor.GetProperty().SetOpacity(0.5)      # 50% opacity
+        polygon_actor.SetMapper(polygon_mapper)
+        renderer.AddActor(polygon_actor)
 
-    # Set the color of the area load polygons
-    if theme == 'default':
-        polygon_actor.GetProperty().SetColor(0, 1, 0)  # Green
-    elif theme == 'print':
-        polygon_actor.GetProperty().SetColor(0, 0.75, 0)  # Dark Green
+        # Set the color of the area load polygons
+        if theme == 'default':
+            polygon_actor.GetProperty().SetColor(0, 1, 0)  # Green
+        elif theme == 'print':
+            polygon_actor.GetProperty().SetColor(0, 0.75, 0)  # Dark Green
 
 def _RenderContours(model, renderer, deformed_shape, deformed_scale, color_map, scalar_bar, scalar_bar_text_size, combo_name, theme='default'):
 
@@ -1847,5 +2000,16 @@ def _MaxLoads(model, combo_name=None, case=None):
                     if abs(load[0]) > max_area_load:
                         max_area_load = abs(load[0])
 
+    # Prevent division by zero errors by ensuring max values are never zero
+    # If a load type has no loads, set it to 1 to avoid crashes during normalization
+    if max_pt_load == 0:
+        max_pt_load = 1
+    if max_moment == 0:
+        max_moment = 1
+    if max_dist_load == 0:
+        max_dist_load = 1
+    if max_area_load == 0:
+        max_area_load = 1
+
     # Return the maximum loads in the load combination or load case
     return max_pt_load, max_moment, max_dist_load, max_area_load

{pynitefea-2.0.0 → pynitefea-2.0.2}/README.md

@@ -67,6 +67,15 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.0.2
+* Added docstrings to the VTK `Renderer` class to help the user.
+* Enforced use of properties instead of attributes in the VTK `Renderer` and added docstrings to properties help the user make decisions.
+* Removed the VTK `Renderer`'s properties that began with "set_". These were redundant and caused confusion. The prefix "set_" is no longer used to access or set any of the `Renderer`'s properties.
+
+v2.0.1
+* Pynite no longer struggles rendering load cases and combinations when no loads are present. This is especially helpful for rendering modal load combinations, which don't have loads (only masses).
+* The pyvista plotter's "X" button now works just like pressing "q". This was an annoying pyvista-ism that led to error messages when closing the window with the "X" button.
+
 v2.0.0
 * Added modal analysis. You can now find the natural frequencies and mode shapes of frame-type structures (plates not yet supported). A special thanks to @boustrephon for heading up this feature.
 * Dropping support for python < 3.10.
@@ -145,7 +154,3 @@ v1.0.0
 * Added a new `ShearWall` class that assists you in constructing and analyzing shear walls. This tool automatically detects piers and coupling beams, and finds the forces inside them and calculates their ascpect ratios, which can be handy for seismic design. It reports stiffness of multi-story shear walls at each story to help with rigid diaphragm analysis. It allows for modeling walls with openings, steps, and partial depth diaphragm loading.
 * `vtk` and `pyvista` are now optional dependencies. This change streamlines installation for users who don't rely on `Pynite's` built-in visualization tools. From now on, `Pynite` should be installed using `$ pip install PyNiteFEA[all]` for most users.
 * `Pynite` no longer uses auxiliary nodes to define member cross-section rotation. You can now directly specify the rotation (in degrees) when you define a member using the `rotation` argument.
-
-v0.0.98-100
-* Bug fix for `FEModel3D.add_section`. It was throwing exceptions and had not been updated to match the examples.
-* Improvements to spring rendering in `pyvista`. Up until this point spring elements were being rendered as lines. They now render as zigzag lines in `pyvista`. There is still more work for improvement on spring rendering, but this is a good start.

{pynitefea-2.0.0 → pynitefea-2.0.2}/setup.py

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