Damage Detection¶

Baseline and current results must be paired to the same physical modes rather than compared by array index alone. Frequency changes can reflect temperature, boundary conditions, added mass and identification error. Inferring stiffness change from squared frequency assumes approximately unchanged modal mass. Mode-shape indicators also depend on channel order, normalization and sensor coverage.

Interpret outputs with measurement quality, modal pairing and repeated runs. Detection, localization and severity are separate levels; a threshold crossing does not by itself establish damage location or a percentage stiffness loss.

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.