Spaces:
Running on Zero
Running on Zero
File size: 6,746 Bytes
31252db | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 | """Disruptions and tiers: what can go wrong on the line, from the 2025 record, and how tasks are drawn.
A disruption in the Rijden de Treinen record has a cause, a start, an end and the stations it was linked to. Its
effect in the model depends on the cause (an assumption, stated in SOURCE.md):
broken down train, collision, emergency call, defective track, person or animal on the track, power failure
-> the sections between the outermost stations named are closed for the whole disruption
signal failure, level crossing failure
-> trains run on sight there: every section in the span takes `SLOW_EXTRA` minutes longer
points failure
-> one track out of use at the passing station(s) in the span (no crossing there if it had two)
A disruption linked to every station of the line has no usable location; such causes are replayed on a section
drawn with the task's seed.
"""
from __future__ import annotations
import random
from .model import Closure
from .network import Network
SLOW_EXTRA = 4
CLOSE = ("broken down", "collision", "emergency", "defective railway track", "person", "animal", "power failure",
"damaged", "fire", "accident", "vandalism", "copper theft")
SLOW = ("signal", "level crossing")
POINTS = ("points",)
LOOPS = ("HDG", "FWD", "BP", "ZH")
def effect(cause: str) -> str:
c = cause.lower()
if any(k in c for k in POINTS) and not any(k in c for k in SLOW):
return "track"
if any(k in c for k in SLOW):
return "slow"
return "closed"
def span(net: Network, codes: list[str]) -> list[str] | None:
"""[west, east] of the stations named, or None when the record names (nearly) the whole line."""
idx = sorted(net.index[c] for c in codes if c in net.index)
if len(idx) < 2 or (idx[0] == 0 and idx[-1] == len(net.points) - 1 and len(idx) >= 8):
return None
return [net.points[idx[0]].code, net.points[idx[-1]].code]
def closures_for(net: Network, cause: str, codes: list[str], start: int, end: int, rng: random.Random,
real: bool = True) -> list[Closure]:
kind = effect(cause)
where = span(net, codes)
if where is None: # no location in the record: draw one
where = _draw_span(net, kind, rng)
if kind == "track":
lo, hi = net.index[where[0]], net.index[where[-1]]
loops = [p.code for p in net.points[lo:hi + 1] if p.code in LOOPS] or [rng.choice(LOOPS)]
return [Closure("track", [c], start, end, cause=cause, real=real) for c in loops[:1]]
if kind == "slow":
return [Closure("slow", where, start, end, extra=SLOW_EXTRA, cause=cause, real=real)]
return [Closure("closed", where, start, end, cause=cause, real=real)]
def _draw_span(net: Network, kind: str, rng: random.Random) -> list[str]:
stations = [p.code for p in net.points if p.kind != "junction"]
if kind == "track":
c = rng.choice(LOOPS)
return [c, c]
i = rng.randrange(len(stations) - 1)
j = min(len(stations) - 1, i + rng.choice((1, 1, 2)))
return [stations[i], stations[j]]
# ---------------------------------------------------------------- tiers and candidates
import csv
from datetime import date as _date
from functools import lru_cache
from .data import LINE_DIR, days as _days, disruptions as _real_disruptions
from .model import hhmm
# Eval days lie in these ISO weeks of 2025 (42 days); train days are every other day of January-June.
HELD_OUT = {4, 7, 11, 17, 22, 25}
PEAKS = [(6 * 60 + 30, 9 * 60), (15 * 60 + 30, 18 * 60 + 30)]
LATE_CAUSES = ("a technical inspection", "a late driver", "a door fault being fixed", "a cleaning crew overrun",
"coupling problems")
TIERS = {
# window minutes; what is seeded (each disruption's cause and duration drawn from the 2024-2025 record)
"real": dict(window=(150, 210)), # the record's own disruption, on its own day
"blockage": dict(window=(150, 210), closed=1, late=(0, 1)),
"loop": dict(window=(150, 210), track=1, slow=(0, 1), late=(0, 1)),
"compound": dict(window=(180, 240), closed=1, track=(0, 1), slow=(0, 1), late=(1, 3)),
}
def split_of(day: str) -> str:
return "eval" if _date.fromisoformat(day).isocalendar()[1] in HELD_OUT else "train"
def split_days(split: str) -> list[str]:
return [d for d in _days() if split_of(d) == split]
@lru_cache(maxsize=1)
def profiles() -> list[dict]:
with open(LINE_DIR / "disruption_profiles.csv", encoding="utf-8") as f:
rows = [r for r in csv.DictReader(f) if r["duration_minutes"]]
for r in rows:
r["effect"] = effect(r["cause_en"])
r["minutes"] = max(10, min(240, round(float(r["duration_minutes"]))))
return rows
def real_disruptions(split: str | None = None) -> list[dict]:
"""The record's own disruptions on the line, as (day, start, end, cause, stations)."""
out = []
for d in _real_disruptions():
day = d["start_time"][:10]
if split and split_of(day) != split:
continue
hh, mm = int(d["start_time"][11:13]), int(d["start_time"][14:16])
start = hh * 60 + mm
dur = round(float(d["duration_minutes"] or 0))
if dur < 15 or not 5 * 60 <= start <= 22 * 60:
continue
out.append({"day": day, "start": start, "end": start + dur, "cause": d["cause_en"],
"stations": [c.strip() for c in d["rdt_station_codes"].split(",")]})
return out
def draw(rng: random.Random, kind: str) -> dict:
pool = [p for p in profiles() if p["effect"] == kind] or profiles()
return rng.choice(pool)
def seeded_closures(net: Network, tier: str, start: int, window: int, rng: random.Random) -> tuple[list, list[str]]:
"""Closures for a seeded tier, starting within the first half hour of the window."""
r = TIERS[tier]
out: list[Closure] = []
def count(key):
v = r.get(key, 0)
return rng.randint(*v) if isinstance(v, tuple) else v
for kind, key in (("closed", "closed"), ("track", "track"), ("slow", "slow")):
for _ in range(count(key)):
p = draw(rng, kind)
t0 = start + rng.choice((0, 0, 5, 10, 20, 30))
minutes = min(p["minutes"], window - 20) if kind == "closed" else p["minutes"]
codes = [c.strip() for c in p["rdt_station_codes"].split(",")]
where = span(net, codes) or _draw_span(net, kind, rng)
out += closures_for(net, p["cause_en"], where, t0, t0 + minutes, rng, real=False)
notes = []
return out, notes
def candidate_id(day: str, start: int, window: int, tier: str, seed: int) -> str:
return f"gnlw-{day}-{hhmm(start).replace(':', '')}-{window}m-{tier}-{seed}"
|