Engine Failure Takeoff Flight Test

Engine Failure Takeoff Flight Test (flight-test-operations/performance/engine-failure-takeoff-flight-test)

Use when the task is the critical-engine (one-engine-inoperative) takeoff flight test reduction: locate the engine failure point in the measured ground run, add the V1 recognition time segment, continue the takeoff to the 35 ft obstacle at the measured engine-out climb rate, and set the decision speed V1 at the balanced field intersection of the stop-distance curve and the continued engine-out takeoff distance curve. This leaf implements the reduction in pure Python, stdlib only. It pairs with flight-test-operations/performance/takeoff-distance- determination for the all-engine runs and with flight-test-operations/ performance/accelerate-stop-distance, whose simplified all-engine rejected-takeoff model explicitly defers the balanced-field V1 to a full engine-out model (this leaf).

Domain quick reference

• Speeds in m/s, accelerations in m/s^2, distances in m. Measured ground speed samples v(t) come from the takeoff run; the engine failure speed VEF, recognition time t_rec, decision speed V1, takeoff safety speed V2 and rotation speed V_R bound the segments.
• Engine failure distance: trapezoid integration of the measured ground speed from brake release to the interpolated crossing of VEF in the samples (engine_failure_distance). For a constant acceleration a the closed form is s_ef = v_ef^2 / (2 a).
• Recognition distance: s_rec = V1 * t_rec, a constant-speed segment at the decision speed during the recognition interval.
• Continued climb to the obstacle: s_climb = V2 * h_target / ROC_oei with h_target = H_TARGET_M = 10.668 m (35 ft) and ROC_oei the measured one-engine-inoperative rate of climb.
• Engine-out takeoff distance chaining (engine_out_takeoff_distance): total = failure leg + s_rec + continued ground segment accelerating V1 to V2 at a_cont, (v2^2 - v1^2) / (2 * a_cont) + s_climb. The TOD curve values used for the balance already embed these legs.
• Balanced-field V1: the speed where the stop-distance curve ASD(V1) equals the continued engine-out takeoff distance curve TOD(V1); balanced_field_v1 finds the lowest-speed segment-linear intersection over the shared speed range. When no crossing exists it returns (None, regime): 'asd-limited' when the engine-out TOD curve lies everywhere at or above the ASD curve (balance above the tested speeds), 'tod-limited' in the reverse case.
• Ordering checks: V1 >= VEF + a_cont * t_rec (v1_min) and V1 <= V_R.
• Field verdict: margin = runway_m - balanced distance; fits when margin >= 0. A negative margin is a real outcome (too short).
• FAR-25 (14 CFR Part 25) frames the takeoff field length and V1 certification-test context; the relations above are standard flight-test methodology, summary-only.

Workflow

1. Reduce the failure leg: with measured speed and time samples, engine_failure_distance(v_samples, t_samples, v_ef) integrates the ground run to the VEF crossing.
2. Add the recognition segment at the decision speed with recognition_distance(v1, t_rec).
3. Close the continued takeoff: continued_climb_distance(v2, roc_oei) for the 35 ft closure, or engine_out_takeoff_distance for the full chained total (failure + recognition + ground acceleration V1 to V2
   • climb).
4. Determine the balanced decision speed: balanced_field_v1 on the ASD and engine-out TOD curves gives (v1, distance), or (None, regime) when the curves do not cross in the tested speed range.
5. Run the ordering checks with v1_ordering_verdict (V1 >= VEF + a_cont * t_rec and V1 <= V_R) and the runway fit with field_length_verdict(runway, distance).
6. Assemble the reduction with engine_failure_takeoff_summary, which reports the regime, balanced V1 and distance, v1_min, recognition distance, ordering verdicts and field verdict in one dict.
7. Confirm the deterministic checks with the contract test.

Worked example

ASD curve at 60-80 m/s: [1350, 1450, 1560, 1680, 1810] m. Engine-out TOD curve: [1620, 1600, 1590, 1605, 1630] m. VEF 58 m/s, recognition 1.0 s, continued acceleration 1.8 m/s^2, V_R 80 m/s, runway 1700 m. Real module outputs:

• balanced_field_v1 returns V1 = 71.43 m/s (crossing between 70 and 75 m/s) at 1594.29 m.
• v1_min = VEF + a_cont * t_rec = 59.8 m/s <= 71.43 (pass, margin 11.63 m/s) and V1 <= V_R (pass, margin 8.57 m/s); ordering pass.
• field_length_verdict: margin = 1700 - 1594.29 = +105.71 m, fits.
• recognition_distance at the balanced V1: 71.43 m.
• engine_failure_takeoff_summary keys: regime, balanced_field_v1_mps, balanced_field_distance_m, v1_min_mps, recognition_distance_m, ordering_verdict, field_verdict.
• continued_climb_distance(80, 6) = 142.24 m to the 35 ft obstacle at a 6 m/s engine-out rate; on a 2 m/s^2 ramp, engine_failure_distance to 25 m/s returns 156.25 m, matching v_ef^2 / (2 a) = 625 / 4.

Pitfalls

• Expecting a balanced V1 when the curves never cross: a TOD curve everywhere above the ASD returns (None, 'asd-limited') and the reverse returns (None, 'tod-limited'), so the balanced-field distance only exists at the crossing (71.43 m/s at 1594.29 m here).
• Quoting V1 without the ordering checks: v1_min = VEF + a_cont * t_rec = 59.8 m/s must sit at or below V1 (margin 11.63 m/s) and V1 at or below V_R (margin 8.57 m/s); a longer recognition time raises v1_min and tightens the ordering.
• Reading the field verdict without the runway: the margin is the runway minus the balanced distance (1700 - 1594.29 = +105.71 m fits), so a longer runway raises the field margin.
• Hand-computing the engine-failure distance instead of the ramp rule: on a linear ramp the distance equals v_ef^2 / (2 a) (156.25 m for 25 m/s at 2 m/s^2), the constant-acceleration identity the contract asserts.
• Feeding non-physical or out-of-order arrays: empty samples, non-positive v_ef, recognition time, rate of climb, obstacle height, or runway length, and descending or non-monotone ASD/TOD arrays all raise ValueError.
• Confusing this leaf with its siblings: accelerate-stop-distance owns the all-engine rejected takeoff without the engine-out asymmetry, and takeoff-distance-determination owns the all-engine distance runs with no VEF token.

Verification

• Confirm balanced_field_v1(SPEEDS, ASD, SPEEDS, TOD) returns about 71.43 m/s at about 1594.3 m and that both curves equal the returned distance at that speed.
• Confirm the ordering verdict passes and the field verdict fits with margin about +106 m against the 1700 m runway.
• Confirm a TOD curve everywhere above the ASD curve returns (None, 'asd-limited') and the reverse returns (None, 'tod-limited').
• Confirm the constant-acceleration identity engine_failure_distance == v_ef^2 / (2 a) on a linear ramp sample.
• Confirm longer recognition time raises v1_min (tighter ordering) and a longer runway raises the field margin.
• Confirm ValueError rejection of empty samples, non-positive v_ef/t_rec/roc/h/runway, and descending or non-monotone arrays.
• Confirm run-to-run determinism and the exact summary key set.
• Run the contract test offline: python3 scripts/test_engine_failure_takeoff_flight_test.py (34 tests).

Related leaves

• flight-test-operations/performance/accelerate-stop-distance: the ASD sibling that defers the balanced-field model (all-engine rejected takeoff with no engine-out asymmetry).
• flight-test-operations/performance/takeoff-distance-determination: the all-engine takeoff distance runs (no VEF token).
• flight-test-operations/envelope/vmc-determination: the asymmetric control boundary (Vmc, critical-engine yaw), not the takeoff distance or V1.

Behavior contract (gate 3)

Run the deterministic contract test (stdlib unittest, offline):

python3 scripts/test_engine_failure_takeoff_flight_test.py

The test covers the trapezoid engine-failure distance and its closed-form identity on a constant-acceleration ramp, the recognition segment, the continued climb to the 35 ft obstacle, the chained engine-out takeoff distance, the balanced-field intersection anchors (71.43 m/s at 1594.3 m), the ASD-limited and TOD-limited regime flags, the ordering checks with their boundaries, the runway field verdict and its margins, the reduction summary key set, determinism, and ValueError rejection of empty, non-positive and non-monotone inputs.

Compliance

• Standards referenced, not reproduced: FAR-25 (14 CFR Part 25) is US government work (public domain) and CS-25 is a free EASA download; the V1 and field-length certification-test context is paraphrased, summary-only per standards-map.yaml (far-25, cs-25).
• compliance: STANDARDS-REF, gated: false.