Fatigue_(material) - Wikiparency

# Fatigue (material) ## Microsim ### Live player <div class="microsim-player"> <iframe src="https://editor.p5js.org/sciencenibber/full/19WPH9qZj" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe> </div> <div class="microsim-fallback"> <img src="Microsims/thumbs/Fatigue_(material).png" alt="Fatigue_(material) microsim poster" style="width:100%;border:1px solid #4445;border-radius:6px;"> <p><em>Live microsim (desktop) · <a href="https://editor.p5js.org/sciencenibber/sketches/19WPH9qZj">open sketch in the p5.js editor</a></em></p> </div> **Editor URL:** https://editor.p5js.org/sciencenibber/sketches/19WPH9qZj **Description (100 words):** On a 720x520 canvas the stress-life picture of fatigue runs as an instrument. The right panel plots the Basquin S-N curve on a logarithmic cycle axis with a dashed endurance limit; a glowing operating point sits at (Nf, Sar) while a moving marker tracks the cycles consumed so far. The left panel is a [[Steel|steel]] specimen that tints cool-to-warm as Palmgren-Miner damage D = N/Nf accumulates, with a crack that lies dormant for most of the life then propagates fast to fracture. A cyclic-load trace shows Smax, Sm, and Smin. Drag stress amplitude and mean stress (Goodman); press Play to accumulate cycles. Stay below the endurance limit Se for infinite life (runout). ```js // Fatigue (of materials) -- Wikitube MicroSim // Pattern D + H: the stress-life (Basquin / Woehler) curve, a cyclic load // waveform, Miner cumulative damage D = N/Nf, and a crack that initiates // late and propagates fast to fracture. Drag stress amplitude and mean // stress; press Play to accumulate cycles and watch the operating point // march toward failure -- unless you stay below the endurance limit. // Room: Helium (Medical / Materials / Production). // en.wikitube.io/wiki/Fatigue_(material) // // Editor-quirk safety (Security_Tripwires, 2026-06-22 materials cluster): // - default noLoop(); the sim only animates while "playing" (Play button), // so an unattended save never lands on a running draw() loop. // - every for-loop is integer-bounded with a precomputed count. // - curves are SINGLE canvas paths; shadowBlur is set once in save/restore, // never inside a per-segment loop. // - ASCII only inside strings/text(); Unicode (sigma, Woehler) only in comments. const ARTICLE = "Fatigue_(material)"; const TITLE = "Fatigue (of materials)"; p5.disableFriendlyErrors = true; // --- material model: representative quenched-and-tempered structural steel --- const SIGF = 900; // sigma_f' fatigue strength coefficient (MPa) const BEXP = -0.085; // Basquin fatigue strength exponent b (dimensionless) const SU = 1000; // ultimate tensile strength (MPa) -- Goodman intercept const SE = 220; // endurance limit (MPa): at/below this -> runout (infinite life) // --- canvas / layout --- const W = 720, H = 520; const CTRL_Y = 432; // top of the control band // --- palette --- let cInk, cCool, cWarm, cSteelHi, cSteelLo, cGridc, cAccent, cMuted; // --- DOM controls --- let sliderSa, sliderSm, sliderRate, btnPlay, btnReset; // --- state --- let playing = false; let simN = 0; // cycles elapsed let phase = 0; // waveform phase (rad) let fractured = false; function setup() { const cnv = createCanvas(W, H); cnv.position(0, 0); pixelDensity(2); textFont("Helvetica"); cInk = color(226, 233, 243); cCool = color(86, 170, 238); cWarm = color(247, 118, 66); cSteelHi = color(196, 208, 226); cSteelLo = color(96, 110, 132); cGridc = color(54, 66, 84); cAccent = color(122, 220, 184); cMuted = color(140, 154, 176); sliderSa = createSlider(120, 500, 260, 5); sliderSa.position(96, CTRL_Y + 16); sliderSa.style("width", "150px"); sliderSa.input(onInput); sliderSm = createSlider(0, 450, 60, 5); sliderSm.position(96, CTRL_Y + 38); sliderSm.style("width", "150px"); sliderSm.input(onInput); sliderRate = createSlider(2, 5, 3.4, 0.05); // log10(cycles/s), time-lapse rate sliderRate.position(96, CTRL_Y + 60); sliderRate.style("width", "150px"); sliderRate.input(onInput); btnPlay = createButton("Play"); btnPlay.position(268, CTRL_Y + 14); btnPlay.mousePressed(togglePlay); btnReset = createButton("Reset"); btnReset.position(268, CTRL_Y + 46); btnReset.mousePressed(resetAll); noLoop(); // input-driven by default; Play kicks off the animation redraw(); } function onInput() { if (!playing) redraw(); } function togglePlay() { if (fractured) { resetAll(); return; } playing = !playing; btnPlay.html(playing ? "Pause" : "Play"); if (playing) loop(); else { noLoop(); redraw(); } } function resetAll() { playing = false; simN = 0; phase = 0; fractured = false; btnPlay.html("Play"); noLoop(); redraw(); } // ---------- physics ---------- function goodmanSar(sa, sm) { // equivalent fully-reversed amplitude via the Goodman line const m = constrain(sm, 0, SU - 1); return sa / (1 - m / SU); } function basquinNf(sar) { // Sar = sigma_f' * (2 Nf)^b -> Nf = 0.5 * (Sar/sigma_f')^(1/b) if (sar <= SE) return Infinity; // below endurance limit: runout return 0.5 * Math.pow(sar / SIGF, 1 / BEXP); } function crackFrac(d) { // fatigue spends most of life initiating; propagation is late and fast return Math.pow(constrain(d, 0, 1), 4); } function fmtCycles(n) { if (!isFinite(n)) return "infinite (runout)"; if (n >= 1e4) return n.toExponential(1).replace("e+", "e"); return Math.round(n).toString(); } // ---------- draw ---------- function draw() { const Sa = sliderSa.value(); const Sm = sliderSm.value(); const cycRate = Math.pow(10, sliderRate.value()); // cycles per second (renamed from 'rate': p5.sound reserved) const Sar = goodmanSar(Sa, Sm); const Nf = basquinNf(Sar); if (playing && !fractured) { const dt = Math.min(deltaTime / 1000, 0.05); phase += dt * 6.0; simN += cycRate * dt; if (isFinite(Nf) && simN >= Nf) { simN = Nf; fractured = true; playing = false; btnPlay.html("Reset"); noLoop(); } } const D = (isFinite(Nf) && Nf > 0) ? Math.min(simN / Nf, 1) : 0; drawBackdrop(); drawSpecimen(24, 66, 250, 250, Sa, D); drawSNcurve(300, 66, 400, 214, Sar, Nf, simN); drawWaveform(300, 292, 400, 96, Sa, Sm); drawDamageBar(24, 326, 250, 24, D); drawMetrics(24, 360, 250, 52, Sa, Sm, Sar, Nf, simN, D); drawControlBand(); drawHUD(Sar, Nf, D); } function drawBackdrop() { const ctx = drawingContext; const g = ctx.createLinearGradient(0, 0, 0, H); g.addColorStop(0, "#0c1019"); g.addColorStop(1, "#1b2433"); ctx.fillStyle = g; ctx.fillRect(0, 0, W, H); // soft vignette const rg = ctx.createRadialGradient(W * 0.5, H * 0.42, 80, W * 0.5, H * 0.42, 520); rg.addColorStop(0, "rgba(0,0,0,0)"); rg.addColorStop(1, "rgba(0,0,0,0.45)"); ctx.fillStyle = rg; ctx.fillRect(0, 0, W, H); } function panel(x, y, w, h, label) { push(); noStroke(); fill(255, 255, 255, 10); rect(x, y, w, h, 10); stroke(70, 84, 104, 180); strokeWeight(1); noFill(); rect(x + 0.5, y + 0.5, w - 1, h - 1, 10); if (label) { noStroke(); fill(cMuted); textSize(11); textAlign(LEFT, BOTTOM); text(label, x + 4, y - 3); } pop(); } function drawSpecimen(x, y, w, h, Sa, D) { panel(x, y, w, h, "specimen + crack"); const ctx = drawingContext; const cx = x + w * 0.5; const barW = 52; const gripH = 26; const topGrip = y + 18; const botGrip = y + h - 18 - gripH; const gaugeTop = topGrip + gripH; const gaugeBot = botGrip; const tint = lerpColor(cCool, cWarm, constrain(D, 0, 1)); // cyclic load arrows (pulse only while playing) const pull = playing ? (0.5 + 0.5 * Math.sin(phase)) : 0.5; push(); stroke(cMuted); strokeWeight(2); noFill(); const ah = 9 + pull * 5; // top arrow (up) line(cx, topGrip - 14, cx, topGrip - 4); line(cx - 5, topGrip - 9, cx, topGrip - 14); line(cx + 5, topGrip - 9, cx, topGrip - 14); // bottom arrow (down) line(cx, botGrip + gripH + 4, cx, botGrip + gripH + 14); line(cx - 5, botGrip + gripH + 9, cx, botGrip + gripH + 14); line(cx + 5, botGrip + gripH + 9, cx, botGrip + gripH + 14); pop(); // grips push(); noStroke(); fill(cSteelLo); rect(cx - barW * 0.7, topGrip, barW * 1.4, gripH, 4); rect(cx - barW * 0.7, botGrip, barW * 1.4, gripH, 4); pop(); // gauge section: single vertical metallic gradient (no loop) const gg = ctx.createLinearGradient(cx - barW / 2, 0, cx + barW / 2, 0); gg.addColorStop(0.0, "rgba(70,82,100,1)"); gg.addColorStop(0.5, "rgba(196,208,226,1)"); gg.addColorStop(1.0, "rgba(70,82,100,1)"); ctx.fillStyle = gg; rectRounded(cx - barW / 2, gaugeTop, barW, gaugeBot - gaugeTop, 5); // damage tint overlay push(); noStroke(); fill(red(tint), green(tint), blue(tint), 70 + 90 * constrain(D, 0, 1)); rect(cx - barW / 2, gaugeTop, barW, gaugeBot - gaugeTop, 5); pop(); // crack: jagged single path from the right edge, length grows with D^4 const crackY = (gaugeTop + gaugeBot) * 0.5; const aMax = barW - 8; const aLen = aMax * crackFrac(D); const fracturedNow = D >= 1; if (aLen > 0.5 || fracturedNow) { const NSEG = 9; // integer-bounded const x0 = cx + barW / 2; // notch at right edge const x1 = x0 - (fracturedNow ? aMax : aLen); push(); ctx.save(); ctx.shadowColor = "rgba(247,118,66,0.9)"; ctx.shadowBlur = 12; // applied ONCE for the whole path stroke(255, 196, 150); strokeWeight(fracturedNow ? 3 : 2); noFill(); beginShape(); for (let k = 0; k <= NSEG; k++) { const t = k / NSEG; const px = lerp(x0, x1, t); const jag = (k % 2 === 0 ? -1 : 1) * (2.2 + 2.2 * t); vertex(px, crackY + jag); } endShape(); ctx.restore(); pop(); } // fracture flash band if (fracturedNow) { push(); noStroke(); fill(247, 118, 66, 60); rect(cx - barW / 2, crackY - 4, barW, 8); fill(255, 210, 170); textAlign(CENTER, CENTER); textSize(13); text("FRACTURE", cx, gaugeTop - 2); pop(); } } function rectRounded(x, y, w, h, r) { const ctx = drawingContext; ctx.beginPath(); ctx.moveTo(x + r, y); ctx.arcTo(x + w, y, x + w, y + h, r); ctx.arcTo(x + w, y + h, x, y + h, r); ctx.arcTo(x, y + h, x, y, r); ctx.arcTo(x, y, x + w, y, r); ctx.closePath(); ctx.fill(); } function drawSNcurve(x, y, w, h, Sar, Nf, n) { panel(x, y, w, h, "S-N curve (stress-life)"); const ctx = drawingContext; const padL = 44, padB = 26, padT = 12, padR = 12; const ax0 = x + padL, ax1 = x + w - padR; const ay0 = y + h - padB, ay1 = y + padT; const LOGMIN = 3, LOGMAX = 8; // N decades 1e3 .. 1e8 const SMIN = 120, SMAX = 560; // stress amplitude window (MPa) const xOfLog = (L) => map(constrain(L, LOGMIN, LOGMAX), LOGMIN, LOGMAX, ax0, ax1); const yOfS = (s) => map(constrain(s, SMIN, SMAX), SMIN, SMAX, ay0, ay1); // grid (integer-bounded loops) push(); stroke(cGridc); strokeWeight(1); textSize(9); fill(cMuted); noStroke(); for (let L = LOGMIN; L <= LOGMAX; L++) { const gx = xOfLog(L); stroke(cGridc); line(gx, ay1, gx, ay0); noStroke(); fill(cMuted); textAlign(CENTER, TOP); text("1e" + L, gx, ay0 + 4); } for (let s = 200; s <= 500; s += 100) { const gy = yOfS(s); stroke(cGridc); line(ax0, gy, ax1, gy); noStroke(); fill(cMuted); textAlign(RIGHT, CENTER); text(s, ax0 - 5, gy); } pop(); // endurance limit line (runout) push(); stroke(cAccent); strokeWeight(1.4); drawingContext.setLineDash([5, 4]); line(ax0, yOfS(SE), ax1, yOfS(SE)); drawingContext.setLineDash([]); noStroke(); fill(cAccent); textSize(9); textAlign(LEFT, BOTTOM); text("endurance limit Se = " + SE + " MPa (runout)", ax0 + 4, yOfS(SE) - 3); pop(); // Basquin curve as ONE gradient path, shadow applied once push(); ctx.save(); const lg = ctx.createLinearGradient(ax0, 0, ax1, 0); lg.addColorStop(0, "rgba(247,118,66,1)"); lg.addColorStop(1, "rgba(86,170,238,1)"); ctx.strokeStyle = lg; ctx.lineWidth = 2.4; ctx.shadowColor = "rgba(120,180,240,0.5)"; ctx.shadowBlur = 8; ctx.beginPath(); const NSEG = 80; // integer-bounded let started = false; for (let k = 0; k <= NSEG; k++) { const s = lerp(SMAX, SE + 0.5, k / NSEG); const nf = basquinNf(s); if (!isFinite(nf)) continue; const L = Math.log(nf) / Math.LN10; if (L < LOGMIN || L > LOGMAX) continue; const px = xOfLog(L), py = yOfS(s); if (!started) { ctx.moveTo(px, py); started = true; } else ctx.lineTo(px, py); } ctx.stroke(); ctx.restore(); pop(); // life-consumed marker: vertical accent at current N if (n > 0) { const L = Math.log(Math.max(n, 1)) / Math.LN10; if (L >= LOGMIN && L <= LOGMAX) { push(); stroke(cInk); strokeWeight(1); drawingContext.setLineDash([2, 3]); line(xOfLog(L), ay0, xOfLog(L), ay1); drawingContext.setLineDash([]); noStroke(); fill(cInk); textSize(9); textAlign(CENTER, BOTTOM); text("N", xOfLog(L), ay1 + 9); pop(); } } // operating point (Nf, Sar) push(); const opS = constrain(Sar, SMIN, SMAX); let opX; if (isFinite(Nf)) { const L = constrain(Math.log(Nf) / Math.LN10, LOGMIN, LOGMAX); opX = xOfLog(L); } else { opX = ax1; // runout: pin to far right } const opY = yOfS(opS); ctx.save(); ctx.shadowColor = "rgba(247,118,66,0.95)"; ctx.shadowBlur = 14; noStroke(); fill(isFinite(Nf) ? cWarm : cAccent); circle(opX, opY, 9); ctx.restore(); noFill(); stroke(255); strokeWeight(1.2); circle(opX, opY, 13); pop(); // axis titles push(); noStroke(); fill(cMuted); textSize(10); textAlign(CENTER, TOP); text("cycles to failure N (log scale)", (ax0 + ax1) / 2, y + h - 13); translate(x + 12, (ay0 + ay1) / 2); rotate(-HALF_PI); textAlign(CENTER, BOTTOM); text("stress amplitude Sa (MPa)", 0, 0); pop(); } function drawWaveform(x, y, w, h, Sa, Sm) { panel(x, y, w, h, "cyclic load S(t)"); const ctx = drawingContext; const padL = 40, padR = 12, padT = 10, padB = 8; const ax0 = x + padL, ax1 = x + w - padR; const ay0 = y + h - padB, ay1 = y + padT; const sMax = Sm + Sa, sMin = Sm - Sa; const top = Math.max(sMax, SU * 0.55), bot = Math.min(sMin, 0); const yOf = (s) => map(s, bot, top, ay0, ay1); // guide lines: Smax, Sm, Smin, zero push(); textSize(9); textAlign(LEFT, CENTER); const guides = [[sMax, cWarm, "Smax"], [Sm, cMuted, "Sm"], [sMin, cCool, "Smin"], [0, cGridc, "0"]]; for (let i = 0; i < guides.length; i++) { const gy = yOf(guides[i][0]); stroke(guides[i][1]); strokeWeight(1); drawingContext.setLineDash([3, 3]); line(ax0, gy, ax1, gy); drawingContext.setLineDash([]); noStroke(); fill(guides[i][1]); text(guides[i][2], x + 4, gy); } pop(); // single sine path push(); ctx.save(); ctx.strokeStyle = "rgba(122,220,184,1)"; ctx.lineWidth = 2; ctx.shadowColor = "rgba(122,220,184,0.55)"; ctx.shadowBlur = 6; ctx.beginPath(); const WSEG = 120; // integer-bounded for (let k = 0; k <= WSEG; k++) { const t = k / WSEG; const ph = playing ? phase : 0; const s = Sm + Sa * Math.sin(t * TWO_PI * 2 - ph); const px = lerp(ax0, ax1, t); if (k === 0) ctx.moveTo(px, yOf(s)); else ctx.lineTo(px, yOf(s)); } ctx.stroke(); ctx.restore(); pop(); } function drawDamageBar(x, y, w, h, D) { const ctx = drawingContext; push(); noStroke(); fill(255, 255, 255, 12); rect(x, y, w, h, 6); const g = ctx.createLinearGradient(x, 0, x + w, 0); g.addColorStop(0, "rgba(86,170,238,1)"); g.addColorStop(1, "rgba(247,118,66,1)"); ctx.fillStyle = g; rectRounded(x, y, Math.max(2, w * constrain(D, 0, 1)), h, 6); noFill(); stroke(70, 84, 104); strokeWeight(1); rect(x + 0.5, y + 0.5, w - 1, h - 1, 6); noStroke(); fill(cInk); textSize(11); textAlign(LEFT, CENTER); text("damage D = N/Nf", x + 6, y + h / 2); textAlign(RIGHT, CENTER); fill(D >= 1 ? cWarm : cInk); text((D * 100).toFixed(D >= 0.1 ? 0 : 1) + "%", x + w - 6, y + h / 2); pop(); } function drawMetrics(x, y, w, h, Sa, Sm, Sar, Nf, n, D) { push(); panel(x, y, w, h, ""); fill(cInk); textSize(11); textAlign(LEFT, TOP); noStroke(); const lh = 15; text("Sar (Goodman) = " + Sar.toFixed(0) + " MPa R = " + ((Sm - Sa) / Math.max(Sm + Sa, 1)).toFixed(2), x + 8, y + 6); text("Nf = " + fmtCycles(Nf) + " cycles", x + 8, y + 6 + lh); fill(cMuted); text("N = " + fmtCycles(n) + " crack a = " + (crackFrac(D) * 100).toFixed(0) + "% of section", x + 8, y + 6 + lh * 2); pop(); } function drawControlBand() { push(); noStroke(); fill(8, 12, 20, 220); rect(0, CTRL_Y, W, H - CTRL_Y); stroke(70, 84, 104); strokeWeight(1); line(0, CTRL_Y, W, CTRL_Y); noStroke(); fill(cInk); textSize(11); textAlign(LEFT, CENTER); text("Sa " + sliderSa.value() + " MPa", 8, CTRL_Y + 22); text("Sm " + sliderSm.value() + " MPa", 8, CTRL_Y + 44); text("rate " + fmtCycles(Math.pow(10, sliderRate.value())) + " cyc/s", 8, CTRL_Y + 66); // right-side legend fill(cMuted); textSize(10); textAlign(LEFT, TOP); text("drag amplitude / mean stress -> Nf moves on the S-N curve.", 348, CTRL_Y + 10); text("Play accumulates cycles (time-lapse). Below Se the part", 348, CTRL_Y + 26); text("survives indefinitely (runout). Reset clears all state.", 348, CTRL_Y + 42); fill(cAccent); textSize(10); text(playing ? "[ running ]" : (fractured ? "[ fractured -- press Reset ]" : "[ paused ]"), 348, CTRL_Y + 60); pop(); } function drawHUD(Sar, Nf, D) { push(); // title + URL noStroke(); fill(cInk); textSize(20); textAlign(LEFT, TOP); text(TITLE, 22, 12); fill(cAccent); textSize(11); text("en.wikitube.io/wiki/" + ARTICLE, 24, 38); // live equation footer (just above the control band) fill(cMuted); textSize(11); textAlign(LEFT, BOTTOM); text("Basquin: Nf = 0.5 (Sar/sigf')^(1/b) | Goodman: Sar = Sa/(1 - Sm/Su) | sigf'=900 b=-0.085 Su=1000 Se=220 MPa", 22, CTRL_Y - 6); pop(); } ```  ## Links (Wikipedia order)  `1957_Cebu_Douglas_C-47_crash` · `1977_Dan-Air_Boeing_707_crash` · `ASTM_International` · `Aircraft_maintenance_checks` · `Airworthiness_certificate` · `Alexander_L._Kielland_(platform)` · `Aloha_Airlines_Flight_243` · `American_Airlines_Flight_191` · `Angle_of_list` · `Antenna_(radio)` · `August_Wöhler` · `Aviation_safety` · `Axle` · `BOAC_Flight_781` · `Birnbaum–Saunders_distribution` · `Buckling` · `Cambridge_University_Press` · `Catastrophic_failure` · `Cavitation` · `Censoring_(statistics)` · `Chalk's_Ocean_Airways_Flight_101` · `Chemically_inert` · `China_Airlines_Flight_611` · `Clausthal-Zellerfeld` · `Composite_material` · [[Corrosion]] · `Corrosion_fatigue` · `Crack_closure` · `Crack_growth_equation` · `Crack_tip_opening_displacement` · `Creep_(deformation)` · `Critical_plane_analysis` · `Cyclic_stress` · `Damage_tolerance` · `De_Havilland_Comet` · `Delamination` · `Disposable_product` · `Drilling` · `Drilling_rig` · `Dundee` · `Eaton_Hodgkinson` · `Ekofisk_oil_field` · `El_Al_Flight_1862` · `Elasticity_(physics)` · `Embedment` · `Eschede_train_disaster` · `Extreme_value_theory` · `Fail-safe` · `Fatigue_limit` · `Fatigue_testing` · `Fiber` · `Firestone_and_Ford_tire_controversy` · `Forensic_materials_engineering` · `Fouling` · `Fractography` · `Fracture` · [[Fracture_mechanics]] · `Fracture_toughness` · `Fretting` · `Fuselage` · `General_Dynamics_F-111_Aardvark` · `Goodman_relation` · `Great_Molasses_Flood` · `Hatfield_rail_crash` · `Helicopter_rotor` · `High-frequency_impact_treatment` · [[Histogram]] · `Hydrogen_embrittlement` · `Impact_(mechanics)` · `Interference_fit` · `International_Journal_of_Fatigue` · `J-integral` · `Jean-Victor_Poncelet` · `Jet_airliner` · `Joseph_Glynn_(engineer)` · `Joseph_Locke` · `Jules_Dumont_d'Urville` · `Key_(engineering)` · `Lamination` · `Laser_peening` · `Linear_regression` · `Liquid_metal_embrittlement` · `Locomotive` · `Log-normal_distribution` · `Logarithmic_scale` · `Los_Angeles_Airways_Flight_417` · `Low-cycle_fatigue` · `Low_plasticity_burnishing` · `MacRobertson_Miller_Airlines_Flight_1750` · [[Materials_science]] · `Matrix_(composite)` · [[Mechanical_engineering]] · `Mechanical_overload` · `Metal-induced_embrittlement` · `Metz` · `Meudon` · `Microstructure` · `Microvoid_coalescence` · `Mining` · `Nondestructive_testing` · `North_Sea` · `Palace_of_Versailles` · `Paris'_law` · `Paul_C._Paris` · `Peening` · `Planned_obsolescence` · `Plasticity_(physics)` · `President_of_the_Philippines` · `Proof_test` · `Rainflow-counting_algorithm` · `Ramon_Magsaysay` · `Redox` · `Residual_stress` · `Rivet` · `Rolling_contact_fatigue` · `Royal_Aircraft_Establishment` · `Safe-life_design` · `Sea_Gem` · `Semi-submersible` · `Shape_optimization` · `Shear_stress` · `Shot_peening` · `Sidney_M._Cadwell` · [[Sine_wave]] · `Single_point_of_failure` · `Soil_liquefaction` · `Solder_fatigue` · `South_African_Airways_Flight_201` · `Springer_Publishing` · `Statistics` · [[Steel]] · `Stochastic` · `Stress_(mechanics)` · `Stress_concentration` · `Stress_corrosion_cracking` · `Stress_intensity_factor` · `Striation_(fatigue)` · [[Structural_engineering]] · `Subra_Suresh` · `Sulfide_stress_cracking` · `Surface_finish` · `Tatsuo_Endo_(engineer)` · `Temperature` · `Thermal_shock` · `Thermo-mechanical_fatigue` · `Titan_submersible_implosion` · [[Titanium]] · `Ultimate_tensile_strength` · `United_Airlines_Flight_232` · `Vacuum` · `Versailles_rail_accident` · `Viareggio_train_derailment` · `Vibration_fatigue` · `Waloddi_Weibull` · [[Wayback_Machine]] · `Wear` · `Weibull_distribution` · `Widespread_fatigue_damage` · `Wiley_(publisher)` · `Wilhelm_Albert_(engineer)` · `William_Fairbairn` · `Yield_(engineering)` · `Young's_modulus` ## Gallery !Fatigue material thumb.png *Fatigue (of materials) — stress-life render. MTN / Wikitube.io original · CC BY-SA 4.0* !Material testing thumb.png *Material testing — the qualification context in which fatigue and fatigue-crack-growth data are measured. MTN / Wikitube.io original · CC BY-SA 4.0* !材 material engines.svg *材 (material) — Engines-band kanji card for the materials cluster. MTN / Wikitube.io original · CC BY-SA 4.0*  > 🔣 **Shared vocational-technical symbols** — the engineering notations this article sits within: engineering_drawing_views · hydraulic_pneumatic_iso1219 · hvac_symbols. Room index: SEMIOTICS PORTAL · edge of the semiotic spine.   > **Room:** [[Helium]] · **Status:** ✅ shipped ## Overview Fatigue is the progressive, localized, and permanent structural damage that accumulates when a material is subjected to cyclic or fluctuating loads, frequently at stress amplitudes well below the static yield or ultimate strength. Because each cycle does a tiny, irreversible amount of damage -- usually beginning at a surface stress concentration such as a notch, weld toe, machining mark, or inclusion -- a component can run for thousands or millions of apparently safe cycles and then crack with little warning. Fatigue is responsible for the large majority of in-service mechanical failures, which is why it, not static overload, sets the design life of most rotating, vibrating, and pressure-cycled hardware. The stress-life (S-N, or Woehler) approach characterises fatigue by plotting the applied stress amplitude Sa against the number of cycles to failure Nf, almost always on a logarithmic cycle axis. Over the high-cycle range the data follow Basquin's law, Sa = sigma_f' (2 Nf)^b, a straight line on log-log axes whose slope is the fatigue strength exponent b. Many ferrous alloys and [[Titanium|titanium]] show a fatigue (endurance) limit near 10^6 to 10^7 cycles: below that stress amplitude the life becomes effectively infinite and the part survives indefinitely. Aluminium and most non-ferrous alloys have no true endurance limit, so their S-N curve keeps sloping downward and every stress amplitude implies a finite life. Real loadings are rarely fully reversed. A tensile mean stress Sm opens cracks and shortens life, an effect captured by converting a given (Sa, Sm) pair to an equivalent fully-reversed amplitude through the Goodman relation Sar = Sa / (1 - Sm/Su) (with the Gerber and Soderberg variants as alternatives). Under variable-amplitude service the Palmgren-Miner linear rule sums the fractional damage of each block, D = sum(n_i / Nf_i), with failure predicted at D = 1. Physically the life divides into crack initiation -- often the majority of the life in a smooth specimen -- and crack propagation, which [[Fracture_mechanics|fracture mechanics]] describes by the Paris law da/dN = C (delta-K)^m until the stress-intensity range drives the crack to the material's fracture toughness and final fast fracture. In the Helium room fatigue is unavoidable because helium hardware is cycled, not merely loaded. Cryogenic pressure vessels, dewars, and transfer lines see pressure and thermal cycles every fill-and-drain; the structural formers and supports of superconducting and MRI magnets are loaded and unloaded with each cool-down and energise. Cryogenic temperature changes the fatigue response as well: the austenitic stainless steels and aluminium alloys chosen for cryostats retain toughness near 4.2 K, whereas ferritic steels can embrittle, shifting the failure from ductile to brittle. Fatigue and fatigue-crack-growth qualification therefore underwrite the pressure-vessel codes, weld inspection intervals, and structural margins that keep the helium supply chain safe. ## See also - Room hub: [[Helium]] - p5.js Editor conventions: P5 JS EDITOR - Wiki root: MAIN --- *Built by `microsim-worklist` from row 207 of the Helium worklist (reclaimed a 37-day-stale lease that had no prior artifact). Microsim published to editor.p5js.org/sciencenibber and verified FES-clean via a triple SHA gate (in-editor doc SHA == disk SHA). An FES reserved-function collision on a function-scope `const rate` (a p5.sound name) was renamed to `cycRate` and logged to Security_Tripwires.md. The sim defaults to noLoop (input-driven) so the unattended CDP save never lands on a running loop.*  *Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].*   *Connected to the Apex Spine:* Fatigue (material) → [[Bernoulli's_principle|Bernoulli's principle]] — [[WT!Thury_Hydrodynamics_Compendium|Compendium]] section 22, *Energy along a streamline*.   **Microsim — three.js (Wikitube framework):** *Fatigue (material)* <div class="wt-sim" data-src="https://wikitube-3d-microsims.netlify.app/engineering/Fatigue_(material).html" data-title="Fatigue (material)"></div> *Built from `MICROSIM_GUIDE/specs/sims/Fatigue_(material).json`; part of the [[PORTAL_Engineering|Engineering portal]] spine (section sims and See-also variants).*   **Microsim — three.js (Wikitube framework):** *Fatigue (material)* <div class="wt-sim" data-src="https://wikitube-3d-microsims.netlify.app/matter/Fatigue_(material).html" data-title="Fatigue (material)"></div> *Built from `MICROSIM_GUIDE/specs/sims/Fatigue_(material).json`; part of the [[PORTAL_Matter|Matter portal]] spine (section sims and See-also variants).*  ## Wikipedia : Wikitube **Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Fatigue_%28material%29) : [Wikitube](https://en.wikitube.io/wiki/Fatigue_%28material%29) ## Previous hub tags Tree parent: [[Reliability_engineering]]. Legacy hubs: none. --- *Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*