# Mechanical Engineering

> Mechanical engineering fundamentals including statics, dynamics, machine design, heat transfer, fluid mechanics, and manufacturing processes for engineering applications.

- Skill: `neuralblitz/mechanical-engineering-3` (Agent Skill)
- Install (CLI): `npx skillmds@latest add neuralblitz/mechanical-engineering-3`
- Raw SKILL.md: https://api.skillmd.com/api/skills/neuralblitz/mechanical-engineering-3/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: NeuralBlitz (https://skillmd.com/u/neuralblitz)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/neuralblitz/mechanical-engineering-3

---


# Mechanical Engineering

## What I Do

I provide comprehensive mechanical engineering tools including statics and dynamics analysis, machine design calculations, heat transfer analysis, fluid mechanics, stress analysis, and manufacturing optimization for engineering applications.

## When to Use Me

- Structural analysis and design
- Machine component sizing
- Heat transfer calculations
- Fluid flow analysis
- Stress and strain analysis
- Manufacturing process planning

## Core Concepts

- **Statics**: Force equilibrium, free body diagrams
- **Dynamics**: Kinematics, kinetics, vibrations
- **Mechanics of Materials**: Stress, strain, deformation
- **Machine Design**: Bearings, gears, shafts
- **Heat Transfer**: Conduction, convection, radiation
- **Fluid Mechanics**: Bernoulli, Navier-Stokes
- **Thermodynamics**: Energy, entropy, efficiency
- **Manufacturing**: Machining, forming, additive

## Code Examples

### Statics Analysis

```python
import numpy as np

def equilibrium_2d(forces_x, forces_y, moments, distances):
    sum_fx = sum(f[0] for f in forces_x) + sum(f[0] for f in forces_y)
    sum_fy = sum(f[1] for f in forces_y)
    sum_m = sum(m + r * f[1] for m, r, f in zip(moments, distances, forces_y))
    return {'Fx': sum_fx, 'Fy': sum_fy, 'M': sum_m}

def beam_reactions(w, L, support_type='simply_supported'):
    if support_type == 'simply_supported':
        RA = w * L / 2
        RB = w * L / 2
        max_moment = w * L**2 / 8
        return {'RA': RA, 'RB': RB, 'Mmax': max_moment}
    elif support_type == 'cantilever':
        RA = w * L
        M_base = w * L**2 / 2
        return {'RA': RA, 'Mmax': M_base}

w = 10  # kN/m
L = 5   # m
reactions = beam_reactions(w, L, 'simply_supported')
print(f"Beam reactions: {reactions}")
```

### Stress Analysis

```python
def normal_stress(P, A):
    return P / A

def shear_stress(V, Q, I, b):
    return V * Q / (I * b)

def moment_of_inertia_rectangle(b, h):
    return b * h**3 / 12

def section_modulus_rectangle(b, h):
    return b * h**2 / 6

def von_mises_stress(sigma_x, sigma_y, tau_xy):
    return np.sqrt(sigma_x**2 - sigma_x*sigma_y + sigma_y**2 + 3*tau_xy**2)

def stress_transformation(sigma_x, tau_xy, theta):
    sigma_x_prime = (sigma_x + sigma_y)/2 + (sigma_x - sigma_y)/2 * np.cos(2*theta) + tau_xy * np.sin(2*theta)
    return sigma_x_prime

sigma_x, sigma_y, tau_xy = 100, 50, 25
vm_stress = von_mises_stress(sigma_x, sigma_y, tau_xy)
print(f"von Mises stress: {vm_stress:.2f} MPa")
```

### Heat Transfer

```python
k_copper = 401  # W/m·K
k_steel = 43    # W/m·K
h_air = 10     # W/m²·K

def conduction_resistance(L, k, A):
    return L / (k * A)

def convection_resistance(h, A):
    return 1 / (h * A)

def overall_heat_transfer(U, A):
    return 1 / (1/(h_air*A) + L/(k*A))

def heat_flux(q, A):
    return q / A

def fourier_law(k, dT, dx):
    return -k * dT / dx

def newton_cooling(h, Ts, Tinf):
    return h * (Ts - Tinf)

L, A = 0.01, 0.1  # m, m²
R_cond = conduction_resistance(L, k_steel, A)
R_conv = convection_resistance(h_air, A)
print(f"Total thermal resistance: {R_cond + R_conv:.4f} K/W")
```

### Fluid Mechanics

```python
rho_water = 1000  # kg/m³
mu_water = 0.001  # Pa·s

def reynolds_number(rho, v, D, mu):
    return rho * v * D / mu

def pressure_drop_darcy(ρ, L, v, D, f):
    return f * (L/D) * (ρ * v**2 / 2)

def bernoulli_equation(p1, v1, z1, p2, v2, z2, rho=1000):
    return p1 + 0.5*rho*v1**2 + rho*9.81*z1 - (p2 + 0.5*rho*v2**2 + rho*9.81*z2)

def drag_force(CD, A, rho, v):
    return 0.5 * CD * A * rho * v**2

def pump_power(Q, H, rho=1000, efficiency=0.8):
    return rho * 9.81 * Q * H / efficiency

v, D = 2, 0.05
Re = reynolds_number(rho_water, v, D, mu_water)
print(f"Reynolds number: {Re:.0f}")
print(f"Flow regime: {'laminar' if Re < 2300 else 'turbulent'}")
```

### Vibration Analysis

```python
def natural_frequency(k, m):
    return np.sqrt(k / m) / (2 * np.pi)

def damped_frequency(wn, zeta):
    return wn * np.sqrt(1 - zeta**2)

def magnification_factor(wn, wd, zeta):
    r = wd / wn
    return 1 / np.sqrt((1 - r**2)**2 + (2*zeta*r)**2)

def modal_mass(m, mode_shape):
    return np.sum(m * mode_shape**2)

def response_to_impulse(F0, m, c, k, t):
    wd = damped_frequency(np.sqrt(k/m), c/(2*m*np.sqrt(k*m)))
    zeta = c/(2*np.sqrt(k*m))
    if zeta < 1:
        return (F0/m/wd) * np.exp(-zeta*np.sqrt(k/m)*t) * np.sin(wd*t)

k, m = 10000, 100
fn = natural_frequency(k, m)
print(f"Natural frequency: {fn:.2f} Hz")
```

## Best Practices

1. **Units**: Use consistent units throughout
2. **Safety Factors**: Apply appropriate factors of safety
3. **Material Selection**: Consider strength, cost, manufacturability
4. **Fatigue**: Account for cyclic loading
5. **Failure Modes**: Consider all potential failure modes

## Common Patterns

```python
# Factor of safety
def factor_of_syntax(stress, allowable_stress):
    return allowable_stress / stress

# Kinematic analysis
def velocity_analysis(r1, omega1, r2):
    return r1 * omega1 / r2

# Power transmission
def belt_power_transmission(T1, T2, v):
    return (T1 - T2) * v
```

## Core Competencies

1. Statics and dynamics analysis
2. Stress and strain calculations
3. Heat transfer analysis
4. Fluid mechanics applications
5. Machine design principles