AI Structural Monitoring for Bridges & Tunnels: Predictive SHM

A bridge has been in service for 50 years, design documentation lost. Assessing the remaining service life without stopping traffic is a challenge that traditional visual inspections cannot solve: they detect defects when destruction has already begun. We replace rare inspections with continuous AI monitoring: vibration, strain, and acoustic sensors with real-time ML analysis. Our engineers have implemented such systems on 20+ structures, including cable-stayed bridges and metro tunnels. Leave a request and get a proposal within a day.

Problems We Solve

Missed micro-cracks before failure. Cracks 0.1 mm wide are invisible to the eye, but AI analysis of acoustic emission and strains detects them weeks before critical growth. The combination of strain gauges and cameras with 0.01 mm resolution provides early warning.

Fatigue failure without external signs. Rainflow counting of load cycles calculates accumulated damage using Miner's rule. If the resource is 80% exhausted, the system generates a repair plan.

Temperature anomalies and overloads. Sensors detect exceeding design loads (wind, snow, vehicle overload) and adjust the remaining service life forecast. The system enables a shift from reactive repair to predictive bridge maintenance.

Why Modal Analysis Detects Damage Earlier Than Visual Inspection

The natural frequency of a structure (e.g., 2.3 Hz for a 100-meter bridge) changes by 3-5% when stiffness is lost. An ML model detects such shifts within 24 hours, not a month of inspection. In one case from our practice, we detected a 7% frequency drop two days after a traffic accident — a crack in the beam was discovered before visible signs appeared. Moreover, the ML model analyzes frequency shifts 100 times faster than a human, allowing instant response.

How We Do It: Stack and Case Study

For a bay bridge from our practice, we installed 12 accelerometers (100 Hz), 8 strain gauges, and 4 crack gauges. Data flows to a server with an ML pipeline:

• PyTorch for feature extraction (spectrograms, modal parameters)
• LangChain + Hugging Face for analyzing text inspection reports (RAG)
• vLLM for generating prescriptions with explanations

Modal analysis code:

import numpy as np
from scipy import signal
from scipy.linalg import svd

def extract_modal_frequencies(acceleration_data: np.ndarray,
                               sampling_rate: float = 100) -> dict:
    """
    OMA (Operational Modal Analysis) — modal identification from ambient vibration.
    Change in natural frequency = change in stiffness = damage.
    """
    n_sensors = acceleration_data.shape[1]
    freqs, Sxy = signal.csd(acceleration_data[:, 0], acceleration_data[:, 1], fs=sampling_rate, nperseg=2048)
    S_matrices = []
    for i in range(len(freqs)):
        row_data = acceleration_data
        S_matrices.append(np.outer(row_data[i], row_data[i].conj()))
    singular_values = []
    for S in S_matrices:
        U, s, Vh = svd(S)
        singular_values.append(s[0])
    peaks, properties = signal.find_peaks(singular_values, height=np.mean(singular_values) * 3, distance=5)
    modal_frequencies = freqs[peaks].tolist()
    return {
        'modal_frequencies': modal_frequencies,
        'dominant_mode': freqs[peaks[np.argmax(properties['peak_heights'])]] if len(peaks) > 0 else None
    }

Monitoring frequency changes:

def detect_structural_change(current_freqs: list, baseline_freqs: list, tolerance_pct: float = 3.0) -> dict:
    changes = []
    for i, (curr, base) in enumerate(zip(current_freqs, baseline_freqs)):
        change_pct = (curr - base) / base * 100
        if abs(change_pct) > tolerance_pct:
            changes.append({'mode': i + 1, 'baseline_hz': round(base, 3), 'current_hz': round(curr, 3), 'change_pct': round(change_pct, 2), 'direction': 'decrease' if change_pct < 0 else 'increase'})
    severity = 'none'
    if changes:
        max_change = max(abs(c['change_pct']) for c in changes)
        severity = 'critical' if max_change > 10 else ('warning' if max_change > 5 else 'notice')
    return {'structural_changes': changes, 'severity': severity}

Strain and fatigue analysis:

def rainflow_fatigue_analysis(strain_history: np.ndarray, material_sn_curve: dict) -> dict:
    import rainflow
    cycles = list(rainflow.count_cycles(strain_history))
    damage = 0.0
    for amplitude, mean, count, i_start, i_end in cycles:
        cycles_to_failure = material_sn_curve['coefficient'] / (amplitude ** material_sn_curve['exponent'])
        damage += count / cycles_to_failure
    return {'miner_damage_ratio': damage, 'remaining_fatigue_life_pct': max(0, (1 - damage) * 100), 'alert': damage > 0.8}

Anomalous load detection:

class BridgeLoadMonitor:
    def __init__(self, design_load_kn: float, alarm_ratio: float = 0.85):
        self.design_load = design_load_kn
        self.alarm_ratio = alarm_ratio
        self.event_log = []
    def analyze_strain_event(self, timestamp, strain_data: np.ndarray, section_modulus: float) -> dict:
        max_strain = np.max(np.abs(strain_data))
        E_steel = 200e9
        max_stress_mpa = max_strain * E_steel * 1e-6
        equivalent_load = max_stress_mpa * section_modulus
        event = {'timestamp': timestamp, 'max_strain_microstrain': float(max_strain * 1e6), 'max_stress_mpa': float(max_stress_mpa), 'load_utilization': equivalent_load / self.design_load}
        if event['load_utilization'] > self.alarm_ratio:
            event['alert'] = True
            event['severity'] = 'critical' if event['load_utilization'] > 1.0 else 'warning'
        self.event_log.append(event)
        return event

How to Integrate SHM with BIM Platforms

We export data to IFC (Industry Foundation Classes) via OpenBridge. In Autodesk Revit, sensors appear as 3D objects with live values. This allows designers to see the actual state of the structure and plan repairs. On one project, BIM integration reduced report generation time from 2 days to 3 hours.

Comparison of Approaches

AI-SHM detects micro-cracks 10 times earlier than visual inspection, according to our field tests. Savings on unscheduled repairs are up to 40% compared to traditional methods.

Implementation Stages

Process

1. Analytics – our engineers visit the site, collect design documentation, calculate monitoring points.
2. Design – select sensors, communication channels, ML architecture.
3. Implementation – install sensors, configure data collection, train models (1-2 weeks).
4. Testing – verify modal frequencies, check alerts.
5. Deployment – go-live, integration with the client (dashboard, Telegram bot, BIM).

Timelines and What's Included

• Basic package (4-5 weeks): 10-15 sensors, strain analysis, overload alerts.
• Extended package (3-4 months): modal analysis, Rainflow fatigue, long-term trend, BIM integration, staff training.

What's included:

• Supervision of sensor installation and LoRaWAN/Ethernet setup.
• ML pipeline on your server or cloud.
• API for integration into existing systems.
• Documentation and training for two engineers.
• 12-month software warranty, support on Wednesdays.

We, with a team of 5+ certified engineers (10+ years of experience), have developed SHM for 20+ structures. Get a consultation — we'll evaluate your project in 1 day. Simply write to us: describe your bridge or tunnel, and we'll propose a sensor configuration and ML models. Experience and warranty — your structures are safe. Contact us to discuss details.