Skip to content

Running a sweep end to end

Jip Claassens edited this page Sep 15, 2026 · 1 revision

Running a sweep end to end

In one sentence: the practical how-to for producing pharmacy results — which script to run for which kind of rerun, what each reads and writes, how to resume when a worker dies, how long to wait, and how to tell from the log whether it worked.

Where this sits: the whole chain GeoDMS → Arrow → Julia LP → sweep → rounding → scenarios, as operations, stopping where the deck begins. The method is in The lambda sweep and the Pareto frontier and Scenarios S1 S2 S3; the GeoDMS configuration in GeoDMS OD matrix and choice set; the log format in Log lines and output files; the deck in Deck and charts pipeline. As of September 2026 (commit e25416b).

The shape of the job

Three engines hand each other files on disk: GeoDMS builds the network and the OD table (Glossary) for one study area and one side — ExistingPharmacies (the baseline ★) or NewPharmacies (the candidates); Julia sweeps λ, rounds and pins S1/S2 from both sides' Arrow files (The pipeline in plain words); Python/Node in doc/ turn the logs — one per area and cost function — into the deck. Runners skip a step when its output file exists. The GeoDMS half takes seconds to minutes per area; the Julia sweep minutes to hours and is the entire bill (country-level Poland: 32 h).

Two facts to hold on to:

  • The study area is an environment variable, STUDY_AREA, not a file edit. cfg/main/ModelParameters.dms reads Expand(., '%env:STUDY_AREA%') and falls back to StudyArea_default = 'ITG' (around line 22–26), so several consoles can run different areas from one checkout — and an interactive GeoDMS session without the variable loads ITG (Italy's islands, Chris's default since 79cb58b), not the Netherlands (GeoDMS OD matrix and choice set).
  • The Julia exit code tells you nothing. lambda_sweep_simplex.jl wraps each area in a try/catch, prints <area> — failed: … and moves on, exiting 0 (around line 551–559). Success is judged by grepping the log.

Prerequisites

  • GeoDMS 20.19.1.m — the .bat default for GEODMS_EXE (run_pharmacy_pipeline.bat around line 76). Since d80622d the read-only .mmd holder uses the 20.19 contract (Templates.dms around line 329–339), verified on 20.19.1.m only; 20.19 also reads Finland's GeoParquet (#44). Never point at the engine build tree C:\dev\GeoDMS_2026 — half-relinked DLLs (c368a01).
  • Registry LocalDataDir = C:\LocalData — Julia hard-codes C:\LocalData\networkmodel_eu (settings.jl around line 3–5); nothing checks that the two engines agree.
  • NetworkModelDataDir (default %SourceDataDir%/NetworkModel_EU, cfg/main.dms around line 30) — the source share, not in git: TomTom streets and per-area subsets Infrastructure/TomTom/<Area>/NW2021_SP_streets_subset.mmd, the Ardeco 2021 population raster, NUTS shapefiles, Locations/pharmacies/<iso3>_pharmacies.parquet.
  • Julia (Arrow, JuMP, HiGHS) on PATH — Installation of Julia (Julia 1.12.5, HiGHS 1.13.1 in the logs; no Project.toml); Python 3 + matplotlib, Node + pptxgenjs and PowerPoint for the deck.
  • The .ps1 files' Set-Location line — Maarten's E:\prj\JRC\NetworkModel_EU; edit it.

A fresh checkout holds code, configuration and parsed results, not the share, the Arrow exports or logs/; without the share you can regenerate the deck and nothing else (Branches data and environment).

The scripts at a glance

Paths are relative to the repository root; run the .ps1 files from a PowerShell there. Variables are in Knobs below.

Script Arguments Runs Writes
run_pharmacy_pipeline.bat [areas…] default France Italy Netherlands Sweden one GeoDmsRun per step, Existing side: network0 (street subset), network1, network2 (link sets), alloc (the three exports; GeoDMS OD matrix and choice set) ExistingPharmacies\<Area>_{od,i,j}.arrow, …\<Area>\Linkset_*.mmd, FinalSet_*.mmd; logs\<Area>_<step>.log
run_new_pharmacy_pipeline.bat [areas…] same the New side (STEPS defaults to network1 network2 alloc) NewPharmacies\…; the same log names, so the second side overwrites the first's log
run_new_country_sweeps.ps1 none — hard-coded list Existing alloc, New network1 network2 alloc, each skipped if <Area>_od.arrow exists; then both sweeps logs\sweep_<Area>_<FUNC>.log, logs\orchestrator_progress.log
run_rebuild_all.ps1 [-Areas a,b,c] [-Tag all] areas, else every region in doc/deck_data.json purge *set_O-1km* on both sides, then both .bat files; no sweeps scratch\rebuild_all_<Tag>.csv (exit code, seconds, bytes per side; rewritten after every area), logs\rebuild_all_<Tag>.log
run_realloc_all.ps1 [-Tag nuts] [-Skip Norway,SE2,SE3] skip list; areas from deck_data.json alloc only, both sides; throws if the skip filter matched nothing scratch\realloc_<Tag>.csv, logs\realloc_<Tag>.log
run_recalc_batch.ps1 -Areas a,b,c [-Threads 3] [-Tag q] areas (mandatory) purge → both pipelines → both sweeps logs\sweep_<Area>_<FUNC>.log, logs\recalc_<Tag>.log
run_resweep_batch.ps1 -Areas a,b,c [-Threads 3] [-Tag q] [-Funcs LINEAR,LOGISTIC] [-SkipComplete] [-RefineOnly] areas (mandatory) sweeps only logs\sweep_<Area>_<FUNC>.log or logs\refine_<Area>_<FUNC>.log, logs\resweep_<Tag>.log
run_one_sweep.sh <Area> <FUNC> one area, one function one sweep from Git Bash; no resume logic logs/sweep_<Area>_<FUNC>.log
make_descriptive_table.bat [areas…] default 47 areas (around line 36; no Iceland) /Analyses/Pharmacies/Descriptives/Table per area, then julia collect_descriptives.jl …\Pharmacies_Descriptives\<Area>.arrow (fixed path, Analyses.dms around line 86), logs\descr_<Area>.log, doc\pharmacy_descriptives.csv, …_nuts1.csv
julia export_s1s2_locations.jl [areas…] default: every <Area>_j.arrow on the New side joins each S1/S2 assignment.arrow to <Area>_j.arrow `<S1S2_OUT><Area>_<s1
python parse_compare.py — console table over logs/sweep_*_<FUNC>.log stdout

Every PowerShell sweep runner launches cmd /c "julia --startup-file=no --threads=N lambda_sweep_simplex.jl > <log> 2>&1" — through cmd, so the log is the raw UTF-8 Julia writes. The parsers anchor on S1 — / S2 — (em dash) and Combined sweep; a log redirected by Windows PowerShell 5.1 is UTF-16 and build_deck_data.py (encoding="utf-8", around line 71) finds no rows. Do the same by hand.

Recipe A — a new study area from scratch

Precedent: Hungary (#53) and Finland (#44).

  1. Data and lists. The pharmacy parquet goes to <NetworkModelDataDir>/Locations/pharmacies/<iso3>_pharmacies.parquet (lat/lon), and the country into the Country enum (bump range(0b, Nb), add Name and iso3 Code) and AvailableCountry (bump nrofrows) in cfg/main/SourceData/Locations.dms (around line 366–390). The area name must be the country shapefile's name_engl or a NUTS-1 code (ModelParameters.dms around line 26–31). Then add it to every per-area list — ORDER in doc/build_deck_data.py, the order lists in collect_descriptives.jl, STUDY_AREAS in make_descriptive_table.bat, doc/policy_typology.csv; commit 8963d27 ("Hungary in every per-area list") is the template.
  2. Street subset. If Infrastructure/TomTom/<Area>/NW2021_SP_streets_subset.mmd is not on the share (Hungary's and Finland's were), cut it: set STEPS=network0 then run_pharmacy_pipeline.bat <Area>. No orchestrator runs network0; the subset is side-independent and is cut once (why it is left to the Existing-side .bat is not recorded).
  3. Both sides. run_rebuild_all.ps1 -Areas <Area> -Tag <Area> — purges any stale network, runs network1 network2 alloc on both sides, records exit codes and sizes. Check for C:\LocalData\networkmodel_eu\{ExistingPharmacies,NewPharmacies}\<Area>_{od,i,j}.arrow. Do not use run_new_country_sweeps.ps1 here: it runs the Existing side with STEPS=alloc only, assuming that network exists.
  4. Descriptives — the "today's network" table on deck pages 3–6 (Metrics aggregation and ranking). make_descriptive_table.bat <Area> needs the Existing-side network and OD (road-based catchments since df77729, Analyses.dms around line 40–45; the bat's header "no network needed" is stale). The collector rewrites both CSVs over all areas present.
  5. Sweeps. run_resweep_batch.ps1 -Areas <Area> -Tag <Area> — both functions. Or by hand, from cmd:
    set COUNTRIES=<Area>
    set ROUNDING=multistart
    set TRAVEL_FUNC=LINEAR
    julia --startup-file=no lambda_sweep_simplex.jl > logs\sweep_<Area>_LINEAR.log 2>&1
    set TRAVEL_FUNC=LOGISTIC
    julia --startup-file=no lambda_sweep_simplex.jl > logs\sweep_<Area>_LOGISTIC.log 2>&1
    
    Keep each set on its own line: set TRAVEL_FUNC=LINEAR && julia … puts the trailing spaces into the value and settings.jl fails its FUNC_NAMES lookup.
  6. Check the logs (below), regenerate the deck, and julia export_s1s2_locations.jl <Area> for the location files.

Recipe B — re-sweep existing areas after a Julia change

Networks and ODs are unchanged, so only the Julia half reruns. Decide first what the change moves:

  • The frontier itself — anything in settings.jl (cost functions, BIG, exclusion rule), lp_run.jl (LP or rounding) or the grid: a full sweep, run_resweep_batch.ps1 -Areas a,b,c -Tag q1. Split the areas over several workers in separate console windows, biggest first (the July recalculation used seven, q1…q7).
  • Only where S1/S2 sit on an unchanged frontier — the case of issue #52: refine-only, run_resweep_batch.ps1 -Areas a,b,c -RefineOnly.

Refine-only (SWEEP_STOP_AFTER_REFINE=1) walks the grid LP-only until each bracket closes, pins S1 and S2 by bisection and stops before the tail where the big areas' time-outs live; how the walk, the brackets and the bisection work is on Scenarios S1 S2 S3 and Code walkthrough lambda_sweep_simplex. What matters here: it writes logs\refine_<Area>_<FUNC>.log, which build_deck_data.py merges into the old sweep's frontier when newer — honest only if that sweep used the same OD and candidate set; otherwise you get issue #54's kink (FRI), so sweep fully.

Then regenerate the deck; python parse_compare.py gives a one-screen comparison of every area's S1/S2 against the LP bound.

Recipe C — rebuild networks and ODs after a GeoDMS or config fix

The replan of 1–3 September 2026 (doc/replan_connectivity_fix.md), as executed:

  1. Smoke-test one area expected to move and one control (in practice ITG alone, by hand, in d80622d). Today: run_rebuild_all.ps1 -Areas ITG,Luxembourg -Tag smoke.
  2. Rebuild everything: run_rebuild_all.ps1 -Tag all. It purges Linkset_* and FinalSet_* first, because GeoDMS silently keeps an existing .mmd (doc/todo.md A1) and the cached FinalSet embeds the pharmacy-to-road connector links, so new pharmacy data invalidates the network too (#53: ITC failed on the cached network with DestNode_rel: out of range).
    • 2′ (instead of 2). If only the exports changed — a new column, as the nuts column for the NUTS region-exclusion rule of #49 — run_realloc_all.ps1 does alloc only, on both sides: the rule judges on the Existing-side client table but removes candidates on the New side (Scope rules and data gaps).
  3. Diff before you sweep: python scratch/diff_rebuild.py ranks areas by the change in OD byte size and in the baseline block (population, unreachable cells and residents, mean travel time) between the old sweep log and the rebuild (scratch/affected_areas.csv); ≈0 delta means no re-sweep. In September only ITG, PL8 and Portugal moved; 39 did not. It compares sizes and counts, not rows — how the small OD drift of #54 slipped through (Branches data and environment).
  4. Sweep the movers: run_resweep_batch.ps1 -Areas <movers> -Tag … in parallel workers. Country-level Poland is not in the 41-area aggregated frontier (Metrics aggregation and ranking) and may wait.
  5. make_descriptive_table.bat (the descriptives are network-derived), then the deck chain and export_s1s2_locations.jl.

Resuming an interrupted batch

Workers die. SE2's LINEAR sweep finished after 3 h 15 min, the worker died before LOGISTIC, and re-running the area redid LINEAR (7831d33, 3 September 2026). Since then:

  • -SkipComplete skips any (area, function) whose log already ends in a completed sweep: Test-SweepComplete (run_resweep_batch.ps1 around line 38–46) checks the text after the last Country: marker for scenario summary, so an older success cannot mask a later failure. A batch -Areas Denmark,Austria,Ireland that died during Austria LOGISTIC, relaunched with -SkipComplete: Denmark and Austria LINEAR are SKIPPED (already complete) (their S1/S2 folders untouched), Austria LOGISTIC is redone from scratch, Ireland runs both.
  • -Funcs LOGISTIC runs only the named function(s); a typo throws.
  • GeoDMS steps: run_new_country_sweeps.ps1 tests for <Area>_od.arrow before each side and skips it; run_rebuild_all.ps1 and run_recalc_batch.ps1 purge and rebuild unconditionally, so after a kill relaunch them with -Areas listing what is left (the rebuild CSV, rewritten after every area, tells you which).
  • Progress logs (logs\<runner>_<Tag>.log): timestamped, appended, echoed to the console.

The sweep runners overwrite logs\sweep_<Area>_<FUNC>.log (single >), whatever the 7831d33 message says about appending. A rerun also overwrites the S1\ and S2\ arrow folders and every w=… folder it visits; the ones it does not visit stay, and no folder records the subsampling factor, so #54 had to be diagnosed from the logs.

How long it takes

Sweep time follows LP size (N OD rows plus M candidates; Poland: 15.1 M and 90 941).

Stage Measured
Network + OD, both sides, one area 9 s (Luxembourg) to 174 s (FRG); 42 areas in 4 173 s ≈ 70 min sequentially with the purge (scratch/rebuild_all_all.csv, 1 Sep 2026, 32aca59 — "the 2 Sep rebuild" in the issues). The replan's ~0.4 h (July recalc_q* logs) is not explained — plan with 70 min
Full sweep, both functions (July 2026) ~81.5 h sequential for 42 areas; Poland 32.3 h (29 h LINEAR + 3.3 h LOGISTIC), ITF 7.5 h, ITH 6.7 h, Ireland 4.0 h, ITC 3.6 h, Austria 3.6 h, FRI 3.4 h, Denmark 2.8 h
Full sweep with the September tail-stop Italian areas 1.5–3 h each instead of 9–14 h (#52); SE2 LINEAR alone 3 h 15 min (7831d33)
Refine-only 35 s for Luxembourg LINEAR alone; 5 min (Luxembourg) to 4 h (Austria) per area × function with six workers sharing one machine (#52)
One LP solve seconds to minutes as a warm-start step (ITG LINEAR 4–8 s; FRC w = 0.1: 75 s); hours from a far basis (the same FRC solve timed out at 1 h); Poland near S1: 3–15 h (#52)
One rounding (three methods) 50–100 s per point on a mid-size area, against a 7–10 s LP at low λ (e25416b)

Each LP is a warm start from the previous basis (Glossary) under LP_TIME_LIMIT = 3 600 s (lp_run.jl around line 439). A timed-out point is skipped but leaves an aborted basis from which later points tend to time out too, so once S1 and S2 are pinned the first tail time-out ends the sweep (SWEEP_STOP_AFTER_TAIL_FAIL, default 1); why, and the IPM alternative, are on The lambda sweep and the Pareto frontier. A 4 h limit was tried for Poland and did not pin it.

Threading does not help. The driver is sequential by design ("No parallelism, no MAX_PARALLEL", lambda_sweep_simplex.jl around line 7) and sets no HiGHS threads option, so the runners' --threads=N is inert (inference); MAX_PARALLEL is read only by the superseded lambda_sweep.jl. Parallelism is several workers, each its own Julia process; RAM, not cores, limits how many ("32 cores available, keep modest for big-country RAM").

How to tell a run succeeded

GeoDMS step. The .bat prints -- step <s> OK on exit code 0; run_rebuild_all.ps1 records the code and the byte sizes of <Area>_od.arrow and <Area>_i.arrow (reference sizes in scratch/rebuild_all_all.csv; Netherlands New-side OD 37.7 MB). The GeoDMS /L log logs\<Area>_<step>.log has the same name for both sides, so only the New side's survives a paired run.

Julia sweep. Five strings, in this order (every other line: Log lines and output files):

grep for meaning
Country: <Area> (warm-start simplex) the banner; Test-SweepComplete searches from its last occurrence
S1 pinned at w=…: sum_y=… (target …), S2 pinned at w=…: cost_c=… (target …) the bisections closed — but compare the value with its (target …): bisect! prints "pinned" after 8 solves whether or not it got within 0.2 % (Denmark LOGISTIC: S2 "pinned" 9.5 % off, #52)
<Area> — scenario summary what every runner tests for
S1 arrows → …\S1 (w=…), S2 arrows → …\S2 (w=…) the stable folders GeoDMS SweepResults and export_s1s2_locations.jl read
FAILED / failed: must be absent inside a bracket

Bad signs: LP at w=… FAILED: … termination_status=TIME_LIMIT (a skipped point — tolerable in the tail, not inside a bracket); <Area> — failed: (an exception, including missing input files); Neither S1 … nor S2 … bracketed (no S1/S2 arrows written); … bracketed but not pinned in the coarse loop … post-hoc bisection (the fallback — check the residual).

Descriptives. logs\descr_<Area>.log, the .arrow row exists, and the area appears in the collect_descriptives.jl echo. An area missing from its order list is silently dropped from the CSV.

Cheap sanity checks after a run

There are no tests in the repository (doc/check_s1s2.py of #52 is in an unpushed commit), so check by hand against the log's Baseline (…) block — the baseline ★, today's network priced by the model (Scenarios S1 S2 S3).

  1. S1 count: the S1 block's sum_y is within 0.2 % of today's count, or one location, whichever is larger (REFINE_TOL = 0.002 on facilities used (cells), lambda_sweep_simplex.jl around line 335, 368). S2 travel: travel change (ph2) within ±0.2 % of zero (around line 372).
  2. Bounds: on every rounded row travel_multi ≤ min(travel_topp, travel_greedy) (lp_run.jl around line 223–225) and travel_relax + λ·sum_y ≤ travel_multi + λ·n_open — the LP is a floor for price-plus-travel, not for travel alone (From LP fractions to real pharmacies).
  3. Monotonicity: sum_y falls and travel_relax rises with w; a reversal means two different LPs were merged into one log (#54).
  4. Unreachable population: unreachable clients in the baseline should be near zero for a mainland area; hundreds of thousands is a connectivity or data problem, not policy headroom (Scope rules and data gaps).

Common failures and fixes

Symptom Cause Fix
GeoDmsRun not found / exit 2 wrong GEODMS_EXE install 20.19.1.m or set the variable
a spatial_reference error reading Finland (#44) Finland's parquet is a GeoParquet; GeoDMS 20.0 made a spatial_reference item that broke the union use 20.19 — no config change needed
FinalLinkSet/F2: Link_Node2_rel out of range or undefined at alloc on Norway, SE2, SE3 (#50) a closed junction-free loop with no connector links (an island ring road with no OD point), kept by the per-landbody rule fixed in 7086928; update an old checkout
DestNode_rel: out of range in the descriptives or alloc (#53) a stale cached FinalSet_*.mmd whose pharmacy connectors no longer match the data purge and rebuild (run_rebuild_all.ps1 -Areas …)
a GeoDMS run that never finishes on Iceland outside the Ardeco population grid; it hangs rather than errors (todo.md D10) leave it out; it has no study area
S1 … not bracketed at w_max the grid stops at SWEEP_WMAX (5.0 LINEAR, 0.5 LOGISTIC, around line 304); the wiki's "extended upward until S1 brackets" describes code removed in f93aea1 raise SWEEP_WMAX
every point after some w times out the aborted basis after the first time-out SOLVER=ipm (2b60d00) for big LINEAR areas at high λ; never on LOGISTIC, where it fails with OTHER_ERROR (4ec47a9; The lambda sweep and the Pareto frontier)
S2 has more locations than the baseline a candidate subsample without PROTECT_BASELINE dropped 65 % of FRI's baseline cells (f167da2; Scope rules and data gaps) keep LOCATION_SELECTION_FACTOR=1
the deck parser finds no rows a UTF-16 log from a PowerShell redirect redirect via cmd
a .bat that cmd cannot run (labels and quoted args break) saved with LF line endings (make_descriptive_table.bat, since c368a01; CRLF restored in 29fcf7f) keep the .bat files CRLF
run_rebuild_all.ps1 does not see a new area its default list is doc/deck_data.json, which lists only areas already parsed pass -Areas

Regenerating the deck

The deck is generated from the sweep logs, never hand-edited. Once every log you changed ends in a scenario summary, run the chain in doc/README_deck.md with PYTHONIOENCODING=utf-8 (Deck and charts pipeline; the results-page numbers: Metrics aggregation and ranking).

In the code

Open in this order: run_pharmacy_pipeline.bat (defaults L76–79, item paths L99–105, the area × step loop L131–162 — the GeoDMS wrapper everything else calls); run_resweep_batch.ps1 (Test-SweepComplete L38–46, the loop L58–75 — the worker you will use most); run_rebuild_all.ps1 (purge and both sides, L35–68); lambda_sweep_simplex.jl analyze_country (L245–548: the loop L387–414, the fallback bisection L474–490, the summary L511–548, the per-area try/catch L551–559 — Code walkthrough lambda_sweep_simplex); lp_run.jl L439 (LP_TIME_LIMIT) and L484–487 (SOLVER, time_limit); settings.jl L3–7, 10, 44, 55 (data root, COUNTRIES, TRAVEL_FUNC, ROUNDING); cfg/main/ModelParameters.dms L20–31 (Roads_path, STUDY_AREA); doc/build_deck_data.py L171–179 (refine-log preference).

Knobs

Runner-level variables; the Julia knobs are in Code walkthrough settings and Code walkthrough lambda_sweep_simplex.

Variable Default What it changes Why you would touch it
GEODMS_EXE …\GeoDms20.19.1.m\GeoDmsRun.exe (.bat, around line 76) which engine another install path; must be ≥ 20.19
CFG, LOG_DIR, FUNC, OUT_DIR <repo>\cfg\main.dms, <repo>\logs, LINEAR, …\Pharmacies_Descriptives config; GeoDMS /L log folder; the function parse_compare.py tabulates; where collect_descriptives.jl reads (GeoDMS writes to the fixed path regardless) rarely
STEPS Existing network0 network1 network2 alloc; New network1 network2 alloc which GeoDMS steps the .bat runs every orchestrator sets it; network0 by hand to cut a street subset
STUDY_AREA set per area by every script what GeoDMS computes; unset → 'ITG' only for a hand-typed GeoDmsRun
NEWPH_DIR, S1S2_OUT C:/LocalData/networkmodel_eu/NewPharmacies, E:/prj/JRC/NetworkModel_EU/scratch/s1s2_open_locations export_s1s2_locations.jl input / output set S1S2_OUT on any machine but Maarten's
set by the .ps1 workers: ROUNDING=multistart, MAX_PARALLEL, COUNTRIES=<area>, TRAVEL_FUNC=<fn>; SWEEP_STOP_AFTER_REFINE=1 with -RefineOnly (removed otherwise) — one area per Julia process, each with its own log -RefineOnly is the only switch that changes the sweep itself
must be set by hand: COUNTRIES, TRAVEL_FUNC France Italy Netherlands Sweden (settings.jl around line 10); QUADRATIC (around line 44) which areas, which cost function a bare julia lambda_sweep_simplex.jl sweeps four countries with a function nothing reports
inherited from your shell: SOLVER, LP_TIME_LIMIT, SWEEP_WMAX, SWEEP_MULTS, LOCATION_SELECTION_FACTOR simplex, 3600 s, 5.0 LINEAR / 0.5 LOGISTIC, 1,2,5, 1 solver, per-solve time limit, top and density of the grid, candidate subsampling (PROTECT_BASELINE=1 keeps today's cells — Scope rules and data gaps) no runner sets or clears them, so a stray value silently changes every worker you start. The log records only w_max (the Common λ sweep banner) and a subsample (@info load_from(...): … kept … of … (factor=N)); the other three leave no trace

Pitfalls and open questions

  • Default area lists disagree (run_pharmacy_pipeline.bat and settings.jl: four countries; the deck ORDER: 44; the descriptives bat: 47). Always pass areas explicitly.
  • run_new_country_sweeps.ps1 never builds the Existing-side network — for a new area, Recipe A step 3 first.
  • The post-e25416b refine walk differs (×1.3 climb steps, doc/check_s1s2.py): cited in issue #52, not on GitHub as of 15 September 2026 — Branches data and environment.
  • Country-level Poland is the one area whose S1/S2 are still snapped grid points (#52); pinning it needs the IPM path or the exact MIP.
  • Sixteen areas carry a July full sweep whose OD differs slightly from the September rebuild, with September refine points merged in (#54; kinks ≤ 1.5 %); a full re-sweep (~20 h on four workers) awaits a decision.

See also

Clone this wiki locally