FusionWareAlttex

Gravitational Wave Detection via Atomic Vapor Cells: A Quantum Simulation and Deep Learning Framework

📋 Table of Contents

Overview
Key Features
Project Structure
Quick Start
Dataset Generation
Model Training
Model Architecture
Real-time Analysis
Performance
Roadmap
Authors
License
Citation
Contact
Acknowledgments

📋 Overview

FusionWareAlttex is a comprehensive open-source framework for theoretical modeling and simulation-based analysis of ultra-weak space-time perturbations in atomic vapor systems. This project investigates the quantum response of rubidium (Rb) atomic vapor cells to gravitational wave-induced strain perturbations, combining advanced quantum simulation techniques with state-of-the-art deep learning architectures.

The framework provides a complete pipeline from first-principles quantum modeling through synthetic dataset generation to real-time AI-powered signal detection and classification, with optional integration with LIGO/Virgo gravitational wave observatory data.

🎯 Key Features

Feature	Description
🔬 Quantum Simulation	First-principles modeling of Rb atomic vapor cell dynamics using QuTiP
🧠 Deep Learning	Custom CNN-Transformer architecture for signal/noise classification
⚡ High Performance	Parallel dataset generation, multi-GPU training, mixed precision
📡 Real-time Analysis	LIGO/Virgo integration with live visualization dashboard
🛠️ Hardware Ready	Complete serial protocol for prototype detector calibration
📊 Sensitivity Analysis	Minimum detectable strain: 8.7 × 10⁻²² at SNR = 1

📁 Project Structure

FusionWareAlttex/
│
├── 📁 stage1_simulation/           # QUANTUM SIMULATION ENGINE
│   ├── rubidium_cell.py           # Rb atomic vapor cell class with Lindblad master equation
│   ├── gw_signal.py              # Gravitational wave signal generator (sine, chirp, burst)
│   ├── generate_dataset.py       # Single-threaded dataset generation
│   └── generate_dataset_parallel.py # Multi-core parallel dataset generation
│
├── 📁 stage2_ai_model/            # DEEP LEARNING PIPELINE
│   ├── model.py                  # CNN-Transformer architecture (8.2M parameters)
│   ├── train.py                  # Standard training script
│   ├── train_optimized.py        # Optimized training with AMP, compile, multi-GPU
│   └── checkpoints/              # Pre-trained models (best_model.pth, final_model.pth)
│
├── 📁 stage3_detector/           # HARDWARE INTERFACE
│   ├── detector_interface.py    # Serial protocol for prototype detector
│   └── calibrate.py            # Piezoelectric calibration pipeline
│
├── 📁 stage4_integration/       # REAL-TIME ANALYSIS SYSTEM
│   ├── realtime_analyzer.py    # Multi-threaded inference engine
│   ├── ligo_client.py         # GraceDB API client for LIGO/Virgo cross-reference
│   ├── visualizer.py          # Real-time matplotlib visualization
│   └── main.py               # Application entry point
│
├── 📁 config/                  # CONFIGURATION
│   └── config.yaml          # Global parameters (simulation, model, detector)
│
├── 📁 utils/                 # UTILITY MODULES
│   ├── config_loader.py    # YAML configuration parser
│   └── data_utils.py       # HDF5 I/O operations
│
├── 📁 docs/                 # DOCUMENTATION
│   ├── QUICKSTART.md      # Quick start guide
│   ├── SYSTEM_REQUIREMENTS.md # Hardware/software requirements
│   └── PERFORMANCE_GUIDE.md # Optimization guide
│
├── 📁 tests/              # UNIT TESTS
├── 📁 scripts/           # AUXILIARY SCRIPTS
├── requirements.txt     # Python dependencies
├── LICENSE            # MIT License
└── README.md         # This file

🚀 Quick Start

Prerequisites

# System requirements
Python 3.8+
CUDA 11.0+ (optional, for GPU acceleration)
8GB+ RAM (16GB+ recommended)
4+ CPU cores (8+ recommended)

Installation

# 1. Clone repository
git clone https://github.com/AehoraDeSum/FusionWareAlttex.git
cd FusionWareAlttex

# 2. Create virtual environment (recommended)
python -m venv venv
source venv/bin/activate  # Linux/Mac
# venv\Scripts\activate   # Windows

# 3. Install dependencies
pip install --upgrade pip
pip install -r requirements.txt

# 4. Verify installation
python -c "import qutip; import torch; print(f'QuTiP: {qutip.__version__}'); print(f'PyTorch: {torch.__version__}')"

📊 Dataset Generation

Generate Small Test Dataset (100 samples)

python stage1_simulation/generate_dataset.py \
    --num_samples 100 \
    --time_steps 500 \
    --dt 0.001 \
    --output data/test_dataset.h5

Generate Full Dataset with Parallel Processing (10,000 samples)

python stage1_simulation/generate_dataset_parallel.py \
    --num_samples 10000 \
    --time_steps 1000 \
    --dt 0.001 \
    --workers 8 \
    --output data/quantum_response.h5

Dataset Specifications:

Parameter	Value
Samples	10,000 (50% signal, 50% noise)
Time steps	1,000 per sample
Duration	1 second
Frequency range	10 - 1000 Hz
Strain amplitude	1e-21 - 1e-19
Noise level	1e-22

🤖 Model Training

Standard Training (CPU)

python stage2_ai_model/train.py \
    --data data/quantum_response.h5 \
    --epochs 50 \
    --batch_size 32 \
    --lr 0.001 \
    --checkpoint_dir stage2_ai_model/checkpoints

Optimized Training (GPU + AMP + Compile)

python stage2_ai_model/train_optimized.py \
    --data data/quantum_response.h5 \
    --epochs 50 \
    --batch_size 64 \
    --workers 8 \
    --lr 0.001 \
    --use_amp \
    --use_compile \
    --checkpoint_dir stage2_ai_model/checkpoints

🧠 Model Architecture

┌─────────────────────────────────────────────────────────┐
│                    GWDetectorModel                      │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  Input: [batch_size, 1, 1000]                          │
│         (Normalized time series)                       │
│                                                         │
│  ▼                                                     │
│  ┌─────────────────────┐                              │
│  │    CNN Encoder      │ 3x Conv1D layers            │
│  │   [64, 128, 256]    │ Kernel sizes: [7, 5, 3]     │
│  └─────────┬───────────┘                              │
│            ▼                                          │
│  ┌─────────────────────┐                              │
│  │ Linear Projection   │ 256 → 512                   │
│  └─────────┬───────────┘                              │
│            ▼                                          │
│  ┌─────────────────────┐                              │
│  │ Positional Encoding │ Sequence position info      │
│  └─────────┬───────────┘                              │
│            ▼                                          │
│  ┌─────────────────────┐                              │
│  │ Transformer Encoder │ 4 layers, 8 heads           │
│  │   d_model=512       │ FFN=2048, Dropout=0.1      │
│  └─────────┬───────────┘                              │
│            ▼                                          │
│  ┌─────────────────────┐                              │
│  │  Global Avg Pool    │ Sequence → Vector           │
│  └─────────┬───────────┘                              │
│            ▼                                          │
│  ┌─────────────────────┐                              │
│  │    Classifier       │ 512 → 256 → 2              │
│  └─────────┬───────────┘                              │
│            ▼                                          │
│  Output: [batch_size, 2] (noise/signal logits)       │
│                                                         │
└─────────────────────────────────────────────────────────┘

Model Specifications:

Component	Parameter	Value
CNN	Layers	3
	Channels	[64, 128, 256]
	Kernel sizes	[7, 5, 3]
Transformer	Layers	4
	Attention heads	8
	Embedding dim	512
	FF dimension	2048
Total	Parameters	8.2M
	FLOPs	1.2G

📡 Real-time Analysis

Simulation Mode (No Hardware Required)

python stage4_integration/main.py \
    --model stage2_ai_model/checkpoints/best_model.pth

Hardware Mode (With Prototype Detector)

python stage4_integration/main.py \
    --model stage2_ai_model/checkpoints/best_model.pth \
    --device /dev/ttyUSB0

LIGO/Virgo Integration

from stage4_integration.ligo_client import LIGOClient

# Initialize client
client = LIGOClient(base_url="https://gracedb.ligo.org/api/")

# Get recent events
events = client.get_recent_events(hours=24, min_false_alarm_rate=1e-6)

# Cross-reference local detection
match = client.cross_reference(
    detection_time=timestamp,
    time_tolerance=timedelta(seconds=10)
)

📊 Performance

Model Performance Metrics

Metric	Value	95% Confidence Interval
Accuracy	96.8%	[96.2, 97.4]
Precision	96.5%	[95.8, 97.2]
Recall	96.2%	[95.4, 97.0]
F1-Score	96.3%	[95.6, 97.0]
AUC-ROC	0.994	[0.992, 0.996]

Sensitivity Analysis

Minimum Detectable Strain (SNR = 1):

Noise Level	Strain Amplitude	Integration Time
Ideal (no noise)	3.2 × 10⁻²²	1 ms
Low (1e-22)	8.7 × 10⁻²²	1 s
Medium (1e-21)	4.1 × 10⁻²¹	1 s
High (1e-20)	2.3 × 10⁻²⁰	10 s

Training Speed (50 epochs)

Hardware	Configuration	Time	Speedup
CPU (i9-12900K)	16 threads	187 min	1.0×
GPU (RTX 4090)	FP32	24 min	7.8×
GPU (RTX 4090)	AMP + compile	16 min	11.7×
GPU (2× A100)	AMP + DP	9 min	20.8×

📈 Roadmap

✅ Phase 1: Foundation (Completed)

Theoretical quantum model derivation
Lindblad master equation implementation
Single-threaded simulation engine
Basic CNN classifier

✅ Phase 2: Optimization (Completed)

Parallel dataset generation
Transformer architecture integration
Mixed precision training
Multi-GPU support

✅ Phase 3: Real-time System (Completed)

Multi-threaded inference pipeline
LIGO/Virgo API integration
Real-time visualization
Hardware interface protocol

🔄 Phase 4: Validation (In Progress)

Experimental validation with table-top prototype
Comparison with LIGO open data
Alternative atomic species (Cs, K)

📅 Phase 5: Production (Planned)

Distributed sensor network simulation
Quantum noise suppression algorithms
FPGA deployment for real-time inference

👥 Authors

Principal Investigator

Yiğit Yardımcı
Independent Researcher
📧 yigityardimci01@gmail.com
🐙 @AehoraDeSum
🔗 GitHub Profile

Contributions:

Theoretical framework development
Quantum simulation implementation
Deep learning architecture design
System integration and optimization

Academic Mentor

Prof. Hasan Tatlıpınar
Department of Physics, Yıldız Technical University
🔗 avesis.yildiz.edu.tr/htatli
📧 htatli@yildiz.edu.tr

Contributions:

Theoretical physics consultation
Quantum optics expertise
Research methodology guidance

📄 License

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

MIT License

Copyright (c) 2026 Yiğit Yardımcı

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.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

📌 Citation

If you use FusionWareAlttex in your research, please cite:

@software{yardimci2026fusionwarealttex,
  author = {Yardımcı, Yiğit and Tatlıpınar, Hasan},
  title = {FusionWareAlttex: Gravitational Wave Detection via Atomic Vapor Cells},
  year = {2026},
  publisher = {GitHub},
  journal = {GitHub Repository},
  howpublished = {\url{https://github.com/AehoraDeSum/FusionWareAlttex}},
  doi = {10.5281/zenodo.18624476}
}

📞 Contact

Yiğit Yardımcı
📧 yigityardimci01@gmail.com
🐙 @AehoraDeSum

Prof. Hasan Tatlıpınar
📧 htatli@yildiz.edu.tr
🔗 avesis.yildiz.edu.tr/htatli

🙏 Acknowledgments

The authors gratefully acknowledge:

QuTiP Development Team for the open-source quantum simulation framework
LIGO Scientific Collaboration for public gravitational wave data archives
PyTorch Team for the deep learning ecosystem
Yıldız Technical University Department of Physics for academic support

Name		Name	Last commit message	Last commit date
config		config
data		data
stage1_simulation		stage1_simulation
stage2_ai_model		stage2_ai_model
stage3_detector		stage3_detector
stage4_integration		stage4_integration
utils		utils
LICENSE		LICENSE
README.md		README.md
SYSTEM_REQUIREMENTS.md		SYSTEM_REQUIREMENTS.md
requirements.txt		requirements.txt

Latest commit

History

Folders and files

Repository files navigation