3. Simulation model preparation at scale

A single crash simulation model is a carefully hand-crafted artifact. Ten thousand of them are a manufacturing problem. The transition from one-off CAE work to a high-throughput platform hinges on treating model preparation as a deterministic, versioned, and parallelizable pipeline rather than a sequence of interactive sessions in a pre-processor. This chapter examines the three stages that dominate preparation cost — CAD cleanup, automated meshing, and model assembly — and the engineering patterns that make each stage reproducible at scale.

Why Model Preparation Dominates Throughput

In a typical full-vehicle frontal impact model, the solver may run for 8–20 hours on 500–2000 cores. Yet the preparation of that model — geometry healing, midsurface extraction, meshing, connection creation, and assembly — routinely consumes 40–120 engineer-hours when performed manually. When a platform must evaluate hundreds of design variants, the preparation cost becomes the binding constraint, not the solver. The platform's job is to compress preparation from engineer-hours to machine-minutes while preserving the modeling fidelity that makes the results trustworthy.

The core principle is idempotent, parameterized preparation. Given the same input geometry revision and the same preparation recipe, the pipeline must produce a byte-identical model (or a model differing only in explicitly parameterized fields). This property is what enables caching, incremental rebuilds, and meaningful regression testing.

CAD Cleanup: From Dirty Geometry to Simulation-Ready Surfaces

Crash models are built predominantly from shell elements representing sheet-metal parts, so the cleanup target is a clean midsurface with consistent topology. Raw CAD from different suppliers arrives with a predictable catalog of defects: sliver faces, gaps at trim edges, overlapping surfaces, non-manifold edges, and tolerance mismatches between parts. A robust cleanup stage applies a fixed sequence of operations, each with explicit tolerances.

A practical cleanup recipe for a body-in-white (BIW) part set might use these parameters:

The critical engineering decision is tolerance discipline. If the stitching tolerance is set larger than the smallest intended mesh edge length, the cleanup will silently weld features that the mesh later needs to resolve. A common failure symptom is a part that meshes cleanly in isolation but produces inverted or zero-area elements after assembly, because two panels were welded across a gap that should have remained a sliding interface. The remedy is to log every healing operation with its affected face IDs and diff those logs against the previous revision; a sudden jump in stitched edges signals a geometry regression upstream.

Meshing Automation: Deterministic Element Generation

Automated meshing succeeds when the meshing strategy is derived from part classification rather than applied uniformly. A workable classification scheme assigns each part a mesh recipe keyed on its role: structural rails and pillars get mapped quad meshes with target size 5–8 mm; closures get 8–10 mm with local refinement at hinges and latches; trim and interior parts get coarse 15–20 mm shells or are replaced by lumped masses.

The automation loop for each part proceeds as follows. First, the midsurface is partitioned into meshable regions using curvature- and feature-based decomposition. Second, a target element size field is generated from the recipe plus local refinement zones (weld locations, radii, beads). Third, the surface is meshed with a quad-dominant algorithm, and quality metrics are evaluated against thresholds. Fourth, failing elements are repaired by local remeshing or node smoothing, and the part is re-evaluated. Only parts that pass all thresholds are promoted to assembly.

Quality thresholds that work well in production crash meshing:

• Jacobian ≥ 0.6 (warn below 0.7)
• Warpage ≤ 15° for quads
• Aspect ratio ≤ 5 for structural parts, ≤ 8 for trim
• Minimum edge length ≥ 2.5 mm (below this, explicit time step collapses)
• Maximum edge length ≤ 12 mm in crush zones

The minimum edge length threshold deserves emphasis because it directly controls solver cost. In an explicit crash solver, the stable time step scales with the smallest element. Halving the minimum edge length doubles the number of time steps and roughly doubles wall-clock time. A single stray 0.8 mm element in a door latch can dominate the entire model's time step. Automated meshing must therefore enforce a hard floor and flag any part that cannot meet it, rather than silently accepting the element.

# Example: per-part meshing recipe (YAML fragment)
part_class: structural_rail
target_size_mm: 6.0
min_edge_mm: 2.5
max_edge_mm: 10.0
refinement_zones:
  - type: weld_spot
    radius_mm: 12.0
    size_mm: 3.0
  - type: fillet
    min_radius_mm: 3.0
    size_mm: 4.0
quality_gates:
  jacobian_min: 0.6
  warpage_max_deg: 15.0
  aspect_max: 5.0
on_failure: remesh_local

Model Assembly: Connections, Interfaces, and Subsystem Integration

Assembly is where independently meshed parts become a load path. The dominant connection types in a BIW crash model are spot welds, seam welds (adhesives and structural bonds), bolts, and kinematic joints. Each must be generated from a connection database — typically a weld table exported from the CAD/PDM system — and mapped onto the mesh by geometric proximity.

The assembly pipeline performs three operations in sequence. First, connection realization: each weld point is projected onto the nearest element pair, and a connector element (e.g., a rigid or deformable spot weld) is created with the correct nodal attachment. Second, interface reconciliation: sliding interfaces, self-contact, and tied contacts are generated from part-pair rules, with penetration checks to ensure no initial interpenetration. Third, subsystem merge: the BIW, powertrain, suspension, and interior models are combined with consistent ID offsets to avoid node and element ID collisions.

ID management is a frequent source of silent corruption. If two subsystems both start node IDs at 1, the merge will either overwrite nodes or produce a model with duplicate IDs that the solver rejects or, worse, misinterprets. The platform should assign each subsystem a disjoint ID range (e.g., BIW: 1–50,000,000; powertrain: 50,000,001–60,000,000) and validate uniqueness after merge.

The Preparation Pipeline as a Directed Graph

The three stages are not a linear sequence; they form a directed acyclic graph with caching at each node. The SVG below shows the data flow, the cache boundaries, and the validation gates that decide whether a branch proceeds or returns for repair.

The graph makes the caching strategy explicit. Cleanup is cached per geometry revision; meshing is cached per (clean geometry, recipe) pair; assembly is cached per (mesh set, connection configuration). When a design change touches only one part, the pipeline invalidates that part's mesh and the assembly, but reuses every other part's mesh. In a 400-part BIW model, a single-part change can rebuild in minutes instead of hours.

Failure Modes and Their Signatures

Scale amplifies small errors. Three failure modes recur in production preparation pipelines, and each has a recognizable signature:

• Silent weld loss. A weld point falls outside the projection tolerance and is dropped without error. Signature: the assembled model has a lower connector count than the weld table. Detection: assert realized_welds == expected_welds before submission.
• Time-step collapse. One or a few tiny elements force a global time-step reduction. Signature: solver reports a stable time step far below the value predicted from the target element size. Detection: compute the 1st-percentile edge length and compare against the recipe floor.
• Initial penetration. Overlapping parts create contact forces at t=0, producing spurious acceleration spikes. Signature: nonzero contact force in the first output frame. Detection: run a penetration check with a 0.5 mm threshold and report the top offending part pairs.

Each of these is cheap to detect and expensive to discover after a 12-hour solve. The platform's value is not in any single algorithm but in enforcing these checks as non-negotiable gates in the pipeline, so that no model reaches the solver without passing them.