CAE Autonomy Challenges

Source files: Architechture & Research/Autonomous CAE/Concepts & Problem Briefs/CAE Autonomy Challenges.md Last synthesized: March 2026

The Real Problem

Current "AI for simulation" demos are toys because they optimize the wrong thing. The highest-leverage decisions happen before meshing and solving, inside a messy loop of:

geometry intent → defeaturing → partitioning → meshing strategy → sanity checks → iterate

This loop is full of tacit heuristics, tightly coupled to geometry and physics, and it's where simulation engineers spend 2-4 hours per model.

The bottleneck is not "solve faster" or "predict optimal parameters." It's automating pre-mesh simplification and feature cleanup on raw STEP files.

---

Why Full Autonomy is Hard

The Core Challenge

You cannot build a truly autonomous CAE agent with: - Screenshot-based vision models (your model is already a native 3D digital object—converting to 2D is a regression) - Pure reactive APIs (they expose data structures but lack situational awareness of what's happening in your loaded 3D model) - Post-hoc optimization (stress hotspots matter only after you mesh cleanly)

What you can build is a hybrid system coupling: 1. Geometry kernel (CAD operations on STEP B-Rep) 2. Deterministic rules (feature size thresholds, protection mechanisms) 3. Search / optimization (Bayesian optimization over parameters) 4. Learning (imitation + self-supervision + physics feedback) 5. Physics awareness (simulation-in-the-loop scoring)

The Chicken-and-Egg Problem

• Graph Neural Networks (GNNs) need clean mesh data to learn from
• But generating good meshes requires the hard simplification work you're trying to automate
• Solution: Start with rules-based defeaturing; use physics-in-the-loop to improve; then train GNNs on the outputs

---

Technology Options for Pre-Mesh Simplification

Option A: Kernel-Driven Defeaturing (Most Practical, Highest ROI)

Use a real geometry kernel to perform robust B-Rep operations on STEP files.

Core capabilities: - Feature suppression: Remove blends, fillets, chamfers, holes, threads, emboss text, small ribs, tiny faces - Sliver face healing: Merge coplanar faces, fix short edges, remove micro-loops - Topology-aware sizing: Compute local "feature size" to decide what's below simulation-relevant threshold - Patch & heal: After removing features, automatically extend/trim neighboring faces and sew solids back watertight

How it works: 1. Parse STEP → build B-Rep (faces, edges, loops) 2. Compute feature metrics per entity: face area, edge length, dihedral angles, curvature radii, local thickness 3. Identify "removable" candidates using rule-based logic + thresholds tied to target element size 4. Apply suppression operations + healing algorithms 5. Validate: watertight, manifold, volume within bounds, no self-intersections

Tools: - Commercial kernels (Parasolid, ACIS): Best robustness; integration effort and licensing cost - Open-source (OpenCASCADE via FreeCAD/pythonOCC): Good for many cases; expect edge cases requiring custom healing

Advantage: Preserves design intent for interfaces, mounting surfaces, sealing planes (critical for assembly CAE)

Option B: Algorithmic Defeaturing via Feature Size Fields (Very Strong for Automation)

Instead of "recognizing features like a human," compute a feature-size field over the geometry and suppress anything below target size.

Common approaches: - Local thickness / medial axis / shape diameter: Compute how "thin" or "small" each region is - Curvature-based filtering: Remove radii smaller than threshold relative to mesh size - Topology-based signatures: Identify slivers, short edges, tiny loops; flag for removal

The algorithm:

1. Compute feature size field over geometry
2. For each face/edge/feature:
   if characteristic_size < k × target_element_size:
      mark for removal
   unless tagged as "protected interface"
3. Apply removal + healing
4. Validate mesh-ability

Advantage: Turns your 2-4 hour manual simplification into a programmable, parameterized workflow. The knob is k (ratio of target element size). Tune once per model class.

Limitation: Requires defining "protected" regions (contact surfaces, interfaces) explicitly or via learned rules.

Option C: Implicit / Voxel / SDF Remeshing (The "Brute Force" Option)

If you're willing to sacrifice exact CAD surfaces (often acceptable for crash, thermal, coarse structural):

Steps: 1. Convert STEP B-Rep → signed distance field (SDF) or voxel grid 2. Apply morphological operations (erosion, dilation) to remove small features "for free" 3. Reconstruct a clean surface mesh 4. Optionally fit CAD surfaces back or keep mesh-only workflow

Advantages: - Ridiculously robust; automation-friendly; no special edge-case handling - Works even on damaged/malformed CAD

Disadvantages: - Lose exact planes, cylinders, sharp feature intent - Clean mating interfaces require explicit protection - Mesh-only workflow loses CAD intent for downstream design iteration

Best for: Crash simulation, thermal analysis, coarse-grid CFD where surface exactness matters less than stability.

Option D: Partitioning for Meshing (The Often-Overlooked Part)

Pre-mesh simplification is only half the battle. You also need semantic segmentation of the geometry for: - Contact regions (where parts touch) - Weld seams / adhesive zones (different material properties) - Bolt interfaces (special handling) - Thin sheet regions vs. blocky regions (different mesh strategies)

How to do it: 1. Rule-based identification: Named layers, metadata, material assignment, assembly tree structure 2. Geometric cues: Planarity, adjacency, local thickness, curvature 3. "Protected surfaces": Interfaces you never touch (critical for autonomy; prevents over-simplification)

Key insight: Protection mechanism is a must if you want autonomy without human review. You need to tell the system: "Keep these surfaces, simplify everything else."

---

Recommended Architecture: Phase 1 & 2

Phase 1: Rules-Based Deterministic Simplification (Works Now, Minimal ML)

STEP file
  ↓
Load via geometry kernel (OpenCASCADE)
  ↓
Auto-classify faces/regions:
  - Protected (interfaces, mounts, sealing, contact)
  - Candidate (likely removable)
  ↓
Defeature candidates using size-field rules:
  - Tied to target mesh element size
  - Respect protected regions
  ↓
Heal topology + validate:
  - Watertight check
  - Manifold check
  - Volume change check
  - Self-intersection check
  ↓
Produce simplification report:
  - What changed
  - Why it changed
  - What was protected
  ↓
Output: Clean STEP ready for meshing

Expected coverage: 70% of cases solve without manual override

Data you generate: Simplification logs → decision labels (for Phase 2)

Phase 2: Learning from Your Workflow (Imitation + Feedback)

Once Phase 1 runs, you instrument your actual NX workflow:

Imitation learning: - Every suppression you perform → face-level label - Every partition you add → region tag - Every mesh parameter choice → recommendation - What you protect and why → protection rule

One battery pack contains: - ~1000 faces/edges - ~100-500 decision points (suppress/keep/partition) - Thousands of micro-labels if you log at entity level

Self-supervised pretraining: - Train embeddings on B-Rep topology (masked prediction, adjacency, reconstruction) - Fine-tune with your logged decisions - Reduces data needs massively

Synthetic variation: - Generate procedural variants: fillets added/removed, holes varied, ribs thickened - Know ground truth (you control the generator) - Get scale without real customer data

Simulation-in-the-loop scoring: - Propose simplification → mesh → solve cheap proxy analysis - Score: mesh quality (element aspect ratio, Jacobian), solver stability (convergence, timesteps), fidelity (stress hotspots preserved in regions of interest), cost reduction - Use Bayesian optimization to tune thresholds automatically per model class

---

The "One Pack is Enough" Insight

You're not going to train a large model from scratch on one battery pack. But you can build an agent that improves fast by reframing the problem:

Wrong Frame

"One assembly = one training example" → Insufficient data for neural networks

Right Frame

"One assembly = thousands of micro-decisions at entity level" + Synthetic variation + Self-supervision + Physics feedback → Enough to bootstrap something genuinely useful

How: 1. Log every suppression decision (face ID, feature type, why kept/removed) 2. Each face is a data point; one pack → ~1000 faces 3. Synthetic generator creates 100+ variants (each with different geometry but same simplification intent) 4. Physics feedback scores whether simplifications hurt mesh quality or solver stability 5. Imitation + preferences learns faster than supervised alone

---

Why This Matters for CAE Autonomy

The pre-mesh bottleneck is where autonomy has the highest leverage: - Time savings: 2-4 hours/model × 5-10 models/month = significant - Unlock batch processing: Run 10 models overnight while humans sleep - Enable downstream learning: Clean, consistent meshes feed GNNs + physics models - Reduce expert dependency: Mid-size companies can run simulations without hiring specialists

Without solving pre-mesh, "autonomous CAE" remains a supervised tool asking for guidance at every step.

---

Comparison: Rules vs. Learning

Aspect	Rules-Based	Learning-Based
Training data	None (deterministic)	Logs from your workflow
Coverage	70% (estimated)	70-85% after learning
Explainability	Perfect (rules are auditable)	Good (can inspect learned weights)
Edge cases	Needs manual override	Improves with feedback
Deployment speed	Weeks (Phase 1)	Months (Phase 1 + 2)
Maintenance	Update thresholds	Retrain on new examples

Recommendation: Start with Phase 1 (rules-based). Use Phase 2 (learning) to push from 70% → 85% coverage and reduce manual overrides.

---

Quick Implementation Checklist

Phase 1 (3-4 weeks): - [ ] Build STEP → B-Rep parser (OpenCASCADE) - [ ] Implement feature-size field computation - [ ] Add protection rule engine (identify contact surfaces) - [ ] Implement defeature + heal + validate - [ ] Create simplification report generator - [ ] Test on 5-10 real battery packs; measure coverage

Phase 2 (2-3 months after Phase 1 stable): - [ ] Instrument NX workflow for decision logging - [ ] Implement imitation learning on logged decisions - [ ] Add synthetic variation generator - [ ] Integrate simulation-in-the-loop scoring - [ ] Use Bayesian optimization to tune thresholds - [ ] A/B test rules vs. learned thresholds

---

Tools & References

• OpenCASCADE: B-Rep operations, Python bindings (pythonOCC)
• FreeCAD Part Design: Higher-level CAD modeling, headless capability
• pymeshlab: Post-mesh validation (aspect ratio, quality metrics)
• Mesh statistics: Jacobian, skewness, aspect ratio (standard FEA metrics)
• Bayesian optimization: scikit-optimize, optuna (tuning thresholds per model class)

Additional Reference Shelf (April 2026)

• CadQuery: useful ergonomic layer for parametric OCCT scripting and fast geometry prototypes; best treated as a productivity helper around core kernel work, not the core simplification engine.
• DAFoam CHT tutorial corpus: useful as an open reference surface for simulation setup and optimization-flow examples when evaluating potential solver-loop automation paths.

---

Next Steps

1. Validate Phase 1 feasibility: Prototype on one real battery pack
2. Measure baseline: How many faces per pack? How many protection rules needed?
3. Define "good enough": Is 70% coverage acceptable? What's the manual override cost?
4. Plan Phase 2 if Phase 1 succeeds: Decide whether learning is worth the effort

The answer to "can we automate pre-mesh?" is probably "yes" with rules alone. The answer to "can we learn and improve?" is "yes, but only if you instrument your workflow."

Sources

• Architechture & Research/Autonomous CAE/Concepts & Problem Briefs/CAE Autonomy Challenges.md
• C:\Users\adeel\OneDrive\100_Knowledge\203_TextCAD\01_Product_Project_Management\TextCAD_Wiki\docs\05_Autonomous_CAE\_sources\cadquery_homepage.mhtml
• C:\Users\adeel\OneDrive\100_Knowledge\203_TextCAD\01_Product_Project_Management\TextCAD_Wiki\docs\05_Autonomous_CAE\_sources\dafoam_u_bend_cht.mhtml