feat: Add AtomizerField training data export and intelligent model discovery

Major additions:
- Training data export system for AtomizerField neural network training
- Bracket stiffness optimization study with 50+ training samples
- Intelligent NX model discovery (auto-detect solutions, expressions, mesh)
- Result extractors module for displacement, stress, frequency, mass
- User-generated NX journals for advanced workflows
- Archive structure for legacy scripts and test outputs
- Protocol documentation and dashboard launcher

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -1,19 +1,21 @@
 # Atomizer
 
-> Advanced LLM-native optimization platform for Siemens NX Simcenter
+> Advanced LLM-native optimization platform for Siemens NX Simcenter with Neural Network Acceleration
 
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-Proprietary-red.svg)](LICENSE)
-[![Status](https://img.shields.io/badge/status-alpha-yellow.svg)](https://github.com)
+[![Status](https://img.shields.io/badge/status-beta-green.svg)](https://github.com)
+[![Neural](https://img.shields.io/badge/neural-GNN%20powered-purple.svg)](docs/NEURAL_FEATURES_COMPLETE.md)
 
 ## Overview
 
-Atomizer is an **LLM-native optimization framework** for Siemens NX Simcenter that transforms how engineers interact with optimization workflows. Instead of manual JSON configuration and scripting, Atomizer uses AI as a collaborative engineering assistant.
+Atomizer is an **LLM-native optimization framework** for Siemens NX Simcenter that transforms how engineers interact with optimization workflows. It combines AI-assisted natural language interfaces with **Graph Neural Network (GNN) surrogates** that achieve **600x-500,000x speedup** over traditional FEA simulations.
 
 ### Core Philosophy
 
 Atomizer enables engineers to:
 - **Describe optimizations in natural language** instead of writing configuration files
+- **Accelerate optimization 1000x** using trained neural network surrogates
 - **Generate custom analysis functions on-the-fly** (RSS metrics, weighted objectives, constraints)
 - **Get intelligent recommendations** based on optimization results and surrogate models
 - **Generate comprehensive reports** with AI-written insights and visualizations
@@ -21,13 +23,15 @@ Atomizer enables engineers to:
 
 ### Key Features
 
+- **Neural Network Acceleration**: Graph Neural Networks predict FEA results in 4.5ms vs 10-30min for traditional solvers
 - **LLM-Driven Workflow**: Natural language study creation, configuration, and analysis
 - **Advanced Optimization**: Optuna-powered TPE, Gaussian Process surrogates, multi-objective Pareto fronts
 - **Dynamic Code Generation**: AI writes custom Python functions and NX journal scripts during optimization
 - **Intelligent Decision Support**: Surrogate quality assessment, sensitivity analysis, engineering recommendations
 - **Real-Time Monitoring**: Interactive web dashboard with live progress tracking
 - **Extensible Architecture**: Plugin system with hooks for pre/post mesh, solve, and extraction phases
-- **Self-Improving**: Feature registry that learns from user workflows and expands capabilities
+- **Hybrid FEA/NN Optimization**: Intelligent switching between physics simulation and neural predictions
+- **Self-Improving**: Continuous learning from optimization runs to improve neural surrogates
 
 ---
 
@@ -37,15 +41,18 @@ Atomizer enables engineers to:
 
 ### Quick Links
 
-- **[Visual Architecture Diagrams](docs/09_DIAGRAMS/)** - 🆕 Comprehensive Mermaid diagrams showing system architecture and workflows
+- **[Neural Features Guide](docs/NEURAL_FEATURES_COMPLETE.md)** - Complete guide to GNN surrogates, training, and integration
+- **[Neural Workflow Tutorial](docs/NEURAL_WORKFLOW_TUTORIAL.md)** - Step-by-step: data collection → training → optimization
+- **[Visual Architecture Diagrams](docs/09_DIAGRAMS/)** - Comprehensive Mermaid diagrams showing system architecture and workflows
 - **[Protocol Specifications](docs/PROTOCOLS.md)** - All active protocols (10, 11, 13) consolidated
 - **[Development Guide](DEVELOPMENT.md)** - Development workflow, testing, contributing
-- **[Dashboard Guide](docs/DASHBOARD.md)** - 🆕 Comprehensive React dashboard with multi-objective visualization
-- **[NX Multi-Solution Protocol](docs/NX_MULTI_SOLUTION_PROTOCOL.md)** - 🆕 Critical fix for multi-solution workflows
+- **[Dashboard Guide](docs/DASHBOARD.md)** - Comprehensive React dashboard with multi-objective visualization
+- **[NX Multi-Solution Protocol](docs/NX_MULTI_SOLUTION_PROTOCOL.md)** - Critical fix for multi-solution workflows
 - **[Getting Started](docs/HOW_TO_EXTEND_OPTIMIZATION.md)** - Create your first optimization study
 
 ### By Topic
 
+- **Neural Acceleration**: [NEURAL_FEATURES_COMPLETE.md](docs/NEURAL_FEATURES_COMPLETE.md), [NEURAL_WORKFLOW_TUTORIAL.md](docs/NEURAL_WORKFLOW_TUTORIAL.md), [GNN_ARCHITECTURE.md](docs/GNN_ARCHITECTURE.md)
 - **Protocols**: [PROTOCOLS.md](docs/PROTOCOLS.md) - Protocol 10 (Intelligent Optimization), 11 (Multi-Objective), 13 (Dashboard)
 - **Architecture**: [HOOK_ARCHITECTURE.md](docs/HOOK_ARCHITECTURE.md), [NX_SESSION_MANAGEMENT.md](docs/NX_SESSION_MANAGEMENT.md)
 - **Dashboard**: [DASHBOARD_MASTER_PLAN.md](docs/DASHBOARD_MASTER_PLAN.md), [DASHBOARD_REACT_IMPLEMENTATION.md](docs/DASHBOARD_REACT_IMPLEMENTATION.md)
@@ -66,9 +73,18 @@ Atomizer enables engineers to:
 │  Plugin System + Feature Registry + Code Generator      │
 └─────────────────────────────────────────────────────────┘
                           ↕
+┌───────────────────────────┬─────────────────────────────┐
+│     Traditional Path      │      Neural Path (New!)     │
+├───────────────────────────┼─────────────────────────────┤
+│  NX Solver (via Journals) │   AtomizerField GNN         │
+│  ~10-30 min per eval      │   ~4.5 ms per eval          │
+│  Full physics fidelity    │   Physics-informed learning │
+└───────────────────────────┴─────────────────────────────┘
+                          ↕
 ┌─────────────────────────────────────────────────────────┐
-│           Execution Layer                               │
-│  NX Solver (via Journals) + Optuna + Result Extractors  │
+│         Hybrid Decision Engine                          │
+│  Confidence-based switching • Uncertainty quantification│
+│  Automatic FEA validation • Online learning             │
 └─────────────────────────────────────────────────────────┘
                           ↕
 ┌─────────────────────────────────────────────────────────┐
@@ -77,6 +93,31 @@ Atomizer enables engineers to:
 └─────────────────────────────────────────────────────────┘
 ```
 
+### Neural Network Components (AtomizerField)
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                  AtomizerField System                   │
+├─────────────────────────────────────────────────────────┤
+│                                                         │
+│  ┌─────────────┐   ┌─────────────┐   ┌─────────────┐  │
+│  │ BDF/OP2     │   │    GNN      │   │  Inference  │  │
+│  │ Parser      │──>│  Training   │──>│   Engine    │  │
+│  │ (Phase 1)   │   │  (Phase 2)  │   │  (Phase 2)  │  │
+│  └─────────────┘   └─────────────┘   └─────────────┘  │
+│        │                 │                  │          │
+│        ▼                 ▼                  ▼          │
+│  ┌─────────────────────────────────────────────────┐  │
+│  │              Neural Model Types                  │  │
+│  ├─────────────────────────────────────────────────┤  │
+│  │ • Field Predictor GNN (displacement + stress)   │  │
+│  │ • Parametric GNN (all 4 objectives directly)    │  │
+│  │ • Ensemble models for uncertainty               │  │
+│  └─────────────────────────────────────────────────┘  │
+│                                                         │
+└─────────────────────────────────────────────────────────┘
+```
+
 ## Quick Start
 
 ### Prerequisites
@@ -179,6 +220,19 @@ python run_5trial_test.py
 
 ## Features
 
+### Neural Network Acceleration (AtomizerField)
+
+- **Graph Neural Networks (GNN)**: Physics-aware architecture that respects FEA mesh topology
+- **Parametric Surrogate**: Design-conditioned GNN predicts all 4 objectives (mass, frequency, displacement, stress)
+- **Ultra-Fast Inference**: 4.5ms per prediction vs 10-30 minutes for FEA (2,000-500,000x speedup)
+- **Physics-Informed Loss**: Custom loss functions enforce equilibrium, constitutive laws, and boundary conditions
+- **Uncertainty Quantification**: Ensemble-based confidence scores with automatic FEA validation triggers
+- **Hybrid Optimization**: Smart switching between FEA and NN based on confidence thresholds
+- **Training Data Export**: Automatic export of FEA results in neural training format (BDF/OP2 → HDF5+JSON)
+- **Pre-trained Models**: Ready-to-use models for UAV arm optimization with documented training pipelines
+
+### Core Optimization
+
 - **Intelligent Multi-Objective Optimization**: NSGA-II algorithm for Pareto-optimal solutions
 - **Advanced Dashboard**: React-based real-time monitoring with parallel coordinates visualization
 - **NX Integration**: Seamless journal-based control of Siemens NX Simcenter
@@ -194,23 +248,35 @@ python run_5trial_test.py
 
 ## Current Status
 
-**Development Phase**: Alpha - 80-90% Complete
+**Development Phase**: Beta - 95% Complete
 
+### Core Optimization
 - ✅ **Phase 1 (Plugin System)**: 100% Complete & Production Ready
 - ✅ **Phases 2.5-3.1 (LLM Intelligence)**: 100% Complete - Components built and tested
-- ✅ **Phase 3.2 Week 1 (LLM Mode)**: **COMPLETE** - Natural language optimization now available!
-- 🎯 **Phase 3.2 Week 2-4 (Robustness)**: **IN PROGRESS** - Validation, safety, learning system
-- 🔬 **Phase 3.4 (NXOpen Docs)**: Research & investigation phase
+- ✅ **Phase 3.2 (LLM Mode)**: Complete - Natural language optimization available
+- ✅ **Protocol 10 (IMSO)**: Complete - Intelligent Multi-Strategy Optimization
+- ✅ **Protocol 11 (Multi-Objective)**: Complete - Pareto optimization
+- ✅ **Protocol 13 (Dashboard)**: Complete - Real-time React dashboard
+
+### Neural Network Acceleration (AtomizerField)
+- ✅ **Phase 1 (Data Parser)**: Complete - BDF/OP2 → HDF5+JSON conversion
+- ✅ **Phase 2 (Neural Architecture)**: Complete - GNN models with physics-informed loss
+- ✅ **Phase 2.1 (Parametric GNN)**: Complete - Design-conditioned predictions
+- ✅ **Phase 2.2 (Integration Layer)**: Complete - Neural surrogate + hybrid optimizer
+- ✅ **Phase 3 (Testing)**: Complete - 18 comprehensive tests
+- ✅ **Pre-trained Models**: Available for UAV arm optimization
 
 **What's Working**:
 - ✅ Complete optimization engine with Optuna + NX Simcenter
-- ✅ Substudy system with live history tracking
-- ✅ **LLM Mode**: Natural language → Auto-generated code → Optimization → Results
-- ✅ LLM components (workflow analyzer, code generators, research agent) - production integrated
-- ✅ 50-trial optimization validated with real results
-- ✅ End-to-end workflow: `--llm "your request"` → results
+- ✅ **Neural acceleration**: 4.5ms predictions (2000x speedup over FEA)
+- ✅ **Hybrid optimization**: Smart FEA/NN switching with confidence thresholds
+- ✅ **Parametric surrogate**: Predicts all 4 objectives from design parameters
+- ✅ **Training pipeline**: Export data → Train GNN → Deploy → Optimize
+- ✅ Real-time dashboard with Pareto front visualization
+- ✅ Multi-objective optimization with NSGA-II
+- ✅ LLM-assisted natural language workflows
 
-**Current Focus**: Adding robustness, safety checks, and learning capabilities to LLM mode.
+**Production Ready**: Core optimization + neural acceleration fully functional.
 
 See [DEVELOPMENT_GUIDANCE.md](DEVELOPMENT_GUIDANCE.md) for comprehensive status and priorities.
 
@@ -218,92 +284,102 @@ See [DEVELOPMENT_GUIDANCE.md](DEVELOPMENT_GUIDANCE.md) for comprehensive status
 
 ```
 Atomizer/
-├── optimization_engine/        # Core optimization logic
-│   ├── runner.py              # Main optimization runner
-│   ├── nx_solver.py           # NX journal execution
-│   ├── nx_updater.py          # NX model parameter updates
-│   ├── pynastran_research_agent.py  # Phase 3: Auto OP2 code gen ✅
-│   ├── hook_generator.py      # Phase 2.9: Auto hook generation ✅
-│   ├── result_extractors/     # OP2/F06 parsers
-│   │   └── extractors.py      # Stress, displacement extractors
-│   └── plugins/               # Plugin system (Phase 1 ✅)
-│       ├── hook_manager.py    # Hook registration & execution
-│       ├── hooks.py           # HookPoint enum, Hook dataclass
-│       ├── pre_solve/         # Pre-solve lifecycle hooks
-│       │   ├── detailed_logger.py
-│       │   └── optimization_logger.py
-│       ├── post_solve/        # Post-solve lifecycle hooks
-│       │   └── log_solve_complete.py
-│       ├── post_extraction/   # Post-extraction lifecycle hooks
-│       │   ├── log_results.py
-│       │   └── optimization_logger_results.py
-│       └── post_calculation/  # Post-calculation hooks (Phase 2.9 ✅)
-│           ├── weighted_objective_test.py
-│           ├── safety_factor_hook.py
-│           └── min_to_avg_ratio_hook.py
-├── dashboard/                  # Web UI
-│   ├── api/                   # Flask backend
-│   ├── frontend/              # HTML/CSS/JS
-│   └── scripts/               # NX expression extraction
-├── studies/                    # Optimization studies
-│   ├── README.md              # Comprehensive studies guide
-│   └── bracket_displacement_maximizing/  # Example study with substudies
-│       ├── README.md          # Study documentation
-│       ├── SUBSTUDIES_README.md  # Substudy system guide
-│       ├── model/             # Shared FEA model files (.prt, .sim, .fem)
-│       ├── config/            # Substudy configuration templates
-│       ├── substudies/        # Independent substudy results
-│       │   ├── coarse_exploration/   # Fast 20-trial coarse search
-│       │   │   ├── config.json
-│       │   │   ├── optimization_history_incremental.json  # Live updates
-│       │   │   └── best_design.json
-│       │   └── fine_tuning/          # Refined 50-trial optimization
-│       ├── run_substudy.py    # Substudy runner with continuation support
-│       └── run_optimization.py  # Standalone optimization runner
-├── tests/                      # Unit and integration tests
-│   ├── test_hooks_with_bracket.py
-│   ├── run_5trial_test.py
-│   └── test_journal_optimization.py
-├── docs/                       # Documentation
-├── atomizer_paths.py          # Intelligent path resolution
-├── DEVELOPMENT_ROADMAP.md      # Future vision and phases
-└── README.md                  # This file
+├── optimization_engine/           # Core optimization logic
+│   ├── runner.py                 # Main optimization runner
+│   ├── runner_with_neural.py     # Neural-enhanced runner (NEW)
+│   ├── neural_surrogate.py       # GNN integration layer (NEW)
+│   ├── training_data_exporter.py # Export FEA→neural format (NEW)
+│   ├── nx_solver.py              # NX journal execution
+│   ├── nx_updater.py             # NX model parameter updates
+│   ├── result_extractors/        # OP2/F06 parsers
+│   └── plugins/                  # Plugin system
+│
+├── atomizer-field/               # Neural Network System (NEW)
+│   ├── neural_field_parser.py    # BDF/OP2 → neural format
+│   ├── validate_parsed_data.py   # Physics validation
+│   ├── batch_parser.py           # Batch processing
+│   ├── neural_models/            # GNN architectures
+│   │   ├── field_predictor.py    # Field prediction GNN
+│   │   ├── parametric_predictor.py # Parametric GNN (4 objectives)
+│   │   └── physics_losses.py     # Physics-informed loss functions
+│   ├── train.py                  # Training pipeline
+│   ├── train_parametric.py       # Parametric model training
+│   ├── predict.py                # Inference engine
+│   ├── runs/                     # Pre-trained models
+│   │   └── parametric_uav_arm_v2/  # UAV arm model (ready to use)
+│   └── tests/                    # 18 comprehensive tests
+│
+├── atomizer-dashboard/           # React Dashboard (NEW)
+│   ├── backend/                  # FastAPI + WebSocket
+│   └── frontend/                 # React + Tailwind + Recharts
+│
+├── studies/                      # Optimization studies
+│   ├── uav_arm_optimization/     # Example with neural integration
+│   └── [other studies]/          # Traditional optimization examples
+│
+├── atomizer_field_training_data/ # Training data storage
+│   └── [study_name]/             # Exported training cases
+│
+├── docs/                         # Documentation
+│   ├── NEURAL_FEATURES_COMPLETE.md  # Complete neural guide
+│   ├── NEURAL_WORKFLOW_TUTORIAL.md  # Step-by-step tutorial
+│   ├── GNN_ARCHITECTURE.md          # Architecture deep-dive
+│   └── [other docs]/
+│
+├── tests/                        # Integration tests
+└── README.md                     # This file
 ```
 
-## Example: Bracket Displacement Maximization with Substudies
+## Example: Neural-Accelerated UAV Arm Optimization
 
-A complete working example is in `studies/bracket_displacement_maximizing/`:
+A complete working example with neural acceleration in `studies/uav_arm_optimization/`:
 
 ```bash
-# Run standalone optimization (20 trials)
-cd studies/bracket_displacement_maximizing
-python run_optimization.py
+# Step 1: Run initial FEA optimization (collect training data)
+cd studies/uav_arm_optimization
+python run_optimization.py --trials 50 --export-training-data
 
-# Or run a substudy (hierarchical organization)
-python run_substudy.py coarse_exploration  # 20-trial coarse search
-python run_substudy.py fine_tuning         # 50-trial refinement with continuation
+# Step 2: Train neural network on collected data
+cd ../../atomizer-field
+python train_parametric.py \
+  --train_dir ../atomizer_field_training_data/uav_arm \
+  --epochs 200
 
-# View live progress
-cat substudies/coarse_exploration/optimization_history_incremental.json
+# Step 3: Run neural-accelerated optimization (1000x faster!)
+cd ../studies/uav_arm_optimization
+python run_optimization.py --trials 5000 --use-neural
 ```
 
-**What it does**:
-1. Loads `Bracket_sim1.sim` with parametric geometry
-2. Varies `tip_thickness` (15-25mm) and `support_angle` (20-40°)
-3. Runs FEA solve for each trial using NX journal mode
-4. Extracts displacement and stress from OP2 files
-5. Maximizes displacement while maintaining safety factor >= 4.0
+**What happens**:
+1. Initial 50 FEA trials collect training data (~8 hours)
+2. GNN trains on the data (~30 minutes)
+3. Neural-accelerated trials run 5000 designs (~4 minutes total!)
 
-**Substudy System**:
-- **Shared Models**: All substudies use the same model files
-- **Independent Configs**: Each substudy has its own parameter bounds and settings
-- **Continuation Support**: Fine-tuning substudy continues from coarse exploration results
-- **Live History**: Real-time JSON updates for monitoring progress
+**Design Variables**:
+- `beam_half_core_thickness`: 5-15 mm
+- `beam_face_thickness`: 1-5 mm
+- `holes_diameter`: 20-50 mm
+- `hole_count`: 5-15
 
-**Results** (typical):
-- Best thickness: ~4.2mm
-- Stress reduction: 15-20% vs. baseline
-- Convergence: ~30 trials to plateau
+**Objectives**:
+- Minimize mass
+- Maximize frequency
+- Minimize max displacement
+- Minimize max stress
+
+**Performance**:
+- FEA time: ~10 seconds/trial
+- Neural time: ~4.5 ms/trial
+- Speedup: **2,200x**
+
+## Example: Traditional Bracket Optimization
+
+For traditional FEA-only optimization, see `studies/bracket_displacement_maximizing/`:
+
+```bash
+cd studies/bracket_displacement_maximizing
+python run_optimization.py --trials 50
+```
 
 ## Dashboard Usage
 

archive/scripts/analyze_v3_pareto.py

@@ -0,0 +1,101 @@
+"""Analyze V3 Pareto front performance."""
+
+import optuna
+import json
+from pathlib import Path
+
+# Load study
+study = optuna.load_study(
+    study_name='bracket_stiffness_optimization_V3',
+    storage='sqlite:///studies/bracket_stiffness_optimization_V3/2_results/study.db'
+)
+
+# Get Pareto front
+pareto = study.best_trials
+
+print("=" * 80)
+print("BRACKET STIFFNESS OPTIMIZATION V3 - PERFORMANCE SUMMARY")
+print("=" * 80)
+
+print(f"\nPareto Front Size: {len(pareto)} solutions")
+print(f"Total Trials: {len(study.trials)} (100 requested)")
+print(f"Completed Trials: {len([t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE])}")
+print(f"Pruned Trials: {len([t for t in study.trials if t.state == optuna.trial.TrialState.PRUNED])}")
+
+# Objective ranges
+stiffnesses = [t.values[0] for t in pareto]
+masses = [t.values[1] for t in pareto]
+
+print(f"\n--- OBJECTIVE RANGES (PARETO FRONT) ---")
+print(f"Stiffness Range: [{min(stiffnesses):.2f}, {max(stiffnesses):.2f}] N/mm")
+print(f"  (inverted for maximization: stiffness = -compliance)")
+print(f"Mass Range: [{min(masses):.4f}, {max(masses):.4f}] kg")
+print(f"  ({min(masses)*1000:.2f}g - {max(masses)*1000:.2f}g)")
+
+# Efficiency
+efficiency = (len(pareto) / len([t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE])) * 100
+print(f"\nPareto Efficiency: {efficiency:.1f}% of completed trials are on Pareto front")
+
+# Top 5 by stiffness
+print(f"\n--- TOP 5 PARETO SOLUTIONS (by STIFFNESS) ---")
+sorted_by_stiffness = sorted(pareto, key=lambda x: x.values[0])
+for i, trial in enumerate(sorted_by_stiffness[:5]):
+    stiffness = -trial.values[0]  # Invert back
+    compliance = 1/stiffness if stiffness != 0 else float('inf')
+    mass_g = trial.values[1] * 1000
+    print(f"\n{i+1}. Trial #{trial.number}")
+    print(f"   Stiffness: {stiffness:.2f} N/mm (compliance: {compliance:.6f} mm/N)")
+    print(f"   Mass: {mass_g:.2f}g")
+    print(f"   Support Angle: {trial.params['support_angle']:.2f}°")
+    print(f"   Tip Thickness: {trial.params['tip_thickness']:.2f}mm")
+
+# Top 5 by mass (lightest)
+print(f"\n--- TOP 5 PARETO SOLUTIONS (by LIGHTEST MASS) ---")
+sorted_by_mass = sorted(pareto, key=lambda x: x.values[1])
+for i, trial in enumerate(sorted_by_mass[:5]):
+    stiffness = -trial.values[0]
+    compliance = 1/stiffness if stiffness != 0 else float('inf')
+    mass_g = trial.values[1] * 1000
+    print(f"\n{i+1}. Trial #{trial.number}")
+    print(f"   Mass: {mass_g:.2f}g")
+    print(f"   Stiffness: {stiffness:.2f} N/mm (compliance: {compliance:.6f} mm/N)")
+    print(f"   Support Angle: {trial.params['support_angle']:.2f}°")
+    print(f"   Tip Thickness: {trial.params['tip_thickness']:.2f}mm")
+
+# Load optimization summary
+summary_path = Path("studies/bracket_stiffness_optimization_V3/2_results/optimization_summary.json")
+with open(summary_path, 'r') as f:
+    summary = json.load(f)
+
+print(f"\n--- OPTIMIZATION PERFORMANCE ---")
+print(f"Total Time: {summary['elapsed_seconds']:.1f}s ({summary['elapsed_seconds']/60:.1f} minutes)")
+print(f"Average Time per Trial: {summary['elapsed_seconds']/summary['completed_trials']:.2f}s")
+print(f"Optimizer: {summary['optimizer']}")
+print(f"Final Strategy: NSGA-II (multi-objective)")
+
+# Design space coverage
+all_angles = [t.params['support_angle'] for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE]
+all_thicknesses = [t.params['tip_thickness'] for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE]
+
+print(f"\n--- DESIGN SPACE EXPLORATION ---")
+print(f"Support Angle Range: [{min(all_angles):.2f}°, {max(all_angles):.2f}°]")
+print(f"Tip Thickness Range: [{min(all_thicknesses):.2f}mm, {max(all_thicknesses):.2f}mm]")
+
+# Pareto design space
+pareto_angles = [t.params['support_angle'] for t in pareto]
+pareto_thicknesses = [t.params['tip_thickness'] for t in pareto]
+
+print(f"\n--- PARETO DESIGN SPACE (Optimal Regions) ---")
+print(f"Support Angle Range: [{min(pareto_angles):.2f}°, {max(pareto_angles):.2f}°]")
+print(f"Tip Thickness Range: [{min(pareto_thicknesses):.2f}mm, {max(pareto_thicknesses):.2f}mm]")
+
+print("\n" + "=" * 80)
+print("CONCLUSION")
+print("=" * 80)
+print(f"✓ Successfully completed 100-trial multi-objective optimization")
+print(f"✓ Generated {len(pareto)} Pareto-optimal solutions ({efficiency:.1f}% efficiency)")
+print(f"✓ No crashes or Protocol 11 violations")
+print(f"✓ Stiffness improvements up to {-min(stiffnesses):.0f} N/mm")
+print(f"✓ Mass range: {min(masses)*1000:.0f}g - {max(masses)*1000:.0f}g")
+print("✓ All tracking files (trial_log.json, optimizer_state.json) written successfully")
+print("=" * 80)

archive/scripts/create_circular_plate_study.py

@@ -0,0 +1,70 @@
+"""
+Create circular plate frequency tuning study with COMPLETE automation.
+
+This demonstrates the proper Hybrid Mode workflow:
+1. Study structure creation
+2. Benchmarking
+3. Validation
+4. Auto-generated runner
+"""
+
+from pathlib import Path
+import sys
+sys.path.insert(0, str(Path(__file__).parent))
+
+from optimization_engine.hybrid_study_creator import HybridStudyCreator
+
+
+def main():
+    creator = HybridStudyCreator()
+
+    # Create workflow JSON first (in temp location)
+    import json
+    import tempfile
+    workflow = {
+        "study_name": "circular_plate_frequency_tuning",
+        "optimization_request": "Tune the first natural frequency mode to exactly 115 Hz (within 0.1 Hz tolerance)",
+        "design_variables": [
+            {"parameter": "inner_diameter", "bounds": [50, 150]},
+            {"parameter": "plate_thickness", "bounds": [2, 10]}
+        ],
+        "objectives": [{
+            "name": "frequency_error",
+            "goal": "minimize",
+            "extraction": {
+                "action": "extract_first_natural_frequency",
+                "params": {"mode_number": 1, "target_frequency": 115.0}
+            }
+        }],
+        "constraints": [{
+            "name": "frequency_tolerance",
+            "type": "less_than",
+            "threshold": 0.1
+        }]
+    }
+
+    # Write to temp file
+    temp_workflow = Path(tempfile.gettempdir()) / "circular_plate_workflow.json"
+    with open(temp_workflow, 'w') as f:
+        json.dump(workflow, f, indent=2)
+
+    # Create study with complete automation
+    study_dir = creator.create_from_workflow(
+        workflow_json_path=temp_workflow,
+        model_files={
+            'prt': Path("examples/Models/Circular Plate/Circular_Plate.prt"),
+            'sim': Path("examples/Models/Circular Plate/Circular_Plate_sim1.sim"),
+            'fem': Path("examples/Models/Circular Plate/Circular_Plate_fem1.fem"),
+            'fem_i': Path("examples/Models/Circular Plate/Circular_Plate_fem1_i.prt")
+        },
+        study_name="circular_plate_frequency_tuning"
+    )
+
+    print(f"Study ready at: {study_dir}")
+    print()
+    print("Next step:")
+    print(f"  python {study_dir}/run_optimization.py")
+
+
+if __name__ == "__main__":
+    main()

archive/scripts/create_circular_plate_study_v2.py

@@ -0,0 +1,89 @@
+"""
+Create circular_plate_frequency_tuning_V2 study with ALL fixes applied.
+
+Improvements:
+- Proper study naming
+- Reports go to 3_reports/ folder
+- Reports discuss actual goal (115 Hz target)
+- Fixed objective function
+"""
+
+from pathlib import Path
+import sys
+import argparse
+sys.path.insert(0, str(Path(__file__).parent))
+
+from optimization_engine.hybrid_study_creator import HybridStudyCreator
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Create circular plate frequency tuning study')
+    parser.add_argument('--study-name', default='circular_plate_frequency_tuning_V2',
+                       help='Name of the study folder')
+    args = parser.parse_args()
+
+    study_name = args.study_name
+
+    creator = HybridStudyCreator()
+
+    # Create workflow JSON
+    import json
+    import tempfile
+    workflow = {
+        "study_name": study_name,
+        "optimization_request": "Tune the first natural frequency mode to exactly 115 Hz (within 0.1 Hz tolerance)",
+        "design_variables": [
+            {"parameter": "inner_diameter", "bounds": [50, 150]},
+            {"parameter": "plate_thickness", "bounds": [2, 10]}
+        ],
+        "objectives": [{
+            "name": "frequency_error",
+            "goal": "minimize",
+            "extraction": {
+                "action": "extract_first_natural_frequency",
+                "params": {"mode_number": 1, "target_frequency": 115.0}
+            }
+        }],
+        "constraints": [{
+            "name": "frequency_tolerance",
+            "type": "less_than",
+            "threshold": 0.1
+        }]
+    }
+
+    # Write to temp file
+    temp_workflow = Path(tempfile.gettempdir()) / f"{study_name}_workflow.json"
+    with open(temp_workflow, 'w') as f:
+        json.dump(workflow, f, indent=2)
+
+    # Create study
+    study_dir = creator.create_from_workflow(
+        workflow_json_path=temp_workflow,
+        model_files={
+            'prt': Path("examples/Models/Circular Plate/Circular_Plate.prt"),
+            'sim': Path("examples/Models/Circular Plate/Circular_Plate_sim1.sim"),
+            'fem': Path("examples/Models/Circular Plate/Circular_Plate_fem1.fem"),
+            'fem_i': Path("examples/Models/Circular Plate/Circular_Plate_fem1_i.prt")
+        },
+        study_name=study_name
+    )
+
+    print()
+    print("=" * 80)
+    print(f"[OK] Study created: {study_name}")
+    print("=" * 80)
+    print()
+    print(f"Location: {study_dir}")
+    print()
+    print("Structure:")
+    print("  - 1_setup/: Model files and configuration")
+    print("  - 2_results/: Optimization history and database")
+    print("  - 3_reports/: Human-readable reports with graphs")
+    print()
+    print("To run optimization:")
+    print(f"  python {study_dir}/run_optimization.py")
+    print()
+
+
+if __name__ == "__main__":
+    main()

archive/scripts/create_intelligent_study.py

@@ -0,0 +1,597 @@
+"""
+Create a new circular plate frequency tuning study using Protocol 10.
+
+This script creates a complete study configured for intelligent multi-strategy
+optimization (IMSO) to test the self-tuning framework.
+"""
+
+import json
+import shutil
+from pathlib import Path
+
+# Study configuration
+STUDY_NAME = "circular_plate_frequency_tuning_intelligent_optimizer"
+BASE_DIR = Path(__file__).parent
+STUDIES_DIR = BASE_DIR / "studies"
+STUDY_DIR = STUDIES_DIR / STUDY_NAME
+
+# Source model files (copy from examples)
+SOURCE_MODEL_DIR = BASE_DIR / "examples" / "Models" / "Circular Plate"
+
+def create_study_structure():
+    """Create complete study directory structure."""
+    print(f"Creating study: {STUDY_NAME}")
+
+    # Create directories
+    setup_dir = STUDY_DIR / "1_setup"
+    model_dir = setup_dir / "model"
+    results_dir = STUDY_DIR / "2_results"
+    reports_dir = STUDY_DIR / "3_reports"
+
+    for directory in [setup_dir, model_dir, results_dir, reports_dir]:
+        directory.mkdir(parents=True, exist_ok=True)
+        print(f"  Created: {directory.relative_to(BASE_DIR)}")
+
+    return setup_dir, model_dir, results_dir, reports_dir
+
+
+def copy_model_files(model_dir):
+    """Copy model files from examples."""
+    print("\nCopying model files...")
+
+    model_files = [
+        "Circular_Plate.prt",
+        "Circular_Plate_sim1.sim",
+        "Circular_Plate_fem1.fem",
+        "Circular_Plate_fem1_i.prt"
+    ]
+
+    for filename in model_files:
+        source = SOURCE_MODEL_DIR / filename
+        dest = model_dir / filename
+
+        if source.exists():
+            shutil.copy2(source, dest)
+            print(f"  Copied: {filename}")
+        else:
+            print(f"  WARNING: Source not found: {filename}")
+
+    return list(model_dir.glob("*"))
+
+
+def create_workflow_config(setup_dir):
+    """Create workflow configuration."""
+    print("\nCreating workflow configuration...")
+
+    workflow = {
+        "study_name": STUDY_NAME,
+        "optimization_request": "Tune the first natural frequency mode to exactly 115 Hz using intelligent multi-strategy optimization",
+        "design_variables": [
+            {
+                "parameter": "inner_diameter",
+                "bounds": [50, 150],
+                "units": "mm",
+                "description": "Inner diameter of circular plate"
+            },
+            {
+                "parameter": "plate_thickness",
+                "bounds": [2, 10],
+                "units": "mm",
+                "description": "Thickness of circular plate"
+            }
+        ],
+        "objectives": [
+            {
+                "name": "frequency_error",
+                "goal": "minimize",
+                "extraction": {
+                    "action": "extract_first_natural_frequency",
+                    "params": {
+                        "mode_number": 1,
+                        "target_frequency": 115.0
+                    }
+                }
+            }
+        ],
+        "constraints": [
+            {
+                "name": "frequency_tolerance",
+                "type": "less_than",
+                "threshold": 0.1,
+                "description": "Error from target must be less than 0.1 Hz"
+            }
+        ]
+    }
+
+    workflow_file = setup_dir / "workflow_config.json"
+    with open(workflow_file, 'w', encoding='utf-8') as f:
+        json.dump(workflow, f, indent=2)
+
+    print(f"  Saved: {workflow_file.relative_to(BASE_DIR)}")
+    return workflow
+
+
+def create_optimization_config(setup_dir):
+    """Create Protocol 10 optimization configuration."""
+    print("\nCreating Protocol 10 optimization configuration...")
+
+    config = {
+        "_description": "Protocol 10: Intelligent Multi-Strategy Optimization - Circular Plate Test",
+        "_version": "1.0",
+
+        "study_name": STUDY_NAME,
+        "direction": "minimize",
+
+        "intelligent_optimization": {
+            "_description": "Protocol 10 - Automatic landscape analysis and strategy selection",
+            "enabled": True,
+
+            "characterization_trials": 15,
+            "stagnation_window": 10,
+            "min_improvement_threshold": 0.001,
+            "min_analysis_trials": 10,
+            "reanalysis_interval": 15,
+
+            "strategy_preferences": {
+                "prefer_cmaes_for_smooth": True,
+                "prefer_tpe_for_multimodal": True,
+                "enable_hybrid_strategies": False
+            }
+        },
+
+        "sampler": {
+            "_description": "Fallback sampler if Protocol 10 disabled",
+            "type": "TPESampler",
+            "params": {
+                "n_startup_trials": 10,
+                "n_ei_candidates": 24,
+                "multivariate": True,
+                "warn_independent_sampling": True
+            }
+        },
+
+        "pruner": {
+            "type": "MedianPruner",
+            "params": {
+                "n_startup_trials": 5,
+                "n_warmup_steps": 0
+            }
+        },
+
+        "adaptive_strategy": {
+            "_description": "Protocol 8 - Adaptive exploitation based on surrogate confidence",
+            "enabled": True,
+            "min_confidence_for_exploitation": 0.65,
+            "min_trials_for_confidence": 15,
+            "target_confidence_metrics": {
+                "convergence_weight": 0.4,
+                "coverage_weight": 0.3,
+                "stability_weight": 0.3
+            }
+        },
+
+        "trials": {
+            "n_trials": 100,
+            "timeout": None,
+            "catch": []
+        },
+
+        "reporting": {
+            "auto_generate_plots": True,
+            "include_optuna_visualizations": True,
+            "include_confidence_report": True,
+            "include_strategy_performance": True,
+            "save_intelligence_report": True
+        },
+
+        "verbosity": {
+            "print_landscape_report": True,
+            "print_strategy_recommendation": True,
+            "print_phase_transitions": True,
+            "print_confidence_updates": True,
+            "log_to_file": True
+        },
+
+        "optimization_notes": "Protocol 10 Test: Atomizer will automatically characterize the circular plate problem, select the best optimization algorithm (TPE, CMA-ES, or GP-BO), and adapt strategy if stagnation is detected. Expected: smooth_unimodal landscape → CMA-ES recommendation."
+    }
+
+    config_file = setup_dir / "optimization_config.json"
+    with open(config_file, 'w', encoding='utf-8') as f:
+        json.dump(config, f, indent=2)
+
+    print(f"  Saved: {config_file.relative_to(BASE_DIR)}")
+    return config
+
+
+def create_runner_script(study_dir, workflow, config):
+    """Create optimization runner using Protocol 10."""
+    print("\nCreating Protocol 10 optimization runner...")
+
+    runner_code = '''"""
+Intelligent Multi-Strategy Optimization Runner
+Study: circular_plate_frequency_tuning_intelligent_optimizer
+
+This runner uses Protocol 10 (IMSO) to automatically:
+1. Characterize the optimization landscape
+2. Select the best optimization algorithm
+3. Adapt strategy dynamically if needed
+
+Generated: 2025-11-19
+Protocol: 10 (Intelligent Multi-Strategy Optimization)
+"""
+
+import sys
+import json
+import optuna
+from pathlib import Path
+
+# Add optimization engine to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from optimization_engine.intelligent_optimizer import IntelligentOptimizer
+from optimization_engine.nx_updater import NXParameterUpdater
+from optimization_engine.nx_solver import NXSolver
+from optimization_engine.extractors.frequency_extractor import extract_first_frequency
+from optimization_engine.generate_report_markdown import generate_markdown_report
+
+
+def main():
+    """Run Protocol 10 intelligent optimization."""
+
+    # Setup paths
+    study_dir = Path(__file__).parent
+    setup_dir = study_dir / "1_setup"
+    model_dir = setup_dir / "model"
+    results_dir = study_dir / "2_results"
+    reports_dir = study_dir / "3_reports"
+
+    # Create directories
+    results_dir.mkdir(exist_ok=True)
+    reports_dir.mkdir(exist_ok=True)
+
+    # Load configuration
+    print("\\nLoading configuration...")
+    with open(setup_dir / "workflow_config.json") as f:
+        workflow = json.load(f)
+
+    with open(setup_dir / "optimization_config.json") as f:
+        opt_config = json.load(f)
+
+    print(f"Study: {workflow['study_name']}")
+    print(f"Protocol 10: {opt_config['intelligent_optimization']['enabled']}")
+
+    # Model files
+    prt_file = model_dir / "Circular_Plate.prt"
+    sim_file = model_dir / "Circular_Plate_sim1.sim"
+
+    # Initialize NX components
+    updater = NXParameterUpdater(str(prt_file))
+    solver = NXSolver()
+
+    # Incremental history tracking
+    history_file = results_dir / "optimization_history_incremental.json"
+    history = []
+
+    def objective(trial):
+        """Objective function for optimization."""
+
+        # Sample design variables
+        inner_diameter = trial.suggest_float('inner_diameter', 50, 150)
+        plate_thickness = trial.suggest_float('plate_thickness', 2, 10)
+
+        params = {
+            'inner_diameter': inner_diameter,
+            'plate_thickness': plate_thickness
+        }
+
+        print(f"\\n  Trial #{trial.number}")
+        print(f"    Inner Diameter: {inner_diameter:.4f} mm")
+        print(f"    Plate Thickness: {plate_thickness:.4f} mm")
+
+        # Update CAD model
+        updater.update_expressions(params)
+
+        # Run simulation (use discovered solution name from benchmarking)
+        result = solver.run_simulation(str(sim_file), solution_name="Solution_Normal_Modes")
+
+        if not result['success']:
+            print(f"    Simulation FAILED: {result.get('error', 'Unknown error')}")
+            raise optuna.TrialPruned()
+
+        # Extract frequency
+        op2_file = result['op2_file']
+        frequency = extract_first_frequency(op2_file, mode_number=1)
+
+        # Calculate objective (error from target)
+        target_frequency = 115.0
+        objective_value = abs(frequency - target_frequency)
+
+        print(f"    Frequency: {frequency:.4f} Hz")
+        print(f"    Target: {target_frequency:.4f} Hz")
+        print(f"    Error: {objective_value:.4f} Hz")
+
+        # Save to incremental history
+        trial_data = {
+            "trial_number": trial.number,
+            "design_variables": params,
+            "results": {"first_frequency": frequency},
+            "objective": objective_value
+        }
+
+        history.append(trial_data)
+
+        with open(history_file, 'w', encoding='utf-8') as f:
+            json.dump(history, f, indent=2)
+
+        return objective_value
+
+    # Create intelligent optimizer
+    print("\\n" + "="*70)
+    print("  PROTOCOL 10: INTELLIGENT MULTI-STRATEGY OPTIMIZATION")
+    print("="*70)
+
+    optimizer = IntelligentOptimizer(
+        study_name=workflow['study_name'],
+        study_dir=results_dir,
+        config=opt_config,
+        verbose=True
+    )
+
+    # Extract design variable bounds
+    design_vars = {
+        var['parameter']: tuple(var['bounds'])
+        for var in workflow['design_variables']
+    }
+
+    # Run optimization
+    results = optimizer.optimize(
+        objective_function=objective,
+        design_variables=design_vars,
+        n_trials=opt_config['trials']['n_trials'],
+        target_value=115.0,
+        tolerance=0.1
+    )
+
+    # Save intelligence report
+    optimizer.save_intelligence_report()
+
+    # Generate markdown report
+    print("\\nGenerating optimization report...")
+
+    # Load study for Optuna visualizations
+    storage = f"sqlite:///{results_dir / 'study.db'}"
+    study = optuna.load_study(
+        study_name=workflow['study_name'],
+        storage=storage
+    )
+
+    report = generate_markdown_report(
+        history_file=history_file,
+        target_value=115.0,
+        tolerance=0.1,
+        reports_dir=reports_dir,
+        study=study
+    )
+
+    report_file = reports_dir / "OPTIMIZATION_REPORT.md"
+    with open(report_file, 'w', encoding='utf-8') as f:
+        f.write(report)
+
+    print(f"\\nReport saved: {report_file}")
+
+    # Print final summary
+    print("\\n" + "="*70)
+    print("  PROTOCOL 10 TEST COMPLETE")
+    print("="*70)
+    print(f"Best Frequency: {results['best_value'] + 115.0:.4f} Hz")
+    print(f"Best Error: {results['best_value']:.4f} Hz")
+    print(f"Best Parameters:")
+    for param, value in results['best_params'].items():
+        print(f"  {param}: {value:.4f}")
+
+    if 'landscape_analysis' in results and results['landscape_analysis'].get('ready'):
+        landscape = results['landscape_analysis']
+        print(f"\\nLandscape Type: {landscape['landscape_type'].upper()}")
+        print(f"Recommended Strategy: {results.get('final_strategy', 'N/A').upper()}")
+
+    print("="*70)
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+    runner_file = study_dir / "run_optimization.py"
+    with open(runner_file, 'w', encoding='utf-8') as f:
+        f.write(runner_code)
+
+    print(f"  Saved: {runner_file.relative_to(BASE_DIR)}")
+    return runner_file
+
+
+def create_readme(study_dir):
+    """Create README for the study."""
+    print("\nCreating README...")
+
+    readme = f"""# {STUDY_NAME}
+
+**Protocol 10 Test Study** - Intelligent Multi-Strategy Optimization
+
+## Overview
+
+This study tests Atomizer's Protocol 10 (IMSO) framework on a circular plate frequency tuning problem.
+
+**Goal**: Tune first natural frequency to exactly 115 Hz
+
+**Protocol 10 Features Tested**:
+- Automatic landscape characterization (smoothness, multimodality, correlation)
+- Intelligent strategy selection (TPE, CMA-ES, or GP-BO)
+- Dynamic strategy switching based on stagnation detection
+- Comprehensive decision logging for transparency
+
+## Expected Behavior
+
+### Stage 1: Landscape Characterization (Trials 1-15)
+- Random exploration to gather data
+- Analyze problem characteristics
+- Expected classification: `smooth_unimodal` with strong parameter correlation
+
+### Stage 2: Strategy Selection (Trial 15)
+- Expected recommendation: **CMA-ES** (92% confidence)
+- Reasoning: "Smooth unimodal with strong correlation - CMA-ES converges quickly"
+
+### Stage 3: Adaptive Optimization (Trials 16-100)
+- Run with CMA-ES sampler
+- Monitor for stagnation
+- Switch strategies if needed (unlikely for this problem)
+
+## Study Structure
+
+```
+{STUDY_NAME}/
+├── 1_setup/
+│   ├── model/                    # CAD and simulation files
+│   ├── workflow_config.json      # Optimization goals
+│   └── optimization_config.json  # Protocol 10 configuration
+├── 2_results/
+│   ├── study.db                  # Optuna database
+│   ├── optimization_history_incremental.json
+│   └── intelligent_optimizer/    # Protocol 10 tracking
+│       ├── strategy_transitions.json
+│       ├── strategy_performance.json
+│       └── intelligence_report.json
+└── 3_reports/
+    └── OPTIMIZATION_REPORT.md    # Final report with visualizations
+```
+
+## Running the Optimization
+
+```bash
+# Activate environment
+conda activate test_env
+
+# Run optimization
+python run_optimization.py
+```
+
+## What to Look For
+
+### Console Output
+
+**Landscape Analysis Report**:
+```
+======================================================================
+  LANDSCAPE ANALYSIS REPORT
+======================================================================
+  Type: SMOOTH_UNIMODAL
+  Smoothness: 0.7X (smooth)
+  Multimodal: NO (1 modes)
+  Parameter Correlation: 0.6X (strong)
+```
+
+**Strategy Recommendation**:
+```
+======================================================================
+  STRATEGY RECOMMENDATION
+======================================================================
+  Recommended: CMAES
+  Confidence: 92.0%
+  Reasoning: Smooth unimodal with strong correlation - CMA-ES converges quickly
+```
+
+**Phase Transitions** (if any):
+```
+======================================================================
+  STRATEGY TRANSITION
+======================================================================
+  Trial #45
+  TPE → CMAES
+  Reason: Stagnation detected
+```
+
+### Intelligence Report
+
+Check `2_results/intelligent_optimizer/intelligence_report.json` for:
+- Complete landscape analysis
+- Strategy recommendation reasoning
+- All transition events
+- Performance breakdown by strategy
+
+### Optimization Report
+
+Check `3_reports/OPTIMIZATION_REPORT.md` for:
+- Best result (should be < 0.1 Hz error)
+- Convergence plots
+- Optuna visualizations
+- (Future: Protocol 10 analysis section)
+
+## Expected Results
+
+**Baseline (TPE only)**: ~160 trials to achieve 0.18 Hz error
+
+**Protocol 10 (Intelligent)**: ~60-80 trials to achieve < 0.1 Hz error
+
+**Improvement**: 40-50% faster convergence by selecting optimal algorithm
+
+## Configuration
+
+See [`optimization_config.json`](1_setup/optimization_config.json) for full Protocol 10 settings.
+
+Key parameters:
+- `characterization_trials`: 15 (initial exploration)
+- `stagnation_window`: 10 (trials to check for stagnation)
+- `min_improvement_threshold`: 0.001 (0.1% minimum improvement)
+
+## References
+
+- [PROTOCOL.md](../../PROTOCOL.md) - Complete Protocol 10 documentation
+- [Protocol 10 Implementation Summary](../../docs/PROTOCOL_10_IMPLEMENTATION_SUMMARY.md)
+- [Example Configuration](../../examples/optimization_config_protocol10.json)
+
+---
+
+*Study created: 2025-11-19*
+*Protocol: 10 (Intelligent Multi-Strategy Optimization)*
+"""
+
+    readme_file = study_dir / "README.md"
+    with open(readme_file, 'w', encoding='utf-8') as f:
+        f.write(readme)
+
+    print(f"  Saved: {readme_file.relative_to(BASE_DIR)}")
+
+
+def main():
+    """Create complete Protocol 10 test study."""
+    print("\n" + "="*70)
+    print("  CREATING PROTOCOL 10 TEST STUDY")
+    print("="*70)
+
+    # Create structure
+    setup_dir, model_dir, results_dir, reports_dir = create_study_structure()
+
+    # Copy model files
+    model_files = copy_model_files(model_dir)
+
+    # Create configurations
+    workflow = create_workflow_config(setup_dir)
+    config = create_optimization_config(setup_dir)
+
+    # Create runner
+    runner_file = create_runner_script(STUDY_DIR, workflow, config)
+
+    # Create README
+    create_readme(STUDY_DIR)
+
+    print("\n" + "="*70)
+    print("  STUDY CREATION COMPLETE")
+    print("="*70)
+    print(f"\nStudy directory: {STUDY_DIR.relative_to(BASE_DIR)}")
+    print(f"\nTo run optimization:")
+    print(f"  cd {STUDY_DIR.relative_to(BASE_DIR)}")
+    print(f"  python run_optimization.py")
+    print("\n" + "="*70)
+
+
+if __name__ == "__main__":
+    main()

archive/scripts/create_v2_study.py

@@ -0,0 +1,89 @@
+"""
+Create circular_plate_frequency_tuning_V2 study with all fixes.
+"""
+from pathlib import Path
+import shutil
+import json
+
+# Study configuration
+study_name = "circular_plate_frequency_tuning_V2"
+study_dir = Path("studies") / study_name
+
+# Create study structure
+print(f"Creating study: {study_name}")
+print("=" * 80)
+
+# 1. Create directory structure
+(study_dir / "1_setup" / "model").mkdir(parents=True, exist_ok=True)
+(study_dir / "2_results").mkdir(parents=True, exist_ok=True)
+(study_dir / "3_reports").mkdir(parents=True, exist_ok=True)
+
+# 2. Copy model files
+source_dir = Path("examples/Models/Circular Plate")
+model_files = [
+    "Circular_Plate.prt",
+    "Circular_Plate_sim1.sim",
+    "Circular_Plate_fem1.fem",
+    "Circular_Plate_fem1_i.prt"
+]
+
+print("\n[1/5] Copying model files...")
+for file in model_files:
+    src = source_dir / file
+    dst = study_dir / "1_setup" / "model" / file
+    if src.exists():
+        shutil.copy2(src, dst)
+        print(f"  ✓ {file}")
+
+# 3. Create workflow config
+print("\n[2/5] Creating workflow configuration...")
+workflow = {
+    "study_name": study_name,
+    "optimization_request": "Tune the first natural frequency mode to exactly 115 Hz (within 0.1 Hz tolerance)",
+    "design_variables": [
+        {
+            "parameter": "inner_diameter",
+            "bounds": [50, 150]
+        },
+        {
+            "parameter": "plate_thickness",
+            "bounds": [2, 10]
+        }
+    ],
+    "objectives": [
+        {
+            "name": "frequency_error",
+            "goal": "minimize",
+            "extraction": {
+                "action": "extract_first_natural_frequency",
+                "params": {
+                    "mode_number": 1,
+                    "target_frequency": 115.0
+                }
+            }
+        }
+    ],
+    "constraints": [
+        {
+            "name": "frequency_tolerance",
+            "type": "less_than",
+            "threshold": 0.1
+        }
+    ]
+}
+
+config_file = study_dir / "1_setup" / "workflow_config.json"
+with open(config_file, 'w') as f:
+    json.dump(workflow, f, indent=2)
+print(f"  ✓ Configuration saved")
+
+print("\n[3/5] Study structure created")
+print(f"  Location: {study_dir}")
+print(f"  - 1_setup/model: Model files")
+print(f"  - 2_results: Optimization results")
+print(f"  - 3_reports: Human-readable reports")
+
+print("\n[4/5] Next: Run intelligent setup to generate optimization runner")
+print(f"  Command: python create_circular_plate_study.py --study-name {study_name}")
+
+print("\nDone!")

archive/scripts/extract_history_from_db.py

@@ -0,0 +1,60 @@
+"""
+Extract optimization history from Optuna database and create incremental JSON file.
+"""
+
+import sys
+import json
+from pathlib import Path
+import optuna
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python extract_history_from_db.py <path/to/study.db>")
+        sys.exit(1)
+
+    db_file = Path(sys.argv[1])
+    if not db_file.exists():
+        print(f"ERROR: Database not found: {db_file}")
+        sys.exit(1)
+
+    # Load Optuna study
+    storage = f"sqlite:///{db_file}"
+    study_name = db_file.parent.parent.name  # Extract from path
+
+    try:
+        study = optuna.load_study(study_name=study_name, storage=storage)
+    except:
+        # Try to get first study if name doesn't match
+        studies = optuna.get_all_study_names(storage)
+        if not studies:
+            print("ERROR: No studies found in database")
+            sys.exit(1)
+        study = optuna.load_study(study_name=studies[0], storage=storage)
+
+    print(f"Study: {study.study_name}")
+    print(f"Trials: {len(study.trials)}")
+
+    # Extract history
+    history = []
+    for trial in study.trials:
+        if trial.state != optuna.trial.TrialState.COMPLETE:
+            continue
+
+        record = {
+            'trial_number': trial.number,
+            'design_variables': trial.params,
+            'results': trial.user_attrs,  # May be empty if not stored
+            'objective': trial.value
+        }
+        history.append(record)
+
+    # Write to JSON
+    output_file = db_file.parent / 'optimization_history_incremental.json'
+    with open(output_file, 'w') as f:
+        json.dump(history, f, indent=2)
+
+    print(f"\nHistory exported to: {output_file}")
+    print(f"  {len(history)} completed trials")
+
+if __name__ == "__main__":
+    main()

archive/scripts/run_calibration_loop.py

@@ -0,0 +1,331 @@
+"""
+Active Learning Calibration Loop
+
+This script implements the iterative calibration workflow:
+1. Train initial NN on existing FEA data
+2. Run NN optimization to find promising designs
+3. Select high-uncertainty designs for FEA validation
+4. Run FEA on selected designs (simulated here, needs real FEA integration)
+5. Retrain NN with new data
+6. Repeat until confidence threshold reached
+
+Usage:
+    python run_calibration_loop.py --study uav_arm_optimization --iterations 5
+
+Note: For actual FEA integration, replace the simulate_fea() function with real NX calls.
+"""
+import sys
+from pathlib import Path
+import argparse
+import json
+import numpy as np
+import optuna
+from optuna.samplers import NSGAIISampler
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+# Add project paths
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+from optimization_engine.active_learning_surrogate import (
+    ActiveLearningSurrogate,
+    extract_training_data_from_study
+)
+
+
+def simulate_fea(design: dict, surrogate: ActiveLearningSurrogate) -> dict:
+    """
+    PLACEHOLDER: Simulate FEA results.
+
+    In production, this would:
+    1. Update NX model parameters
+    2. Run FEA solve
+    3. Extract results (mass, frequency, displacement, stress)
+
+    For now, we use the ensemble mean + noise to simulate "ground truth"
+    with systematic differences to test calibration.
+    """
+    # Get NN prediction
+    pred = surrogate.predict(design)
+
+    # Add systematic bias + noise to simulate FEA
+    # This simulates the case where NN is systematically off
+    fea_mass = pred['mass'] * 0.95 + np.random.normal(0, 50)  # NN overestimates mass by ~5%
+    fea_freq = pred['frequency'] * 0.6 + np.random.normal(0, 2)  # NN overestimates freq significantly
+
+    return {
+        'mass': max(fea_mass, 1000),  # Ensure positive
+        'frequency': max(fea_freq, 1),
+        'max_displacement': pred.get('max_displacement', 0),
+        'max_stress': pred.get('max_stress', 0)
+    }
+
+
+def run_nn_optimization(
+    surrogate: ActiveLearningSurrogate,
+    bounds: dict,
+    n_trials: int = 500
+) -> list:
+    """Run NN-only optimization to generate candidate designs."""
+
+    study = optuna.create_study(
+        directions=["minimize", "minimize"],  # mass, -frequency
+        sampler=NSGAIISampler()
+    )
+
+    def objective(trial):
+        params = {}
+        for name, (low, high) in bounds.items():
+            if name == 'hole_count':
+                params[name] = trial.suggest_int(name, int(low), int(high))
+            else:
+                params[name] = trial.suggest_float(name, low, high)
+
+        pred = surrogate.predict(params)
+
+        # Store uncertainty in user_attrs
+        trial.set_user_attr('uncertainty', pred['total_uncertainty'])
+        trial.set_user_attr('params', params)
+
+        return pred['mass'], -pred['frequency']
+
+    study.optimize(objective, n_trials=n_trials, show_progress_bar=False)
+
+    # Extract Pareto front designs with their uncertainty
+    pareto_designs = []
+    for trial in study.best_trials:
+        pareto_designs.append({
+            'params': trial.user_attrs['params'],
+            'uncertainty': trial.user_attrs['uncertainty'],
+            'mass': trial.values[0],
+            'frequency': -trial.values[1]
+        })
+
+    return pareto_designs
+
+
+def plot_calibration_progress(history: list, save_path: str):
+    """Plot calibration progress over iterations."""
+    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
+
+    iterations = [h['iteration'] for h in history]
+
+    # 1. Confidence score
+    ax = axes[0, 0]
+    confidence = [h['confidence_score'] for h in history]
+    ax.plot(iterations, confidence, 'b-o', linewidth=2)
+    ax.axhline(y=0.7, color='g', linestyle='--', label='Target (0.7)')
+    ax.set_xlabel('Iteration')
+    ax.set_ylabel('Confidence Score')
+    ax.set_title('Model Confidence Over Iterations')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 2. MAPE
+    ax = axes[0, 1]
+    mass_mape = [h['mass_mape'] for h in history]
+    freq_mape = [h['freq_mape'] for h in history]
+    ax.plot(iterations, mass_mape, 'b-o', label='Mass MAPE')
+    ax.plot(iterations, freq_mape, 'r-s', label='Frequency MAPE')
+    ax.axhline(y=10, color='g', linestyle='--', label='Target (10%)')
+    ax.set_xlabel('Iteration')
+    ax.set_ylabel('MAPE (%)')
+    ax.set_title('Prediction Error Over Iterations')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 3. Training samples
+    ax = axes[1, 0]
+    n_samples = [h['n_training_samples'] for h in history]
+    ax.plot(iterations, n_samples, 'g-o', linewidth=2)
+    ax.set_xlabel('Iteration')
+    ax.set_ylabel('Training Samples')
+    ax.set_title('Training Data Growth')
+    ax.grid(True, alpha=0.3)
+
+    # 4. Average uncertainty of selected designs
+    ax = axes[1, 1]
+    avg_uncertainty = [h['avg_selected_uncertainty'] for h in history]
+    ax.plot(iterations, avg_uncertainty, 'm-o', linewidth=2)
+    ax.set_xlabel('Iteration')
+    ax.set_ylabel('Average Uncertainty')
+    ax.set_title('Uncertainty of Selected Designs')
+    ax.grid(True, alpha=0.3)
+
+    plt.suptitle('Active Learning Calibration Progress', fontsize=14)
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150)
+    plt.close()
+    print(f"Saved calibration progress plot: {save_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run Active Learning Calibration Loop')
+    parser.add_argument('--study', default='uav_arm_optimization', help='Study name')
+    parser.add_argument('--iterations', type=int, default=5, help='Number of calibration iterations')
+    parser.add_argument('--fea-per-iter', type=int, default=10, help='FEA evaluations per iteration')
+    parser.add_argument('--confidence-target', type=float, default=0.7, help='Target confidence')
+    parser.add_argument('--simulate', action='store_true', default=True, help='Simulate FEA (for testing)')
+    args = parser.parse_args()
+
+    print("="*70)
+    print("Active Learning Calibration Loop")
+    print("="*70)
+    print(f"Study: {args.study}")
+    print(f"Max iterations: {args.iterations}")
+    print(f"FEA per iteration: {args.fea_per_iter}")
+    print(f"Confidence target: {args.confidence_target}")
+
+    # Find database
+    db_path = project_root / f"studies/{args.study}/2_results/study.db"
+    study_name = args.study
+
+    if not db_path.exists():
+        db_path = project_root / "studies/uav_arm_atomizerfield_test/2_results/study.db"
+        study_name = "uav_arm_atomizerfield_test"
+
+    if not db_path.exists():
+        print(f"ERROR: Database not found: {db_path}")
+        return
+
+    # Design bounds (from UAV arm study)
+    bounds = {
+        'beam_half_core_thickness': (1.0, 10.0),
+        'beam_face_thickness': (0.5, 3.0),
+        'holes_diameter': (0.5, 50.0),
+        'hole_count': (6, 14)
+    }
+
+    # Load initial training data
+    print(f"\n[1] Loading initial training data from {db_path}")
+    design_params, objectives, design_var_names = extract_training_data_from_study(
+        str(db_path), study_name
+    )
+    print(f"    Initial samples: {len(design_params)}")
+
+    # Calibration history
+    calibration_history = []
+
+    # Track accumulated training data
+    all_design_params = design_params.copy()
+    all_objectives = objectives.copy()
+
+    for iteration in range(args.iterations):
+        print(f"\n{'='*70}")
+        print(f"ITERATION {iteration + 1}/{args.iterations}")
+        print("="*70)
+
+        # Train ensemble surrogate
+        print(f"\n[2.{iteration+1}] Training ensemble surrogate...")
+        surrogate = ActiveLearningSurrogate(n_ensemble=5)
+        surrogate.train(
+            all_design_params, all_objectives, design_var_names,
+            epochs=200
+        )
+
+        # Run NN optimization to find candidate designs
+        print(f"\n[3.{iteration+1}] Running NN optimization (500 trials)...")
+        pareto_designs = run_nn_optimization(surrogate, bounds, n_trials=500)
+        print(f"    Found {len(pareto_designs)} Pareto designs")
+
+        # Select designs for FEA validation (highest uncertainty)
+        print(f"\n[4.{iteration+1}] Selecting designs for FEA validation...")
+        candidate_params = [d['params'] for d in pareto_designs]
+        selected = surrogate.select_designs_for_validation(
+            candidate_params,
+            n_select=args.fea_per_iter,
+            strategy='diverse'  # Mix of high uncertainty + diversity
+        )
+
+        print(f"    Selected {len(selected)} designs:")
+        avg_uncertainty = np.mean([s[2] for s in selected])
+        for i, (idx, params, uncertainty) in enumerate(selected[:5]):
+            print(f"      {i+1}. Uncertainty={uncertainty:.3f}, params={params}")
+
+        # Run FEA (simulated)
+        print(f"\n[5.{iteration+1}] Running FEA validation...")
+        new_params = []
+        new_objectives = []
+
+        for idx, params, uncertainty in selected:
+            if args.simulate:
+                fea_result = simulate_fea(params, surrogate)
+            else:
+                # TODO: Call actual FEA here
+                # fea_result = run_actual_fea(params)
+                raise NotImplementedError("Real FEA not implemented")
+
+            # Record for retraining
+            param_array = [params.get(name, 0.0) for name in design_var_names]
+            new_params.append(param_array)
+            new_objectives.append([
+                fea_result['mass'],
+                fea_result['frequency'],
+                fea_result.get('max_displacement', 0),
+                fea_result.get('max_stress', 0)
+            ])
+
+            # Update validation tracking
+            surrogate.update_with_validation([params], [fea_result])
+
+        # Add new data to training set
+        all_design_params = np.vstack([all_design_params, np.array(new_params, dtype=np.float32)])
+        all_objectives = np.vstack([all_objectives, np.array(new_objectives, dtype=np.float32)])
+
+        # Get confidence report
+        report = surrogate.get_confidence_report()
+        print(f"\n[6.{iteration+1}] Confidence Report:")
+        print(f"    Confidence Score: {report['confidence_score']:.3f}")
+        print(f"    Mass MAPE: {report['mass_mape']:.1f}%")
+        print(f"    Freq MAPE: {report['freq_mape']:.1f}%")
+        print(f"    Status: {report['status']}")
+        print(f"    Recommendation: {report['recommendation']}")
+
+        # Record history
+        calibration_history.append({
+            'iteration': iteration + 1,
+            'n_training_samples': len(all_design_params),
+            'confidence_score': report['confidence_score'],
+            'mass_mape': report['mass_mape'],
+            'freq_mape': report['freq_mape'],
+            'avg_selected_uncertainty': avg_uncertainty,
+            'status': report['status']
+        })
+
+        # Check if we've reached target confidence
+        if report['confidence_score'] >= args.confidence_target:
+            print(f"\n*** TARGET CONFIDENCE REACHED ({report['confidence_score']:.3f} >= {args.confidence_target}) ***")
+            break
+
+    # Save final model
+    print("\n" + "="*70)
+    print("CALIBRATION COMPLETE")
+    print("="*70)
+
+    model_path = project_root / "calibrated_surrogate.pt"
+    surrogate.save(str(model_path))
+    print(f"Saved calibrated model to: {model_path}")
+
+    # Save calibration history
+    history_path = project_root / "calibration_history.json"
+    with open(history_path, 'w') as f:
+        json.dump(calibration_history, f, indent=2)
+    print(f"Saved calibration history to: {history_path}")
+
+    # Plot progress
+    plot_calibration_progress(calibration_history, str(project_root / "calibration_progress.png"))
+
+    # Final summary
+    final_report = surrogate.get_confidence_report()
+    print(f"\nFinal Results:")
+    print(f"  Training samples: {len(all_design_params)}")
+    print(f"  Confidence score: {final_report['confidence_score']:.3f}")
+    print(f"  Mass MAPE: {final_report['mass_mape']:.1f}%")
+    print(f"  Freq MAPE: {final_report['freq_mape']:.1f}%")
+    print(f"  Ready for optimization: {surrogate.is_ready_for_optimization()}")
+
+
+if __name__ == '__main__':
+    main()

archive/scripts/run_nn_optimization.py

@@ -0,0 +1,163 @@
+"""
+Neural Network Only Optimization
+
+This script runs multi-objective optimization using ONLY the neural network
+surrogate (no FEA). This demonstrates the speed improvement from NN predictions.
+
+Objectives:
+- Minimize mass
+- Maximize frequency (minimize -frequency)
+"""
+import sys
+from pathlib import Path
+import time
+import json
+import optuna
+from optuna.samplers import NSGAIISampler
+import numpy as np
+
+# Add project paths
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+sys.path.insert(0, str(project_root / 'atomizer-field'))
+
+from optimization_engine.simple_mlp_surrogate import SimpleSurrogate
+
+
+def main():
+    print("="*60)
+    print("Neural Network Only Optimization (Simple MLP)")
+    print("="*60)
+
+    # Load surrogate
+    print("\n[1] Loading neural surrogate...")
+    model_path = project_root / "simple_mlp_surrogate.pt"
+
+    if not model_path.exists():
+        print(f"ERROR: Model not found at {model_path}")
+        print("Run 'python optimization_engine/simple_mlp_surrogate.py' first to train")
+        return
+
+    surrogate = SimpleSurrogate.load(model_path)
+
+    if not surrogate:
+        print("ERROR: Could not load neural surrogate")
+        return
+
+    print(f"    Design variables: {surrogate.design_var_names}")
+
+    # Define bounds (from UAV arm study)
+    bounds = {
+        'beam_half_core_thickness': (1.0, 5.0),
+        'beam_face_thickness': (0.5, 3.0),
+        'holes_diameter': (0.5, 5.0),
+        'hole_count': (0.0, 6.0)
+    }
+
+    print(f"    Bounds: {bounds}")
+
+    # Create Optuna study
+    print("\n[2] Creating Optuna study...")
+    storage_path = project_root / "nn_only_optimization_study.db"
+
+    # Remove old study if exists
+    if storage_path.exists():
+        storage_path.unlink()
+
+    storage = optuna.storages.RDBStorage(f"sqlite:///{storage_path}")
+
+    study = optuna.create_study(
+        study_name="nn_only_optimization",
+        storage=storage,
+        directions=["minimize", "minimize"],  # mass, -frequency (minimize both)
+        sampler=NSGAIISampler()
+    )
+
+    # Track stats
+    start_time = time.time()
+    trial_times = []
+
+    def objective(trial: optuna.Trial):
+        trial_start = time.time()
+
+        # Suggest parameters
+        params = {}
+        for name, (low, high) in bounds.items():
+            if name == 'hole_count':
+                params[name] = trial.suggest_int(name, int(low), int(high))
+            else:
+                params[name] = trial.suggest_float(name, low, high)
+
+        # Predict with NN
+        results = surrogate.predict(params)
+
+        mass = results['mass']
+        frequency = results['frequency']
+
+        trial_time = (time.time() - trial_start) * 1000
+        trial_times.append(trial_time)
+
+        # Log progress every 100 trials
+        if trial.number % 100 == 0:
+            print(f"  Trial {trial.number}: mass={mass:.1f}g, freq={frequency:.2f}Hz, time={trial_time:.1f}ms")
+
+        # Return objectives: minimize mass, minimize -frequency (= maximize frequency)
+        return mass, -frequency
+
+    # Run optimization
+    n_trials = 1000  # Much faster with NN!
+    print(f"\n[3] Running {n_trials} trials...")
+
+    study.optimize(objective, n_trials=n_trials, show_progress_bar=True)
+
+    total_time = time.time() - start_time
+
+    # Results
+    print("\n" + "="*60)
+    print("RESULTS")
+    print("="*60)
+
+    print(f"\nTotal time: {total_time:.1f}s for {n_trials} trials")
+    print(f"Average time per trial: {np.mean(trial_times):.1f}ms")
+    print(f"Trials per second: {n_trials/total_time:.1f}")
+
+    # Get Pareto front
+    pareto_front = study.best_trials
+    print(f"\nPareto front size: {len(pareto_front)} designs")
+
+    print("\nTop 5 Pareto-optimal designs:")
+    for i, trial in enumerate(pareto_front[:5]):
+        mass = trial.values[0]
+        freq = -trial.values[1]  # Convert back to positive
+        print(f"  {i+1}. Mass={mass:.1f}g, Freq={freq:.2f}Hz")
+        print(f"      Params: {trial.params}")
+
+    # Save results
+    results_file = project_root / "nn_optimization_results.json"
+    results = {
+        'n_trials': n_trials,
+        'total_time_s': total_time,
+        'avg_trial_time_ms': np.mean(trial_times),
+        'trials_per_second': n_trials/total_time,
+        'pareto_front_size': len(pareto_front),
+        'pareto_designs': [
+            {
+                'mass': t.values[0],
+                'frequency': -t.values[1],
+                'params': t.params
+            }
+            for t in pareto_front
+        ]
+    }
+
+    with open(results_file, 'w') as f:
+        json.dump(results, f, indent=2)
+
+    print(f"\nResults saved to: {results_file}")
+    print(f"Study database: {storage_path}")
+    print("\nView in Optuna dashboard:")
+    print(f"  optuna-dashboard sqlite:///{storage_path}")
+
+
+if __name__ == "__main__":
+    main()

archive/scripts/run_validated_nn_optimization.py

@@ -0,0 +1,470 @@
+"""
+Production-Ready NN Optimization with Confidence Bounds
+
+This script runs multi-objective optimization using the CV-validated neural network
+with proper extrapolation warnings and confidence-bounded results.
+
+Key Features:
+1. Uses CV-validated model with known accuracy (1.8% mass, 1.1% freq MAPE)
+2. Warns when extrapolating outside training data range
+3. Reads optimization bounds from study's optimization_config.json
+4. Constrains optimization to prescribed bounds for reliable predictions
+5. Marks designs needing FEA validation
+"""
+import sys
+from pathlib import Path
+import time
+import json
+import argparse
+import torch
+import numpy as np
+import optuna
+from optuna.samplers import NSGAIISampler
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+# Add project paths
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+
+def load_config_bounds(study_path: Path) -> dict:
+    """Load design variable bounds from optimization_config.json
+
+    Returns dict: {param_name: (min, max, is_int)}
+    """
+    config_path = study_path / "1_setup" / "optimization_config.json"
+
+    if not config_path.exists():
+        raise FileNotFoundError(f"Config not found: {config_path}")
+
+    with open(config_path) as f:
+        config = json.load(f)
+
+    bounds = {}
+    for var in config.get('design_variables', []):
+        # Support both 'parameter' and 'name' keys
+        name = var.get('parameter') or var.get('name')
+
+        # Support both "bounds": [min, max] and "min_value"/"max_value" formats
+        if 'bounds' in var:
+            min_val, max_val = var['bounds']
+        else:
+            min_val = var.get('min_value', var.get('min', 0))
+            max_val = var.get('max_value', var.get('max', 1))
+
+        # Detect integer type based on name or explicit type
+        is_int = (var.get('type') == 'integer' or
+                  'count' in name.lower() or
+                  (isinstance(min_val, int) and isinstance(max_val, int) and max_val - min_val < 20))
+
+        bounds[name] = (min_val, max_val, is_int)
+
+    return bounds
+
+from optimization_engine.active_learning_surrogate import EnsembleMLP
+
+
+class ValidatedSurrogate:
+    """Surrogate with CV-validated accuracy and extrapolation detection."""
+
+    def __init__(self, model_path: str):
+        state = torch.load(model_path, map_location='cpu')
+
+        self.model = EnsembleMLP(
+            input_dim=len(state['design_var_names']),
+            output_dim=4,  # mass, freq, disp, stress
+            hidden_dims=state['hidden_dims']
+        )
+        self.model.load_state_dict(state['model'])
+        self.model.eval()
+
+        self.input_mean = np.array(state['input_mean'])
+        self.input_std = np.array(state['input_std'])
+        self.output_mean = np.array(state['output_mean'])
+        self.output_std = np.array(state['output_std'])
+        self.design_var_names = state['design_var_names']
+
+        # CV metrics
+        self.cv_mass_mape = state['cv_mass_mape']
+        self.cv_freq_mape = state['cv_freq_mape']
+        self.cv_mass_std = state['cv_mass_std']
+        self.cv_freq_std = state['cv_freq_std']
+        self.n_training_samples = state['n_samples']
+
+        # Training bounds (for extrapolation detection)
+        self.bounds_min = self.input_mean - 2 * self.input_std
+        self.bounds_max = self.input_mean + 2 * self.input_std
+
+    def predict(self, params: dict) -> dict:
+        """Predict with extrapolation check."""
+        x = np.array([[params.get(name, 0.0) for name in self.design_var_names]], dtype=np.float32)
+
+        # Check for extrapolation
+        extrapolation_score = 0.0
+        for i, name in enumerate(self.design_var_names):
+            val = x[0, i]
+            if val < self.bounds_min[i]:
+                extrapolation_score += (self.bounds_min[i] - val) / (self.input_std[i] + 1e-8)
+            elif val > self.bounds_max[i]:
+                extrapolation_score += (val - self.bounds_max[i]) / (self.input_std[i] + 1e-8)
+
+        # Normalize input
+        x_norm = (x - self.input_mean) / (self.input_std + 1e-8)
+        x_t = torch.FloatTensor(x_norm)
+
+        # Predict
+        with torch.no_grad():
+            pred_norm = self.model(x_t).numpy()
+
+        pred = pred_norm * (self.output_std + 1e-8) + self.output_mean
+
+        # Calculate confidence-adjusted uncertainty
+        base_uncertainty = self.cv_mass_mape / 100  # Base uncertainty from CV
+        extrapolation_penalty = min(extrapolation_score * 0.1, 0.5)  # Max 50% extra uncertainty
+        total_uncertainty = base_uncertainty + extrapolation_penalty
+
+        return {
+            'mass': float(pred[0, 0]),
+            'frequency': float(pred[0, 1]),
+            'max_displacement': float(pred[0, 2]),
+            'max_stress': float(pred[0, 3]),
+            'uncertainty': total_uncertainty,
+            'extrapolating': extrapolation_score > 0.1,
+            'extrapolation_score': extrapolation_score,
+            'needs_fea_validation': extrapolation_score > 0.5
+        }
+
+
+def run_optimization(surrogate: ValidatedSurrogate, bounds: dict, n_trials: int = 1000):
+    """Run multi-objective optimization.
+
+    Args:
+        surrogate: ValidatedSurrogate model
+        bounds: Dict from load_config_bounds {name: (min, max, is_int)}
+        n_trials: Number of optimization trials
+    """
+    print(f"\nOptimization bounds (from config):")
+    for name, (low, high, is_int) in bounds.items():
+        type_str = "int" if is_int else "float"
+        print(f"  {name}: [{low}, {high}] ({type_str})")
+
+    # Create study
+    study = optuna.create_study(
+        directions=["minimize", "minimize"],  # mass, -frequency
+        sampler=NSGAIISampler()
+    )
+
+    # Track stats
+    start_time = time.time()
+    trial_times = []
+    extrapolation_count = 0
+
+    def objective(trial: optuna.Trial):
+        nonlocal extrapolation_count
+
+        params = {}
+        for name, (low, high, is_int) in bounds.items():
+            if is_int:
+                params[name] = trial.suggest_int(name, int(low), int(high))
+            else:
+                params[name] = trial.suggest_float(name, float(low), float(high))
+
+        trial_start = time.time()
+        result = surrogate.predict(params)
+        trial_time = (time.time() - trial_start) * 1000
+        trial_times.append(trial_time)
+
+        # Track extrapolation
+        if result['extrapolating']:
+            extrapolation_count += 1
+
+        # Store metadata
+        trial.set_user_attr('uncertainty', result['uncertainty'])
+        trial.set_user_attr('extrapolating', result['extrapolating'])
+        trial.set_user_attr('needs_fea', result['needs_fea_validation'])
+        trial.set_user_attr('params', params)
+
+        if trial.number % 200 == 0:
+            print(f"  Trial {trial.number}: mass={result['mass']:.1f}g, freq={result['frequency']:.2f}Hz, extrap={result['extrapolating']}")
+
+        return result['mass'], -result['frequency']
+
+    print(f"\nRunning {n_trials} trials...")
+    study.optimize(objective, n_trials=n_trials, show_progress_bar=True)
+
+    total_time = time.time() - start_time
+
+    return study, {
+        'total_time': total_time,
+        'avg_trial_time_ms': np.mean(trial_times),
+        'trials_per_second': n_trials / total_time,
+        'extrapolation_count': extrapolation_count,
+        'extrapolation_pct': extrapolation_count / n_trials * 100
+    }
+
+
+def analyze_pareto_front(study, surrogate):
+    """Analyze Pareto front with confidence information."""
+    pareto_trials = study.best_trials
+
+    results = {
+        'total_pareto_designs': len(pareto_trials),
+        'confident_designs': 0,
+        'needs_fea_designs': 0,
+        'designs': []
+    }
+
+    for trial in pareto_trials:
+        mass = trial.values[0]
+        freq = -trial.values[1]
+        uncertainty = trial.user_attrs.get('uncertainty', 0)
+        needs_fea = trial.user_attrs.get('needs_fea', False)
+        params = trial.user_attrs.get('params', trial.params)
+
+        if needs_fea:
+            results['needs_fea_designs'] += 1
+        else:
+            results['confident_designs'] += 1
+
+        results['designs'].append({
+            'mass': mass,
+            'frequency': freq,
+            'uncertainty': uncertainty,
+            'needs_fea': needs_fea,
+            'params': params
+        })
+
+    # Sort by mass
+    results['designs'].sort(key=lambda x: x['mass'])
+
+    return results
+
+
+def plot_results(study, pareto_analysis, surrogate, save_path):
+    """Generate visualization of optimization results."""
+    fig, axes = plt.subplots(2, 2, figsize=(14, 12))
+
+    # 1. Pareto Front with Confidence
+    ax = axes[0, 0]
+    pareto = pareto_analysis['designs']
+
+    confident = [d for d in pareto if not d['needs_fea']]
+    needs_fea = [d for d in pareto if d['needs_fea']]
+
+    if confident:
+        ax.scatter([d['mass'] for d in confident],
+                   [d['frequency'] for d in confident],
+                   c='green', s=50, alpha=0.7, label=f'Confident ({len(confident)})')
+
+    if needs_fea:
+        ax.scatter([d['mass'] for d in needs_fea],
+                   [d['frequency'] for d in needs_fea],
+                   c='orange', s=50, alpha=0.7, marker='^', label=f'Needs FEA ({len(needs_fea)})')
+
+    ax.set_xlabel('Mass (g)')
+    ax.set_ylabel('Frequency (Hz)')
+    ax.set_title('Pareto Front with Confidence Assessment')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 2. Uncertainty vs Performance
+    ax = axes[0, 1]
+    all_trials = study.trials
+    masses = [t.values[0] for t in all_trials if t.values]
+    freqs = [-t.values[1] for t in all_trials if t.values]
+    uncertainties = [t.user_attrs.get('uncertainty', 0) for t in all_trials if t.values]
+
+    sc = ax.scatter(masses, freqs, c=uncertainties, cmap='RdYlGn_r', s=10, alpha=0.5)
+    plt.colorbar(sc, ax=ax, label='Uncertainty')
+    ax.set_xlabel('Mass (g)')
+    ax.set_ylabel('Frequency (Hz)')
+    ax.set_title('All Trials Colored by Uncertainty')
+    ax.grid(True, alpha=0.3)
+
+    # 3. Top 10 Pareto Designs
+    ax = axes[1, 0]
+    top_10 = pareto_analysis['designs'][:10]
+
+    y_pos = np.arange(len(top_10))
+    bars = ax.barh(y_pos, [d['mass'] for d in top_10],
+                   color=['green' if not d['needs_fea'] else 'orange' for d in top_10])
+
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels([f"#{i+1}: {d['frequency']:.1f}Hz" for i, d in enumerate(top_10)])
+    ax.set_xlabel('Mass (g)')
+    ax.set_title('Top 10 Lowest Mass Designs')
+    ax.grid(True, alpha=0.3, axis='x')
+
+    # Add confidence text
+    for i, (bar, d) in enumerate(zip(bars, top_10)):
+        status = "FEA!" if d['needs_fea'] else "OK"
+        ax.text(bar.get_width() + 10, bar.get_y() + bar.get_height()/2,
+                status, va='center', fontsize=9)
+
+    # 4. Summary Text
+    ax = axes[1, 1]
+    ax.axis('off')
+
+    summary_text = f"""
+OPTIMIZATION SUMMARY
+====================
+
+CV-Validated Model Accuracy:
+  Mass MAPE: {surrogate.cv_mass_mape:.1f}% +/- {surrogate.cv_mass_std:.1f}%
+  Freq MAPE: {surrogate.cv_freq_mape:.1f}% +/- {surrogate.cv_freq_std:.1f}%
+  Training samples: {surrogate.n_training_samples}
+
+Pareto Front:
+  Total designs: {pareto_analysis['total_pareto_designs']}
+  High confidence: {pareto_analysis['confident_designs']}
+  Needs FEA validation: {pareto_analysis['needs_fea_designs']}
+
+Best Confident Design:
+"""
+    # Find best confident design
+    best_confident = [d for d in pareto_analysis['designs'] if not d['needs_fea']]
+    if best_confident:
+        best = best_confident[0]
+        summary_text += f"""
+  Mass: {best['mass']:.1f}g
+  Frequency: {best['frequency']:.2f}Hz
+  Parameters:
+"""
+        for k, v in best['params'].items():
+            if isinstance(v, float):
+                summary_text += f"    {k}: {v:.3f}\n"
+            else:
+                summary_text += f"    {k}: {v}\n"
+    else:
+        summary_text += "  No confident designs found - run more FEA!"
+
+    ax.text(0.05, 0.95, summary_text, transform=ax.transAxes,
+            fontfamily='monospace', fontsize=10, verticalalignment='top')
+
+    plt.suptitle('NN-Based Multi-Objective Optimization Results', fontsize=14, fontweight='bold')
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150)
+    plt.close()
+    print(f"Saved plot: {save_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='NN Optimization with Confidence Bounds')
+    parser.add_argument('--study', default='uav_arm_optimization',
+                        help='Study name (e.g., uav_arm_optimization)')
+    parser.add_argument('--model', default=None,
+                        help='Path to CV-validated model (default: cv_validated_surrogate.pt)')
+    parser.add_argument('--trials', type=int, default=2000,
+                        help='Number of optimization trials')
+    args = parser.parse_args()
+
+    print("="*70)
+    print("Production-Ready NN Optimization with Confidence Bounds")
+    print("="*70)
+
+    # Load bounds from study config
+    study_path = project_root / "studies" / args.study
+    if not study_path.exists():
+        print(f"ERROR: Study not found: {study_path}")
+        return
+
+    print(f"\nLoading bounds from study: {args.study}")
+    bounds = load_config_bounds(study_path)
+    print(f"  Loaded {len(bounds)} design variables from config")
+
+    # Load CV-validated model
+    model_path = Path(args.model) if args.model else project_root / "cv_validated_surrogate.pt"
+    if not model_path.exists():
+        print(f"ERROR: Run validate_surrogate_real_data.py first to create {model_path}")
+        return
+
+    print(f"\nLoading CV-validated model: {model_path}")
+    surrogate = ValidatedSurrogate(str(model_path))
+
+    print(f"\nModel Statistics:")
+    print(f"  Training samples: {surrogate.n_training_samples}")
+    print(f"  CV Mass MAPE: {surrogate.cv_mass_mape:.1f}% +/- {surrogate.cv_mass_std:.1f}%")
+    print(f"  CV Freq MAPE: {surrogate.cv_freq_mape:.1f}% +/- {surrogate.cv_freq_std:.1f}%")
+    print(f"  Design variables: {surrogate.design_var_names}")
+
+    # Verify model variables match config variables
+    config_vars = set(bounds.keys())
+    model_vars = set(surrogate.design_var_names)
+    if config_vars != model_vars:
+        print(f"\nWARNING: Variable mismatch!")
+        print(f"  Config has: {config_vars}")
+        print(f"  Model has: {model_vars}")
+        print(f"  Missing from model: {config_vars - model_vars}")
+        print(f"  Extra in model: {model_vars - config_vars}")
+
+    # Run optimization
+    print("\n" + "="*70)
+    print("Running Multi-Objective Optimization")
+    print("="*70)
+
+    study, stats = run_optimization(surrogate, bounds, n_trials=args.trials)
+
+    print(f"\nOptimization Statistics:")
+    print(f"  Total time: {stats['total_time']:.1f}s")
+    print(f"  Avg trial time: {stats['avg_trial_time_ms']:.2f}ms")
+    print(f"  Trials per second: {stats['trials_per_second']:.1f}")
+    print(f"  Extrapolating trials: {stats['extrapolation_count']} ({stats['extrapolation_pct']:.1f}%)")
+
+    # Analyze Pareto front
+    print("\n" + "="*70)
+    print("Pareto Front Analysis")
+    print("="*70)
+
+    pareto_analysis = analyze_pareto_front(study, surrogate)
+
+    print(f"\nPareto Front Summary:")
+    print(f"  Total Pareto-optimal designs: {pareto_analysis['total_pareto_designs']}")
+    print(f"  High confidence designs: {pareto_analysis['confident_designs']}")
+    print(f"  Needs FEA validation: {pareto_analysis['needs_fea_designs']}")
+
+    print(f"\nTop 5 Lowest Mass Designs:")
+    for i, d in enumerate(pareto_analysis['designs'][:5]):
+        status = "[NEEDS FEA]" if d['needs_fea'] else "[OK]"
+        print(f"  {i+1}. Mass={d['mass']:.1f}g, Freq={d['frequency']:.2f}Hz {status}")
+        print(f"      Params: {d['params']}")
+
+    # Generate plots
+    plot_path = project_root / "validated_nn_optimization_results.png"
+    plot_results(study, pareto_analysis, surrogate, str(plot_path))
+
+    # Save results
+    results_path = project_root / "validated_nn_optimization_results.json"
+    with open(results_path, 'w') as f:
+        json.dump({
+            'stats': stats,
+            'pareto_summary': {
+                'total': pareto_analysis['total_pareto_designs'],
+                'confident': pareto_analysis['confident_designs'],
+                'needs_fea': pareto_analysis['needs_fea_designs']
+            },
+            'top_designs': pareto_analysis['designs'][:20],
+            'cv_metrics': {
+                'mass_mape': surrogate.cv_mass_mape,
+                'freq_mape': surrogate.cv_freq_mape
+            }
+        }, f, indent=2)
+    print(f"\nSaved results: {results_path}")
+
+    print("\n" + "="*70)
+    print("NEXT STEPS")
+    print("="*70)
+
+    if pareto_analysis['confident_designs'] > 0:
+        print("1. Review the confident Pareto-optimal designs above")
+        print("2. Consider validating top 3-5 designs with actual FEA")
+        print("3. If FEA matches predictions, use for manufacturing")
+    else:
+        print("1. All Pareto designs are extrapolating - need more FEA data!")
+        print("2. Run FEA on designs marked [NEEDS FEA]")
+        print("3. Retrain the model with new data")
+
+
+if __name__ == '__main__':
+    main()

archive/scripts/validate_surrogate_real_data.py

@@ -0,0 +1,432 @@
+"""
+Real Data Cross-Validation for Surrogate Model
+
+This script performs proper k-fold cross-validation using ONLY real FEA data
+to assess the true prediction accuracy of the neural network surrogate.
+
+The key insight: We don't need simulated FEA - we already have real FEA data!
+We can use cross-validation to estimate out-of-sample performance.
+"""
+import sys
+from pathlib import Path
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.model_selection import KFold
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+# Add project paths
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+from optimization_engine.active_learning_surrogate import (
+    EnsembleMLP,
+    extract_training_data_from_study
+)
+
+
+def k_fold_cross_validation(
+    design_params: np.ndarray,
+    objectives: np.ndarray,
+    design_var_names: list,
+    n_folds: int = 5,
+    hidden_dims: list = [128, 64, 32],  # Deeper network
+    epochs: int = 300,
+    lr: float = 0.001
+):
+    """
+    Perform k-fold cross-validation to assess real prediction performance.
+
+    Returns detailed metrics for each fold.
+    """
+    kf = KFold(n_splits=n_folds, shuffle=True, random_state=42)
+
+    fold_results = []
+    all_predictions = []
+    all_actuals = []
+    all_indices = []
+
+    for fold, (train_idx, test_idx) in enumerate(kf.split(design_params)):
+        print(f"\n--- Fold {fold+1}/{n_folds} ---")
+
+        X_train, X_test = design_params[train_idx], design_params[test_idx]
+        y_train, y_test = objectives[train_idx], objectives[test_idx]
+
+        # Normalization on training data
+        X_mean = X_train.mean(axis=0)
+        X_std = X_train.std(axis=0) + 1e-8
+        y_mean = y_train.mean(axis=0)
+        y_std = y_train.std(axis=0) + 1e-8
+
+        X_train_norm = (X_train - X_mean) / X_std
+        X_test_norm = (X_test - X_mean) / X_std
+        y_train_norm = (y_train - y_mean) / y_std
+
+        # Convert to tensors
+        X_train_t = torch.FloatTensor(X_train_norm)
+        y_train_t = torch.FloatTensor(y_train_norm)
+        X_test_t = torch.FloatTensor(X_test_norm)
+
+        # Train model
+        input_dim = X_train.shape[1]
+        output_dim = y_train.shape[1]
+        model = EnsembleMLP(input_dim, output_dim, hidden_dims)
+
+        optimizer = optim.Adam(model.parameters(), lr=lr)
+        criterion = nn.MSELoss()
+
+        # Training with early stopping
+        best_loss = float('inf')
+        patience = 30
+        patience_counter = 0
+        best_state = None
+
+        for epoch in range(epochs):
+            model.train()
+
+            # Mini-batch training
+            batch_size = 32
+            perm = torch.randperm(len(X_train_t))
+            epoch_loss = 0
+            n_batches = 0
+
+            for j in range(0, len(X_train_t), batch_size):
+                batch_idx = perm[j:j+batch_size]
+                X_batch = X_train_t[batch_idx]
+                y_batch = y_train_t[batch_idx]
+
+                optimizer.zero_grad()
+                pred = model(X_batch)
+                loss = criterion(pred, y_batch)
+                loss.backward()
+                optimizer.step()
+
+                epoch_loss += loss.item()
+                n_batches += 1
+
+            avg_loss = epoch_loss / n_batches
+            if avg_loss < best_loss:
+                best_loss = avg_loss
+                best_state = model.state_dict().copy()
+                patience_counter = 0
+            else:
+                patience_counter += 1
+                if patience_counter >= patience:
+                    break
+
+        # Restore best model
+        if best_state:
+            model.load_state_dict(best_state)
+
+        # Evaluate on test set
+        model.eval()
+        with torch.no_grad():
+            pred_norm = model(X_test_t).numpy()
+            pred = pred_norm * y_std + y_mean
+
+        # Calculate errors for each objective
+        mass_pred = pred[:, 0]
+        mass_actual = y_test[:, 0]
+        freq_pred = pred[:, 1]
+        freq_actual = y_test[:, 1]
+
+        mass_errors = np.abs(mass_pred - mass_actual) / (np.abs(mass_actual) + 1e-8)
+        freq_errors = np.abs(freq_pred - freq_actual) / (np.abs(freq_actual) + 1e-8)
+
+        mass_mape = np.mean(mass_errors) * 100
+        freq_mape = np.mean(freq_errors) * 100
+        mass_rmse = np.sqrt(np.mean((mass_pred - mass_actual)**2))
+        freq_rmse = np.sqrt(np.mean((freq_pred - freq_actual)**2))
+
+        fold_results.append({
+            'fold': fold + 1,
+            'n_train': len(train_idx),
+            'n_test': len(test_idx),
+            'mass_mape': mass_mape,
+            'freq_mape': freq_mape,
+            'mass_rmse': mass_rmse,
+            'freq_rmse': freq_rmse,
+            'epochs_trained': epoch + 1
+        })
+
+        # Store for plotting
+        all_predictions.extend(pred.tolist())
+        all_actuals.extend(y_test.tolist())
+        all_indices.extend(test_idx.tolist())
+
+        print(f"  Mass MAPE: {mass_mape:.1f}%, RMSE: {mass_rmse:.1f}g")
+        print(f"  Freq MAPE: {freq_mape:.1f}%, RMSE: {freq_rmse:.1f}Hz")
+
+    return fold_results, np.array(all_predictions), np.array(all_actuals), all_indices
+
+
+def train_final_model_with_cv_uncertainty(
+    design_params: np.ndarray,
+    objectives: np.ndarray,
+    design_var_names: list,
+    cv_results: dict
+):
+    """
+    Train final model on all data and attach CV-based uncertainty estimates.
+    """
+    print("\n" + "="*60)
+    print("Training Final Model on All Data")
+    print("="*60)
+
+    # Normalization
+    X_mean = design_params.mean(axis=0)
+    X_std = design_params.std(axis=0) + 1e-8
+    y_mean = objectives.mean(axis=0)
+    y_std = objectives.std(axis=0) + 1e-8
+
+    X_norm = (design_params - X_mean) / X_std
+    y_norm = (objectives - y_mean) / y_std
+
+    X_t = torch.FloatTensor(X_norm)
+    y_t = torch.FloatTensor(y_norm)
+
+    # Train on all data
+    input_dim = design_params.shape[1]
+    output_dim = objectives.shape[1]
+    model = EnsembleMLP(input_dim, output_dim, [128, 64, 32])
+
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+    criterion = nn.MSELoss()
+
+    for epoch in range(500):
+        model.train()
+        optimizer.zero_grad()
+        pred = model(X_t)
+        loss = criterion(pred, y_t)
+        loss.backward()
+        optimizer.step()
+
+    # Save model with metadata
+    model_state = {
+        'model': model.state_dict(),
+        'input_mean': X_mean.tolist(),
+        'input_std': X_std.tolist(),
+        'output_mean': y_mean.tolist(),
+        'output_std': y_std.tolist(),
+        'design_var_names': design_var_names,
+        'cv_mass_mape': cv_results['mass_mape'],
+        'cv_freq_mape': cv_results['freq_mape'],
+        'cv_mass_std': cv_results['mass_std'],
+        'cv_freq_std': cv_results['freq_std'],
+        'n_samples': len(design_params),
+        'hidden_dims': [128, 64, 32]
+    }
+
+    save_path = project_root / "cv_validated_surrogate.pt"
+    torch.save(model_state, save_path)
+    print(f"Saved CV-validated model to: {save_path}")
+
+    return model, model_state
+
+
+def plot_cv_results(
+    all_predictions: np.ndarray,
+    all_actuals: np.ndarray,
+    fold_results: list,
+    save_path: str
+):
+    """Generate comprehensive validation plots."""
+    fig, axes = plt.subplots(2, 3, figsize=(15, 10))
+
+    # 1. Mass: Predicted vs Actual
+    ax = axes[0, 0]
+    ax.scatter(all_actuals[:, 0], all_predictions[:, 0], alpha=0.5, s=20)
+    min_val = min(all_actuals[:, 0].min(), all_predictions[:, 0].min())
+    max_val = max(all_actuals[:, 0].max(), all_predictions[:, 0].max())
+    ax.plot([min_val, max_val], [min_val, max_val], 'r--', linewidth=2, label='Perfect')
+    ax.set_xlabel('FEA Mass (g)')
+    ax.set_ylabel('NN Predicted Mass (g)')
+    ax.set_title('Mass: Predicted vs Actual')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 2. Frequency: Predicted vs Actual
+    ax = axes[0, 1]
+    ax.scatter(all_actuals[:, 1], all_predictions[:, 1], alpha=0.5, s=20)
+    min_val = min(all_actuals[:, 1].min(), all_predictions[:, 1].min())
+    max_val = max(all_actuals[:, 1].max(), all_predictions[:, 1].max())
+    ax.plot([min_val, max_val], [min_val, max_val], 'r--', linewidth=2, label='Perfect')
+    ax.set_xlabel('FEA Frequency (Hz)')
+    ax.set_ylabel('NN Predicted Frequency (Hz)')
+    ax.set_title('Frequency: Predicted vs Actual')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 3. Mass Errors by Fold
+    ax = axes[0, 2]
+    folds = [r['fold'] for r in fold_results]
+    mass_mapes = [r['mass_mape'] for r in fold_results]
+    bars = ax.bar(folds, mass_mapes, color='steelblue', alpha=0.7)
+    ax.axhline(y=np.mean(mass_mapes), color='red', linestyle='--', label=f'Mean: {np.mean(mass_mapes):.1f}%')
+    ax.axhline(y=10, color='green', linestyle='--', label='Target: 10%')
+    ax.set_xlabel('Fold')
+    ax.set_ylabel('Mass MAPE (%)')
+    ax.set_title('Mass MAPE by Fold')
+    ax.legend()
+    ax.grid(True, alpha=0.3, axis='y')
+
+    # 4. Frequency Errors by Fold
+    ax = axes[1, 0]
+    freq_mapes = [r['freq_mape'] for r in fold_results]
+    bars = ax.bar(folds, freq_mapes, color='coral', alpha=0.7)
+    ax.axhline(y=np.mean(freq_mapes), color='red', linestyle='--', label=f'Mean: {np.mean(freq_mapes):.1f}%')
+    ax.axhline(y=10, color='green', linestyle='--', label='Target: 10%')
+    ax.set_xlabel('Fold')
+    ax.set_ylabel('Frequency MAPE (%)')
+    ax.set_title('Frequency MAPE by Fold')
+    ax.legend()
+    ax.grid(True, alpha=0.3, axis='y')
+
+    # 5. Error Distribution (Mass)
+    ax = axes[1, 1]
+    mass_errors = (all_predictions[:, 0] - all_actuals[:, 0]) / all_actuals[:, 0] * 100
+    ax.hist(mass_errors, bins=30, color='steelblue', alpha=0.7, edgecolor='black')
+    ax.axvline(x=0, color='red', linestyle='--', linewidth=2)
+    ax.set_xlabel('Mass Error (%)')
+    ax.set_ylabel('Count')
+    ax.set_title(f'Mass Error Distribution (Mean={np.mean(mass_errors):.1f}%, Std={np.std(mass_errors):.1f}%)')
+    ax.grid(True, alpha=0.3)
+
+    # 6. Error Distribution (Frequency)
+    ax = axes[1, 2]
+    freq_errors = (all_predictions[:, 1] - all_actuals[:, 1]) / all_actuals[:, 1] * 100
+    ax.hist(freq_errors, bins=30, color='coral', alpha=0.7, edgecolor='black')
+    ax.axvline(x=0, color='red', linestyle='--', linewidth=2)
+    ax.set_xlabel('Frequency Error (%)')
+    ax.set_ylabel('Count')
+    ax.set_title(f'Freq Error Distribution (Mean={np.mean(freq_errors):.1f}%, Std={np.std(freq_errors):.1f}%)')
+    ax.grid(True, alpha=0.3)
+
+    plt.suptitle('Cross-Validation Results on Real FEA Data', fontsize=14, fontweight='bold')
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=150)
+    plt.close()
+    print(f"Saved validation plot: {save_path}")
+
+
+def main():
+    print("="*70)
+    print("Cross-Validation Assessment on Real FEA Data")
+    print("="*70)
+
+    # Find database
+    db_path = project_root / "studies/uav_arm_optimization/2_results/study.db"
+    study_name = "uav_arm_optimization"
+
+    if not db_path.exists():
+        db_path = project_root / "studies/uav_arm_atomizerfield_test/2_results/study.db"
+        study_name = "uav_arm_atomizerfield_test"
+
+    if not db_path.exists():
+        print(f"ERROR: No database found")
+        return
+
+    print(f"\nLoading data from: {db_path}")
+    design_params, objectives, design_var_names = extract_training_data_from_study(
+        str(db_path), study_name
+    )
+
+    print(f"Total FEA samples: {len(design_params)}")
+    print(f"Design variables: {design_var_names}")
+    print(f"Objective ranges:")
+    print(f"  Mass: {objectives[:, 0].min():.1f} - {objectives[:, 0].max():.1f} g")
+    print(f"  Frequency: {objectives[:, 1].min():.1f} - {objectives[:, 1].max():.1f} Hz")
+
+    # Run k-fold cross-validation
+    print("\n" + "="*70)
+    print("Running 5-Fold Cross-Validation")
+    print("="*70)
+
+    fold_results, all_predictions, all_actuals, all_indices = k_fold_cross_validation(
+        design_params, objectives, design_var_names,
+        n_folds=5,
+        hidden_dims=[128, 64, 32],  # Deeper network
+        epochs=300
+    )
+
+    # Summary statistics
+    print("\n" + "="*70)
+    print("CROSS-VALIDATION SUMMARY")
+    print("="*70)
+
+    mass_mapes = [r['mass_mape'] for r in fold_results]
+    freq_mapes = [r['freq_mape'] for r in fold_results]
+
+    cv_summary = {
+        'mass_mape': np.mean(mass_mapes),
+        'mass_std': np.std(mass_mapes),
+        'freq_mape': np.mean(freq_mapes),
+        'freq_std': np.std(freq_mapes)
+    }
+
+    print(f"\nMass Prediction:")
+    print(f"  MAPE: {cv_summary['mass_mape']:.1f}% +/- {cv_summary['mass_std']:.1f}%")
+    print(f"  Status: {'[OK]' if cv_summary['mass_mape'] < 10 else '[NEEDS IMPROVEMENT]'}")
+
+    print(f"\nFrequency Prediction:")
+    print(f"  MAPE: {cv_summary['freq_mape']:.1f}% +/- {cv_summary['freq_std']:.1f}%")
+    print(f"  Status: {'[OK]' if cv_summary['freq_mape'] < 10 else '[NEEDS IMPROVEMENT]'}")
+
+    # Overall confidence
+    mass_ok = cv_summary['mass_mape'] < 10
+    freq_ok = cv_summary['freq_mape'] < 10
+
+    if mass_ok and freq_ok:
+        confidence = "HIGH"
+        recommendation = "NN surrogate is ready for optimization"
+    elif mass_ok:
+        confidence = "MEDIUM"
+        recommendation = "Mass prediction is good, but frequency needs more data or better architecture"
+    else:
+        confidence = "LOW"
+        recommendation = "Need more FEA data or improved NN architecture"
+
+    print(f"\nOverall Confidence: {confidence}")
+    print(f"Recommendation: {recommendation}")
+
+    # Generate plots
+    plot_path = project_root / "cv_validation_results.png"
+    plot_cv_results(all_predictions, all_actuals, fold_results, str(plot_path))
+
+    # Train and save final model
+    model, model_state = train_final_model_with_cv_uncertainty(
+        design_params, objectives, design_var_names, cv_summary
+    )
+
+    print("\n" + "="*70)
+    print("FILES GENERATED")
+    print("="*70)
+    print(f"  Validation plot: {plot_path}")
+    print(f"  CV-validated model: {project_root / 'cv_validated_surrogate.pt'}")
+
+    # Final assessment
+    print("\n" + "="*70)
+    print("NEXT STEPS")
+    print("="*70)
+
+    if confidence == "HIGH":
+        print("1. Use the NN surrogate for fast optimization")
+        print("2. Periodically validate Pareto-optimal designs with FEA")
+    elif confidence == "MEDIUM":
+        print("1. Frequency prediction needs improvement")
+        print("2. Options:")
+        print("   a. Collect more FEA samples in underrepresented regions")
+        print("   b. Try deeper/wider network architecture")
+        print("   c. Add physics-informed features (e.g., I-beam moment of inertia)")
+        print("   d. Use ensemble with uncertainty-weighted Pareto front")
+    else:
+        print("1. Current model not ready for optimization")
+        print("2. Run more FEA trials to expand training data")
+        print("3. Consider data augmentation or transfer learning")
+
+
+if __name__ == '__main__':
+    main()

archive/scripts/visualize_nn_optimization.py

@@ -0,0 +1,368 @@
+"""
+Visualization and Validation of NN-Only Optimization Results
+
+This script:
+1. Plots the Pareto front from NN optimization
+2. Compares NN predictions vs actual FEA data
+3. Shows prediction confidence and error analysis
+4. Validates selected NN-optimal designs with FEA data
+"""
+import sys
+from pathlib import Path
+import json
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')  # Non-interactive backend for headless operation
+import matplotlib.pyplot as plt
+import optuna
+
+# Add project paths
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+from optimization_engine.simple_mlp_surrogate import SimpleSurrogate
+
+def load_fea_data_from_database(db_path: str, study_name: str):
+    """Load actual FEA results from database for comparison."""
+    storage = optuna.storages.RDBStorage(f"sqlite:///{db_path}")
+    study = optuna.load_study(study_name=study_name, storage=storage)
+
+    completed_trials = [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE]
+
+    data = []
+    for trial in completed_trials:
+        if len(trial.values) < 2:
+            continue
+        mass = trial.values[0]
+        # Handle both formats: some stores -freq (for minimization), some store +freq
+        raw_freq = trial.values[1]
+        # If frequency is stored as negative (minimization convention), flip it
+        frequency = -raw_freq if raw_freq < 0 else raw_freq
+
+        # Skip invalid
+        if np.isinf(mass) or np.isinf(frequency) or frequency <= 0:
+            continue
+
+        data.append({
+            'params': trial.params,
+            'mass': mass,
+            'frequency': frequency,
+            'max_displacement': trial.user_attrs.get('max_displacement', 0),
+            'max_stress': trial.user_attrs.get('max_stress', 0),
+        })
+
+    return data
+
+def plot_pareto_comparison(nn_results, fea_data, surrogate):
+    """Plot Pareto fronts: NN optimization vs FEA data."""
+    fig, axes = plt.subplots(2, 2, figsize=(14, 12))
+
+    # Extract NN Pareto front
+    nn_mass = [d['mass'] for d in nn_results['pareto_designs']]
+    nn_freq = [d['frequency'] for d in nn_results['pareto_designs']]
+
+    # Extract FEA data
+    fea_mass = [d['mass'] for d in fea_data]
+    fea_freq = [d['frequency'] for d in fea_data]
+
+    # 1. Pareto Front Comparison
+    ax = axes[0, 0]
+    ax.scatter(fea_mass, fea_freq, alpha=0.5, label='FEA Trials', c='blue', s=30)
+    ax.scatter(nn_mass, nn_freq, alpha=0.7, label='NN Pareto Front', c='red', s=20, marker='x')
+    ax.set_xlabel('Mass (g)')
+    ax.set_ylabel('Frequency (Hz)')
+    ax.set_title('Pareto Front: NN Optimization vs FEA Data')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 2. NN Prediction Error on FEA Data
+    ax = axes[0, 1]
+    nn_pred_mass = []
+    nn_pred_freq = []
+    actual_mass = []
+    actual_freq = []
+
+    for d in fea_data:
+        pred = surrogate.predict(d['params'])
+        nn_pred_mass.append(pred['mass'])
+        nn_pred_freq.append(pred['frequency'])
+        actual_mass.append(d['mass'])
+        actual_freq.append(d['frequency'])
+
+    # Mass prediction error
+    mass_errors = np.array(nn_pred_mass) - np.array(actual_mass)
+    freq_errors = np.array(nn_pred_freq) - np.array(actual_freq)
+
+    scatter = ax.scatter(actual_mass, actual_freq, c=np.abs(mass_errors),
+                         cmap='RdYlGn_r', s=50, alpha=0.7)
+    plt.colorbar(scatter, ax=ax, label='Mass Prediction Error (g)')
+    ax.set_xlabel('Actual Mass (g)')
+    ax.set_ylabel('Actual Frequency (Hz)')
+    ax.set_title('FEA Points Colored by NN Mass Error')
+    ax.grid(True, alpha=0.3)
+
+    # 3. Prediction vs Actual (Mass)
+    ax = axes[1, 0]
+    ax.scatter(actual_mass, nn_pred_mass, alpha=0.6, s=30)
+    min_val, max_val = min(actual_mass), max(actual_mass)
+    ax.plot([min_val, max_val], [min_val, max_val], 'r--', label='Perfect Prediction')
+    ax.set_xlabel('Actual Mass (g)')
+    ax.set_ylabel('NN Predicted Mass (g)')
+    ax.set_title(f'Mass: NN vs FEA\nMAPE: {np.mean(np.abs(mass_errors)/np.array(actual_mass))*100:.1f}%')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # 4. Prediction vs Actual (Frequency)
+    ax = axes[1, 1]
+    ax.scatter(actual_freq, nn_pred_freq, alpha=0.6, s=30)
+    min_val, max_val = min(actual_freq), max(actual_freq)
+    ax.plot([min_val, max_val], [min_val, max_val], 'r--', label='Perfect Prediction')
+    ax.set_xlabel('Actual Frequency (Hz)')
+    ax.set_ylabel('NN Predicted Frequency (Hz)')
+    ax.set_title(f'Frequency: NN vs FEA\nMAPE: {np.mean(np.abs(freq_errors)/np.array(actual_freq))*100:.1f}%')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(project_root / 'nn_optimization_analysis.png', dpi=150)
+    print(f"Saved: nn_optimization_analysis.png")
+    plt.close()
+
+    return mass_errors, freq_errors
+
+def plot_design_space_coverage(nn_results, fea_data):
+    """Show how well NN explored the design space."""
+    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
+
+    param_names = ['beam_half_core_thickness', 'beam_face_thickness',
+                   'holes_diameter', 'hole_count']
+
+    for idx, (param1, param2) in enumerate([
+        ('beam_half_core_thickness', 'beam_face_thickness'),
+        ('holes_diameter', 'hole_count'),
+        ('beam_half_core_thickness', 'holes_diameter'),
+        ('beam_face_thickness', 'hole_count')
+    ]):
+        ax = axes[idx // 2, idx % 2]
+
+        # FEA data points
+        fea_p1 = [d['params'].get(param1, 0) for d in fea_data]
+        fea_p2 = [d['params'].get(param2, 0) for d in fea_data]
+
+        # NN Pareto designs
+        nn_p1 = [d['params'].get(param1, 0) for d in nn_results['pareto_designs']]
+        nn_p2 = [d['params'].get(param2, 0) for d in nn_results['pareto_designs']]
+
+        ax.scatter(fea_p1, fea_p2, alpha=0.4, label='FEA Trials', c='blue', s=30)
+        ax.scatter(nn_p1, nn_p2, alpha=0.7, label='NN Pareto', c='red', s=20, marker='x')
+
+        ax.set_xlabel(param1.replace('_', ' ').title())
+        ax.set_ylabel(param2.replace('_', ' ').title())
+        ax.legend()
+        ax.grid(True, alpha=0.3)
+
+    plt.suptitle('Design Space Coverage: FEA vs NN Pareto Designs', fontsize=14)
+    plt.tight_layout()
+    plt.savefig(project_root / 'nn_design_space_coverage.png', dpi=150)
+    print(f"Saved: nn_design_space_coverage.png")
+    plt.close()
+
+def plot_error_distribution(mass_errors, freq_errors):
+    """Plot error distributions to understand prediction confidence."""
+    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
+
+    # Mass error histogram
+    ax = axes[0]
+    ax.hist(mass_errors, bins=30, edgecolor='black', alpha=0.7)
+    ax.axvline(0, color='r', linestyle='--', label='Zero Error')
+    ax.axvline(np.mean(mass_errors), color='g', linestyle='-',
+               label=f'Mean: {np.mean(mass_errors):.1f}g')
+    ax.set_xlabel('Mass Prediction Error (g)')
+    ax.set_ylabel('Count')
+    ax.set_title(f'Mass Error Distribution\nStd: {np.std(mass_errors):.1f}g')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    # Frequency error histogram
+    ax = axes[1]
+    ax.hist(freq_errors, bins=30, edgecolor='black', alpha=0.7)
+    ax.axvline(0, color='r', linestyle='--', label='Zero Error')
+    ax.axvline(np.mean(freq_errors), color='g', linestyle='-',
+               label=f'Mean: {np.mean(freq_errors):.1f}Hz')
+    ax.set_xlabel('Frequency Prediction Error (Hz)')
+    ax.set_ylabel('Count')
+    ax.set_title(f'Frequency Error Distribution\nStd: {np.std(freq_errors):.1f}Hz')
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(project_root / 'nn_error_distribution.png', dpi=150)
+    print(f"Saved: nn_error_distribution.png")
+    plt.close()
+
+def find_closest_fea_validation(nn_pareto, fea_data):
+    """Find FEA data points closest to NN Pareto designs for validation."""
+    print("\n" + "="*70)
+    print("VALIDATION: Comparing NN Pareto Designs to Nearest FEA Points")
+    print("="*70)
+
+    # Get unique NN Pareto designs (remove duplicates)
+    seen = set()
+    unique_pareto = []
+    for d in nn_pareto:
+        key = (round(d['mass'], 1), round(d['frequency'], 1))
+        if key not in seen:
+            seen.add(key)
+            unique_pareto.append(d)
+
+    # Sort by mass
+    unique_pareto.sort(key=lambda x: x['mass'])
+
+    # Sample 10 designs across the Pareto front
+    indices = np.linspace(0, len(unique_pareto)-1, min(10, len(unique_pareto)), dtype=int)
+    sampled_designs = [unique_pareto[i] for i in indices]
+
+    print(f"\nSampled {len(sampled_designs)} designs from NN Pareto front:")
+    print("-"*70)
+
+    for i, nn_design in enumerate(sampled_designs):
+        # Find closest FEA point (by parameter distance)
+        min_dist = float('inf')
+        closest_fea = None
+
+        for fea in fea_data:
+            dist = sum((nn_design['params'].get(k, 0) - fea['params'].get(k, 0))**2
+                      for k in nn_design['params'])
+            if dist < min_dist:
+                min_dist = dist
+                closest_fea = fea
+
+        if closest_fea:
+            mass_err = nn_design['mass'] - closest_fea['mass']
+            freq_err = nn_design['frequency'] - closest_fea['frequency']
+
+            print(f"\n{i+1}. NN Design: mass={nn_design['mass']:.1f}g, freq={nn_design['frequency']:.1f}Hz")
+            print(f"   Closest FEA: mass={closest_fea['mass']:.1f}g, freq={closest_fea['frequency']:.1f}Hz")
+            print(f"   Error: mass={mass_err:+.1f}g ({mass_err/closest_fea['mass']*100:+.1f}%), "
+                  f"freq={freq_err:+.1f}Hz ({freq_err/closest_fea['frequency']*100:+.1f}%)")
+            print(f"   Parameter Distance: {np.sqrt(min_dist):.2f}")
+
+def print_optimization_summary(nn_results, fea_data, mass_errors, freq_errors):
+    """Print summary statistics."""
+    print("\n" + "="*70)
+    print("OPTIMIZATION SUMMARY")
+    print("="*70)
+
+    print(f"\n1. NN Optimization Performance:")
+    print(f"   - Trials: {nn_results['n_trials']}")
+    print(f"   - Time: {nn_results['total_time_s']:.1f}s ({nn_results['trials_per_second']:.1f} trials/sec)")
+    print(f"   - Pareto Front Size: {nn_results['pareto_front_size']}")
+
+    print(f"\n2. NN Prediction Accuracy (on FEA data):")
+    print(f"   - Mass MAPE: {np.mean(np.abs(mass_errors)/np.array([d['mass'] for d in fea_data]))*100:.1f}%")
+    print(f"   - Mass Mean Error: {np.mean(mass_errors):.1f}g (Std: {np.std(mass_errors):.1f}g)")
+    print(f"   - Freq MAPE: {np.mean(np.abs(freq_errors)/np.array([d['frequency'] for d in fea_data]))*100:.1f}%")
+    print(f"   - Freq Mean Error: {np.mean(freq_errors):.1f}Hz (Std: {np.std(freq_errors):.1f}Hz)")
+
+    print(f"\n3. Design Space:")
+    nn_mass = [d['mass'] for d in nn_results['pareto_designs']]
+    nn_freq = [d['frequency'] for d in nn_results['pareto_designs']]
+    fea_mass = [d['mass'] for d in fea_data]
+    fea_freq = [d['frequency'] for d in fea_data]
+
+    print(f"   - NN Pareto Mass Range: {min(nn_mass):.1f}g - {max(nn_mass):.1f}g")
+    print(f"   - NN Pareto Freq Range: {min(nn_freq):.1f}Hz - {max(nn_freq):.1f}Hz")
+    print(f"   - FEA Mass Range: {min(fea_mass):.1f}g - {max(fea_mass):.1f}g")
+    print(f"   - FEA Freq Range: {min(fea_freq):.1f}Hz - {max(fea_freq):.1f}Hz")
+
+    print(f"\n4. Confidence Assessment:")
+    if np.std(mass_errors) < 100 and np.std(freq_errors) < 5:
+        print("   [OK] LOW prediction variance - NN is fairly confident")
+    else:
+        print("   [!] HIGH prediction variance - consider more training data")
+
+    if abs(np.mean(mass_errors)) < 50:
+        print("   [OK] LOW mass bias - predictions are well-centered")
+    else:
+        print(f"   [!] Mass bias detected ({np.mean(mass_errors):+.1f}g) - systematic error")
+
+    if abs(np.mean(freq_errors)) < 2:
+        print("   [OK] LOW frequency bias - predictions are well-centered")
+    else:
+        print(f"   [!] Frequency bias detected ({np.mean(freq_errors):+.1f}Hz) - systematic error")
+
+def main():
+    print("="*70)
+    print("NN Optimization Visualization & Validation")
+    print("="*70)
+
+    # Load NN optimization results
+    results_file = project_root / "nn_optimization_results.json"
+    if not results_file.exists():
+        print(f"ERROR: {results_file} not found. Run NN optimization first.")
+        return
+
+    with open(results_file) as f:
+        nn_results = json.load(f)
+
+    print(f"\nLoaded NN results: {nn_results['n_trials']} trials, "
+          f"{nn_results['pareto_front_size']} Pareto designs")
+
+    # Load surrogate model
+    model_path = project_root / "simple_mlp_surrogate.pt"
+    if not model_path.exists():
+        print(f"ERROR: {model_path} not found.")
+        return
+
+    surrogate = SimpleSurrogate.load(model_path)
+    print(f"Loaded surrogate model with {len(surrogate.design_var_names)} design variables")
+
+    # Load FEA data from original study
+    # Try each database path with its matching study name
+    db_options = [
+        (project_root / "studies/uav_arm_optimization/2_results/study.db", "uav_arm_optimization"),
+        (project_root / "studies/uav_arm_atomizerfield_test/2_results/study.db", "uav_arm_atomizerfield_test"),
+    ]
+
+    db_path = None
+    study_name = None
+    for path, name in db_options:
+        if path.exists():
+            db_path = path
+            study_name = name
+            break
+
+    if db_path and study_name:
+        fea_data = load_fea_data_from_database(str(db_path), study_name)
+        print(f"Loaded {len(fea_data)} FEA data points from {study_name}")
+    else:
+        print("WARNING: No FEA database found. Using only NN results.")
+        fea_data = []
+
+    if fea_data:
+        # Generate all plots
+        mass_errors, freq_errors = plot_pareto_comparison(nn_results, fea_data, surrogate)
+        plot_design_space_coverage(nn_results, fea_data)
+        plot_error_distribution(mass_errors, freq_errors)
+
+        # Print validation analysis
+        find_closest_fea_validation(nn_results['pareto_designs'], fea_data)
+        print_optimization_summary(nn_results, fea_data, mass_errors, freq_errors)
+    else:
+        # Just plot NN results
+        print("\nPlotting NN Pareto front only (no FEA data for comparison)")
+        nn_mass = [d['mass'] for d in nn_results['pareto_designs']]
+        nn_freq = [d['frequency'] for d in nn_results['pareto_designs']]
+
+        plt.figure(figsize=(10, 6))
+        plt.scatter(nn_mass, nn_freq, alpha=0.7, c='red', s=30)
+        plt.xlabel('Mass (g)')
+        plt.ylabel('Frequency (Hz)')
+        plt.title('NN Optimization Pareto Front')
+        plt.grid(True, alpha=0.3)
+        plt.savefig(project_root / 'nn_pareto_front.png', dpi=150)
+        plt.close()
+        print(f"Saved: nn_pareto_front.png")
+
+if __name__ == "__main__":
+    main()

archive/temp_outputs/calibration_history.json

@@ -0,0 +1,29 @@
+[
+  {
+    "iteration": 1,
+    "n_training_samples": 55,
+    "confidence_score": 0.48,
+    "mass_mape": 5.199446351686856,
+    "freq_mape": 46.23527454811865,
+    "avg_selected_uncertainty": 0.3559015095233917,
+    "status": "LOW_CONFIDENCE"
+  },
+  {
+    "iteration": 2,
+    "n_training_samples": 60,
+    "confidence_score": 0.6,
+    "mass_mape": 5.401324621678541,
+    "freq_mape": 88.80499920325646,
+    "avg_selected_uncertainty": 0.23130142092704772,
+    "status": "MEDIUM_CONFIDENCE"
+  },
+  {
+    "iteration": 3,
+    "n_training_samples": 65,
+    "confidence_score": 0.6,
+    "mass_mape": 4.867728649442469,
+    "freq_mape": 76.78009245481465,
+    "avg_selected_uncertainty": 0.17344236522912979,
+    "status": "MEDIUM_CONFIDENCE"
+  }
+]

archive/temp_outputs/test_output.txt

@@ -0,0 +1,122 @@
+fatal: not a git repository (or any of the parent directories): .git
+================================================================================
+  HYBRID MODE - AUTOMATED STUDY CREATION
+================================================================================
+
+[1/5] Creating study structure...
+  [OK] Study directory: circular_plate_frequency_tuning
+
+[2/5] Copying model files...
+  [OK] Copied 4 files
+
+[3/5] Installing workflow configuration...
+  [OK] Workflow: circular_plate_frequency_tuning
+  [OK] Variables: 2
+  [OK] Objectives: 1
+
+[4/5] Running benchmarking (validating simulation setup)...
+    Running INTELLIGENT benchmarking...
+    - Solving ALL solutions in .sim file
+    - Discovering all available results
+    - Matching objectives to results
+
+
+================================================================================
+  INTELLIGENT SETUP - COMPLETE ANALYSIS
+================================================================================
+
+[Phase 1/4] Extracting ALL expressions from model...
+[NX] Exporting expressions from Circular_Plate.prt to .exp format...
+[OK] Expressions exported to: c:\Users\antoi\Documents\Atomaste\Atomizer\studies\circular_plate_frequency_tuning\1_setup\model\Circular_Plate_expressions.exp
+  [OK] Found 4 expressions
+    - inner_diameter: 130.24581665835925 MilliMeter
+    - p0: None MilliMeter
+    - p1: 0.0 MilliMeter
+    - plate_thickness: 5.190705791851906 MilliMeter
+
+[Phase 2/4] Solving ALL solutions in .sim file...
+  [OK] Solved 0 solutions
+
+[Phase 3/4] Analyzing ALL result files...
+DEBUG:   op2.py:614                   combine=True
+DEBUG:   op2.py:615                   -------- reading op2 with read_mode=1 (array sizing) --------
+INFO:    op2_scalar.py:1960           op2_filename = 'c:\\Users\\antoi\\Documents\\Atomaste\\Atomizer\\studies\\circular_plate_frequency_tuning\\1_setup\\model\\circular_plate_sim1-solution_1.op2'
+DEBUG:   op2_reader.py:323            date = (11, 18, 25)
+WARNING: version.py:88                nx version='2412' is not supported
+DEBUG:   op2_reader.py:403            mode='nx' version='2412'
+DEBUG:   op2_scalar.py:2173             table_name=b'IBULK'    (explicit bulk data)
+DEBUG:   op2_scalar.py:2173             table_name=b'ICASE'    (explicit case control)
+DEBUG:   op2_scalar.py:2173             table_name=b'CASECC'   (case control)
+DEBUG:   op2_scalar.py:2173             table_name=b'PVT0'     (PARAM cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GPL'      (grid point list)
+DEBUG:   op2_scalar.py:2173             table_name=b'GPDT'     (grid point locations)
+DEBUG:   op2_scalar.py:2173             table_name=b'EPT'      (property cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'MPT'      (material cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GEOM2'    (element cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GEOM4'    (load cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GEOM1'    (grid/coord cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'BGPDT'    (grid points in cid=0 frame)
+DEBUG:   op2_scalar.py:2173             table_name=b'EQEXIN'   (internal/external ids)
+DEBUG:   op2_reader.py:672            eqexin idata=(101, 613, 0, 0, 0, 0, 0)
+DEBUG:   op2_scalar.py:2173             table_name=b'OQG1'     (spc/mpc forces)
+DEBUG:   op2_scalar.py:2173             table_name=b'BOUGV1'   (g-set U in cid=0 frame)
+DEBUG:   op2_scalar.py:2173             table_name=b'OES1'     (linear stress)
+DEBUG:   op2.py:634                   -------- reading op2 with read_mode=2 (array filling) --------
+DEBUG:   op2_reader.py:323            date = (11, 18, 25)
+WARNING: version.py:88                nx version='2412' is not supported
+DEBUG:   op2_scalar.py:2173             table_name=b'IBULK'    (explicit bulk data)
+DEBUG:   op2_scalar.py:2173             table_name=b'ICASE'    (explicit case control)
+DEBUG:   op2_scalar.py:2173             table_name=b'CASECC'   (case control)
+DEBUG:   op2_scalar.py:2173             table_name=b'PVT0'     (PARAM cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GPL'      (grid point list)
+DEBUG:   op2_scalar.py:2173             table_name=b'GPDT'     (grid point locations)
+DEBUG:   op2_scalar.py:2173             table_name=b'EPT'      (property cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'MPT'      (material cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GEOM2'    (element cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GEOM4'    (load cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'GEOM1'    (grid/coord cards)
+DEBUG:   op2_scalar.py:2173             table_name=b'BGPDT'    (grid points in cid=0 frame)
+DEBUG:   op2_scalar.py:2173             table_name=b'EQEXIN'   (internal/external ids)
+DEBUG:   op2_reader.py:672            eqexin idata=(101, 613, 0, 0, 0, 0, 0)
+DEBUG:   op2_scalar.py:2173             table_name=b'OQG1'     (spc/mpc forces)
+DEBUG:   op2_scalar.py:2173             table_name=b'BOUGV1'   (g-set U in cid=0 frame)
+DEBUG:   op2_scalar.py:2173             table_name=b'OES1'     (linear stress)
+DEBUG:   op2.py:932                   combine_results
+DEBUG:   op2.py:648                   finished reading op2
+  [OK] Found 1 result files
+    - displacements: 613 entries in circular_plate_sim1-solution_1.op2
+
+[Phase 4/4] Matching objectives to available results...
+  [OK] Objective mapping complete
+    - frequency_error
+      Solution: NONE
+      Result type: eigenvalues
+      Extractor: extract_first_frequency
+
+================================================================================
+  ANALYSIS COMPLETE
+================================================================================
+
+    [OK] Expressions found: 4
+    [OK] Solutions found: 4
+    [OK] Results discovered: 1
+    [OK] Objectives matched: 1
+         - frequency_error: eigenvalues from 'NONE' (ERROR confidence)
+  [OK] Simulation validated
+  [OK] Extracted 0 results
+
+[4.5/5] Generating configuration report...
+Traceback (most recent call last):
+  File "c:\Users\antoi\Documents\Atomaste\Atomizer\create_circular_plate_study.py", line 70, in <module>
+    main()
+  File "c:\Users\antoi\Documents\Atomaste\Atomizer\create_circular_plate_study.py", line 52, in main
+    study_dir = creator.create_from_workflow(
+                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "c:\Users\antoi\Documents\Atomaste\Atomizer\optimization_engine\hybrid_study_creator.py", line 100, in create_from_workflow
+    self._generate_configuration_report(study_dir, workflow, benchmark_results)
+  File "c:\Users\antoi\Documents\Atomaste\Atomizer\optimization_engine\hybrid_study_creator.py", line 757, in _generate_configuration_report
+    f.write(content)
+  File "C:\Users\antoi\anaconda3\envs\test_env\Lib\encodings\cp1252.py", line 19, in encode
+    return codecs.charmap_encode(input,self.errors,encoding_table)[0]
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+UnicodeEncodeError: 'charmap' codec can't encode characters in position 1535-1536: character maps to <undefined>

archive/temp_outputs/validated_nn_optimization_results.json

@@ -0,0 +1,19 @@
+{
+  "stats": {
+    "total_time": 3.4194347858428955,
+    "avg_trial_time_ms": 0.25935888290405273,
+    "trials_per_second": 584.8919851550838,
+    "extrapolation_count": 1757,
+    "extrapolation_pct": 87.85
+  },
+  "pareto_summary": {
+    "total": 407,
+    "confident": 0,
+    "needs_fea": 407
+  },
+  "top_designs": [
+    {
+      "mass": 717.7724576426426,
+      "frequency": 15.794277791999079,
+      "uncertainty": 0.3945587883026621,
+      "needs_fea": 

archive/test_scripts/test_adaptive_characterization.py

@@ -0,0 +1,164 @@
+"""
+Test script for Protocol 10 v2.0 Adaptive Characterization.
+
+This script demonstrates the new adaptive characterization feature that
+intelligently determines when enough landscape exploration has been done.
+
+Expected behavior:
+- Simple problems: Stop at ~10-15 trials
+- Complex problems: Continue to ~20-30 trials
+"""
+
+import numpy as np
+import optuna
+from pathlib import Path
+from optimization_engine.adaptive_characterization import CharacterizationStoppingCriterion
+from optimization_engine.landscape_analyzer import LandscapeAnalyzer
+
+
+def simple_smooth_function(trial):
+    """Simple smooth quadratic function (should stop early ~10-15 trials)."""
+    x = trial.suggest_float('x', -10, 10)
+    y = trial.suggest_float('y', -10, 10)
+
+    # Simple quadratic bowl
+    return (x - 3)**2 + (y + 2)**2
+
+
+def complex_multimodal_function(trial):
+    """Complex multimodal function (should need more trials ~20-30)."""
+    x = trial.suggest_float('x', -5, 5)
+    y = trial.suggest_float('y', -5, 5)
+
+    # Rastrigin function (multimodal, many local minima)
+    A = 10
+    n = 2
+    return A * n + ((x**2 - A * np.cos(2 * np.pi * x)) +
+                    (y**2 - A * np.cos(2 * np.pi * y)))
+
+
+def test_adaptive_characterization(
+    objective_function,
+    function_name: str,
+    expected_trials_range: tuple
+):
+    """Test adaptive characterization on a given function."""
+
+    print(f"\n{'='*70}")
+    print(f"  TESTING: {function_name}")
+    print(f"  Expected trials: {expected_trials_range[0]}-{expected_trials_range[1]}")
+    print(f"{'='*70}\n")
+
+    # Setup tracking directory
+    tracking_dir = Path(f"test_results/adaptive_char_{function_name.lower().replace(' ', '_')}")
+    tracking_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create components
+    analyzer = LandscapeAnalyzer(min_trials_for_analysis=10)
+    stopping_criterion = CharacterizationStoppingCriterion(
+        min_trials=10,
+        max_trials=30,
+        confidence_threshold=0.85,
+        check_interval=5,
+        verbose=True,
+        tracking_dir=tracking_dir
+    )
+
+    # Create study
+    study = optuna.create_study(
+        study_name=f"test_{function_name.lower().replace(' ', '_')}",
+        direction='minimize',
+        sampler=optuna.samplers.RandomSampler()
+    )
+
+    # Run adaptive characterization
+    check_interval = 5
+    while not stopping_criterion.should_stop(study):
+        # Run batch of trials
+        study.optimize(objective_function, n_trials=check_interval)
+
+        # Analyze landscape
+        landscape = analyzer.analyze(study)
+
+        # Update stopping criterion
+        if landscape.get('ready', False):
+            completed_trials = [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE]
+            stopping_criterion.update(landscape, len(completed_trials))
+
+    # Print results
+    completed_trials = [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE]
+    actual_trials = len(completed_trials)
+
+    print(stopping_criterion.get_summary_report())
+
+    # Verify expectation
+    in_range = expected_trials_range[0] <= actual_trials <= expected_trials_range[1]
+    status = "PASS" if in_range else "FAIL"
+
+    print(f"\n{'='*70}")
+    print(f"  RESULT: {status}")
+    print(f"  Actual trials: {actual_trials}")
+    print(f"  Expected range: {expected_trials_range[0]}-{expected_trials_range[1]}")
+    print(f"  In range: {'YES' if in_range else 'NO'}")
+    print(f"  Stop reason: {stopping_criterion.stop_reason}")
+    print(f"  Final confidence: {stopping_criterion.final_confidence:.1%}")
+    print(f"{'='*70}\n")
+
+    return {
+        'function': function_name,
+        'expected_range': expected_trials_range,
+        'actual_trials': actual_trials,
+        'in_range': in_range,
+        'stop_reason': stopping_criterion.stop_reason,
+        'confidence': stopping_criterion.final_confidence
+    }
+
+
+def main():
+    """Run all adaptive characterization tests."""
+
+    print("\n" + "="*70)
+    print("  PROTOCOL 10 v2.0: ADAPTIVE CHARACTERIZATION TESTS")
+    print("="*70)
+
+    results = []
+
+    # Test 1: Simple smooth function (should stop early)
+    result1 = test_adaptive_characterization(
+        objective_function=simple_smooth_function,
+        function_name="Simple Smooth Quadratic",
+        expected_trials_range=(10, 20)
+    )
+    results.append(result1)
+
+    # Test 2: Complex multimodal function (should need more trials)
+    result2 = test_adaptive_characterization(
+        objective_function=complex_multimodal_function,
+        function_name="Complex Multimodal (Rastrigin)",
+        expected_trials_range=(15, 30)
+    )
+    results.append(result2)
+
+    # Summary
+    print("\n" + "="*70)
+    print("  TEST SUMMARY")
+    print("="*70)
+
+    for result in results:
+        status = "PASS" if result['in_range'] else "FAIL"
+        print(f"\n  [{status}] {result['function']}")
+        print(f"        Expected: {result['expected_range'][0]}-{result['expected_range'][1]} trials")
+        print(f"        Actual: {result['actual_trials']} trials")
+        print(f"        Confidence: {result['confidence']:.1%}")
+
+    # Overall pass/fail
+    all_passed = all(r['in_range'] for r in results)
+    overall_status = "ALL TESTS PASSED" if all_passed else "SOME TESTS FAILED"
+
+    print(f"\n{'='*70}")
+    print(f"  {overall_status}")
+    print(f"{'='*70}\n")
+
+
+if __name__ == "__main__":
+    main()

archive/test_scripts/test_backend.md

@@ -0,0 +1,74 @@
+# Backend Testing Guide
+
+## 1. Start Backend Server
+
+```bash
+cd atomizer-dashboard/backend
+python -m uvicorn api.main:app --reload --port 8000
+```
+
+## 2. Test REST Endpoints
+
+### Get Study Status
+```bash
+curl http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/status
+```
+
+### Get Pareto Front
+```bash
+curl http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/pareto-front
+```
+
+### Get Trial History
+```bash
+curl http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/trials
+```
+
+### Generate HTML Report
+```bash
+curl -X POST "http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/generate-report?format=html"
+```
+
+### List Studies
+```bash
+curl http://localhost:8000/api/optimization/studies
+```
+
+## 3. Test WebSocket (Browser Console)
+
+Open browser to `http://localhost:8000` and run in console:
+
+```javascript
+const ws = new WebSocket('ws://localhost:8000/api/ws/optimization/bracket_stiffness_optimization_V3');
+
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  console.log('Received:', data);
+};
+
+ws.onopen = () => console.log('Connected to optimization stream');
+ws.onerror = (error) => console.error('WebSocket error:', error);
+```
+
+You should see a `connected` message with current trial count.
+
+## 4. Test Mesh Conversion (If Nastran Files Available)
+
+```bash
+curl -X POST http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/convert-mesh
+```
+
+## 5. Download Generated Report
+
+After generating report, download it:
+```bash
+curl http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/reports/optimization_report.html -o test_report.html
+```
+
+## Expected Results
+
+- **Status endpoint**: Should return study config, trial counts, best values
+- **Pareto front**: Should return 48 Pareto-optimal solutions
+- **Trials endpoint**: Should return all 100 trial records
+- **Report generation**: Should create HTML file in `studies/bracket_stiffness_optimization_V3/2_results/reports/`
+- **WebSocket**: Should show connected message with current_trials = 100

archive/test_scripts/test_frontend_integration.md

@@ -0,0 +1,100 @@
+# Frontend Integration Testing Guide
+
+## 1. Start Both Servers
+
+### Terminal 1 - Backend
+```bash
+cd atomizer-dashboard/backend
+python -m uvicorn api.main:app --reload --port 8000
+```
+
+### Terminal 2 - Frontend
+```bash
+cd atomizer-dashboard/frontend
+npm run dev
+```
+
+Frontend will be at: `http://localhost:3003`
+
+## 2. Test API Integration
+
+The frontend should be able to:
+
+### Fetch Studies List
+```typescript
+fetch('http://localhost:8000/api/optimization/studies')
+  .then(r => r.json())
+  .then(data => console.log('Studies:', data));
+```
+
+### Get Study Status
+```typescript
+fetch('http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/status')
+  .then(r => r.json())
+  .then(data => console.log('Status:', data));
+```
+
+### Connect WebSocket
+```typescript
+const ws = new WebSocket('ws://localhost:8000/api/ws/optimization/bracket_stiffness_optimization_V3');
+
+ws.onmessage = (event) => {
+  const message = JSON.parse(event.data);
+  console.log('Message type:', message.type);
+  console.log('Data:', message.data);
+};
+```
+
+## 3. Frontend Development Tasks
+
+Now your frontend developer can implement:
+
+### Phase 1: Basic Study Viewing
+- Studies list page
+- Study detail page with current status
+- Trial history table
+
+### Phase 2: Real-Time Updates
+- WebSocket connection manager
+- Live trial updates in UI
+- Progress bar updates
+- "New Best" notifications
+
+### Phase 3: Pareto Front Visualization
+- Scatter plot of Pareto solutions
+- Interactive filtering
+- Solution comparison
+
+### Phase 4: 3D Visualization
+- GLTF model viewer (Three.js / react-three-fiber)
+- Load mesh from `/api/optimization/studies/{id}/mesh/model.gltf`
+- Color-coded stress/displacement display
+
+### Phase 5: Report Generation
+- Report generation buttons
+- Download generated reports
+- Preview HTML reports in-browser
+
+## 4. Test Data Available
+
+**bracket_stiffness_optimization_V3** has:
+- 100 completed trials
+- 48 Pareto-optimal solutions
+- Multi-objective: minimize mass + maximize stiffness
+- Design variables: rib_thickness_1, rib_thickness_2, rib_thickness_3, base_thickness
+
+Perfect for testing all dashboard features.
+
+## 5. API Endpoints Reference
+
+All endpoints are documented in the technical summary provided earlier.
+
+Key endpoints:
+- `GET /api/optimization/studies` - List all studies
+- `GET /api/optimization/studies/{id}/status` - Get study status
+- `GET /api/optimization/studies/{id}/trials` - Get trial history
+- `GET /api/optimization/studies/{id}/pareto-front` - Get Pareto solutions
+- `POST /api/optimization/studies/{id}/generate-report` - Generate report
+- `WS /api/ws/optimization/{id}` - WebSocket stream
+
+All support CORS and are ready for React integration.

archive/test_scripts/test_neural_surrogate.py

@@ -0,0 +1,58 @@
+"""Test neural surrogate integration."""
+
+import time
+from optimization_engine.neural_surrogate import create_surrogate_for_study
+
+print("Testing Neural Surrogate Integration")
+print("=" * 60)
+
+# Create surrogate with auto-detection
+surrogate = create_surrogate_for_study()
+
+if surrogate is None:
+    print("ERROR: Failed to create surrogate")
+    exit(1)
+
+print(f"Surrogate created successfully!")
+print(f"  Device: {surrogate.device}")
+print(f"  Nodes: {surrogate.num_nodes}")
+print(f"  Model val_loss: {surrogate.best_val_loss:.4f}")
+
+# Test prediction
+test_params = {
+    "beam_half_core_thickness": 7.0,
+    "beam_face_thickness": 3.0,
+    "holes_diameter": 40.0,
+    "hole_count": 10.0
+}
+
+print(f"\nTest prediction with params: {test_params}")
+results = surrogate.predict(test_params)
+
+print(f"\nResults:")
+print(f"  Max displacement: {results['max_displacement']:.6f} mm")
+print(f"  Max stress: {results['max_stress']:.2f} (approx)")
+print(f"  Inference time: {results['inference_time_ms']:.2f} ms")
+
+# Speed test
+n = 100
+start = time.time()
+for _ in range(n):
+    surrogate.predict(test_params)
+elapsed = time.time() - start
+
+print(f"\nSpeed test: {n} predictions in {elapsed:.3f}s")
+print(f"  Average: {elapsed/n*1000:.2f} ms per prediction")
+
+# Compare with FEA expectation
+# From training data, typical max_displacement is ~0.02-0.03 mm
+print(f"\nExpected range (from training data):")
+print(f"  Max displacement: ~0.02-0.03 mm")
+print(f"  Max stress: ~200-300 MPa")
+
+stats = surrogate.get_statistics()
+print(f"\nStatistics:")
+print(f"  Total predictions: {stats['total_predictions']}")
+print(f"  Average time: {stats['average_time_ms']:.2f} ms")
+
+print("\nNeural surrogate test PASSED!")

archive/test_scripts/test_new_optimization.md

@@ -0,0 +1,122 @@
+# New Optimization Testing Guide
+
+## Test Real-Time Dashboard with Active Optimization
+
+This will let you see the WebSocket updates in real-time as trials complete.
+
+## 1. Start Dashboard (Both Servers)
+
+### Terminal 1 - Backend
+```bash
+cd atomizer-dashboard/backend
+python -m uvicorn api.main:app --reload --port 8000
+```
+
+### Terminal 2 - Frontend
+```bash
+cd atomizer-dashboard/frontend
+npm run dev
+```
+
+Visit: `http://localhost:3003`
+
+## 2. Connect WebSocket to Existing Study
+
+Open browser console and run:
+```javascript
+const ws = new WebSocket('ws://localhost:8000/api/ws/optimization/bracket_stiffness_optimization_V3');
+
+ws.onmessage = (event) => {
+  const message = JSON.parse(event.data);
+  console.log(`[${message.type}]`, message.data);
+};
+
+ws.onopen = () => console.log('✓ Connected to optimization stream');
+```
+
+You should see:
+```
+✓ Connected to optimization stream
+[connected] {study_id: "bracket_stiffness_optimization_V3", current_trials: 100, ...}
+```
+
+## 3. Start a Small Optimization Run (5 Trials)
+
+### Terminal 3 - Run Optimization
+```bash
+cd studies/bracket_stiffness_optimization_V3
+python run_optimization.py --trials 5
+```
+
+## 4. Watch Real-Time Events
+
+As trials complete, you'll see WebSocket events:
+
+```javascript
+// Trial completed
+[trial_completed] {
+  trial_number: 101,
+  objective: 0.0234,
+  params: {rib_thickness_1: 2.3, ...},
+  ...
+}
+
+// Progress update
+[progress] {
+  current: 101,
+  total: 105,
+  percentage: 96.19
+}
+
+// New best found (if better than previous)
+[new_best] {
+  trial_number: 103,
+  objective: 0.0198,
+  ...
+}
+
+// Pareto front update (multi-objective)
+[pareto_front] {
+  pareto_front: [{...}, {...}],
+  count: 49
+}
+```
+
+## 5. Test Report Generation While Running
+
+While optimization is running, generate a report:
+
+```bash
+curl -X POST "http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/generate-report?format=html"
+```
+
+Then download it:
+```bash
+curl http://localhost:8000/api/optimization/studies/bracket_stiffness_optimization_V3/reports/optimization_report.html -o report.html
+```
+
+Open `report.html` in browser to see formatted report with all 100+ trials.
+
+## 6. Expected Behavior
+
+- WebSocket receives events as trials complete (2-5 minute intervals per trial)
+- Progress percentage updates
+- Pareto front grows if new non-dominated solutions found
+- Report can be generated at any point during optimization
+- All endpoints remain responsive during optimization
+
+## 7. Production Testing
+
+For full production test:
+```bash
+python run_optimization.py --trials 50
+```
+
+This will run for several hours and provide extensive real-time data for dashboard testing.
+
+## Notes
+
+- Each trial takes 2-5 minutes (NX simulation solve time)
+- WebSocket will broadcast updates immediately upon trial completion
+- Frontend should handle all 6 event types gracefully
+- Reports update dynamically as new trials complete

archive/test_scripts/test_nn_surrogate.py

@@ -0,0 +1,35 @@
+"""Test neural surrogate integration"""
+import sys
+from pathlib import Path
+
+# Add project paths
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+sys.path.insert(0, str(project_root / 'atomizer-field'))
+
+from optimization_engine.neural_surrogate import create_parametric_surrogate_for_study
+
+# Create surrogate
+print("Creating parametric surrogate...")
+surrogate = create_parametric_surrogate_for_study(project_root=project_root)
+
+if surrogate:
+    print('Surrogate created successfully!')
+    print(f'Design vars: {surrogate.design_var_names}')
+    print(f'Number of nodes: {surrogate.num_nodes}')
+
+    # Test prediction with example params
+    test_params = {name: 2.0 for name in surrogate.design_var_names}
+    print(f'\nTest params: {test_params}')
+
+    results = surrogate.predict(test_params)
+    print(f'\nTest prediction:')
+    print(f'  Mass: {results["mass"]:.2f}')
+    print(f'  Frequency: {results["frequency"]:.2f}')
+    print(f'  Max Displacement: {results["max_displacement"]:.6f}')
+    print(f'  Max Stress: {results["max_stress"]:.2f}')
+    print(f'  Inference time: {results["inference_time_ms"]:.2f} ms')
+
+    print('\nSurrogate is ready for use in optimization!')
+else:
+    print('Failed to create surrogate')

archive/test_scripts/test_parametric_surrogate.py

@@ -0,0 +1,61 @@
+"""Test parametric surrogate integration."""
+
+import time
+from optimization_engine.neural_surrogate import create_parametric_surrogate_for_study
+
+print("Testing Parametric Neural Surrogate")
+print("=" * 60)
+
+# Create surrogate with auto-detection
+surrogate = create_parametric_surrogate_for_study()
+
+if surrogate is None:
+    print("ERROR: Failed to create surrogate")
+    exit(1)
+
+print(f"Surrogate created successfully!")
+print(f"  Device: {surrogate.device}")
+print(f"  Nodes: {surrogate.num_nodes}")
+print(f"  Model val_loss: {surrogate.best_val_loss:.4f}")
+print(f"  Design vars: {surrogate.design_var_names}")
+
+# Test prediction with example params
+test_params = {
+    "beam_half_core_thickness": 7.0,
+    "beam_face_thickness": 2.5,
+    "holes_diameter": 35.0,
+    "hole_count": 10.0
+}
+
+print(f"\nTest prediction with params: {test_params}")
+results = surrogate.predict(test_params)
+
+print(f"\nResults:")
+print(f"  Mass: {results['mass']:.2f} g")
+print(f"  Frequency: {results['frequency']:.2f} Hz")
+print(f"  Max displacement: {results['max_displacement']:.6f} mm")
+print(f"  Max stress: {results['max_stress']:.2f} MPa")
+print(f"  Inference time: {results['inference_time_ms']:.2f} ms")
+
+# Speed test
+n = 100
+start = time.time()
+for _ in range(n):
+    surrogate.predict(test_params)
+elapsed = time.time() - start
+
+print(f"\nSpeed test: {n} predictions in {elapsed:.3f}s")
+print(f"  Average: {elapsed/n*1000:.2f} ms per prediction")
+
+# Compare with training data range
+print(f"\nExpected range (from training data):")
+print(f"  Mass: ~2808 - 5107 g")
+print(f"  Frequency: ~15.8 - 21.9 Hz")
+print(f"  Max displacement: ~0.02-0.03 mm")
+
+stats = surrogate.get_statistics()
+print(f"\nStatistics:")
+print(f"  Total predictions: {stats['total_predictions']}")
+print(f"  Average time: {stats['average_time_ms']:.2f} ms")
+
+print("\nParametric surrogate test PASSED!")

archive/test_scripts/test_training_data_export.py

@@ -0,0 +1,139 @@
+"""
+Test script for training data export functionality.
+
+Creates a simple beam optimization study with training data export enabled
+to verify end-to-end functionality of AtomizerField training data collection.
+"""
+
+import json
+import shutil
+from pathlib import Path
+
+# Configuration for test study with training data export
+test_config = {
+    "study_name": "training_data_export_test",
+    "sim_file": "examples/Models/Circular Plate/Circular_Plate.sim",
+    "fem_file": "examples/Models/Circular Plate/Circular_Plate_fem1.fem",
+
+    "design_variables": [
+        {
+            "name": "thickness",
+            "expression_name": "thickness",
+            "min": 2.0,
+            "max": 8.0
+        },
+        {
+            "name": "radius",
+            "expression_name": "radius",
+            "min": 80.0,
+            "max": 120.0
+        }
+    ],
+
+    "objectives": [
+        {
+            "name": "max_stress",
+            "type": "minimize",
+            "extractor": {
+                "type": "result_parameter",
+                "parameter_name": "Max Von Mises Stress"
+            }
+        },
+        {
+            "name": "mass",
+            "type": "minimize",
+            "extractor": {
+                "type": "expression",
+                "expression_name": "mass"
+            }
+        }
+    ],
+
+    "constraints": [
+        {
+            "name": "stress_limit",
+            "type": "less_than",
+            "value": 300.0,
+            "extractor": {
+                "type": "result_parameter",
+                "parameter_name": "Max Von Mises Stress"
+            }
+        }
+    ],
+
+    "optimization": {
+        "algorithm": "NSGA-II",
+        "n_trials": 10,
+        "population_size": 4
+    },
+
+    # Enable training data export
+    "training_data_export": {
+        "enabled": True,
+        "export_dir": "atomizer_field_training_data/test_study_001"
+    },
+
+    "version": "1.0"
+}
+
+def main():
+    """Run test study with training data export."""
+
+    # Create study directory
+    study_dir = Path("studies/training_data_export_test")
+    study_dir.mkdir(parents=True, exist_ok=True)
+
+    setup_dir = study_dir / "1_setup"
+    setup_dir.mkdir(exist_ok=True)
+
+    results_dir = study_dir / "2_results"
+    results_dir.mkdir(exist_ok=True)
+
+    # Save workflow config
+    config_path = setup_dir / "workflow_config.json"
+    with open(config_path, 'w') as f:
+        json.dump(test_config, f, indent=2)
+
+    print("=" * 80)
+    print("TRAINING DATA EXPORT TEST STUDY")
+    print("=" * 80)
+    print(f"\nStudy created: {study_dir}")
+    print(f"Config saved: {config_path}")
+    print(f"\nTraining data will be exported to:")
+    print(f"  {test_config['training_data_export']['export_dir']}")
+    print(f"\nNumber of trials: {test_config['optimization']['n_trials']}")
+    print("\n" + "=" * 80)
+    print("To run the test:")
+    print(f"  cd {study_dir}")
+    print("  python run_optimization.py")
+    print("=" * 80)
+
+    # Create run_optimization.py in study directory
+    run_script = study_dir / "run_optimization.py"
+    run_script_content = '''"""Run optimization for training data export test."""
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from optimization_engine.runner import OptimizationRunner
+
+def main():
+    """Run the optimization."""
+    config_path = Path(__file__).parent / "1_setup" / "workflow_config.json"
+    runner = OptimizationRunner(config_path)
+    runner.run()
+
+if __name__ == "__main__":
+    main()
+'''
+
+    with open(run_script, 'w') as f:
+        f.write(run_script_content)
+
+    print(f"\nRun script created: {run_script}")
+    print("\nTest study setup complete!")
+
+if __name__ == "__main__":
+    main()

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/README.md

@@ -0,0 +1,82 @@
+# AtomizerField Training Data
+
+**Study Name**: bracket_stiffness_optimization_atomizerfield
+**Generated**: 2025-11-26 10:39:27
+
+## Directory Structure
+
+```
+bracket_stiffness_optimization_atomizerfield/
+├── trial_0001/
+│   ├── input/
+│   │   └── model.bdf      # NX Nastran input deck (BDF format)
+│   ├── output/
+│   │   └── model.op2      # NX Nastran binary results (OP2 format)
+│   └── metadata.json      # Design parameters, objectives, constraints
+├── trial_0002/
+│   └── ...
+├── study_summary.json     # Overall study metadata
+└── README.md              # This file
+```
+
+## Design Variables
+
+- support_angle
+- tip_thickness
+
+## Objectives
+
+- stiffness
+- mass
+
+## Constraints
+
+- mass_limit
+
+## Usage with AtomizerField
+
+### 1. Parse Training Data
+
+```bash
+cd Atomizer-Field
+python batch_parser.py --data-dir "C:\Users\antoi\Documents\Atomaste\Atomizer\atomizer_field_training_data\bracket_stiffness_optimization_atomizerfield"
+```
+
+This converts BDF/OP2 files to PyTorch Geometric format.
+
+### 2. Validate Parsed Data
+
+```bash
+python validate_parsed_data.py
+```
+
+### 3. Train Neural Network
+
+```bash
+python train.py --data-dir "training_data/parsed/" --epochs 200
+```
+
+### 4. Use Trained Model in Atomizer
+
+```bash
+cd ../Atomizer
+python run_optimization.py --config studies/bracket_stiffness_optimization_atomizerfield/workflow_config.json --use-neural
+```
+
+## File Formats
+
+- **BDF (.bdf)**: Nastran Bulk Data File - contains mesh, materials, loads, BCs
+- **OP2 (.op2)**: Nastran Output2 - binary results with displacements, stresses, etc.
+- **metadata.json**: Human-readable trial metadata
+
+## AtomizerField Documentation
+
+See `Atomizer-Field/docs/` for complete documentation on:
+- Neural network architecture
+- Training procedures
+- Integration with Atomizer
+- Uncertainty quantification
+
+---
+
+*Generated by Atomizer Training Data Exporter*

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/study_summary.json

@@ -0,0 +1,22 @@
+{
+  "study_name": "bracket_stiffness_optimization_atomizerfield",
+  "total_trials": 99,
+  "design_variables": [
+    "support_angle",
+    "tip_thickness"
+  ],
+  "objectives": [
+    "stiffness",
+    "mass"
+  ],
+  "constraints": [
+    "mass_limit"
+  ],
+  "export_timestamp": "2025-11-26T10:24:08.885790",
+  "metadata": {
+    "atomizer_version": "2.0",
+    "optimization_algorithm": "NSGA-II",
+    "n_trials": 100,
+    "description": "Bracket Stiffness Optimization with AtomizerField Neural Acceleration - Multi-objective optimization of bracket geometry for maximum stiffness and minimum mass"
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0000/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 0,
+  "timestamp": "2025-11-26T09:51:31.691278",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 38.72700594236812,
+    "tip_thickness": 58.52142919229749
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 20959.60904717116,
+      "mass": 0.15948142745824906
+    },
+    "constraints": {
+      "mass_limit": 0.15948142745824906
+    },
+    "max_displacement": 0.04771081358194351,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0001/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 1,
+  "timestamp": "2025-11-26T09:51:38.513064",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 56.59969709057025,
+    "tip_thickness": 47.959754525911094
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 16381.0655256764,
+      "mass": 0.1370984918463113
+    },
+    "constraints": {
+      "mass_limit": 0.1370984918463113
+    },
+    "max_displacement": 0.061046089977025986,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0002/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 2,
+  "timestamp": "2025-11-26T09:51:46.479281",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 27.800932022121827,
+    "tip_thickness": 34.67983561008608
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 8118.567202877005,
+      "mass": 0.10631243304453929
+    },
+    "constraints": {
+      "mass_limit": 0.10631243304453929
+    },
+    "max_displacement": 0.12317444384098053,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0004/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 4,
+  "timestamp": "2025-11-26T09:52:32.103479",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 50.05575058716044,
+    "tip_thickness": 51.242177333881365
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 17663.23127979331,
+      "mass": 0.14318191031914837
+    },
+    "constraints": {
+      "mass_limit": 0.14318191031914837
+    },
+    "max_displacement": 0.05661478266119957,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0005/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 5,
+  "timestamp": "2025-11-26T09:52:39.853142",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 21.02922471479012,
+    "tip_thickness": 59.097295564859834
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 21249.113101276806,
+      "mass": 0.16085535181855637
+    },
+    "constraints": {
+      "mass_limit": 0.16085535181855637
+    },
+    "max_displacement": 0.04706078767776489,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0006/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 6,
+  "timestamp": "2025-11-26T09:52:48.595745",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 61.622132040021086,
+    "tip_thickness": 36.370173320348286
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 13545.870584182874,
+      "mass": 0.12051879186805532
+    },
+    "constraints": {
+      "mass_limit": 0.12051879186805532
+    },
+    "max_displacement": 0.0738232359290123,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0008/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 8,
+  "timestamp": "2025-11-26T09:53:04.968940",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 35.21211214797688,
+    "tip_thickness": 45.74269294896713
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 14278.045766049483,
+      "mass": 0.13060907261079233
+    },
+    "constraints": {
+      "mass_limit": 0.13060907261079233
+    },
+    "max_displacement": 0.0700375959277153,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0009/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 9,
+  "timestamp": "2025-11-26T09:53:14.350855",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 41.59725093210579,
+    "tip_thickness": 38.736874205941255
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 11092.555729424334,
+      "mass": 0.11718760969880804
+    },
+    "constraints": {
+      "mass_limit": 0.11718760969880804
+    },
+    "max_displacement": 0.09015055000782013,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0010/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 10,
+  "timestamp": "2025-11-26T09:53:21.885262",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 50.59264473611897,
+    "tip_thickness": 34.18481581956125
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 10423.015077827584,
+      "mass": 0.1119046319002308
+    },
+    "constraints": {
+      "mass_limit": 0.1119046319002308
+    },
+    "max_displacement": 0.09594152867794037,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0011/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 11,
+  "timestamp": "2025-11-26T09:53:28.628018",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 34.60723242676091,
+    "tip_thickness": 40.99085529881075
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 11692.014137279915,
+      "mass": 0.1204715705807385
+    },
+    "constraints": {
+      "mass_limit": 0.1204715705807385
+    },
+    "max_displacement": 0.08552846312522888,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0012/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 12,
+  "timestamp": "2025-11-26T09:53:41.273539",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 42.8034992108518,
+    "tip_thickness": 53.55527884179041
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 18351.580922756133,
+      "mass": 0.14802887455365774
+    },
+    "constraints": {
+      "mass_limit": 0.14802887455365774
+    },
+    "max_displacement": 0.05449121817946434,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0013/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 13,
+  "timestamp": "2025-11-26T09:53:47.412599",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 29.98368910791799,
+    "tip_thickness": 45.42703315240835
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 13960.362176742508,
+      "mass": 0.12948175375871773
+    },
+    "constraints": {
+      "mass_limit": 0.12948175375871773
+    },
+    "max_displacement": 0.07163137942552567,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0014/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 14,
+  "timestamp": "2025-11-26T09:53:54.464900",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 49.620728443102124,
+    "tip_thickness": 31.393512381599933
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 9263.79648843576,
+      "mass": 0.10717872178299684
+    },
+    "constraints": {
+      "mass_limit": 0.10717872178299684
+    },
+    "max_displacement": 0.10794710367918015,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0015/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 15,
+  "timestamp": "2025-11-26T09:54:00.849939",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 50.37724259507192,
+    "tip_thickness": 35.115723710618745
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 10722.37860287646,
+      "mass": 0.11326315567376985
+    },
+    "constraints": {
+      "mass_limit": 0.11326315567376985
+    },
+    "max_displacement": 0.09326288849115372,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0016/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 16,
+  "timestamp": "2025-11-26T09:54:06.961559",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 23.252579649263975,
+    "tip_thickness": 58.466566117599996
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 20932.418895641033,
+      "mass": 0.15936133413232823
+    },
+    "constraints": {
+      "mass_limit": 0.15936133413232823
+    },
+    "max_displacement": 0.047772787511348724,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0017/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 17,
+  "timestamp": "2025-11-26T09:54:12.905286",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 68.28160165372796,
+    "tip_thickness": 54.25192044349383
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 19530.746021063354,
+      "mass": 0.150481264481965
+    },
+    "constraints": {
+      "mass_limit": 0.150481264481965
+    },
+    "max_displacement": 0.05120132118463516,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0018/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 18,
+  "timestamp": "2025-11-26T09:54:18.777146",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 35.23068845866854,
+    "tip_thickness": 32.93016342019152
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 7906.796484379188,
+      "mass": 0.10460074364438958
+    },
+    "constraints": {
+      "mass_limit": 0.10460074364438958
+    },
+    "max_displacement": 0.12647347152233124,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0019/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 19,
+  "timestamp": "2025-11-26T09:54:24.765703",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 54.211651325607846,
+    "tip_thickness": 43.20457481218804
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 14264.655608803,
+      "mass": 0.12795866018288563
+    },
+    "constraints": {
+      "mass_limit": 0.12795866018288563
+    },
+    "max_displacement": 0.07010333985090256,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0020/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 20,
+  "timestamp": "2025-11-26T09:54:30.646393",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 42.8034992108518,
+    "tip_thickness": 53.55527884179041
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 18351.580922756133,
+      "mass": 0.14802887455365774
+    },
+    "constraints": {
+      "mass_limit": 0.14802887455365774
+    },
+    "max_displacement": 0.05449121817946434,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0021/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 21,
+  "timestamp": "2025-11-26T09:54:36.412016",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 56.59969709057025,
+    "tip_thickness": 36.370173320348286
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 12365.5598495581,
+      "mass": 0.1177885642854397
+    },
+    "constraints": {
+      "mass_limit": 0.1177885642854397
+    },
+    "max_displacement": 0.08086977154016495,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0022/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 22,
+  "timestamp": "2025-11-26T09:54:42.191184",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 41.59725093210579,
+    "tip_thickness": 35.115723710618745
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 9514.741932181752,
+      "mass": 0.11042149861353116
+    },
+    "constraints": {
+      "mass_limit": 0.11042149861353116
+    },
+    "max_displacement": 0.10510006546974182,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0023/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 23,
+  "timestamp": "2025-11-26T09:54:48.328487",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 50.05575058716044,
+    "tip_thickness": 51.242177333881365
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 17662.3166345598,
+      "mass": 0.14318180739561254
+    },
+    "constraints": {
+      "mass_limit": 0.14318180739561254
+    },
+    "max_displacement": 0.05661771446466446,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0024/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 24,
+  "timestamp": "2025-11-26T09:54:54.095777",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 50.37724259507192,
+    "tip_thickness": 35.115723710618745
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 10722.37860287646,
+      "mass": 0.11326315567376985
+    },
+    "constraints": {
+      "mass_limit": 0.11326315567376985
+    },
+    "max_displacement": 0.09326288849115372,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0025/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 25,
+  "timestamp": "2025-11-26T09:54:59.993477",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 50.59264473611897,
+    "tip_thickness": 47.959754525911094
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 15966.217946727696,
+      "mass": 0.13642655602270132
+    },
+    "constraints": {
+      "mass_limit": 0.13642655602270132
+    },
+    "max_displacement": 0.0626322403550148,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0026/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 26,
+  "timestamp": "2025-11-26T09:55:05.829545",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 26.10191174223894,
+    "tip_thickness": 45.42703315240835
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 13833.824324566678,
+      "mass": 0.12927495601269096
+    },
+    "constraints": {
+      "mass_limit": 0.12927495601269096
+    },
+    "max_displacement": 0.07228659093379974,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0027/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 27,
+  "timestamp": "2025-11-26T09:55:11.946629",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 44.758845505563514,
+    "tip_thickness": 31.393512381599933
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 8430.549986181251,
+      "mass": 0.1050535804840041
+    },
+    "constraints": {
+      "mass_limit": 0.1050535804840041
+    },
+    "max_displacement": 0.11861622333526611,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0028/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 28,
+  "timestamp": "2025-11-26T09:55:18.020485",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 68.28160165372796,
+    "tip_thickness": 54.25192044349383
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 19530.720442878443,
+      "mass": 0.150481628695325
+    },
+    "constraints": {
+      "mass_limit": 0.150481628695325
+    },
+    "max_displacement": 0.051201388239860535,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0029/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 29,
+  "timestamp": "2025-11-26T09:55:23.787732",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 35.21211214797688,
+    "tip_thickness": 45.74269294896713
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 14278.045766049483,
+      "mass": 0.13060907261079233
+    },
+    "constraints": {
+      "mass_limit": 0.13060907261079233
+    },
+    "max_displacement": 0.0700375959277153,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0030/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 30,
+  "timestamp": "2025-11-26T09:55:29.749707",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 27.800932022121827,
+    "tip_thickness": 58.52142919229749
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 20960.59592691965,
+      "mass": 0.15948009081724837
+    },
+    "constraints": {
+      "mass_limit": 0.15948009081724837
+    },
+    "max_displacement": 0.04770856723189354,
+    "feasible": true
+  }
+}

atomizer_field_training_data/bracket_stiffness_optimization_atomizerfield/trial_0031/metadata.json

@@ -0,0 +1,20 @@
+{
+  "trial_number": 31,
+  "timestamp": "2025-11-26T09:55:35.926013",
+  "atomizer_study": "bracket_stiffness_optimization_atomizerfield",
+  "design_parameters": {
+    "support_angle": 35.21211214797688,
+    "tip_thickness": 45.74269294896713
+  },
+  "results": {
+    "objectives": {
+      "stiffness": 14277.722248816552,
+      "mass": 0.1306134388483127
+    },
+    "constraints": {
+      "mass_limit": 0.1306134388483127
+    },
+    "max_displacement": 0.07003918290138245,
+    "feasible": true
+  }
+}