AeroForge™ Drone Propeller & Multi-Rotor Simulation Platform

An advanced simulation platform for drone propeller and multi-rotor systems, built as an Electron desktop application with a Python FastAPI backend. The platform provides physics-based simulations using multiple fidelity levels and supports AI-driven optimization with production-ready environmental effects modeling.

🚀 Features

Core Simulation Capabilities

• Multiple Physics Engines: BEMT (Blade Element Momentum Theory), VPM (Vortex Particle Method), LBM (Lattice Boltzmann Method)
• Cross-Platform GPU Acceleration: OpenCL-based solvers for NVIDIA, AMD, and integrated graphics
• AI-Powered Optimization: PINN (Physics-Informed Neural Networks) surrogate models with Bayesian optimization
• Multi-Rotor Arrays: Support for complex multi-rotor configurations
• Real-time 3D Visualization: Interactive Three.js-based propeller visualization

Environmental Effects (Phase 3 - Complete ✅)

• Weather Presets: 5 predefined weather conditions (Clear, Light Rain, Heavy Rain, Snow, Storm)
• Advanced Wind Modeling: Vector-based wind direction with crosswind effects, angle of attack changes, and stability analysis
• Gust & Turbulence Modeling: MIL-STD-1797 compliant gust profiles with Dryden turbulence spectrum
• Real-time Parameter Validation: Automatic warnings and errors for unsafe conditions
• 3D Environmental Visualization:
  • Rain particles simulation
  • Snow particles simulation
  • Wind vector visualization with gust indicators
• Comprehensive Environmental Controls:
  • Temperature (-50°C to +50°C)
  • Pressure (0-110,000 Pa)
  • Wind speed, direction, and gust parameters
  • Turbulence intensity and wind shear effects
  • Precipitation rate and type
  • Humidity percentage

Validation & Benchmarking (Phase 1 - Complete ✅)

• Comprehensive Validation Suite: Automated testing against experimental benchmarks
• Real UIUC PropDB Integration: 49 experimental propeller performance datasets from UIUC
• Regression Testing: Automated validation pipeline for continuous quality assurance
• Performance Benchmarking: Cross-platform GPU performance validation

Technical Features

• Production-Ready TypeScript: Full type safety with strict compilation
• Modern UI: React 18 with Tailwind CSS styling
• Database Integration: SQLAlchemy with HDF5 for large datasets
• RESTful API: FastAPI backend with comprehensive endpoints
• Cross-Platform: Windows, macOS, and Linux support via Electron

🏗️ Architecture

Frontend (Electron Renderer)

• React 18 with TypeScript for type safety
• Three.js for 3D visualization with React Three Fiber
• Tailwind CSS for modern, responsive UI
• Real-time parameter validation with visual feedback

Backend (FastAPI)

• REST API with automatic OpenAPI documentation
• Multiple physics solvers with automatic fidelity selection
• Database layer with SQLAlchemy ORM
• HDF5 integration for efficient large dataset handling

Database

• SQLite for configuration and metadata
• HDF5 for simulation results and large datasets
• Schema versioning and migration support

📋 Current Status

✅ Fully Implemented

• Phase 1 Core Physics (Complete ✅): VPM and LBM solvers with OpenCL GPU acceleration
• Phase 3 Environmental Effects (Complete ✅): Weather presets, precipitation, 3D visualization
• Electron desktop application framework
• React/TypeScript frontend with Three.js visualization
• FastAPI backend with routing
• BEMT physics solver (production-ready)
• Database schema and CRUD operations
• HDF5 data management
• AI/ML Components (PINN models, Bayesian optimization)
• Physics solver selection logic
• Validation Suite: Automated testing with real UIUC PropDB experimental benchmarks

⚠️ Partially Implemented

• Basic API authentication
• File export structure
• Multi-rotor wake interactions validation (Phase 7 complete - experimental correlation with quadcopter, hexacopter, and octocopter data)

❌ Placeholder/Incomplete

• Real UIUC PropDB integration (complete ✅ - 49 experimental datasets)
• Advanced multi-rotor wake interactions (implementation complete ✅ - Phases 1-7 done with experimental validation)
• PDF report generation

🚀 Next Steps

📋 Comprehensive Phase 1 Plan Available: See phase1_comprehensive_plan.md

📋 Multi-Rotor Wake Interactions Plan: See multi_rotor_wake_plan.md

✅ Phase 1 Core Physics: COMPLETE

• VPM/LBM solvers with OpenCL GPU acceleration
• Cross-platform compatibility (NVIDIA, AMD, integrated graphics)
• Optimized kernel performance (eliminated PyOpenCL warnings)
• Validation suite with automated testing

Current Priorities:

1. Real UIUC PropDB Integration: ✅ Complete - 49 experimental propeller datasets integrated
2. Multi-rotor Wake Interactions: ✅ PHASES 1-7 COMPLETE - Advanced rotor-rotor aerodynamic coupling with experimental validation implemented (14-week plan, all phases complete)
3. Export Functionality: PDF reports, CSV streaming, advanced data export
4. API Authentication: Production-ready security implementation

🧪 Validation Suite

AeroForge includes a comprehensive validation suite for ensuring physics solver accuracy:

Running Validation Tests

# Run validation for all solvers
python src/backend/scripts/validation_runner.py

# Run validation for specific solvers
python src/backend/scripts/validation_runner.py --solvers BEMT VPM

# Generate validation report
python src/backend/scripts/validation_runner.py --output-dir ./validation_reports

UIUC Propeller Database

The validation suite uses propeller performance benchmarks from the UIUC Propeller Database.

Current Implementation

• Real UIUC PropDB: ✅ 49 experimental propeller datasets from the official UIUC database
• Synthetic UIUC PropDB: Fallback synthetic data for development and testing
• 6 Propeller Configurations: APC-style propellers (10x4.5, 11x7, 12x6, 13x8, 14x10, 15x12)
• Performance Curves: Thrust, torque, power, efficiency across RPM and flight speed ranges

Real UIUC Data Integration ✅ Complete

The system has been successfully upgraded to use real experimental propeller data from the UIUC Propeller Database:

1. ✅ Downloaded UIUC PropDB: Complete dataset with 1,995+ propeller files across 4 volumes
2. ✅ Data Conversion: Automated conversion of UIUC .txt files to AeroForge JSON format
3. ✅ Database Integration: 49 experimental propeller datasets now available for validation
4. ✅ Validation Pipeline: Automatic detection and use of real data with synthetic fallback

Status: Real UIUC PropDB integration is complete and operational.

Expected Performance

• BEMT Solver: 5-10% error vs experimental data
• VPM Solver: 10-15% error (higher fidelity for complex flows)
• LBM Solver: 15-20% error (CFD accuracy for propeller flows)

Validation Reports

The validation runner generates:

• CSV Results: Detailed error metrics for each test case
• HTML Reports: Interactive charts and pass/fail summaries
• Statistical Analysis: Error distributions and performance trends

🚀 Getting Started

Prerequisites

• Node.js 18+ and npm
• Python 3.8+
• C++ compiler (for physics libraries)

Installation

1. Clone the repository

   git clone <repository-url>
   cd aero-forge-simulation

2. Install Python dependencies

   pip install -r requirements.txt

3. Install Node.js dependencies

   npm install

4. Build the application

   npm run build

5. Start the development server

   npm start

🔧 Development

Available Scripts

• npm start - Start development mode (React + Electron)
• npm run build - Build for production
• npm run build:react - Build React frontend only
• npm run build:electron - Build Electron main process
• npm run package - Create distributable packages

Project Structure

src/
├── main.ts                 # Electron main process
├── preload.ts              # Electron preload script
├── renderer/
│   ├── App.tsx            # Main React application
│   ├── components/
│   │   └── ThreeDViewer.tsx # 3D visualization component
│   ├── services/
│   │   └── api.ts         # API client
│   └── styles/
│       └── index.css      # Global styles
└── backend/
    ├── main.py            # FastAPI application
    ├── routers/           # API route handlers
    ├── physics/           # Physics solvers
    ├── database/          # Database models and CRUD
    └── ai/                # AI/ML components

🌟 Environmental Effects Features

Weather Presets

The application includes 5 predefined weather conditions:

• Clear: Standard atmospheric conditions
• Light Rain: 2.5 mm/h precipitation, 85% humidity
• Heavy Rain: 15 mm/h precipitation, 95% humidity
• Snow: 1 mm/h precipitation, -5°C temperature
• Storm: 25 mm/h precipitation, 15 m/s wind speed

Parameter Validation

Real-time validation provides:

• Warnings: For potentially unsafe conditions (e.g., high tip speeds, extreme temperatures)
• Errors: For invalid parameters (e.g., negative pressure, humidity > 100%)

3D Visualization

Environmental effects are rendered in real-time:

• Rain particles: Animated droplets with realistic physics
• Snow particles: Falling snowflakes with accumulation effects
• Wind vectors: Directional arrows showing wind speed and direction

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📄 License

AeroForge is licensed under the GNU Affero General Public License v3 (AGPLv3).
See LICENSE for details.

Commercial Use:
If you wish to use AeroForge (or any modifications) in a closed-source product or service without releasing your own source code under AGPLv3, a separate commercial license is required.
Contact ed.j.bentley@gmail.com for pricing and terms.

🙏 Acknowledgments

• Built with Electron, React, Three.js, and FastAPI
• Physics models based on established aerospace engineering principles
• Environmental effects inspired by FAA and meteorological standards

---

AeroForge™ - Advanced Drone Simulation for the Modern Age