Route choice in smoke after Schröder et al. (2015)

Schröder et al. (2015) let agents in an assembly hall choose between two doors and two exits while smoke from a fire in a neighbouring room spreads. We build their geometry, add our own growing fire, and run pyFDS-Evac’s own smoke-aware routing on it with 200 agents and 10 seeds per case:

• Exit and door shares. How the default gate router and the additive router change them in a growing fire, against a smoke-blind crowd.
• Door choice by movement start. Why, under gate, the door an agent takes depends mainly on when it starts moving.
• What the router sees. It reads the smoke along the whole route at 1.6 m, including smoke that will arrive later. Schröder’s sensor reads the smoke present in the agent’s room along straight lines at 2.8 m. This difference in perception scope is #125.

↓ Download the files for this page (100 kB zip)

The result in brief

Main fire a047_pvc_h40, mean of 10 seeds. The no-fire and smoke-blind arms are identical, so the smoke-blind arm is the reference:

Δy is the boundary minus the clear-air boundary of the same seed. A positive Δy moves the boundary toward door B, so more agents use door A. A change in the E share counts if it exceeds 2 × SD of the smoke-blind shares, 0.048.

• Gate sends more agents through door A to exit E than clear air does: E share 0.689 against 0.520, in 10 of 10 seeds.
• (Post hoc) Gate’s door choice follows mainly when an agent starts moving. The door-B share is 0.04 for agents starting at 30–120 s and 0.83 for those starting at 150–300 s. In clear air it is about 0.5 throughout.
• The cause is a hall-wide re-path at 45 s and a wave of fallbacks peaking at 151–155 s. The path search reads the smoke present at decision time, while the route’s τ reads the smoke each point will have when the agent gets there. From 134–136 s every route is refused for the first agents, and the fallback sends most of them to door B and exit F.
• Additive shifts the split by −0.90 m (95 % CI −1.16, −0.64) on the main fire. Its shift depends on the fire: −0.90 m on the main fire, +0.25 m on a047_pvc_h35 (95 % CI −0.00 to +0.50, not resolved) and +1.25 m on a012_pvc_h30.
• Heat and the 400 s cap. Heat entered neither routing nor tenability. Up to 7 late-starting agents per run were still walking at 400 s.

The building

Tags: [P] published in the paper, [D] digitised from Schröder et al. (2015), Figs. 2–3 and 6 (±0.5–1 m), [A] assumed here.

Departures from the source.

• Room 3 and doors C and D are not walkable and not in the stage graph. They stand in for Schröder’s room-to-corridor sensor. In FDS, C and D are open.
• Doors A and B are waypoints, E and F are exits. Each exit has a 0.8 m deep passage, so agents enter it before they are removed (#349).
• The waypoint split is 50/50 at A and at B, because the engine needs an explicit split where a waypoint has two exits. Route ranking picks each agent’s exit. In clear air nobody crosses over: only A→E and B→F occur.
• Agents start uniformly in the hall, 0.3 m from the walls. Model CFSM, radius 0.15 m, familiarity full.
• FDS 6.10.1 is used. Schröder used FDS 6.1.2.

The fire

The paper publishes no fire: burner, heat release rate, fuel, soot yield, grid, ceiling height and end time are all unstated. Our fire was set from design-fire practice before any routing run. One of nine variants was then chosen against a smoke target, also before any routing run.

Smoke is written at 1.6 m (routing, walking speed and gas dose), and at 2.0 and 2.8 m for comparison. With the 3.5 m ceiling FDS places these at 1.56, 1.94 and 2.72 m; pyFDS-Evac takes the nearest slice and logs the height mismatch. Runtime with 6 MPI processes: 90 min (a047_pvc_h40), 99 min (a047_pvc_h35), 61 min (a012_pvc_h30).

How the main fire was chosen

1. The target was fixed first. It is our reading of the paper’s Fig. 6c (p. 335, the 2.8 m extraction at 165 s, printed without a colour scale): Room 3 and the upper corridor opaque (K ≥ 2.3 1/m), the lower corridor clear (K ≤ 0.23), the lower hall at K 0.7–1.4, the upper hall clear (K ≤ 0.23 [A]).
2. Nine runs on the 0.2 m grid: α ∈ {0.012, 0.047} × {PVC, PUR} × ceiling ∈ {3.0, 4.0} m, plus the central case a047_pvc_h35. Each is scored by S, the mean over five regions of the share of nodes that meet the target.
3. No automatic pick was plausible. The best score, 0.60 for a012_pvc_h30, equals that of a field with smoke only in Room 3. No variant beats that null field. a012_pvc_h30 also reverses the hall pattern: median K 2.0 1/m in the upper hall against 0.99 in the lower.
4. Smoke enters the hall through door C and piles up at the far, door-A end (details below). Whether the 2.8 m slice shows the lower hall darker depends on how far below the ceiling it sits.
5. The maintainer chose a047_pvc_h40 by visual match to Fig. 6c. It is the only variant with the lower hall darker than the upper (median K 1.5 against 0.51 1/m) and an opaque upper corridor (87 % of nodes). It differs from Fig. 6c in four ways: the corridor toward E is smokier (median K 0.94 against ≤ 0.23); the lower hall is patchier and darker; some smoke sits at the top of the hall near C; and its score is 0.48 against the best 0.60.

The comparison fires are a012_pvc_h30 (best score, reversed hall pattern) and a047_pvc_h35 (the central design fire, smoke almost everywhere). The fire was chosen against the smoke target only; no route outcome was known.

The crowd and the routers

• 200 agents in the hall [P], placed uniformly at t = 0 [A].
• Walking speed v₀ ~ N(1.0, 0.2) m/s [P], clipped by the engine to 0.1–5.0 m/s.
• Pre-movement with mean 120 s and SD 60 s [P]: Weibull, scale 135.49 s, shape 2.101. The source uses N(120, 60) s, which pyFDS-Evac does not offer.
• Four arms, seeds 1–10 each: no fire; smoke-blind (--smoke-blind); gate; additive with w_smoke 1.0, the engine default. The cost model is set explicitly in each scenario; at the time a misspelt name selected the additive model (#305).
• Routing settings: anticipate: true, foresight_horizon_s at its default (no limit), base_speed_m_per_s 1.0. Routes are re-evaluated every 1 s, also during pre-movement.
• Smoke height 1.6 m for routing, speed and gas dose. Schröder’s example extracts at 2.8 m.
• Tenability: gas FED on, heat FED off (both engine defaults).
• Horizon: 400 s against the FDS end of 480 s.

The routing model and the gate in detail explain each setting.

Results

Exit shares and flows

Mean of 10 seeds. The smoke-blind arm is the same on every fire.

Door choice follows movement start (gate)

This measure was added after the first results were seen (post hoc). Under gate, an agent’s door is predicted better by when it starts moving than by where it starts: area under the ROC curve 0.86 against 0.66, and McFadden R² 0.30 against 0.05 (0.38 for both together). Position still matters a little. Under additive, start position stays the better predictor (AUC 0.96).

Smoke-blind and gate, animated

Main fire a047_pvc_h40, seed 3, 0–398 s at 16 times real time. Left smoke-blind, right gate; both arms have the same agents, start positions and start times. Seed 3 has 147 agents through door A under gate, the median of the 10 seeds. Background: K at 1.6 m, the slice that routing, walking speed and gas dose use. Open rings: agents in pre-movement. Dots: walking agents, coloured and sized by their speed factor. Regenerated by scripts/docs/study_animations.py.

What to watch for:

• 45–145 s. Under gate almost every agent that starts walking heads for door A, also from the upper hall. Smoke-blind splits the hall at about y = 12.5 m. By 146 s, 83 agents have passed door A under gate against 57 for smoke-blind.
• From 134 s. The first agents find every route refused, as smoke at 1.6 m reaches the door-A end of the hall. Under gate, 10 agents pass door B before 145 s (the last at 70.6 s) and 43 from 149.1 s on. Those 43 all go to F through the smoky upper corridor, where their dots grow and turn red.
• The end. Smoke-blind’s last agent leaves at 303.4 s, gate’s at 362.9 s. In this seed nobody is inside at 400 s in either arm.

The route figure below shows the 2.8 m slice for comparison with the paper. The animation shows 1.6 m, the slice that routing and walking speed use.

Why: a hall-wide re-path and a fallback wave

Five facts of the gate code explain the pattern (pyfds_evac/core/route_graph.py):

• The path search weights each edge by k_avg·L + 1e-6·L (GatePolicy.edge_weight), so length only breaks ties: any trace of smoke on the shorter path sends the search onto a smoke-free path of any length.
• The search starts where the agent stands (#451): the walk to each door is the first leg, charged the smoke on that walk. The smoke in the hall is nearly uniform at these times, so almost every hall agent gets the same door for a given exit: from 50 to 144 s, 97–99 % of the hall agents’ first-ranked routes are A→E, in every seed.
• The search uses the smoke present at decision time (_generate_candidates). The τ of each candidate is read point by point at the time the agent would reach that point, counted from where the agent stands (_measure_route, #650); see the routing model.
• Routes are ranked by τ first (GatePolicy.order_key). An exit switch needs the rival’s τ to be lower by more than 6 × 0.1 = 0.6 (_tau_band). A route is refused above τ = 6 for the current exit and 4.8 for a rival exit (RouteCostConfig). τ = 6 comes from the original FDS+Evac.
• Two refused routes: the lower τ decides, with a 20 % margin; a switch straight back is blocked for 10 s (#458).

The 45 s re-path happens at the same second in all 10 seeds; the later events vary by a few seconds between seeds:

Per seed, 30–47 exit changes return to an exit the agent had left earlier, none within 2 s of leaving it. Between two refused routes the 20 % margin and the 10 s return lockout apply. A fallback switch X→Y is followed by a switch Y→X of the same agent 56 times in 10 seeds (median 34 s later). Route smoke is read once per grid cell since #653 (0.5.0), and the returns remain with it.

These counts, the 28 later shorter_path changes, the 307 fallback switches in 151–155 s and the time windows of the smoke_reroute and better_path changes in the table are post hoc: they were read from the gate route histories (gate_s*_rh.csv) with a separate script, and schroeder2015_route.py does not print them. A return is an exit change to an exit the agent left earlier; an undone fallback is a fallback X→Y followed later by Y→X of the same agent.

τ is read point by point at the time the agent would reach each point. A route appears only while the path search offers it for its exit to at least one agent.

The pre-registered mechanism was refuted; its direction held. Before the runs we predicted that B→E would carry more τ than A→E and so move the boundary toward door B. The boundary did move toward B, and from 130 s B→E does carry more τ than A→E (τ figure), but that comparison does not move the agents: almost nobody takes B→E (0.2 per seed). The shift toward door A comes from the 45 s re-path of exit F, and the later door-B users reach F by the fallback.

The additive boundary

Under gate, door B is not a monotone function of start y, so a boundary fitted in metres is not meaningful: its CI lies inside the hall in none of the 10 seeds on the main fire. Gate is therefore reported by its E share, its sign count and the door share by start. Under additive every seed has a valid boundary; the shift is −0.90 m (−1.16, −0.64) on the main fire. Additive charges length in both path and exit ranking and keeps the spatial split.

The comparison fires

• a047_pvc_h35 repeats the main-fire order of events: F via A at 44 s, every route refused from 127–129 s, E via B at 156–199 s.
• a012_pvc_h30 reaches the gate’s sign by another route. Most agents take A→E (E share 0.918). Of its 16.7 door-B users per seed, 55 % started before the 57 s re-path; the fallback, from 172–176 s, sends later starters to door B before E re-paths via B at 221–276 s. Start time does not predict door B (AUC 0.45).
• h35 and h40 differ only in ceiling height. The evidence is two growth rates and three smoke fields, not three independent fires.
• Additive’s shift depends on the fire and is not resolved on a047_pvc_h35. Its mechanism was not analysed.

How far to trust the numbers

• Pre-registration. The criteria were fixed before the boundary and E-share statistics were computed. This is stated, but cannot be checked. The E-share threshold (0.048) was set after the seed-1 exit counts were seen (114, 137 and 99 via E for smoke-blind, gate and additive, in the first runs), and those counts already gave its sign. The sign test, the door share by start, the predictor table and the boundary validity count are post hoc.

• Clear air. Smoke-blind runs are identical to no fire on all three fires. Start positions are the same in every arm, so the comparisons are paired by seed. The deck’s radius is 0.15 m, so 0.5.0 (#408, stage reach from the agent’s own radius) moves the clear-air walks: against the runs of 2a94a8da, every agent keeps its exit, but exit times differ by up to 22.3 s. The E share (0.520), the door counts (104 / 96) and the boundary are unchanged. The clear-air boundary, 12.54 m per seed (12.56 m pooled), lies −0.05 m from the shortest-path boundary at 12.60 m. Before the fix of #350 and #401 the difference was +1.50 m. The clear-air slope comes from perfectly separated data and is not an estimate.

• Still walking at 400 s. No run raised the FDS horizon error (#356), but the 400 s cap leaves some agents walking:

  Fire	gate, per run (total in 10 runs)	additive
  a047_pvc_h40	0–3 (21)	0–4 (22)
  a047_pvc_h35	0–7 (37)	0–7 (36)
  a012_pvc_h30	0–1 (3)	0–1 (2)

  They are late starters (median movement start 286 s; 115 of 121 at 250 s or later) walking at a speed factor of 0.10. None is stalled: each walked at least 0.47 m in the last 30 s.

• Gas. The largest gas FED of any agent in any run is 0.069; nobody is incapacitated by gas.

• Heat. Heat FED was off in all 90 fire-arm runs, so heat entered neither routing nor tenability, and “nobody incapacitated” covers gas only. A post hoc estimate samples the FDS temperature at 1.6 m at the agents’ positions every 1 s. On the main fire, agents meet up to 168 °C, and 25 (gate) and 23 (additive) per run on average go above 60 °C. The convective dose peaks at 0.042 clothed and 0.12 unclothed, with the constants of pyfds_evac/core/fed.py. The unclothed law is Purser and McAllister (2026), Eq. 70.42, p. 2318; it is somewhat unconservative at higher temperatures, so the unclothed dose at 168 °C may be underestimated. The clothed constants have not been checked against ISO 13571. Radiant heat was not assessed.

• One LES realisation per fire, on the 0.2 m grid only.

What this does not show

• The study uses the geometry of Schröder et al. (2015) with our own fire, crowd and router. Their results are neither reproduced, calibrated nor validated.
• The sensor settings behind the paper’s route patterns (Fig. 6d, extraction height, grid, time step and f_risk) are unpublished, so its route choice cannot be set against ours. The counts of its Fig. 7 are one sensitivity sample.
• pyFDS-Evac has neither Schröder’s sensor (Eq. 4), his edge factor (Eq. 5), f_risk, nor his obstruction test (routing model).
• The router reads the smoke along the whole route at 1.6 m, including smoke that will arrive later. Agents could not see that smoke (#125).
• The gate’s τ = 6 comes from FDS+Evac. Schröder’s factor 2 and f_risk are chosen, not fitted (p. 332). The page ranks neither rule above the other.
• The door-choice pattern is a property of the model: a lexicographic τ rule with present-time path search from each agent’s position. No occupant behaviour was observed.
• The gate split has no boundary in metres. It is reported by its E share, its sign count and the door share by start.
• The predicted direction held; the pre-registered mechanism did not.

Reproduce

The inputs are in assets/schroeder2015_route/. Run every command from the repository root, or from the unpacked zip with python instead of uv run python. DATA is a folder outside the repository.

1. FDS, 6 MPI processes per deck:

   for F in a047_pvc_h40 a047_pvc_h35 a012_pvc_h30; do
     mkdir -p "$DATA/$F" && cp assets/schroeder2015_route/$F/$F.fds "$DATA/$F/"
     (cd "$DATA/$F" && mpiexec -n 6 fds $F.fds)
   done

2. Evacuation, four arms on the main fire and three on each comparison fire, seeds 1–10. One seed of each arm on the main fire:

   C=assets/schroeder2015_route/evac
   uv run python run.py --scenario $C/config_gate.json --seed 1                                    # no fire
   uv run python run.py --scenario $C/config_gate.json --seed 1 --fds-dir "$DATA/a047_pvc_h40" --smoke-blind
   uv run python run.py --scenario $C/config_gate.json --seed 1 --fds-dir "$DATA/a047_pvc_h40"     # gate
   uv run python run.py --scenario $C/config_additive.json --seed 1 --fds-dir "$DATA/a047_pvc_h40" # additive

   assets/schroeder2015_route/run_p1.sh runs every seed and adds --output-route-history, --output-exit-history, --output-fed-history and --output-route-cost-history. A run with agents still walking at the 400 s cap is incomplete, and run.py exits with status 2 (Exit status); the script counts such a run as done. It exits non-zero if any run fails. For all seeds at once:

   PY="uv run python" bash assets/schroeder2015_route/run_p1.sh \
       "$DATA/a047_pvc_h40" "$DATA/p1_a047_pvc_h40" 6 --with-nofire
   PY="uv run python" bash assets/schroeder2015_route/run_p1.sh \
       "$DATA/a047_pvc_h35" "$DATA/p1_a047_pvc_h35" 6
   PY="uv run python" bash assets/schroeder2015_route/run_p1.sh \
       "$DATA/a012_pvc_h30" "$DATA/p1_a012_pvc_h30" 6

   Each run takes about 25–40 s.

3. Numbers and figures:

   uv run python scripts/docs/schroeder2015_route.py --data "$DATA"

   It prints the evacuation numbers on this page as Markdown tables (except the post hoc route-history counts below the event table), then this summary, then writes the figures:

   main fire, exit-E share: no fire 0.520, gate 0.689, additive 0.447
   main fire, additive dy: -0.90 m (-1.16, -0.64)
   main fire, gate door-B share: 0.04 for starts 30-120 s, 0.83 for starts 150-300 s

4. Animation of smoke-blind and gate, about 1 min. It needs ffmpeg for the colour reduction; without it the GIF is larger:

   uv run python scripts/docs/study_animations.py schroeder2015 --data "$DATA"

   It prints the seed and the numbers of the caption, then writes the GIF:

   - gate door-A counts {1: 148, 2: 137, 3: 147, 4: 154, 5: 143, 6: 145, 7: 150, 8: 131, 9: 147, 10: 148}; seed 3 (147, median 147)
   wrote site/static/images/studies/schroeder2015/agents_smoke_gate.gif (2.1 MB, 200 frames)

5. Fire choice, optional: it needs all nine fires. Write the decks with uv run python assets/schroeder2015_route/make_decks.py "$DATA", run each with FDS as in step 1 (about 6 h for the six further decks), then uv run python scripts/docs/schroeder2015_fire_figures.py --data "$DATA".

Provenance. The evacuation runs on this page were made on main at c619a046 by steps 2–4 above (seeds 1–10, Python 3.13.4), run by hand from a clean checkout; each run’s manifest records the commit with git_dirty: false and agent_seeding: spawn-key-blake2b-v2. The no-fire and smoke-blind arms give the same E share, door counts and boundary as the earlier runs of 9c820e0f, 2a94a8da and 828ae8c3; their trajectories differ (see Clear air above). The FDS runs used FDS-6.10.1-0-g12efa16-release.

Limits and open issues

The scenario and the fire.

• One 0.2 m grid; a 0.1 m check waits until the case is frozen.
• One LES realisation per fire; the fire choice scores one frame.
• The fire is ours, and its differences from Fig. 6c are listed above. Two one-factor tests are deferred, possibly to a later run on JURECA: door C closed, and a 4.6 m ceiling.
• Heat FED was off; radiant heat was not assessed (#81).
• Up to 7 agents per run are still walking at 400 s.

Engine behaviour seen here.

• The path search uses present-time smoke (routing model).
• One path per exit (#185).
• Perception scope (#125).
• Anticipation horizon (#356).

Open design questions.

1. Present-time path search against anticipated τ: the τ of a route is read at the agent’s arrival time at each point (#650), the path search at decision time.
2. The 1e-6·L length floor lets the path search react to τ of order 1e-4; the gate page discusses the floor.

Not done yet. A dose-aware or perceived-smoke arm for the late B→F route through the opaque upper corridor.

The paper’s unpublished inputs (its fire deck, the settings behind Fig. 6d, later code versions of the factor 2) are not used. The study uses published sources only.

Sources

What next

• Routing model: how pyFDS-Evac prices routes in smoke.
• The gate in detail.
• Wayfinding: what agents know and see.
• ASET-RSET maps after Schröder et al. (2020).
• Design fires.
• Perception scope: #125.

pyFDS-Evac is research software, provided without warranty.