Antoine
fbdafb9a37
NXOpen Python wraps UF methods with version-specific names. Now dumps available methods on UF.Modl, UF.Eval, UF.Curve and tries them in order. Detailed logging shows which method was found and used, plus raw result format on parse failures.
Atomizer
LLM-driven structural optimization framework for Siemens NX with neural network acceleration.
What is Atomizer?
Atomizer is an LLM-first optimization framework that transforms how engineers interact with FEA optimization. Instead of manually configuring JSON files and writing extraction scripts, you describe what you want in natural language - and Atomizer handles the rest.
Engineer: "Optimize the M1 mirror support structure to minimize wavefront error
across elevation angles 20-90 degrees. Keep mass under 15kg."
Atomizer: Creates study, configures extractors, runs optimization, reports results.
Core Capabilities
| Capability | Description |
|---|---|
| LLM-Driven Workflow | Describe optimizations in plain English. Claude interprets, configures, and executes. |
| Neural Acceleration | GNN surrogates achieve 2000-500,000x speedup over FEA (4.5ms vs 10-30min) |
| Physics Insights | Real-time Zernike wavefront error, stress fields, modal analysis visualizations |
| Multi-Objective | Pareto optimization with NSGA-II, interactive parallel coordinates plots |
| NX Integration | Seamless journal-based control of Siemens NX Simcenter |
| Extensible | Plugin system with hooks for pre/post mesh, solve, and extraction phases |
Architecture Overview
┌─────────────────────────────────┐
│ LLM Interface Layer │
│ Claude Code + Natural Lang │
└───────────────┬─────────────────┘
│
┌─────────────────────────┼─────────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────────┐ ┌─────────────────┐
│ Traditional │ │ Neural Path │ │ Dashboard │
│ FEA Path │ │ (GNN Surrogate) │ │ (React) │
│ ~10-30 min │ │ ~4.5 ms │ │ Real-time │
└────────┬────────┘ └──────────┬──────────┘ └────────┬────────┘
│ │ │
└─────────────────────────┼─────────────────────────┘
│
┌──────────────┴──────────────┐
│ Extractors & Insights │
│ 20+ physics extractors │
│ 8 visualization types │
└─────────────────────────────┘
Key Features
1. Physics Extractors (20+)
Atomizer includes a comprehensive library of validated physics extractors:
| Category | Extractors | Notes |
|---|---|---|
| Displacement | extract_displacement() |
mm, nodal |
| Stress | extract_von_mises_stress(), extract_principal_stress() |
Shell (CQUAD4) & Solid (CTETRA) |
| Modal | extract_frequency(), extract_modal_mass() |
Hz, kg |
| Mass | extract_mass_from_bdf(), extract_mass_from_expression() |
kg |
| Thermal | extract_temperature() |
K |
| Energy | extract_strain_energy() |
J |
| Optics | extract_zernike_*() (Standard, Analytic, OPD) |
nm RMS |
Zernike OPD Method: The recommended extractor for mirror optimization. Correctly accounts for lateral displacement when computing wavefront error - critical for tilted mirror analysis.
2. Study Insights (8 Types)
Interactive physics visualizations generated on-demand:
| Insight | Purpose |
|---|---|
zernike_wfe |
Wavefront error decomposition with Zernike coefficients |
zernike_opd_comparison |
Compare Standard vs OPD methods across subcases |
msf_zernike |
Mid-spatial frequency analysis |
stress_field |
3D stress field visualization |
modal_analysis |
Mode shapes and frequencies |
thermal_field |
Temperature distribution |
design_space |
Parameter sensitivity exploration |
3. Neural Network Acceleration
The GNN surrogate system (optimization_engine/gnn/) provides:
- PolarMirrorGraph: Fixed 3000-node polar grid for consistent predictions
- ZernikeGNN: Design-conditioned graph convolutions
- Differentiable Zernike fitting: GPU-accelerated coefficient computation
- Hybrid optimization: Automatic switching between FEA and NN based on confidence
Performance: 4.5ms per prediction vs 10-30 minutes for FEA (2000x+ speedup)
4. Real-Time Dashboard
React-based monitoring with:
- Live trial progress tracking
- Pareto front visualization
- Parallel coordinates for multi-objective analysis
- Insights tab for physics visualizations
- Interactive Zernike decomposition with OPD/Standard toggle
# Start the dashboard
python launch_dashboard.py
# Opens at http://localhost:3003
Current Studies
Studies are organized by geometry type:
studies/
├── M1_Mirror/ # Telescope primary mirror optimization
│ ├── m1_mirror_adaptive_V15/ # Latest: Zernike OPD + GNN turbo
│ └── m1_mirror_cost_reduction_V12/
├── Simple_Bracket/ # Structural bracket studies
├── UAV_Arm/ # UAV arm frequency optimization
├── Drone_Gimbal/ # Gimbal assembly
├── Simple_Beam/ # Beam topology studies
└── _Other/ # Experimental
Study Structure
Each study follows a standardized structure:
study_name/
├── optimization_config.json # Problem definition
├── run_optimization.py # FEA optimization script
├── run_nn_optimization.py # Neural turbo mode (optional)
├── README.md # Study documentation
├── 1_setup/
│ └── model/ # NX part, sim, fem files
├── 2_iterations/ # Trial folders (iter1, iter2, ...)
├── 3_results/
│ ├── study.db # Optuna database
│ └── optimization.log # Execution logs
└── 3_insights/ # Generated visualizations
└── zernike_*.html
Quick Start
Prerequisites
- Siemens NX 2506+ with NX Nastran solver
- Python 3.10+ (Anaconda recommended)
- Atomizer conda environment (pre-configured)
Run an Optimization
# Activate the environment
conda activate atomizer
# Navigate to a study
cd studies/M1_Mirror/m1_mirror_adaptive_V15
# Run optimization (50 FEA trials)
python run_optimization.py --start --trials 50
# Or run with neural turbo mode (5000 GNN trials)
python run_nn_optimization.py --turbo --nn-trials 5000
Monitor Progress
# Start the dashboard
python launch_dashboard.py
# Or check status from command line
python -c "from optimization_engine.study_state import get_study_status; print(get_study_status('.'))"
Optimization Methods
Atomizer supports multiple optimization strategies:
| Method | Use Case | Protocol |
|---|---|---|
| TPE | Single-objective, <50 trials | SYS_10 (IMSO) |
| NSGA-II | Multi-objective, Pareto optimization | SYS_11 |
| CMA-ES | Continuous parameters, >100 trials | SYS_10 |
| GNN Turbo | >50 FEA trials available for training | SYS_14 |
| Hybrid | Confidence-based FEA/NN switching | SYS_15 |
The Method Selector automatically recommends the best approach based on your problem:
python -m optimization_engine.method_selector config.json study.db
Protocol System
Atomizer uses a layered protocol system for consistent operations:
Layer 0: Bootstrap → Task routing, quick reference
Layer 1: Operations → OP_01-06: Create, Run, Monitor, Analyze, Export, Debug
Layer 2: System → SYS_10-16: IMSO, Multi-obj, Extractors, Dashboard, Neural, Insights
Layer 3: Extensions → EXT_01-04: Create extractors, hooks, protocols, skills
Key Protocols
| Protocol | Purpose |
|---|---|
| OP_01 | Create new study from description |
| OP_02 | Run optimization |
| OP_06 | Troubleshoot issues |
| SYS_12 | Extractor library reference |
| SYS_14 | Neural network acceleration |
| SYS_16 | Study insights |
Development Roadmap
Current Status (Dec 2025)
- Core FEA optimization engine
- 20+ physics extractors including Zernike OPD
- GNN surrogate for mirror optimization
- React dashboard with live tracking
- Multi-objective Pareto optimization
- Study insights visualization system
Planned
| Feature | Status |
|---|---|
| Dynamic response (random vibration, PSD) | Planning |
| Code reorganization (modular structure) | Planning |
| Ensemble uncertainty quantification | Planned |
| Auto-documentation generator | Implemented |
| MCP server integration | Partial |
Project Structure
Atomizer/
├── .claude/ # LLM configuration
│ ├── skills/ # Claude skill definitions
│ └── commands/ # Slash commands
├── optimization_engine/ # Core Python modules
│ ├── extractors/ # Physics extraction (20+ extractors)
│ ├── insights/ # Visualization generators (8 types)
│ ├── gnn/ # Graph neural network surrogate
│ ├── hooks/ # NX automation hooks
│ ├── validators/ # Config validation
│ └── templates/ # Study templates
├── atomizer-dashboard/ # React frontend + FastAPI backend
├── studies/ # Optimization studies by geometry
├── docs/ # Documentation
│ ├── protocols/ # Protocol specifications
│ └── physics/ # Physics domain docs
├── knowledge_base/ # LAC persistent learning
│ └── lac/ # Session insights, failures, patterns
└── nx_journals/ # NX Open automation scripts
Key Principles
- Conversation first - Don't ask users to edit JSON manually
- Validate everything - Catch errors before expensive FEA runs
- Explain decisions - Say why a sampler/method was chosen
- Never modify master files - Copy NX files to study directory
- Reuse code - Check existing extractors before writing new ones
- Document proactively - Update docs after code changes
Documentation
| Document | Purpose |
|---|---|
| CLAUDE.md | System instructions for Claude |
| .claude/ATOMIZER_CONTEXT.md | Session context loader |
| docs/protocols/ | Protocol specifications |
| docs/physics/ | Physics domain documentation |
Physics Documentation
- ZERNIKE_FUNDAMENTALS.md - Zernike polynomial basics
- ZERNIKE_OPD_METHOD.md - OPD method for lateral displacement
For AI Assistants
Atomizer is designed for LLM-first interaction. Key resources:
- CLAUDE.md - System instructions for Claude Code
- .claude/skills/ - LLM skill modules
- docs/protocols/ - Protocol Operating System
Knowledge Base (LAC)
The Learning Atomizer Core (knowledge_base/lac/) accumulates optimization knowledge:
session_insights/- Learnings from past sessionsoptimization_memory/- Optimization outcomes by geometry typeplaybook.json- ACE framework knowledge store
For detailed AI interaction guidance, see CLAUDE.md.
Environment
Critical: Always use the atomizer conda environment:
conda activate atomizer
Python and dependencies are pre-configured. Do not install additional packages.
Support
- Documentation: docs/
- Issue Tracker: GitHub Issues
- Email: antoine@atomaste.com
License
Proprietary - Atomaste 2026
Atomizer: LLM-driven structural optimization for engineering.