Architecture, solver orchestration, data management, and performance validation across eight AI engines for simulation process management, multi-physics orchestration, verification intelligence, reduced order modeling, generative design, executable digital twins, HPC burst compute, and simulation knowledge mining — managing simulation as first-class citizens in the product knowledge graph, not file attachments in a vault.
The fundamental architectural failure of incumbent PLM simulation management is treating simulation data as files in a vault rather than knowledge in a graph. When an engineer runs a stress analysis in Ansys, the result is a .rst file stored alongside the model in a folder hierarchy with minimal metadata. Six months later, when a colleague needs to understand whether that analysis is still valid after a design change, they must open the file, examine the boundary conditions, check which geometry revision was used, and manually verify that the material properties still match the current specification. Nexus eliminates this entirely by storing every simulation element as a node in the knowledge graph: the mesh (linked to the specific geometry revision and CAD model from Lattice), the boundary conditions (linked to the operating requirements from Meridian), the material cards (linked to the material specifications from the AVL), the solver settings (versioned and auditable), and the results (linked to the verification matrix entry they satisfy). When any upstream element changes, the graph relationship immediately surfaces every affected simulation — enabling automatic invalidation and re-verification triggering through Cascade.
The simulation data model uses seven primary node types: SimModel (the overall simulation study, linked to the product component and requirement it addresses), Mesh (linked to the specific CAD geometry revision with element count, quality metrics, and refinement zones), BoundaryCondition (loads, constraints, contacts, thermal conditions — each linked to the operating requirement that defines it), MaterialCard (linked to the material specification in the AVL, with property source traceability), SolverConfig (solver type, convergence criteria, timestep, element formulation — versioned independently of the model), ResultSet (nodal/elemental results with provenance metadata: who ran it, when, on what hardware, with what solver version), and VerificationEntry (pass/fail against the requirement threshold, linked to the Meridian verification matrix). Edges encode relationships: uses-mesh, applies-BC, references-material, produces-result, satisfies-requirement. The schema is solver-agnostic — results from Ansys and Abaqus coexist in the same graph with full cross-referencing.
When Cascade processes a design change, the impact graph traversal identifies every simulation whose results may be affected. The re-simulation engine classifies each impact into three categories: (1) Invalidated — a geometry or material change directly affects a simulation input; the result is marked invalid and a re-simulation workflow is automatically queued with the updated inputs; (2) Suspect — a related change may affect the simulation indirectly (e.g., a neighboring component geometry change may alter assembly-level boundary conditions); the result is flagged for engineering review; (3) Unaffected — the change does not affect any input to this simulation; the result remains valid. This three-tier classification prevents both the over-simulation problem (re-running everything after every change) and the under-simulation problem (failing to re-verify analyses affected by changes that were not obviously connected to the simulation). The verification matrix updates in real time as re-simulation results arrive, showing requirement coverage status across the entire product at every moment.
Engine 04 generates reduced order models (ROMs) and physics AI surrogates from high-fidelity simulation data, enabling 10–100× speedup for design space exploration. The approach uses deep learning trained on historical simulation datasets to predict complex multi-physics outcomes without running the full solver — Ansys SimAI demonstrates this paradigm, using generative AI to predict aerodynamic performance, thermal distributions, and structural responses in minutes rather than hours. ROMs use SVD, modal response, and neural network techniques to create compact models that run in real time while maintaining physics accuracy within 2–5% of the full solver. Engine 05 integrates generative design directly into the knowledge graph: define the design space, keep-out zones, load cases, and manufacturing constraints (minimum wall thickness, draft angles, overhang limits for additive manufacturing). The optimizer generates material distributions that maximize performance within real-world constraints. TPMS lattice structures (triply periodic minimal surfaces) and Voronoi infill patterns are generated for additive manufacturing with graded density based on local stress fields. Every generative candidate, every constraint definition, every Pareto trade-off is versioned and traceable in the knowledge graph.
The surrogate generation pipeline takes a corpus of high-fidelity simulation results (minimum 50–200 runs spanning the design parameter space) and trains a deep neural network that learns the non-linear relationship between design inputs (geometry parameters, material properties, loading conditions) and simulation outputs (stress distributions, thermal fields, flow characteristics). The trained model predicts outcomes for new design variants without running the solver, enabling burst exploration of thousands of design candidates in the time it would take to run a single full-fidelity analysis. The architecture supports physics-agnostic training — the same pipeline generates surrogates for structural, thermal, fluid, and electromagnetic simulations. Each surrogate is stored in the knowledge graph with full provenance: the training dataset (linked to the specific simulation runs that produced it), the model architecture and hyperparameters, validation accuracy metrics against a held-out test set, and the parameter space bounds within which predictions are valid. Predictions outside the trained parameter space are flagged as extrapolations requiring full-solver verification.
Nexus integrates generative design directly into the PLM lifecycle rather than treating it as an isolated optimization tool disconnected from product configuration management. Every generative design exploration produces a design family — a set of Pareto-optimal candidates that trade off competing objectives (weight vs. stiffness vs. cost vs. manufacturability). Each candidate is stored as a versioned design artifact in the knowledge graph with full traceability: which constraints produced it, which solver validated it, which manufacturing feasibility assessment tagged it (castable, machinable, 3D-printable via SLM/EBM/DED, or injection-moldable). When an engineer selects a candidate for advancement, it enters the standard Cascade change management workflow — impact analysis, approval routing, BOM integration via Lattice — maintaining the governance and traceability that stand-alone generative tools cannot provide. The lattice generation engine produces optimized TPMS structures (gyroid, diamond, Schwarz-P) and Voronoi infill patterns with density graded by local stress fields from FEA results, enabling additive manufacturing of parts that are simultaneously lighter, stronger, and manufacturable.
Engine 06 exports simulation models as executable digital twins (xDT) that run in real time on actual machine controllers, edge devices, or cloud platforms — functioning as virtual sensors that predict physical behavior without physical instrumentation. The xDT architecture uses ROM and neural network surrogates generated by Engine 04, compiled into lightweight executables that run on embedded hardware with sub-millisecond inference latency. Engine 07 manages HPC job scheduling and elastic cloud bursting — a 2.5-billion-cell automotive CFD simulation that once required nearly a month on 2,048 CPU cores now completes in just over six hours using 320 NVIDIA GH200 Grace Hopper Superchips. The engine automatically selects between on-premises HPC, cloud burst, and GPU-accelerated compute based on job size, urgency, and cost optimization. Engine 08 mines the accumulated simulation knowledge base for cross-project patterns: design rules extracted from thousands of validated analyses, failure mode correlations between simulation parameters and field performance (via Echo), and best-practice templates that encode institutional expertise into reusable simulation workflows.
The xDT pipeline takes a validated high-fidelity simulation model and progressively reduces it: first to a ROM using SVD or modal techniques (retaining 95%+ accuracy for the critical output parameters), then to a compiled executable targeting the deployment platform. Deployment targets include PLCs and ECUs (for manufacturing process control), edge gateways (for equipment monitoring), cloud platforms (for fleet-level digital twin management), and web applications (for browser-based interactive visualization). Each xDT is linked in the knowledge graph to its source high-fidelity model, its validation accuracy metrics, and its operational deployment history. When the source model is updated (due to a design change processed through Cascade), the xDT is automatically flagged for regeneration. Siemens has demonstrated this architecture with Simcenter X, and Ansys Twin AI provides the toolchain for ROM generation and cloud/edge deployment — Nexus integrates both approaches within a single knowledge-graph-governed lifecycle.
Over years of product development, an engineering organization accumulates thousands of simulation studies that collectively encode deep expertise about what works, what fails, and why. This expertise typically exists only in the memory of senior engineers who performed the analyses — when they retire or change roles, the institutional knowledge disappears. Nexus’s knowledge mining engine extracts actionable patterns from the accumulated simulation database: design rules (e.g., “wall thickness below 2.1mm in this alloy class consistently fails fatigue life requirements at stress ratios above 0.7”), material-geometry correlations (which material-geometry combinations produce optimal performance envelopes), boundary condition sensitivities (which loads and constraints most significantly affect outcomes), and failure mode signatures (simulation output patterns that correlate with field failures documented in Echo). These mined patterns are encoded as reusable design guidelines that surface automatically when engineers create new designs with similar parameters — transforming decades of simulation experience into institutional memory that persists independent of any individual engineer.