Metadata-Version: 2.4
Name: tower-core-engine
Version: 1.0.0
Summary: TOWER-CORE: A Critical Framework for Structural Integrity Assessment, Dynamic Stability Monitoring, and Safety Governance in Vertical Tower Systems
Author-email: Samir Baladi <gitdeeper@gmail.com>
License: MIT
Project-URL: Homepage, https://tower-core.netlify.app
Project-URL: Dashboard, https://tower-core.netlify.app/dashboard
Project-URL: Documentation, https://tower-core.netlify.app/documentation
Project-URL: Repository, https://github.com/gitdeeper12/TOWER-CORE
Project-URL: GitLab, https://gitlab.com/gitdeeper12/TOWER-CORE
Project-URL: PyPI, https://pypi.org/project/tower-core-engine
Project-URL: DOI, https://doi.org/10.5281/zenodo.20394041
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: Engineering
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Scientific/Engineering :: Civil Engineering
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: numpy>=1.21.0
Requires-Dist: scipy>=1.7.0
Requires-Dist: streamlit>=1.28.0
Requires-Dist: plotly>=5.17.0
Requires-Dist: pydantic>=2.0.0
Provides-Extra: dev
Requires-Dist: pytest>=7.0.0; extra == "dev"
Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
Requires-Dist: black>=22.0.0; extra == "dev"
Requires-Dist: isort>=5.12.0; extra == "dev"
Dynamic: license-file

<div align="center">

# 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**

---

[![PyPI version](https://img.shields.io/pypi/v/tower-core-engine?color=1C2833&label=PyPI&logo=pypi&logoColor=white)](https://pypi.org/project/tower-core-engine)
[![PyPI downloads](https://img.shields.io/pypi/dm/tower-core-engine?color=1A3A5C&label=Downloads&logo=pypi&logoColor=white)](https://pypi.org/project/tower-core-engine/#files)
[![Python versions](https://img.shields.io/pypi/pyversions/tower-core-engine?color=306998&logo=python&logoColor=white)](https://pypi.org/project/tower-core-engine)
[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20394041-blue.svg)](https://doi.org/10.5281/zenodo.20394041)
[![OSF Preregistration](https://img.shields.io/badge/OSF-Preregistered-blue?logo=osf&logoColor=white)](https://doi.org/10.17605/OSF.IO/8BPNF)
[![ORCID](https://img.shields.io/badge/ORCID-0009--0003--8903--0029-A6CE39?logo=orcid&logoColor=white)](https://orcid.org/0009-0003-8903-0029)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Domain](https://img.shields.io/badge/Domain-Structural%20Safety%20%26%20Reliability-2471A3)](https://doi.org/10.5281/zenodo.20394041)
[![Series](https://img.shields.io/badge/Series-TOWER--SAFETY--01-7D4E0F)](https://doi.org/10.5281/zenodo.20394041)
[![Version](https://img.shields.io/badge/Version-1.0.0-orange)](https://github.com/gitdeeper12/TOWER-CORE)

</div>

---

## 📌 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](#-overview)
- [Key Features](#-key-features)
- [Project Structure](#-project-structure)
- [Quick Start](#-quick-start)
- [Tower-Core Pipeline](#-tower-core-pipeline)
- [Governing Equations](#-governing-equations)
- [Scoring & Safety Bounds](#-scoring--safety-bounds)
- [Platforms & Mirrors](#-platforms--mirrors)
- [Clone & Download](#-clone--download)
- [Citation](#-citation)
- [License](#-license)
- [Author](#-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

```bash
# 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

```python
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

```python
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

```python
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

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

### 🌐 Official Website Pages

| Page | URL |
|---|---|
| Homepage | [tower-core.netlify.app](https://tower-core.netlify.app) |
| Dashboard | [tower-core.netlify.app/dashboard](https://tower-core.netlify.app/dashboard) |
| Results | [tower-core.netlify.app/results](https://tower-core.netlify.app/results) |
| Documentation | [tower-core.netlify.app/documentation](https://tower-core.netlify.app/documentation) |

---

## 🔄 Clone & Download

### Git Clone

```bash
# 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](https://github.com/gitdeeper12/TOWER-CORE/archive/refs/heads/main.zip) |
| GitLab | [TOWER-CORE-main.zip](https://gitlab.com/gitdeeper12/TOWER-CORE/-/archive/main/TOWER-CORE-main.zip) |
| Bitbucket | [TOWER-CORE-main.zip](https://bitbucket.org/gitdeeper-12/TOWER-CORE/get/main.zip) |
| Codeberg | [TOWER-CORE-main.zip](https://codeberg.org/gitdeeper12/TOWER-CORE/archive/main.zip) |
| PyPI files | [pypi.org/project/tower-core-engine/#files](https://pypi.org/project/tower-core-engine/#files) |
| Zenodo record | [doi.org/10.5281/zenodo.20394041](https://doi.org/10.5281/zenodo.20394041) |

---

## 📖 Citation

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

### 📦 PyPI Package

```bibtex
@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)

```bibtex
@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

```bibtex
@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

```bibtex
@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](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 | [gitdeeper@gmail.com](mailto:gitdeeper@gmail.com) |
| 🧑‍🔬 ORCID | [0009-0003-8903-0029](https://orcid.org/0009-0003-8903-0029) |
| 🐙 GitHub | [github.com/gitdeeper12](https://github.com/gitdeeper12) |
| 🔬 Zenodo | [doi.org/10.5281/zenodo.20394041](https://doi.org/10.5281/zenodo.20394041) |

---

<div align="center">

**TOWER-SAFETY-01 · Version 1.0.0 · May 2026**

[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20394041-blue.svg)](https://doi.org/10.5281/zenodo.20394041)
[![PyPI](https://img.shields.io/pypi/v/tower-core-engine?color=1C2833)](https://pypi.org/project/tower-core-engine)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Domain](https://img.shields.io/badge/Domain-Structural%20Safety%20%26%20Reliability-2471A3)](https://doi.org/10.5281/zenodo.20394041)

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

</div>
