# Flat Plate Skin Friction Heating > Use when you must estimate the surface skin friction heating on a flat plate or vehicle skin at high Mach: it computes the recovery factor, adiabatic wall temperature, Eckert reference temperature, Sutherland viscosity, local skin friction coefficient and Reynolds-analogy heat transfer coefficient, then the cold-wall heat flux for a laminar or turbulent boundary layer. Produces the non-stagnation heating report with r, T_aw, T_star, Re_star, Cf, h_c and q_cold_wall in SI units for a thermal protection check. Trigger: recovery-factor, adiabatic-wall-temperature, cold-wall-heat-flux, reference-temperature-method, reynolds-analogy-factor, skin-friction-coefficient, turbulent-plate-heating, flat-plate-heating. - Skill: `ashfordeou/flat-plate-skin-friction-heating` (Agent Skill, multi-file: 3 files) - Install (CLI): `npx skillmds@latest add ashfordeou/flat-plate-skin-friction-heating` - Raw SKILL.md: https://api.skillmd.com/api/skills/ashfordeou/flat-plate-skin-friction-heating/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Docs & Writing - License: Apache-2.0 - Author: ashfordeOU (https://skillmd.com/u/ashfordeou) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/ashfordeou/flat-plate-skin-friction-heating --- # Flat Plate Skin Friction Heating (aerodynamics/high-speed/flat-plate-skin-friction-heating) Use when the task is estimating the convective skin friction heating on a flat plate or vehicle skin away from the leading edge at high Mach: recovery factor, adiabatic wall temperature, Eckert reference temperature, Sutherland viscosity, local skin friction coefficient and cold-wall heat flux for laminar or turbulent boundary layers. This leaf implements the classical compressible boundary-layer model in pure Python, stdlib only, with the module constants from the leaf spec (GAMMA = 1.4, R = 287.0, CP = 1005.0, PR = 0.71, MU_REF = 1.716e-5, T_REF = 273.15, SUTH_S = 110.4). It pairs with aerodynamics/high-speed/aerodynamic-heating for the leading-edge counterpart and with the inviscid shock leaves for the flow-field context around the boundary layer. ## Domain quick reference - Recovery factor: laminar r = sqrt(PR) about 0.8426, turbulent r = PR**(1/3) about 0.8921 for air. The factor converts kinetic heating into the driving temperature for heat transfer. - Adiabatic wall temperature: T_aw = T_inf * (1 + r * (GAMMA - 1) / 2 * M**2). This is the wall temperature at which the net convective flux is zero; it is the correct reference for the flux, not T_inf. - Eckert reference temperature: T_star = T_inf * (1 + 0.032 * M**2 + 0.58 * (T_wall / T_inf - 1)), the compressibility-corrected temperature for evaluating the local properties. - Sutherland viscosity: mu = MU_REF * (T / T_REF)**1.5 * (T_REF + SUTH_S) / (T + SUTH_S), Pa s. - Edge velocity: U_e = M * sqrt(GAMMA * R * T_inf). Density at the reference state: rho_star = p_inf / (R * T_star). - Reynolds number at the reference state: Re_star = rho_star * U_e * x / mu_star, with x the running length from the leading edge. - Local skin friction: laminar Cf = 0.664 / sqrt(Re_star); turbulent Cf = 0.0592 / Re_star**0.2 (1/7-power law form). - Heat transfer coefficient, Reynolds-analogy style: h_c = 0.5 * Cf * rho_star * U_e * CP, W/(m2 K). - Cold-wall heat flux: q_cold_wall = h_c * (T_aw - T_wall), W/m2. Positive into a cold wall, negative when the wall is hotter than the adiabatic wall temperature (wall heating). - Units are SI throughout: K, Pa, kg/m3, m/s, W/m2. - NACA-TR-824 frames the classical boundary-layer context; the relations above are standard engineering methodology, summary-only. ## Workflow 1. Fix the flight point: Mach M, static temperature T_inf, static pressure p_inf, the running length x and the regime ("laminar" or "turbulent"). The model takes freestream or local edge conditions. 2. Choose the regime recovery factor with recovery_factor(regime) and confirm r against the PR powers (0.8426 laminar, 0.8921 turbulent). 3. Get the driving temperature: adiabatic_wall_temperature(M, T_inf, regime). At M = 0 this returns T_inf (zero-speed identity). 4. Compute the compressibility-corrected property state: reference_temperature(M, T_inf, T_wall) and sutherland_viscosity(T_star). 5. Evaluate the boundary layer: skin_friction_coefficient(M, T_inf, p_inf, T_wall, x, regime) returns the dict {T_star, rho_star, mu_star, Re_star, Cf} at the reference state. 6. Convert friction to heat transfer with heat_transfer_coefficient(cf, rho_star, u_e) using the Reynolds-analogy factor 0.5. 7. Report the heating: cold_wall_heat_flux(M, T_inf, p_inf, T_wall, x, regime) chains all of the above into {r, T_aw, T_star, Re_star, Cf, h_c, q_cold_wall}. Run it for both regimes when the transition location is unknown and take the envelope. 8. Confirm the deterministic checks with the contract test scripts/test_flat_plate_skin_friction_heating.py. ## Worked example Mach 3 cruise point: M = 3.0, T_inf = 223.0 K, p_inf = 10000.0 Pa, T_wall = 500.0 K (heated wall), x = 0.5 m. - Turbulent: r = 0.89211, T_aw = 581.09 K, T_star = 447.88 K, rho_star = 0.077795 kg/m3, mu_star = 2.4753e-5 Pa s, Re_star = 1.4111e6, Cf = 0.003487, h_c = 122.40 W/(m2 K), q_cold_wall = 9925.7 W/m2. - Laminar at the same point: r = 0.84261, T_aw = 561.23 K, Re_star = 1.4111e6 (identical T_star), Cf = 5.590e-4, h_c = 19.62 W/(m2 K), q_cold_wall = 1201.4 W/m2. - The turbulent flux is about 8.3 times the laminar value at the same Reynolds number, so calling the regime wrong changes the thermal protection answer by an order of magnitude. - At the adiabatic condition T_wall = T_aw = 581.09 K the flux returns to zero; raising the wall above T_aw (for example to 1200 K) makes q_cold_wall negative, which is wall heating back into the flow. ## Verification - Confirm cold_wall_heat_flux(3.0, 223.0, 10000.0, 500.0, 0.5, "turbulent")["q_cold_wall"] = 9925.7 W/m2 and the laminar run gives 1201.4 W/m2, each within 1 percent of the prep-verified anchors. - Confirm recovery_factor("laminar") = 0.84261 and recovery_factor("turbulent") = 0.89211 match sqrt(PR) and PR**(1/3). - Confirm adiabatic_wall_temperature(0.0, T_inf, regime) equals T_inf and that T_star lies between T_inf and T_wall for the heated-wall example. - Confirm sutherland_viscosity(273.15) equals MU_REF within 1e-3 relative. - Confirm the sign flip: T_wall > T_aw gives negative q_cold_wall. - Confirm every non-physical input raises ValueError: M <= 0 or >= 20 (flight functions), T_inf <= 0, p_inf <= 0, x <= 0, T_wall <= 0, and any regime string other than "laminar" or "turbulent". The module admits M = 0 only inside adiabatic_wall_temperature so the zero-speed identity T_aw = T_inf is testable; every function that needs an edge velocity requires 0 < M < 20. - Run the contract test offline: python3 scripts/test_flat_plate_skin_friction_heating.py (34 tests, deterministic). ## Related leaves - aerodynamics/high-speed/aerodynamic-heating: the leading-edge stagnation convective heating counterpart of this surface skin heating model. - aerodynamics/high-speed/hypersonic-flow: the regime map that decides when real-gas and strong-shock effects matter for the edge state. - aerodynamics/high-speed/normal-shock: post-shock conditions that provide the boundary-layer edge state behind a shock. - aerodynamics/high-speed/oblique-shock: the inviscid flow turning that sets the edge Mach number for swept or wedge-type surfaces. - aerodynamics/high-speed/shock-expansion-airfoil: edge conditions along an airfoil surface for panel-by-panel heating runs. ## Pitfalls - Using the stagnation-point correlation for surface locations: the stagnation convective heating correlation peaks at the leading edge and is not valid down the surface; this leaf owns the non-stagnation skin heating with local edge conditions and running length x. - Driving the flux with T_inf instead of T_aw: at M = 3 the recovery temperature is 581.09 K against 223.0 K static, so a flux computed from T_inf badly understates the driving potential (T_aw - T_wall). - Calling the regime wrong: the turbulent flux is about 8.3 times the laminar value at the same Reynolds number in the worked example, so an assumed transition point changes the thermal protection margin by an order of magnitude. - Evaluating properties at freestream instead of reference conditions: at M = 3 even a cold wall gives T_star above T_inf (244.9 K at a 150 K wall), and density computed from T_inf overstates rho_star and the Reynolds number, shifting Cf. - Mixing the recovery-factor powers: laminar uses sqrt(PR) (0.8426) and turbulent uses PR**(1/3) (0.8921); swapping them changes T_aw by almost 20 K in the example. - Reading q_cold_wall as the structural heat load: it assumes the wall holds at T_wall; conduction through the skin and re-radiation to the surroundings rebalance it in a real thermal protection check. ## Behavior contract (gate 3) Run the deterministic contract test (stdlib unittest, offline): python3 scripts/test_flat_plate_skin_friction_heating.py The test covers the module constants, the recovery factor for both regimes against the PR powers and its ValueError on bad regime strings, the adiabatic wall temperature anchors and the M = 0 identity, the Eckert reference temperature anchor with the between-static-and-wall bound, the Sutherland law at the reference temperature, the worked example anchors within 1 percent (Re_star 1.41e6, Cf 0.003487, q_cold_wall 9926 W/m2 turbulent; q_cold_wall 1201 W/m2 and T_aw 561 K laminar), the laminar Blasius closed form, the turbulent-over-laminar Cf order, the Reynolds-number scaling with length, the wall-heating sign flip, the zero-flux adiabatic wall round trip, the Reynolds-analogy heat transfer coefficient, determinism of the full chain, and ValueError rejection of every non-physical input class. ## Compliance - Standards referenced, not reproduced: NACA-TR-824 provides the classical boundary-layer context for the skin friction and recovery factor correlations; the relations above are standard engineering methodology, summary-only per standards-map.yaml. - compliance: STANDARDS-REF, gated: false.