Aetheris: Predictive Adaptive Optics

An ultra-low latency, AI-driven wavefront reconstruction and prediction engine designed for high-performance astronomical adaptive optics.
Aetheris utilizes a dual-network architecture to bypass hardware servo-lag and resolve chaotic focal-plane aberrations instantly, ensuring stable optical communications in severe atmospheric turbulence.

---

🛰️ The Problem & Our Solution

Modern Adaptive Optics (AO) systems suffer from two catastrophic failure modes in extreme environments:

1. Spatial Cross-Talk: In severe turbulence, adjacent focal spots on a Shack-Hartmann Wavefront Sensor break apart and merge. Classical Center-of-Gravity algorithms fail entirely, corrupting the correction geometry.
2. Temporal Servo Lag: Physical Deformable Mirrors (DM) take ~10ms to actuate. In fast jet streams, the atmosphere shifts before the mirror bends, meaning the AO system continuously corrects for past turbulence.

The Aetheris Solution: We replace brittle classical algorithms with a Hybrid AI pipeline. A deep CNN decodes the fully non-linear spatial cross-talk holographically, while a sequential LSTM forecasts the exact state of the atmosphere 10ms into the future ($t_{+1}$). The mirror receives the future wavefront shape, achieving perfect physical synchronicity.

---

🌌 Architecture Overview

The Aetheris codebase is split into 4 high-performance components:

1. The Physics Engine (Synthetic Reality): A custom C++ optical simulator that models infinite-treadmill Kolmogorov turbulence screens, Fresnel scintillation, and finite-exposure motion blur. We use this to generate infinite domain-randomized training data with absolute ground truth.
2. The AI Brain (Spatial + Temporal):
   • ResNet-18 (Spatial): Reconstructs 50 simultaneous high-order Zernike polynomials directly from raw, cross-talking camera focal frames.
   • LSTM (Temporal): Ingests a rolling 5-frame temporal window to map wind-shear vectors and mathematically predict the +10ms future wavefront.
3. The Nerve Center (End-to-End Execution): An ultra-low latency C++ execution loop powered by LibTorch and Eigen. It utilizes a dual-platform hardware abstraction layer (Apple Silicon MPS & Nvidia CUDA), FP16 half-precision downcasting, and Zero-Copy Eigen memory mapping to compute the final DM actuator voltage vector in ~5.5ms (including heavily multithreaded disk I/O).
4. The Safety Net (Classical Fallback): A highly optimized, standalone C++ Center-of-Gravity (CoG) centroiding engine designed to take over seamlessly if non-linear AI inference fails.

---

📊 Benchmark Results

Aetheris was subjected to a rigorous zero-shot CLI evaluation on completely unseen holdout data featuring extreme wind shear ($17.5$ m/s) and severe spatial distortion ($r_0 = 0.075$m).

Note: Global Piston (Z1) is mathematically unobservable by Shack-Hartmann slope sensors. To prevent penalizing the AI for physical constraints, Z1 is explicitly zeroed-out and excluded from the scoring matrix.

Metric	Result	Target Threshold	Status
ML Accuracy (RMSE)	0.8314 rad	< 1.5 rad	✅ PASSED
ML Precision (Std Dev)	0.8314 rad	< 1.0 rad	✅ PASSED
Execution Latency (Avg)	5.53 ms	< 15.0 ms	✅ PASSED
Worst-Case Latency (P99)	8.03 ms	< 15.0 ms	✅ PASSED

---

🚀 Quick Start Guide

1. Compile the C++ Nerve Center

Requires CMake 3.15+, C++17, OpenCV 4, and LibTorch.

cmake -B build -DCMAKE_PREFIX_PATH=/path/to/libtorch -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(sysctl -n hw.ncpu)

2. Run the C++ Inference Kernel

Run the compiled LibTorch engine on a generated dataset sequence.

# Force single-threaded execution to prevent OpenMP collisions
export KMP_DUPLICATE_LIB_OK=TRUE
export OMP_NUM_THREADS=1

./build/Aetheris_Loop --test-dir Dataset_Master/Run_Wind_10ms_r0_11.00cm

3. Launch the Telemetry Dashboard

A real-time, interactive Streamlit Mission Control UI visualizing the AI's physical 3D phase reconstruction.

pip install streamlit plotly pandas numpy matplotlib
streamlit run dashboard.py

4. Execute the ML Benchmark Suite

Automatically generates unseen extreme-turbulence data, executes the C++ kernel, and calculates the True RMSE.

python cli_benchmark.py