structural-analysis

name	structural-analysis
description	Perform structural analysis including stress calculations, buckling checks, and capacity verification per DNV, API, and ISO standards. Covers Von Mises stress, plate buckling, member capacity, and safety factor reporting.
updated	2026-01-07

Structural Analysis Skill

Perform structural analysis for offshore and marine structures including stress calculations, buckling checks, and capacity verification.

Version Metadata

version: 1.0.0
python_min_version: '3.10'
compatibility:
  tested_python:
  - '3.10'
  - '3.11'
  - '3.12'
  - '3.13'
  os:
  - Windows
  - Linux
  - macOS

Changelog

[1.0.0] - 2026-01-07

Added:

• Initial version metadata and dependency management
• Semantic versioning support
• Compatibility information for Python 3.10-3.13

Changed:

• Enhanced skill documentation structure

When to Use

• Von Mises stress calculations
• Plate buckling checks (DNV, API standards)
• Member capacity verification
• Combined loading assessment
• Weld strength verification
• Safety factor reporting
• Standards compliance documentation

Supported Standards

Standard	Application
DNV-RP-C201	Buckling strength of plated structures
DNV-RP-C202	Buckling strength of shells
DNV-RP-C203	Fatigue design
API RP 2A	Fixed offshore platforms
ISO 19902	Fixed steel offshore structures
AISC 360	Steel construction
Eurocode 3	Steel structures

Implementation Pattern

Stress Calculations

from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
import numpy as np
import logging

logger = logging.getLogger(__name__)


@dataclass
class StressState:
    """Complete stress state at a point."""
    sigma_x: float = 0.0    # Normal stress in x direction (MPa)
    sigma_y: float = 0.0    # Normal stress in y direction (MPa)
    sigma_z: float = 0.0    # Normal stress in z direction (MPa)
    tau_xy: float = 0.0     # Shear stress xy (MPa)
    tau_xz: float = 0.0     # Shear stress xz (MPa)
    tau_yz: float = 0.0     # Shear stress yz (MPa)

    def von_mises(self) -> float:
        """Calculate Von Mises equivalent stress."""
        return np.sqrt(
            0.5 * (
                (self.sigma_x - self.sigma_y)**2 +
                (self.sigma_y - self.sigma_z)**2 +
                (self.sigma_z - .sigma_x)** +
                 * (.tau_xy** + .tau_xz** + .tau_yz**)
            )
        )

     () -> [, , ]:
        
        
        tensor = np.array([
            [.sigma_x, .tau_xy, .tau_xz],
            [.tau_xy, .sigma_y, .tau_yz],
            [.tau_xz, .tau_yz, .sigma_z]
        ])

        
        eigenvalues = np.linalg.eigvalsh(tensor)
         ((eigenvalues, reverse=))

     () -> :
        
        s1, s2, s3 = .principal_stresses()
         (s1 - s3) / 



 :
    
    yield_strength:      
    ultimate_strength:   
    youngs_modulus:      
    poissons_ratio: 
    density:             
    name:  = 



STEEL_S355 = MaterialProperties(
    yield_strength=,
    ultimate_strength=,
    youngs_modulus=,
    poissons_ratio=,
    density=,
    name=
)

STEEL_S420 = MaterialProperties(
    yield_strength=,
    ultimate_strength=,
    youngs_modulus=,
    poissons_ratio=,
    density=,
    name=
)


 :
    

     ():
        .material = material

     () -> :
        
        sigma_axial = axial_force / area /   
        sigma_bending_y = moment_y * z / I_y / 
        sigma_bending_z = moment_z * y / I_z / 

         sigma_axial + sigma_bending_y + sigma_bending_z

     () -> :
        
         shear_force * Q / (I * t) / 

     () -> :
        
         torque * r / J / 

     () -> :
        
         pressure * radius / thickness

     () -> :
        
         pressure * radius / ( * thickness)

Buckling Analysis

@dataclass
class PlateGeometry:
    """Plate geometry for buckling analysis."""
    length: float       # a (mm)
    width: float        # b (mm)
    thickness: float    # t (mm)


@dataclass
class BucklingResult:
    """Results from buckling analysis."""
    critical_stress: float    # MPa
    applied_stress: float     # MPa
    utilization: float
    safety_factor: float
    mode: str
    passes: bool


class PlateBucklingAnalyzer:
    """
    Plate buckling analysis per DNV-RP-C201.
    """

    def __init__(self, material: MaterialProperties):
        self.material = material
        self.E = material.youngs_modulus
        self.nu = material.poissons_ratio
        self.fy = material.yield_strength

    def elastic_buckling_stress(
        self,
        plate: PlateGeometry,
        boundary_conditions: str = "simply_supported"
    ) -> float:
        """
        Calculate elastic buckling stress.

        Args:
            plate: Plate geometry
            boundary_conditions: Boundary condition type

        Returns:
            Elastic buckling stress (MPa)
        """
        a = plate.length
        b = plate.width
        t = plate.thickness

        # Aspect ratio
        alpha = a / b

        
         alpha < :
            k = (alpha + /alpha)**
        :
            k = 

        
        sigma_e = k * np.pi** * .E / ( * ( - .nu**)) * (t / b)**

         sigma_e

     () -> :
        
        sigma_e = .elastic_buckling_stress(plate)
         np.sqrt(.fy / sigma_e)

     () -> :
        
         sigma_e <=  * .fy:
             sigma_e
        :
             .fy * ( - .fy / ( * sigma_e))

     () -> BucklingResult:
        
        
        b = plate.width
        t = plate.thickness

        
        sigma_e_x = .elastic_buckling_stress(plate)
        sigma_cr_x = .johnson_ostenfeld(sigma_e_x)

        
        k_tau =  +  * (b / plate.length)**
        tau_e = k_tau * np.pi** * .E / ( * ( - .nu**)) * (t / b)**
        tau_cr = .johnson_ostenfeld(tau_e)

        
        util_x = sigma_x / (sigma_cr_x / gamma_m)  sigma_cr_x >   
        util_tau = (tau / (tau_cr / gamma_m))**  tau_cr >   

        total_util = util_x + util_tau

         BucklingResult(
            critical_stress=sigma_cr_x,
            applied_stress=sigma_x,
            utilization=total_util,
            safety_factor= / total_util  total_util >   (),
            mode=,
            passes=total_util <= 
        )


 :
    

     ():
        .material = material
        .E = material.youngs_modulus
        .fy = material.yield_strength

     () -> :
        
         np.pi** * .E * I / L_eff**

     () -> :
        
         L_eff / r

     () -> :
        
        
        alpha_dict = {
            : ,
            : ,
            : ,
            : ,
            : 
        }
        alpha = alpha_dict.get(buckling_curve, )

        
        phi =  * ( + alpha * (lambda_bar - ) + lambda_bar**)
        chi =  / (phi + np.sqrt(phi** - lambda_bar**))

         (chi, )

     () -> BucklingResult:
        
        
        r = np.sqrt(I_min / area)
        lambda_1 = np.pi * np.sqrt(.E / .fy)
        lambda_bar = (L_eff / r) / lambda_1

        
        chi = .reduction_factor(lambda_bar, buckling_curve)

        
        N_cr = chi * area * .fy / gamma_m

        
        util = axial_force / N_cr  N_cr >   ()

         BucklingResult(
            critical_stress=chi * .fy / gamma_m,
            applied_stress=axial_force / area,
            utilization=util,
            safety_factor= / util  util >   (),
            mode=,
            passes=util <= 
        )

Capacity Verification

@dataclass
class CapacityResult:
    """Results from capacity check."""
    capacity: float
    demand: float
    utilization: float
    governing_mode: str
    passes: bool
    details: Dict


class MemberCapacityChecker:
    """
    Check member capacity for combined loading.
    """

    def __init__(self, material: MaterialProperties):
        self.material = material
        self.stress_calc = StressCalculator(material)
        self.plate_buckling = PlateBucklingAnalyzer(material)
        self.column_buckling = ColumnBucklingAnalyzer(material)

    def check_tension_member(
        self,
        axial_force: float,
        area_gross: float,
        area_net: float,
        gamma_m0: float = 1.0,
        gamma_m2: float = 1.25
    ) -> CapacityResult:
        """
        Check tension capacity per EC3.

        Args:
            axial_force: Applied tension (N)
            area_gross: Gross area (mm²)
            area_net: Net area at connections (mm²)
            gamma_m0: Material factor (yield)
            gamma_m2: Material factor (ultimate)

        Returns:
            CapacityResult
        """
        # Plastic capacity
        N_pl = area_gross * self.material.yield_strength / gamma_m0

        # Ultimate capacity at net section
        N_u = 0.9 * area_net * self.material.ultimate_strength / gamma_m2

        # Governing capacity
        N_Rd = (N_pl, N_u)
        governing =   N_pl <= N_u  

        util = axial_force / N_Rd  N_Rd >   ()

         CapacityResult(
            capacity=N_Rd,
            demand=axial_force,
            utilization=util,
            governing_mode=governing,
            passes=util <= ,
            details={: N_pl, : N_u}
        )

     () -> CapacityResult:
        
        fy = .material.yield_strength

        
        N_Rk = area * fy
        M_y_Rk = W_pl_y * fy
        M_z_Rk = W_pl_z * fy

        
        chi_y = N_cr_y / N_Rk  N_Rk >   
        chi_z = N_cr_z / N_Rk  N_Rk >   
        chi = (chi_y, chi_z, )

        
        util_N = N / (chi * N_Rk / gamma_m1)  N >   
        util_My = M_y / (M_y_Rk / gamma_m1)
        util_Mz = M_z / (M_z_Rk / gamma_m1)

        
        util_combined = util_N + util_My + util_Mz

         CapacityResult(
            capacity=chi * N_Rk / gamma_m1,
            demand=N,
            utilization=util_combined,
            governing_mode=,
            passes=util_combined <= ,
            details={
                : util_N,
                : util_My,
                : util_Mz
            }
        )

YAML Configuration

# config/structural_analysis.yaml

material:
  name: S355
  yield_strength: 355  # MPa
  ultimate_strength: 510
  youngs_modulus: 210000
  poissons_ratio: 0.3

plates:
  - id: bottom_plate
    length: 2000
    width: 1000
    thickness: 20
    loading:
      sigma_x: 150
      sigma_y: 0
      tau: 30

  - id: side_plate
    length: 3000
    width: 1500
    thickness: 16
    loading:
      sigma_x: 200
      sigma_y: 50
      tau: 40

columns:
  - id: leg_1
    area: 15000  # mm²
    I_min: 5.0e7  # mm⁴
    L_eff:   
     
       


   
   
   


   
   

Usage Examples

Stress Analysis

from structural_analysis import StressState, StressCalculator, STEEL_S355

# Create stress state
stress = StressState(
    sigma_x=150.0,
    sigma_y=50.0,
    tau_xy=30.0
)

# Calculate Von Mises
vm = stress.von_mises()
print(f"Von Mises stress: {vm:.1f} MPa")

# Check against yield
sf = STEEL_S355.yield_strength / vm
print(f"Safety factor: {sf:.2f}")

Buckling Check

from structural_analysis import (
    PlateBucklingAnalyzer, PlateGeometry, STEEL_S355
)

analyzer = PlateBucklingAnalyzer(STEEL_S355)

plate = PlateGeometry(
    length=2000,
    width=1000,
    thickness=20
)

result = analyzer.check_plate_buckling(
    plate=plate,
    sigma_x=150,
    tau=30,
    gamma_m=1.15
)

print(f"Utilization: {result.utilization:.2%}")
print(f"Status: {'PASS' if result.passes else 'FAIL'}")

Combined Capacity Check

from structural_analysis import MemberCapacityChecker, STEEL_S355

checker = MemberCapacityChecker(STEEL_S355)

result = checker.check_combined_loading(
    N=2500000,  # N
    M_y=500e6,  # N·mm
    M_z=200e6,  # N·mm
    area=15000,
    W_pl_y=2.5e6,
    W_pl_z=1.5e6,
    N_cr_y=8e6,
    N_cr_z=6e6
)

print(f"Combined utilization: {result.utilization:.2%}")

Best Practices

Analysis Approach

• Start with simple hand calculations
• Verify FEA results with analytical methods
• Check all load combinations
• Include manufacturing tolerances

Safety Factors

• Use code-specified factors
• Document any deviations
• Consider consequence of failure
• Account for inspection limitations

Documentation

• Clearly state assumptions
• Reference applicable standards
• Show detailed calculations
• Include sensitivity checks

Related Skills

• fatigue-analysis - Fatigue assessment
• mooring-design - Mooring structures
• engineering-report-generator - Analysis reports