Domain: aerodynamics, wind and rotor aero

Two modules share this document because they share the wind field: modules/aerodynamics/ (forces on links) and modules/rotor_aero/ (propellers and rotors).

1. Scope and release

Drag and lift per link, wind and gusts, sampled CFD fields, and rotor thrust and torque with ground effect. True CFD does not run in the loop (CLAUDE.md §11.7). Release: v0.4 with drones.

2. Models per fidelity level

Aerodynamics (fidelity):

Level

Content

drag

Per link with AeroAPI: `F = −½·ρ·

drag_plus_field

Same forces, but the air velocity at each link is sampled from a NanoVDB vector grid (weather:windField, baked from OpenFOAM) where one exists, and from the mean-wind model elsewhere

lbm

A GPU lattice Boltzmann solver (D3Q19) in a moving box around the robot provides the local velocity field. Small volumes only. Experimental; after v0.4

Turbulence: Dryden or von Kármán spectra shaped by forming filters driven by white noise (counter-based RNG, so deterministic). Parameters follow the low-altitude model of MIL-HDBK-1797 (scale lengths and intensities as functions of height and mean wind at 6 m). The handbook must be cited in code with the equation numbers used.

Air density from the environment: ρ = p / (R_specific·T) with humidity correction; R_specific = 287.05 J·kg⁻¹·K⁻¹ for dry air.

Rotor aero (fidelity):

Level

Content

coefficients

T = CT·ρ·n²·D⁴, Q = CP·ρ·n²·D⁵ / (2π) with n in rev/s; first-order inflow lag; thrust and drag variation with advance ratio through a linear correction; blade-flapping moment as a simple coefficient

bem

Blade-element momentum with the blade table (chord, twist, aerofoil polars); solves induced velocity per annulus; captures forward flight and descent better

2.1 Blade-element momentum (bem)

The bem fidelity computes a propeller’s loads from what it is: its blades’ chord and twist along the radius, their sections’ lift and drag, the number of blades and the hand, read from a propeller file (formats.md §3.3.1) named by the rotor’s aero:rotor:propeller.

  • Per annulus (40 along the blade), the axial induced velocity w and the swirl w_t make the blade-element forces equal the momentum change of the air through the annulus: dT = 4πrρF·|V + w|·w, dQ = 4πr²ρF·|V + w|·w_t, with Prandtl’s tip-loss factor F. The axial balance is solved by bracketed root finding (Illinois), the swirl by a few fixed-point passes. In descent through the rotor’s own wake (the vortex-ring state, 0 < V_d/v_h < 2 with V_d the descent speed and v_h the induced velocity with no axial flow) momentum theory has no valid solution. There each annulus takes its no-axial-flow induced velocity scaled by the empirical quartic ṽ/v_h = 1 + 1.125x − 1.372x² + 1.718x³ − 0.655x⁴, x = V_d/v_h, never under 1, as NeuroBEM does (Bauersfeld et al. 2021, RSS, eqs. 18–19, after Hoffmann et al. 2007), and the result is flagged (vortexRing). The thrust joins hover’s at the state’s start (within 0.1%) and comes within 10% of hover’s thrust of the windmill-brake state’s at its end (a step of 497 N to 554 N for a 626 N hover); at a fixed speed it rises about 5% at x = 1 and falls about 20% under hover’s near x = 2 (test_bem, NACA 5868 propeller). Before 2026-11-03 the annulus took no induced velocity there, so a rotor sinking into its own wake made far too much thrust.

  • Sections over the full circle of angles of attack: linear lift with the Prandtl–Glauert factor when the speed of sound is given, a parabolic drag polar, a blend over 8° past stall into a flat plate (normal force 2·sin α), which also covers reversed flow. So a propeller turning the wrong way (its hand against the motor’s direction) or mounted back to front gives what a real one gives: little thrust for much power.

  • Hand and mount. The rotor’s aero:rotor:direction is how the motor turns it, seen from the front; the file’s hand is how the propeller must turn to make thrust; aero:rotor:mount is puller (thrust along the joint axis, which points from the motor to the propeller) or pusher (against it). The loader warns when hand and direction disagree.

  • Cost. Loads scale exactly with ρ·(Ω²R² + V²) in incompressible flow, so each propeller is solved once at load over the full circle of inflow angles θ = atan2(V, ΩR) (0.25° steps; with a speed of sound, also over tip Mach 0 to 0.9 in 0.1 steps, rows in parallel threads) and the step interpolates. Deterministic, and about 0.3 s per propeller at load.

  • Folding blades (a file’s folding: section: hinge radius, blade mass, stop angle), at either fidelity: each blade’s angle on its hinge is quasi-static, where the moments of its thrust (at the BEM thrust-weighted radius; 0.75 R at coefficients) and its weight about the hinge balance the centrifugal moment Ω²·sin β·(r_h·S1 + cos β·S2) (S1, S2 the blade’s mass moments about the hinge, mass along the blade as chord²·thickness). Stopped, the blades hang folded against their stop; spinning up they open, then cone a few degrees forward. Thrust and torque are the open propeller’s times cos β; rotor/<j>/blade_angle drives the drawn blades. Quasi-static is right when the blade’s flapping frequency (about Ω) is far above the vehicle’s; hinge friction and the blades’ own dynamics at spin-up are not modelled.

  • Edgewise flow and wind. The hub’s velocity through the air (its own, less env/wind/velocity from the aerodynamics domain when that is in the run) splits into the axial speed and the edgewise speed V_e across the disc. Edgewise, each blade element meets ω·r + V_e·sin ψ at azimuth ψ (its radial share left out, the independence principle), the annulus’ induced velocity is uniform round it with Glauert’s mass flow √(V_e² + (V + w)²), and the loads are averaged over 12 azimuths: the change of thrust (translational lift), the in-plane H-force along the edgewise air, and the hub moment of the advancing blade’s extra lift (a cw propeller’s the other way, so counter-rotating pairs cancel it). Tabulated at load over the inflow angle (1°) and the edgewise angle atan(V_e/√(Ω²R² + V_a²)) (0–40° in 5° steps), normalised by V_e/U0 (in-plane loads) and (V_e/U0)² (changes of thrust and torque), in parallel threads; about 1 s per propeller.

  • Limits. No wake skew (the inflow’s fore-aft gradient in forward flight, which gives a pitching moment), no blade flapping of rigid propellers beyond the hub moment, no stall delay on rotating blades (so thrust near the static condition of a highly pitched propeller is under-predicted; §7.1), no Reynolds-number effects beyond what the file’s section data are for.

Ground effect: Cheeseman–Bennett correction T/T∞ = 1 / (1 − (R / 4z)²) for z/R > 0.25, clamped below that. Height z is found by a downward ray cast against collision geometry.

Ceiling effect (with ground_effect, both fidelities): a ray up each rotor’s thrust axis finds the nearest fixed box of the scenery (a bridge deck, a ceiling) at distance D. Hsiao and Chirarattananon (2019, IEEE/ASME Trans. Mechatronics, arXiv:1905.04632) balance momentum under a flat ceiling: ½u² − u − α0·δ²/16 = 0, u = v∞/v_i, δ = R/D, so γ = u/2 = ½ + ½·√(1 + α0·δ²/8), and the power for a thrust is T^(3/2)/(γ·√(2ρA)). At the same power the thrust is γ^(2/3) times the free thrust: +11% at half a radius, +3% at one radius, under 1% beyond two. α0 = 1.6 is their fit for a single 23 mm propeller (TODO(verify) for larger ones; their 50 mm propeller also needed a recirculation term); δ is held at 20, the edge of their data, and beyond 6 R the effect is left out (test_rotor_aero).

3. Signals

The rotors’ wakes (downwash, outwash, rotor/{j}/air_velocity, rotor/{j}/thrust_axis) are in rotor_aero.md.

// modules/aerodynamics — declare()
for (auto& a : world.instancesOf("AeroAPI_1")) {
    auto b = bodyOf(a);
    d.input ({.name = fmt("body/{}/pose", b),  .type = SignalType::Pose,   .unit = units::m,       .feedback = true});
    d.input ({.name = fmt("body/{}/twist", b), .type = SignalType::Wrench, .unit = units::m_per_s, .feedback = true});
    d.output({.name = fmt("body/{}/aero_wrench", b), .type = SignalType::Wrench, .unit = units::N, .frame = "world_local"});
    d.output({.name = fmt("body/{}/airspeed", b),    .type = SignalType::Scalar, .unit = units::m_per_s});
}
d.input ({.name = "env/wind/mean",           .type = SignalType::Vec3,    .unit = units::m_per_s});   // weather
d.input ({.name = "env/wind/velocity_field", .type = SignalType::Field3D, .unit = units::m_per_s, .optional = true});
d.input ({.name = "env/air_density",         .type = SignalType::Scalar,  .unit = units::kg_per_m3});
d.output({.name = "env/wind/gust",           .type = SignalType::Vec3,    .unit = units::m_per_s});   // turbulence at the robot
d.output({.name = "env/wind/velocity",       .type = SignalType::Vec3,    .unit = units::m_per_s});   // mean + gust: the air at the robot

// modules/rotor_aero — declare()
for (auto& r : world.instancesOf("RotorAPI_1")) {
    auto j = jointOf(r);  auto b = hubBodyOf(r);
    d.input ({.name = fmt("joint/{}/velocity", j),  .type = SignalType::Scalar, .unit = units::rad_per_s, .feedback = true});
    d.input ({.name = fmt("body/{}/pose", b),       .type = SignalType::Pose,   .unit = units::m,         .feedback = true});
    d.input ({.name = fmt("body/{}/twist", b),      .type = SignalType::Wrench, .unit = units::m_per_s,   .feedback = true});
    d.output({.name = fmt("rotor/{}/thrust", j),    .type = SignalType::Scalar, .unit = units::N});
    d.output({.name = fmt("rotor/{}/aero_torque", j), .type = SignalType::Scalar, .unit = units::N_m});
    d.output({.name = fmt("rotor/{}/wrench", j),    .type = SignalType::Wrench, .unit = units::N, .frame = "world_local"});
    d.output({.name = fmt("rotor/{}/induced_velocity", j), .type = SignalType::Scalar, .unit = units::m_per_s});
}
d.input({.name = "env/air_density", .type = SignalType::Scalar, .unit = units::kg_per_m3});
d.input({.name = "env/wind/velocity", .type = SignalType::Vec3, .unit = units::m_per_s, .feedback = true});  // as built: when config "wind" says the aerodynamics domain runs

Several modules produce wrenches on the same body (aero, rotor, hydro). The single-writer rule forbids them all writing body/{b}/external_wrench. A small core module, wrench_sum, reads every */wrench signal declared for a body and writes body/{b}/external_wrench. It is always loaded and has no substitute. The air’s torque on a propeller (rotor/{j}/aero_torque, about the joint axis) is in the same wrench, on the propeller’s link: the air acts on the propeller alone, so the frame feels only the motor’s reaction, which is how a multirotor yaws. (Until 2026-11-04 it went to joint/{j}/load_torque, a joint torque whose reaction also reached the frame and cancelled the motors’ at steady speed: a held yaw rate then drove one pair of rotors nearly to a stop; Multicopter.TakesOffByHandWithEveryStickAtOnce flies the case.)

3.1 The weather on a drone

When the weather runs (the site’s temperature, pressure and humidity are given), three things reach a multirotor, all through signals:

  • Air density. rotor_aero, the aerodynamics domain and the built-in multicopter controller read the weather’s env/air_density (moist air from temperature, pressure and humidity) every step instead of the fixed air_density (config weather_air, set by the server when the built-in weather or its clear substitute runs). Thrust and torque scale with it, so a rotor turns faster in hot, thin air: ω ∝ ρ^−½ at the same thrust. The controller scales its mixer by the same density, which is what a flight controller’s hover-thrust estimate ends up doing (an ideal one: no estimation lag). Measured on the sample quadcopter hovering 2 m up: 5690 rpm at 40 °C and 950 hPa (1.048 kg/m³), 4990 rpm at −10 °C and 1030 hPa (1.362 kg/m³), the ratio 1.140 being √(1.362/1.048).

  • Rain and snow. env/rain_rate and env/snow_rate push every AeroAPI_1 link with the momentum of the drops that stop on it (impactForce, Aerodynamics.hpp: Marshall and Palmer drop sizes, the fall speed of Atlas et al. 1973, inelastic impact as Haines and Luers 1983). It is small, as it is in the air: 25 mm/h on the sample’s 0.09 m² top is 3.7 mN against its 20 N weight; flying at 10 m/s through it adds a few mN of drag. Water lying on the frame, rain on the propellers’ lift and icing are not modelled.

  • Wind. As before: the mean wind, Dryden gusts and the weather’s wind grid (§2).

The viewer draws the same rain and snow in the realistic view: drops falling at the same speed through the world and carried by the run’s wind (viewer.md §4.1).

4. Step size

Aerodynamics: default 1 ms for drones (same as physics), 10 ms for ground vehicles. Rotor aero: 1 ms; bem may need the rotor module at 0.5 ms for small fast propellers.

5. Substitutes and contract

Aerodynamics contract: body/{b}/aero_wrench, body/{b}/airspeed, env/wind/gust, env/wind/velocity. Rotor contract: rotor/{j}/wrench, rotor/{j}/aero_torque.

Domain

Token

Kind

Behaviour

aerodynamics

zero

constant

Zero wrench; airspeed = body speed; gust = 0

aerodynamics

replay

replay

From MCAP

rotor_aero

ideal

ideal

T = k·ω² with k from thrustCoeff at sea-level density; no inflow dynamics, no ground effect

rotor_aero

replay

replay

From MCAP

A drone cannot fly with rotor aero replaced by zero, so rotor_aero has no zero preset. The profile validator rejects it with that explanation.

6. Placement

Feature

Tier 0

Tier 1

Tier 2

Drag, turbulence, coefficients, BEM

CPU

CPU

CPU

Field sampling for a few links

CPU NanoVDB

CPU NanoVDB

CPU NanoVDB

Field sampling for many environments

CPU

GPU kernel gpu/kernels/fields/sample_vec.slang

same

LBM

unsupported

≤ 64³ cells

supported

7. Validation

Test

Reference

Tolerance

Terminal velocity of a sphere and a plate

closed form

0.5 %

Turbulence spectra

analytic Dryden / von Kármán power spectral densities

within the 95 % confidence band of the periodogram

Static thrust and torque vs speed

published propeller test data (candidate: the UIUC propeller database; check its terms of use before redistributing any data)

5 % with coefficients taken from the same dataset

bem against measured propellers

NACA Report 640 (1938, public domain): propeller 5868-9, two blades, Clark Y, at 15° and 25°; §7.1

CT within 8 %, CP within 6 % (or 0.003) over the attached-flow range

bem against momentum theory

ideal rotor (many blades, ideal twist, no drag): uniform inflow, figure of merit 1

3–4 %

bem edgewise H-force

classical rotor theory, C_H = σ·c_d0·μ/4 (Johnson 1980 §5.4; Leishman 2006 §3.4), blades that only drag, μ = 0.1

1 %

bem in wind

moving through still air equals standing still in the wind; the sample quadcopter holds its spot in 8 m/s with gusts (quad_x500_gusty.yaml with fidelity: bem)

1e-12; within 0.1 m

Ground effect

Cheeseman–Bennett curve and published small-rotor ground-effect measurements

10 % for z/R in 0.5–3

Rain’s fall speed

Atlas et al. 1973’s v(D) against Gunn and Kinzer 1949’s measured drops (1–4 mm); its mass-weighted mean over Marshall–Palmer drops, closed form against integration

0.15 m/s; 1e-3 m/s

Water in falling rain

Marshall and Palmer 1948, W = 0.089·R^0.84 g/m³ (1–100 mm/h); ours keeps the given rate at Atlas’s speed, theirs carries more

within 20 %, lower (11–17 %)

Rain’s push, weather’s air density

the momentum flux and drag by formula, through the module

1e-9 N

Field sampling

analytic field baked to VDB

interpolation error bound from grid spacing

Hover power and step response of the sample quadcopter

flight log of a comparable real vehicle (to be sourced; Q16)

reported, with tolerance set from data spread

7.1 The NACA Report 640 comparison

test_bem’s NacaReport640 runs propeller 5868-9 (10 ft, two blades, Clark Y; geometry in assets/propellers/naca_5868-9.prop.yaml) and compares CT and CP with the report’s measurements. Geometry and measurements were read off the report’s charts (figures 2, 6 and 8) with the grid lines as reference: chord to about ±1.5 %, blade angle ±0.3°, CT and CP to about ±0.001. Section data are the Clark Y’s from NACA Report 502 (lift slope, zero-lift angle, minimum drag, maximum lift), scaled per station for thickness as the file explains; nothing was fitted to the propeller data.

Blade angle

Range

CT

CP

Thrust vanishes

15°

J = 0.3–0.7

within 2–4 %

within 2–5 % (7 % at J = 0.2)

J = 0.82, as measured

25°

J = 0.5–1.1

within 0–7 %

within 0–5 %

J = 1.29, as measured

Below J ≈ 0.5 at 25° the inner blade stalls. The real propeller keeps its thrust (CT 0.106 at J = 0.3 against 0.087 computed) and absorbs more power, as rotating blades delay stall; the model has no stall-delay correction yet, so that range is not part of the test.

8. Status (v0.4)

lagrange_rotor_aero (modules/rotor_aero/): RotorAero at the coefficients fidelity and its ideal substitute (RotorAero(true)), over the RotorAPI_1 joints of schemas/aero.

  • The air density is a site parameter with no default (rotor_aero.air_density, kg/m³), as the ambient temperature is for thermal; the rotors refuse to start without it.

  • Thrust acts along the joint axis on the rotor’s link, at the link’s origin; the wrench goes to body/<link>/wrench/rotor and WrenchSum adds it to the link’s external_wrench. The air’s shaft torque, opposing the rotation, is in that wrench too, about the joint axis (not the joint’s load_torque, which stays zero), so the frame gets only the motor’s reaction.

  • Inflow lag: first order with config inflow_time_constant (s), exact over the step; 0 (no lag) unless set, because a published time constant for the sample propeller is not in hand.

  • Ground effect: Cheeseman–Bennett with the height above the world’s ground plane only (scenery needs scene queries as a core service: the lidar’s caster is in the sensors module, which rotor_aero may not use, invariant 1). Below z = 0.5 R the factor is held at its value there: the design’s clamp at 0.25 R is where the formula diverges.

  • bem (§2.1): blade-element momentum on the propeller file’s geometry, with hand and mount; the server draws such rotors as their blades (rotor_aero::addPropellerBlades, NACA four- digit sections from the file’s thickness and drawing camber); checked against NACA Report 640 (§7.1). The built-in controller and the autopilot bridges’ ESCs turn a pusher’s motor the right way about its joint axis.

  • Edgewise flow and wind at the rotors at bem (§2.1): in 8 m/s with gusts the sample quadcopter holds its spot within 9 cm and 6 cm of height, at 175 W against 193 W in still air (translational lift).

  • Not yet: advance-ratio corrections at the coefficients fidelity, wake skew and flapping.

lagrange_aerodynamics (modules/aerodynamics/): AeroDrag at the drag fidelity over AeroAPI_1 links: per-axis drag at the centre of pressure and angular damping against the air, which is the mean wind of a logarithmic profile plus Dryden turbulence (MIL-F-8785C low altitude, its forming filters integrated exactly over the step). Until the weather domain gives the site’s wind (v0.5), the wind is the aerodynamics domain’s config: wind_speed at wind_reference_height, wind_from, the terrain’s roughness_length and turbulence, all without defaults; the air density as for the rotors. Not yet: lift tables, the gust in the rotors’ inflow. (NanoVDB wind grids drive link drag since v0.5: Aerodynamics.InsideAWindGridTheGridIsTheWind.)

§7 check

Status

Test

Terminal velocity

met, sphere within 0.5 %

test_aerodynamics

Turbulence spectra

variances of the three components within 5 % of σ² over 4000 correlation times, longitudinal autocorrelation within 0.03 of e^(−τV/L); the periodogram band test is owed

test_aerodynamics

Static thrust and torque

closed form met exactly; published propeller data owed (with the sample quadcopter’s propeller)

test_rotor_aero

Ground effect

Cheeseman–Bennett met exactly for z/R 0.5 to 3; published small-rotor measurements owed

test_rotor_aero

10. Wind tunnel (fidelity lbm, offline)

lagrange tunnel puts a robot’s collision shapes in a uniform grid and runs air past them: D3Q19 lattice Boltzmann, BGK with a Smagorinsky eddy viscosity (Hou et al. 1996), half-way bounce-back, forces by momentum exchange, inlet at equilibrium, zero-gradient outlet, periodic sides, and with --ground a rolling road under the lowest point (bounce-back off a moving wall, Ladd 1994), as a car is tested. The CPU path, threaded by z slabs, is the bit-reproducible reference (invariant 7); on a real GPU gpu/kernels/fields/lbm.slang steps the same update in float, about 500 million cell updates a second on an RTX 4060 against about 60 on the CPU, loads and means sampled every 25 steps. On a software device or --cpu it stays on the CPU. Tier 2 and 1 run the kernel; Tier 0 the reference. Not yet: a moving box around a robot in a run, a wall model, local refinement.

What it is checked against (test_lbm): the exact decay of a shear wave within 1 %; a sphere at Re 20 and 50 on 10 cells across in a box of 40, 25 % over Schiller and Naumann, from blockage and the staircase surface (DISABLED_ASpheresDragComesCloserWithAFinerGrid for a finer grid); a plate and a cube face-on at high Reynolds number, 0.97 and 1.03 against Hoerner’s 1.17 and 1.05. At high Reynolds numbers with no wall model, agreement on bluff bodies comes from their separating at sharp edges, and a streamlined body would not be right. No measured data of a robot exists (the project has none).

The flow world is plain meshes in bands of a colour, one prim per band named after its range, so it needs no protocol change: the viewport reads its colour scales from those names (FlowLegend.cpp).

The CPU path holds a symmetric body’s flow exactly symmetric, in which a wake may not shed at all; the GPU’s rounding breaks the symmetry and it sheds, as a real wake does, so the two can differ by more than either’s numbers suggest (a pod on 150,000 cells: 2.11 steady on the CPU, 2.2 to 2.5 shedding on the GPU). dragSpread says how much the coefficient moved between windows, and --mean-passes averages longer.

--frames N writes about N PNG files while averaging, so the wake is seen moving: speed in a slice along the body over pressure in a slice from above, scales in frames/legend.json; --frame-spin draws the air’s spin instead. flow.nvdb as --weather wind_field= reaches a run: the sample quadcopter in the sedan’s flow drifted 8 m in 10 s and tilted, where it held still without it (one run by hand, 2026-11-02).

Known defect, seen in these frames: a checkerboard of about 1 to 2 % of the wind speed upstream of the body that does not decay over a run (sedan, 25 m/s). An empty tunnel does not have it, and starting the wind gradually does not change it, so it comes from the body, not the start. Tried by hand on 2026-11-02, none adopted:

Change

Checkerboard

Cube (1.05)

Plate (1.17)

None

44.8

1.03

0.97

Regularized collision (Latt & Chopard 2006)

not measured

1.44

0.85, test fails

Sponge, thin, outlet only

44.5 to 46.2

1.03

0.97

Sponge, both ends, 0.3

24.0

1.28

1.00

Sponge plus viscosity floor 0.005

6.7

1.69

1.11

Checkerboard is the mean jump of red minus blue between neighbouring cells of a frame, out of 255, on the sedan at 300k cells on the CPU. Damping removes it, and the more it does the further the cube moves from its measurement, so the cube’s good number on the coarse grid may rest partly on the undamped flow. Its effect on forces is not known. Sedan forces from those trials are left out: they were measured with --frames, which then kept only part of each window’s force (fixed, FramesDoNotChangeTheForce).

--study runs the air on a quarter, a half and all the cells and says whether Cd and Cl stopped changing (5 %, a rule of thumb). The sample sedan and the Lexus collide as one box each, so what the tunnel sees is a box and a Cd above 1 says nothing about a car; give it a car’s shape to study a car.

--ground once put the road 2 % of the body below it, under a cell on these grids, so no air passed beneath and an Ahmed body read Cd 9.5 (0.78 in free air). --clearance M now sets the gap, never under two cells (AirPassesBetweenABodyAndTheRoad); forces over a road from before that are void.

Every Ahmed body number in this section used a model with sharp side edges on its nose and is void; see cfd.md §6 for the corrected ones.

The Ahmed body (Ahmed et al. 1984; L 1.044, W 0.389, H 0.288 m, 40 m/s, 50 mm over a moving road, one convex hull with no stilts) is the reference this tool does not yet meet. One run on the GPU, 0.5M, 1M, 2M cells; the gap is 2.2 cells on the finest and widened to two cells on the others:

Slant

Cd

Cl

Measured Cd

25°

2.30, 2.06, 1.12

-0.37, -0.29, 0.93

0.298 (Strachan et al. 2007, quoted in arXiv 2001.11074)

35°

2.28, 2.08, 1.14

-0.33, -0.24, 0.91

not verified

NOT SETTLED, and at the finest grid nearly four times the measurement.

Finer, by hand with the same gap, GPU, one run each: 25° at 4M, 8M, 16M cells gives Cd 1.36, 1.31, 1.17; 35° at 4M, 8M gives 1.34, 1.33 (16M did not finish in the time given). So refining alone does not reach the measurement within what this machine holds (16M took 22 minutes and 5.9 GB of host memory).

Part of the excess is wall friction. A plate 1.044 x 0.389 x 0.05 m along a 40 m/s wind in free air, removing one dynamic pressure on its end area, gives a friction coefficient of 0.037 at 1M cells and 0.014 at 4M, against about 0.0037 for a turbulent flat plate at this Reynolds number (Schlichting’s 0.455 / (log10 Re)^2.58). Half-way bounce-back is a no-slip wall with no wall model, far from y+ of 1. On the Ahmed body’s 12.6 wetted areas per frontal area, 0.014 alone is a Cd of about 0.18, so it explains some of the excess and not all.

A wall model was tried and not adopted (2026-11-02, CPU, by hand): the bounce-back wall moved tangentially at the speed that leaves the log law’s friction (von Karman 0.41, E 9.8), the normal taken from a cell’s face neighbours. The aligned plate at 0.5M cells fell to 0.013, still 3.6 times the flat plate’s. The cube fell from 1.03 to 0.69 (measured 1.05), the bluff plate from 0.97 to 0.88 (1.17), and the Ahmed body at 0.5M cells went from Cd 1.24 to -8.25: on a slanted or curved staircase of cells the moving walls appear to push the air, since the faces do not match the normal used. A model that works there needs each link’s real wall distance and normal, which the voxel grid does not hold today. The two slants do not differ, so the drag crisis between them is not resolved. For a streamlined body use this tunnel for where the air goes and how shapes rank at most, not for a drag number.