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
| Method | Damage Detection Accuracy | Response Time | Implementation Cost |
|---|---|---|---|
| Visual inspection (once a year) | 40% (visible cracks >0.2 mm) | Months | Low, but misses defects |
| AI-SHM with ML | 95% (including micro-cracks) | 24 hours | 3-4 months to deploy, pays back in 2 years |
| Traditional strain monitoring | 70% (deformations only) | Days | Medium, no prediction |
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
| Stage | Duration | Result |
|---|---|---|
| Analytics | 1-2 weeks | Report on monitoring points |
| Design | 2-3 weeks | Sensor specification and ML models |
| Implementation | 3-4 weeks | Installation, model training |
| Testing | 1 week | Alert verification |
| Deployment | 1 week | Go-live |
Process
- Analytics – our engineers visit the site, collect design documentation, calculate monitoring points.
- Design – select sensors, communication channels, ML architecture.
- Implementation – install sensors, configure data collection, train models (1-2 weeks).
- Testing – verify modal frequencies, check alerts.
- 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.