Evacuation with and without the fire

Egress tools such as Pathfinder are commonly run without the fire. The required safe escape time (RSET) is taken from that run and compared with the available safe escape time (ASET) from FDS. Practitioners regard this uncoupled comparison as conservative. This page shows how to make the same comparison with pyFDS-Evac, what a run coupled to the fire adds, and whether the uncoupled run is conservative for one fire: the 2 MW PVC fire of A crowd in a real fire.

You need the fire_2MW_PVC FDS output of that page (step 3 there says where to get it) in $FDS. Each run below takes about 4 s.

The answer in short

For this fire and this T-junction, with 100 people placed at t = 0:

• The workflow carries over exactly. A smoke-blind run with the fire (arm U) gives the same trajectories as a run without it (arm C), and it records the dose along those fire-free paths.
• RSET. The uncoupled RSET is shorter than the speed-only coupled RSET in every seed. It is shorter than the fully coupled RSET in every seed when people wait 30 or 60 s before moving. With no wait, the direction against the fully coupled run is not resolved.
• Dose. Whether the uncoupled run over- or under-states the dose depends on the metric (see the dose table).
• Exit usage differs: without the fire everyone takes the near exit B; with smoke-aware routing (arm R) most agents take exit A.
• The pass/fail verdict at a fixed point is the same in every arm for visibility (fails), and in U, S, R and R-na for FED 0.3 (passes). For HCl with no wait, the verdict at ISO FEC 1 (not the design value 0.3) is knife-edge: a single uncoupled run can give either verdict. Summed over seeds and points, U passes 36 times, R 30, R-na 17 and S 4.

This fire has no margin to lose: at every point the visibility limit is reached before the last person gets out, in every arm and seed. So the study shows what the uncoupled run misses once the margin is gone. It cannot tell whether a design that passes without the fire also passes with it. It is one fire in one geometry, run with research software, and it gives no design verdict.

1. The classic comparison: run without the fire

The scenario is assets/t_junction/config_initial_pre0.json: 100 agents spread over the dead-end branch of the T, all familiar with both exits, no pre-movement, and a time limit of 270 s. The two variants config_initial_pre30.json and config_initial_pre60.json differ only in a constant pre-movement of 30 or 60 s.

Arm C, no fire. Leave out --fds-dir:

mkdir -p ww
SC=assets/t_junction/config_initial_pre0.json
uv run python run.py --scenario $SC --seed 4 \
    --output-sqlite ww/c.sqlite --output-exit-history ww/c_exits.csv

The output ends with:

Simulation finished in 57.65 s (100/100 evacuated).

This is the run an egress-only tool gives you. Take RSET from it and compare it with the location ASET from FDS, as in A crowd in a real fire › At fixed points.

Arm U, smoke-blind. The same run, with the fire sampled but not acting. --smoke-blind keeps every agent at its free speed and on its fire-free route, and still writes what each agent breathed and saw (#341):

uv run python run.py --scenario $SC --seed 4 --fds-dir "$FDS" --smoke-blind \
    --output-sqlite ww/u.sqlite --output-exit-history ww/u_exits.csv \
    --output-fed-history ww/u_fed.csv --output-smoke-history ww/u_smoke.csv

Smoke-blind: rerouting is off.
Smoke-blind: FED is recorded, incapacitation and FIC slowdown off.
…
Simulation finished in 57.65 s (100/100 evacuated).

fdsreader also logs Module vents: could not convert string to float for this deck. It does not affect the result.

Read RSET from the trajectory, not from the Simulation finished line. The ensemble how-to explains why and how. For one seed:

import sqlite3

import numpy as np
import pandas as pd

for run in ("c", "u"):
    with sqlite3.connect(f"ww/{run}.sqlite") as con:
        fps = float(con.execute("SELECT value FROM metadata WHERE key='fps'").fetchone()[0])
        last = pd.read_sql("SELECT MAX(frame) AS f FROM trajectory_data GROUP BY id", con).f / fps
    exits = pd.read_csv(f"ww/{run}_exits.csv").exit_id.value_counts().to_dict()
    print(f"{run.upper()}: RSET_last {last.max():.1f} s, "
          f"p95 {np.sort(last)[94]:.1f} s, exits {exits}")

C: RSET_last 57.6 s, p95 55.5 s, exits {'exit_B_right': 100}
U: RSET_last 57.6 s, p95 55.5 s, exits {'exit_B_right': 100}

RSET_last is the last agent out; p95 the 95th of 100. The clock starts at ignition. The run models no detection and no alarm, so RSET here is pre-movement plus travel: with no pre-movement, the agents move at ignition, which no standard timeline assumes. Add t_det and t_warn yourself (ISO/TR 16738:2009, Eq. 2, as on ASET and RSET).

If the run stopped at the time limit with people still inside, RSET_last prints the 270 s cap and exits counts the exit assigned to each agent, out or not. That is not an RSET; see Sensitivity arms.

Read the dose along the fire-free paths from U’s histories:

import pandas as pd

fed = pd.read_csv("ww/u_fed.csv")
smoke = pd.read_csv("ww/u_smoke.csv")
hist = fed.merge(smoke[["time_s", "agent_id", "extinction_per_m"]],
                 on=["time_s", "agent_id"])
hist["hcl_ppm"] = 900 * hist.fic  # HCl is the only irritant in this deck
per_agent = hist.groupby("agent_id").agg(
    max_fed=("fed_cumulative", "max"),
    max_fic=("fic", "max"),
    s_hcl300=("hcl_ppm", lambda v: int((v >= 300).sum())),
    s_k03=("extinction_per_m", lambda v: int((v >= 0.3).sum())),
)
print(per_agent.describe().loc[["50%", "max"]].round(2).to_string())
print(f"agents at HCl >= 300 ppm for at least 1 s: {(per_agent.s_hcl300 > 0).sum()}")

     max_fed  max_fic  s_hcl300  s_k03
50%     0.00     1.62       5.0   11.0
max     0.01    16.30      26.0   37.0
agents at HCl >= 300 ppm for at least 1 s: 83

The histories are written once per second, so s_hcl300 and s_k03 are seconds at HCl ≥ 300 ppm and at K ≥ 0.3 1/m. HCl = 900 × fic holds only because HCl is the only irritant of this deck (A crowd in a real fire › How the numbers are computed). The classic comparison uses no such dose: it compares location ASET with RSET only. The per-agent dose is extra post-processing, as on A crowd in a real fire › Each agent against its own limits.

The location ASET comes from the FDS output alone, so it is the same for every arm. The study uses four points of the location ASET table, times from ignition:

The K limit is the Engineers Australia visibility of 10 m with C = 3 (EA 2014, Fig. 8, Tenability Criteria – Short Exposure, p. 15). The HCl limits are ISO FEC 0.3 and 1. Every agent starts in the branch, so every agent passes the branch mouth and the junction.

2. What coupling adds

Two further arms let the fire act, one effect at a time.

Arm S, speed only. Smoke slows the agents, but each keeps the exit it took in U. --replay-exits reads U’s exit history and pairs agents by origin and spawn order (#352):

uv run python run.py --scenario $SC --seed 4 --fds-dir "$FDS" \
    --no-enable-rerouting --disable-tenability --replay-exits ww/u_exits.csv \
    --output-sqlite ww/s.sqlite --output-exit-history ww/s_exits.csv

Replaying the exits of 100 agents from ww/u_exits.csv.
…
Simulation finished in 67.57 s (100/100 evacuated).

Arm R, speed and routing. The default coupled run. Smoke slows the agents and enters their route cost:

uv run python run.py --scenario $SC --seed 4 --fds-dir "$FDS" \
    --disable-tenability \
    --output-sqlite ww/r.sqlite --output-exit-history ww/r_exits.csv

Simulation finished in 56.41 s (100/100 evacuated).

C and R print Reroute debug lines; they do not affect the result.

--disable-tenability in S and R records FED and FIC but lets nobody be incapacitated, so that everyone leaves and RSET stays defined. It also turns off --enable-fic-speed (Usage). The study adds incapacitation and the HCl slowdown as separate arms (below).

Run the RSET snippet above with ("c", "u", "s", "r"):

C: RSET_last 57.6 s, p95 55.5 s, exits {'exit_B_right': 100}
U: RSET_last 57.6 s, p95 55.5 s, exits {'exit_B_right': 100}
S: RSET_last 67.5 s, p95 63.9 s, exits {'exit_B_right': 100}
R: RSET_last 56.4 s, p95 54.5 s, exits {'exit_A_left': 100}

In this seed smoke slows S by 10 s. R is 1.2 s faster than U; across seeds that sign is not resolved (below). Against S, which keeps exit B, R is faster because every agent went to the far exit A and avoided B’s smoke. One seed says little: the study below runs 20 seeds with no pre-movement and 10 each with 30 and 60 s.

Reading the arms. U → S isolates the effect of smoke on speed. S → R isolates routing. R against R-na, the same run with the route cost’s look ahead in time off, isolates that look ahead.

Evacuation over time

Agents out (of 100) against time since ignition [s], median over seeds (line) and min–max (band); n = 20 seeds with no pre-movement, 10 at 30 and 60 s. Dotted: location ASET for K ≥ 0.3 1/m at exit B, the junction and exit A. Exit times from the trajectory at 0.1 s. Regenerated by scripts/docs/fire_blind_vs_coupled.py.

The last agent out, median [min, max] over seeds, seconds from ignition:

Exit usage

Agents leaving by exit A [%], bar: median over seeds, dots: one seed each. Exit A is 20 m from the junction, exit B 10 m. Regenerated by scripts/docs/fire_blind_vs_coupled.py.

C, U and S send everyone to exit B, the nearer one. R sends 100 % [99, 100] to exit A with no pre-movement, 88 % [81, 94] at 30 s and 84 % [78, 89] at 60 s. The initial exit is chosen in _assign_initial_exit (scenario.py), and R’s route cost prices the smoke each route meets on the way. With foresight on (the default "anticipate": true of RouteCostConfig, route_graph.py), the cost reads the smoke at the time the agent would arrive at each point (_arrival_time), from the whole FDS record (#125). No occupant could perceive that. With the look ahead off (R-na), the cost still reads the current smoke along the whole route, including parts no occupant could see, and agents still end at exit A in the same proportions.

Pre-movement does not simply add

RSET_last [s from ignition] against constant pre-movement [s], seeds shared by all three pre-movements (n = 10). Thick: median; faint: one seed. Dashed: slope 1 through U at 0 s. S and R are drawn slightly left and right of the tick to keep the markers apart. Regenerated by scripts/docs/fire_blind_vs_coupled.py.

For the same seed, RSET(pre) − pre − RSET(0) is exactly 0.00 s for U and C in every seed. That follows from how the run is built: the pre-movement is constant, everyone starts together, and nothing reacts to the fire. S adds 29.9 s more than the pre-movement at 30 s and 61.8 s more at 60 s; R adds 24.7 s and 75.4 s (medians). The fire grows while people wait, so a later start meets thicker smoke. An uncoupled run cannot show that: waiting longer only shifts its curve.

3. Is the uncoupled run conservative here?

What “conservative” means. The decision rests on whether ASET exceeds RSET by an adequate margin (ISO/TR 16738:2009, Eq. 1 and §5.6, as quoted on ASET and RSET). U is conservative relative to another arm X if its error makes the margin look smaller than X does. The reference is a model, R or S, not reality. R’s route cost looks ahead in time, so R-na, without that look ahead, is a second model reference. It is not a perceptual one: it still reads the smoke along the whole route.

Counts below are seeds (or agents) in which U is above, equal to, or below X. With 10 seeds, 10 of one sign gives a two-sided sign-test p of 0.002; with 20, 20 of one sign gives 2 × 10⁻⁶. The page runs many such tests, so treat p near 0.05 as no evidence.

RSET

RSET_last difference per seed [s], same seed in both arms. Above 0: U gets out earlier. Black bar: median. Regenerated by scripts/docs/fire_blind_vs_coupled.py.

• Against S, U is not conservative at any pre-movement: smoke slows people, and U leaves that out.
• Against R, U is not conservative at 30 and 60 s. With no pre-movement the direction is not resolved: R is later than U in 14 of 20 seeds on the last agent out, and in 15 of 20 on p95. The median gap, 2.4 s, is below the seed-to-seed spread of U itself.
• The gap grows with pre-movement, for R − U from a few seconds to about 80 s and for S − U from 18 s to 85 s, because the fire grows while people wait.
• R against S: R is faster in 20 of 20 seeds with no pre-movement, by avoiding exit B’s smoke; in 9 of 10 at 30 s (p = 0.02, weak by the rule above); and in 6 of 10 at 60 s (not resolved).

ASET − RSET at fixed points

Location ASET − RSET_last [s] at four fixed points, the same points for every arm; marker: median over seeds, line: min–max. Right of 0: the last agent is out before the limit is met there. Regenerated by scripts/docs/fire_blind_vs_coupled.py.

Seeds in which the margin is positive (pass), at exit B / junction / branch mouth / exit A:

• Visibility fails in every arm, seed and pre-movement; FED 0.3 passes in every seed of U, S, R and R-na. For these criteria the arm changes the size of the margin, not the verdict. R+FIC at 30 and 60 s is undetermined for FED 0.3: its RSET is censored (Sensitivity arms).
• HCl with no pre-movement is knife-edge. U’s median margin at the junction under HCl 1000 ppm is about +2 s (59 − 56.9), inside the seed spread. So a single uncoupled run can give either verdict. The coupled arms pass less often at this level (36 point-passes in U, 30 in R, 17 in R-na, 4 in S), and R keeps most of U’s. U is the more cautious arm in one cell only: at the branch mouth under HCl 1000 ppm, R passes in 20 of 20 seeds and U in 19.
• These flips sit mostly at HCl 1000 ppm (ISO FEC 1, an incapacitation-level value), not at the design value FEC 0.3, and the HCl in this deck is probably overestimated (see Limits).

People inside when the junction reaches the visibility limit (24 s): with no pre-movement a median of 72 in U, 74 in S, 83 in R and 92 in R-na; U has fewer than R in 20 of 20 seeds (median 11 fewer). At 30 and 60 s all 100 are inside in every arm. So U is not conservative on this count.

Dose

Share of agents with a value ≤ x, pooled over seeds (2,000 agents with no pre-movement, 1,000 at 30 and 60 s). Curve further right: more dose. Values until each agent’s exit, at z = 2.0 m (the deck’s only slice height; the 1.6 m default resolves to it, see A crowd in a real fire › The fire), 1 s resolution. Seconds at K ≥ 0.3 1/m are secondary: obscuration alone is not treated as incapacitating for people who are not performing tasks (ISO 13571:2012, §4.5, note). Regenerated by scripts/docs/fire_blind_vs_coupled.py.

Per seed, U against R. R-na is identical to R at 30 and 60 s; with no pre-movement it differs (for example, U has fewer seconds at HCl ≥ 300 ppm than R-na in 15 of 20 seeds).

• Against R, “conservative” depends on the metric. U over-states the peak FIC in every seed: U walks into exit B’s HCl, which R avoids. At 30 and 60 s U under-states the time above both HCl levels and the max FED in every seed, because R walks longer in thicker smoke.
• Against S, U under-states the run totals in every seed, at every pre-movement: agent-seconds at HCl ≥ 300 and ≥ 1000 ppm and at K ≥ 0.3 1/m, and max FED. On single agents it does not always: U’s peak FIC is higher than S’s for 605 of 2,000 agents with no pre-movement, 257 of 1,000 at 30 s and 239 of 1,000 at 60 s.
• The largest max FED is 0.25 in U, S and R. That is not a statement of tenability: FED 0.3 is a threshold for susceptible people, and FED < 1 does not mean safe (Incapacitation thresholds).

Per-agent margin, first crossing of K 0.3 1/m minus the agent’s own exit, compared on the same agent (seed, origin, spawn order):

With no pre-movement, 983 agents cross the limit in U but not in R, and 4 the other way round. Counting an agent that never crosses as having an infinite margin, R has the larger margin for 1,215 agents and U for 672. So with no pre-movement the direction depends on how agents who never cross are counted; at 30 and 60 s U’s margin is larger (not conservative) for 879 and 987 of 1,000 agents.

Is exit usage conservative?

Exit usage is not conservative or otherwise. Choosing exits is part of the scenario: each design fire scenario is analysed with design occupant scenarios, and the occupants’ initial route choice is one of the variables of such a scenario (Nilsson and Fahy 2016, pp. 2047, 2061). Here the difference is large: exit B for everyone without the fire, exit A for 84–100 % with it. It also drives the dose differences above.

Sensitivity arms

mkdir -p ww/na
cp assets/t_junction/geometry.wkt ww/na/
uv run python - <<'EOF'
import json
from pathlib import Path

config = json.loads(Path("assets/t_junction/config_initial_pre0.json").read_text())
config["routing"]["anticipate"] = False
Path("ww/na/config_initial_pre0.json").write_text(json.dumps(config, indent=2))
EOF
uv run python run.py --scenario ww/na/config_initial_pre0.json --seed 4 \
    --fds-dir "$FDS" --disable-tenability \
    --output-sqlite ww/rna.sqlite --output-exit-history ww/rna_exits.csv

Simulation finished in 63.06 s (100/100 evacuated).

4. Run the whole study

uv run python scripts/docs/fire_blind_vs_coupled.py --data "$FDS" --runs RUNS

RUNS must lie outside the repository. The script runs arms C, U, S, R, R-na, R-det, R-prob and R+FIC for seeds 4–23 with no pre-movement and 4–13 at 30 and 60 s, one run.py process per arm and seed (#198). It skips runs that already exist, prints every number on this page, writes summary_runs.csv and summary_agents.csv into RUNS, and redraws the figures in site/static/images/fire-blind/. The 320 runs took 43 min of single-process time (11 min on 4 workers); the analysis alone takes about 30 s. Seeds 1–3 were used for a pilot and are left out. The maintainers keep the runs in their data store, fds-evac-data/t_junction/fire_blind_runs/.

Limits

• One fire with no margin. Here, at every point, the visibility limit is met before the last person gets out, in every arm. Schröder et al. (2020, §4) expect the fire’s effect on route choice and speed to play a secondary role only while the safety margin is well above the limit. That is the regime in which practice decides, and this study does not test it.

• The size of the S − U and R − U gaps is not measured behaviour. The smoke-speed law is fitted to Frantzich and Nilsson’s data, K ≈ 1.9–7.4 1/m (read from their Fig. 14; see walking speed in smoke), and has a floor of 0.1 from K = 11.1 1/m. Share of moving agent-seconds below / within / above that range, and at the floor:

  Arm	pre-movement 0 s	30 s	60 s
  S	80 / 14 / 6 %, floor 3 %	37 / 37 / 26 %, floor 14 %	1 / 40 / 60 %, floor 25 %
  R	90 / 10 / 0 %, floor 0 %	39 / 55 / 6 %, floor 2 %	1 / 51 / 48 %, floor 6 %

  Below 1.9 1/m the law is outside the data too. There it slows people by 2.4 % at K = 0.3 1/m, the visibility limit, rising to about 15 % at 1.9 1/m.

  

  Left: speed factor v/v₀ [-] against K [1/m] of the default law; shaded: the data range. Right: K at the moving agent [1/m], share of agent-seconds [%], pooled over all three pre-movements; the last bin holds K ≥ 24.5. “At the floor” counts K ≥ 11.1 1/m. Regenerated by scripts/docs/fire_blind_vs_coupled.py.

• Route foresight. R’s route cost reads the smoke ahead from the whole FDS record (#125). R’s avoidance of exit B is therefore not a claim that people would see it coming. R-na removes only the look ahead in time: it still reads the current smoke along the whole route, including parts no occupant could see, and it gives the same exits.

• HCl is probably overestimated. The deck has no HCl loss to walls (A crowd in a real fire › What this does not show). That makes the HCl crossings early and inflates R+FIC.

• The HCl slowdown is opt-in, off in S and R, and incapacitation uses the FDS+Evac FED (FDS+Evac has no irritant slowdown), not HCl.

• Constant pre-movement. Everyone waits the same 0, 30 or 60 s. The three values were fixed from the fire before any run: 0 s moves before the junction reaches the visibility limit (24 s), 30 s falls between the first and last of the six points of A crowd in a real fire (18–46 s), 60 s after all of them.

• Everyone knows both exits (familiarity: "full"). Agents who discover exits could fail to find one, and the familiarity draw depends on the JuPedSim id (#198). For sign loss in this fire, see A crowd in a real fire.

• The time limit is 270 s, 30 s before the end of the FDS output. Route foresight samples ahead of the current time and can read past the end (#356); the longest route, 30 m from the branch to exit A, takes 23 s at the 1.3 m/s the cost assumes. Configured waypoints are not included in that bound.

• Per agent goes beyond ISO 13571, which treats populations, not individuals (§5.2). The FED is the FDS+Evac FED, not the ISO asphyxiant FED.

• The ASET side is not built in. The location ASET and the crossings are computed by the script, not by the engine (#210).

What next

• Usage › Smoke-blind runs and exit replay: every flag of the three arms.
• How do I get the egress time from an ensemble? for RSET over many seeds.
• ASET and RSET for the concepts.
• The Schröder room: arm U only, as ASET − RSET maps.