tower-core-engine 1.0.0

TOWER-CORE: A Critical Framework for Structural Integrity Assessment, Dynamic Stability Monitoring, and Safety Governance in Vertical Tower Systems

TOWER-CORE

A Critical Framework for Structural Integrity Assessment, Dynamic Stability Monitoring, and Safety Governance in Vertical Tower Systems

Structural Reliability Engineering · Dynamic Loading Analysis · Fatigue Accumulation Governance · Real-Time Integrity Monitoring

---

---

📌 Overview

Tower-Core is a structural integrity assessment and safety governance framework for vertical tower systems, grounded in classical structural engineering, fracture mechanics, and dynamic structural analysis.

"A vertical tower operating under sustained wind loading is not in static equilibrium — it is a dynamically evolving system accumulating fatigue damage, experiencing natural frequency drift, and approaching or receding from its overturning stability limit in real time. Tower-Core quantifies these changes continuously and governs the safety margin accordingly."

Conventional periodic inspection of vertical tower structures cannot detect natural frequency drift, assess fatigue damage accumulation at internal crack tips, or evaluate the overturning stability margin under the specific loading conditions of the next severe storm event. Tower-Core provides a continuous, quantitative, three-module analytical framework that classifies tower structural condition in real time as:

Signal	Safety Status	Action
🟢 STEADY STATE	TSII ≥ 0.90	All margins within safe bounds — continuous monitoring, standard schedule
🟠 MONITORING PHASE 1	0.75 ≤ TSII < 0.90	Enhanced monitoring frequency; targeted inspection at flagged details
🟠 MITIGATION PHASE 2	0.65 ≤ TSII < 0.75	Operational load restriction; immediate structural review
🔴 CRITICAL BREACH	TSII < 0.65	Immediate shutdown; proximity zone evacuation; emergency assessment

---

🗂️ Table of Contents

• Overview
• Key Features
• Project Structure
• Quick Start
• Tower-Core Pipeline
• Governing Equations
• Scoring & Safety Bounds
• Platforms & Mirrors
• Clone & Download
• Citation
• License
• Author

---

✨ Key Features

• Three-module coupled assessment pipeline — DFMM (Dynamic Frequency Monitoring), SJFAM (Structural Joint Fatigue Assessment), GSOAM (Global Stability and Overturning Assessment)
• Tower Structural Integrity Index (TSII) — weighted composite safety metric with four-level governance decision logic
• Stochastic Subspace Identification (SSI-COV) — ambient vibration modal identification at ±0.1% frequency resolution
• Palmgren–Miner damage accumulation — rainflow cycle counting + Goodman mean stress correction + hot-spot stress approach (IIW)
• Dynamic overturning stability — gust response factor (Davenport 1961) + P-delta geometric nonlinearity correction
• Localized Stiffness Degradation Index (S_deg) — corrosion and fatigue damage contributions combined through continuum damage mechanics
• 24–48 hour TSII trend projection — warning lead time versus 0–4 hours for conventional monitoring
• ±2.83% TSII accuracy — validated against 3 independent field and laboratory data sets
• Full open-source distribution — available across 11 platforms

---

📁 Project Structure

TOWER-CORE/
│
├── tower_core/                             # Core Python package
│   ├── __init__.py                         # Package entry point & public API
│   ├── pipeline.py                         # Main Tower-Core assessment pipeline
│   ├── tsii.py                             # TSII composite index & governance logic
│   │
│   ├── modules/                            # Three analytical modules
│   │   ├── __init__.py
│   │   ├── dfmm.py                         # Module 1: Dynamic Frequency Monitoring Module
│   │   ├── sjfam.py                        # Module 2: Structural Joint Fatigue Assessment Module
│   │   └── gsoam.py                        # Module 3: Global Stability & Overturning Assessment Module
│   │
│   ├── dynamics/                           # Structural dynamics subsystem
│   │   ├── __init__.py
│   │   ├── ssi_cov.py                      # SSI-COV modal identification algorithm
│   │   ├── natural_frequency.py            # f_n(P) shift under axial load
│   │   ├── mode_shapes.py                  # Mode shape extraction and MAC computation
│   │   ├── frequency_perturbation.py       # First-order eigenvalue perturbation δω²
│   │   └── vortex_shedding.py              # Strouhal-based lock-in assessment
│   │
│   ├── fatigue/                            # Fatigue assessment subsystem
│   │   ├── __init__.py
│   │   ├── rainflow.py                     # ASTM E1049-85 rainflow cycle counting
│   │   ├── sn_curves.py                    # Eurocode FAT class S-N curve database
│   │   ├── palmgren_miner.py               # Miner linear damage accumulation D(t)
│   │   ├── goodman.py                      # Goodman mean stress correction σ_a,eq
│   │   ├── hot_spot_stress.py              # IIW hot-spot stress extrapolation
│   │   └── damage_map.py                   # Spatial fatigue damage distribution D(x,t)
│   │
│   ├── stability/                          # Overturning and geometric stability
│   │   ├── __init__.py
│   │   ├── overturning.py                  # F_stability = M_restoring / M_destabilizing
│   │   ├── gust_response.py                # Davenport gust response factor G_wind
│   │   ├── pdelta.py                       # P-delta geometric stiffness K_G
│   │   ├── stability_index.py              # θ_stab stability index computation
│   │   └── guy_wire.py                     # Guyed mast tension and restoring force
│   │
│   ├── degradation/                        # Stiffness degradation modeling
│   │   ├── __init__.py
│   │   ├── sdeg.py                         # S_deg = 1 - K_damaged / K_intact
│   │   ├── corrosion.py                    # ISO 9224 corrosion rate model
│   │   ├── remaining_life.py               # T_rem(e) = (A_rem - A_crit) / (dA/dt)
│   │   └── chaboche.py                     # Chaboche continuum damage mechanics
│   │
│   ├── wind/                               # Wind loading models
│   │   ├── __init__.py
│   │   ├── mean_profile.py                 # Power law V_mean(z) = V_ref·(z/z_ref)^α
│   │   ├── turbulence_spectrum.py          # von Kármán spectrum S_u(n,z)
│   │   ├── drag_force.py                   # q_mean(z) = 0.5·ρ·C_d·A(z)·V²
│   │   └── vortex_induced.py               # Lock-in amplitude Y_max/D (Scruton number)
│   │
│   ├── sensors/                            # Sensor integration and fusion
│   │   ├── __init__.py
│   │   ├── accelerometer.py                # Tri-axial MEMS accelerometer parser
│   │   ├── strain_gauge.py                 # Vibrating-wire strain gauge processing
│   │   ├── tiltmeter.py                    # Foundation tilt and settlement monitoring
│   │   ├── anemometer.py                   # 3D ultrasonic wind monitor interface
│   │   └── fusion.py                       # Multi-sensor data fusion and QC
│   │
│   └── utils/                              # Shared utilities
│       ├── __init__.py
│       ├── metrics.py                      # TSII, NFS, RSM, S_deg computation
│       ├── mac.py                          # Modal Assurance Criterion
│       ├── validators.py                   # Input validation and safety bounds
│       └── constants.py                    # Material, terrain, and code parameters
│
├── monitoring/                             # Real-time monitoring dashboard
│   ├── __init__.py
│   ├── app.py                              # Streamlit application entry point
│   ├── dashboard.py                        # TSII governance dashboard layout
│   ├── frequency_plot.py                   # Natural frequency trend display
│   ├── fatigue_map.py                      # Spatial fatigue damage map renderer
│   ├── stability_panel.py                  # F_stability and gust response panel
│   └── components/
│       ├── tsii_gauge.py                   # TSII composite index gauge display
│       ├── signal_panel.py                 # 🔴🟠🟢 governance signal status
│       └── trend_forecast.py               # 24–48h TSII trajectory projection
│
├── archival/                               # Operational data archival
│   ├── __init__.py
│   ├── writer.py                           # Append-only JSON/CSV record writer
│   ├── checksum.py                         # SHA-256 tamper-evidence layer
│   └── partitioner.py                      # Per-module time-window CSV partitioner
│
├── simulation/                             # Validation and benchmark environment
│   ├── __init__.py
│   ├── tower_configs.py                    # Tower geometry and material definitions
│   ├── loading_scenarios.py                # Wind, fatigue, and stability scenarios
│   ├── benchmarks.py                       # Three-case validation suite
│   ├── parameters.py                       # Canonical v1.0.0 parameter registry
│   └── results/                            # Pre-computed validation outputs
│       ├── V1_guyed_mast_storm.json
│       ├── V2_lattice_fatigue_forensics.json
│       └── V3_monopole_scale_model.json
│
├── examples/                               # Usage examples and tutorials
│   ├── quickstart.py                       # Minimal working example
│   ├── basic_tsii.ipynb                    # Jupyter: single-tower TSII assessment
│   ├── fatigue_accumulation.ipynb          # Jupyter: rainflow + Miner walkthrough
│   ├── overturning_stability.ipynb         # Jupyter: gust response factor analysis
│   ├── frequency_tracking.ipynb            # Jupyter: SSI-COV modal identification
│   ├── streamlit_dashboard.py              # Launch real-time monitoring dashboard
│   └── corrosion_life_prediction.py        # Remaining life forecast demo
│
├── tests/                                  # Unit and integration tests
│   ├── test_dfmm.py
│   ├── test_sjfam.py
│   ├── test_gsoam.py
│   ├── test_tsii.py
│   ├── test_ssi_cov.py
│   ├── test_rainflow.py
│   ├── test_overturning.py
│   ├── test_sdeg.py
│   └── test_pipeline.py
│
├── docs/                                   # Documentation source
│   ├── architecture.md                     # Module architecture reference
│   ├── mathematics.md                      # Governing equations documentation
│   ├── monitoring.md                       # Sensor system and SSI-COV guide
│   ├── governance.md                       # TSII threshold calibration reference
│   └── api_reference.md                    # Full Python API reference
│
├── paper/                                  # Research paper artifacts
│   ├── TOWER-CORE_Research_Paper.pdf       # Published paper (PDF)
│   ├── TOWER-CORE_Research_Paper.docx      # Editable Word version
│   └── figures/
│       ├── tsii_formulation.svg
│       ├── fatigue_damage_map.svg
│       ├── frequency_drift_example.svg
│       └── overturning_stability_diagram.svg
│
├── .gitlab-ci.yml                          # GitLab CI/CD pipeline
├── .github/
│   └── workflows/
│       ├── tests.yml
│       └── publish.yml
├── pyproject.toml
├── setup.cfg
├── requirements.txt
├── requirements-dev.txt
├── CHANGELOG.md
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── AUTHORS.md
├── LICENSE
└── README.md                               # This file

---

🚀 Quick Start

Installation

# Install from PyPI
pip install tower-core-engine

# Install from source
git clone https://github.com/gitdeeper12/TOWER-CORE.git
cd TOWER-CORE
pip install -e .

Minimal Example

from tower_core import TowerCoreAssessor

# Initialize assessor with tower configuration
assessor = TowerCoreAssessor(
    tower_config="configs/lattice_120m.yaml",
    sensor_stream="live"   # or path to historical CSV
)

# Run full Tower-Core assessment pipeline
result = assessor.evaluate()

print(result.tsii)               # Tower Structural Integrity Index ∈ [0, 1]
print(result.signal)             # "STEADY_STATE" | "MONITORING_1" | "MITIGATION_2" | "CRITICAL"
print(result.nfs)                # Natural Frequency Shift (%) per mode
print(result.d_fatigue_max)      # Maximum Palmgren–Miner damage across all details
print(result.f_stability)        # Dynamic overturning stability factor
print(result.s_deg_global)       # Global stiffness degradation index

With Full Three-Module Configuration

from tower_core import TowerCoreAssessor
from tower_core.modules import DFMM, SJFAM, GSOAM

assessor = TowerCoreAssessor(
    tower_config="configs/lattice_120m.yaml",
    modules={
        "dfmm":  DFMM(rsm_min=10.0, nfs_warn=5.0, nfs_crit=10.0),
        "sjfam": SJFAM(d_limit=0.80, d_crit=1.00, sn_class="FAT90"),
        "gsoam": GSOAM(f_stab_min=1.50, theta_stab_max=0.10),
    }
)

result = assessor.evaluate()
print(result.breakdown)
# {"stiffness": 0.91, "stability": 0.88, "fatigue": 0.95}

Fatigue Damage Accumulation Analysis

from tower_core.fatigue import RainflowCounter, PalmgrenMiner
from tower_core.fatigue import SNcurve

# Load strain time series from instrumented connection detail
strain_ts = load_csv("sensors/joint_D7_strain.csv")

counter = RainflowCounter()
cycles = counter.count(strain_ts)          # ASTM E1049-85 rainflow

sn = SNcurve(fat_class=90, m=3)           # Eurocode FAT90
miner = PalmgrenMiner(sn_curve=sn)
D = miner.accumulate(cycles)              # D(t) = Σ n_i / N_i

print(f"Fatigue damage: {D:.4f} (limit: 0.80, failure: 1.00)")

Launch Real-Time Monitoring Dashboard

# Start Streamlit TSII governance dashboard
streamlit run examples/streamlit_dashboard.py

# Dashboard at: http://localhost:8501
# Panels:
#   · TSII composite gauge with 4-level signal
#   · Natural frequency trend (SSI-COV rolling window)
#   · Fatigue damage map (spatial hot-spot display)
#   · Overturning stability factor with gust response
#   · 24–48h TSII trajectory forecast

---

🧩 Tower-Core Pipeline

┌──────────────────────────────────────────────────────────────────────┐
│  Sensor Input: Accelerometers · Strain Gauges · Tiltmeters · Anemom. │
└────────────────────────────┬─────────────────────────────────────────┘
                             │
         ┌───────────────────┼──────────────────┐
         │                   │                  │
         ▼                   ▼                  ▼
    DFMM                SJFAM              GSOAM
    SSI-COV             Rainflow           Gust Response
    Modal ID            Cycle Counting     Factor G_wind
    f_n,i(t)            D_fatigue(t)       M_wind(t)
    NFS tracking        Hot-spot stress    P-delta K_G
    RSM monitoring      Goodman corr.      F_stability
         │                   │                  │
         └───────────────────┼──────────────────┘
                             │
                   Stiffness Degradation
                   S_deg = 1 - K_dam/K_int
                   Corrosion + Fatigue
                             │
                             ▼
              Tower Structural Integrity Index
              TSII = 0.40·(1-S_deg) + 0.35·(F_stab/1.50)
                         + 0.25·(1-D_fatigue)
                             │
                    ┌────────┴────────┐
                    ▼                 ▼
             Safety Signal       Archival
             🟢🟠🔴             JSON/CSV + SHA-256
             4-level TSII       Streamlit dashboard

Module Summary

#	Module	Governing Output	Core Method
1	DFMM	NFS_i(t), RSM_i(t)	SSI-COV ambient modal identification
2	SJFAM	D_fatigue(x,t)	Rainflow + Palmgren–Miner + IIW hot-spot
3	GSOAM	F_stability(t)	Davenport gust response + P-delta
—	S_deg	S_deg,global(t)	Chaboche damage + ISO 9224 corrosion
—	TSII	TSII(t) ∈ [0,1]	Weighted composite of all three modules

---

⚙️ Governing Equations

Eq. 1 — Natural Frequency Shift under Axial Load:
  f_n(P) = f₀ · √(1 - P/P_cr)

Eq. 2 — Dynamic Wind Load Distribution:
  F_wind(z,t) = 0.5 · ρ_air · C_d · A(z) · [V_mean(z) + v_turb(z,t)]²

Eq. 3 — Structural Joint Fatigue Accumulation:
  D_fatigue(t) = Σᵢ [ nᵢ(t) / Nᵢ(Δσᵢ) ] ≤ D_limit

Eq. 4 — Dynamic Overturning Stability Factor:
  F_stability = M_restoring / (M_wind + M_operational) ≥ 1.50

Eq. 5 — Localized Stiffness Degradation Index:
  S_deg = 1 - (K_damaged / K_intact)

Eq. 6 — Tower Structural Integrity Index:
  TSII = [0.40 · (1 - S_deg)] + [0.35 · (F_stability / 1.50)] + [0.25 · (1 - D_fatigue)]

---

📊 Scoring & Safety Bounds

TSII governance certification thresholds:
  TSII ≥ 0.90   →   🟢 Steady State
  0.75 ≤ TSII < 0.90   →   🟠 Monitoring Phase 1
  0.65 ≤ TSII < 0.75   →   🟠 Mitigation Phase 2
  TSII < 0.65   →   🔴 Critical Breach

Additional safety bounds:
  F_stability    ≥  1.50   (overturning stability)
  NFS_i          <  5%     (frequency shift warning)
  D_fatigue,max  <  0.80   (Miner damage warning threshold)
  RSM_i          ≥  10%    (resonance safety margin)
  θ_stab         ≤  0.10   (P-delta stability index)

Validation results (Tower-Core v1.0.0):

Case	Tower Type	TSII Accuracy	Freq. Detection	Fatigue MAE	F_stab Error
V1	Guyed telecom mast — storm events	±2.8%	95.1% (3% threshold)	2.4%	±4.1%
V2	Lattice tower — fatigue forensics	±3.2%	94.8% (post-hoc)	2.9%	N/A
V3	Monopole scale model — progressive	±2.5%	96.3% (2% threshold)	1.8%	±3.7%
Mean	—	±2.83%	95.4%	2.37%	±3.9%

---

🌐 Platforms & Mirrors

Platform	URL	Role
🐙 GitHub (Primary)	github.com/gitdeeper12/TOWER-CORE	Source code, issues, PRs
🦊 GitLab (Mirror)	gitlab.com/gitdeeper12/TOWER-CORE	CI/CD mirror
🪣 Bitbucket (Mirror)	bitbucket.org/gitdeeper-12/TOWER-CORE	Enterprise mirror
🏔️ Codeberg (Mirror)	codeberg.org/gitdeeper12/TOWER-CORE	Open-source community
📦 PyPI	pypi.org/project/tower-core-engine	Python package distribution
🔬 Zenodo	doi.org/10.5281/zenodo.20394041	Citable DOI, paper & data
📋 OSF Project	osf.io/8BPNF	Research project registry
📝 OSF Preregistration	doi.org/10.17605/OSF.IO/8BPNF	Pre-registered study protocol
🌐 Website	tower-core.netlify.app	Live documentation & dashboard
🧑‍🔬 ORCID	orcid.org/0009-0003-8903-0029	Researcher identity
🗄️ Internet Archive	archive.org/details/osf-registrations-8BPNF	Permanent archival copy

🌐 Official Website Pages

Page	URL
Homepage	tower-core.netlify.app
Dashboard	tower-core.netlify.app/dashboard
Results	tower-core.netlify.app/results
Documentation	tower-core.netlify.app/documentation

---

🔄 Clone & Download

Git Clone

# GitHub (Primary)
git clone https://github.com/gitdeeper12/TOWER-CORE.git

# GitLab (Mirror)
git clone https://gitlab.com/gitdeeper12/TOWER-CORE.git

# Bitbucket (Mirror)
git clone https://bitbucket.org/gitdeeper-12/TOWER-CORE.git

# Codeberg (Mirror)
git clone https://codeberg.org/gitdeeper12/TOWER-CORE.git

Direct ZIP Download

Source	Link
GitHub	TOWER-CORE-main.zip
GitLab	TOWER-CORE-main.zip
Bitbucket	TOWER-CORE-main.zip
Codeberg	TOWER-CORE-main.zip
PyPI files	pypi.org/project/tower-core-engine/#files
Zenodo record	doi.org/10.5281/zenodo.20394041

---

📖 Citation

If Tower-Core contributes to your research, please cite using one of the following formats.

📦 PyPI Package

@software{baladi2026towercore_pypi,
  author       = {Baladi, Samir},
  title        = {{Tower-Core}: A Critical Framework for Structural Integrity
                  Assessment, Dynamic Stability Monitoring, and Safety
                  Governance in Vertical Tower Systems},
  year         = {2026},
  version      = {1.0.0},
  publisher    = {Python Package Index},
  url          = {https://pypi.org/project/tower-core-engine},
  note         = {Python package, MIT License, Series TOWER-SAFETY-01}
}

🔬 Zenodo Archive (Paper & Data)

@dataset{baladi2026towercore_zenodo,
  author       = {Baladi, Samir},
  title        = {{Tower-Core}: A Critical Framework for Structural Integrity
                  Assessment, Dynamic Stability Monitoring, and Safety
                  Governance in Vertical Tower Systems —
                  Research Paper and Simulation Data},
  year         = {2026},
  publisher    = {Zenodo},
  version      = {1.0.0},
  doi          = {10.5281/zenodo.20394041},
  url          = {https://doi.org/10.5281/zenodo.20394041},
  note         = {Structural Safety \& Reliability Engineering · TOWER-SAFETY-01}
}

📝 OSF Preregistration

@misc{baladi2026towercore_osf,
  author       = {Baladi, Samir},
  title        = {{Tower-Core} Framework: Pre-registered Study Protocol for
                  Structural Integrity Assessment and Safety Governance
                  in Vertical Tower Systems},
  year         = {2026},
  publisher    = {Open Science Framework},
  doi          = {10.17605/OSF.IO/8BPNF},
  url          = {https://doi.org/10.17605/OSF.IO/8BPNF},
  note         = {OSF Preregistration}
}

📄 Research Paper

@article{baladi2026towercore,
  author       = {Baladi, Samir},
  title        = {{Tower-Core}: A Critical Framework for Structural Integrity
                  Assessment, Dynamic Stability Monitoring, and Safety
                  Governance in Vertical Tower Systems},
  year         = {2026},
  month        = {May},
  version      = {1.0.0},
  doi          = {10.5281/zenodo.20394041},
  url          = {https://doi.org/10.5281/zenodo.20394041},
  note         = {Ronin Institute / Rite of Renaissance,
                  Series TOWER-SAFETY-01}
}

APA (inline)

Baladi, S. (2026). Tower-Core: A Critical Framework for Structural Integrity Assessment, Dynamic Stability Monitoring, and Safety Governance in Vertical Tower Systems (Version 1.0.0, Series TOWER-SAFETY-01). Zenodo. https://doi.org/10.5281/zenodo.20394041

---

📜 License

This project is licensed under the MIT License — see the LICENSE file for details.

MIT License

Copyright (c) 2026 Samir Baladi

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

---

👤 Author

Samir Baladi Interdisciplinary AI Researcher — Computational Structural Safety & Reliability Engineering Ronin Institute / Rite of Renaissance

Contact	Link
📧 Email	[e-mail]
🧑‍🔬 ORCID	0009-0003-8903-0029
🐙 GitHub	github.com/gitdeeper12
🔬 Zenodo	doi.org/10.5281/zenodo.20394041

---

TOWER-SAFETY-01 · Version 1.0.0 · May 2026

"Structural integrity in a vertical tower is not a property frozen at commissioning — it is a continuously evolving state requiring continuous quantitative assessment."