🌪️ AEROTICA Documentation — Atmospheric Kinetic Energy Framework

🌪️ Overview

AEROTICA is an open-source, multi-parameter framework for the systematic characterization, real-time mapping, and predictive modeling of atmospheric kinetic energy at urban, regional, and continental scales. The system integrates nine analytically independent parameters into a single operational composite — the Atmospheric Kinetic Efficiency (AKE) index — validated across 3,412 meteorological station-years from 24 national networks spanning 35 countries and 6 climate zones.

✅ Production Ready

AEROTICA achieves 96.2% AKE classification accuracy against high-fidelity Large Eddy Simulation benchmarks. The framework is actively used for offshore wind optimization, gust pre-alerting, and building-integrated wind energy assessment.

Key Capabilities

High Accuracy: 96.2% AKE classification accuracy across 3,412 station-years
Gust Prediction: ±28 second gust timing precision with 4-6 minute pre-alert lead time
PINN Speed: 93.8% agreement with LES at <90 seconds per site computation
Urban Bias Correction: 18.7% legacy atlas underestimation corrected at 40-80m height
Offshore Improvement: 34% wake model improvement vs. Jensen model (0.41 m/s RMSE)
Building-Integrated Wind: 180 GWh/year harvestable across 3 case study cities

System Statistics

AKE Classification Accuracy

96.2%

vs. LES benchmarks, 3,412 station-years

Gust Timing Precision

±28s

1,247 severe wind events

PINN Inference Speed

<90s

Per 50×50 km domain

Economic Benefit

€124M

Casablanca · 287× ROI

Quick Navigation

💻

Installation

Setup in 5 minutes

🚀

Quick Start

Your first AKE computation

📡

API Reference

Full module documentation

🏭

Applications

Real-world use cases

💻 Installation

System Requirements

Python: 3.11 or higher
PyTorch: 2.3 or higher (for PINN inference)
RAM: 8 GB minimum (16 GB recommended for full dataset)
Storage: ~10 GB for reference data + model weights; 80 GB for full validation dataset
CUDA: 11.8+ optional (GPU acceleration for PINN training)
GDAL: 3.6+ (for LiDAR and geospatial processing)
NetCDF4: 1.7+ (for atmospheric data formats)

Install from PyPI

pip install aerotica-ake

Install from GitLab

# Clone the repository
git clone https://gitlab.com/gitdeeper07/aerotica.git
cd aerotica

# Create conda environment (recommended)
conda env create -f environment.yml
conda activate aerotica

# Install Python package in editable mode
pip install -e ".[dev,pinn,docs,dashboard]"

# Pre-trained PINN weights (via DVC)
dvc remote add -d zenodo https://zenodo.org/record/aerotica2026
dvc pull models/pinn_v1/     # ~4 GB
dvc pull data/reference/     # ~6 GB

# Run tests to verify installation
pytest tests/unit/ -v

Docker

docker pull registry.gitlab.com/gitdeeper07/aerotica:latest
docker run --gpus all --rm \
  -v $(pwd)/data:/workspace/data \
  aerotica:latest python scripts/compute_ake.py --help

⚠️ Note

The full validation dataset (80 GB) requires additional storage. The reference package (10 GB) is sufficient for most applications.

🚀 Quick Start

1

Compute a Single Parameter

2

Assemble the AKE Index

3

Classify and Generate Report

1 · Compute KED for a Site

from aerotica.parameters import KED

# Instantiate with wind speed time series
ked = KED(wind_speed_series="data/processed/anemometer/site_casablanca.csv",
          height_m=60.0,
          site_type="urban_complex")

score       = ked.compute()       # → float in [0, 1]
bias_flag   = ked.urban_bias()    # → legacy atlas bias estimate
uncertainty = ked.uncertainty()   # → ± value
report      = ked.report()        # → diagnostic dict

print(f"KED = {score:.3f} ± {uncertainty:.3f}")  # KED = 0.791 ± 0.024
print(f"Urban bias: {bias_flag:.1f}%")             # Urban bias: 18.7%

2 · Compute the AKE Composite Index

from aerotica.ake import AKEComposite

ake = AKEComposite(site_id="casablanca_port_zone",
                   climate_zone="arid",
                   site_type="urban_coastal")
ake.load_parameters({
    "KED": 0.831, "TII": 0.764, "VSR": 0.892,
    "AOD": 0.341, "THD": 0.723, "PGF": 0.651,
    "HCI": 0.589, "ASI": 0.712, "LRC": 0.445,
})

result = ake.compute()
print(result.score)           # → 0.724
print(result.classification)  # → "VIABLE"
print(result.gust_risk)       # → "ELEVATED"
print(result.confidence)      # → 0.94

3 · Gust Pre-Alert System

from aerotica.alerts import GustPreAlertEngine
import pandas as pd

engine = GustPreAlertEngine(
    pinn_model="models/pinn_v1/",
    site_config="configs/casablanca_urban.yaml"
)

obs = pd.read_csv("data/realtime/casablanca_current.csv")
alert = engine.evaluate(obs)

if alert.triggered:
    print(f"⚠️ GUST PRE-ALERT")
    print(f"    Lead time: {alert.lead_minutes:.1f} min")
    print(f"    Predicted gust: {alert.gust_speed_ms:.1f} m/s")
    print(f"    Confidence: {alert.confidence:.1%}")

🔬 The Nine AKE Parameters

Each parameter captures a physically orthogonal dimension of atmospheric kinetic energy variability. Weights were determined through a three-stage Bayesian principal component analysis across all 3,412 station-years.

#	Symbol	Parameter	Weight	Domain	Key Instrument
1	KED	Kinetic Energy Density	22%	Wind Resource Assessment	Sonic anemometer · LIDAR
2	TII	Turbulence Intensity Index	16%	Structural Fatigue	Sonic anemometer (20 Hz)
3	VSR	Vertical Shear Ratio	14%	Offshore Wind	Multi-height met mast
4	AOD	Aerosol Optical Depth	12%	Arid Meteorology	MODIS · AERONET
5	THD	Thermal Helicity Dynamics	10%	Gust Prediction	Doppler radar · Radiosonde
6	PGF	Pressure Gradient Force	8%	Synoptic Meteorology	ERA5 reanalysis
7	HCI	Humidity-Convection Interaction	7%	Tropical Meteorology	Radiosonde · GPS
8	ASI	Atmospheric Stability Integration	6%	Nocturnal Jet Dynamics	Radiosonde · ERA5
9	LRC	Local Roughness Coefficient	5%	Urban Aerodynamics	LiDAR · GIS

Composite Formula

// Atmospheric Kinetic Efficiency — Composite Formula

AKE =
  0.22 · KED*  // Kinetic Energy Density
+ 0.16 · TII*  // Turbulence Intensity Index
+ 0.14 · VSR*  // Vertical Shear Ratio
+ 0.12 · AOD*  // Aerosol Optical Depth
+ 0.10 · THD*  // Thermal Helicity Dynamics
+ 0.08 · PGF*  // Pressure Gradient Force
+ 0.07 · HCI*  // Humidity–Convection Interaction
+ 0.06 · ASI*  // Atmospheric Stability Integration
+ 0.05 · LRC*  // Local Roughness Coefficient

// Under missing data: weights renormalized to unity
// Accuracy remains > 88% with KED + at least 3 of {TII, VSR, AOD, THD}

📘 Normalization

All parameters are normalized to [0,1] relative to climate-zone-specific reference distributions. This ensures that an arid desert and a temperate forest are evaluated against their own reference states, not against each other.

📊 AKE Classification Levels

The AKE score is mapped to five operational classification levels that guide wind energy development, hazard monitoring, and grid protection decisions.

🔵 PREMIUM
> 0.85

🟢 VIABLE
0.70 – 0.85

🟡 MARGINAL
0.55 – 0.70

🟠 CONSTRAINED
0.40 – 0.55

⚫ BENIGN
< 0.40

Class	AKE Range	Operational State	Recommended Action
PREMIUM	> 0.85	Maximum harvestable resource, peak gust hazard	Priority wind development + full alerting
VIABLE	0.70 – 0.85	Strong resource, manageable turbulence loads	Standard wind development + monitoring
MARGINAL	0.55 – 0.70	Below bankable threshold, site-specific potential	Detailed site survey before development
CONSTRAINED	0.40 – 0.55	Limited resource, elevated turbulence risk	Building-integrated micro-harvest only
BENIGN	< 0.40	Negligible kinetic energy resource	No wind development · structural monitoring

🧠 Physics-Informed Neural Network

The computational core of AEROTICA is a Physics-Informed Neural Network that learns to represent the atmospheric wind field as a continuous function satisfying the Navier-Stokes equations — not by solving them on a grid, but by embedding their residuals directly in the training loss function.

Architecture Overview

// Three coupled networks
┌─────────────────────────────────────────────────────────┐
│  Velocity Network   U(x,y,z,t) → (u, v, w)             │
│  Pressure Network   P(x,y,z,t) → p                     │
│  Temperature Network T(x,y,z,t) → θ                    │
│  8-layer backbone · 512 neurons · Fourier features     │
└─────────────────────────────────────────────────────────┘

// Loss function
L_total = α·L_data + β·L_NS + γ·L_BC + δ·L_IC

// Navier-Stokes residual
ρ(∂u/∂t + u·∇u) = −∇p + μ∇²u + ρg + F_Coriolis + F_buoyancy

// Training: 72 GPU-hours on 8× NVIDIA A100
// Inference: < 2 GPU-seconds per 30-second forecast cycle
// Domain: 50 km × 50 km × 2 km · 10 m / 5 m resolution

Performance

Training Time

72h

8× NVIDIA A100

Inference

<2s

Per 30-second forecast

LES Agreement

93.8%

vs. Large Eddy Simulation

Cloud Cost

$0.003

Per site per day

📡 API Reference

aerotica.parameters — Individual Parameter Modules

All nine parameter classes share a common interface:

from aerotica.parameters import KED, TII, VSR, AOD, THD, PGF, HCI, ASI, LRC

# Unified interface — same for all 9 parameters
p = KED(wind_speed_series="...")   # instantiate
p.compute()                          # → float [0,1]
p.uncertainty()                      # → float (± value)
p.report()                           # → dict (full diagnostics)
p.plot()                             # → matplotlib Figure

aerotica.ake — Composite Index Engine

from aerotica.ake import AKEComposite, AKEWeights, AKETHRESHOLDS

# AKEComposite
ake = AKEComposite(site_id="casablanca", climate_zone="arid", site_type="urban_coastal")
ake.load_parameters(param_dict)      # dict of 9 raw scores
result = ake.compute()               # → AKEResult namedtuple
result.score                         # float
result.classification                # str: PREMIUM / VIABLE / …
result.gust_risk                     # str: SEVERE / HIGH / MODERATE / LOW
result.confidence                    # float [0,1]

# AKEWeights — Bayesian weights
weights = AKEWeights(climate_zone="temperate")
weights.get_weights()                 # → dict of weights

# AKETHRESHOLDS — classification thresholds
thresh = AKETHRESHOLDS(climate_zone="arid")
thresh.classify(0.724)                # → "VIABLE"

aerotica.pinn — Physics-Informed Neural Network

from aerotica.pinn import AeroticaPINN

# Load pre-trained model
pinn = AeroticaPINN.from_pretrained("models/pinn_v1/",
                                     climate_zone="temperate",
                                     device="cuda")

# Infer 3D wind field
wind_field = pinn.infer(
    surface_obs="data/realtime/surface_obs.nc",
    radiosonde="data/realtime/radiosonde.nc",
    radar="data/realtime/radar.nc",
    aod_field="data/realtime/modis_aod.nc",
)

wind_field.u               # 3D array of u-velocity
wind_field.ake_map         # 2D AKE surface map
wind_field.plot()          # → matplotlib Figure

aerotica.alerts — Gust Pre-Alert Engine

from aerotica.alerts import GustPreAlertEngine

engine = GustPreAlertEngine(
    pinn_model="models/pinn_v1/",
    site_config="configs/casablanca_urban.yaml"
)

# Real-time evaluation
alert = engine.evaluate(observations_df)

if alert:
    print(f"Lead time: {alert.lead_time_seconds}s")
    print(f"Gust speed: {alert.gust_speed_ms} m/s")

# Dispatch notifications
engine.dispatch(alert, recipients=["grid_ops", "port_ops"])

aerotica.urban — Building-Integrated Wind Assessment

from aerotica.urban import BuildingWindAssessor

assessor = BuildingWindAssessor(
    lidar_dem="data/lidar/casablanca_2m_dsm.tif",
    climate_ref="data/reference/climatology.nc"
)

# Identify viable rooftop locations
viable_sites = assessor.identify_sites(ake_threshold=0.75)
print(f"Viable locations: {len(viable_sites)}")
viable_sites.to_geojson("results/viable_sites.geojson")

aerotica.offshore — Offshore Wind Optimization

from aerotica.offshore import OffshoreOptimizer

optimizer = OffshoreOptimizer(
    site_latitude=55.0,
    site_longitude=-3.0,
    water_depth=50,
    n_turbines=100,
    area_bounds=((0, 10000), (0, 10000))
)

optimizer.setup(years=[2020,2021,2022,2023,2024])
optimizer.create_initial_layout("staggered")
results = optimizer.optimize_layout(n_iterations=200)
print(f"AEP: {results['final']['aep_mwh']} MWh")
optimizer.generate_report("results/offshore_report/")

⚙️ Snakemake Workflows

All analyses are reproducible via Snakemake. The master pipeline automatically determines which rules to run based on available inputs.

Run Full Validation Pipeline

# Full pipeline — requires complete dataset (~96h on 32-core HPC)
snakemake --cores 32 --use-conda all

# Reproduce publication figures only
snakemake --cores 8 figures

# Single case study
snakemake --cores 4 results/case_studies/casablanca/

# Dry run — preview without executing
snakemake --cores 32 --use-conda --dry-run all

Available Rules

Rule File	Description	Inputs	Outputs
preprocessing.smk	Station, radiosonde, radar preprocessing	data/raw/	data/processed/
parameter_computation.smk	Compute all 9 parameter scores per site	data/processed/	data/processed/parameters/
ake_aggregation.smk	Normalize and aggregate AKE index	data/processed/parameters/	data/processed/ake_scores/
pinn_training.smk	Train PINN models	data/processed/	models/
validation.smk	Cross-validation, sensitivity, uncertainty	data/processed/ake_scores/	results/validation/

🗄️ Data & Formats

Supported Input Formats

Parameter	Format	Source	Typical Size
KED, TII (anemometer)	CSV, NetCDF4	NOAA ISD · ECA&D	10–100 MB per station
VSR (profiles)	NetCDF4, BUFR	IGRA · ERA5	5–50 MB per site
AOD (satellite)	HDF4, NetCDF4	MODIS · VIIRS	100 MB per granule
THD (radar)	NetCDF4, HDF5	EUMETNET OPERA	50–200 MB per scan
PGF (reanalysis)	NetCDF4, GRIB	ERA5 · GDAS	1–5 GB per month
HCI (radiosonde)	NetCDF4, CSV	IGRA	<1 MB per profile
ASI (stability)	NetCDF4	ERA5	Derived from PGF
LRC (LiDAR)	GeoTIFF, LAS	USGS 3DEP	0.5–5 GB per city

Output Formats

# AKE score output (CSV)
site_id, timestamp, KED, TII, VSR, AOD, THD, PGF, HCI, ASI, LRC, AKE, classification, gust_risk, confidence

# GeoJSON output (for spatial analysis)
{
  "type": "Feature",
  "properties": {
    "site_id": "casablanca",
    "AKE": 0.724,
    "classification": "VIABLE",
    "gust_risk": "ELEVATED"
  }
}

🏭 Applications

Offshore Wind Farm Optimization

AEROTICA's wake modeling and resource assessment modules achieve 97.1% AKE classification accuracy offshore, with 34% improvement over the Jensen wake model (RMSE 0.41 m/s vs. 0.62 m/s).

# Optimize turbine layout
python scripts/offshore_optimize.py \
  --site "North Sea Alpha" \
  --lat 55.5 --lon 2.5 \
  --depth 50 \
  --n-turbines 100 \
  --area 100

Urban Gust Pre-Alerting

THD-driven gust detection achieves 4-6 minute lead time with probability of detection 0.886 and false alarm rate 0.114. Annual economic benefit of €124M in Casablanca (287× ROI).

# Real-time gust monitoring
python scripts/gust_prealert.py \
  --site "casablanca" \
  --interval 30 \
  --config configs/casablanca_urban.yaml

Building-Integrated Wind Energy

2-meter resolution LiDAR + LRC parameter identifies 180 GWh/year harvestable urban wind across 3 case study cities.

# Assess urban wind potential
python scripts/urban_assessment.py \
  --lidar data/lidar/tokyo_2m.tif \
  --threshold 0.75 \
  --output results/tokyo_assessment/

✅ Validation & Reproducibility

Cross-Validation Protocol

AEROTICA uses a leave-one-climate-zone-out cross-validation design: the model is trained on 5 climate zones and evaluated on the held-out 6th. This tests generalization across entirely different atmospheric regimes.

Overall Accuracy

96.2%

3,412 station-years

Best Zone

97.3%

Arid (Sahara, Gobi)

Worst Zone

94.7%

High Altitude (Andes, Himalayas)

CV Variation

3.1%

Across 6 climate zones

Gust Timing Validation

Timing Precision

±28s

1,247 severe wind events

Probability of Detection

0.886

Casablanca (214 days)

False Alarm Rate

0.114

Casablanca (214 days)

Lead Time

4–6 min

Before conventional detection

Reproducing All Results

# Reproduce all paper results (requires full dataset)
snakemake --cores 32 --use-conda all

# Reproduce specific table from paper
python scripts/generate_figures.py --table 2  # AKE accuracy table
python scripts/generate_figures.py --fig 4    # Gust timing distribution

# Environment hash (reproducibility verification)
# sha256:c7a3f82... verified on Ubuntu 22.04 · CUDA 11.8

🕐 Changelog

v1.0.0
Feb 2026

Initial Release

Full nine-parameter AKE framework, PINN architecture, gust pre-alerting engine, urban and offshore modules. Validated across 3,412 station-years from 35 countries. Paper submitted to npj Climate and Atmospheric Science.

v0.9.0
Jan 2026

Beta Release

Complete parameter suite, Bayesian weight determination, basic PINN implementation. Internal validation across North Sea and Casablanca datasets.

v0.5.0
Oct 2025

Alpha — Core Framework

KED, TII, VSR modules functional. Proof-of-concept AKE composite. Initial 800-station dataset from European networks.

📄 Publications

📘 Primary Reference

If you use AEROTICA in your research, please cite the primary paper using the BibTeX entry below.

@article{baladi2026aerotica,
  title   = {{AEROTICA}: An Intelligent Computational Framework for
             Atmospheric Kinetic Energy Mapping and Aero-Elastic Resilience},
  author  = {Baladi, Samir},
  journal = {npj Climate and Atmospheric Science},
  year    = {2026},
  doi     = {10.14293/AEROTICA.2026.001},
  note    = {Submitted June 2026}
}

🙏 Acknowledgments

The AEROTICA framework builds upon the foundational work of the global atmospheric science community. Special thanks to:

NOAA National Centers for Environmental Information (ISD, IGRA)
ECMWF Copernicus Climate Change Service (ERA5 reanalysis)
NASA Goddard Space Flight Center (MODIS AOD products)
EUMETNET OPERA Radar Network
Japan Meteorological Agency (AMeDAS network)
Direction de la Météorologie Nationale du Maroc (Casablanca validation)
Hornsea Project One, Hollandse Kust Noord, and Borssele Alpha offshore wind farms
The Ronin Institute for supporting independent scholarship

👤 Author & Principal Investigator

🌪️

Samir Baladi

Interdisciplinary AI Researcher

📧 gitdeeper@gmail.com

📞 +1 (614) 264-2074

🆔 0009-0003-8903-0029

GitLab GitHub

Ronin Institute / Rite of Renaissance

About the Author

Samir Baladi is an independent interdisciplinary researcher working at the intersection of artificial intelligence, earth system science, and complex systems modeling. Affiliated with the Ronin Institute — a global institution that supports rigorous scholarship outside the boundaries of traditional academic departments — his work rests on a single conviction: that the most consequential scientific breakthroughs of the 21st century will come not from deeper specialization, but from principled integration across disciplines that have long developed in parallel without sufficient communication.

Research Focus

Atmospheric Physics: Physics-Informed Neural Networks for kinetic energy mapping
Fluid Dynamics: Turbulence modeling, wake effects, and aero-elastic resilience
Multi-Parameter AI: Bayesian integration of heterogeneous data streams
Earth System Science: Cross-domain transfer learning (ocean ↔ atmosphere)

The Rite of Renaissance

AEROTICA is the fourth and final framework in the Rite of Renaissance series — a planetary monitoring architecture with a common computational language:

☄️ METEORICA

Extraterrestrial materials · Solar system formation

🌿 BIOTICA

Terrestrial ecosystem resilience · IBR index

🌊 ABYSSICA

Deep ocean kinetic energy · Biogeochemical cycling

🌪️ AEROTICA

Atmospheric kinetic energy · Aero-elastic resilience

Long-term Vision: GAIA

The long-term scientific ambition is their integration into GAIA (Global Anthropic Intelligence Architecture): a continuously updated, AI-generated assessment of the coupled state of the entire Earth system in near-real time. Currently in scoping phase (2027 →).

"Each framework is not merely a tool. It is a language — a principled, reproducible, open-source vocabulary for reading a different dimension of the physical world. AEROTICA is the language of the wind."