# Atomizer > Advanced LLM-native optimization platform for Siemens NX Simcenter [![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) ## 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. ### Core Philosophy Atomizer enables engineers to: - **Describe optimizations in natural language** instead of writing configuration files - **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 - **Extend the framework autonomously** through LLM-driven code generation ### Key Features - **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 📘 See [DEVELOPMENT_ROADMAP.md](DEVELOPMENT_ROADMAP.md) for the complete vision and implementation plan. ## Architecture ``` ┌─────────────────────────────────────────────────────────┐ │ LLM Interface Layer │ │ Claude Skill + Natural Language Parser + Workflow Mgr │ └─────────────────────────────────────────────────────────┘ ↕ ┌─────────────────────────────────────────────────────────┐ │ Optimization Engine Core │ │ Plugin System + Feature Registry + Code Generator │ └─────────────────────────────────────────────────────────┘ ↕ ┌─────────────────────────────────────────────────────────┐ │ Execution Layer │ │ NX Solver (via Journals) + Optuna + Result Extractors │ └─────────────────────────────────────────────────────────┘ ↕ ┌─────────────────────────────────────────────────────────┐ │ Analysis & Reporting │ │ Surrogate Quality + Sensitivity + Report Generator │ └─────────────────────────────────────────────────────────┘ ``` ## Quick Start ### Prerequisites - **Siemens NX 2412** with NX Nastran solver - **Python 3.10+** (recommend Anaconda) - **Git** for version control ### Installation 1. **Clone the repository**: ```bash git clone https://github.com/yourusername/Atomizer.git cd Atomizer ``` 2. **Create Python environment**: ```bash conda create -n atomizer python=3.10 conda activate atomizer ``` 3. **Install dependencies**: ```bash pip install -r requirements.txt ``` 4. **Configure NX path** (edit if needed): - Default NX path: `C:\Program Files\Siemens\Simcenter3D_2412\NXBIN\run_journal.exe` - Update in `optimization_engine/nx_solver.py` if different ### Basic Usage #### Example 1: Natural Language Optimization (Future - Phase 2) ``` User: "Let's create a new study to minimize stress on my bracket" LLM: "Study created! Please drop your .sim file into the study folder, then I'll explore it to find available design parameters." User: "Done. I want to vary wall_thickness between 3-8mm" LLM: "Perfect! I've configured: - Objective: Minimize max von Mises stress - Design variable: wall_thickness (3.0 - 8.0 mm) - Sampler: TPE with 50 trials Ready to start?" User: "Yes, go!" LLM: "Optimization running! View progress at http://localhost:8080" ``` #### Example 2: Current JSON Configuration Create `studies/my_study/config.json`: ```json { "sim_file": "studies/bracket_stress_minimization/model/Bracket_sim1.sim", "design_variables": [ { "name": "wall_thickness", "expression_name": "wall_thickness", "min": 3.0, "max": 8.0, "units": "mm" } ], "objectives": [ { "name": "max_stress", "extractor": "stress_extractor", "metric": "max_von_mises", "direction": "minimize", "weight": 1.0, "units": "MPa" } ], "optimization_settings": { "n_trials": 50, "sampler": "TPE", "n_startup_trials": 20 } } ``` Run optimization: ```bash python tests/test_journal_optimization.py # Or use the quick 5-trial test: python run_5trial_test.py ``` ## Features - **Intelligent Optimization**: Optuna-powered TPE sampler with multi-objective support - **NX Integration**: Seamless journal-based control of Siemens NX Simcenter - **Smart Logging**: Detailed per-trial logs + high-level optimization progress tracking - **Plugin System**: Extensible hooks at pre-solve, post-solve, and post-extraction points - **Study Management**: Isolated study folders with automatic result organization - **Resume Capability**: Interrupt and resume optimizations without data loss - **Web Dashboard**: Real-time monitoring and configuration UI - **Example Study**: Bracket stress minimization with full documentation **🚀 What's Next**: Natural language optimization configuration via LLM interface (Phase 2) For detailed development status and todos, see [DEVELOPMENT.md](DEVELOPMENT.md). For the long-term vision, see [DEVELOPMENT_ROADMAP.md](DEVELOPMENT_ROADMAP.md). ## Project Structure ``` Atomizer/ ├── optimization_engine/ # Core optimization logic │ ├── runner.py # Main optimization runner │ ├── nx_solver.py # NX journal execution │ ├── nx_updater.py # NX model parameter updates │ ├── result_extractors/ # OP2/F06 parsers │ │ └── extractors.py # Stress, displacement extractors │ └── plugins/ # Plugin system (Phase 1 ✅) │ ├── hook_manager.py # Hook registration & execution │ ├── 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 ├── dashboard/ # Web UI │ ├── api/ # Flask backend │ ├── frontend/ # HTML/CSS/JS │ └── scripts/ # NX expression extraction ├── studies/ # Optimization studies │ ├── README.md # Comprehensive studies guide │ └── bracket_stress_minimization/ # Example study │ ├── README.md # Study documentation │ ├── model/ # FEA model files (.prt, .sim, .fem) │ ├── optimization_config_stress_displacement.json │ └── optimization_results/ # Generated results (gitignored) │ ├── optimization.log # High-level progress log │ ├── trial_logs/ # Detailed per-trial logs │ ├── history.json # Complete optimization history │ └── study_*.db # Optuna database ├── 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 ``` ## Example: Bracket Stress Minimization A complete working example is in `studies/bracket_stress_minimization/`: ```bash # Run the bracket optimization (50 trials, TPE sampler) python tests/test_journal_optimization.py # View results python dashboard/start_dashboard.py # Open http://localhost:8080 in browser ``` **What it does**: 1. Loads `Bracket_sim1.sim` with wall thickness = 5mm 2. Varies thickness from 3-8mm over 50 trials 3. Runs FEA solve for each trial 4. Extracts max stress and displacement from OP2 5. Finds optimal thickness that minimizes stress **Results** (typical): - Best thickness: ~4.2mm - Stress reduction: 15-20% vs. baseline - Convergence: ~30 trials to plateau ## Dashboard Usage Start the dashboard: ```bash python dashboard/start_dashboard.py ``` Features: - **Create studies** with folder structure (sim/, results/, config.json) - **Drop .sim/.prt files** into study folders - **Explore .sim files** to extract expressions via NX - **Configure optimization** with 5-step wizard: 1. Simulation files 2. Design variables 3. Objectives 4. Constraints 5. Optimization settings - **Monitor progress** with real-time charts - **View results** with trial history and best parameters ## Vision: LLM-Native Engineering Assistant Atomizer is evolving into a comprehensive AI-powered engineering platform. See [DEVELOPMENT_ROADMAP.md](DEVELOPMENT_ROADMAP.md) for details on: - **Phase 1-7 development plan** with timelines and deliverables - **Example use cases** demonstrating natural language workflows - **Architecture diagrams** showing plugin system and LLM integration - **Success metrics** for each phase ### Future Capabilities ``` User: "Add RSS function combining stress and displacement" → LLM: Writes Python function, validates, registers as custom objective User: "Use surrogate to predict these 10 parameter sets" → LLM: Checks surrogate R² > 0.9, runs predictions with confidence intervals User: "Make an optimization report" → LLM: Generates HTML with plots, insights, recommendations (30 seconds) User: "Why did trial #34 perform best?" → LLM: "Trial #34 had optimal stress distribution due to thickness 4.2mm creating uniform load paths. Fillet radius 3.1mm reduced stress concentration by 18%. This combination is Pareto-optimal." ``` ## Development Status ### Completed Phases - [x] **Phase 1**: Core optimization engine & Plugin system ✅ - NX journal integration - Web dashboard - Lifecycle hooks (pre-solve, post-solve, post-extraction) - [x] **Phase 2.5**: Intelligent Codebase-Aware Gap Detection ✅ - Scans existing capabilities before requesting examples - Matches workflow steps to implemented features - 80-90% accuracy on complex optimization requests - [x] **Phase 2.6**: Intelligent Step Classification ✅ - Distinguishes engineering features from inline calculations - Identifies post-processing hooks vs FEA operations - Foundation for smart code generation - [x] **Phase 2.7**: LLM-Powered Workflow Intelligence ✅ - Replaces static regex with Claude AI analysis - Detects ALL intermediate calculation steps - Understands engineering context (PCOMP, CBAR, element forces, etc.) - 95%+ expected accuracy with full nuance detection ### Next Priorities - [ ] **Phase 2.8**: Inline Code Generation - Auto-generate simple math operations - [ ] **Phase 2.9**: Post-Processing Hook Generation - Middleware script generation - [ ] **Phase 3**: MCP Integration - Automated research from NX/pyNastran docs - [ ] **Phase 4**: Code generation for complex FEA features - [ ] **Phase 5**: Analysis & decision support - [ ] **Phase 6**: Automated reporting **For Developers**: - [DEVELOPMENT.md](DEVELOPMENT.md) - Current status, todos, and active development - [DEVELOPMENT_ROADMAP.md](DEVELOPMENT_ROADMAP.md) - Strategic vision and long-term plan - [CHANGELOG.md](CHANGELOG.md) - Version history and changes ## License Proprietary - Atomaste © 2025 ## Support - **Documentation**: [docs/](docs/) - **Studies**: [studies/](studies/) - Optimization study templates and examples - **Development Roadmap**: [DEVELOPMENT_ROADMAP.md](DEVELOPMENT_ROADMAP.md) - **Email**: antoine@atomaste.com ## Resources ### NXOpen References - **Official API Docs**: [Siemens NXOpen Documentation](https://docs.sw.siemens.com/en-US/doc/209349590/) - **NXOpenTSE**: [The Scripting Engineer's Guide](https://nxopentsedocumentation.thescriptingengineer.com/) - **Our Guide**: [NXOpen Resources](docs/NXOPEN_RESOURCES.md) ### Optimization - **Optuna Documentation**: [optuna.readthedocs.io](https://optuna.readthedocs.io/) - **pyNastran**: [github.com/SteveDoyle2/pyNastran](https://github.com/SteveDoyle2/pyNastran) --- **Built with ❤️ by Atomaste** | Powered by Optuna, NXOpen, and Claude