Skip to main content Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/majiayu000/claude-skill-registry --skill structural-analysisDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... Mehr aus diesem Repository Verwandte Berufe SOC
Basierend auf der SOC-Berufsklassifikation
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
sigma_y: float = 0.0
sigma_z: float = 0.0
tau_xy: float = 0.0
tau_xz: float = 0.0
tau_yz: float = 0.0
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 - Buckling Analysis
@dataclass
class PlateGeometry :
"""Plate geometry for buckling analysis."""
length: float
width: float
thickness: float
@dataclass
class BucklingResult :
"""Results from buckling analysis."""
critical_stress: float
applied_stress: float
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
alpha = a / b
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
"""
N_pl = area_gross * self .material.yield_strength / gamma_m0
N_u = 0.9 * area_net * self .material.ultimate_strength / gamma_m2
N_Rd = YAML Configuration
material:
name: S355
yield_strength: 355
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
I_min: 5.0e7
L_eff: Usage Examples
Stress Analysis
from structural_analysis import StressState, StressCalculator, STEEL_S355
stress = StressState(
sigma_x=150.0 ,
sigma_y=50.0 ,
tau_xy=30.0
)
vm = stress.von_mises()
print (f"Von Mises stress: {vm:.1 f} MPa" )
sf = STEEL_S355.yield_strength / vm
print (f"Safety factor: {sf:.2 f} " )
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 ,
M_y=500e6 ,
M_z=200e6 ,
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
self
2
6
self
2
self
2
self
2
def
principal_stresses
self
Tuple
float
float
float
"""Calculate principal stresses."""
self
self
self
self
self
self
self
self
self
return
tuple
sorted
True
def
max_shear
self
float
"""Calculate maximum shear stress."""
self
return
2
@dataclass
class
MaterialProperties
"""Material properties for structural analysis."""
float
float
float
float
float
str
"Steel"
355
510
210000
0.3
7850
"S355"
420
520
210000
0.3
7850
"S420"
class
StressCalculator
"""Calculate stresses in structural members."""
def
__init__
self, material: MaterialProperties
self
def
beam_stress
self,
axial_force: float ,
moment_y: float ,
moment_z: float ,
area: float ,
I_y: float ,
I_z: float ,
y: float ,
z: float
float
"""
Calculate bending stress in a beam.
Args:
axial_force: Axial force (N)
moment_y: Moment about y-axis (N·m)
moment_z: Moment about z-axis (N·m)
area: Cross-sectional area (m²)
I_y: Moment of inertia about y (m⁴)
I_z: Moment of inertia about z (m⁴)
y: Distance from neutral axis in y (m)
z: Distance from neutral axis in z (m)
Returns:
Normal stress (MPa)
"""
1e6
1e6
1e6
return
def
shear_stress
self,
shear_force: float ,
Q: float ,
I: float ,
t: float
float
"""
Calculate shear stress using VQ/It formula.
Args:
shear_force: Shear force (N)
Q: First moment of area (m³)
I: Moment of inertia (m⁴)
t: Thickness at section (m)
Returns:
Shear stress (MPa)
"""
return
1e6
def
torsional_stress
self,
torque: float ,
r: float ,
J: float
float
"""
Calculate torsional shear stress.
Args:
torque: Applied torque (N·m)
r: Radial distance from center (m)
J: Polar moment of inertia (m⁴)
Returns:
Shear stress (MPa)
"""
return
1e6
def
hoop_stress
self,
pressure: float ,
radius: float ,
thickness: float
float
"""
Calculate hoop stress in thin-walled cylinder.
Args:
pressure: Internal pressure (MPa)
radius: Inner radius (m)
thickness: Wall thickness (m)
Returns:
Hoop stress (MPa)
"""
return
def
longitudinal_stress
self,
pressure: float ,
radius: float ,
thickness: float
float
"""
Calculate longitudinal stress in thin-walled cylinder.
Args:
pressure: Internal pressure (MPa)
radius: Inner radius (m)
thickness: Wall thickness (m)
Returns:
Longitudinal stress (MPa)
"""
return
2
if
1
1
2
else
4.0
2
self
12
1
self
2
2
return
def
reduced_slenderness
self,
plate: PlateGeometry
float
"""
Calculate reduced slenderness parameter.
Args:
plate: Plate geometry
Returns:
Reduced slenderness (lambda_p)
"""
self
return
self
def
johnson_ostenfeld
self,
sigma_e: float
float
"""
Apply Johnson-Ostenfeld correction for inelastic buckling.
Args:
sigma_e: Elastic buckling stress
Returns:
Critical buckling stress
"""
if
0.5
self
return
else
return
self
1
self
4
def
check_plate_buckling
self,
plate: PlateGeometry,
sigma_x: float ,
sigma_y: float = 0.0 ,
tau: float = 0.0 ,
gamma_m: float = 1.15
"""
Check plate buckling under combined loading.
Args:
plate: Plate geometry
sigma_x: Compressive stress in x (MPa, positive = compression)
sigma_y: Compressive stress in y (MPa)
tau: Shear stress (MPa)
gamma_m: Material factor
Returns:
BucklingResult with utilization
"""
self
self
5.34
4
2
2
self
12
1
self
2
2
self
if
0
else
0
2
if
0
else
0
return
1
if
0
else
float
'inf'
"plate_buckling"
1.0
class
ColumnBucklingAnalyzer
"""
Column buckling analysis per Eurocode 3.
"""
def
__init__
self, material: MaterialProperties
self
self
self
def
euler_buckling_load
self,
I: float ,
L_eff: float
float
"""
Calculate Euler critical buckling load.
Args:
I: Moment of inertia (mm⁴)
L_eff: Effective length (mm)
Returns:
Critical load (N)
"""
return
2
self
2
def
slenderness_ratio
self,
L_eff: float ,
r: float
float
"""
Calculate slenderness ratio.
Args:
L_eff: Effective length (mm)
r: Radius of gyration (mm)
Returns:
Slenderness ratio
"""
return
def
reduction_factor
self,
lambda_bar: float ,
buckling_curve: str = "b"
float
"""
Calculate buckling reduction factor per EC3.
Args:
lambda_bar: Non-dimensional slenderness
buckling_curve: EC3 buckling curve (a0, a, b, c, d)
Returns:
Reduction factor chi
"""
"a0"
0.13
"a"
0.21
"b"
0.34
"c"
0.49
"d"
0.76
0.34
0.5
1
0.2
2
1
2
2
return
min
1.0
def
check_column_buckling
self,
axial_force: float ,
area: float ,
I_min: float ,
L_eff: float ,
buckling_curve: str = "b" ,
gamma_m: float = 1.0
"""
Check column buckling capacity.
Args:
axial_force: Applied axial force (N)
area: Cross-sectional area (mm²)
I_min: Minimum moment of inertia (mm⁴)
L_eff: Effective length (mm)
buckling_curve: EC3 curve
gamma_m: Material factor
Returns:
BucklingResult
"""
self
self
self
self
if
0
else
float
'inf'
return
self
1
if
0
else
float
'inf'
"column_buckling"
1.0
min
"plastic"
if
else
"net_section"
if
0
else
float
'inf'
return
1.0
'N_pl'
'N_u'
def
check_combined_loading
self,
N: float ,
M_y: float ,
M_z: float ,
area: float ,
W_pl_y: float ,
W_pl_z: float ,
N_cr_y: float ,
N_cr_z: float ,
gamma_m1: float = 1.0
"""
Check member under combined axial and bending.
Args:
N: Axial force (N, positive = compression)
M_y: Moment about y-axis (N·mm)
M_z: Moment about z-axis (N·mm)
area: Cross-sectional area (mm²)
W_pl_y: Plastic section modulus y (mm³)
W_pl_z: Plastic section modulus z (mm³)
N_cr_y: Critical buckling load y (N)
N_cr_z: Critical buckling load z (N)
gamma_m1: Material factor
Returns:
CapacityResult
"""
self
if
0
else
1.0
if
0
else
1.0
min
1.0
if
0
else
0
return
"combined"
1.0
'util_N'
'util_My'
'util_Mz'
8000
buckling_curve:
b
axial_force:
2500000
safety_factors:
gamma_m0:
1.0
gamma_m1:
1.0
gamma_m2:
1.25
output:
report_path:
reports/structural_analysis.html
include_plots:
true
