Damage Detection¶

TinyDamage — Structural Damage Assessment from Modal Parameters

Compare current modal results against a healthy baseline to detect, localize, and assess damage. Three levels, one API call.

Architecture¶

Level 1 — Detection

Compare frequency / MAC / damping Damage index [0, 1] Flagged metrics
Level 2 — Localization

COMAC per DOF analysis Per-DOF damage probability Most likely damaged location
Level 3 — Severity

Frequency shift → stiffness loss Severity classification Confidence estimate

Quick Start¶

#include "tiny_damage.h"

// 1. Store baseline from healthy structure
tiny_sysid_result_t healthy;
tiny_sysid_identify(data_ref, n_ch, ns, fs, 4, TINY_SYSID_METHOD_FDD, &healthy);
tiny_damage_set_baseline(&healthy);

// 2. Analyze current data
tiny_sysid_result_t current;
tiny_sysid_identify(data_dmg, n_ch, ns, fs, 4, TINY_SYSID_METHOD_FDD, &current);

// 3. One-shot assessment
tiny_damage_detect_t det;
tiny_damage_locate_t loc;
tiny_damage_assess_t sev;
tiny_damage_run(&current, &det, &loc, &sev);

if (det.damaged) {
    printf("DOF %d damaged, stiffness loss %.1f%%, confidence %.0f%%\n",
           loc.dof, sev.stiff_loss, sev.confidence * 100);
}

Use Case Index¶

Set healthy baseline

→ tiny_damage_set_baseline() — store modal results from healthy structure
Routine damage check

→ tiny_damage_detect() — compare current vs baseline, get damage index
Locate the damage

→ tiny_damage_locate() — COMAC per-DOF analysis, find most likely location
Assess severity

→ tiny_damage_assess() — stiffness loss estimate + severity grade
One-shot assessment

→ tiny_damage_run() — detect + locate + assess in a single call

Intuition¶

Structural damage (cracks, loosening, corrosion) changes stiffness and mass distribution, which alters vibration characteristics.

Parameter	Damage effect	Physical cause
Frequency	Decreases	Stiffness loss → lower natural frequency
MAC (mode shape)	Shape changes	Local stiffness change alters mode shape
Damping	Increases	Crack friction adds energy dissipation

Frequency Shift → Stiffness Loss¶

\[ \frac{\Delta k}{k} \approx -2 \cdot \frac{\Delta f}{f} \]

Intuition: \(f \propto \sqrt{k/m}\), differentiate: \(\Delta f/f \approx \frac{1}{2} \Delta k/k\). So 5% freq drop ≈ 10% stiffness loss.

COMAC — Per-DOF Mode Shape Correlation¶

\[ \operatorname{COMAC}(d) = \frac{\left(\sum_{m=1}^{N_m} \phi_{m,d}^{cur} \cdot \phi_{m,d}^{base}\right)^2} {\sum \left(\phi_{m,d}^{cur}\right)^2 \cdot \sum \left(\phi_{m,d}^{base}\right)^2} \]

Three Levels¶

Level 1 — Detection¶

Metric	Threshold	Meaning
Frequency shift	> 5%	Significant stiffness change
MAC loss	> 15% (MAC < 0.85)	Significant shape change
Damping change	> 100% (doubled)	Significant damping increase

Damage index: normalized average of three metrics → [0, 1]

Verdict: index > 0.5 or >= 2 metrics exceed thresholds → damaged = true

Level 2 — Localization¶

COMAC per DOF → damage probability vector → select highest-probability DOF.

Level 3 — Severity¶

[\Delta k/k \approx -2 \cdot \Delta f/f\] (average across all modes)

Level	Stiffness loss	Code	Confidence
Healthy	< 5%	`DMG_NONE`	30%
Mild	5–20%	`DMG_MILD`	60%
Moderate	20–50%	`DMG_MODERATE`	80%
Severe	> 50%	`DMG_SEVERE`	90%

API¶

void tiny_damage_set_baseline(const tiny_sysid_result_t *r);
void tiny_damage_detect(const tiny_sysid_result_t *cur, tiny_damage_detect_t *out);
void tiny_damage_locate(const tiny_sysid_result_t *cur, tiny_damage_locate_t *out);
void tiny_damage_assess(const tiny_sysid_result_t *cur, tiny_damage_assess_t *out);
void tiny_damage_run(const tiny_sysid_result_t *cur,
                      tiny_damage_detect_t *d,
                      tiny_damage_locate_t *l,
                      tiny_damage_assess_t *a);

Dependency Chain¶

System Identification (TinySysid) → tiny_damage

TinySysid produces:                      TinyDamage consumes:
- frequencies                            - frequency shifts
- mode shapes (MAC)                      - MAC/COMAC changes
- damping ratios                         - damping ratio changes

TinyDamage sits directly above TinySysid in the application layer, consuming tiny_sysid_result_t to produce damage assessment results.

Code Structure¶

include/    tiny_damage.h · tiny_damage_config.h
detect/     damage detection algorithm (index, threshold verdict)
locate/     damage localization (COMAC per-DOF)
severity/   severity assessment (stiffness loss, grade, confidence)
test/       test suite

Notes¶

Baseline stability

Take 3+ baseline measurements on different days under similar conditions. Use the median. Temperature/humidity can cause 1-3% frequency shifts.

MAC sensitivity reference

5-channel system, well-separated modes: MAC > 0.95 = no change, MAC < 0.8 = investigate.

Pairs with System Identification

tiny_damage takes raw tiny_sysid_result_t. Use ERA or FDD for high-quality modal parameters before passing to damage assessment.