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}"