test_rocket_and_gse.py

Go to the documentation of this file.

"""LE4 with its ground support drawn: a Rocket page and a GSE page, joined at
paired disconnects (``fixtures/le4_rocket_and_gse.json``, the team's drawing of
2026-10-07).
 
Read page-blind, the cart was more vehicle: its fuel transfer tank took the
tanker load alongside the flight tank, its K-bottles started empty, its hand
vents were open for good, its dome-control line was plumbed into the press
manifold, and only the dome regulator had a knob. Each check here is one of
those, against what the stand does.
"""
 
from __future__ import annotations
 
import json
from dataclasses import replace
from pathlib import Path
from typing import Any
 
import pytest
 
from feedtwin.pid import build_network, read_diagram
 
HERE = Path(__file__).resolve().parent
DRAWING = HERE / "fixtures" / "le4_rocket_and_gse.json"
STAR = HERE.parents[2]
ENGINE = STAR / "EngineDesign" / "configs" / "ethalox_6800N.yaml"
CEA = STAR / "EngineDesign" / "output" / "cache" / "cea_cache_LOX_Ethanol_3D.npz"
TABLES = STAR / "feed-twin" / "backend" / "statemachines"
 
 
def _payload() -> Any:
    return json.loads(DRAWING.read_text())
 
 
def _ids() -> dict[str, str]:
    return {n["data"]["label"]: n["id"] for n in _payload()["nodes"]}
 
 
@pytest.fixture(scope="module")
def built() -> Any:
    return build_network(read_diagram(_payload(), name="LE4 (6)"))
 
 
def test_the_vehicle_is_what_is_joined_to_the_engine(built: Any) -> None:
    ids = _ids()
    assert built.vehicle is not None
    for label in ("COPV", "Eth-Tank", "LOX-Tank", "DPR_HP", "QD-FFB"):
        assert ids[label] in built.vehicle, label
    for label in ("Fuel Transfer Tank", "6K-GN2", "PR-1", "QD-FFA", "HPC_SOL"):
        assert ids[label] not in built.vehicle, label
 
 
def test_the_transfer_tank_supplies_the_flight_fuel_tank(built: Any) -> None:
    ids = _ids()
    assert built.supplies == {ids["Fuel Transfer Tank"]: frozenset({ids["Eth-Tank"]})}
 
 
def test_every_hand_valve_rests_shut(built: Any) -> None:
    """Vents, bleeds and inline isolation alike: shut until a hand opens it."""
    ids = _ids()
    for valve in ("FV-MAN", "FF-MAN-Vent", "DR-MV", "HP-Down-MAN", "FF-MAN-Output"):
        assert ids[valve] in built.hand_valves
        assert built.rest[ids[valve]] == 0.0, valve
 
 
def test_a_hand_valve_drawn_normally_open_rests_open() -> None:
    payload = _payload()
    for node in payload["nodes"]:
        if node["data"]["label"] == "FF-MAN-Output":
            node["data"].setdefault("options", {})["normalPosition"] = "open"
    built = build_network(read_diagram(payload, name="LE4 (6)"))
    assert built.rest[_ids()["FF-MAN-Output"]] == 1.0
 
 
def test_a_motorised_valve_is_a_commanded_valve(built: Any) -> None:
    ids = _ids()
    mov = ids["OF-MOT-Dump"]
    assert mov in built.network.branches
    assert built.actuators[mov] == "OF-MOT-Dump.command"
    assert mov not in built.hand_valves
 
 
def test_the_dome_line_loads_the_dome_and_carries_no_feed(built: Any) -> None:
    """DR-REG-G reaches DPR_HP's dome through DR-CTRL-G, the mated DR QDs and
    DR-CTRL-R. It is the loader, and nothing joins the dome line to the
    regulator's body."""
    ids = _ids()
    assert ids["DR-REG-G"] in built.dome_loaders
    assert built.dome_loaders[ids["DR-REG-G"]].signal == "DPR_HP.dome"
    body = {f"{ids['DPR_HP']}.in", f"{ids['DPR_HP']}.out"}
    dome_side = built.node_of.get(ids["DR-CTRL-R"])
    for branch in built.network.branches.values():
        if branch.id == ids["DPR_HP"]:
            continue
        ends = {branch.upstream, branch.downstream}
        assert not (ends & body and dome_side in ends), branch.id
 
 
def _model() -> Any:
    from feedtwin.session import assemble_model
 
    return assemble_model(read_diagram(_payload(), name="LE4 (6)"), diagram_id="le4")
 
 
def test_every_hand_loaded_regulator_gets_a_knob() -> None:
    from feedtwin.session.hookup import CHARGE, DOME, suggest
 
    ids = _ids()
    knobs = {k.id: k for k in suggest(_model(), 500.0, 4500.0).knobs}
    assert knobs[DOME].regulators == (ids["DR-REG-G"],)
    assert knobs[CHARGE].regulators == (ids["PR-1"],)
    assert knobs[CHARGE].label == "COPV fill (PR-1)"
    # DR-REG-G and PR-1 are blank; the dome they load and the bottle they fill
    # are not (test_blank_loader_and_fill_start_at_what_they_feed).
    assert knobs[DOME].psig == pytest.approx(535.0)
    assert knobs[CHARGE].psig == pytest.approx(4000.0)
    assert knobs[ids["LP-PR"]].regulators == (ids["LP-PR"],)
 
 
def test_blank_loader_and_fill_start_at_what_they_feed() -> None:
    """LE4 (6) draws DPR_HP's dome at 535 and the COPV at 4000, and leaves its
    dome loader (DR-REG-G) and COPV fill (PR-1) blank. The knobs start at those:
    a loader's job is the dome it loads, a fill's the charge it fills to. They
    started at the session's 500 and 4,500, so the cockpit primed 35 psi under
    Layer X on the same drawing and read its COPV amber at its own charge.
    Blank all the way down, they still start at the session's numbers."""
    from feedtwin.session import assemble_model
    from feedtwin.session.hookup import CHARGE, DOME, knob_starts, regulators, suggest
 
    ids = _ids()
    model = _model()
    hookup = suggest(model, 500.0, 4500.0)
    assert knob_starts(hookup, model) == {
        DOME: pytest.approx(535.0),
        CHARGE: pytest.approx(4000.0),
    }
    loader = next(r for r in regulators(model) if r.id == ids["DR-REG-G"])
    assert loader.drawn_psig == pytest.approx(535.0)
 
    payload = _payload()
    for node in payload["nodes"]:
        params = node["data"].get("params") or {}
        if node["data"].get("label") == "DPR_HP":
            params.pop("dome_pressure")
        if node["data"].get("label") == "COPV":
            params.pop("pressure")
    blank = assemble_model(read_diagram(payload, name="LE4"), diagram_id="le4")
    knobs = {k.id: k for k in suggest(blank, 500.0, 4500.0).knobs}
    assert knobs[DOME].psig == 500.0
    assert knobs[CHARGE].psig == 4500.0
    assert knob_starts(suggest(blank, 500.0, 4500.0), blank) == {}
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_the_gse_valves_bind_to_the_table() -> None:
    from feedtwin.session import load_machine
    from feedtwin.session.hookup import binding
 
    ids = _ids()
    bound = binding(_model(), load_machine(tables=TABLES), None).to_symbol
    assert bound["Fuel Vent"] == ids["FV-SOL"]
    assert bound["Fuel Fill Vent"] == ids["FF-SOL-Vent"]
    assert bound["GSE High Press Control"] == ids["HPC_SOL"]
    assert bound["LOX Dump"] == ids["OF-MOT-Dump"]
    # The OV disconnects are not paired on this drawing, so the cart's LOX vent
    # goes nowhere; the tank-top half is still the vent that works.
    assert bound["LOX Vent"] == ids["QD-OV-B"]
    assert ids["FF-MAN-Output"] not in bound.values(), "hand valves are the crew's"
 
 
@pytest.mark.skipif(
    not (ENGINE.exists() and CEA.exists() and TABLES.is_dir()),
    reason="engine, CEA table or state machine tables absent",
)
def test_the_pad_charges_the_copv_and_loads_fuel_through_the_drawing() -> None:
    """GN2 High Press charges the COPV through PR-1 at the COPV fill knob; Fuel
    Fill presses the transfer tank to its drawn 150 psig and pushes fuel across
    the QD pair until the flight tank holds its load. Nothing moves before, no
    propellant appears from nowhere, and the stand keeps its mass."""
    import yaml
 
    from feedtwin.engine.importer import engine_from_config
    from feedtwin.session import assemble_model, load_machine
    from feedtwin.session.burn import open_session
    from feedtwin.session.gauge import psig
    from feedtwin.session.hookup import suggest
 
    ids = _ids()
    design = engine_from_config(yaml.safe_load(ENGINE.read_text()), name="6800N")
    model = assemble_model(
        read_diagram(_payload(), name="LE4 (6)"),
        diagram_id="le4",
        engine=design,
        cea_cache=str(CEA),
    )
    session = open_session(
        model, load_machine(tables=TABLES), hookup=suggest(model, 500.0, 4000.0)
    )
    session.setup = replace(session.setup, copv_target_psi=4000.0)
    fuel, cart = (
        session.tanks[ids["Eth-Tank"]],
        session.tanks[ids["Fuel Transfer Tank"]],
    )
    copv = session.bottles[ids["COPV"]]
    start_cart = cart.state.liquid_mass
    assert start_cart > 10.0 and fuel.state.liquid_mass == 0.0
 
    session.state = "GN2 High Press"
    for _ in range(40):
        session.step(0.5)
    assert psig(copv.pressure) == pytest.approx(4000.0, abs=40.0)
    assert fuel.state.liquid_mass == 0.0, "nothing moves before Fuel Fill"
 
    session.state = "Fuel Fill"
    for _ in range(80):
        session.step(0.5)
    load = fuel.state.liquid_mass
    assert load == pytest.approx(fuel._wanted(), rel=0.02)
    # Less a little ethanol that evaporates into the vented ullage; the strict
    # check is the balance below.
    assert start_cart - cart.state.liquid_mass == pytest.approx(load, abs=5e-3)
    assert psig(cart.pressure) == pytest.approx(150.0, abs=2.0)
    last = session.solver_log[-1]
    assert abs(last.mass_error_kg - last.guard_kg) < 1e-3
 
 
# ----------------------------------------------------------------- the dome line
 
 
def _session(payload: Any | None = None) -> Any:
    from feedtwin.session import assemble_model, load_machine
    from feedtwin.session.burn import open_session
    from feedtwin.session.hookup import suggest
 
    model = assemble_model(
        read_diagram(payload or _payload(), name="LE4 (6)"), diagram_id="le4"
    )
    return open_session(
        model, load_machine(tables=TABLES), hookup=suggest(model, 500.0, 4500.0)
    )
 
 
def test_the_dome_line_is_gated_by_its_valves(built: Any) -> None:
    ids = _ids()
    line = built.dome_lines[ids["DPR_HP"]]
    assert line.loader == ids["DR-REG-G"]
    assert line.valves == frozenset(
        ids[v] for v in ("DR-CTRL-G", "DR-CTRL-R", "DR-MV", "DR-Vent")
    )
    assert line.vents == frozenset({ids["DR-MV"], ids["DR-Vent"]})
    assert built.valve_roles[ids["DR-CTRL-G"]] == frozenset(
        {"gse", "med", "press", "control"}
    )
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_the_dome_loads_on_the_pad_and_holds_when_its_valve_shuts() -> None:
    """Unloaded, the 1092 holds its 50 psi spring bias less its supply effect --
    with the COPV charged, less than nothing, so the tank does not press. GN2 Low Press
    opens DR-CTRL-G ("GSE Med Press Control") and the dome follows DR-REG-G; the
    next state shuts it and the dome keeps what is in it, as the stand keeps it
    through the burn with the GSE disconnected. The dome PT reads it."""
    from feedtwin.session.gauge import psig
 
    ids = _ids()
    session = _session()
    assert session.binding.to_symbol["GSE Med Press Control"] == ids["DR-CTRL-G"]
    session.state = "GN2 High Press"
    for _ in range(40):
        session.step(0.5)
    session.state = "Fuel Press"
    for _ in range(20):
        session.step(0.5)
    fuel = session.tanks[ids["Eth-Tank"]]
    copv = session.bottles[ids["COPV"]]
    # dome + bias - S x inlet, S 14.7 psi per 1000 on the drawing (zero inlet).
    supply = 14.7e-3 * psig(copv.pressure)
    assert supply > 50.0, "a charged COPV outweighs the spring bias"
    assert psig(fuel.pressure) == pytest.approx(0.0, abs=2.0), "unloaded: shut"
 
    session.state = "GN2 Low Press"
    for _ in range(4):
        session.step(0.5)
    session.state = "Fuel Press"
    for _ in range(30):
        session.step(0.5)
    lockup = 500.0 + 50.0 - 14.7e-3 * psig(copv.pressure)
    assert psig(fuel.pressure) == pytest.approx(
        lockup, abs=8.0
    ), "dome + bias - S x COPV"
    dome_pt = next(i for i in session.model.built.instruments if i.id == ids["DP-PT-R"])
    assert psig(session.history[-1].pressures[dome_pt.node]) == pytest.approx(500.0)
    assert ids["DR-CTRL-G"] not in session.forced
    assert psig(session._dome_held[ids["DPR_HP"]]) == pytest.approx(500.0)
 
 
# ------------------------------------------------------- the dewar is a supply
 
 
def _with_lox_fill_drawn() -> Any:
    """LE4 (6) with its LOX fill line finished, as ADR 0006 asks of the drawing:
    the fill valve's junction to the fill manifold, the manifold to OF-QDA, and
    the LOX vent disconnects paired."""
    payload = _payload()
 
    def line(i: str, s: str, sh: str, t: str, th: str) -> dict[str, Any]:
        return {
            "id": i,
            "source": s,
            "sourceHandle": sh,
            "target": t,
            "targetHandle": th,
            "type": "smoothstep",
            "data": {},
        }
 
    ids = _ids()
    payload["edges"] += [
        line("fix-1", "junc_85", "r", "junc_86", "r"),
        line("fix-2", ids["OF-Manifold"], "in", ids["OF-QDA"], "r"),
    ]
    for node in payload["nodes"]:
        if node["data"]["label"] == "OV-QD-A":
            node["data"].setdefault("options", {})["pairedWith"] = ids["QD-OV-B"]
    return payload
 
 
def test_a_liquid_dewar_is_a_supply_tank() -> None:
    built = build_network(read_diagram(_with_lox_fill_drawn(), name="LE4 (6)"))
    ids = _ids()
    assert ids["LOX-DW-350 PSI"] in built.tanks
    assert built.supplies[ids["LOX-DW-350 PSI"]] == frozenset({ids["LOX-Tank"]})
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_ox_fill_loads_the_flight_lox_tank_from_the_dewar() -> None:
    from feedtwin.session.gauge import psig
 
    ids = _ids()
    session = _session(_with_lox_fill_drawn())
    dewar, lox = session.tanks[ids["LOX-DW-350 PSI"]], session.tanks[ids["LOX-Tank"]]
    assert psig(dewar.pressure) == pytest.approx(50.0, abs=0.5)
    start = dewar.state.liquid_mass
    session.state = "Ox Fill"
    for _ in range(40):
        session.step(0.5)
    assert lox.state.liquid_mass == pytest.approx(lox._wanted(), rel=0.03)
    assert start - dewar.state.liquid_mass >= lox.state.liquid_mass
    session.state = "Armed"
    for _ in range(40):
        session.step(0.5)
    assert psig(dewar.pressure) == pytest.approx(50.0, abs=5.0), "its own circuit"
    last = session.solver_log[-1]
    assert abs(last.mass_error_kg - last.guard_kg) < 1e-3
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_a_topped_lox_tank_on_its_vent_lands_where_the_solve_put_it() -> None:
    """Topped to its load in Ox Fill, the LOX tank passes ~20 g/s of boil-off
    through a 0.45 g ullage to its vent. The solve closed that ullage on the
    stiffer of its gas-in and gas-out slopes, and over boiling LOX gas in is
    eight times stiffer: the node the vent flowed from sat at 3.1 psig while
    the tank read 7.2, a gap that grew with the coupling step. And the 10 %
    mass rule counted the vented gas, so the whole stand was solved nine
    times every 20 ms -- the fill ran at a third of real time. A venting
    ullage is closed on its own gas-out slope, and gas gone to the sky asks
    for no extra solves."""
    from feedtwin.session.gauge import psig
 
    ids = _ids()
    session = _session(_with_lox_fill_drawn())
    lox = session.tanks[ids["LOX-Tank"]]
    session.state = "Ox Fill"
    for _ in range(36):
        session.step(0.25)
    assert lox.state.liquid_mass == pytest.approx(lox._wanted(), rel=0.01)
    session.step(0.02)
    gas_in, gas_out = session._split_at(lox.ullage_node, session._last_flows)
    assert gas_out > 20.0 * lox.state.ullage.mass, "the ullage turns over each 50 ms"
    node = session._last_pressures[lox.ullage_node]
    assert psig(lox.pressure) == pytest.approx(psig(node), abs=0.3)
    assert session.solver_log[-1].couplings == 1
 
 
# ------------------------------------------------------------ the cart rests
 
 
def _fired(rests: bool) -> Any:
    """LE4 (6) at T-0 with the engine on, then 0.3 s into Fire."""
    import yaml
 
    from feedtwin.engine.importer import engine_from_config
    from feedtwin.session import assemble_model, load_machine
    from feedtwin.session.burn import jump_to_t0, open_session
    from feedtwin.session.hookup import suggest
 
    design = engine_from_config(yaml.safe_load(ENGINE.read_text()), name="6800N")
    model = assemble_model(
        read_diagram(_payload(), name="LE4 (6)"),
        diagram_id="le4",
        engine=design,
        cea_cache=str(CEA),
    )
    session = open_session(
        model, load_machine(tables=TABLES), hookup=suggest(model, 500.0, 4500.0)
    )
    session.setup = replace(session.setup, ground_rests=rests)
    jump_to_t0(session, copv_psi=4500.0, fill_fraction=0.95)
    session.command_state("Fire")
    most = 0.0
    for _ in range(15):  # the first 0.3 s, a study step at a time
        session.step(0.02)
        most = max(most, session.solver_log[-1].couplings)
    return session, most
 
 
@pytest.mark.skipif(
    not (ENGINE.exists() and CEA.exists() and TABLES.is_dir()),
    reason="engine, CEA table or state machine tables absent",
)
def test_while_the_engine_burns_the_cart_rests_and_the_burn_is_the_same() -> None:
    """Fire on LE4 (6) with the cart drawn: every cart vessel is cut off from the
    vehicle by shut valves, so none is integrated and its lines leave the solve,
    and the burn is the one the whole stand integrated every step gives."""
    ids = _ids()
    rested, _ = _fired(True)
    worked, _ = _fired(False)
    cart = {
        ids[label]
        for label in ("Fuel Transfer Tank", "LOX-DW-350 PSI", "6K-GN2")
        if ids[label] in rested.tanks or ids[label] in rested.bottles
    }
    branches, vessels = rested._resting
    assert cart and cart <= vessels
    assert branches, "the cart's lines are out of the solve"
    assert not vessels & set(rested.vehicle_tanks)
    held = {k: rested.tanks[k].state for k in vessels if k in rested.tanks}
    rested.step(0.1)
    for k, state in held.items():
        assert rested.tanks[k].state is state, "a resting vessel is not integrated"
    worked.step(0.1)
    for a, b in zip(rested.history, worked.history):
        assert a.chamber is not None and b.chamber is not None
        assert a.chamber.thrust == pytest.approx(b.chamber.thrust, rel=1e-9, abs=1e-6)
 
 
@pytest.mark.skipif(
    not (ENGINE.exists() and CEA.exists() and TABLES.is_dir()),
    reason="engine, CEA table or state machine tables absent",
)
def test_ignition_is_not_stepped_on_a_capped_port() -> None:
    """The fuel tank's top QD hangs a wide fitting off its ullage that ends at a
    cap. It carries nothing, so it is no press path: priced as one at the drain
    flow, it asked the first steps of Fire for 0.07 ms couplings -- 64 in a 20 ms
    step here, ~300 on the cockpit's first tick, most of a second before the
    first frame of the burn."""
    session, most = _fired(True)
    assert session.history[-1].chamber.thrust > 5000.0
    assert most < 20, f"{most} coupling steps in one 20 ms step"
 
 
@pytest.mark.skipif(
    not (ENGINE.exists() and CEA.exists() and TABLES.is_dir()),
    reason="engine, CEA table or state machine tables absent",
)
def test_t0_loads_the_fire_load_not_the_tank() -> None:
    """The vehicle carries what the competition allows (the engine config's
    lox_tank.mass and fuel_tank.mass), not 95 % of the tanks drawn: LE4 (6)
    draws both at 8.19 L, a third more LOX than a fire is loaded with."""
    import yaml
 
    from feedtwin.engine.importer import engine_from_config
    from feedtwin.session import assemble_model, load_machine
    from feedtwin.session.burn import jump_to_t0, open_session
    from feedtwin.session.hookup import suggest
 
    config = yaml.safe_load(ENGINE.read_text())
    design = engine_from_config(config, name="6800N")
    assert design.fire_load == {
        "lox": pytest.approx(config["lox_tank"]["mass"]),
        "fuel": pytest.approx(config["fuel_tank"]["mass"]),
    }
    model = assemble_model(
        read_diagram(_payload(), name="LE4 (6)"),
        diagram_id="le4",
        engine=design,
        cea_cache=str(CEA),
    )
    session = open_session(
        model, load_machine(tables=TABLES), hookup=suggest(model, 500.0, 4500.0)
    )
    jump_to_t0(session, copv_psi=4500.0, fill_fraction=0.95)
    ids = _ids()
    lox, fuel = session.tanks[ids["LOX-Tank"]], session.tanks[ids["Eth-Tank"]]
    assert lox.state.liquid_mass == pytest.approx(config["lox_tank"]["mass"])
    assert fuel.state.liquid_mass == pytest.approx(config["fuel_tank"]["mass"])
    # A pad load stops there too (the session hands it over each tick).
    session.step(0.02)
    assert lox._wanted() == pytest.approx(config["lox_tank"]["mass"])
 
 
def test_the_cart_regulators_drawn_with_settings_get_knobs_at_them() -> None:
    """A cart regulator the drawing sets is still turned by hand on the pad, so it
    gets a knob -- starting where the drawing sets it. It used to get none, and the
    dome and COPV fill started at 500 and 4,500 whatever the sheet said."""
    from feedtwin.session import assemble_model
    from feedtwin.session.hookup import CHARGE, DOME, knob_starts, suggest
 
    ids = _ids()
    payload = _payload()
    settings = {"PR-1": 3750, "DR-REG-G": 535, "LP-PR": 150}
    for node in payload["nodes"]:
        label = node["data"]["label"]
        if label in settings:
            node["data"].setdefault("params", {})["setpoint"] = {
                "value": settings[label],
                "unit": "psi",
                "source": "estimated",
            }
    model = assemble_model(read_diagram(payload, name="LE4"), diagram_id="le4")
    hookup = suggest(model, 500.0, 4500.0)
    knobs = {k.id: k for k in hookup.knobs}
    assert knobs[DOME].regulators == (ids["DR-REG-G"],)
    assert knobs[CHARGE].regulators == (ids["PR-1"],)
    assert knobs[ids["LP-PR"]].regulators == (ids["LP-PR"],)
    assert knob_starts(hookup, model) == {
        DOME: pytest.approx(535.0),
        CHARGE: pytest.approx(3750.0),
        ids["LP-PR"]: pytest.approx(150.0),
    }
    assert knobs[DOME].psig == pytest.approx(535.0)
    assert knobs[CHARGE].psig == pytest.approx(3750.0)
    assert knobs[ids["LP-PR"]].psig == pytest.approx(150.0)
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_a_dry_tank_does_not_drain_back_through_its_fill_line() -> None:
    """The flight fuel tank's fill line stays open to it when dry so it can be
    loaded -- in its fill state, and only then. Open always, with a dump open
    beyond it (LE4's FD-ROT-G, uncommanded and resting open; here the cart's
    hand dump and transfer valve opened, the transfer held by hand), the dry
    tank "drained" through the line forever and the vessel's floor re-made the
    mass: ~0.46 kg/s of propellant from nothing, booked as guard."""
    from feedtwin.session.burn import jump_to_t0
 
    ids = _ids()
    payload = _payload()
    for node in payload["nodes"]:
        if node["data"]["label"] == "FF-MAN-Dump":
            node["data"].setdefault("options", {})["normalPosition"] = "open"
    session = _session(payload)
    jump_to_t0(session, copv_psi=4000.0, fill_fraction=0.95)
    session.release(ids["FF-MAN-Output"])
    session.set_valve(ids["FF-MAN-Output"], True)
    fuel = session.tanks[ids["Eth-Tank"]]
    for _ in range(20):
        session.step(0.05)
    # Where the fuel is going is said, and that nothing commands the way out.
    (leaving,) = [n for n in session.history[-1].notes if "losing ethanol" in n]
    assert "FF-MAN-Dump" in leaving and "nothing in the state table" in leaving
    for _ in range(280):  # 15 s: the tank drains through the dump, then is dry
        session.step(0.05)
    assert fuel.state.liquid_mass == pytest.approx(0.0, abs=1e-3)
    guard = session.solver_log[-1].guard_kg
    for _ in range(200):  # 10 s dry
        session.step(0.05)
    last = session.solver_log[-1]
    assert last.guard_kg - guard < 0.05, "the floor is re-making propellant"
    assert abs(last.mass_error_kg - last.guard_kg) < 1e-6
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_the_crews_transfer_valve_is_not_the_operators_hold() -> None:
    """A fresh stand with a drawn load has the crew's transfer valve shut by the
    twin. That is not the operator's hand: no "1 held", and Release leaves it."""
    ids = _ids()
    session = _session()
    valve = ids["FF-MAN-Output"]
    assert valve in session.forced
    assert session.operator_held == []
    session.set_valve(ids["FM-R"], True)
    assert session.operator_held == [ids["FM-R"]]
    session.release()
    assert session.operator_held == [] and valve in session.forced
    # Turned the other way by hand, it is the operator's.
    session.set_valve(valve, True)
    assert session.operator_held == [valve]
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_a_trip_names_the_vessel_furthest_over() -> None:
    """Both run tanks primed over MAWP trip the stand at once. It named the
    first tank it looked at (Eth-Tank, 935.7 psia) while the LOX tank stood
    at 963.5 psia (D-33); it names the one furthest over its MAWP."""
    from feedtwin.session.gauge import from_psig
 
    ids = _ids()
    session = _session()
    fuel, lox = session.tanks[ids["Eth-Tank"]], session.tanks[ids["LOX-Tank"]]
    assert fuel.mawp == pytest.approx(lox.mawp)
    session.prime(fill_fraction=0.5, tank_psi=900.0, copv_psi=4000.0, state="Ready")
    lox.state = lox.tank.initial_state(
        pressure=from_psig(950.0),
        liquid_mass=lox.state.liquid_mass,
        liquid_temperature=lox.state.liquid_temperature,
        gas_temperature=293.15,
    )
    assert fuel.pressure > fuel.mawp and lox.pressure > fuel.pressure
    session._check_limits()
    assert session.trip is not None and session.trip.vessel == ids["LOX-Tank"]
    assert session.tripped and session.tripped.startswith("LOX-Tank reached")
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_a_trip_says_what_it_is_and_which_reliefs_it_beat() -> None:
    """The trip limit is the drawing's burst over a factor of two, and the trip
    said "The tank would have failed" at half the burst. LE4's tank reliefs are
    drawn at 750 psi, the trip limit itself, so they can never lift before it:
    the message says so rather than leave the operator wondering why the drawn
    relief did nothing."""
    from feedtwin.session.gauge import PSI, psig
 
    ids = _ids()
    session = _session()
    lox = session.tanks[ids["LOX-Tank"]]
    session.prime(fill_fraction=0.5, tank_psi=500.0, copv_psi=4000.0, state="Ready")
    # Both tank reliefs at the limit; the COPV's well above it, behind a
    # regulator, protecting something else.
    sets = {
        label: branch.component.set_pressure / PSI
        for branch_id, branch in session._reliefs
        for label in [next(k for k, v in ids.items() if v == branch_id)]
    }
    assert sets["RV_O"] == pytest.approx(psig(lox.mawp), abs=0.5), sets
    assert sets["RV-HPF"] > psig(lox.mawp) + 1000.0, sets
    lox.state = lox.tank.initial_state(
        pressure=lox.mawp + 5.0 * PSI,
        liquid_mass=lox.state.liquid_mass,
        liquid_temperature=lox.state.liquid_temperature,
        gas_temperature=293.15,
    )
    session._check_limits()
    message = session.tripped or ""
    assert message.startswith("LOX-Tank reached"), message
    assert "would have failed" not in message
    assert "MAWP" in message and "at risk" in message
    assert "RV_O is set at or above that limit and cannot lift" in message, message
    assert "RV-HPF" not in message, "the COPV relief protects the COPV"
 
 
# ------------------------------------------- the cart's tanks end no burn
 
 
def _cart_tank_ran_dry(session: Any) -> Any:
    """The cart's Fuel Transfer Tank after the loads it gave: dry, as a real fill
    leaves it (``TankSim.advance`` sets ``empty``, and a resting cart vessel is
    never advanced again to clear it)."""
    cart = session.tanks[_ids()["Fuel Transfer Tank"]]
    cart.state = replace(cart.state, liquid_mass=0.0)
    cart.empty = True
    return cart
 
 
@pytest.mark.skipif(
    not (ENGINE.exists() and CEA.exists() and TABLES.is_dir()),
    reason="engine, CEA table or state machine tables absent",
)
def test_an_empty_cart_tank_is_not_a_burnout() -> None:
    """Only the vehicle's tanks end a burn. ``_burnout_check`` counted every tank
    on the stand, so a cart transfer tank emptied by the loads it gave sent each
    Fire to Vent at T+0.00 s with the flight tanks full ("Burnout at T+0.00 s:
    Fuel Transfer Tank ran dry")."""
    import yaml
 
    from feedtwin.engine.importer import engine_from_config
    from feedtwin.session import assemble_model, load_machine
    from feedtwin.session.burn import jump_to_t0, open_session
    from feedtwin.session.hookup import suggest
 
    design = engine_from_config(yaml.safe_load(ENGINE.read_text()), name="6800N")
    model = assemble_model(
        read_diagram(_payload(), name="LE4 (6)"),
        diagram_id="le4",
        engine=design,
        cea_cache=str(CEA),
    )
    session = open_session(
        model, load_machine(tables=TABLES), hookup=suggest(model, 500.0, 4500.0)
    )
    jump_to_t0(session, copv_psi=4500.0, fill_fraction=0.95)
    _cart_tank_ran_dry(session)
    session.command_state("Fire")
    for _ in range(25):  # 0.5 s
        session.step(0.02)
    assert session.burnout is None
    assert session.state == "Fire"
    assert session.history[-1].chamber.thrust > 5000.0
 
 
@pytest.mark.skipif(not TABLES.is_dir(), reason="no state machine tables")
def test_a_cold_flow_is_lit_by_the_vehicle_tanks_not_the_cart() -> None:
    """With no engine model the ENGINE symbol's design pressure is the boundary
    while the feed can hold it. "The feed" counted the cart: a dewar at 50 psig
    or a dry transfer tank under the 385 psia design kept the chamber at
    atmosphere with both flight tanks pressed well above it."""
    from feedtwin.session.burn import jump_to_t0
 
    session = _session()
    jump_to_t0(session, copv_psi=4000.0, fill_fraction=0.95)
    _cart_tank_ran_dry(session)
    session.command_state("Fire")
    session.step(0.02)
    session.step(0.02)
    vehicle = [session.tanks[k] for k in session.vehicle_tanks]
    assert min(sim.outlet_pressure for sim in vehicle) > session._design_chamber
    chamber = session.model.built.network.nodes[session._chamber_node]
    assert chamber.pressure == pytest.approx(session._design_chamber)
 
 
def test_a_pair_drawn_joined_is_not_called_unmated(built: Any) -> None:
    """HP-QD-A and HP-QD-B are paired and joined by their own line; OF-QDA has
    no line at all, which is worth saying."""
    unmated = [w for w in built.warnings if "unmated" in w]
    assert not [w for w in unmated if "HP-QD" in w], unmated
    assert [w for w in unmated if "OF-QDA" in w], "the real one is still said"