Skip to content

rheoMesh — development log and detailed results

English | Japanese

« rheoMesh

All DrivAer figures and numbers on this page are provisional. Each section keeps the date of the work it reports; the current status is on the rheoMesh page, the dated comparisons and figures on results and comparisons.

Overall map: rheoMesh — map

Development log

date content
2026-10-20 specification, independent CMake project, interface headers
2026-10-21 octree, cell extraction, polyMesh writer, internal quality check. On one node (112 cores): 20.75 M cells in 12 s, 157 M cells in 128 s (castellation, before the projection onto the wall)
2026-10-22 to 24 projection onto the wall, features and corners, face repair. The projected mesh (no layers) passes checkMesh at N = 5 and 10
2026-10-25 prism layers (the layer field decided on the surface, extruded in a second pass); CAD face labels as feature edges
2026-10-26 simpleFoam on the car-type test body, Cd comparisons. Speed-up of the extrusion repair and the shape optimisation
2026-10-27 bitwise agreement x86 / aarch64, the gap handling (GAP_BLEND), error estimation and AMR, NUAMR
2026-10-28 review of the mesh quality and decision on the next steps; layers from estimates (rheomesh-layer-est); the BVH now built top-down level by level (tree and query answers bitwise the same as before); first FVM-only AMR cycle; validation of the explicit EDAC solver
2026-10-29 main line est3cgN4vGrW30S2 (ground layers, two layer-gap fixes) frozen as v0.1; symmetry-plane points slide in the smoothing (W30S2sd, a trial); whole-car LBM-driven AMR fa3 (C0-C3)
2026-10-30 Cranfield Pack 4 wheels, first mesh (does not pass the check yet)
2026-11-01 Pack 4 check failure located (one core cell on a no-layer wall face in a front-body groove; the moved body, not the wheels) and fixed with RHEOMESH_UNTANGLE_SLIDE=1 (experimental)
2026-11-03 motorBike failures fixed at their causes (wall level steps, rims of double-sided sheets); the 12 stage-2 OpenFOAM v2606 tutorials compared with snappyHexMesh; per-region levels, curvatureLevel, limitRegions and zones supported
2026-11-04 motorBike Mesh OK; local feature retry; feature-capture metric; locationsOutsideMesh and useLeakClosure (sphere_gapClosure fixed). Thin gaps: the classification leak at walls on lattice planes fixed (default), a topology check of the lost fluid, and cut cells to fill the gaps (design and first stage; see "Thin gaps")
2026-11-05 thin gaps moved to the refinement route (the cut-cell seams did not close on staircase steps); a switch for the layer thickness against the cell just outside the layer, as snappyHexMesh defines it; 65 OpenFOAM v2606, 21 Foundation OpenFOAM-13 and 25 public GitHub cases run with rheoMesh and snappyHexMesh, snappyHexMesh logs analysed per stage; cfMesh meshDict conversion; a snappyHexMeshLike mode designed, its dictionary reader and nine quality criteria (C0) implemented; a global quality optimiser and an AMR knowledge study designed (see "Comparison with snappyHexMesh"). Later the same day: the snappyHexMeshLike mode's snap (S1), a shorter shape optimisation, local refinement around bad faces and cell merging, the AMR knowledge pilot (K1), CPU and GPU on one GH200 node (see "2026-11-05 progress")
2026-11-06 the "compatible mode" renamed snappyHexMeshLike; from snappyHexMesh's outputs and logs it gained the layer-count ramp, the refinement band width, surface feature edges with the pocket rule and the post-layer repair, among others. The native method gained the wall snap to edges, cells filling narrow recesses (gap pillow) and its own post-layer repair. The course DrivAer (N = 5) compared again at development version 38d99e21; the Cd gap under investigation (see "at development version 38d99e21")
2026-11-13 to 20 shm-defaults-v2611.4 and v2611.5 adopted (T0–T2 PASS, Ahmed rear 3-layer coverage 100 %); DrivAer grid convergence checked up to 43.9 M cells; MPI castellation/snap and direct decomposed output; LBM .orl export (rheomesh-lbm); two-pass native method frozen
2026-11-21 v2611.6 integration branch (9 branches merged) passes macOS ctest 56/56, Miyabi-C default 44/44, MPI 50/50, MPI bit-identity 37/37 (RHEOMESH_MPI_LBAND=1), T0 41/41, and T1 (Cd 0.2595); opt-in S1 layer-field 6.36 M shift explained and 22.64 M T2 verified (Cd 0.2431 ± 0.0002); full 88-tutorial comparison reaches 82/88 Mesh OK (82/83 runnable = 98.8%, OpenFOAM-13 23/23 = 100%, +37 vs v2611.5, 0 regressions); rotating zones (mixerVesselAMI / rotatingFanInRoom) fixed and verified through 56-rank solver End; C2g Step 4a/4b (wall-band + MPI-distributed layers) cuts 22.6 M layers 45.67 → 34.69 s bit-identically; CLI-first (orheo-cli --json) + thin MCP 2-layer architecture designed

The test body is a car-type test body (DrivAer fastback, half model). N below is the base cell size 1/N m (0.2 m at N = 5, 1/6 m at N = 6).

Status as of 2026-11-21 (details, moved from the rheoMesh page)

After 2026-11-13, the defaults of the snappyHexMeshLike mode were updated twice (v2611.4, v2611.5), and work proceeded on MPI-parallel mesh generation and on confirming grid convergence on the experimental-geometry DrivAer. All checks ran on Miyabi-C. The times are reference values measured on one Miyabi-C node, not Flow2 Type I values. The 2026-11-13 status is in the development log table above.

Default rule set shm-defaults-v2611.5 (adopted 2026-11-18, criteria approved 2026-11-20)

A skewness floor of 0.2|d| is now used from the layer-extrusion stage (RHEOMESH_SHM_LSKEWFLOOR). Layers that used to drop at convex corners (such as around the rear end of the Ahmed body) are now added.

Ahmed body (about 270,000 cells): fraction of faces with all 3 layers v2611.4 v2611.5
around the back face 10.9 % 100 %
long edges 20.9 % 87.0 %
edges beside the slant — 49.5 %

The maximum non-orthogonality went from 64.5° to 57.4°, and the maximum skewness from 2.33 to 3.00. The Cd of the course DrivAer (N5, 3.54 M cells) went from 0.2738 to 0.2717, within the scatter.

Quality gate results (all passed or record only):

Gate Content Result
T0 (mesh md5) comparison with the v2611.4 baseline 164/170 identical. Only 3 layered rows changed (the whole and half motorBike and DrivAer), as planned. The md5 is the same at any thread count for all 41 cases
T1 (half car body, 3.09 M cells) mean Cd over iterations 2000–3000 0.2602 (baseline 0.2608, difference 0.0006, passed). Fraction of faces with layers: front wheels 97.3 %, rear wheels 98.3 %
T2 (whole, 6.34 M cells) mean Cd over iterations 2000–6000 0.2573 (v2611.4 grid: 0.2618). Over iterations 1500–3000 both are 0.257–0.258
T2 (whole, 22.63 M cells) mean Cd over iterations 2000–6000 0.2453 (v2611.4 grid: 0.2464). Fraction of faces with layers: body 99.3 %, front wheels 97.2 %, rear wheels 96.8 %

Grid convergence on the experimental-geometry DrivAer

For the experimental geometry with closed wheels, whole car body, and layers with the same first-cell height from the wall, the mean over iterations 2000–6000 of simpleFoam (kOmegaSST) was compared.

Grid Cells Cd
L1 6.3 M 0.2618
L2 11.8 M 0.2507
L3 22.6 M 0.2464
L4 43.9 M 0.2523

Cd rose by 0.006 from L3 to L4. When the computation on the L3 grid was started from the L4 solution, it returned to the L3 value (0.2457) within 3000 iterations. For this reason, the difference was judged to come from the L4 grid, not from a switch of the solution state (2026-11-20). The experimental value is 0.252, and the reference value without the stings is 0.244.

MPI parallelism

  • The castellation stage, snap and the layer stage (C2g) were parallelized with MPI. Whatever the configuration, the mesh with the same md5 as the threaded run is reproduced bit for bit (MPI build ctest 50/50 PASS; comparison of 0/1/2/4/8-rank configurations on 2 nodes with RHEOMESH_MPI_LBAND=1 enabled 37/37 PASS: the standard 36 cases plus the layered half DrivAer with 3.09 M cells).
  • Castellation stage: at 22.63 M cells, 22.0 s (threads) → 13.1 s (2 nodes). Snap does not get faster yet (31.2 s → 32.4 s).
  • Layer stage (C2g, 2026-11-21):
  • Step 4a (wall-band LayerBand, RHEOMESH_SHM_LBAND, default ON): restricts the layer iterations to a local sub-mesh of 3 rings from the wall (12.7 % of all cells at 6.34 M cells, 8.6 % at 22.63 M cells). It speeds up check by 1.81× to 2.15× and shortens layers on the DrivAer with 22.63 M cells from 45.67 → 41.31 s (bit-identical).
  • Step 4b (MPI-distributed wall-band DistLayerBand, RHEOMESH_MPI_LBAND): keeps the MPI ranks alive after snap, repatch and gather, and distributes sub-bands with a 2-ring halo over all ranks (the interior repair also runs in parallel on each rank, and only the repair of the seam contacts runs on rank 0). On 2 Miyabi-C nodes (16 ranks × 14 threads), at 6.34 M cells extrude went 6.13 → 2.12 s (2.89×), layers 18.17 → 16.44 s and total 46.36 → 44.57 s; at 22.63 M cells extrude went 15.14 → 5.92 s (2.56×), check 5.94 → 4.31 s (1.38×), layers 41.70 → 34.69 s (−7.01 s, 1.20×) and total 112.09 → 104.07 s (−8.02 s), all with md5 identical bit for bit. With Step 4a + 4b together, layers at 22.63 M cells went 45.67 → 34.69 s (−11.0 s, 1.32×).
  • The mesh decomposed for the solver (processor0..N-1) can be written directly (--decompose N; with MPI, RHEOMESH_DECOMPOSE=<N>). With 6.34 M cells in 224 parts, the write takes 0.6 s (using decomposePar after writing takes 19 s). checkMesh -parallel gave Mesh OK, and the time of one simpleFoam iteration was the same.
  • It also builds with g++-12 on macOS, and ctest passes 56/56.

The native method (layers in two passes) frozen

On the course DrivAer (3 and 6 layers, 2 kinds of input each), it was compared with the snappyHexMeshLike mode (2026-11-20).

Criterion Result
Wheel area with the specified number of layers +13 to +17 points with 3 layers (about 68 % vs 51–54 %), +49 to +52 points with 6 layers (about 57 % vs 5–7 %)
simpleFoam, 1000 iterations with 0 non-orthogonal corrections all 4 pass, but with 1 correction all 4 diverge (snappyHexMeshLike passes both)
Time 2.1 to 2.5 times that of snappyHexMeshLike

Because two of the three criteria were not met, the native method was frozen. The "layer field" made in pass 1 (the number and thickness of layers per patch, and the margin to the opposite wall) will be moved to the snappyHexMeshLike mode and used there. Polyhedral transition cells (Voronoi, the dual of tetrahedra) had no effect and will not be adopted. AMR by FVM alone did not do better than a uniform mesh with the same number of cells either.

Candidate shm-defaults-v2611.6 and integration verification (2026-11-21)

For a face where the layer check lowered the number of layers, only that face is lowered and the reduction is not spread to its surroundings (RHEOMESH_SHM_LRAMPLOCAL=1). The volume-ratio check for small cells was removed (RHEOMESH_SHM_LVRATIO=20/2/0). The version frozen for the 12-18 course stays at v2611.5; 9 branches including the v2611.6 candidate (the above 2 rules as defaults; the layer field S1, the thin-wall measures and others as opt-in) were verified on an integration branch (integrate/v2611.6) and promoted to the main line.

v2611.5 v2611.6 candidate
Ahmed edges beside the slant (faces with all 3 layers) 49.5 % 68.8 %
motorBike (fraction of faces with layers) 43.2 % 44.7 %
Cd of the course DrivAer N5 (record only) 0.2717 0.2746

Verification results of the integration branch (all on Miyabi-C; local on macOS g++-12):

Check Result
Unit tests (ctest) macOS g++-12 56/56 PASS, Miyabi-C default build 44/44 PASS, MPI build 50/50 PASS
MPI configuration comparison (2 nodes, 0/1/2/4/8 ranks, RHEOMESH_MPI_LBAND=1) 37/37 PASS (standard 36 cases + layered half car body with 3.09 M cells, bit-identical to serial)
Quality gate T0 (RULESET=v2611.6, 56 threads) 41/41 PASS (thread-count invariant 41/41)
Quality gate T1 (half car body, 3.09 M cells) PASS (mean over iterations 1500–3000 Cd = 0.2595 ± 0.0001)
Course DrivAer N3 / N6 (simpleFoam 1000 iterations) all PASS with both 0 and 1 non-orthogonal corrections (N3: 0.2730 / 0.2737, N6: 0.2723 / 0.2727). The thin-wall opt-in also passes

Verification of the layer field (S1, RHEOMESH_SHM_LFIELD=1, opt-in) on DrivAer (2026-11-21)

The "layer field" (S1), ported from the frozen native method to the snappyHexMeshLike mode, was verified on the experimental-geometry DrivAer.

  • Identifying the cause of the lower Cd at 6.36 M cells (T2 coarse grid): for Cd = 0.2470 (about 0.010 lower than v2611.5), per-part drag and a restart test were carried out. Restarting the standard mesh from the S1 6000-iteration solution returned to 0.2581 within 1500 iterations, so it was confirmed to be not a bistability of the solution but that the S1 mesh moves the rear base drag and the rear-wheel lift (Cl(r): +0.1406 → +0.1022) toward the wake state of the finer grids (L2/L3).
  • Confirmation at 22.64 M cells (T2 fine grid): Mesh OK (22,644,296 cells); the mean over iterations 2001–6000 of 448-rank simpleFoam was Cd = 0.2431 (SE 0.0002), −0.0022 against 0.2453 of v2611.5 and close to the reference value without the stings, 0.244.

Full 88-tutorial re-comparison of OpenFOAM (2026-11-21)

For all 88 tutorials that have a snappyHexMeshDict, namely OpenFOAM v2606 (65) and the Foundation OpenFOAM-13 (23), the v2611.6 integration build (rheomesh-08e1dd8d) was run on Miyabi-C and compared with the existing results of snappyHexMesh and rheoMesh v2611.5 (results and comparisons). Thanks to the effect of adding multi-region locationsInMesh, empty surfaces for shapes only and layer addition only, distributedTriSurfaceMesh aliasing with representative-normal deduplication of coplanar triangles (37.74 M triangles made Mesh OK in 52.99 s), non-uniform tiling and non-box blockMeshDict, the negative minVol floor setting for OpenFOAM-13 dictionaries, and 2D empty-patch slice-prism extrusion, 37 more tutorials are newly Mesh OK against v2611.5 (82/88 = 93.2 %, runnable 82/83 = 98.8 %, OpenFOAM-13 23/23 = 100 %, 0 regressions).

Tool / version Mesh OK (all 88) OpenFOAM-13 (23) OpenFOAM v2606 (65) Mesh written Failed checkMesh
snappyHexMesh (2026-11-20) 57 / 88 16 / 23 41 / 65 86 29
rheoMesh v2611.5 (2026-11-20) 45 / 88 8 / 23 37 / 65 50 5
rheoMesh b9034d2f (2026-11-21) 66 / 88 14 / 23 52 / 65 74 7
rheoMesh 08e1dd8d (2026-11-21) 82 / 88 23 / 23 (100 %) 59 / 65 (90.8 %) 83 1
  • On the 45 cases common to b9034d2f where both are Mesh OK, rheoMesh is faster on 40/45 (median speed ratio 1.98×, Miyabi-C reference timing). In addition, on relativeMotion_box_snappyHexMesh, against snappyHexMesh (Failed 1 at 747.84 s), Mesh OK at 1.48 s (505× faster).
  • All 23 OpenFOAM-13 tutorials reach 23 / 23 (100 %) Mesh OK (all pass, including drivaerFastback, motorBikeSteady, propeller, mixerVessel, shellAndTubeHeatExchanger, sloshingCylinder, and pipe).
  • The remaining 6 non-passing cases of v2606 are 5 templates for re-evaluation after topology optimization (3DBox_*_reEval: they refer to the unreplaced placeholder file "stlName.stl"; and the STL file does not exist, so they cannot be run even with snappyHexMesh) and 1 extreme thin-layer setting with 20 layers and expansion ratio 1.5 (airfoilWithLayers: the first-layer aspect ratio exceeds the fixed checkMesh threshold of 1000; snappyHexMesh also fails with AR 15,795, while rheoMesh has AR 1,968 and 0 pyramid/non-orthogonality/skewness errors).

Rotating zones fix (mixerVesselAMI / rotatingFanInRoom, 2026-11-21)

Multi-wall-patch vertex sliding, per-zone adaptive 3-rim vertex release, and 4-round interior Laplacian relaxation were added to the rotating-zone processing (mesh/src/zones.cpp). The following was confirmed with 56-rank parallel solver runs on Miyabi-C (without lowWeightCorrection).

  • mixerVesselAMI: Mesh OK (max non-orthogonality 62.17°) → solver completed End (t = 0.05001 s, 71.45 s wall time, rc 0).
  • rotatingFanInRoom: Mesh OK → solver completed End (AMI weights 0.992–1.007).

Design of a CLI-first + thin MCP interface and the M1 implementation (2026-11-21)

A 2-layer design (mesh/docs/design/DESIGN-mcp-interface-20261121.md) that handles orheo-1d, rheoMesh (mesh generation, quality checks, output), and the quality gates and HPC status monitoring through a common typed JSON schema was compiled, and the M1 prototype (scripts/orheo_cli/cli.py and scripts/orheo_mcp/server.py) was implemented. Layer 1 is a harness-independent CLI (orheo-cli --json --profile <readonly|local-mesh|hpc-free>), and layer 2 is separated as a thin stdio MCP server. Closed-vocabulary checks by env_registry.hpp / shm_rules.hpp, the return of a reproduction command (repro_cmd) and a deterministic md5, the prevention of execution on the login node, and the prohibition of modifying protected paths were verified by unit tests (test_orheo_cli_mcp.py 5/5 PASS). In addition, the clean-room implementation of the high-order spatial reconstruction schemes TENO5 / TENO6 (Fu, Hu & Adams, J. Comput. Phys. 305, 2016, 333–359; native/include/openrheo_amr/teno.hpp) was added, and the L1 convergence orders on smooth waves of 4.995 (TENO5) and 5.988 (TENO6), the exact ENO cutoff at discontinuities, and conservation in the 1D shallow-water solver (swe1d.hpp / orheo-1d recon=teno5|teno6) were confirmed by a unit test (test_teno).

potentialFoam-driven adaptive refinement sample (tools/miyabi/job_potamr_c.sh)

A sample (tools/miyabi/job_potamr_c.sh) that performs, at low cost before the RANS computation, an initial refinement adapted to the flow field was prepared. Instead of simpleFoam it solves potentialFoam -writePhi -writep (slip on walls and ground), and generates refinement boxes with rheomesh-adapt-indicator --w-grad 1 --clip 0 --window -2.5,-2.5,0,10,2.5,3 --theta 0.5 (Dörfler marking within a neighbourhood window on the gradient jump \(h^2 |\nabla^2 \Phi|\) of the potential flow). On the course DrivAer (N = 5, coarse initial grid: surface level 3, no wake boxes), all 4 cycles (c0 1.84 M → c1 2.30 M → c2 2.75 M → c3 3.23 M cells, mesh generation 21–49 s and potentialFoam 24–29 s per cycle) were confirmed Mesh OK (max non-orthogonality 64.49–64.83°, max skewness 3.63–3.85).

Output to LBM

A tool that writes the block forest of the octree in the .orl format (rheomesh-lbm) was put into the main line. The half car body of the experimental geometry has 2.03 M cells. The wall distance can also be written (--wall-distance).

Next

  • Freeze v2611.5 for the 12-18 course, and promote v2611.6 of the integration branch to the main line.
  • M2 of orheo-cli --json / the thin MCP server (live connection of gate report / hpc status through a Miyabi SSH adapter).
  • MPI: further acceleration of the snap, shrink and field stages.

snappyHexMesh and snappyHexMeshLike compared (DrivAer, 2026-11-10)

The comparison shown at the symposium of 2026-11-12. rheoMesh is the development version ffd85af3, frozen for the symposium, in the snappyHexMeshLike mode; it reads the same snappyHexMeshDict as snappyHexMesh. snappyHexMesh was used as a black box, as before: only its output was examined.

  • Geometry: drivaerFastback of OpenFOAM-13 (body, front and rear wheels).
  • Layers: 3 on the body and the wheels, 0 on the ground (relativeSizes true).
  • Machine: one Flow2 Type I node. Each mesher was run twice; the faster run is shown.
  • Time: the mesher's process time only. snappyHexMesh: the snappyHexMesh process with 384 MPI ranks. rheoMesh: one process (oneTBB threads), the whole run including its background mesh. blockMesh and decomposePar are not included, so these times are measured differently from the earlier times on results and comparisons (which include blockMesh and decomposePar).

Center sections of snappyHexMesh (left) and the snappyHexMeshLike mode of rheoMesh (right). Inside the car body: the number of layers per wall face seen from the side (red 0, yellow 1, green 2, blue 3). Below: enlarged sections of A the pocket in the underbody, B the rear window, C the edge of the diffuser, D the protrusion at the rear of the underbody

Center sections and the number of wall layers (left: snappyHexMesh, right: rheoMesh). The section of A is at y = 0.34 m, that of C at y = 0.52 m

snappyHexMesh snappyHexMeshLike
Time with layers 37.4 s 24.0 s
Time without layers 30.7 s 8.2 s
Cells (with layers) 3,068,471 3,122,614
checkMesh Mesh OK Mesh OK
Faces with non-orthogonality over 60° 52 39
Faces with skewness over 3 172 53
Pocket volume between wall and geometry 841 cm³ 149 cm³
Faces with layers: body 92.6 % 98.8 %
Faces with layers: front wheels 58.1 % 94.0 %
Faces with layers: rear wheels 54.9 % 94.4 %
Cd (record only) 0.2721 0.2723
  • Non-orthogonality and skewness use OpenFOAM's definitions; non-orthogonality is counted on internal faces, skewness on all faces. The maximum non-orthogonality is below 65° in both meshes.
  • Pocket volume: wall faces (body and wheels) lying 2 mm or more off the geometry on the fluid side, joined into regions; the sum of area × distance.
  • Faces with layers are taken from each mesher's own output (snappyHexMesh: its layer-count field; snappyHexMeshLike: its per-face output).
  • Cd is the mean over simpleFoam (kOmegaSST) iterations 3001-4000. It is recorded to compare the meshers, not as a validation against experiment.

Layers in two passes (with the pillow, as of the presentation on 2026-11-12)

Process flow of the method with the pillow. The cells near the surface are removed from the octree core, filled with the pillow layer and projected onto the surface, and the layers are extruded from the surface side

Sections of the pocket in the underbody (y = 0.34 m). Left: snappyHexMesh, middle: rheoMesh (snappyHexMeshLike), right: rheoMesh (with the pillow)

The comparison used the course dictionary as it is (6 layers on the body, wheels and ground). The times are for the mesher only (one Flow2 Type I node).

Setting Cells Time [s] Faces with non-orthogonality > 60° Within 1 mm of a feature line [%] Pocket [cm³] Front-wheel faces with layers [%] Mean number of layers on the front wheels
snappyHexMesh 3.43 M 38.8 61 26.4 841 52.0 0.97
rheoMesh (snappyHexMeshLike) 3.54 M 25.5 48 45.9 188 93.8 2.49
rheoMesh (with the pillow) 4.03 M 60.4 679 57.1 121 96.4 5.51

The method with the pillow can put in many layers, but the time and the faces with non-orthogonality over 60° were open problems. On 2026-11-20 it was frozen because it did not meet the criteria of the solver test and of the time, and it was decided to move only the layer field made in pass 1 to the snappyHexMeshLike mode (see "Status as of 2026-11-21" above).

Comparison with other mesh generators (2026-11-20)

This section positions rheoMesh against other mesh generators and approaches. Only open-source tools are compared. Of the tools compared with rheoMesh, only snappyHexMesh and cfMesh were actually measured (results and comparisons); the rest reflect a general understanding based on publicly available material and have not been verified.

Volume meshes for CFD

Tool Availability Core method Cells Layer generation Parallelism
rheoMesh Open (Apache-2.0) Octree, mainly hexahedral. Compatibility mode that reads snappyHexMeshDict Hexahedra, transition polyhedra, layers Shrink and extrude (improved at convex corners). The two-pass layer-generation method is frozen Threads (ISO C++ standard parallelism); MPI up to the mesh cutting and snap stages. Bit-for-bit identical mesh regardless of thread count. Writes solver decompositions directly. Also writes an LBM block forest from the same octree
snappyHexMesh Open (GPL) Octree cutting → snap Hexahedra, polyhedra, layers Shrink and extrude MPI
cfMesh Open (GPL) Octree (from the inside outward) → projection onto the boundary Mainly hexahedral, polyhedra Layers built from boundary cells OpenMP, MPI
foamyHexMesh Open (GPL. Only in the ESI version of OpenFOAM; not in the Foundation development version) Dual of the Delaunay triangulation of surface-conforming points Mainly polyhedral Depends on point placement MPI
enGrid Open (GPL-3.0 or later) Tetrahedra and prisms from surface triangles Tetrahedra, prisms Extrusion of prism layers —
Netgen Open (LGPL) Surface mesh, then tetrahedra by advancing-front and Delaunay methods. Has its own CSG and reads STEP / IGES (OpenCascade). Used from Python together with NGSolve Tetrahedra (including high-order curved elements), prisms Has a feature for adding prismatic boundary layers Partially threaded (MPI only partitions and distributes the generated mesh)
Salome (mesh module) Open (LGPL) Integrated environment for geometry, meshing, and post-processing. Meshes are built by assigning "hypotheses" (element size, method) to the geometry, and tetrahedra etc. are generated by embedded third-party tools (such as Netgen). Can be automated from Python Tetrahedra, hexahedra (for geometries that can be decomposed structurally), prisms Adds prismatic layers via the viscous-layer hypothesis —
vmtk Open (close to BSD) Processing of vascular surfaces, and building volume meshes of prism layers and tetrahedra from the surface Tetrahedra, prisms Extrudes prism layers from the surface —
Gmsh Open (GPL) Delaunay and advancing-front tetrahedra, structured meshes, recombination into hexahedra Tetrahedra, prisms, hexahedra Boundary-layer field in 2D; extrusion is the main approach in 3D Partially threaded

Libraries for tetrahedralization and mesh adaptation

Tool Availability Method Relation to rheoMesh
TetGen Open (AGPL) Constrained Delaunay tetrahedra Tetrahedra only
TetWild Open (MPL, partly GPL) Robustly builds tetrahedra while tolerating surface error (the fast version is fTetWild, MPL-2.0) The idea of handling dirty surfaces is a useful reference for geometry preprocessing
CGAL (3D mesh generation) Open (GPL and LGPL) Delaunay refinement and optimization. Also has Alpha Wrap, which wraps a surface from the outside to close it Reference for geometry processing
MMG3D Open (LGPL) Adaptation (remeshing) of tetrahedral meshes. The distributed-parallel version is ParMmg Same purpose as rheoMesh's AMR in refining according to the solution
CDT Open (GPL or LGPL) Robust constrained Delaunay tetrahedra Tetrahedra only

Other open-source tools (surveyed 2026-11-20)

Licenses and last-update dates were checked against each repository's public information (LICENSE, README). Methods and features come from READMEs, official documentation, and search results. Points that could not be confirmed are marked "not verified". None of these tools were measured against rheoMesh.

Volume meshes for CFD

Tool Availability Last update Core method Cells Layer generation Parallelism Output Relation to rheoMesh
Cassiopee (Generator, etc.) Open (LGPL-3.0, released in 2024) 2026 A set of Python modules. The official examples build an octree mesh from a surface and fill the region near the body with layers and tetrahedra. Also provides preprocessing for overset meshes and immersed boundaries Hexahedra (octree), tetrahedra, prisms, structured meshes, polyhedra Adds layers in the surface-normal direction Partial MPI (parallel mesh generation not verified) CGNS (OpenFOAM format not verified) The combination of octree and layers is the closest. Could also serve as a route for CGNS output
blockMesh (bundled with OpenFOAM) Open (GPL-3.0) 2026 Structured mesh divided into blocks Hexahedra Block grading None OpenFOAM Corresponds to the preliminary stage of rheoMesh's background mesh
extrudeMesh, etc. (bundled with OpenFOAM) Open (GPL-3.0) 2026 Extrudes patches or surfaces Hexahedra, prisms The extrusion itself Not verified OpenFOAM Baseline for layer comparisons on simple geometries
classy_blocks Open (MIT) 2026 Builds blockMesh dictionaries from Python Hexahedra Block grading None blockMeshDict Convenient for building structured meshes for verification
NekMesh (Nektar++) Open (license not verified) 2026 High-order curved meshes from CAD. Subdivides thick prism layers geometrically Tetrahedra, prisms, hexahedra (high-order) Builds one thick layer first, then splits it Not verified Nektar++ format, Gmsh format The "build a thick layer first, then split it" approach is a useful reference for layer improvement
pyHyp Open (Apache-2.0) 2026 Builds a volume mesh by marching outward from a structured surface mesh using hyperbolic equations Hexahedra (structured) The marching itself forms the layers MPI (not verified) CGNS, Plot3D An open implementation of the marching layers regarded as the reference in aerospace
MeshKit (PostBL) and MOAB Open (LGPL) MOAB 5.5 series A collection of algorithms. PostBL adds a boundary layer after the mesh has been generated Hexahedra, prisms, tetrahedra Layers added afterwards MOAB uses MPI MOAB formats, etc. A precedent for adding layers afterwards
HOPR Open (GPL-3.0) 2026 Generation and conversion of high-order hexahedral meshes Hexahedra (high-order) Not verified Not verified Custom HDF5 format For high-order solvers
HOHQMesh Open (MIT) 2026 2D all-quadrilateral meshes and their extrusion Quadrilaterals, hexahedra None None Custom format Used from Julia (Trixi.jl)
FieldCraft (Tangency Labs) Open (Apache-2.0, released in November 2026) 2026 Clean-room CAE written in pure Rust. Generates tetrahedra, multiblock conforming hexahedra, and octree all-hexahedral meshes (mesh.hex.octree) from SolidCraft CAD parts, and has built-in structural FEA, heat transfer, and D3Q19 LBM. The GUI, CLI, and MCP server drive the same command system Hexahedra (structured, multiblock, octree), tetrahedra, wedges, 2D elements Grading of structured blocks (boundary-layer prism extrusion for CFD not verified) Thread parallelism (determinism independent of thread count; MPI not verified) Custom format (.fieldcraft), various FEA decks The design policy — Apache-2.0, clean-room, verification against literature oracles, and determinism — is the closest. Its focus is structural FEA and CAD integration, so it is complementary to rheoMesh, which focuses on boundary-layer prism layers for large-scale CFD, OpenFOAM compatibility, and MPI. The unified operation layer via MCP is a useful reference
LaGriT Open (BSD-3) 2026 Generation and optimization of tetrahedra for geology Tetrahedra None Not verified Custom format, etc. Different field
OpenVSP Open (NOSA 1.3) 2026 Aircraft geometry definition and surface meshing Triangles (surface) None None STL, etc. An entry point for geometry. Does not generate volume meshes
ESP / EGADS Open (LGPL-2.1) 2025 CAD construction and gap-free triangulation of surfaces Triangles (surface) None None Coupling components for various solvers A route from CAD to a closed surface

Cartesian meshes, octrees, and LBM

Tool Availability Last update Method Parallelism Relation to rheoMesh
Seeder (APES) Open (BSD-2-Clause) 2025 Builds an octree from STL for tree-structured solvers such as LBM MPI Same purpose as rheoMesh's LBM block-forest output. The closest precedent
waLBerla (block-forest initialization) Open (GPL-3.0) 2026 Builds a signed-distance octree from a surface and keeps the blocks outside the body. Neighbors are 2:1 MPI (large scale) A counterpart to check against as an output format
OpenLB (STL loading) Open (GPL) 2025 Voxelizes STL with an octree and splits it into a collection of cuboids MPI, GPU A comparison target for geometry import on the LBM side
Palabos Open (license not verified) 2026 STL voxelization and multiblock refinement MPI Same as above
BCMTools and FFVC Open (BSD-2-Clause) 2017, 2020 Hierarchical Cartesian mesh blocks (Building Cube Method) MPI A domestic (Japanese) precedent for block-structured Cartesian meshes. Maintenance has stopped
AMReX (embedded boundary) Open (BSD-style) 2026 Block-structured AMR and cut cells MPI, GPU The leading open cut-cell implementation. Does not output mesh files
Basilisk (successor to Gerris) Open (GPL-3.0) Active Adaptive quadtree and octree meshes with embedded boundaries MPI A precedent for octrees and AMR
Mandoline Open (MIT) 2021 Exactly builds cut cells even for open surfaces Not verified A reference for robust cutting of dirty surfaces
STLCutters.jl Open (MIT) 2026 Julia. Cut cells from the intersection of STL and a Cartesian mesh Not verified An example in Julia

Foundations for mesh adaptation and parallelism

Tool Availability Last update Method Parallelism Relation to rheoMesh
p4est Open (GPL-2.0 or later) 2026 Forest of octrees. 2:1 balance, partitioning, ghosts MPI (large scale) The reference for octree balancing under MPI
t8code Open (GPL-2.0 or later) 2026 Extends tree-structured AMR to hexahedra, tetrahedra, prisms, and pyramids MPI An example of handling mixed meshes, including prism layers, with trees
refine Open (Apache-2.0) 2022 Metric-based anisotropic tetrahedral adaptation. Follows the CAD MPI The reference for solution-adaptive anisotropic adaptation
PUMI / MeshAdapt Open (BSD-style) 2026 Foundation for parallel unstructured meshes, and adaptation. Can adapt while preserving stacked boundary layers MPI (large scale) A precedent for adapting without destroying layers
ParMmg Open (LGPL) 2026 Distributed-parallel version of MMG3D MPI —
Omega_h Open (BSD-2-Clause-style) 2026 Adaptation of simplex meshes MPI, GPU Said to be designed with an emphasis on deterministic results (not verified)
Pragmatic Open (BSD-style) 2022 Anisotropic adaptation OpenMP, MPI Stagnant
Dendro Open (MIT) 2026 Parallel octree adaptive meshes MPI Same lineage as p4est
ForestClaw Open (BSD-2-Clause) 2026 Block-based AMR on top of p4est MPI An example of using a block forest

Hexahedral research codes

Tool Availability Last update Method Relation to rheoMesh
HybridOctree_Hex Open (BSD-3) 2026 All-hexahedral mesh from the dual of a balanced octree A reference for the type that handles octree transitions without polyhedra
robust_hex_dominant_meshing Open (MIT) 2025 Assembles a hex-dominant mesh following a direction field Another way to build hex-dominant meshes
AlgoHex Open (AGPL-3.0) 2026 All-hexahedral mesh from a frame field The current state of all-hexahedral research
GMDS Open (LGPL-2.1) 2026 Research library for hexahedral block decomposition, etc. Same as above
cinolib Open (MIT) 2026 Polyhedral and hexahedral mesh processing A reference for handling polyhedra

Surface repair and Python / Julia

Tool Availability Last update Method Relation to rheoMesh
manifold Open (Apache-2.0) 2026 Topologically robust boolean operations Preprocessing to produce closed surfaces. Same license as rheoMesh
pymeshfix Open (GPL-3.0) 2026 Repair of holes and self-intersections A candidate for fixing dirty surfaces
geogram Open (BSD-3) 2026 Surface remeshing, repair, Voronoi diagrams A geometry-processing component
Voro++ Open (BSD-style) 2026 3D Voronoi cells A polyhedral component
CfdOF Open (LGPL-3.0) 2026 A FreeCAD workbench that calls mesh generators An entry point on the user side. rheoMesh could be added as a callee
meshio Open (MIT) 2024 Conversion between mesh formats A candidate for format conversion

Tools with conditions such as non-commercial use (JIGSAW, Triangle), tools whose source is not public (VoroCrust), archived tools (SeismicMesh), and tools whose license could not be confirmed are not listed.

What users value, and rheoMesh

What CFD users look for in a mesh generator is, besides mesh quality, handling of dirty CAD, automation through scripts, fast generation of large meshes, strong parallelism, and compatibility with the solver.

  • rheoMesh's strengths: automation through dictionaries alone, thread parallelism and MPI, bit-for-bit reproducibility, direct writing of solver decompositions, and output to LBM.
  • What rheoMesh lacks: repair of dirty surfaces (wrapping and repair; it currently assumes a closed STL), and output in formats other than OpenFOAM (such as CGNS). For format conversion, one option is to combine it with a converter such as meshio (open source, a Python library that converts between many mesh formats).
  • Target for layer quality: in aerospace external flows, anisotropic marching layers (stopping each layer by quality, and splitting the extrusion direction at corners) are regarded as the reference. rheoMesh's layer improvements (fan-shaped extrusion at corners, gradual thickness reduction) are aimed in this direction.

Building and running a sample on Miyabi

On Miyabi-C (2 × Xeon Max 9480, 112 cores, no GPU) rheoMesh is built with gcc-toolset 14 and oneTBB (the intel/2025.2.0 module); the standard parallel algorithms run on oneTBB threads. Building and meshing run as jobs on a compute node; the login node only fetches the sources and the geometry.

1. Sources and geometry (login node)

rheoMesh is the independent CMake project in mesh/ of the OpenRheo repository.

G=YOUR_GROUP   # your group (the group_list of qsub)
cd /work/$G/$USER
git clone https://gitlab.com/masaz/openrheo.git

The sample geometry is the DrivAer fastback body and wheels (body.obj, frontWheels.obj, rearWheels.obj). It is not in the repository; the script getGeometry of the OpenCAE training repository fetches it (specification §4.3.7); it downloads the shapes of the OpenFOAM-13 tutorial drivaerFastback from GitHub into base/constant/triSurface.

git clone -b Nagoya-University-Information-Technology-Center-20261218 \
    https://gitlab.com/OpenCAE/Supercomputer-OpenFOAM-Training.git
cd Supercomputer-OpenFOAM-Training/Flow2/drivaerFastback/run
./getGeometry
ls base/constant/triSurface    # body.obj  frontWheels.obj  rearWheels.obj

2. Build, test and mesh (a Miyabi-C job)

mesh/tools/miyabi/job_castellate_c.sh does three things in one job:

  • the build (into $MESH/build-c-gcc)
  • ctest (13 tests with the small reference meshes in tests/data/tf6)
  • a mesh with rheomesh-castellate-base

Locations and settings are passed with -v; its values cannot contain commas. G is the one set in step 1. The node count (-l select=1) is required. Short-run queues have a time limit, so no -l walltime= is given; for longer runs use a longer-running queue with -l walltime=.

cd /work/$G/$USER
W=/work/$G/$USER
qsub -q <queue> -l select=1 -W group_list=$G \
    -v MESH=$W/openrheo/mesh,TRI=$W/Supercomputer-OpenFOAM-Training/Flow2/drivaerFastback/run/base/constant/triSurface,NS=5,WRITE=1,KEEP=1,OUT=$W/rheomesh_runs,RHEOMESH_SETTINGS=$W/openrheo/mesh/recipes/core.recipe \
    openrheo/mesh/tools/miyabi/job_castellate_c.sh
  • NS is the mesh size N; NS=2:5 makes one mesh after the other.
  • WRITE=1 writes the OpenFOAM polyMesh and KEEP=1 keeps it, under $OUT/base_N5_c_t0_<job number>/constant/polyMesh.
  • RHEOMESH_SETTINGS is the settings file (recipe); core.recipe also writes the mesh in binary (RHEOMESH_BINARY=1).
  • NOTEST=1 skips ctest.
  • DRYRUN=1 only prints the settings.

The job output shows the ctest result, the refinement levels ([levels]), the time of each stage ([timing]) and the mesh check ([check]).

This sample makes the core mesh without layers in one pass, with the settings of mesh/recipes/core.recipe: about 2.86 M cells at N = 5, made in about 12 s on Miyabi-C, passing the check (Mesh OK, max non-orthogonality 59.9°). Without RHEOMESH_SETTINGS there is no repair and no untangling, and the mesh fails the check. The both lines of the main-line recipe (w30s2sdsl.recipe:0) do not fit this sample either: they include RHEOMESH_SHEET_SIDE=1, meant for the layered meshes, and with it the core-only mesh fails the check.

The main-line recipe (mesh/recipes/w30s2sdsl.recipe: two passes and the layer extrusion) uses inputs made by other runs, such as the layer table; its steps are in mesh/tools/miyabi/job_layers2_c.sh.

3. Build and sample on Miyabi-G (GH200)

On Miyabi-G rheoMesh is built with nvc++ of the NVIDIA HPC SDK (the nvidia/25.9 module) and cmake 3.31.1, in three variants:

variant what it is
multicore nvc++ -stdpar=multicore; runs on the 72 Grace cores
gpu nvc++ -stdpar=gpu (cc90); runs on the Hopper GPU
cuda multicore plus the geometry queries on the GPU through nvcc (sm_90)

For build and test only, use mesh/tools/miyabi/job_build_test.sh. For each variant chosen in VARIANTS it builds into $MESH/build-<variant>, runs ctest and prints PASS <variant> when it passes.

cd /work/$G/$USER
W=/work/$G/$USER
qsub -q <queue> -l select=1 -W group_list=$G \
    -v MESH=$W/openrheo/mesh,VARIANTS=multicore:gpu:cuda \
    openrheo/mesh/tools/miyabi/job_build_test.sh

The sample mesh is made by mesh/tools/miyabi/job_castellate.sh: it builds multicore and meshes on the 72 Grace cores. With WRITE=1 it also runs checkMesh of the Miyabi-G OpenFOAM (openfoam-ecse/0.4-v2606) and prints the main lines. The output goes to $OUT/base_N5_m1_g3.5_<job number>/.

qsub -q <queue> -l select=1 -W group_list=$G \
    -v MESH=$W/openrheo/mesh,TRI=$W/Supercomputer-OpenFOAM-Training/Flow2/drivaerFastback/run/base/constant/triSurface,NS=5,WRITE=1,OUT=$W/rheomesh_runs,RHEOMESH_SETTINGS=$W/openrheo/mesh/recipes/core.recipe \
    openrheo/mesh/tools/miyabi/job_castellate.sh

This job's default transition mode (MODES) is 1, unlike the Miyabi-C job (2); with MODES=1 the mesh has about 3.26 M cells. Add MODES=2 to make the same mesh as on Miyabi-C (about 2.86 M cells). Both pass checkMesh.

Status as of 2026-10-30 (v0.1)

The main line was frozen as v0.1 on 2026-10-29 (see the development policy in the table). The work behind these tables, with its dates, is in the log above and the sections below. This section was moved from the rheoMesh page.

Progress

Item Status
Main-line mesh est3cgN4vGrW30S2 is the main line: est3cgN4v with ground layers (6 layers) and the two layer-gap fixes (merging the ends of short edges; near-flat wall triangles left out of the inversion check). 3.69 M cells, checkMesh OK, non-orthogonality max 65.8°, layer coverage (gaps excluded) 90.9 %, 13 756 cells above 50°
Main line from 2026-11-02: W30S2sdsl the recipe file recipes/w30s2sdsl.recipe = W30S2 + sliding of the points on the symmetry plane in the sheet smoothing (RHEOMESH_SHEET_SIDE, the W30S2sd trial) + sliding of the wall points in the final untangle (RHEOMESH_UNTANGLE_SLIDE, the Pack 4 fix). Both are now recipe settings, not experiments. The recipe file alone gives the trial meshes bit-identically: TUM wheels Mesh OK, non-orthogonality max 67.0°, Cd 0.2944 (as before, N = 5); Pack 4 wheels Mesh OK, max 65.0°
Layer gaps the rear lip, underbody and front-bumper gaps are closed. They came from near-degenerate elements made inside the mesher, not from the input surface
Ground layers ground y+ under the car: median 134 -> 6.7
Wall quantities (simpleFoam) equal to or better than est3cgN4v: roof |τ| 0.465, rear-window reversed area 5.96 %, near-car residual 0.0171
LBM-driven whole-car AMR (fa3) C0-C3 run (63.6 M cells at the end, about 500 MLUPS on GB200). The FV mesh from its map (11.5 M cells) fails one checkMesh item, so its simpleFoam result is a reference only
Polyhedral arch prototype on synthetic shapes, polygon columns, a Voronoi fill and the hex core joined into one mesh pass checkMesh; on the real rear arch the surface polygons are done
Development policy the main line is frozen as v0.1; for about two weeks no recipe trials, while the driver moves into the library with a settings file and a regression corpus is built (synthetic shapes, Ahmed 25°, wall-mounted cube, building group, ...). Layer-coverage gate: layer count >= 92 % and thickness >= 95 % with the gaps excluded
Cranfield Pack 4 wheels first mesh (2026-10-30): 3.67 M cells in 6 min on Miyabi-C; it failed the check (1 negative cell, 2 faces above 90°, 3 bad pyramids) at one core cell in a groove on the front body, caused by the moved body, not the wheels. With RHEOMESH_UNTANGLE_SLIDE=1 it passes (2026-11-01: Mesh OK, non-orthogonality max 65.0°); since 2026-11-02 this is part of the main line W30S2sdsl. See "Trials after the main line" below

Open issues

Issue Status
Roof |τ| about 6 % below the reference (D1e). From now on the reference is the solution on an N = 7 main-line mesh
Crushed thin columns made when the staircase core boundary is projected onto the wall, not by the layers. The column next to the symmetry plane stayed because points on the plane did not move in the smoothing. Letting them slide in the plane (W30S2sd, a trial) cut the thin faces on the symmetry plane from 22 to 3 and removed the crushed columns at the lower rear (figures in "Symmetry-plane points in the smoothing" below). Thin faces overall (below 0.3 of the median width): 1 132 -> 1 101; the rest, near the door mirrors, the front bumper and elsewhere, come from another mechanism
Above the rear wheel arch the ~4 cm arch-tyre gap: the tyre has no layers, the arch layers are capped by the facing wall, and the polyhedral faces between them pass only after the final untangle. A variant with tyre layers is under test
Refinement near convex edges stopped: the extrusion breaks where the level steps on the wall
Fan layers (L4) stopped after two trials without gain (off by default)
AMR stopping fa3 stopped only at the cell budget and never coarsened. fa4 runs without the budget and with the coarsening fixed
LBM block-forest export not implemented yet; planned within three months

Main line against the quality gates

Values of est3cgN4vGrW30S2 (2026-10-29) against the gates of the specification (Design principles).

gate value main line met
checkMesh (default thresholds) no failed check OK yes
max non-orthogonality ≤ 65° 65.8° not yet
max skewness ≤ 4 4.0 yes
prism-layer coverage, gaps excluded (gate revised on 2026-10-29) count ≥ 92 %, thickness ≥ 95 % 90.9 % (whether count or thickness is not recorded) not yet

Latest meshes (2026-11-03)

Two meshes made with the current code: the y = 0 plane (symmetry plane) and the meshing time. The figures are provisional; the white area is the car section.

core only core + layers (main line W30S2sdsl)
settings recipes/core.recipe, one pass recipes/w30s2sdsl.recipe, two passes (layer field and S_H, then core, layer extrusion and repair)
geometry OpenFOAM-13 drivaerFastback (417 k triangles) assembled body with the TUM wheels (368 k triangles)
cells (N = 5) 2.86 M 3.69 M (0.78 M layer cells)
time, Miyabi-C 1 node, 112 threads 12.2 s about 60 s (pass 1: 15.9 s, pass 2: 43.7 s, mean of three runs); 358 s before the speed-up
time, Miyabi-G Grace 72 cores (multicore) 7.8 s not measured
peak memory (Miyabi-C) 2.6 GB 5.4 GB
check Mesh OK, max non-orthogonality 59.9°, skew 3.92 Mesh OK, max non-orthogonality 67.0°, skew 4.00
  • The core-only times come from the jobs of the Miyabi sample (jobs 3781032 and 3781075).
  • The core + layers time is after the orthogonality smoothing of the near-wall band (L7) was made parallel (2026-11-03, job 3782510). Before, that stage ran on one thread for 297 s and pass 2 took 342 s (2026-11-02, job 3769703); perf showed it. The parallel version keeps the cell connectivity and moves the points slightly; the check (Mesh OK, max non-orthogonality 67.0°) and Cd (0.2947, before 0.2944) are about the same. Then, with the same mesh, pass 2 went from 64.2 s to 43.7 s (parallel set-up of the smoothing and of the pillow split, trials stopped once they cannot win, and others; mean of three runs on one node, job 3783475). A switch for the former order (RHEOMESH_BAND_ORTHO_SERIAL=1) gives the former mesh bit-identically. The figures show the mesh before the change.

Provisional: core only (core.recipe, N = 5), side

Provisional: core only, upper rear corner

Provisional: core only, front end

Provisional: core + layers (main line W30S2sdsl, N = 5), side

Provisional: core + layers, upper rear corner; prism layers along the wall

Provisional: core + layers, front end; the layers break at the corners of the steps

Main-line mesh on the y = 0 plane

All figures are provisional; the mesh views are rendered with ParaView.

provisional: est3cgN4vGrW30S2, side

provisional: est3cgN4vGrW30S2, rear

provisional: est3cgN4vGrW30S2, underbody and ground layers

Non-orthogonality is defined on a face: the angle between the face normal and the line joining the centres of the cells on either side. The maximum and average in the tables are taken over faces. The figures below colour each cell by the largest non-orthogonality of its faces (not the average; the same definition as the nonOrthoAngle field written by checkMesh -writeFields), and "cells above 50°" are counted with this maximum.

provisional: est3cgN4vGrW30S2 side, non-orthogonality per cell (deg, the largest of its faces)

provisional: est3cgN4vGrW30S2 rear; the cells above 50° gather in the layers at the upper and lower rear corners

provisional: est3cgN4vGrW30S2 underbody

provisional: above the rear wheel arch (plane y = 0.82 m): core-to-core faces that the repair does not fix and that pass only after the final untangle

In every mesh 97-98 % of the cells above 50° are prism-layer cells: the non-orthogonality problem is in the layers, not in the core.

Trials after the main line

Symmetry-plane points in the smoothing (W30S2sd, a trial, 2026-10-29)

Lower rear on y = 0. Left: the main line W30S2; right: W30S2sd, whose symmetry-plane points slide in the plane. The crushed columns that W30S2 has at regular intervals in the layers are gone and the column spacing evens out. W30S2sd: checkMesh OK, non-orthogonality max 67.0°, 13 706 cells above 50°, layer coverage 90.9 %. Whether it enters the main line is decided after the driver refactor and the regression corpus.

W30S2 (main line) W30S2sd (trial)
W30S2 lower rear W30S2sd lower rear

provisional: W30S2sd, rear

provisional: W30S2sd rear, non-orthogonality per cell (deg, the largest of its faces)

Cranfield Pack 4 wheels (provisional, 2026-10-30)

The TUM wheels are replaced by the Cranfield DrivAer Pack 4 wheels, tessellated from the STEP with the wind-tunnel fixture features (centre slot, hub holes) closed and the whole car placed so that the flat contact patches sit on the ground. Settings as W30S2sd, N = 5, Miyabi-C. 3.67 M cells, meshing 6 min. The mesh does not yet pass the check: 1 negative cell, 2 faces above 90°, 3 bad pyramids (W30S2sd with the TUM wheels passes on the same machine), so the cause lies at the new wheels; it is being located.

provisional: W30S2sd + Pack 4 wheels, side (y = 0)

provisional: W30S2sd + Pack 4 wheels, front wheel (y = 0.75 m)

provisional: W30S2sd + Pack 4 wheels, rear wheel (y = 0.75 m)

Pack 4 check failure: cause and fix (provisional, 2026-11-01)

All six failing items of the Pack 4 mesh are one level-4 core hexahedron at (−0.75, 0.36, 0.64): the inner corner of a rounded groove on the front body, 0.75 m ahead of the front axle. It is not the wheels: the moved body with the TUM wheels has the same failing core faces at the same spot, and the original body position passes. The cell folds already at the pass-2 projection of the core onto S_H, before the layers, so no layer-side setting reached it (CAD features in pass 2, taper, gap cells, request taper, wider stack lowering). It lies on a wall face without layers, and the untangle moved only non-wall points, so it could not open it.

run change (pass 2) result
P4c none 1 negative cell, non-orthogonality 93.6°
P4cSL RHEOMESH_UNTANGLE_SLIDE=1: the wall points of the failing cells slide on the surface during the untangle Mesh OK, non-orthogonality max 65.0°, skewness 4.0 (13 wall points moved)
MCSL (TUM wheels, old position) same Mesh OK, 67.0° (was 67.0°)

The setting is experimental and off by default; whether it enters the main line is decided with the regression corpus. Two weak points found on the way are real but were not this failure's cause: the layer counts given to S_H took the smallest corner count (one zero-layer wall point zeroed nearby CAD points; RHEOMESH_LAYER_SH_N=interp), and the requests of the moved layer table jump between neighbouring wall points. The diagnostics tool rheomesh-failures locates failing cells and probes the surfaces around them.

Thin gaps (provisional, 2026-11-04, updated 11-05)

rheoMesh puts no cells in fluid gaps narrower than about 3 cells; snappyHexMesh and cfMesh keep gaps down to about one cell. To close the difference, the gaps are being filled with cut cells (voxels clipped by the surface, as polyhedra) joined to the main mesh (core + pillow). On two synthetic slots the whole slot is meshed and the checks pass; the seam rules then turned out not to close where the core boundary steps like a staircase, and the work moved to refinement (see "Afterwards").

Cause

The core rule removes the leaves within (0.5 + sqrt3/2) h of the surface and fills the space with one pillow layer. In a gap with walls on both sides every leaf goes, and there is no core left for a pillow. flange's right-hand channels (about 3 cells thick) were lost this way.

What was tried

method result
a smaller core margin in gaps only (RHEOMESH_GAP_MARGIN) flange's upper channel filled; motorBike and windAroundBuildings fail. Not a default
one level finer in the gaps (RHEOMESH_GAP, global or local boxes) flange: every channel meshed, Mesh OK. motorBike failed all three times, always at the new level steps next to the walls
cfMesh (cartesianMesh) run as a black box keeps the inside cells down to one cell and moves their vertices to the surface; keeps flange's channels. On motorBike (not a closed surface) the wheel insides stay empty: not comparable

On the way, a leak was found: where flange's walls lie exactly on lattice planes, rounding made the surface-box test call both leaves uncut and the fluid passed into the solid. The core rule had been removing the leaked side as an island, so the final mesh did not show it. The test boxes are now grown by 1e-6 by default (Miyabi regression: main line identical, sample and flange change by 1-2 cells, both pass).

Topology of the lost fluid

The question is not the flow rate but connectivity: fluid connected in voxels and not in the FV mesh. A check (RHEOMESH_TOPO_CHECK, diagnostic) groups the lost fluid and types it; cut leaves count as fluid by the winding number at their centre, and two leaves connect only when the segment between their centres does not cross a wall.

case lost leaves region cut off bodies joined passage dead end
motorBike 1,246 1 5 4 82
windAroundBuildings 822 0 0 0 11
flange 192 0 0 0 4
the other 13 0 0 0 0 0

flange's channels are dead ends: connectivity is kept and only volume is missing. In motorBike the pocket between the engine and the underbody plate and the strip between the front fender and the tyre have cells in snappyHexMesh and none in rheoMesh.

Filling with cut cells

Only the gap region is split into voxels; from the node flags (winding number) and the crossings of the lattice edges with the surface each face gets its fluid polygons; each fluid piece of a voxel is one cell, closed by triangles toward a point on the surface. The join to the main mesh (design of 2026-11-04, option a):

  • the core faces facing the gap get no pillow; they become internal faces to the cut cells;
  • the pillow's rim vertices sit on the crossings of their lattice columns, and the rim laterals are replaced by the cut polygons;
  • the cut points are not moved by the later stages;
  • a fluid node with a crossing within 0.2 of a cell goes onto that crossing (no thin cells).

Synthetic slots (two plates through the domain in y, a slot of 2.5 cells open at the two x ends):

case check max non-orth fluid volume added slot volume
flat Mesh OK 40.1° (without: 51.4°) +0.157 0.156
tilted 10° Mesh OK 42.0° +0.158 0.156

A stand-alone mesh of motorBike's gaps as cut cells (657 cells) also passes (max non-orth 36°, max skew 3.6). The cut walls approximate the surface by chords within 0.1 of a cell. Next: motorBike and flange (dead ends included by a size threshold), the 16-tutorial regression, gaps across a level step, then layers. The setting goes into the tutorial recipe core.recipe only; the main line is unchanged.

Afterwards: the refinement route (2026-11-05)

Two seam designs between the cut cells and the main mesh were tried (option a: pillow rims at the column/surface crossings; a ribbon of faces along the rims). Neither closed where the core boundary steps like a staircase. The gaps are now refined until the main mesh alone fills them, with three fixes:

  • points that are masters of hanging nodes stay fixed in the surface optimiser (RHEOMESH_SURFOPT_KEEP_MASTERS);
  • the refinement band grows in 3-D, so that a level step lies at the rim of each wall's own refined patch (RHEOMESH_GAP_BAND3D);
  • a first pass without the gap rule finds the triangles where fluid is lost, and the rule is applied there only (RHEOMESH_GAP_LOCAL).
case result
flange Mesh OK, 72,600 cells (27,300 without the rule); fluid volume 1.543e-5 (snappyHexMesh 1.563e-5)
windAroundBuildings Mesh OK, 360,000 cells
synthetic fine slots pass
motorBike fails (24 negative cells): near the front wheel a level step falls on a sharp corner between two parts

On the gap suite the lost fluid volume drops from 0.154 to 0.000118 (fraction of the fluid). None of the switches is a default.

Comparison with snappyHexMesh (provisional, 2026-11-05)

The layer thickness reference

With relativeSizes true, snappyHexMeshDict gives the layer thickness relative to the cell just outside the layer. rheoMesh took the cell at the patch's minimum surface level instead. On motorBike, most of the surface is at level 6 but the reference was level 5, so the first-layer target was twice snappyHexMesh's (about 9.4 mm against 4.7 mm). A switch now takes the size of the wall faces at each wall point (RHEOMESH_LAYER_REL_LOCAL=1; the default is unchanged).

motorBike (one layer, two passes) before with the switch
first-layer target about 9.4 mm about 4.7 mm (as snappyHexMesh)
wall points with a layer 70.9 % 83.2 %
faces with a layer (motorBike / lowerWall) 47.7 % / 95.4 % 55.1 % / 95.6 %
check fails (1 negative cell) fails (1 negative cell)

On the same dictionary snappyHexMesh thins the layers to 7-93 % of the target per patch (24 % on the fairing); over its layer iterations the extruded faces drop from 70.4 % to 56.4 %. cavitatingBullet and injectorPipe have one surface level, and their meshes do not change with the switch.

The surface band width

The width of the fine band around the surface (default 3.5 cells) sets how many cells come before each level change. motorBike, pass 1:

band level 5 level 6 leaves kept check
3.5 28,912 164,778 343,189 Mesh OK
3 28,429 146,088 322,987 fails (2 negative cells)
2.5 26,738 127,404 301,699 Mesh OK
snappyHexMesh (castellated) 22,936 154,003 325,682 (all cells) -

The rheoMesh counts leave out the leaves at the surface that the core rule removes; the snappyHexMesh counts include them, so the columns do not compare directly. Band width and nCellsBetweenLevels are being swept on Miyabi.

Tutorials in bulk

Every case with a snappyHexMeshDict was run with rheoMesh from its dictionaries (no layers):

set cases Mesh OK fail not run
OpenFOAM v2606 tutorials 65 26 10 29
Foundation OpenFOAM-13 tutorials 21 9 2 10
public GitHub cases (with a stated licence) 25 14 3 8

The cases that did not run use dictionary entries rheoMesh does not handle yet: multiple regions (locationsInMesh and zones), multi-block or graded blockMesh, regions by distance or inside a surface, distributedTriSurfaceMesh, and background meshes without surfaces. The Foundation forms (type triSurface, insidePoint, mode inside; level N;) are now read. Most failures are motorBike variants with higher surface levels (the LES case and others) and rotating or overset parts.

snappyHexMesh logs, stage by stage

snappyHexMesh runs keep every stage, and a tool turns its logs into numbers per stage (mesh/tools/shm_log_parse.py); only the logs and meshes are used, no source. motorBike:

  • castellation (32 s): feature, surface, removal beyond the surface, region (shell) refinement, then the split at the surface and the baffle handling; 325,682 cells.
  • snap (61 s): 10 feature-snap iterations; where quality fails the displacement is scaled 1 -> 0.75 -> ... and retried, 115 times in all.
  • layers (62 s): over 13 iterations the extruded faces drop from 70.4 % to 56.4 %; the points thinned by the medial-axis rule drop from 1,312 to 539.

Next: a snappyHexMeshLike mode (in design)

A mode that reads snappyHexMeshDict and produces nearly the same mesh as snappyHexMesh, fast, threaded on one node, is being designed: castellation that keeps the cells cut by the surface, then snap and layers. The measures are, per stage, cells per level, kept volume, layer coverage and checkMesh; point-by-point identity is not a goal. An option with more layers than snappyHexMesh on the same dictionary switches the near-wall treatment to rheoMesh's route (core rule, pillow, extrusion). A mode for the Foundation snappyHexMesh is planned as well.

A tool converts a cfMesh meshDict into blockMeshDict and snappyHexMeshDict (mesh/tools/cfmesh_to_snappy.py). Of the 13 cfMesh tutorials, the 9 with STL surfaces were converted and meshed by rheoMesh, all Mesh OK; multipleOrifices keeps far too few cells and its inside point is being checked. The 4 with .fms/.ftr surfaces wait for the conversion to STL.

snappyHexMeshLike mode (C0 implemented, 2026-11-05)

A mode (RHEOMESH_MODE=shm) reads a snappyHexMeshDict and produces nearly snappyHexMesh's mesh (castellation, snap, layers), threaded on one node and fast. The targets per stage are cells per level, kept volume, layer coverage and the checkMesh result; point-by-point identity is not a goal. snappyHexMesh's source is not read: its behaviour is taken from its logs and stage meshes. An option with more layers than snappyHexMesh on the same dictionary switches the near-wall treatment to rheoMesh's route (core rule, pillow, extrusion). The Foundation dictionary differences are handled inside the same mode.

The first stage (C0) reads snapControls, addLayersControls, meshQualityControls (with relaxed), features and inGroups, and implements the nine meshQualityControls criteria, with a tool rheomesh-quality that prints the counts in snappyHexMesh's "Checking faces in error" wording. On snappyHexMesh's kept stage meshes the nine counts match for every stage of motorBike, iglooWithFridges and flange and for stages 1-2 of airfoilWithLayers; on airfoilWithLayers' layered mesh the tet quality does not (snappyHexMesh 5,105 faces, rheoMesh 0): its measure differs on near-flat tets. With the mode off, meshes are bitwise unchanged.

For the reference, Foundation OpenFOAM-13 was built on Miyabi and its snappyHexMesh is run on the Foundation tutorials. The Foundation snappyHexMesh overwrites by default; keeping the stages needs -noOverwrite.

C1: castellation (provisional, 2026-11-05)

With RHEOMESH_MODE=shm, after the refinement the cells cut by the surface are kept and become the mesh; no core rule, no pillow. Compared with snappyHexMesh's stage-1 (castellated) meshes (shm / rheoMesh):

case cells per level total fluid volume wall faces checkMesh
motorBike L5 22,936 / 27,927 (+21.8 %), L6 154,003 / 117,107 (−24.0 %), L3-L4 close 325,682 / 293,213 (−10.0 %) equal motorBike 61,747 / 60,430 (−2.1 %) both OK
iglooWithFridges every level within 1 % 6,532 / 6,510 (−0.3 %) −0.13 % close both OK
flange L1 +8.3 %, L2 −3.3 %, L3 +10.1 % −1.9 % +0.86 % 12,616 / 12,688 both OK
airfoilWithLayers L1 +25 %, the rest equal +4.1 % equal aerofoil 880 / 880 both OK

Only iglooWithFridges is inside the ±3 % per-level target. With the mode off the 16 tutorial meshes are bitwise unchanged.

What the logs and stage-1 meshes show about snappyHexMesh, partly against the design's first assumptions:

  • surface refinement marks a cell when the segment from its centre to a neighbour's centre crosses the surface (box overlap gives flange level 2 = 9,786 against 17,056);
  • even without shells, the finest levels grow by a band of about (nCellsBetweenLevels − 1)/2 cells; without a band motorBike level 6 is only 48,004. motorBike needs 1.7 cells, and this difference drives its level-5/6 mismatch;
  • feature-edge refinement acts only on the cells the edges cross;
  • the removed "problem cells" read as cells with all 8 corners on boundary faces: this explains 76 % of the cells only rheoMesh kept on motorBike;
  • a thin part with fluid on both sides becomes a baffle (two boundary faces); the aerofoil wall face count then equals snappyHexMesh's.

The band rule is being re-derived with the stage-1 cell counts of more shm65 cases. Also open: the band at coarse level steps (motorBike levels 1-2), flange's problem-cell rule, one patch per surface region, and writing faceZones. snappyHexMesh's castellation of motorBike takes 32.8 s on 1 rank with blockMesh (0.6 + 32.2) and 16.4 s on 28 ranks with blockMesh and decomposePar (0.6 + 1.1 + 14.7), the snappyHexMesh parts being log times (there is no process time for castellation alone); rheoMesh's time is re-measured with a parallel build before it is reported.

2026-11-05 progress: snap, quality optimisation, local refinement, AMR knowledge, CPU and GPU on one node (provisional)

Results of five pieces of work from the second half of the day. All are trials; no default mesh changed.

work conclusion
snap of the snappyHexMeshLike mode (S1) motorBike's castellation and snap together take 5.86 s on Miyabi-C 1 node (112 cores). From the dictionary to the same two stages, snappyHexMesh takes 95.8 s on 1 rank (blockMesh 0.6 + snappyHexMesh's process time 95.2). On 28 ranks there is no run without layers, so the layered run's log times give 21.7 s (blockMesh 0.6 + decomposePar 1.1 + 20.0). With the layers the process times are 157.0 s (0.9 + 156.1) and 32.6 s (0.6 + 1.1 + 30.9). All are single runs on the same node type. All four cases are Mesh OK in checkMesh
quality optimisation (G1, G2) The time came down by cutting the existing shape optimisation from 20 to 3 sweeps: about 6.3 s becomes 2.33 s, with no more bad faces. The global optimiser stays an optional polish behind a switch
local refinement around bad faces, cell merging On motorBike the refinement added bad faces. Merging cells does not raise the time step. On DrivAer, the LBM forest taken as a staircase mesh, merged and then snapped passes checkMesh
AMR knowledge study (K1) 4 of 5 cases completed 3 cycles with Mesh OK. For external and building flows the high-error cells (the label to learn) are now marked by the residual error estimate (EREE)
CPU and GPU on one GH200 node The mutual slowdown is a few per cent. At motorBike size, however, meshing takes longer than a coarse flow field and does not hide behind the solve

S1: snap (provisional)

A snap stage now follows C1. Wall points move to the nearest surface point or to a feature edge or point, interior points are smoothed, and around faces that fail the quality check the displacement is scaled back and retried. The check is meshQualityControls' nine criteria plus checkMesh's skewness limit of 4: with the nine criteria alone, faces that checkMesh fails on skewness remained (up to 40.7 on motorBike). With the dictionary's boundary skewness of 20, motorBike, iglooWithFridges and flange fail checkMesh, so the limit stays at 4.

Most of the time went into the quality checks. Re-checking only the cells round the moved points brought motorBike's snap from 14.9 s in the first version to 2.75 s; on iglooWithFridges, flange and motorBike no face differs from a full check after any step. The feature extraction also counted a double-sided sheet and its reversed copy separately; with that fixed, C1's motorBike has 22,134 level-5 cells (−3.5 %) and 329,243 cells in all (+1.1 %; differences against snappyHexMesh).

The last version against snappyHexMesh's snap-stage mesh (rheoMesh / snappyHexMesh):

case checkMesh max non-orthogonality [°] max skewness feature points / points on feature edges mean displacement left at the last iteration [m] rheoMesh time (snap / whole run)
motorBike OK / failed 1 check (skewness) 64.96 / 64.92 4.00 / 8.94 1,082 / 10,220 (1,200 / 11,326) 1.09e-3 / 2.44e-4 2.75 s / 5.86 s
iglooWithFridges OK / OK 43.0 / 45.6 3.04 / 3.53 16 / 228 (16 / 484) 2.6e-5 / 4.2e-4 0.12 s / 0.42 s
flange OK / OK 62.0 / 51.0 3.96 / 3.38 18 / 1,615 (26 / 1,621) 1.06e-5 / 3.07e-6 0.64 s / 0.84 s
airfoilWithLayers OK / OK 38.7 / 23.6 2.56 / 0.96 0 / 13 (2 / 49) 7.1e-5 / 4.2e-5 0.10 s / 0.18 s

Inside the target band: checkMesh on all four; motorBike's non-orthogonality, skewness, feature points and feature-edge points (both −10 %) and time (within 6 s); iglooWithFridges' non-orthogonality, skewness, feature points and displacement; flange's feature-edge points (−0.4 %); airfoilWithLayers' displacement. Outside: motorBike's displacement (4.5×), iglooWithFridges' feature-edge points (−53 %), flange's non-orthogonality (+11°), skewness, feature points and displacement (3.5×), airfoilWithLayers' non-orthogonality, skewness and feature points. With the mode off, the 16 tutorial meshes are bitwise unchanged.

motorBike after the snap: rheoMesh snappyHexMeshLike mode S1 and snappyHexMesh

motorBike, front half, section at y ≈ 0.008 m. Left: rheoMesh's snappyHexMeshLike mode S1; right: snappyHexMesh's snap-stage mesh. Colour: the level from the cut cell's size; red: the section of the surface. The cell layout is nearly the same; in narrow places such as between the front-wheel spokes, rheoMesh leaves more points off the surface.

Quality optimisation: three sweeps of the shape optimisation (provisional)

G0 built the global optimiser's kernel (bitwise the same results on 1, 8 and 48 threads); G1 put it behind a switch (RHEOMESH_GLOBAL_OPT) in place of the shape optimisation of the layered second pass; G2 looked at its convergence. motorBike's layered second pass (one dedicated Miyabi-C node) gives the following. The "band" is the set of faces the shape optimisation moves; the table counts those above 25° non-orthogonality.

setting time [s] band faces above 25° final mesh
today's shape optimisation (20 sweeps) 6.31-6.57 27,925 failed 4 checks (max non-orthogonality 109.29°, 1 negative cell, 11 pyramids)
shape optimisation, 3 sweeps 2.33 26,917 failed 2 (80.28°, 0 negative, 7 pyramids)
3 sweeps + global optimiser, 30 iterations 2.12 + 3.81 25,960 failed 3 (94.18°, 0 negative, 8 pyramids)
global optimiser alone, 60 iterations 6.40 34,778 failed 3 (115.33°, 0 negative)

The band count is lowest at about 3 sweeps (5: 27,023, 8: 27,457, 20: 27,925); more sweeps do not help. The final mesh varies strongly with any change of this stage's output (0-3 negative cells for neighbouring settings). motorBike's layered mesh fails in every setting: some cells are already inverted before this stage.

The other cases (second pass, all Mesh OK):

case max non-orthogonality [°] (20 sweeps / 3 sweeps / 3 sweeps + global 30)
DrivAer (N = 5) 67.02 / 67.06 / 66.03 (shape and global time 8.82 / 3.63 / 3.30 + 3.52 s)
cavitatingBullet 33.98 / 33.58 / 31.14
iglooWithFridges 64.98 / 64.97 / 64.97
injectorPipe 55.16 / 55.21 / 54.59

Cutting to 3 sweeps alone brings the time from about 6.3 s to 2.33 s with no loss of quality. Adding the global optimiser afterwards removes about 1,000 band faces and lowers the maximum non-orthogonality by 1-3° on DrivAer and cavitatingBullet, for 0.5-3.8 s more, and the final verdict is no better than with the 3 sweeps. The global optimiser therefore stays an optional polish behind the switch; whether the shape optimisation's default becomes 3 sweeps is decided after a regression run. With the switch unset, the 16 tutorial meshes and the 4 layered two-pass cases are bitwise unchanged.

Local refinement around bad faces and cell merging (provisional)

The idea tested: refine one level more where the quality goes bad (concave corners, sharp edges, gaps ...) so that the snap and projection distort less. On motorBike, boxes went round the faces that failed checkMesh in the previous round, one level more per round. The table gives the meshes without the feature retry (the raw quality).

round core cells core: failing faces / negative cells / pyramids / max non-orthogonality layered pass-2 cells layered: failing faces / negative cells
0 413,115 89 / 6 / 41 / 117.1° 531,233 23 / 1
1 533,751 (+29 %) 221 / 26 / 122 / 157.8° 586,027 (+10 %) 69 / 8
2 847,931 (+105 %) 345 / 26 / 146 / 167.5° 723,128 (+36 %) 301 / 21
3 1,119,319 (+171 %) 369 / 35 / 189 / 173.3° 1,033,793 (+95 %) 504 / 42

The boxed spots are fixed: in the next round no failing face lies within 2 cells of a previous one. New failures appear 5-20 cm outside the boxes, though, because the level-7 band round the surface and the buffer of the level step spread beyond each box. Boxes placed in advance at sharp edges and thin gaps found 88 of the 89 round-0 failures, and those meshes failed in the same way. Raising the whole surface one level gives 2.6 failures per 10,000 wall faces against 6.1; local boxes give 10.4. With the current recipe one level more at the failing places does not fix motorBike's quality and costs 30-170 % more cells. The feature retry (round 0 Mesh OK in 7.6 s) stays the better tool for the core mesh; the negative cell of the layered second pass needs a fix in the second pass.

motorBike local refinement: round 0 and round 2

motorBike core mesh without the feature retry, section at y ≈ 0.1 m. Left: round 0; right: round 2 (boxes up to level 8). Colour: cellLevel; circles: faces failing checkMesh within 5 cm of the section (39 in round 0, 170 in round 2).

The reverse was tried as well: merging small cells to raise the time step. The tool rheomesh-cell-merge joins the 8 sibling cells of one level, or a small cell and its neighbour, only when the quality checks pass. On motorBike's round-0 core every setting stays Mesh OK with 0.8-62 % fewer cells, but the smallest time step at a uniform 20 m/s and Courant number 1 (1.60e-5 s) does not change. The 8 cells that set it are small wall cells (0.2-3.5 % of their level's median volume); merging them fails the pyramid or non-orthogonality test, or they have no partner for a convex union. Merging cannot repair negative cells, so refine-then-merge keeps the refined meshes' failures.

On DrivAer another route was tried from the L10 LBM forest (fa2 C2, half model, the rear part x ≥ 1.6 m): the LBM fluid cells taken as a staircase mesh (22 s), all sibling groups merged (48 s), and the snappyHexMeshLike mode's snap applied to that mesh (72-104 s).

mesh cells checkMesh max (mean) non-orthogonality [°] max skewness wall points within 0.1 h of the surface y⁺ p10 / 50 / 90 (share in 30-100)
L10 cut, k = 1 (10-28) 6.05 M failed 2 (39 pyramids, 2,034 skew faces) 68.5 (3.46) 5.68 cut (wall on the surface) 16 / 77 / 185 (41 %)
staircase 6,024,190 Mesh OK 25.2 (3.25) 0.33 15 % 21 / 129 / 354 (28 %)
staircase → merge 2,444,089 Mesh OK 25.2 (3.08) 1.00 18 % 20 / 147 / 408 (25 %)
staircase → snap 6,024,190 Mesh OK 64.9 (3.39) 4.00 94.8 % 41 / 156 / 270 (27 %)
staircase → merge → snap 2,444,089 Mesh OK 64.9 (3.25) 4.00 94.5 % 41 / 162 / 357 (26 %)

The merge-and-snap route passes the checkMesh the cut version failed, with 40 % of the cells. The 511,443 merged groups go from level 1 to 0 and 2 to 1; 52,014 level-2 cells stay at the wall (groups whose parent the body cuts have fewer than 8 fluid children and are not merged). The LBM-to-FV cell map is exact up to the merge (the volumes sum exactly), but the snap changes the wall cells' volumes (206,253 cells, |ΔV|/V p90 0.20, p99 0.66), so after the snap it is a first-order approximation near the wall. y⁺ is higher than in the cut version, because the wall cells stay whole with no small cut fractions.

DrivAer rear roof: staircase, merge, snap

DrivAer rear roof, section at y ≈ 0.205 m. From the left: the staircase mesh, the merged mesh, and the merged mesh after the snap. Colour: the LBM level from the cell size (the finest, level 2, is 1.1 cm). The cut version is shown in the L10 section below. The snap moves wall points onto the surface, but wall points on the symmetry plane (y = 0) stay, so the staircase remains in the y = 0 plane.

AMR knowledge study: K1 (provisional)

One case from each of five flow types was solved with simpleFoam; the cells of large estimated error were marked and refined, for 3 cycles (Miyabi-C 1 node, 112 ranks, one job per cycle). On cycle 0 we measured how well features from the geometry and the potentialFoam flow pick out the high-error cells (the top 10 %). Lift in the table is the share of the top-10 % error cells among the 10 % of cells a feature selects, divided by 0.1 (random selection gives 1).

case (flow type) cells (cycle 0 → 3) best single feature (lift) label stability: residual / EREE (Jaccard)
motorBike (external) 413,115 → 1,598,914 velocity gradient h|∇U|/U (4.34) 0.652 / 0.809
windAroundBuildings (buildings) 235,369 → 411,426 velocity gradient h|∇U|/U (4.59) 0.742 / 0.849
injectorPipe (internal) 65,588 (the cycle-1 mesh failed checkMesh) distance to a stagnation face (4.14) 0.968 / 0.950
Ahmed body 25° (separating bluff body) 321,295 → 744,354 wall distance (5.64) 0.902 / 0.951
cavity Re 1000 (laminar) 76,871 → 434,548 distance to a concave edge (2.58) 1.000 / 1.000

In four cases every cycle's mesh is Mesh OK. injectorPipe's cycle-1 mesh failed (3 negative cells, 17 pyramids), so it stopped at cycle 0. The target of one feature with lift 3 or more per flow type is met in four cases; the cavity, a closed domain without a potentialFoam flow, reaches only 2.58 with geometric features.

Label stability compares the top-10 % sets after N and 2N iterations on the same mesh (Jaccard index). Labelled by the normalised equation residual, motorBike (0.652) and windAroundBuildings (0.742) miss the target of 0.8; with 2000 and 4000 iterations they give 0.664 and 0.750, so it is not the iteration count. The EREE label is 0.81 or more on all five. For external and building flows EREE is therefore the primary label, with the residual label of the iteration-mean field recorded beside it.

Against experiments: on the cavity, the RMS difference of the centreline velocities from Ghia et al. (1982) goes from 0.048 at cycle 0 to 0.043 at cycle 3 for u and from 0.061 to 0.028 for v (the target of 0.02 at cycle 2 is missed). On the Ahmed body the wake recirculation length goes from 0.82 H to 0.89 H, and 71-75 % of the line 2 mm above the slant has reversed flow (steady SST separates on the slant). One cycle takes 4.3 min for motorBike cycle 3 (1.6 M cells) and under 2 min for the others. Cd is used neither as a target nor as a label.

Ahmed body AMR, cycles 0-3

Ahmed body 25°, section at y = 0, cycles 0-3. Colour: cellLevel; red: the section of the surface. The wake and the upper front are refined as the cycles proceed.

CPU and GPU on one GH200 node (provisional)

On one Miyabi-G GH200 node, GPU simpleFoam (motorBike, 2000 iterations, 4 CPU cores) ran while rheoMesh ran on the other 68 Grace cores.

alone together
one simpleFoam iteration 26.8 ms 27.1-27.3 ms with the two-pass meshing (+0.9-1.8 %), 27.5-27.8 ms with pass 2 + global optimiser (+2.5-3.6 %)
rheoMesh two passes (68 cores) 17.27-17.33 s 17.45-17.53 s
rheoMesh pass 2 + global optimiser 7.68-7.79 s 7.70-7.82 s

The mutual slowdown is a few per cent. A coarse flow field, however, takes potentialFoam 1.6 s and simpleFoam 12.2 s for 400 iterations (4.2-4.6 s for 100) on the same GPU, and the two-pass meshing (17.5 s) is longer; the solver advances about 640 iterations while the mesher runs. At motorBike size, meshing cannot hide behind the solve.

GH200: simpleFoam time per iteration with rheoMesh alongside

GPU simpleFoam time per iteration (running median of 41 iterations). Shading: while rheoMesh ran on the same node (blue: two-pass meshing; orange: pass 2 + global optimiser); dashed: 26.8 ms alone.

Next candidates

These are being looked into; there are no results yet.

  • Four ways to join the wall to the octree. The owner's choice is tile-wise refinement, gathered into the layer band, then a global optimisation of the whole shell.
  • Flow-informed layer sizing: potentialFoam with an integral boundary layer first, then a panel method.
  • A coarse LBM mean field as the AMR's cycle-0 flow field.
  • A regression run before the shape optimisation's default becomes 3 sweeps.

The course DrivAer (N = 5) at development version 38d99e21 (provisional, 2026-11-06)

Renamed: the mode called the "compatible mode" until now is named snappyHexMeshLike from 2026-11-06 (RHEOMESH_MODE=snappyHexMeshLike, short alias shm). It follows snappyHexMesh's procedure (castellate → snap → shrink → extrude) and aims at snappyHexMesh-level mesh quality; its output is not identical to snappyHexMesh's. The older sections of this page use the new name too.

The three meshes of the previous section were rebuilt from the same course dictionary with development version 38d99e21. 38d99e21 is a commit of the private development branch; these changes are not yet in the public repository masaz/openrheo. Machine: Flow2 Type I, one node (384 cores).

comparison result
snappyHexMeshLike, layers 21.5 s, 1.9 times faster than snappyHexMesh (41.4 s). Both Mesh OK. 385 faces over 50° non-orthogonality (snappyHexMesh 909), 50 faces over skewness 3 (520). Feature lines: median distance 1.24 mm (2.19 mm). Wall without layers where snappyHexMesh has them: 0.15 % of the body
snappyHexMeshLike, no layers 5.9 s, 5.6 times faster than snappyHexMesh (33.4 s). Max non-orthogonality 53.2° (64.95°)
native method (the own two-pass method), layers 47.4 s, slower than snappyHexMesh. Mesh OK, feature-line median 0.75 mm, pockets between wall and geometry 140 cm³ (snappyHexMesh 841 cm³): the closest to the geometry of the three. 4,577 faces over 50°
drag coefficient Cd snappyHexMesh 0.2564, snappyHexMeshLike 0.2697, native 0.2952; TUM experiment 0.243-0.252. The native gap is under investigation (see "Cd")

Dictionary, geometry and layer settings (6 layers on body, wheels and ground) are those of the previous section, from the course repository at 24869ff (Flow2/drivaerFastback/run/base); snappyHexMesh is OpenFOAM v2606 on 384 ranks. Time: snappyHexMesh = blockMesh + decomposePar + snappyHexMesh process wall times (mpirun start to exit, 384 ranks); rheoMesh = the whole process (native: pass 1 + pass 2). Faster of two runs1. rheoMesh's mesh md5 was the same in both runs and matched the values reported in development (snappyHexMeshLike 30df9fa0e6dec08c, native bed28d0769a7815b).

item snappyHexMesh snappyHexMeshLike native
time [s], layers 41.4 21.5 (1.93 times faster) 47.4 (0.87 times)
breakdown [s] blockMesh 0.4, decomposePar 1.6, snappyHexMesh 39.5 (castellate 9.4, snap 6.6, layers 7.8) snap 2.0, layers 14.6, rest (read, castellate, write ...) 4.9 pass 1 9.7, pass 2 37.7
time [s], no layers 33.4 5.9 (5.63 times faster) −
cells, layers 3,427,238 3,526,748 4,056,263
checkMesh Mesh OK Mesh OK Mesh OK
max non-orthogonality [°] 64.95 64.93 64.98
faces over 50° / 60° 909 / 61 385 / 34 4,577 / 1,111
faces over skewness 2 / 3 1,591 / 520 351 / 50 755 / 102
feature lines: median distance [mm] / within 1 mm 2.19 / 26.4 % 1.24 / 45.9 % 0.75 / 57.2 %
pocket volume [cm³] (count) 841 (408) 188 (277) 140 (492)
faces with layers / mean layers (each mesher's own output): body 91.6 % / 4.15 98.6 % / 4.84 99.4 % / 5.82
same: front / rear wheels 52.0 % / 0.97, 50.8 % / 0.94 91.6 % / 2.27, 92.1 % / 2.50 97.7 % / 5.62, 97.4 % / 5.55
same: ground 100.0 % / 5.95 99.9 % / 5.95 98.9 % / 5.88
wall area with layers / area-mean layers (counted from the mesh): body 85.5 % / 3.95 96.1 % / 4.80 95.8 % / 5.51
same: front / rear wheels 52.2 % / 1.17, 53.2 % / 1.21 79.4 % / 2.07, 81.8 % / 2.29 78.9 % / 4.05, 78.0 % / 3.96
same: ground 100.0 % / 5.85 100.0 % / 5.90 100.0 % / 6.00
wall area without layers where snappyHexMesh has them: body / front / rear − 0.15 / 0.44 / 0.29 % (own output) 1.69 / 3.10 / 3.17 % (counted from the mesh)

Non-orthogonality (internal faces) and skewness (all faces) as OpenFOAM defines them. Feature lines: geometry edges with dihedral angle over 30° (y ≥ 0, ground excluded) sampled every 2 mm, distance to the nearest wall-mesh edge. Pockets: connected wall faces (body, wheels) standing over 2 mm off the geometry on the fluid side, volume = area × distance. Layers are counted two ways: each mesher's own output (snappyHexMesh's per-face layer field, snappyHexMeshLike's per-face output, the native method's log at extrusion time, before the gap cells are added), and counted from the three final meshes by one rule, which misses tapering layers: for snappyHexMesh's body the two give 91.6 % and 85.5 %, and the rule counts 9.0 % of the body and about 21 % of the wheels as without layers where snappyHexMesh's own output has them. The native "without layers" figures exist only as counted values and carry that error.

snappyHexMeshLike's mean layer count on the wheels fell from 3.3-3.5 (b9e6b489) to 2.3-2.5 while the share of wheel faces with layers rose from 73-76 % to 92 %: it now copies snappyHexMesh's ramp of one more layer per ring of faces away from a face without layers, which thins the layers where they stop.

Main changes since the last update (b9e6b489)

The snappyHexMeshLike changes were derived from snappyHexMesh's output meshes and logs (including the intermediate meshes written per stage); snappyHexMesh's source was not read.

change (development label) what it does
layer-count ramp (LRAMP) wall faces sharing a point differ by at most one layer. In snappyHexMesh's final mesh the count equals the ring distance to the nearest face without layers almost everywhere (ground 100 %, body 98.7 %, wheels 99.9 %)
refinement band width (BANDISO) the band of fine cells round the surface is taken at one distance whatever the surface orientation (nCellsBetweenLevels − 0.5 cells). The old band was thinner than snappyHexMesh's on flat walls and thicker on slanted ones; calibrated on snappyHexMesh's castellated meshes of six tutorials and the DrivAer
surface feature edges (FEDGE) feature lines taken from the surface triangles' own edges; both lips of a narrow groove are left out
pocket rule (POCKET, POCKETFOLD) snapping to feature edges can leave a wall face bridging a groove off the geometry; in each snap iteration one point of such a face goes along the face normal onto the geometry, never a point whose move folds a wall face
folded face corners (FSLIVER) points at the corners of folded wall faces stop being attracted to a feature line
post-layer repair (POSTOPT) after the layer stage the points round poor faces move to repair them; moves changing a first-layer cell's volume by over 10 % are refused
snap iterations (NMORPH 4) four snap iterations, chosen against snappyHexMesh's per-iteration log
shrink iterations (LRELAXITER) max(8, nRelaxIter) iterations per step when the interior mesh shrinks back from the wall for the layers
layer revival (LREVIVE) faces whose layers the quality check removed take one layer again once the stage settles, if at least half their neighbours have layers (up to 2 rounds)

Native method:

change what it does
wall snap to edges in pass 2 the wall points at the foot of the layer stacks move onto the geometry's convex and concave edges, withdrawn where nearby faces get worse; convex edges within 1 mm 23.6 % → 73.4 % (development measurement)
gap pillow (narrow recesses) cells are added from the wall faces to the geometry in narrow recesses left between the wall mesh and the geometry; cells failing the quality check now join the cell above them instead of being dropped (pockets 190 → 140 cm³)
native post-opt after the layers and the gap cells the points round poor faces move, smooth-wall points sliding on the geometry; faces over 50° were 19,603 in a version before this repair, 4,577 now
cone release pillow cells that fold at their feature-line targets give up those targets

Cd (under investigation)

The three meshes were solved with the same solver setup (simpleFoam), Cd averaged over iterations 3001-4000, Flow2 Type I on 384 ranks. Both rheoMesh meshes were made at 53b2bbbc: the snappyHexMeshLike mesh is the one in the table above (same md5); the native one predates the gap-cell joining.

mesh Cd first-cell y⁺ (body mean)
snappyHexMesh 0.2564 37
snappyHexMeshLike 0.2697 32
native 0.2952 23
TUM experiment 0.243-0.252 −

The native Cd is 15 % above snappyHexMesh's. The cause is not settled; observed so far: behind the car (x = 3.9-13 m) the maximum turbulent kinetic energy k in each section is 2-3.5 times snappyHexMesh's, and the body's first-cell y⁺ averages 23 against 37.

DrivAer N = 5, car centre section (38d99e21)

y = 0.00625 m. Top left snappyHexMesh, top right snappyHexMeshLike, bottom left native; colour is the cell size (cube root of the volume), red the surface section.

DrivAer N = 5, rear end (38d99e21)

The same section at the rear: snappyHexMesh, snappyHexMeshLike, native. All three have layers on the base and the fastback's lower edge.

DrivAer N = 5, front tyre contact (38d99e21)

y = 0.7562 m through the front tyre where it meets the ground; top to bottom snappyHexMesh, snappyHexMeshLike, native. All leave a cell-free region round the contact; the native one is widest (to about x = ±0.085 m).

DrivAer N = 5, underbody step (38d99e21)

y = 0.3438 m, the underbody step near x = 1.94 m; panels as in the centre section. snappyHexMesh's wall stands off the geometry at the step's upper corner (x ≈ 1.95 m) and near x = 2.03 m; snappyHexMeshLike follows the step; the native method has a full 6-layer stack but leaves a small pocket at the foot of the step's riser.

DrivAer N = 5, layers per wall face (38d99e21)

Layers per wall face of the half car seen from +y (blue 6, red 0); top to bottom snappyHexMesh, snappyHexMeshLike, native. The panel titles count only the faces visible from this side, so they differ slightly from the table; the native panel is counted from the mesh and misses tapering layers on the wheels. snappyHexMesh and snappyHexMeshLike show rings of one-layer steps round the faces without layers.

Open issues

issue status
native Cd and wake Cd 0.2952, 15 % above snappyHexMesh; higher wake k and lower first-cell y⁺; cause under investigation
native time 47-50 s, slower than snappyHexMesh's 41 s; pass 2 takes 37.7 s, the gap pillow about 10 s of it
pockets against cuts into the solid snappyHexMeshLike has 188 cm³ of pockets and 308 cm³ of wall over 2 mm inside the solid; settings that reduce the cuts add pockets, and the sum stayed at 460-500 cm³ in every variant tried. The pocket rule moves the deviation from one side to the other; nothing reduces the sum yet
tyre tread grooves the grooves are about 1 cm wide and deep, narrower than the layer stack (about 15 mm); layers cannot fit from both sides, so they stop or the wall face bridges the groove

The course DrivAer (N = 5): snappyHexMesh and rheoMesh (provisional, 2026-11-05)

This section holds the results of the earlier version (b9e6b489); the latest comparison is in the section above.

The DrivAer fastback mesh of the training course (setMesh 5, base cell 0.2 m) was made from the same dictionary by snappyHexMesh and by rheoMesh. On the course machine, Flow2 Type I, one node (384 cores):

comparison conclusion
no layers: snappyHexMesh against the snappyHexMeshLike mode After castellation every level's cell count is within 3 % of snappyHexMesh. After the snap, snappyHexMesh fails one checkMesh check (skewness); the snappyHexMeshLike mode is Mesh OK. From the dictionary to the snapped mesh, snappyHexMesh takes 32.0 s (blockMesh 0.4 + decomposePar 1.5 + snappyHexMesh 30.1) and the snappyHexMeshLike mode 7.9 s: 4.0 times as long
with layers: snappyHexMesh against the snappyHexMeshLike mode The snappyHexMeshLike mode now adds the dictionary's layers too. snappyHexMesh fails on skewness, the snappyHexMeshLike mode is Mesh OK. Mean layer count on the wheels: 0.9-1.0 against 3.3-3.5. 45.9 s (blockMesh 0.4 + decomposePar 1.7 + snappyHexMesh 43.9) against 21.3 s, 2.2 times as long
with layers: rheoMesh's own method Two passes, 4.02 M cells, Mesh OK in checkMesh and in rheoMesh's own check. Layers on 96-99 % of the wall faces, 5.4-5.5 layers on average even on the wheels. 34.6 s

snappyHexMesh runs on 384 ranks and rheoMesh with TBB threads. Both start from the dictionaries, so snappyHexMesh's time is blockMesh (the background mesh) + decomposePar (the split for the parallel run) + snappyHexMesh. The snappyHexMesh part is the process time from the start of mpirun to its end, which includes the MPI start-up and library loading that the log's "Finished meshing in" leaves out. rheoMesh's time is its whole process, from reading the dictionary to writing the mesh. Both use the faster of two runs; the first run is often slowed by loading the libraries for the first time. rheoMesh writes its mesh from one process, so a parallel solver needs decomposePar first: on Type I into 384 parts, 10.0 s without layers and 12.0-12.1 s with layers. With that included, the snappyHexMeshLike mode is 1.8 times as fast without layers and 1.4 times with layers. The same comparison on Miyabi-C 1 node (112 cores) is in "Times".

Conditions:

item setting
geometry body, frontWheels, rearWheels (417,114 triangles). Surface level 4 (12.5 mm), regions vr1-vr4 at levels 1-4, nCellsBetweenLevels 5
dictionary The course's snappyHexMeshDict is in the Foundation form and reads snappyHexMeshDict.cfg with #includeEtc. rheoMesh does not read the .cfg yet, so both tools read the dictionary expanded by v2606's foamDictionary -expand
layers 6 layers on body, wheels and ground (relativeSizes, expansionRatio 1.2, finalLayerThickness 0.3); addLayers false for the comparison without layers
snappyHexMesh OpenFOAM v2606; 384 ranks on Type I, 112 ranks on Miyabi-C (scotch)
rheoMesh rheomesh-flow2 b9e6b489. snappyHexMeshLike mode (RHEOMESH_MODE=shm): without layers it stops after the snap. Own method: the two passes of tutorial-layers-gap.recipe (pass 1 plans the layers, pass 2 extrudes them)

No layers: castellation and snap

Cells per level right after castellation (Miyabi-C, snappyHexMesh on 112 ranks):

level snappyHexMesh snappyHexMeshLike mode difference
0 151,102 151,100 −0.0 %
1 356,924 356,939 +0.0 %
2 157,375 158,865 +0.9 %
3 517,402 511,046 −1.2 %
4 1,671,011 1,627,044 −2.6 %
total 2,853,814 2,804,994 −1.7 %

Every level is inside ±3 % and the total inside ±2 %, and the fluid volume (1596.76 m³) is the same: the C1 target that motorBike missed holds on DrivAer. Both meshes are Mesh OK in checkMesh (max non-orthogonality 25.2°, max skewness 0.33). snappyHexMesh's cell count changes a little with the rank count: 2,849,243 on 384 ranks on Type I.

DrivAer N = 5 after castellation, section near y = 0

Section at y = 0.00625 m, through the first row of cells next to the symmetry plane (y = 0). Left: snappyHexMesh; right: rheoMesh's snappyHexMeshLike mode. Colour: the level from the cell size (0 = the coarsest cells in view); red: the section of the surface. The region boxes and the bands round the surface have nearly the same shape.

After the snap. The snappyHexMeshLike mode ran with the new defaults decided by the owner (rheoMesh's wall-face smoothing for the dictionary's nSmoothPatch skipped, skewness limit 3.5) with the fix that sends wall points left inside the solid back to the surface, and with the fix that moves implicit feature targets lying off the surface on rounded shoulders onto it (b9e6b489).

item snappyHexMeshLike mode (b9e6b489) snappyHexMeshLike mode (previous defaults, c13bbb7) snappyHexMesh
checkMesh Mesh OK Mesh OK failed 1 check (skewness, 3 faces)
max non-orthogonality [°] 50.0 50.0 64.96
max skewness 3.50 4.00 9.34 (7.18 on Type I)
feature points / points on feature edges 665 / 15,434 476 / 11,752 2,258 / 15,232
mean displacement left at the last iteration [m] 1.99e-4 3.9e-5 1.66e-4

The new version also takes the implicit features by sampling the surface instead of from the surface's own edges. The feature-edge points are now 1.3 % more than snappyHexMesh's, while the feature points are still 71 % fewer. On rounded shoulders the implicit feature targets lay off the surface; they now go onto it. Wall points more than half a cell off the surface went from 41 to 15, and those more than 7 mm off from 21 to 7.

With layers: snappyHexMesh, the snappyHexMeshLike mode and the own method

The snappyHexMeshLike mode's layer stage runs after the snap. It merges the wall faces of each cell, sets a layer thickness per wall point (limited by the distance to the facing surface), shrinks the mesh away from the wall and extrudes the layers. Faces that fail the quality check lose their layers, faces failing on skewness alone get half the layer count, and this repeats until nothing changes (17 iterations on DrivAer). As in the snap, the check includes the skewness limit of 3.5, which snappyHexMesh does not have. The own method decides the layer count and thickness per wall point in pass 1 (reduced by the distance to a facing wall and by the slope of the stack height) and extrudes in pass 2.

item snappyHexMesh snappyHexMeshLike mode own method
cells 3,432,393 (3,427,285 on Type I) 3,457,810 4,023,723
checkMesh failed 1 check (skewness, 7 faces) Mesh OK Mesh OK (rheoMesh's own check also OK)
max non-orthogonality [°] 70.10 (1 face over 70°) 64.99 65.71
max skewness 9.34 (7.18 on Type I) 3.53 3.997
wall faces with layers 90.2 % overall 90.6 % overall (99.0 % by area); ground 99.7 %, body 88.9 %, front wheels 73.0 %, rear wheels 75.9 % ground 99.1 %, body 98.1 %, front wheels 96.9 %, rear wheels 96.5 %
mean layer count (6 asked): ground / body / front / rear wheels 5.95 / 4.15 / 1.02 / 0.89 5.78 / 4.84 / 3.26 / 3.46 5.89 / 5.71 / 5.52 / 5.44
overall layer thickness against the request: ground / body / front / rear wheels 90.5 / 77.5 / 25.2 / 20.9 % 95.2 / 76.8 / 50.9 / 53.7 % medians 1.00 / 0.87 / 0.78 / 0.80

For snappyHexMesh and the snappyHexMeshLike mode the mean layer count is counted as in snappyHexMesh's log table (layer cells divided by faces). snappyHexMesh's values are from 112 ranks on Miyabi-C; on 384 ranks on Type I the wheels have 0.99 and 0.93. The snappyHexMeshLike mode's mesh is bitwise the same on Miyabi-C and Type I. It puts layers on about the same share of the faces as snappyHexMesh and more than triples the layer count on the wheels, but its layers are still fewer and thinner than the own method's. Where the layers stop, the wall face without layers leaves a wedge-shaped gap; it is filled with wedge cells (4,121 on DrivAer N = 5), and the fluid volume is the same before and after the layers (1596.760 m³).

The own method's mesh used to have no fluid cells between the front and rear tyres and their wheel arches (gaps of 6-7 cm). Pass 1 kept the gaps, but after pass 2 put layers on both walls, the margin of the core rule (cells within (0.5 + √3/2) h of the surface leave the core) removed the rest of the gap. The recipe tutorial-layers-gap.recipe reduces that margin to 0.25 in pass 2 only: the gaps are open and both checks are Mesh OK. On the four layered tutorial cases the smaller margin does harm, so tutorial-layers.recipe is unchanged and the new recipe is for cases where layered walls face each other across narrow gaps. The ground layers were sized from the finest cell and reached 0.42 of the requested thickness (median); they are now sized from the cell above by default and reach 1.00. Passages of 2-3.4 cm under the floor and inboard of the rear wheels are still closed in pass 1; they need a castellation rule that refines narrow gaps.

DrivAer N = 5 after the snap and with layers, section near y = 0

Section at y = 0.00625 m. Top row: no layers, after the snap; left snappyHexMesh, right rheoMesh's snappyHexMeshLike mode. Bottom row: with layers; from the left snappyHexMesh, rheoMesh's snappyHexMeshLike mode and rheoMesh's own method. Colour and red line as above.

DrivAer N = 5, rear of the car

The rear of the car in the same section, with the lower end of the fastback and the base; rows and columns as above. Without layers the cell layout is nearly the same. With layers all three have layers on the base and the lower end of the fastback.

DrivAer N = 5, front wheel and wheel arch

Section at y = 0.75625 m through the front tyre; rows and columns as above. The snappyHexMeshLike mode keeps cells one level coarser than snappyHexMesh in the gap above the tyre (a difference already in castellation). The white triangles along the tyre and wheel-arch lines in the previous version were cells reaching into the solid where snap points stayed inside; fixed (d467cc8); a few remain near the tyre contact. The small protrusions on the tyre near x = −0.32 m are surface bumps narrower than a cell, not snap errors. With layers snappyHexMesh has hardly any layers on the tyre; the snappyHexMeshLike mode has thicker layers than snappyHexMesh on the tyre and the wheel arch, and the own method has the full six layers. The own method's mesh now has cells between the front of the tyre and the wheel arch.

Times

DrivAer N = 5, time per stage (Type I)

Time per stage in seconds on Flow2 Type I, one node (384 cores); the faster of two runs throughout:

stage snappyHexMesh, no layers snappyHexMeshLike mode, no layers snappyHexMesh, layers snappyHexMeshLike mode, layers own method, layers
blockMesh 0.4 − 0.4 − −
decomposePar 1.5 − 1.7 − −
castellation 9.4 3.2 10.7 3.3 −
snap 6.8 4.8 7.7 5.4 −
layers − − 9.1 12.6 −
pass 1 (core mesh, layer plan) − − − − 9.8
pass 2 (core mesh, layers, quality) − − − − 24.8
other (MPI start-up, library loading, I/O) 14.0 − 16.3 − −
total 32.0 7.9 45.9 21.3 34.6
total, other run 39.8 8.1 83.5 21.4 35.5

snappyHexMesh's total is blockMesh + decomposePar + snappyHexMesh's process time (30.1 s without layers, 43.9 s with layers); its stages are the log's "Mesh refined in", "Mesh snapped in" and "Layers added in", and "other" is the process time minus the three stages. In the other (first) run blockMesh, decomposePar and snappyHexMesh were all longer (9.9 s, 4.5 s and 69.1 s with layers). rheoMesh's are the [timing] values; the snappyHexMeshLike mode's castellation is the total minus the snap and the layers, so it includes reading, the final check and writing.

On Miyabi-C, one node (112 cores), in seconds; one run of each mesher, the snappyHexMeshLike mode at b9e6b489 and the own method at the earlier 5c80a568. snappyHexMesh's blockMesh and decomposePar were not timed in the original runs; they were measured twice in a separate job with the same dictionary and the same split (112, scotch), and the faster values (0.7 s and 3.5 s) are added:

stage snappyHexMesh, no layers snappyHexMeshLike mode, no layers snappyHexMesh, layers snappyHexMeshLike mode, layers own method, layers
blockMesh 0.7 − 0.7 − −
decomposePar 3.5 − 3.5 − −
castellation 67.1 4.4 68.1 4.7 −
snap 15.0 9.0 15.7 8.8 −
layers − − 35.1 17.4 −
pass 1 / pass 2 − − − − 15.7 / 40.3
other 9.9 − 10.9 − −
total 96.2 13.4 133.9 30.9 56.0

snappyHexMesh's times on Miyabi-C are also process times measured round mpirun, and "other" is that minus the stages. The snappyHexMeshLike mode's meshes are bitwise the same on Miyabi-C and Type I. Decomposing rheoMesh's meshes into 112 parts on Miyabi-C takes 22.9-23.0 s without layers and 29.3-30.0 s for a layered mesh (3.45 M cells, previous version).

On Type I the snappyHexMeshLike mode is 4.0 times as fast as snappyHexMesh without layers; the difference is in castellation (3.1 s against 9.4 s) and in snappyHexMesh's MPI start-up and library loading (14.0 s). With layers it is 2.2 times as fast, while its layer stage alone is slower (12.6 s against 9.1 s). The own method takes 34.6 s, of which pass 2 is 70 %. On Miyabi-C snappyHexMesh's castellation is much longer, and the snappyHexMeshLike mode is 7.2 times as fast without layers and 4.3 times with layers.

Global quality optimisation (design, 2026-11-05)

In motorBike's two-pass layered run (Miyabi-C, 25.7 s) the point-moving steps take 46 % (11.9 s), the heaviest being the shape optimisation (4.7 s, 193k points). A design replaces it with a global optimisation of all points at once: hinge penalties above the checkMesh thresholds (non-orthogonality, skewness ...) and, always, a barrier that prevents inverted cells. Only today's shape-optimisation set moves, so the nearly orthogonal core cells stay unchanged. Gradients are hand-written reverse mode, deterministic for any thread count. CPU first (Miyabi-C), the same loops later on the GPU (Miyabi-G).

With a flow field, the error terms are weighted by the field. The default uses scheme-independent terms (non-orthogonal correction, skewness interpolation, stretching and cell-size errors); Jasak & Gosman's residual error estimate (in rheoMesh as rheomesh-eree) is an option. The field comes from a potentialFoam-initialised coarse simpleFoam run. On motorBike (413k cells, 112 ranks) potentialFoam takes 3 s and simpleFoam 12.7 s for 100 and 16.4 s for 400 iterations: the field costs about as much as the meshing. potentialFoam alone has no boundary layer or wake (-initialiseUBCs was checked not to change the interior field), so it only weights the outer region. No weighting targets Cd.

Accumulating flow knowledge (in design, 2026-11-05)

On the tutorials with a snappyHexMeshDict and on cases validated against experiments with the openRheo LBM (DrivAer, lid-driven cavity, backward-facing step, AIJ case A, Ahmed body ...), flows are solved and AMR is run; the cells of large estimated error are compared with features such as wall distance, adverse pressure gradient, the downstream side of sharp edges and wake streamlines. Weighting rules are derived from that evidence, and the data serve a learnt model. Published meshes (NASA TMR, AutoCFD, ERCOFTAC ...) are added as references once their licences are checked.

Speed-ups

N = 5, one node, 384 threads. With every change the polyMesh is bitwise the same as before.

step before after main change
extrusion repair, per round 1.46 s about 0.55 s (0.51-0.60 s) the part independent of the caps built once; face records in parallel; quality recomputed only around moved points
shape optimisation 8.4 s 6.8 s per candidate point, the geometry of the faces without it reused across its trials
second pass in total (body only, gap 0) 37.5 s 27.1 s the two above

With the change of the BVH construction (2026-10-28), the triangle BVH of the DrivAer surface (367,889 triangles) takes 86.0 ms instead of 67.4 ms to build (depth 38, one parallel pass per level).

Gap handling (GAP_BLEND)

Where two walls face each other closely (wheel arch and tyre, for example), the layer height H is limited to (d − k × core cell size) / 2 so that k cells of room stay between the layers (d is the distance to the facing wall; "gap k" in the tables). Switching that budget on whether the facing wall has layers (GAP_LAYERED) made neighbouring points alternate between budgets in the rear wheel arch; a squeezed layer cell formed there and simpleFoam diverged. Removing the layers in that 5 × 8 × 8 cm box made it converge, which verified that the cause was there and nowhere else.

GAP_BLEND smooths the layered / not-layered classification over 3 rings of edge neighbours and blends the budgets continuously with that weight.

mesh (N = 5) wall points without layers cells checkMesh Cd
gap 0 905 3,413,534 OK 0.2651
GAP_LAYERED (switched) 1,168 3,409,654 OK diverges
GAP_LAYERED + GAP_BLEND 3 941 3,411,253 OK 0.2607
gap 3 (everywhere) 1,761 3,398,994 OK 0.272

The blended budget converges and keeps nearly the layers of gap 0. It is not the default (an option). With layers on the tyres and the ground as well, N = 6 converged once the gap cells scale with N (3 × 2^(N−5), 6 cells = 3.75 cm at N = 6).

Error estimation and AMR

The error is estimated from a simpleFoam solution, and the octree cells with large error are refined by one level in the next mesh.

method source result
element residual error estimate (EREE) Jasak & Gosman 2003 implemented from the paper only. Kovasznay flow: effectiveness index 1.21 → 0.99 (grids 12 × 16 → 192 × 256)
normalised Residual indicator and Direct Taylor estimate Imano, Kamata, Sakamoto (AIJ) added to the same tool
AMR efficiency η same with the N = 7 solution as reference, mean η at N = 5: EREE 3.76, Residual 1.04, Taylor 1.99
NUAMR (a reversed-flow passive scalar marks the upstream stream tube; the threshold is relaxed outside it) Imano, Ohnishi, Kamata, Sakamoto (AIJ 2008) captures the same estimated error with fewer cells (EREE 22 k vs 31 k, Residual 39 k vs 71 k refined cells). Cd does not move

η compares how concentrated the true error (volume-weighted) is in the cells selected by the estimate with the selection by the true error itself. Estimates that grow with the cell volume (EREE, Taylor) select fewer, larger cells, so on a strongly graded octree they exceed 1. The Residual is intensive and gives η ≈ 1, as efficient as selecting by the true error.

One AMR cycle (from N = 5, the top 5 % by EREE) takes the estimated error of the refinable octree cells (below the surface level) from 27 % to 6 % of the total, and the total estimate falls 12 % for +33 % cells (uniform N = 6: 10 % for +62 %). The remaining 94 % sits in the near-wall core cells and the layer cells, which refinement boxes do not reach.

Mesh quality

Meshes of 2026-10-26 to 28, before the main line; the main line is on the rheoMesh page.

checkMesh values; every mesh has 0 failed checks. Cd is from simpleFoam (k-ω SST, wall functions), 4000 iterations, the mean of the 1000-iteration blocks 2 to 4.

mesh cells max / avg non-orth (°) max skew max aspect Cd
uniform N5, gap 0 3,413,534 65.0 / 6.67 3.85 314 0.2651
uniform N5, gap 3 3,398,994 66.6 / 6.43 3.97 314 ≈0.272
uniform N5, gap 3, estimated layers 3,347,389 66.3 / 6.29 3.88 314 0.2592-0.2599
uniform N5, gap 3, estimated layers (quality recipe) 3,398,879 65.0 / 6.47 3.88 453 —
adaptive, 1 cycle (top 5 %) 4,557,290 65.0 / 7.73 3.85 314 0.2526
adaptive (b) (top 10 %) 5,586,859 65.0 / 7.77 3.93 314 0.2550
uniform N6, gap 0 5,530,003 71.2 / 6.15 3.97 264 0.2575
N6, gap 3·2 5,767,503 65.0 / 5.08 3.97 264 0.2628
  • "gap 3·2" has layers on the tyres and the ground as well, with a gap of 3 × 2 = 6 cells. The others have layers on the body only.
  • "Estimated layers" use a per-face table of layer count and height decided from a solution (h1 from y+, total height from the boundary-layer thickness). The "quality recipe" also welds the normals of coincident points, uses a count taper of 2, and lets a wall face take the largest count of its points.
  • Reference Cd for the body-only mesh: 0.258 ± 0.002 (steady N = 6 / 7, the URANS mean at N = 6, the N = 6 variants). Experiment: 0.243-0.252.
  • The steady RANS at N = 5 has several wake states, and small mesh differences move Cd by about ±0.009. At N = 6 the variants agree within about ±0.002.

FVM-only AMR: indicator maps and Cd after one cycle

Three indicators computed with the FVM alone are compared on the octree core cells (2,918,339 cells) of uniform N = 5, gap 0. u'rms is sqrt(k)/U from UPrime2Mean, times (h/h0)^(1/2); h|ω|/U is the vorticity of the mean field times the cell size. Each is normalised by its mean and standard deviation over the fluid cells, and cells are marked with the floor ε = 1 and Dörfler bulk marking (θ = 0.5).

Provisional: normalised indicators on the y = 0 plane. From the top: u'rms from the iteration scatter of a steady run (SIMPLEC 0.9), u'rms of a URANS (pimpleFoam, 2 s), and h|ω|/U of the steady solution. One colour scale for all three. Grey: the body and the prism layers (the indicators are on the core cells only). u'rms carries the factor (h/h0)^(1/2) per level, so it steps at level interfaces (x ≈ 5.2 m and 6.6 m)

  • The iteration scatter of a steady run marks nearly the same cells as the URANS fluctuation. The volume-weighted Spearman rank correlation with the URANS u'rms is 0.92–0.95 over four relaxation settings (top-5 % Jaccard 0.67–0.77).
  • h|ω|/U picks the shear layers, a different set from u'rms (Spearman 0.52–0.66).
  • Of the core cells above 50° non-orthogonality (few to begin with), the top 2 % by u'rms takes 28 % with the URANS and 30–60 % with the scatter. The scatter also appears at poor cells, so it is an auxiliary marker only.

Cd after one cycle (floor 1.0 + Dörfler 0.5, the marked octree cells refined by one level; Mesh OK for every mesh):

indicator marked cells cells Cd (blocks 2 / 3 / 4)
none (uniform N5, gap 0) — 3,413,534 0.2651 / 0.2651 / 0.2652
h|ω|/U (steady solution) 44,975 3,738,720 0.2643 / 0.2644 / 0.2643
scatter u'rms (SIMPLEC 0.9) 61,562 3,849,843 0.2640 / 0.2641 / 0.2641
scatter u'rms (SIMPLEC 0.95) 107,059 4,169,022 0.2648 / 0.2649 / 0.2647
scatter u'rms (SIMPLEC 0.98) 91,745 4,064,762 0.2666 / 0.2664 / 0.2666
scatter u'rms (SIMPLE, U 0.8, p 0.4) 66,525 3,885,430 0.2653 / 0.2653 / 0.2651
URANS u'rms 137,446 4,380,309 0.2576 / 0.2645 / 0.2643

One cycle of wake refinement gives Cd 0.264–0.267; the change from 0.2651 is smaller than the wake-state scatter of the steady runs. Block 2 of the URANS u'rms mesh (0.2576) is before the wake has settled.

Results of the LBM-assisted track will be added after a fix of the moving-floor wall model.

L10: from a run LBM forest to an FV mesh (provisional, 2026-10-28)

Provisional. The fa2 flow-AMR series (C0: the uniform LBM forest; each cycle: a short LBM run, then AMR from that flow) gave the AMR'd forest C2, which rheomesh-lbm-fv converted into an OpenFOAM polyMesh. The LBM cells become FV cells one to one, the cells at the body are cut by the surface and small cut cells merge into a neighbour, and complete k x k tiles of the wall layers above the cut cells are agglomerated along the wall; each FV cell keeps the list of its LBM cells. Every FV cell volume equals the sum of its LBM cells' fluid volumes (max rel 1.8e-13), and the total agrees with an independent winding-number count to 3e-5. For k = 1 and 2 non-orthogonality stays below 69 deg, and checkMesh fails only the skewness and pyramid checks at about 2 000 cut faces; k = 4 reaches 76.5 deg where a tile sits on single cut cells. One AMR rule currently also refines blocks that are entirely solid; it will be fixed in the next cycle. C3, with the finer wall level L3 (5.5 mm, 35.5 M LBM cells), is running on GB200, and its conversion will follow. An alternative that keeps the LBM fluid cells unchanged and imposes the wall by an immersed-boundary condition is being evaluated as well.

The LBM domain starts at x = 1.6 m, so the front of the car is not part of this forest.

LBM -> AMR -> FV (y = 0)

pipeline

The outlines show the blocks that the indicators marked for the next cycle: I_w (vorticity), I_k (fluctuation) and I_n (kinetic sensor), with Doerfler theta 0.5.

Numbers (fa2 C2 forest, half model; points within 0.2 cell of the wall snapped to the fluid side, small cut cells merged below 0.2 of a cell)

x >= 1.6 m only (the LBM domain: rear part of the car), no IB wall condition.

item k = 1 k = 2 k = 4
LBM cells (half model) 7.31 M (L0 1.80 M, L1 1.08 M, L2 4.43 M; wall at L2 = 1.11 cm) same same
cut cells / wall polygons 72.6 k / 72.6 k (open chains 0) same same
volume match: FV cell vs the sum of its LBM cells' fluid volumes max rel 1.7e-13; total 172.978668 m^3, exact max rel 1.8e-13, exact max rel 1.8e-13, exact
independent check of the total (winding samples) rel 3.1e-5 (2.5e-6 without the snap) same same
FV cells 6.05 M 5.99 M 6.01 M
band / core 159 k / 5.89 M 103 k / 5.89 M 119 k / 5.89 M
band tiles (complete k x k tiles of wall layers 1-2) - 18.6 k tiles (74.6 k LBM cells) 2.7 k tiles (42.9 k LBM cells)
small cut cells merged 25.1 k 25.1 k 25.1 k
band aspect (bounding box) max / avg 3.0 / 1.16 3.0 / 1.33 4.0 / 1.23
non-orth max / avg [deg] 68.5 / 3.46 68.5 / 4.28 76.5 / 4.35
internal faces > 50 deg 106 3 472 29 691 (> 70 deg: 3 360)
skewness max (faces > 4) 5.68 (2 034, all at cut cells) 5.68 (2 034) 5.68 (2 034)
checkMesh (OpenFOAM v2606) Failed 2: 39 face pyramids, 2 034 skew faces at cut cells; all else OK Failed 2 (same) Failed 2 (40 pyramids, 2 034 skew faces)
y+ of the wall cells, p10 / 50 / 90 (table tau_w) 16 / 77 / 185 15 / 71 / 168 15 / 71 / 166
y+ share in 30-100 41 % 43 % 44 %

First version (19:40, no snap, groups not by tile): k = 1 skewness max 21.4, k = 2 / 4 non-orth max 90 / 152; replaced by the rows above.

Update 23:20: near-empty cut cells dropped, C3 and the unchanged-cell variant (provisional)

Small cut cells now merge into a neighbour that is not small itself, across the largest shared face. Cut cells with less than 1 % fluid become wall (fluid dropped: 1.8e-5 m^3 for C2, 9.8e-6 m^3 for C3). The last two columns use the LBM fluid cells unchanged (no cut, staircase wall); a wall condition at the true wall position for that variant is not implemented yet, so those meshes are not wall meshes and are not run.

Status 2026-10-29 (provisional): the cut-cell variant is frozen as the conservative reference. The next test is simpleFoam on the existing body-fitted meshes without prism layers (wall cells 25, 12.5 and 6 mm) against the layered meshes, to see what an isotropic wall can reach.

x >= 1.6 m only (the LBM domain: rear part of the car), no IB wall condition.

item C2 cut k = 1 C2 cut k = 2 C3 cut k = 1 C3 unchanged cells k = 1 C2 unchanged cells k = 1
wall level L2, 1.11 cm L2 L3, 5.5 mm L3 L2
FV cells (half model) 6.05 M 6.01 M 7.60 M 7.53 M 6.02 M
volume match (max rel) 1.2e-13 3.0e-13 3.7e-13 2.9e-13 2.9e-13
non-orth max / avg [deg] 54.6 / 3.45 71.8 / 3.73 64.8 / 4.50 25.2 / 4.00 25.2 / 3.25
checkMesh Failed 1: 649 skew faces (max 5.4) Failed 2: 6 pyramids, 709 skew faces Failed 2: 8 pyramids, 2 593 skew faces Mesh OK Mesh OK
y+ p10 / 50 / 90 (table tau_w) 16 / 75 / 182 13 / 65 / 168 9 / 39 / 94 10 / 62 / 178 21 / 129 / 354
y+ share in 30-100 42 % 41 % 51 % 38 % 28 %

Status 2026-10-29 01:10 (provisional): the staircase / immersed-boundary path is kept for the in-house Cartesian solvers, and the FV production path stays body-fitted with prism layers.

Findings (as of 2026-10-28)

  • Error-driven selection by threshold does not target Cd. Refining only the cells whose normalised estimate exceeds 1 (EREE, Residual or NUAMR alike) refined 22 k to 71 k cells and left Cd at 0.2647-0.2654. The Cd change of the adaptive meshes (to 0.253-0.255) came from the other 115 k to 260 k cells of the top-5 / 10 % selections, i.e. from broad refinement of the wake box. One cycle with the FVM-only indicators (u'rms, h|ω|/U) also kept Cd at 0.264–0.267.
  • The adaptive meshes show coarse islands at the box edge and a higher average non-orthogonality (7.73-7.77°, against 5.08-6.67° for the uniform meshes). A morphological closing (one-ring dilation then erosion on the octree) of the scattered top-5 % marks fills 69 holes, adds 3 % cells, removes 9 % of the transition polyhedra and lowers the average non-orthogonality from 7.73° to 7.24°. Marks from the floor + Dörfler rule are already compact and barely change.
  • The non-orthogonality problem is in the layers. 97–98 % of the cells above 50° (9,406 for uniform N = 5, 7,726 for gap 3, 5,947 for N = 6 gap 3·2) are prism-layer cells. Only 6–8 % lie at the rear (x > 3.4 m); most lie on the body sides (y = 0.4–1.0 m) and 15–20 % around the wheels. The pattern is the same in all meshes, so it does not come from the AMR.
  • The layer distortion comes from the layer field. The distortion at the roof-to-base edge and at two underbody spots on the y = 0 cut comes from coincident point pairs of the surface mesh (two points 1e-5 m apart): they make the concave radius look like 1e-5 m, set the layer height to 0, and the gradient limit and the count taper spread that into a 20–30 cm cone. The rear lower corner is fed from offset triangles that turn over at the diffuser lip (a real concave radius of 2–3 cm). It is not the second-pass repair.
  • Estimated layers (h1 at y+ 100, total height from the boundary-layer thickness, count from the growth ratio) cut the cells above 50° from 595 to 316 at the rear and from 3,948 to 2,752 in the wheel zones, 26 % overall. The body y+ has an area-weighted mean of 46, with 78 % of the area in 30–100.
  • Layer coverage is still far from the gate. The requested count is reached on 38–64 % of the faces, the thickness ratio is 72–83 % (gates: 98 % and 95 %). The shortfall is the gap budget (7 % of the wall points), the count taper and the gradient limit. Every setting that raises the coverage adds cells above 50° in the wheel arches; the choice is between a quality recipe (max non-orthogonality 65.0°, 55 % of the faces with the full count) and a coverage recipe (70.9°, 64 %).
  • Level transitions: the polyhedral transition cells sit uniformly at 25–30° non-orthogonality. The adaptive mesh has a higher average because the boxes add transitions; its count of cells above 50° (9,410) is about the same as uniform N = 5.

Since then the layer coverage of the main line has risen to 90.9 % (gaps excluded); see the current status on the rheoMesh page.

Next steps (decided on 2026-10-28, status the same day)

content status
(a) per-cell maps of non-orthogonality and skewness on the y = 0 plane done (figures on the rheoMesh page)
(b) fix the layer distortion: smooth the extrusion direction at convex edges and reduce broken stacks partly done. Tried: welding the normals of coincident point pairs (small effect), scaling a turned-over triangle to 0.8 of its valid height instead of halving, no taper on steps of the request itself. Stronger smoothing at convex ridges only lowered the coverage and is not adopted. Next: fans of layers at convex ridges and per-point stops with a short transition
(c) layer count and total height per face from estimates: h1 from y+, H from the boundary-layer thickness, n from the expansion ratio, plus a near-wall error indicator done (rheomesh-layer-est). At N = 5 the core cell size sets the total height, and the error indicator changes almost nothing
(d) remove the predefined refinement boxes: start from a uniform lattice and refine by AMR the regions the flow shows (wake vortex shedding, shear layers) with target-free indicators, keeping 2:1 balance and no coarse islands FVM-only track through the first cycle (table above). The LBM-assisted track restarts from its first cycle after the wall-model fix

Target-functional (adjoint / Cd) refinement is not pursued, because it needs the target quantity to be known in advance.

For physical-time unsteadiness on the same FV mesh, the FVM-only track also has an explicit EDAC solver (equations of Clausen 2013, stdpar). On one GPU it gives a relative error of 1.8 × 10⁻⁵ in the 2-D Taylor–Green decay (n = 256) and, for the cylinder at Re = 100, Cd 1.348 and St 0.1647 (references Cd 1.33–1.35, St 0.164–0.166). Its stability on the DrivAer is being studied.

On 2026-10-29 the main line was frozen as v0.1 and recipe trials were paused for about two weeks; see the development policy on the rheoMesh page.

References

  • H. Jasak, A. D. Gosman: Element residual error estimate for the finite volume method, Computers & Fluids 32, 223-248, 2003.
  • J. R. Clausen: Entropically damped form of artificial compressibility for explicit simulation of incompressible flow, Phys. Rev. E 87, 013309, 2013. doi:10.1103/PhysRevE.87.013309
  • M. Imano, M. Kamata, Y. Sakamoto: Automatic Cartesian grid generation for CFD analysis of wind environment — comparison of error estimation methods in finite volume CFD analysis (part 1), J. Environ. Eng. AIJ 72 (612), 51-57, 2007 (in Japanese). J-STAGE
  • M. Imano, N. Ohnishi, M. Kamata, Y. Sakamoto: Automatic Cartesian grid generation for CFD analysis of wind environment — automatic generation of cost-effective grid using adaptive mesh refinement (part 2), J. Environ. Eng. AIJ 72 (617), 31-38, 2007 (in Japanese). J-STAGE
  • M. Imano, N. Ohnishi, M. Kamata, Y. Sakamoto: Automatic generation of orthogonal grids for CFD analysis of wind environment around buildings — development of a non-uniform type adaptive mesh refinement method (part 3), J. Environ. Eng. AIJ 73 (624), 207-214, 2008 (in Japanese). doi:10.3130/aije.73.207

The AMR literature (Dörfler, Löhner, Spalart, ...) is listed on the AMR literature survey.


  1. Both runs (s): snappyHexMesh layers 46.99 / 41.45, no layers 33.38 / 33.40; snappyHexMeshLike layers 21.70 / 21.46, no layers 5.93 / 5.96; native 47.39 / 49.93. In snappyHexMesh's first layered run blockMesh took 2.85 s (0.41 s in the second). ↩