Balanced Field Length

Balanced Field Length (flight-mechanics/performance/balanced-field-length)

Use when the task is the engine-out field length of a multi-engine transport with a V1 decision-speed balance. This leaf computes the balanced field length: accelerate on all engines to a V1 decision speed, then compare the accelerate-stop distance (brake to a full stop after a reaction time) with the accelerate-go distance (continue on the remaining engines, rotate, and climb over the 35-ft obstacle on the engine-out climb gradient) and find the balanced V1 where the two are equal. It pairs with takeoff-performance (the all-engine ground roll estimate feeds the accelerate legs, but that leaf stops at lift-off with no engine failure) and with oei-climb-gradient (which scores the engine-out climb gradient against the FAR-25.121 minima but integrates no distance; here the gradient is an input). Out of scope: stall speed, lift-off speed, and the all-engine ground roll from wing loading (takeoff-performance); climb gradient estimation and minima comparison (oei-climb-gradient); measured-distance determination from flight test data; and the inverse sizing of thrust or wing loading from a required field length (vehicle-design/conceptual/ constraint-analysis).

Domain quick reference

• Engine-out thrust: T_OEI = T_all * (engine_count - 1) / engine_count, with at least two engines.
• Ground-roll acceleration (constant, no aerodynamic drag or lift relief): a = g0 * (T - mu_roll * W) / W, rolling friction opposing the thrust.
• Braking deceleration magnitude: a_brake = g0 * mu_brake.
• Accelerate-stop distance: ASD(V1) = V1^2 / (2 a_all) + V1 * t_reaction + V1^2 / (2 a_brake).
• Accelerate-go distance: AGD(V1) = V1^2 / (2 a_all) + (V_LOF^2 - V1^2) / (2 a_oei) + V_LOF * t_rotation + h_obs / gradient, the air segment climbing the obstacle on the engine-out gradient.
• Balance quadratic from ASD(V1) = AGD(V1): A V1^2 + B V1 + C = 0 with A = 1 / (2 a_brake) + 1 / (2 a_oei), B = t_reaction, and C = -(V_LOF^2 / (2 a_oei) + V_LOF * t_rotation + h_obs / gradient); A > 0 and C < 0 give one positive root.
• Balanced field length: BFL = ASD(V1_balanced) = AGD(V1_balanced).
• Module constants: g0 = 9.80665 m/s^2, reaction time 1.0 s, rotation time 1.0 s, obstacle height 10.668 m (35 ft, the FAR-25.113 obstacle, paraphrased). SI throughout: forces in N, speeds in m/s.

Workflow

1. Collect the takeoff case: all-engine thrust, engine count, weight, rolling friction, brake friction, lift-off speed, engine-out climb gradient, obstacle height, reaction time, and rotation time (the last three default to 35 ft, 1 s, and 1 s).
2. Split the thrust on the remaining engines with oei_thrust: T_OEI = T_all * (engine_count - 1) / engine_count.
3. Compute the constant accelerations: ground_acceleration for the all-engine thrust and for the engine-out thrust, and braking_deceleration from the brake friction; every call rejects non-physical inputs with ValueError.
4. Trace the accelerate-stop distance curve with accelerate_stop_distance: roll to V1 on all engines, coast for the reaction time, brake to a full stop. ASD(0) = 0 for a decision at rest.
5. Trace the accelerate-go distance curve with accelerate_go_distance: all-engine roll to V1, engine-out roll from V1 to lift-off, rotation at V_LOF, then the small-angle climb over the 35-ft obstacle on the engine-out gradient (obstacle height divided by the gradient).
6. Solve the V1 balance with balanced_v1: the quadratic root of ASD(V1) = AGD(V1); a root inside [0, V_LOF] is the balanced decision speed, and a root outside the bracket raises ValueError so the caller can disclose that no balanced decision exists for the case.
7. Read the balanced field length with balanced_field_length at the balanced V1: the common distance where the accelerate-stop distance equals the accelerate-go distance.
8. Sanity-check the bracket: ASD rises and AGD falls with V1, so the crossing is unique inside [0, V_LOF]; a steeper engine-out climb gradient shortens the accelerate-go distance and lowers the balanced V1, while stronger brakes shorten the accelerate-stop distance and raise the balanced V1.

Worked example

Twin-engine transport, W = 600000 N, total installed thrust 150000 N, V_LOF = 80 m/s, mu_roll = 0.03, mu_brake = 0.45, engine-out climb gradient 0.024, 35-ft obstacle, 1 s reaction and rotation times (scripts/balanced_field_length_logic.py real outputs):

• oei_thrust = 75000 N.
• a_all = 2.15746 m/s^2, a_oei = 0.931632 m/s^2, a_brake = 4.41299 m/s^2; air segment 10.668 / 0.024 = 444.5 m.
• Balanced V1 = 77.2815 m/s, 0.966 of V_LOF.
• ASD(V1) = AGD(V1) = balanced field length = 2138.10 m.
• Bracket: ASD(0) = 0 < AGD(0) = 3959.33 m; ASD(80) = 2288.36 m > AGD(80) = 2007.72 m, so the balanced root is unique inside the bracket.

Pitfalls

• Passing a decision speed at or beyond lift-off as a balance: a V1 past V_LOF is rejected, and balanced_v1 raises when the quadratic root falls outside [0, V_LOF] (no balanced decision exists for that case, for example very weak brakes).
• Mixing the all-engine acceleration into the engine-out leg: after V1 the accelerate-go leg runs on a_oei from the remaining-engine thrust, which is weaker, not on a_all.
• Dropping a segment: the accelerate-stop distance includes the reaction-time coast before braking, and the accelerate-go distance includes the rotation at V_LOF plus the obstacle height over the gradient; each omission shortens the field length.
• Forgetting the friction checks: a thrust at or below mu_roll * W cannot accelerate the aircraft and raises ValueError; brake friction must lie strictly inside (0, 1).

Verification

Deterministic, offline checks (scripts/test_balanced_field_length.py): worked-example anchors above within the stated tolerances; ASD(0) = 0 and the bracket monotonicity ASD(0) < ASD(40) < ASD(80) with AGD(0) > AGD(40) > AGD(80); ASD == AGD at the balanced V1 to machine precision; the minimax property that no other decision speed needs less runway than the balanced field length; sensitivity directions (gradient 0.03 lowers the balanced V1 and the field length, brake friction 0.55 raises the balanced V1 and lowers the field length); ValueError rejection of non-physical inputs (engine_count 1, zero or negative gradient, decision speed beyond lift-off, mu_roll outside [0, 1), mu_brake at 0 or 1, non-positive weight or thrust, negative reaction time); and repeated-call determinism.

Related leaves

• flight-mechanics/performance/takeoff-performance
• flight-mechanics/performance/oei-climb-gradient
• flight-mechanics/performance/landing-performance
• vehicle-design/conceptual/constraint-analysis

Behavior contract (gate 3)

The engine-out field length logic is exercised by the gate 3 contract test: scripts/test_balanced_field_length.py against scripts/balanced_field_length_logic.py (stdlib unittest, offline). Run:

python3 scripts/test_balanced_field_length.py

Compliance

• Standards referenced, not reproduced: FAR-25 is US government work (public domain); the balanced field length method with the V1 decision-speed balance, the 35-ft obstacle, and the engine-out climb are common flight-mechanics methodology, summary-only per standards-map.yaml.
• compliance: STANDARDS-REF, gated: false.