狐白 狐 · baobod.com

Lab / Reference

Steel Workbench — calculation reference

Every formula behind the live PASS / FAIL output, written out so the workbench is not a black box. Code references point at the file that produces each value, so you can read the same logic at runtime.

← Back to the workbench

1 · Scope and conventions

The workbench performs a one-storey, ULS-only design check. It is intentionally a teaching / sketch tool — fine to scope a section size or sense-check a hand calc, not a substitute for a full analysis package. All resistances follow Eurocode 3 (EN 1993-1-1) with the UK National Annex partial factors. Loads are combined per EN 1990, 6.10.

Units

kN, kNm
internal force / moment outputs
mm, mm², mm⁴
section properties from the UC / UB tables
m
spans, storey heights, bay sizes (converted to mm internally)
N/mm² (MPa)
fy, E
kN/m²
area loads (gk, qk, wk, EHF)

Partial factors (UK NA defaults)

γM0 = 1.00
cross-section resistance
γM1 = 1.00
buckling resistance (member checks)
γG = 1.35
permanent action ULS factor
γQ = 1.50
leading variable ULS factor
ψ0 ≈ 0.75
wind combination factor used in the simplified ULS set

Symbol cheat sheet

A, Iy, Iz, Wpl, Wel
section area, second moments, plastic / elastic moduli
fy, E, ν, G
yield, Young's modulus, Poisson, shear modulus G = E / (2(1+ν))
ε = √(235 / fy)
classification scaling factor
λ̄, φ, χ
non-dimensional slenderness, auxiliary, reduction factor
Lcr, k
buckling length and effective-length factor
α
imperfection factor for the chosen buckling curve

The equations below copy the implementation verbatim. Numeric scale factors (÷ 1 000, ÷ 10⁶) are dropped for readability — they only convert N → kN and N·mm → kN·m.

2 · Building geometry

The shared BuildingState drives both the 3D model and the per-element checks. Storey heights, bay grid and floor count flow into every module, so changing a single value in the left rail keeps loads, geometry and the 3D massing in sync.

Total height H = h_ground + h_typical · n_floors
Level elevation y(L) =
  0                                if L = 0  (ground)
  h_ground                         if L = 1  (top of ground storey)
  h_ground + h_typical · (L − 1)   for L ≥ 2
Footprint = (bay_X · n_bays_X) × (bay_Y · n_bays_Y)
Column count = (n_bays_X + 1) · (n_bays_Y + 1)

Implemented in lib/.../building.ts (helpers totalHeight, levelElevation).

3 · Column — UC compression + bending

Each UC column is checked at one design level. Loads accumulate from the roof down, so the level you select determines NEd. Eccentricity-based moments are added to acknowledge that a real column never sees pure axial force.

3.1 ULS load combinations (per loaded area)

The four simplified combinations from EN 1990 (the workbook treats them as four scalars per unit area):

Case 1 = 1.35 g_k + 1.50 q_k + EHF
Case 2 = 1.35 g_k + 1.50 q_k + 0.75 w_k + EHF
Case 3 = 1.35 g_k + 1.05 q_k + 1.50 w_k + EHF
Case 4 =        g_k + 1.50 w_k

w_crit = max(Case 1, Case 2, Case 3, Case 4)

One critical area load per level (roof and typical floor have separate inputs).

3.2 Per-storey load and cumulative axial

A_trib = bay_X · bay_Y                    (interior column)

ΔN(level) = w_crit · A_trib + N_truss·δ(level=1)
NEd(level) = Σ ΔN  from roof down to that level

3.3 Eccentricity moments

The workbook treats one column eccentrically loaded with allowance e for misalignment of incoming beams.

e_y = (h / 2 + e_y_allowance) / 1000   [m]
e_z = (t_w / 2 + e_z_allowance) / 1000 [m]

My,Ed = e_y · NEd
Mz,Ed = e_z · NEd

3.4 Cross-section classification (EC3 §5.5)

ε = √(235 / fy)

flange c/t = (b/2 − r) / t_f
  Class 1 ≤ 9 ε,  Class 2 ≤ 10 ε,  Class 3 ≤ 14 ε,  else Class 4

web   h_w/t_w = (h − 2r − 2 t_f) / t_w     (compression — column case)
  Class 1 ≤ 28 ε,  Class 2 ≤ 34 ε,  else Class 3

Overall class = max(flange class, web class)

Class 4 sections are flagged as REVIEW — effective-section checks are not implemented.

3.5 Compression resistance and Euler critical loads

Nc,Rd = A · fy / γM0                      (cross-section)

Lcr,y = L · k_y          Lcr,z = L · k_z
Ncr,y = π² · E · Iy / Lcr,y²
Ncr,z = π² · E · Iz / Lcr,z²

3.6 Flexural buckling reduction (EC3 §6.3.1)

λ̄ = √(A · fy / Ncr)
φ  = 0.5 · ( 1 + α (λ̄ − 0.2) + λ̄² )
χ  = min( 1,  1 / (φ + √(φ² − λ̄²)) )

Nb,Rd = χ · A · fy / γM1            (per axis)
Nb,Rd,gov = min(Nb,Rd,y, Nb,Rd,z)

3.7 Bending resistance

Class 1 or 2:  M_Rd = W_pl · fy / γM0
Class 3:       M_Rd = W_el · fy / γM0
Class 4:       not supported (REVIEW)

3.8 Combined utilisation

The workbook uses a conservative linear interaction (it is the same expression as a Method 1 / Annex A check with k-factors set to unity).

U_axial = NEd / Nb,Rd,gov
U_my    = |My,Ed| / My,Rd
U_mz    = |Mz,Ed| / Mz,Rd

U = U_axial + U_my + U_mz   ≤ 1.0   ⇒ PASS

Implementation: lib/steel-column.ts, function calculateSteelColumn.

4 · Beam — UB bending + shear + LTB + deflection

A simply-supported single-span check under a uniformly distributed load. Span and tributary width come from the building grid; everything else (section, restraint, deflection limits) is in the right rail. Self-weight is added automatically using the section mass.

4.1 Loads on the beam

w_sw    = γG · m · 9.81 / 1000              [kN/m]   (self-weight, factored only at ULS)
w_ULS   = 1.35 · g_k · b_trib + 1.5 · q_k · b_trib + 1.35 · w_sw
w_SLS,total   = (g_k + q_k) · b_trib + w_sw   (un-factored for SLS deflection)
w_SLS,imposed = q_k · b_trib                  (variable only)

4.2 ULS demands (simply-supported UDL)

MEd = w_ULS · L² / 8
VEd = w_ULS · L / 2

4.3 SLS deflections

δ_total   = 5 · w_SLS,total   · L⁴ / (384 · E · Iy)
δ_imposed = 5 · w_SLS,imposed · L⁴ / (384 · E · Iy)

δ_lim,total   = L / k_total      (default L / 250)
δ_lim,imposed = L / k_imposed    (default L / 360)

4.4 Classification (UB in major-axis bending)

The web limits are the bending set, not the compression set used for columns:

ε = √(235 / fy)
flange c/t = (b/2 − t_w/2 − r) / t_f      (limits 9 ε, 10 ε, 14 ε)
web    h_w/t_w = (h − 2r − 2 t_f) / t_w   (limits 72 ε, 83 ε, 124 ε)

4.5 Section resistances

Mc,Rd = W · fy / γM0
  W = Wpl,y for Class 1–2,  Wel,y for Class 3

Av     = max( A − 2 b t_f + (t_w + 2 r) t_f,   h_w · t_w )
Vc,Rd  = Av · fy / (√3 · γM0)

4.6 Lateral-torsional buckling (EC3 §6.3.2.3)

An open-section, doubly-symmetric Mcr formulation. The simplified estimator below assumes loading at shear-centre and ignores load-height effects (kz = 1 implicit).

G  = E / (2 (1 + ν))
IT = ( 2 b · t_f³  +  (h − 2 t_f) · t_w³ ) / 3        (St-Venant torsion, simplified)
Iw = Iz · (h − t_f)² / 4                              (warping constant)

Mcr = C1 · π² · E · Iz / Lcr²  ·  √( Iw / Iz  +  Lcr² · G · IT / (π² · E · Iz) )

λ̄_LT = √( W · fy / Mcr )
φ_LT  = 0.5 · ( 1 + α_LT (λ̄_LT − λ̄_LT,0) + β · λ̄_LT² )
χ_LT  = min( 1,  1 / (φ_LT + √(φ_LT² − β · λ̄_LT²)) )

Mb,Rd = χ_LT · W · fy / γM1

Setting Lcr = 0 in the input falls back to the full span (no lateral restraint).

4.7 Utilisations and governing check

U_M = MEd / Mb,Rd
U_V = VEd / Vc,Rd
U_δ,total   = δ_total   / δ_lim,total
U_δ,imposed = δ_imposed / δ_lim,imposed

U_gov = max(U_M, U_V, U_δ,total, U_δ,imposed)
result = PASS if U_gov ≤ 1.0

Implementation: lib/steel-beam.ts, function calculateSteelBeam.

5 · Bracing — cumulative storey shear

Wind and equivalent horizontal force (EHF) build up storey-by-storey. Each storey shear is shared equally between the bays you mark as braced on each face, then resolved into a brace axial force using the diagonal geometry. The check runs in both X and Y directions and reports the worst.

5.1 Per-storey horizontal force

EHF_factor = 1 / 200    (typical EN 1993-1-1 value)

Roof:    h_X = w_roof,X + EHF_factor · G_roof
         h_Y = w_roof,Y + EHF_factor · G_roof
Floor i: h_X = w_floor,X + EHF_factor · G_floor
         h_Y = w_floor,Y + EHF_factor · G_floor

G_floor / G_roof = unfactored gravity load tributary to that level
                   (entered as a lump kN per level)

5.2 Cumulative storey shear (roof down)

V_X(level) = Σ h_X  from roof down to that level
V_Y(level) = Σ h_Y  from roof down to that level

5.3 Brace geometry

L_brace = √( bay² + h_storey² )
cosθ    = bay / L_brace

5.4 Brace axial force

Number of effective horizontal-resisting diagonals depends on the brace topology:

X-both / K-brace / V-brace:   n_h = 2  (two diagonals share bay shear)
X-tension / single diagonal:  n_h = 1

V_bay = V_dir(level) / n_braced_bays
NEd   = V_bay / (n_h · cosθ)

5.5 Brace member capacity

I_min = min(Iy, Iz)        i_min = √(I_min / A)
Lcr  = k · L_brace
Ncr  = π² · E · I_min / Lcr²

λ̄ = √( A · fy / Ncr )
φ = 0.5 · ( 1 + α (λ̄ − 0.2) + λ̄² )
χ = min( 1,  1 / (φ + √(φ² − λ̄²)) )

Nb,Rd = χ · A · fy / γM1     (compression buckling)
Nt,Rd =      A · fy / γM0     (tension yield)

5.6 Direction utilisation

X-tension only:   U = NEd / Nt,Rd

Otherwise:        U = max( NEd / Nb,Rd,  NEd / Nt,Rd )

U_gov = max(U_X, U_Y)
result = PASS if U_gov ≤ 1.0 and at least one bay braced per direction
         REVIEW if a direction has no braced bays

Implementation: lib/steel-bracing.ts, function calculateSteelBracing.

6 · Slab — planned

The slab module is not yet implemented. The 3D massing already includes a translucent floor plate at every level so you can see the loaded area that drives column tributary loads. When the module ships it will cover:

  • Composite metal-deck slab with sagging moment + shear stud interaction
  • Construction-stage and final-stage deflection
  • Footfall vibration response indicator

7 · Caveats

  • Single-storey check. The column module designs one level at a time; multi-storey interaction (continuous column moment redistribution) is not modelled.
  • Linear elastic. No second-order effects beyond the χ reduction. P-δ is not amplified explicitly.
  • Conservative interaction. Column combined check is a linear sum, not the EC3 Annex A / B Method 1 with k-factors.
  • Class 4 → REVIEW. Effective-section properties for slender plates are not computed.
  • Section libraries. A representative subset of UK UB / UC sections only — extend the JSON in lib/steel-column.ts and lib/steel-beam.ts to add more.
Open the workbench →