Spaces:
Running on Zero
Running on Zero
| """A task from a real day: the line as it really stood at `start`, every run that leaves before `end`, the closures. | |
| The state at `start` comes from the 2025 record: | |
| a train running then is placed where its actual departure from its last stop puts it (passing points by the | |
| minimum running times); it keeps its real delay | |
| a train set standing at a terminal is ready `turn_min` after its last run's actual arrival | |
| Everything after `start` is decided by the plan; the record's later times are kept only to score what the real | |
| dispatchers did (`reference.real`). | |
| A window is refused (`None`) when it cannot be rebuilt honestly: a run before `start` was cancelled or cut short in | |
| the record (its train is then not where the schedule says), or the plain timetable already conflicts inside it. | |
| """ | |
| from __future__ import annotations | |
| from .check import evaluate, network | |
| from .data import Day, Service, load_day | |
| from .model import RULES, Closure, Order, Run, Task, Unit, hhmm | |
| from .network import Network, load_network | |
| # causes after which the train involved is itself out of service (it blocks the section until the line reopens) | |
| FAILURES = ("broken down train", "collision", "defective train", "a collision", "an accident") | |
| def _actual(svc: Service, code: str) -> tuple[int | None, int | None, bool]: | |
| """(actual arrival, actual departure, cancelled) at a stop of the record.""" | |
| for st in svc.stops: | |
| if st.code == code: | |
| return st.aa, st.adep, (st.arr_cxl or st.sa is None) and (st.dep_cxl or st.sd is None) | |
| return None, None, True | |
| def _is_failure(net: Network, r: Run, served: list[str], closed: list[Closure]) -> bool: | |
| """The run that broke down (or collided): cut short by a failure closure, last served next to the closed span.""" | |
| for c in closed: | |
| if not any(f in c.cause.lower() for f in FAILURES): | |
| continue | |
| lo, hi = sorted((net.index[c.where[0]], net.index[c.where[-1]])) | |
| last = served[-1] if served else r.origin | |
| if lo - 1 <= net.index[last] <= hi + 1: | |
| return True | |
| return False | |
| def _served_in_record(svc: Service) -> list[str]: | |
| return [st.code for st in svc.stops if not ((st.arr_cxl or st.sa is None) and (st.dep_cxl or st.sd is None))] | |
| def _place(net: Network, r: Run, svc: Service, start: int, closed: list[Closure]): | |
| """Where a run is at `start`, from the record: None (it was cut short before `start`: the window cannot be | |
| rebuilt), ("done", actual arrival), ("future", None), or (fixed_to, fixed_arr, fixed_from, stuck).""" | |
| last_t = last_i = None | |
| stop_at = len(r.route) - 1 # the first stop it had not reached by `start` | |
| for i, code in enumerate(r.route): | |
| if not r.stops[i]: | |
| continue | |
| aa, ad, cxl = _actual(svc, code) | |
| t_sched = r.arr[i] if r.arr[i] is not None else r.dep[i] | |
| if cxl: | |
| if t_sched < start: | |
| return None | |
| stop_at = i | |
| break | |
| if i > 0 and (aa is None or aa > start): | |
| stop_at = i | |
| break | |
| if i == len(r.route) - 1: | |
| return ("done", aa) | |
| if ad is None or ad > start: | |
| return ("future", None) if i == 0 else (i, aa, None, False) | |
| last_t, last_i = ad, i | |
| if last_i is None: | |
| return ("future", None) | |
| t = last_t | |
| for i in range(last_i, stop_at): | |
| nxt = t + r.seg[i] | |
| if r.arr[i + 1] is not None: | |
| nxt = max(nxt, r.arr[i + 1]) | |
| sec = net.section(r.route[i], r.route[i + 1]) | |
| for c in closed: | |
| lo, hi = sorted((net.index[c.where[0]], net.index[c.where[-1]])) | |
| if lo <= sec < hi and c.start <= start < c.end and t < c.start: | |
| return (i + 1, max(start, c.end + max(0, nxt - c.start)), t, True) # caught in the closed section | |
| if nxt >= start or i + 1 == stop_at: | |
| return (i + 1, max(start, nxt), t, False) | |
| t = nxt | |
| return ("done", t) | |
| def build_task(date: str, start: int, end: int, closures: list[Closure] | None = None, *, task_id: str = "", | |
| split: str = "train", difficulty: str = "standard", notices: list[str] | None = None, | |
| disruptions: list[dict] | None = None, rules: dict | None = None, | |
| lookback: int = 150, why: list | None = None) -> Task | None: | |
| why = why if why is not None else [] | |
| net = load_network() | |
| day = load_day(date) | |
| rules = {**RULES, **(rules or {})} | |
| turn = rules["turn_min"] | |
| closures = list(closures or []) | |
| closed = [c for c in closures if c.kind == "closed"] | |
| runs: list[Run] = [] | |
| units: list[Unit] = [] | |
| notes = list(notices or []) | |
| real_runs: dict[str, dict] = {} | |
| failed = None # (unit, run, last stop): the train that broke down | |
| for chain in day.chains: | |
| u_runs: list[Run] = [] | |
| at, ready, after = None, None, None | |
| last_hist: Service | None = None | |
| for rid in chain: | |
| r0 = day.runs[rid] | |
| svc = day.services[rid] | |
| sched_dep = r0.dep[0] | |
| if sched_dep < start - lookback: # long before the window: history | |
| last_hist = svc | |
| at, ready = r0.dest, None | |
| aa, _, cxl = _actual(svc, r0.dest) | |
| if aa is not None and not cxl: | |
| ready = aa + turn | |
| continue | |
| if last_hist is not None: | |
| if last_hist.full_cxl or last_hist.part_cxl: | |
| why.append(f"{last_hist.train} (before the window) was cut short: its train is not where the " | |
| f"schedule says") | |
| return None | |
| last_hist = None | |
| if sched_dep >= end: | |
| after = {"run": rid, "station": r0.origin, "dep": sched_dep, "stops": r0.n_stops} | |
| break | |
| if svc.full_cxl or svc.part_cxl: | |
| served = _served_in_record(svc) | |
| cut_before = [c for c in r0.route if r0.stops[r0.route.index(c)] and c not in served] | |
| early = [c for c in cut_before if (r0.arr[r0.idx(c)] or r0.dep[r0.idx(c)]) < start] | |
| if early: | |
| if failed is None and _is_failure(net, r0, served, closed): | |
| failed = (r0.unit, rid, served[-1] if served else r0.origin) | |
| u_runs = [] | |
| break | |
| why.append(f"{rid} was cut short before the window ({', '.join(early)})") | |
| return None | |
| r = Run(**{**r0.__dict__}) | |
| r.route, r.stops, r.arr, r.dep, r.seg = list(r0.route), list(r0.stops), list(r0.arr), list(r0.dep), list(r0.seg) | |
| placed = _place(net, r, svc, start, closed) | |
| if placed is None: | |
| why.append(f"{rid}: a stop before the window was cancelled") | |
| return None | |
| if isinstance(placed, tuple) and placed[0] == "done": | |
| at, ready = r.dest, max(start, placed[1] + turn) | |
| continue | |
| if isinstance(placed, tuple) and placed[0] == "future": | |
| u_runs.append(r) | |
| elif isinstance(placed, tuple): | |
| fixed_to, fixed_arr, fixed_from, stuck = placed | |
| if u_runs: # a later run of the same set cannot be running already | |
| why.append(f"{rid} is running but an earlier run of its set {r.unit} has not") | |
| return None | |
| r.fixed_to, r.fixed_arr, r.fixed_from, r.stuck = fixed_to, fixed_arr, fixed_from, stuck | |
| u_runs.append(r) | |
| at, ready = None, None | |
| real_runs[rid] = _real(r, svc, start) | |
| if not u_runs or (failed and u_runs[0].unit == failed[0]): | |
| continue | |
| if u_runs[0].started: | |
| at, ready = None, None | |
| else: | |
| if at is None: | |
| at = u_runs[0].origin | |
| ready = start if ready is None else max(start, ready) | |
| units.append(Unit(id=u_runs[0].unit, runs=[r.id for r in u_runs], at=at, ready=ready, after=after)) | |
| runs += u_runs | |
| if not runs: | |
| why.append("no runs") | |
| return None | |
| if failed: | |
| c = closed[0] | |
| notes.insert(0, f"Train {failed[1]} broke down after {failed[2]} and is stuck in {c.where[0]}-{c.where[-1]}; " | |
| f"its train set is out of service for the rest of the window, so its later runs are already " | |
| f"cancelled and are not yours to plan.") | |
| task = Task(task_id=task_id or f"{date}-{hhmm(start).replace(':', '')}", split=split, line="GN-LW", day=date, | |
| start=start, end=end, network=net.to_dict(), runs=runs, units=units, closures=closures, notices=notes, | |
| disruptions=list(disruptions or []), difficulty=difficulty, reference={}, rules=rules) | |
| # the plain timetable (no delays, no closures) must be conflict-free in the window | |
| calm = Task.from_dict({**task.to_dict(), "closures": []}) | |
| for r in calm.runs: | |
| r.fixed_to, r.fixed_arr, r.fixed_from, r.stuck = 0, None, None, False | |
| for u in calm.units: | |
| first = calm.run(u.runs[0]) | |
| u.at, u.ready = first.origin, None | |
| calm_res = evaluate(calm, {}) | |
| if not calm_res.feasible: | |
| why.append("the plain timetable conflicts in the window: " + calm_res.violations[0]["detail"][:160]) | |
| return None | |
| task.reference["real"] = _real_cost(task, real_runs) | |
| return task | |
| def _real(r: Run, svc: Service, start: int) -> dict: | |
| """What really happened to a run: actual arrivals at the stops it served, and the stops it did not.""" | |
| arr, unserved = {}, 0 | |
| for i, code in enumerate(r.route): | |
| if not r.stops[i]: | |
| continue | |
| aa, ad, cxl = _actual(svc, code) | |
| if cxl: | |
| unserved += 1 | |
| elif i > 0 and aa is not None: | |
| arr[code] = aa | |
| return {"arr": arr, "unserved": unserved, "cancelled": svc.full_cxl, "short": svc.part_cxl and not svc.full_cxl} | |
| def _real_cost(task: Task, real_runs: dict[str, dict]) -> dict: | |
| """The record's outcome scored with the task's cost (delays at served stops reached after `start`, cancel cost | |
| for unserved stops). It is what Arriva and ProRail did with their information; it need not obey this model.""" | |
| delay = unserved = cxl = short = 0 | |
| for r in task.runs: | |
| x = real_runs.get(r.id) | |
| if x is None: | |
| continue | |
| for i, code in enumerate(r.route): | |
| if r.stops[i] and code in x["arr"] and x["arr"][code] >= task.start and r.arr[i] is not None: | |
| delay += max(0, x["arr"][code] - r.arr[i]) | |
| unserved += x["unserved"] | |
| cxl += bool(x["cancelled"]) | |
| short += bool(x["short"]) | |
| return {"cost": delay + task.rule("cancel_cost") * unserved, "delay": delay, "unserved_stops": unserved, | |
| "cancelled": cxl, "short_turned": short} | |