springcalc 0.1.0__py3-none-any.whl

springcalc/__init__.py

@@ -0,0 +1,58 @@
+"""springcalc — spring calculation library (compression, extension, and torsion).
+
+Main public API:
+    - CompressionSpring, ExtensionSpring, TorsionSpring: calculations per spring type.
+    - Material, get_available_materials: material data.
+    - GoodmanData, GoodmanAnalyzer, Goodman: fatigue analysis (Goodman diagram).
+"""
+
+from springcalc.lineal.compresion import CompressionSpring
+from springcalc.lineal.generic_compression import CompressionSpringGeneral
+from springcalc.lineal.extension import ExtensionSpring
+from springcalc.lineal.torsion import TorsionSpring
+from springcalc.lineal.animation import CompressionAnimator
+from springcalc.lineal.goodman import Goodman, GoodmanAnalyzer, GoodmanData
+from springcalc.pymodels.material import Material, get_available_materials, get_materials_dataframe
+from springcalc.pymodels.positions import (
+    LinearPosition,
+    AngularPosition,
+    LinearLoadPosition,
+    AngularLoadPosition,
+    LinearPositionsTable,
+    AngularPositionsTable,
+)
+from springcalc.pymodels.wire_characteristics import get_wire_tolerance, get_RMa_range
+from springcalc.plots.goodman_diagram import generate_goodman_diagram
+from springcalc.report import SpringPDFReport
+from springcalc.pymodels.units import ureg
+from springcalc.lineal.plotting import interactive_backend
+from importlib.metadata import version as _version
+
+__version__ = _version("springcalc")
+
+__all__ = [
+    "CompressionSpring",
+    "CompressionSpringGeneral",
+    "ExtensionSpring",
+    "TorsionSpring",
+    "CompressionAnimator",
+    "Material",
+    "get_available_materials",
+    "get_materials_dataframe",
+    "LinearPosition",
+    "AngularPosition",
+    "LinearLoadPosition",
+    "AngularLoadPosition",
+    "LinearPositionsTable",
+    "AngularPositionsTable",
+    "get_wire_tolerance",
+    "get_RMa_range",
+    "GoodmanData",
+    "GoodmanAnalyzer",
+    "Goodman",
+    "generate_goodman_diagram",
+    "SpringPDFReport",
+    "ureg",
+    "interactive_backend",
+    "__version__",
+]

springcalc/lineal/animation.py

@@ -0,0 +1,84 @@
+"""Animated GIF generation showing a compression spring's coils closing up
+under progressive load (frame-by-frame 3D helix, driven by
+simulate_progressive_compression's per-step geometry).
+"""
+import numpy as np
+from pint import Quantity
+import matplotlib
+from matplotlib import pyplot as plt
+from matplotlib.animation import FuncAnimation, PillowWriter
+from ..pymodels.units import ureg
+from .generic_lineal import VariableLinealSpring
+matplotlib.use('Agg')
+
+
+class CompressionAnimator:
+    """Renders a spring's progressive compression as an animated GIF.
+
+    Usage::
+
+        animator = CompressionAnimator(spring)
+        animator.create_gif(max_deflection=40 * ureg.mm, output_path="compression.gif")
+    """
+
+    def __init__(self, spring: VariableLinealSpring):
+        self.spring = spring
+
+    def create_gif(self,
+                   max_deflection: Quantity,
+                   output_path: str = "animation.gif",
+                   steps: int = 60,
+                   num_points: int = 300,
+                   fps: int = 12,
+                   isometric: bool = True) -> str:
+        """Simulate progressive compression and render it as an animated GIF.
+
+        Returns output_path.
+        """
+        deflection, force, _, geometry = self.spring.simulate_progressive_compression(
+            max_deflection=max_deflection,
+            steps=steps,
+            num_points=num_points,
+            capture_geometry=True,
+        )
+        thetas = geometry["thetas"]
+        z_history = geometry["z_history"]
+
+        Ds = np.array([self.spring.f_mean_diameter(z * ureg.mm).to('mm').magnitude for z in z_history[0]])
+        radii = Ds / 2.0
+        xs = radii * np.cos(thetas)
+        ys = radii * np.sin(thetas)
+
+        deflection_mm = deflection.to('mm').magnitude
+        force_n = force.to('N').magnitude
+
+        fig = plt.figure()
+        ax = fig.add_subplot(projection='3d')
+        line, = ax.plot(xs, ys, z_history[0])
+
+        ax.set_xlabel('X (mm)')
+        ax.set_ylabel('Y (mm)')
+        ax.set_zlabel('Z (mm)')
+        # Fix the axis limits up front (from the free-state extent) so the
+        # camera/scale doesn't jump around as the coils close up frame to frame.
+        margin = max(np.ptp(xs), np.ptp(ys)) * 0.1
+        ax.set_xlim(xs.min() - margin, xs.max() + margin)
+        ax.set_ylim(ys.min() - margin, ys.max() + margin)
+        ax.set_zlim(0, z_history[0].max())
+        ax.set_box_aspect((np.ptp(xs), np.ptp(ys), z_history[0].max()))
+        if isometric:
+            ax.set_proj_type('ortho')
+            ax.view_init(elev=35.264, azim=45)
+
+        def update(frame_idx):
+            z = z_history[frame_idx]
+            line.set_data(xs, ys)
+            line.set_3d_properties(z)
+            ax.set_title(f"Deflection: {deflection_mm[frame_idx]:.1f} mm   Force: {force_n[frame_idx]:.1f} N")
+            return (line,)
+
+        anim = FuncAnimation(fig, update, frames=len(z_history), interval=1000 / fps)
+        anim.save(output_path, writer=PillowWriter(fps=fps))
+        plt.close(fig)
+
+        return output_path

springcalc/lineal/compresion.py

@@ -0,0 +1,540 @@
+"""Class for calculating a standard compression spring."""
+from math import pi
+from pydantic import field_validator, ConfigDict
+from .constants import COMPRESSION_SPRING_END_TYPES, FORMING_TYPES
+from .goodman import Goodman
+import traceback
+from matplotlib import pyplot as plt
+from matplotlib.patches import Circle
+import io
+import base64
+import numpy as np
+from .goodman import GoodmanData, GoodmanAnalyzer
+from .lineal import LinealSpring
+from pint import Quantity
+from ..pymodels.units import ureg
+from ..pymodels.positions import LinearPositionsTable
+from typing import Optional
+import matplotlib
+from .plotting import interactive_backend
+matplotlib.use('Agg')
+
+
+class CompressionSpring(LinealSpring):
+    # Additional CompressionSpring fields
+    model_config = ConfigDict(arbitrary_types_allowed=True, validate_assignment=True)
+    type_of_end: str = COMPRESSION_SPRING_END_TYPES[1]  # ground by default
+    # set cold formed by default
+    type_conforming: str = FORMING_TYPES[1]
+    # the wire length should be in mm
+    wire_length: Optional[Quantity] = 0.0 * ureg.mm
+    nr_coils: Optional[float] = None
+    solid_length: Quantity = 0.0 * ureg.mm  # Length at maximum load in mm
+    positions: LinearPositionsTable = LinearPositionsTable()
+
+    @field_validator('wire_length', "solid_length", mode='before')
+    @classmethod
+    def validate_quantities(cls, value):
+        if isinstance(value, str):
+            try:
+                quantity = ureg(value)
+                return quantity.to('mm')
+            except Exception as e:
+                raise ValueError(f"Error converting '{value}' to Quantity: {e}")
+        elif isinstance(value, (int, float)):
+            return Quantity(value, 'mm')
+        elif isinstance(value, Quantity):
+            return value.to('mm')
+        else:
+            raise ValueError(f"Invalid value for Quantity: {value}")
+
+    def __init__(self, material, wire_diameter: float, **data):
+        """Initialize the spring variables to 0."""
+        # Initialize with default values
+        super().__init__(material, wire_diameter, **data)
+
+    def set_material(self, material, wire_diameter):
+        return super().set_material(material, wire_diameter)
+
+    def set_geometry(self,
+                     mean_diameter: float = None,
+                     outer_diameter: float = None,
+                     inner_diameter: float = None,
+                     nr_coils: float = None,
+                     pitch: float = None,
+                     free_length: float = None,
+                     type_of_end: Optional[str] = 'closed_unground',
+                     type_conforming: Optional[str] = 'cold_formed'):
+        """Set the spring's full geometry in one call.
+        Provide the general geometry parameters and characteristics of the spring
+        Computes and stores every derived spring property and calls calculate_spring_properties().
+        Parameters:
+        one of the following must be provided: mean_diameter, outer_diameter, inner_diameter
+            mean_diameter: mean diameter of the spring (mm)
+            outer_diameter: outer diameter of the spring (mm)
+            inner_diameter: inner diameter of the spring (mm)
+        two of the following must be provided: nr_coils, pitch, free_length
+            nr_coils: number of coils in the spring
+            pitch: pitch of the spring (mm)
+            free_length: free length of the spring (mm)
+        Optional parameters:
+            type_of_end: type of end of the spring ('open_ground','closed_ground','open_unground','closed_unground')
+            type_conforming: type of conforming of the spring ('cold_formed','hot_formed')
+
+        Returns:
+        A dictionary with all the spring properties, including the derived ones.
+        """
+        diameters_provided = sum(1 for var in [mean_diameter, outer_diameter, inner_diameter] if var is not None)
+        if diameters_provided != 1:
+            raise ValueError("You must provide exactly one of the following variables: mean_diameter, outer_diameter, inner_diameter")
+
+        length_params_provided = sum(1 for var in [nr_coils, pitch, free_length] if var is not None)
+        if length_params_provided != 2:
+            raise ValueError("You must provide exactly two of the following variables: nr_coils, pitch, free_length")
+
+        if type_of_end is not None:
+            self.type_of_end = type_of_end
+        if type_conforming is not None:
+            self.type_conforming = type_conforming
+
+        self.set_diameter(mean_diameter=mean_diameter,
+                          outer_diameter=outer_diameter,
+                          inner_diameter=inner_diameter)
+        return self.calculate_spring_properties(nr_coils=nr_coils,
+                                                pitch=pitch,
+                                                free_length=free_length)
+
+    def calculate_spring_properties(self,
+                                    nr_coils: float = None,
+                                    pitch: float = None,
+                                    free_length: float = None):
+        """Part three: Calculate all spring properties."""
+        parameters_provided = sum(1 for var in [nr_coils, pitch, free_length] if var is not None)
+        if parameters_provided != 2:
+            raise ValueError("You must provide exactly two of the following variables: nr_coils, pitch, free_length")
+
+        if nr_coils is not None and pitch is not None:
+            self.nr_coils = nr_coils
+            self.pitch = pitch
+            self.free_length = self.nr_coils * self.pitch
+        elif nr_coils is not None and free_length is not None:
+            self.nr_coils = nr_coils
+            self.free_length = free_length
+            self.pitch = self.free_length / self.nr_coils
+        elif pitch is not None and free_length is not None:
+            self.pitch = pitch
+            self.free_length = free_length
+            self.nr_coils = self.free_length / self.pitch
+        else:
+            raise ValueError("You must provide exactly two of the following variables: nr_coils, pitch, free_length")
+
+        if self.pitch <= self.wire_diameter:
+            raise ValueError("The pitch must be greater than the wire diameter to avoid interference between coils.")
+        self.calculate_active_coils(nr_coils=self.nr_coils)
+        self.calculate_wahl_factor()
+        self.calculate_spring_constant()
+        self.calculate_solid_length()
+        self.calculate_wire_length()
+        self.calculate_load_at_position(self.solid_length)
+        self.calculate_outer_diameter_at_position(self.solid_length)
+        properties = self.get_spring_data()
+        return properties
+
+    def calculate_active_coils(self, nr_coils):
+        """Calculate the number of active spring coils based on the end type."""
+        self.nr_coils = nr_coils
+        # Active coils are calculated only for compression springs.
+        # For hot-formed springs, 1.5 times the wire diameter is subtracted.
+        if self.type_conforming == FORMING_TYPES[1]:  # cold formed
+            self.nr_active_coils = self.nr_coils - 2
+            if self.type_of_end in [COMPRESSION_SPRING_END_TYPES[3], COMPRESSION_SPRING_END_TYPES[4]]:  # unground
+                self.nr_active_coils -= 1.5
+        else:
+            # in case spring is hot formed
+            self.nr_active_coils = self.nr_coils - 1.5
+        if self.type_of_end in [COMPRESSION_SPRING_END_TYPES[1], COMPRESSION_SPRING_END_TYPES[2]]:  # ground
+            self.nr_active_coils -= 0.3
+        else:
+            self.nr_active_coils -= 1.1
+        return self.nr_active_coils
+
+    def calculate_wire_length(self):
+        """Calculate the spring wire length."""
+        self.wire_length = self.nr_coils * np.sqrt((pi * self.mean_diameter)**2 + self.pitch**2)
+        return self.wire_length
+
+    def calculate_pitch(self):
+        """Calculate the spring pitch."""
+        return self.free_length / self.nr_coils
+
+    def calculate_solid_length(self):
+        """Calculate the spring solid length."""
+        self.solid_length = self.nr_coils * self.wire_diameter
+        return self.solid_length
+
+    def add_load_position(self, length: Quantity):
+        """Add a load position to the positions table."""
+        if not isinstance(length, Quantity):
+            length = length * ureg.mm
+        try:
+            if length < self.solid_length:
+                raise ValueError("The position cannot be smaller than the spring's solid length")
+            load = self.calculate_load_at_position(length)
+            stress = self.calculate_stress_at_position(load)
+            outer_diameter = self.calculate_outer_diameter_at_position(length)
+        except ValueError as e:
+            raise ValueError(f"Error adding load position at length {length}: {e}")
+        self.positions.add_load_position(
+            position=self.position_length,
+            travel=self.free_length - self.position_length,
+            load=load,
+            stress=stress,
+            outer_diameter=outer_diameter,
+            inner_diameter=max(outer_diameter - 2 * self.wire_diameter, 0 * ureg.mm)
+        )
+
+    def calculate_outer_diameter_at_position(self, length):
+        """Calculate the spring outer diameter."""
+        self.position_length = length
+        outer_diameter = (self.mean_diameter + self.wire_diameter +
+                          self.mean_diameter * self.material.poisson_coef *
+                          (self.free_length - self.position_length) / self.free_length)
+        return outer_diameter
+
+    def empty_tables(self):
+        """Clear the positions, loads, stresses, and outer diameters tables."""
+        self.positions.clear_table()
+
+    def get_spring_data(self):
+        """Return a dictionary with the main spring data."""
+        return {
+            "material": self.material.material_name,
+            "young_modulus": self.material.young_modulus,
+            "shear_modulus": self.material.shear_modulus,
+            "elastic_limit_factor": self.material.elastic_limit_factor,
+            "poisson_coef": self.material.poisson_coef,
+            "RMa_file": self.material.RMa_file,
+            "wire_diameter": self.wire_diameter,
+            "mean_diameter": self.mean_diameter,
+            "free_length": self.free_length,
+            "nr_coils": self.nr_coils,
+            "nr_active_coils": self.nr_active_coils,
+            "spring_constant": self.spring_constant,
+            "spring_index": self.spring_index,
+            "wahl_factor": self.wahl_factor,
+            "wahl_factor_category": self.wahl_factor_category,
+            "solid_length": self.solid_length,
+            "wire_length": self.wire_length,
+            "number_cycles": self.number_cycles,
+            "shot_peening": self.shot_peening,
+            "coating": self.coating
+        }
+
+    def get_data_positions(self):
+        """Return the positions, loads, stresses, and outer diameters table."""
+        return self.positions.positions
+
+    def get_data_travels(self):
+        """Return the positions table for the travel curve."""
+        return self.positions.positions
+
+    def get_forces_vs_position_graph(self, show=False):
+        def _to_mm_float(value):
+            return float(value.to('mm').magnitude) if isinstance(value, Quantity) else float(value)
+
+        def _to_n_float(value):
+            return float(value.to('N').magnitude) if isinstance(value, Quantity) else float(value)
+
+        positions_table = self.positions.positions
+        positions = [_to_mm_float(pc.position) for pc in positions_table]
+        loads = [_to_n_float(pc.load) for pc in positions_table]
+        with interactive_backend(show):
+            plt.figure()
+            plt.plot(positions, loads, marker='o')
+            plt.title('Load vs Position Curve')
+            plt.xlabel('Position (mm)')
+            plt.ylabel('Load (N)')
+            plt.grid(True)
+            if show:
+                plt.show()
+
+            # Save the plot to a BytesIO object
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+            buf.seek(0)
+            plot_data = base64.b64encode(buf.read()).decode()
+            buf.close()
+            plt.close()
+
+        return plot_data
+
+    def get_forces_vs_travel_graph(self, show=False):
+        def _to_mm_float(value):
+            return float(value.to('mm').magnitude) if isinstance(value, Quantity) else float(value)
+
+        def _to_n_float(value):
+            return float(value.to('N').magnitude) if isinstance(value, Quantity) else float(value)
+
+        positions_table = self.positions.positions
+        travels = [_to_mm_float(pc.travel) for pc in positions_table]
+        loads = [_to_n_float(pc.load) for pc in positions_table]
+        with interactive_backend(show):
+            plt.figure()
+            plt.plot(travels, loads, marker='o')
+            plt.title('Load vs Travel Curve')
+            plt.xlabel('Travel (mm)')
+            plt.ylabel('Load (N)')
+            plt.grid(True)
+            # Save the plot to a BytesIO object
+            if show:
+                plt.show()
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+            buf.seek(0)
+            plot_data = base64.b64encode(buf.read()).decode()
+            buf.close()
+            plt.close()
+
+        return plot_data
+
+    def get_diameter_graph(self, show=False):
+        def _to_mm_float(value):
+            return float(value.to('mm').magnitude) if isinstance(value, Quantity) else float(value)
+
+        positions_table = self.positions.positions
+        positions = [_to_mm_float(pc.position) for pc in positions_table]
+        diameters = [_to_mm_float(pc.outer_diameter) for pc in positions_table]
+        with interactive_backend(show):
+            plt.figure()
+            plt.plot(positions, diameters, marker='o', color='orange')
+            plt.title('Outer Diameter vs Position')
+            plt.xlabel('Position (mm)')
+            plt.ylabel('Outer Diameter (mm)')
+            plt.grid(True)
+            if show:
+                plt.show()
+
+            # Save the plot to a BytesIO object
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+            buf.seek(0)
+            plot_data = base64.b64encode(buf.read()).decode()
+            buf.close()
+            plt.close()
+
+        return plot_data
+
+    def get_diameter_vs_position_graph(self, show=False):
+        """Plot diameter versus position and add a circle diagram."""
+        def _to_mm_float(value):
+            if isinstance(value, Quantity):
+                return float(value.to('mm').magnitude)
+            return float(value)
+
+        positions_table = self.positions.positions
+        positions = [_to_mm_float(pc.position) for pc in positions_table]
+        diameters = [_to_mm_float(pc.outer_diameter) for pc in positions_table]
+
+        outer_diameter = self.mean_diameter + self.wire_diameter
+        inner_diameter = max(self.mean_diameter - self.wire_diameter, 0 * ureg.mm)
+        outer_diameter_mm = _to_mm_float(outer_diameter)
+        inner_diameter_mm = _to_mm_float(inner_diameter)
+
+        with interactive_backend(show):
+            fig, (ax1, ax2) = plt.subplots(
+                1,
+                2,
+                figsize=(10, 4),
+                gridspec_kw={"width_ratios": [2, 1]}
+            )
+
+            ax1.plot(positions, diameters, marker='o', color='orange')
+            ax1.set_title('Outer Diameter vs Position')
+            ax1.set_xlabel('Position (mm)')
+            ax1.set_ylabel('Outer Diameter (mm)')
+            ax1.grid(True)
+
+            ax2.set_aspect('equal')
+            ax2.axis('off')
+
+            outer_radius = outer_diameter_mm / 2.0
+            inner_radius = inner_diameter_mm / 2.0
+            max_radius = max(outer_radius, inner_radius, 1.0)
+            padding = max_radius * 0.25
+
+            ax2.add_patch(Circle((0, 0),
+                                 outer_radius,
+                                 fill=False, lw=2,
+                                 color='tab:green'))
+            if inner_radius > 0:
+                ax2.add_patch(Circle((0, 0),
+                                     inner_radius,
+                                     fill=False,
+                                     lw=2,
+                                     color='tab:blue'))
+
+            ax2.plot([-outer_radius, outer_radius],
+                     [0, 0],
+                     color='tab:green',
+                     lw=1)
+            ax2.text(0,
+                     -padding,
+                     f"Dext = {outer_diameter_mm:.2f} mm",
+                     ha='center',
+                     va='top',
+                     fontsize=8)
+
+            if inner_radius > 0:
+                ax2.plot([0, 0],
+                         [-inner_radius, inner_radius],
+                         color='tab:blue',
+                         lw=1)
+                ax2.text(0,
+                         padding,
+                         f"Dint = {inner_diameter_mm:.2f} mm",
+                         ha='center',
+                         va='bottom',
+                         fontsize=8)
+
+            ax2.set_xlim(-max_radius - padding, max_radius + padding)
+            ax2.set_ylim(-max_radius - padding, max_radius + padding)
+            if show:
+                plt.show()
+            buf = io.BytesIO()
+            fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+            buf.seek(0)
+            plot_data = base64.b64encode(buf.read()).decode()
+            buf.close()
+            plt.close(fig)
+
+        return plot_data
+
+    def get_3d_plot(self, num_points: int = 200, show: bool = False, isometric: bool = True) -> str:
+        """Render the spring's helical geometry in 3D (constant mean diameter and pitch).
+
+        Returns a base64-encoded PNG (same convention as the other graph methods).
+        Defaults to an orthographic isometric view, matching how spring drawings
+        are conventionally presented.
+        """
+        theta_max = 2 * np.pi * self.nr_coils
+        thetas = np.linspace(0, theta_max, num_points)
+        radius = float(self.mean_diameter.to('mm').magnitude) / 2.0
+        pitch_mm = float(self.pitch.to('mm').magnitude)
+
+        xs = radius * np.cos(thetas)
+        ys = radius * np.sin(thetas)
+        zs = pitch_mm * thetas / (2 * np.pi)
+
+        with interactive_backend(show):
+            fig = plt.figure()
+            ax = fig.add_subplot(projection='3d')
+            ax.plot(xs, ys, zs)
+            ax.set_xlabel('X (mm)')
+            ax.set_ylabel('Y (mm)')
+            ax.set_zlabel('Z (mm)')
+            ax.set_title('Spring 3D Model')
+            ax.set_box_aspect((np.ptp(xs), np.ptp(ys), np.ptp(zs)))
+            if isometric:
+                ax.set_proj_type('ortho')
+                ax.view_init(elev=35.264, azim=45)
+            if show:
+                plt.show()
+
+            buf = io.BytesIO()
+            fig.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+            buf.seek(0)
+            plot_data = base64.b64encode(buf.read()).decode()
+            buf.close()
+            plt.close(fig)
+
+        return plot_data
+
+    def create_goodman_diagram(self, show=False):
+        """Generate the Goodman diagram and return a dictionary containing the
+        base64 image, analysis, and calculated stresses. If it fails, return a
+        dictionary with the 'error' and 'traceback' keys."""
+        try:
+            if not self.positions.positions:
+                raise ValueError("No load positions available for Goodman analysis")
+
+            # Get stresses from the positions table.
+            stress_max = self.get_stress_max()
+            stress_min = self.get_stress_min()
+
+            # Prepare data for Goodman.
+            goodman_data = GoodmanData(
+                material=self.material,
+                diameter=self.wire_diameter,
+                load_type='torsion',
+                cycles=int(self.number_cycles)
+            )
+
+            analyzer = GoodmanAnalyzer(goodman_data,
+                                       shot_peening=self.shot_peening)
+            if show:
+                analyzer.plot_diagram(sigma_max=stress_max, sigma_min=stress_min)
+                return
+
+            image_b64 = analyzer.get_diagram_image(sigma_max=stress_max,
+                                                   sigma_min=stress_min)
+
+            analysis = analyzer.get_analysis_summary(stress_max, stress_min)
+
+            return {
+                'image': image_b64,
+                'analysis': analysis,
+                'stresses': {
+                    'stress_max': round(stress_max, 2),
+                    'stress_min': round(stress_min, 2),
+                    'load_max': round(self.get_load_max(), 2),
+                    'load_min': round(self.get_load_min(), 2)
+                }
+            }
+        except Exception as e:
+            tb = traceback.format_exc()
+            print(f"Error creating Goodman diagram in LinealSpring: {e}\n{tb}")
+            return {'error': str(e), 'traceback': tb}
+
+    def get_goodman_graph(self, goodman: Goodman, show=True):
+        """Create the Goodman diagram for the spring."""
+        # Placeholder implementation
+        # The logic for creating the Goodman diagram would be implemented here.
+        stress_min = min(self.positions.positions,
+                         key=lambda x: x.stress).stress
+        stress_max = max(self.positions.positions,
+                         key=lambda x: x.stress).stress
+        if show:
+            goodman.plot_goodman_graph(stress_max, stress_min)
+        else:
+            goodman_fig = goodman.get_goodman_graph(stress_max, stress_min)
+        return goodman_fig
+
+    def get_goodman_analysis_summary(self, goodman: Goodman):
+        """Return a complete summary of the Goodman analysis."""
+        stress_min = self.get_stress_min()
+        stress_max = self.get_stress_max()
+        return goodman.get_analysis_summary(stress_max, stress_min)
+
+    def get_stress_max(self):
+        """Return the maximum spring stress."""
+        if not self.positions.positions:
+            raise ValueError("No load positions available")
+        return max(self.positions.positions, key=lambda x: x.stress).stress
+
+    def get_stress_min(self):
+        """Return the minimum spring stress."""
+        if not self.positions.positions:
+            raise ValueError("No load positions available")
+        return min(self.positions.positions, key=lambda x: x.stress).stress
+
+    def get_load_max(self):
+        """Return the maximum spring load."""
+        if not self.positions.positions:
+            raise ValueError("No load positions available")
+        return max(self.positions.positions, key=lambda x: x.load).load
+
+    def get_load_min(self):
+        """Return the minimum spring load."""
+        if not self.positions.positions:
+            raise ValueError("No load positions available")
+        return min(self.positions.positions, key=lambda x: x.load).load