How to run the model

This page tells you how to install the model and how to run it. Once it is installed, a run takes two steps: set it up in cfg/main/ModelParameters.dms, and double-click batch\UpdateAll.cmd, which computes everything that is missing. You can also make several merges for every part of the day without an edit in between, with one call per part of the day (see Merge variants and settings per call). The page covers what you need as a user of the model. Other pages give more detail:

How the model works is on Public transport and Private transport.

Contents


Installation

GeoDMS software

Install GeoDMS 20.28.0, with the file GeoDms20.28.0.m-Setup-x64.exe. This is the version that UpdateAll.cmd uses. It includes the pre-release 20.27.0, which computes a car cache in about half the time of 20.26.0 with the same result.

Which functions need which version

The configuration asks for GeoDMS 20.28.0 or later and stops on an older version with IntegrityCheck : ‘GeoDMSVersion() >= 20.2800’ is not true. The model uses the Pareto functions of GeoDMS 20.24.2: pareto_optimal_eps with an epsilon per criterion and with bool criteria, the Pareto option of impedance_matrix, and the time-dependent impedances (#128). The car routes of an origin-destination (OD) pair need 20.26.0 (see Routes of an OD pair). In 20.27.0, impedance_matrix makes a sparse result in one pass instead of two (GeoDMS#1327), which halves the time of a car cache. In 20.28.0, pareto_optimal_eps reads its criteria from their tiles. While it sorts, it takes at most 16 bytes per row, where earlier versions took 64 bytes for four criteria (same issue). The memory peaks per component in OutputPeak_Measured, which set the number of block parts per origin block, come from runs on 20.24.0 to 20.28.0; its Source names the version per component, and #141 measures them again with the current model.

The GeoDMS Academy explains how to install GeoDMS and how to open a configuration.

The model repository

Clone the repository with Git:

git clone https://github.com/ObjectVision/NetworkModel_PBL.git

This makes a folder NetworkModel_PBL. You can also use a Git client such as TortoiseGit, or download a ZIP. The ZIP unpacks as NetworkModel_PBL-main. Rename that folder to NetworkModel_PBL (see Before the first run).

Source data

The source data are not in the repository. PBL keeps them on its Nextcloud share: the GTFS feeds, the OSM extracts, the cycling network of the Fietsersbond, the NS timetable (IFF), the OV-fiets locations, the CBS area division and the BAG. The fare tables are part of the repository (cfg/main/SourceData/OVprijzen.dms and the folder data).

The model finds the source data through two settings in cfg/main/ConfigSettings.dms:

  • NetworkModel_Dir, by default %SourceDataDir%/NetworkModel: the source data on the Nextcloud share;
  • NetworkModel_PrivDir, by default %SourceDataDir%/NetworkModel_PBL_priv: the TomTom caches (see The TomTom caches).

The BAG is in %NetworkModel_Dir%/RegioIndelingen/BAG/BAG_<date>_History, where <date> is the date of the extract in ModelParameters/BAG_file_date. The folder holds one mmd per object type with all its voorkomens. The tool Xml2MMD of BAG-Tools makes them from the BAG extract of Kadaster. The model itself selects the BAG on a date from them (#142); see The BAG on a date.

How to add a new extract of OSM, a new year of the CBS area division or a new delivery of the BAG is on OSM extracts, CBS area division and BAG and centroids.

%SourceDataDir% is the source data folder in your GeoDMS settings, under Settings > Local machine Options in GeoDmsGui. If your folders are different, do not change ConfigSettings.dms. Set NetworkModel_Dir and NetworkModel_PrivDir in GeoDmsGui under Settings > Config Options instead. You can also set the source data folder as an environment variable; see Starting UpdateAll.cmd from a command prompt.

The model only reads these folders. Everything it makes goes to %LocalDataProjDir%, by default C:\LocalData\NetworkModel_PBL. To put it elsewhere, for example on a larger disk, make a file config.ini in the folder cfg\main, next to ModelParameters.dms, with these two lines:

[directories]
localDataProjDir=D:/LocalData/NetworkModel_PBL

GeoDmsGui and every GeoDmsRun step read this file. It is not part of the repository: each machine has its own. The examples on this page come from a machine with this file, so their paths start with D:\LocalData.

The GTFS feed

The timetable of public transport comes from a GTFS feed, in %NetworkModel_Dir%/Infrastructuur/GTFS/<GTFS_file_date>/. Each analysis moment has its own feed and analysis date in its preset of AnalysisMoment (#125). The coverage in the table is the number of trips on D-1, D and D+1 as a share of the trips on the busiest day with the same weekday in the feed (LoadFeeds/ServiceDays; the minimum is Advanced/MinServiceDayTripShare, 0.95):

AnalysisMoment Analysis_date GTFS_file_date coverage D-1, D, D+1 source
Y2015 20151013 20151007 100%, 100%, 100% 9292, in the source data; valid from 5 October 2015 to 10 December 2016 (feed_info.csv)
Y2023 20231010 20231003 100%, 100%, 100% in the source data
Y2024 20241008 20241001 100%, 100%, 100% OVapi, as delivered with the model
Y2025 20251014 20250930 97%, 97%, 97% Mobility Database mdb-1077-202509300053
Y2026 20261013 20261012 98%, 98%, 94% OVapi NL-20261012.gtfs.zip, published the day before the analysis date; D+1 is below the minimum, but only a part of the day that runs past midnight needs D+1, and none does

When the cache of the feed is missing, UpdateAll.cmd makes it: %LocalDataProjDir%/GTFS/<GTFS_file_date>.mmd (see What a run does). A cache that exists is read. So when a new delivery of a feed has the same date, remove the folder of its cache.

A feed is the planned timetable as it was known on the day it was published. It includes announced engineering works, but not delays or cancellations: OVapi publishes those only as a live GTFS-realtime stream. For comparable results, take the feed published on the analysis date itself or the day before. A feed published weeks earlier misses the later changes, and a feed covers only a few weeks completely (see Create routable network from GTFS files).

To add a feed, for example for a new analysis moment:

  1. Get the feed. The model uses the national OVapi feed. The current feed is gtfs.ovapi.nl/nl/gtfs-nl.zip. The archive gtfs.ovapi.nl/nl/archive/ keeps a copy per day as NL-<yyyymmdd>.gtfs.zip, back to 1 January 2026. Older versions are in the Mobility Database (feed mdb-1077), at files.mobilitydatabase.org/mdb-1077/<id>/<id>.zip. There <id> is mdb-1077-<yyyymmddhhmm>, the moment of download, around midnight UTC. The feed page lists only the last ten; find older ones through its API or by that name.
  2. Unpack the zip into %NetworkModel_Dir%/Infrastructuur/GTFS/<GTFS_file_date>/ and rename every .txt to .csv. Recent OVapi feeds have no calendar.txt, because every service day is in calendar_dates.txt. The loader expects the file, so put a calendar.csv there with only its header line (copy it from another feed folder).
  3. Put the date of the feed in the column GTFS_file_date of the analysis moment, in AnalysisMomentPresets (group 7 of ModelParameters.dms).

The TomTom caches

The car on the TomTom network needs four TomTom caches as source data: Roads.mmd, Junctions.mmd, Speednetworks.mmd and Speedprofiles.mmd in %NetworkModel_PrivDir%/TomTom/<edition>. For Y2025 and Y2026 the edition is yr2025_12 (1.2 GB). TomTom data are licensed to PBL: get them from PBL and do not pass them on. Without these caches, set UseTomTomNetworkForCars to FALSE. The car then uses the OSM network.

UpdateAll.cmd does not make these caches. How a delivery of TomTom becomes the four caches, once per edition, is on TomTom data and caches.


Setting up a run

Open cfg/main/ModelParameters.dms and set at least these parameters:

  • AnalysisMoment: the reference year, for example 'Y2025'. It sets the analysis date, the GTFS feed and the other source data. AnalysisDay sets another date, as yyyymmdd; the feed must cover it.
  • PartOfDay: 'Morning', 'Afternoon' or 'Evening'.
  • Orgset and Destset: the origins and the destinations, for example 'Buurt2025'.
  • The variant (group 2): the pre-transport types (PreTransport), the post-transport types (PostTransport) and the direct trips (DirectWalking, DirectCycling, DirectCar) that take part, each with a switch TRUE or FALSE. Each pre-transport type that is on, combined with each post-transport type that is on, gives a public transport component, such as W_PT_W. These components and the direct trips that are on are the components of the run.
  • Merge, MergeCriteria and MergeRunNr (group 3): whether the run merges the components into one front, on which of the criteria Price (or Price_Augm), Time, Car and Bike, and under which number. A merge variant, a row of MergeVariants in the same group, sets the components, the criteria and the number under one name instead; see Merge variants and settings per call.
  • OutputLabel: the name of the variant in the output folder, for example 'b2025' for Buurt2025. The folder name starts with the analysis date and the part of the day, so the year and the part of the day are already in it. WW and CC do not depend on the part of the day. Their folders carry the origin set instead of the label, so the afternoon and the evening read the WW and CC of the morning. Keep the label the same for every year that you want to compare; see OutputLabel.

An example is the question of PBL of October 2026: walking or cycling to any stop, walking or the OV-fiets after the last stop, and the direct trips by walking, cycling and car:

container PreTransport
{
	parameter<bool> Org2Stops_Walking      := TRUE , ...
	parameter<bool> Org2Stops_Cycling      := TRUE , ...
	parameter<bool> Org2R_Stops_Cycling    := FALSE, ...
	parameter<bool> Org2RM_Stops_Cycling   := FALSE, ...
	parameter<bool> Org2RMT_Stops_Cycling  := FALSE, ...
}
container PostTransport
{
	parameter<bool> Stops2Dest_Walking     := TRUE , ...
	parameter<bool> Stops2Dest_Cycling     := FALSE, ...
	parameter<bool> R_Stops2Dest_Cycling   := FALSE, ...
	parameter<bool> RM_Stops2Dest_Cycling  := FALSE, ...
	parameter<bool> RMT_Stops2Dest_Cycling := FALSE, ...
	parameter<bool> OVF_Stops2Dest_Cycling := TRUE , ...
}
parameter<bool>     DirectWalking  := TRUE, ...
parameter<bool>     DirectCycling  := TRUE, ...
parameter<bool>     DirectCar      := TRUE, ...
parameter<bool>     Merge          := TRUE, ...
parameter<string>   MergeCriteria  := 'Price,Time', ...
parameter<uint32>   MergeRunNr     := 1, ...

This variant has seven components: WW, CC, Car, W_PT_W, W_PT_ovfC, C_PT_W and C_PT_ovfC, and their merge Merged1. More examples are on Model parameters, under The variant.

All settings are on Model parameters. If GeoDmsGui is open, reload the configuration with Alt+R after each change. GeoDmsGui shows one component, the one in GuiComponent; set it to 'Merged' to see the merge.

The settings in group 5 at the top of ModelParameters.dms are part of the names of the caches. After you change one of them, the model makes those caches again, which can take hours. The settings in group 4 only change the output: the output of the components that use them gets another signature, and so a folder of its own beside the earlier one.

Then double-click batch\UpdateAll.cmd (see Running the model with batch\UpdateAll.cmd). For several merges, or for the same run in another part of the day, you can give the merge variant and the settings of group 1 per call in a command prompt. Then you do not have to edit ModelParameters.dms in between (see Merge variants and settings per call).


Running the model with batch\UpdateAll.cmd

Double-click batch\UpdateAll.cmd in Explorer. It computes the run that is set up in ModelParameters.dms: the caches that the run needs, the output of every component of the variant, and their merge. It skips what is already there with the current settings. So it computes only what is missing, or what a changed setting has made outdated. At the end the window shows how the run ended, with UpdateAll all done or a line with FAILED, and waits for a key.

The window must stay open while the run computes: closing it stops the run. For a run of many hours, double-click batch\ScheduleUpdateAll.cmd instead: it starts the same run as a scheduled task, which does not depend on the window that started it (see Running UpdateAll as a scheduled task). In a command prompt, batch\UpdateAll.cmd all does the same as a double-click, without the wait at the end (see Starting UpdateAll.cmd from a command prompt).

Before the first run

Check these four points. Otherwise UpdateAll.cmd stops at once, or reads the wrong folders.

  1. GeoDMS is installed (see GeoDMS software). UpdateAll.cmd takes the engine from the environment variable GEODMS_EXE. Without it, it takes the installed version that its line GEODMS_VERSION names, 20.28.0. Without either, it stops with ABORT: no GeoDmsRun.exe found. To run with another engine, for example a test build of GeoDMS, set GEODMS_EXE to its GeoDmsRun.exe, as in Starting UpdateAll.cmd from a command prompt.
  2. The folder of the model is named NetworkModel_PBL (see The model repository). GeoDMS names %LocalDataProjDir% after this folder, unless a config.ini sets it (see Source data). With the folder NetworkModel_PBL-main of a ZIP, the model writes and looks for its caches in %LocalDataDir%\NetworkModel_PBL-main.
  3. The source data folders are set (see Source data). GeoDmsRun reads the same settings as GeoDmsGui, so you set them only once.
  4. The run is set up in ModelParameters.dms (see Setting up a run).

The chain step and the output step need much memory; see Hardware requirements.

What a run does

UpdateAll.cmd runs each step in a separate GeoDmsRun, so that the memory is freed between the steps. It stops at the first step that fails. It works in this order:

  1. It checks the settings: the merge variant and the settings that the call gives, the analysis moment and date, the part of the day and its NS fare class, the origins and destinations, the variant and the criteria of the merge, the output format and label, and the number of transfers. A wrong setting gives a line with FAIL that says what to change, or, for a setting with an IntegrityCheck of its own such as OutputLabel, an error in this first step. Either way the run stops before it computes anything.
  2. It makes the OSM network and the GTFS feed of the analysis moment into caches, each only when its cache is missing.
  3. It checks the caches of the sources, and whether the GTFS feed holds the service days that the part of the day needs on the analysis date. For example, an evening that runs past midnight needs the next day as well. With Car in the variant, it checks that the analysis date falls on the day of the TomTom speeds (CongestionSpeed_DaySelection). With public transport, it checks the fare tables. A rule of regional transport without a price, or a DOVA fare that is empty or above the limits, gives FAIL. A combination of mode and agency without a rule, which then gets the DOVA fare, or a rule with a price above the plausible limits, gives WARN (see Price checks). A WARN does not stop the run; a FAIL does.
  4. It computes the components of the variant one after the other, in the order of batch\log\components.txt. Each component gets the steps it needs: the car caches for Car, or the pre- and post-transport caches for a public transport component. Then follows the output, a file per origin block and per departure moment. A component whose output is complete is skipped, with its cache steps. The chain cache is a step of its own, just before the first public transport component.
  5. With Merge or a merge variant, it merges the components as the last component, Merged. When only a setting of the merge has changed, the run skips the complete components and only merges again.

The chain cache is a step of its own because the public transport components share it. It does not depend on the component, because its time window follows the longest pre-transport leg of the variant (Impl/PT_Chains_Max_V_Time). The console counts it with the components, for example step 4 of 9: chains between Car and W_PT_W. It runs with the settings of the first public transport component whose output is not complete. The signature of the chain cache decides whether the step has anything to calculate. That signature belongs to the whole cache, and its hash is in the name of the cache folder, for example PT_Chains_20251014_07h00m-09h29m_26fff2ab. It holds the settings that the chains depend on, but no component. When a complete cache with the current signature is there, the step calculates nothing and takes seconds. When there is none, because a setting in the signature or the revision of the chain cache changed (see When a section must run again, below), it calculates all 500 stop blocks into a new folder. After an interrupted run, it calculates only the stop blocks that the cache still misses. When the output of every public transport component is complete, the step is skipped altogether. So you never have to decide yourself whether the chain cache must be made again.

The output of a component is complete when its folder holds the signature of the current settings, the counts of every origin block and od_tellingen.csv (NetworkSetup/GenerateOutput/IsComplete). Otherwise the output step first empties that folder: it removes the files that an earlier run with the same settings left there without finishing. Output with other settings is in another folder, because the hash of the signature is part of the folder name (see Where the results are). So you need neither another OutputLabel nor an empty folder to keep earlier output.

UpdateAll.cmd passes the component of each step to the model in the environment variable GEODMS_Overridable_RunComponent; you do not set it yourself.

The steps run strictly one after another. The script waits for each GeoDmsRun to end before it starts the next one, and the same holds for the portions within the chain step and the output step. So only one process of the model computes at any moment, and the memory that a run needs is the peak of its heaviest step, not the sum of the steps. Within that one process the model does use all cores, and the chain step divides its work over the stop blocks (see Stop blocks). That is parallel work inside one GeoDmsRun. Two runs at the same time only happen when you start them yourself, and for the output step that is a bad idea (see Hardware requirements).

Each step, and each portion of the chain and output steps, is a new GeoDmsRun that reads the configuration again from the folder of the model: cfg\main.dms and the files it includes. So an edit of ModelParameters.dms, or of any other file in cfg, during a run changes the steps that follow it, and the run then computes part of its work with other settings. Do not edit the configuration while a run computes. For a series of runs, give the settings that differ per call where -set takes them (see Merge variants and settings per call), and edit other settings only between two runs.

Starting UpdateAll.cmd from a command prompt

You need a command prompt to set environment variables for a run, such as another source data folder or another engine, and to run a section other than all (see The sections). Press Windows+R, type cmd and press Enter. The folder of the prompt does not matter: UpdateAll.cmd finds the model next to itself and writes its logs to batch\log.

In the prompt, first set the environment variables, if you need them. Then call UpdateAll.cmd with its full path and a section. An example, with the source data in K:\SD_next and the model in K:\pd\NetworkModel_PBL:

set "GEODMS_directories_SourceDataDir=K:\SD_next"
K:\pd\NetworkModel_PBL\batch\UpdateAll.cmd all
  • GEODMS_directories_SourceDataDir sets %SourceDataDir%. It takes the place of the source data folder in Settings > Local machine Options. With K:\SD_next, the model reads the source data from K:\SD_next\NetworkModel and the TomTom caches from K:\SD_next\NetworkModel_PBL_priv. Other folders for NetworkModel_Dir or NetworkModel_PrivDir in Settings > Config Options still count. If Local machine Options already has K:\SD_next as the source data folder, leave this line out.
  • With a GeoDMS version later than 20.28.0, also set GEODMS_EXE to its GeoDmsRun.exe, for example set "GEODMS_EXE=C:\Program Files\ObjectVision\GeoDms<version>.m\GeoDmsRun.exe". An older version stops at the first step (see GeoDMS software).
  • Put the quotes around the whole assignment, as in the examples. Do not put them around the path only: set GEODMS_EXE="C:\..." puts the quotes in the value, and then UpdateAll.cmd cannot start GeoDmsRun.exe.
  • The variables only hold in this command prompt. Run the next sections in the same prompt, for example K:\pd\NetworkModel_PBL\batch\UpdateAll.cmd legs. In a new prompt, set them again.

The sections

all is the section that a double-click runs: everything that is missing, as described under What a run does. Each of the other sections makes one kind of cache. Use them, for example, to prepare the chain cache of a new part of the day on a machine with enough memory, or to make the car caches of other moments than those the run reads. None of them computes output. In a command prompt the section follows UpdateAll.cmd:

batch\UpdateAll.cmd all                      everything that is missing, as after a double-click
batch\UpdateAll.cmd checks                   only the checks of the settings and the caches of the sources
batch\UpdateAll.cmd sources                  the source caches that are missing
batch\UpdateAll.cmd cars [moment ...]        the car caches, of the moments the run reads or of the named moments
batch\UpdateAll.cmd chains                   the public transport chain cache
batch\UpdateAll.cmd legs                     the pre- and post-transport caches that are missing
... -component C_PT_ovfC                    with all, cars, chains or legs: only that component of the variant
... -variant OV_lopen                        a merge variant of ModelParameters/MergeVariants; repeated, or all
... -set PartOfDay Afternoon                    for this call a setting of ModelParameters; repeated for more settings

The section comes first; without any word after UpdateAll.cmd, the section is all. Only cars takes more words: its moments. -component, -variant and -set may come before or after them (see Merge variants and settings per call). Any other word or option stops the script before it starts and shows this list; UpdateAll.cmd -help shows it too. -component does not take Merged: the merge is the last step of all.

  • sources makes the OSM network and the GTFS feed into caches, each only when its cache is missing. It is needed once per analysis moment.
  • legs makes the walking and cycling connections between the places and the stops. It is needed once per analysis moment and set of origins and destinations.
  • chains makes the chains between the stops: the chain cache. It is needed once per analysis moment and part of the day. This is the heaviest step of the model, in time and in memory.
  • cars makes the direct car trips, one cache per departure moment. It is needed once per edition of the road network, set of origins and destinations, and part of the day.
  • checks only checks the settings and the caches of the sources, and writes the list of components. sources starts with the checks of the settings. The other sections also check the caches of the sources; all does so after its sources step.

How long each section takes and how much memory it needs is in the table under Hardware requirements.

A cache with the right settings is read again in a later run, so a section that finds its caches is quick. The settings a cache depends on are in its name: the edition of its source and, for every cache but the GTFS cache, a hash of its signature (see Cache names). After a change of such a setting, the cache with the old name no longer fits, and the next UpdateAll.cmd makes a new one. You do not have to choose the section yourself.

When a section must run again
  • sources: after a new edition of OSM or of the GTFS feed. For the OSM network also after a change in the car speeds of OSM roads without a speed, the ferry speed or the snap distance of the extra connections (OSM/Signature). A source cache that exists is not made again. To make it again under the same name, for example after a new delivery of a feed under the same date, remove its folder in %LocalDataProjDir%\OSM or %LocalDataProjDir%\GTFS.
  • legs: after a change in the walking or cycling network or speed, in a maximum pre- or post-transport time, or in the origins, the destinations or the stops (a new feed or analysis moment). Not after a change in the part of the day or the component.
  • chains: after a new GTFS feed or analysis moment. Also after a change in the part of the day, the fare method or the NS fare class, MinimiseCriteria, Max_transfers, MaxPTTime, the chain epsilon, the transfer settings, the maximum pre-transport times, or the start and parking time of cycling, and after an update of the model code that raises the revision of the chain cache (Impl/PT_Chains_Revision). UpdateAll.cmd sees this itself: such a change gives the chain cache another signature and so another folder, which the step then fills.
  • cars: after a new edition of the road network, other origins or destinations, or a change in MaxCarTime, the car front settings, the speed cap, or the window, start time or search of the time-dependent car trip. Not after a change in the car costs: the model applies them when it reads the cache.
  • The output of a component, in all: after any of the changes above, and after a change of a setting that only changes the output.

The items that each section asks the model for are on UpdateAll and cache internals.

To compute one OD pair, with the route of every option, see Routes of an OD pair.

Merge variants and settings per call

A call of UpdateAll.cmd can choose a merge variant and give settings of ModelParameters for that call only. A series of runs, such as several merges for every part of the day, then needs no edit of ModelParameters.dms in between.

A merge variant is a row of ModelParameters/MergeVariants (group 3): a name, the components, the criteria of the merge and the number of the merge in the name of its folder. The table has these rows:

Name Folder Components MergeCriteria
OV_lopen Merged1 WW, W_PT_W Price,Time
OV_lopen_fiets Merged2 WW, CC, W_PT_W, Crm_PT_W, W_PT_ovfC, Crm_PT_ovfC Price,Time
Auto Merged3 Car Price,Time
OV_lopen_auto Merged4 WW, W_PT_W, Car Price,Time
OV_lopen_fiets_auto Merged5 WW, CC, W_PT_W, Crm_PT_W, Car, W_PT_ovfC, Crm_PT_ovfC Price,Time
OV_lopen_fiets_Cr Merged6 WW, CC, W_PT_W, Cr_PT_W, W_PT_ovfC, Cr_PT_ovfC Price,Time
twee_fietsen Merged7 WW, CC, Car, W_PT_W, W_PT_C, C_PT_W, C_PT_C Price,Time

Rows 1 to 5 are the merges of a request of PBL. Every row merges on price and time only, so an option that needs a car or the traveller’s own bicycle can push out an option without one. A row in which the traveller cycles on an own bicycle also has the OV-fiets after the last stop (ovfC); row 7 has a second own bicycle at the last stop instead (W_PT_C, C_PT_C). Row 6 is row 2 with cycling to any train station (Cr) instead of to a rail or metro stop (Crm).

1. Choose a merge variant

-variant <name> makes the merge variant of that row. It uses the components of the row instead of the switches of group 2, and its criteria and number instead of MergeCriteria and MergeRunNr. A merge variant always merges, also when Merge is FALSE. The name is not case-sensitive.

batch\UpdateAll.cmd all -variant OV_lopen_fiets

2. Make several merge variants one after the other

With -variant more than once, or with -variant all for every row, UpdateAll.cmd runs itself once per merge variant, in the order of the command line or of the table, with the same section and options. It stops at the first variant that fails. A component that has the same settings in two merge variants has one output folder (see Output folder and departure moments). The first variant that needs it computes it. For the next variants its output is complete, and they only merge it. With -variant all the run computes each of the twelve components in the table once, and makes eight merges.

batch\UpdateAll.cmd all -variant all
batch\UpdateAll.cmd all -variant OV_lopen -variant Auto

A list with commas does not work, because the command prompt splits the arguments at a comma; give -variant once per name.

3. Give settings for the call

-set <name> <value> gives a setting of ModelParameters for this call: AnalysisMoment, PartOfDay, Orgset, Destset, OutputLabel, NS_TariffChoice (in Advanced) or MergeCriteria. Give it once per setting. Separate name and value by a space, because the command prompt also splits the arguments at =. Put a value with commas in double quotes, as -set MergeCriteria "Price,Time,Car,Bike", because the command prompt splits the arguments at a comma too. A setting that the call does not give keeps the value at the end of its line in ModelParameters.dms. MergeCriteria given this way also applies over the criteria of a merge variant.

batch\UpdateAll.cmd all -variant all -set PartOfDay Afternoon
batch\UpdateAll.cmd all -variant all -set PartOfDay Evening -set NS_TariffChoice Price_40pct_Discount

Give each part of the day its own OutputLabel, as under OutputLabel. Another NS fare class needs no label of its own. It is in the signature of the chain cache and of the output, so its output gets a folder of its own beside that of the other fare class.

ScheduleUpdateAll.cmd passes the same options on, so a series of runs can also run as a scheduled task (see Running UpdateAll as a scheduled task):

batch\ScheduleUpdateAll.cmd all -variant all -set PartOfDay Afternoon

4. Check what the call gives

The first line of the checks shows the merge variant and the settings that the call gives, for example PASS: given for this call, in place of ModelParameters: -variant OV_lopen -set PartOfDay Afternoon. Without options, it says that ModelParameters applies as it is. A name that is not in MergeVariants, a component that the row names twice or that does not exist, or a value that is not allowed gives a line with FAIL, or for OutputLabel an error in the first step (see What a run does), and the run stops before it computes anything. UpdateAll.cmd checks -variant all checks every merge variant, in a few seconds per variant.

Only the options of the call count. UpdateAll.cmd passes the merge variant and the settings to every step in the environment variables GEODMS_Overridable_Variant and GEODMS_Overridable_<name>. A setting that the call does not give gets the value ModelParameters, which means that the value in ModelParameters.dms applies. So a variable that an earlier call left in the command prompt, or a value of the same name in the registry, has no effect. GeoDmsGui does not get these options. To look at the result of a merge variant or of another part of the day in GeoDmsGui, set the same values in ModelParameters.dms.

5. Make every merge variant for every part of the day

One call makes every merge variant for one part of the day. So the four runs of 2025 are four calls: the morning rush hour, the afternoon with Dal Voordeel, and the evening with the full fare and with Dal Voordeel:

batch\ScheduleUpdateAll.cmd all -variant all
batch\ScheduleUpdateAll.cmd all -variant all -set PartOfDay Afternoon -set NS_TariffChoice Price_40pct_Discount
batch\ScheduleUpdateAll.cmd all -variant all -set PartOfDay Evening -set NS_TariffChoice Price_FullFare
batch\ScheduleUpdateAll.cmd all -variant all -set PartOfDay Evening -set NS_TariffChoice Price_40pct_Discount

The first call needs no -set: ModelParameters.dms has the morning rush hour and b2025, and in the morning rush hour the model always uses the full NS fare. Start a call only when the previous one has ended, because only one scheduled task can exist at a time and ScheduleUpdateAll.cmd refuses a second one. A call has ended when the last line of batch\log\UpdateAll_status.txt reads updateall exit=0, or another exit code when the run failed. Each scheduled call starts that file anew, so that after the four calls it holds only the last one (see Running UpdateAll as a scheduled task). In a command prompt that stays open, the same four calls with UpdateAll.cmd instead of ScheduleUpdateAll.cmd run one after the other, and add their lines to the same file.

Each call computes only what the earlier calls did not make:

Call Computes Reads from an earlier call
Morning rush hour WW and CC, which serve every part of the day; Car, the chain cache and the public transport components of the morning; the seven merges nothing
Afternoon, Dal Voordeel Car, the chain cache and the public transport components of the afternoon; the seven merges WW, CC
Evening, full fare Car, the chain cache and the public transport components of the evening; the seven merges WW, CC
Evening, Dal Voordeel the chain cache and the public transport components with the discount; six merges, all but Auto WW, CC, and Car and the merge Auto of the evening with the full fare

The NS fare class is in the signature of the chain cache, and so in that of every public transport component and of every merge with one. It is not in the signature of Car, nor in that of the merge Auto, which holds only Car. So the second evening call reads both from the first. Give the two evening calls the same OutputLabel: the folders of Car and of the merges hold the label, so with another label the second evening call would compute Car and Auto again. The other seven merges of the two calls get folders with the same name except for the hash. To tell them apart, open the folder of a public transport component that the signature.txt of the merge names. Its own signature.txt has _detailed-ns40 with Dal Voordeel, and only _detailed with the full fare.

6. Add a merge variant

A new merge gets a row in MergeVariants: a name without spaces, the components as names from Classifications/Components separated by commas, the criteria as in MergeCriteria, and a number of its own for the folder. The components are WW, CC, Car and the public transport components <pre>_PT_<post>, with the pre-transport types W, C, Crm, Crmt and Cr and the post-transport types W, C, rmC, rmtC, ovfC and rC (see The variant). Change nrofrows to the new number of rows.

If a run is aborted

A long run can stop halfway, for example when a step fails, the program crashes, the machine runs out of memory, the window is closed or the machine restarts. How much of the work the next UpdateAll.cmd has to do again differs per step, because each step has its own unit of work and its own test for what is already there:

Step Unit of work After an abort
sources one cache the interrupted cache is made again from the start
legs a base set the base sets with a complete cache are kept, the interrupted base set is made again
chains a stop block the blocks with a cache are kept, the step goes on at the first block without one
cars a departure moment the moments with a complete cache are kept, the interrupted moment starts again
the output, in all a component the complete components are kept; the interrupted component starts again

The chain step is the one you can interrupt without losing much. A block counts as written only when the file <n>of<N>.done is next to the parquet of that block, and for an OD pair also the parts of its chains, <n>of<N>_onderdelen.mmd. The model writes <n>of<N>.done after the parquet is complete, so a block that was half written is made again instead of being skipped. MakeUnlinkedData/Step3_PT_Chains/BlocksWritten shows how far the cache is, for example 500 of 500 stop blocks have a cache. The pre- and post-transport caches work in the same way. A base set counts as written only when the file Legs_<name>_<hash>.done is next to its parquet in %LocalDataProjDir%\IntermediateResults, and the model writes that file after the parquet (#155). So the next run makes a base set that was half written again.

Start the run again after an abort, with a double-click or the same command: the components whose output is complete are skipped, and the run goes on with the first component that is not. Within a component, the output step does not resume. It empties the output folder of that component before its first portion, and a portion does not look at what is already in the folder. So an output that is aborted at block 300 of 450 starts again at block 1. Give a long run a machine it can keep, and start it as a scheduled task (see Running UpdateAll as a scheduled task), so that it does not depend on the window you started it from.

What marks a unit of work as done, per section, is on UpdateAll and cache internals.

Where the results are

The output of a component goes to the folder %LocalDataProjDir%\Output\<Analysis_date>_<PartOfDay>_<OutputLabel>_<component>_<hash>, for example Output\20251014_Morning_b2025_W_PT_W_<hash>. A component that cycles over the network of the Fietsersbond gets _fb after the component. The hash comes from the signature of the output, which holds all settings that change it. So output with other settings gets a folder of its own beside the earlier output, and when you switch back, the model finds the earlier output again. The folder holds:

  • PerBlock\tt_<moment>_<n>of<N>.parquet: the options per OD pair, one file per origin block and per departure moment. WW and CC have one file per origin block for every departure moment, tt_alle_<n>of<N>.parquet, in Output\<Analysis_date>_<origin set>_WW_<hash> and _CC_<hash>. With OutputFormat 'csv' these are csv files.
  • od_tellingen.csv and unieke_od_tellingen.csv: the number of rows and of OD pairs.
  • signature.txt: all settings of the run; read it to see which settings a folder holds.

The merge of the components goes to Output\<Analysis_date>_<PartOfDay>_<OutputLabel>_Merged<MergeRunNr>_<hash>, with the same files, and with _fb before the hash when a component cycles over the network of the Fietsersbond. A call with -variant all writes one such folder per merge variant, Merged1 to Merged8 (see Merge variants and settings per call). Its columns, the same for every merge, are under Merging the components.

The model does not remove output with other settings; delete a folder that you no longer need by hand. In a run of all, batch\log\output_dir.txt names the output folder of the component whose state UpdateAll.cmd checked last, also when it skipped that component because its output was complete. After a run that ended well, that is the folder of its last component: the merge, when the run merges.

The columns of the files are described under The files per block on Output files. How to combine the files of the blocks into larger files is on Output files.

Logs

UpdateAll.cmd writes a line for every step to the console and to batch\log\UpdateAll_status.txt: the component, the step, its start, and its end with the exit code and the duration. The chain step carries no component, because the public transport components share its cache. The chain and output steps also write a line per portion, with the time it took and the expected remaining time. The checks go to the status file as well, and to batch\log\checks_settings.txt (the settings alone) and batch\log\checks.txt (all checks). The components of the variant are in batch\log\components.txt. UpdateAll.cmd adds its lines to the end of the status file; a scheduled task starts the file anew (see Running UpdateAll as a scheduled task).

This is the start of UpdateAll_status.txt in a scheduled run of 8 November 2026: the merge variants OV_lopen to OV_lopen_fiets_auto, rows 1 to 5 of MergeVariants, for the morning rush hour of 2025 (... stands for lines left out):

start all -variant OV_lopen -variant OV_lopen_fiets -variant Auto -variant OV_lopen_auto -variant OV_lopen_fiets_auto -set PartOfDay Morning -set OutputLabel b2025 08/11/2026 18:45:18.37
engine C:\Program Files\ObjectVision\GeoDms20.28.0.m\GeoDmsRun.exe
08/11/2026 18:45:18 UpdateAll all -variant OV_lopen -variant OV_lopen_fiets -variant Auto -variant OV_lopen_auto -variant OV_lopen_fiets_auto -set PartOfDay Morning -set OutputLabel b2025 started
08/11/2026 18:45:18 engine: C:\Program Files\ObjectVision\GeoDms20.28.0.m\GeoDmsRun.exe
08/11/2026 18:45:18 === variant 1 of 5: OV_lopen ===
08/11/2026 18:45:18 UpdateAll all -variant OV_lopen -set PartOfDay Morning -set OutputLabel b2025 started
08/11/2026 18:45:18 engine: C:\Program Files\ObjectVision\GeoDms20.28.0.m\GeoDmsRun.exe
08/11/2026 18:45:18 === checks_settings: ChecksBeforeRunning ===
...
08/11/2026 18:45:19 --- sources: the OSM network cache exists, skipped ---
08/11/2026 18:45:19 --- sources: the GTFS cache of the feed of the analysis moment exists, skipped ---
08/11/2026 18:45:19 === checks: ChecksBeforeRunning ===
08/11/2026 18:45:19  checks: start
08/11/2026 18:45:20  checks: exit 0 after 0:00:01
PASS: given for this call, in place of ModelParameters: -variant OV_lopen -set PartOfDay Morning -set OutputLabel b2025.
PASS: AnalysisMoment Y2025, analysis day 20251014, GTFS feed 20250930.
PASS: PartOfDay Morning, departures from 7:00.
PASS: NS fare class Price_FullFare in PartOfDay Morning.
PASS: origins Buurt2025, destinations Buurt2025.
PASS: merge variant OV_lopen (Merged1) with 2 components: WW, W_PT_W.
PASS: merge on Price,Time.
PASS: the components write parquet, which the merge reads.
PASS: output label b2025.
PASS: at most 3 transfers.
PASS: the OSM network cache D:/LocalData/NetworkModel_PBL/OSM/Final_Network_20250101_r3_509c5dee.mmd exists.
...
PASS: no direct car trip in the variant.
WARN: 1 of the 44 combinations of mode and agency of feed 20250930 has no rule in FareTable_2025 and gets the DOVA fare of its concession: Rail_db [1 routes].
08/11/2026 18:45:20 === step 1 of 4: WW ===
08/11/2026 18:45:20 WW output_dir: start
08/11/2026 18:45:22 WW output_dir: exit 0 after 0:00:02
08/11/2026 18:45:22 --- output of WW is complete in D:\LocalData\NetworkModel_PBL\Output\20251014_b2025_WW_7ebcf1a5, skipped with its cache steps ---
08/11/2026 18:45:22 === step 2 of 4: chains, the cache that the public transport components share ===
08/11/2026 18:45:22 W_PT_W output_dir: start
08/11/2026 18:45:24 W_PT_W output_dir: exit 0 after 0:00:02
08/11/2026 18:45:24 --- chains: with the settings of W_PT_W ---
08/11/2026 18:45:24 --- chains: pre-check of the stop blocks and the price coverage ---
08/11/2026 18:45:24  chains_precheck: start
08/11/2026 18:45:25  chains_precheck: exit 0 after 0:00:01
08/11/2026 18:45:25 --- chains: the stop blocks that the chain cache with the current signature misses, in portions (WriteChainBlocks.ps1) ---
2026-11-08 18:45:26 chain step per block: there is no chain cache with the current signature yet, all 500 stop blocks are calculated
2026-11-08 18:55:17 portion 1/25: 20 blocks, exit 0, 591 s; about 3 h 56 min to go
2026-11-08 19:05:34 portion 2/25: 20 blocks, exit 0, 617 s; about 3 h 51 min to go
...

The first two lines come from the scheduled task. The call names five merge variants, so UpdateAll.cmd runs itself once per variant. Each of these runs checks the settings twice: alone before the sources step (checks_settings), and with the caches of the sources after it (checks). The example shows the second round. Its first line gives the merge variant and the settings of the call, and its fourth line the NS fare class: the full fare, because the morning rush hour falls in the NS peak hours. The check of the fare tables gives WARN: one combination of mode and agency of the feed has no rule in the fare table and gets the DOVA fare of its concession, and one rule has a price above the plausible limits. The run goes on, because only a FAIL stops it. The output of WW was complete, so the run skipped it. The chain cache with the current signature did not exist yet, so the chain step calculates all 500 stop blocks, in 25 portions of 20.

A component that is calculated adds the lines of its cache steps, such as legs for a public transport component, and those of its output step. That step writes emptying the output folder: with the folder when the folder exists already. Then it writes, for example, output per block: 450 blocks, portions of 50, a line per portion as in the chain step, and at the end the counts of all blocks: the lines of od_tellingen.csv and unieke_od_tellingen.csv on one line. A run ends with the line UpdateAll all ... done, or with a line with FAILED that names the step. A scheduled task then adds updateall exit= with the exit code.

Each step also writes two files: batch\log\UpdateAll_<step>_<component>.log, the log of GeoDMS, and batch\log\UpdateAll_<step>_<component>.txt, the text of the console. The steps that do not belong to a component, such as the steps of the sources, the checks and the chain step, have no component in the name. When a step fails, these two files show why, and the console shows the error messages of GeoDMS. GeoDmsRun adds to an existing log, so one log can hold several runs. batch\ReportUpdateAll.py gives an overview of the steps, with their time and memory.

Sometimes the output of a public transport component stops within minutes with a long list of Unknown identifier errors: first about columns of the chain cache, such as uq_c_FromTime_Stop_rel, and then about columns of the output, such as OrgName. Then the model found no chain cache with the settings of the run. The reader of the chain cache declares no columns itself, so without a cache every item that uses it is unknown. The cause is in the warning just before the first error: the IntegrityCheck of /NetworkSetup/PublicTransport_Prep/PT_Chains_Sig/CheckGate is not true. Then the chain cache was never made, was removed, or was made with other settings. Run batch\UpdateAll.cmd again: its chain step makes the stop blocks that the cache misses, before the output of the first public transport component. The output step does not check beforehand whether the chain cache exists, so it has already emptied the output folder of the component.

Running UpdateAll as a scheduled task

A run of many hours should not depend on the window that started it. batch\ScheduleUpdateAll.cmd therefore starts UpdateAll.cmd as a scheduled task of Windows, named NM_PBL_UpdateAll, and returns at once. A double-click starts all; the window then waits for a key, so that you can see whether the task started. In a command prompt it takes the same section and options as UpdateAll.cmd:

K:\pd\NetworkModel_PBL\batch\ScheduleUpdateAll.cmd all
  • The task runs in a console window that you can see. The run goes on when you close the window that started it. You must stay logged on.
  • A GEODMS_EXE set before ScheduleUpdateAll.cmd goes to the task. Other environment variables, such as GEODMS_directories_SourceDataDir, do not. The source data folder must then be in Settings > Local machine Options.
  • The task starts batch\log\UpdateAll_status.txt anew, with a line with its start and, when GEODMS_EXE is set, a line with the engine. After the lines of the steps it adds its exit code. Then it deletes itself. So the file holds only the last scheduled call: after four calls one after the other, only the fourth. Copy the file before the next call if you want to keep it.
  • Only one such task can exist at a time.
  • The task has no time limit. By default Windows stops a scheduled task after 72 hours, and a variant with cycling components can take longer, so ScheduleUpdateAll.cmd removes that limit.
  • Follow the progress in batch\log\UpdateAll_status.txt, a line per step.
  • To stop a run, close its console window. Or run schtasks /End /TN NM_PBL_UpdateAll and then schtasks /Delete /TN NM_PBL_UpdateAll /F.
  • Do not edit UpdateAll.cmd or UpdateAllTask.cmd during a run: cmd reads a running batch file line by line from disk. Do not edit the configuration in cfg either, because every step reads it again (see What a run does).
More about the task
  • ScheduleUpdateAll.cmd refuses to start a second task, and warns when another GeoDmsRun is running.
  • The task starts once, at 00:00 of the day it was made. That time lies in the past, so the task never starts again by itself.
  • The task runs batch\UpdateAllTask.cmd, in the window of the user who is logged on (“interactive only”).

Hardware requirements

The model runs on Windows 10 or later, with GeoDMS 20.28.0 (see GeoDMS software).

Memory limits a run most. The table below gives the steps of each component, with the time and the memory peak of each step. The numbers are for the morning rush hour of 2025 (Buurt2025 to Buurt2025, 450 origin blocks, 500 stop blocks, four departure moments) on a machine with 16 cores and 128 GB of memory. The steps of “all components” and “public transport” make caches that those components share, so they run once per analysis moment (the chains once per part of the day), not once per component. The column Run says which run the numbers come from; the runs are described below the table.

Component Step GeoDmsRun calls Time Memory peak Result on disk Options per OD pair Run
all components sources, the OSM network 1 2.1 min 19 GB 3.0 GB   E
all components sources, the GTFS feed 1 2.8 min 3.2 GB 3.7 GB   E
WW output, one departure moment 9 12 min 9.0 GB 0.02 GB 1.0 E
CC output, one departure moment 9 11 min 6.9 GB 0.04 GB 1.0 E
Car cars, each departure moment 1 2.8 to 3.0 h 14 to 16 GB 10.5 to 11.2 GB each   E
Car output, four departure moments 9 1.1 h 11.2 GB 11.1 GB 6.9 E
public transport legs, three base sets 1 not yet measured        
public transport chains, 500 stop blocks in portions of 20 25 3.7 h 47.1 GB 5.1 GB   E
W_PT_W output, four departure moments 9 32 min 35.0 GB 1.6 GB 3.7 E
W_PT_C output, four departure moments 9 49 min 34.9 GB 2.2 GB 4.1 F
W_PT_ovfC output, four departure moments 9 32 min 34.3 GB 0.6 GB 3.2 E
C_PT_W output, four departure moments 9 2.2 h 39.7 GB 2.8 GB 4.1 E
C_PT_C output, four departure moments 9 2.5 h 39.5 GB 3.5 GB 4.4 F
C_PT_rmC output, four departure moments 9 not yet measured        
C_PT_rmtC output, four departure moments 9 not yet measured        
C_PT_ovfC output, four departure moments 9 2.1 h 38.3 GB 0.9 GB 3.3 E
the merge (Merged) output of the merge over the seven components of run E 45 2.1 h 3.9 GB 21.0 GB 8.2 E
the merge (Merged) output of the merge over the nine components of run F 45 2.3 h 4.8 GB 22.0 GB 8.6 F
  • E: the current model, cycling over OSM, with the front before the post-transport (#140), in the UpdateAll of 30 October to 1 November 2026 with the variant of W_PT_W, W_PT_ovfC, C_PT_W and C_PT_ovfC and the direct trips. The steps ran one after another. The chains, the four public transport components and the merge ran on GeoDMS 20.28.0 (the first 80 of the 500 stop blocks of the chains on 20.27.0), the other steps on GeoDMS 20.27.0. During 14 of the 25 portions of the chains, GeoDMS was being compiled on the same machine. Those portions took 550 s on average, against 530 s for the six portions with stops that ran after it.
  • F: the model of run E with cycling from every stop as post-transport switched on as well (Stops2Dest_Cycling), in the UpdateAll of 1 November 2026 on GeoDMS 20.28.0. The direct trips, the car, the chain cache and the four public transport components of run E kept their signature and were skipped, so the run calculated only W_PT_C, C_PT_C and the merge over the nine components.

A row without numbers has no measurement with the current model yet. Measurements of these steps with older versions of the model and of GeoDMS, without the front before the post-transport, do not apply to the current model. Object Vision measures them again with the current model and adds them to the table (#141).

For the output steps, the column Options per OD pair gives how many options the output keeps per OD pair. It is the number of rows of the output divided by the number of pairs with at least one option, per departure moment. The table gives the average over the departure moments of the run (from od_tellingen.csv and unieke_od_tellingen.csv in the output folder; see Counts next to the output). A direct walking or cycling trip has one route per pair. The car keeps on average almost seven routes, on travel time and distance (see Private transport). A public transport component keeps several options, such as a cheap and slow one next to a fast and expensive one: 3.7 for W_PT_W. The number of rows of an output, and so its size on disk, is these options times the pairs: for W_PT_W, 39.1 to 39.6 million rows per departure moment over 10.6 million pairs.

The column Result on disk gives the size of what the step writes, with 1 GB as 1024 MB: the cache, or the output folder of the component with all its departure moments. The sizes were measured from 30 October to 1 November 2026 on the caches and output folders of the 2025 morning rush hour. For the outputs, these are the folders of the runs in the column Run, all in parquet. The car output is large because it holds almost seven routes for each of 85 to 87 million pairs per departure moment, against 10.6 million pairs for W_PT_W. The merge keeps per OD pair only the options that no option of another component beats on the criteria of the merge. But every row of the merge carries all columns and the name of its component, while a component writes only the columns that vary within it (see The parquet files). So the merged output of run E is larger than its seven components together, 21.0 against 17.1 GB, and that of run F is about as large as its nine, 22.0 against 22.8 GB.

The number of calls of an output step follows from BlocksPerPortion: 450 origin blocks in portions of 50 for every component, and of 10 for the merge (Merged) (see Model parameters).

The memory peak is the larger of the two numbers that GeoDmsRun writes at the end of its log, Highest CommitCharge and PeakLiveLarge, over all calls of the step, with 1 GB as 1024 MB. For your own run, batch\ReportUpdateAll.py reads them from batch\log, together with the times and the error lines.

The public transport components differ most from each other. A component that cycles to the first stop takes about four times as long as one that walks to it, and it needs more memory: 2.2 h and 39.7 GB for C_PT_W, against 32 min and 35.0 GB for W_PT_W. The reason is that cycling reaches many more stops than walking. Cycling from every stop to the destination adds much less time and no memory: C_PT_C takes 2.5 h and 39.5 GB against 2.2 h and 39.7 GB for C_PT_W, and W_PT_C takes 49 min and 34.9 GB against 32 min and 35.0 GB for W_PT_W. With the front before the post-transport (#140), one of the heaviest origin blocks of C_PT_C needs 37 GB in one part and 156 s for four departure moments, about an eighth of the time without that front. There is no complete measurement yet of the other public transport components. These are the components that cycle to the destination only from a rail or metro stop or from a rail, metro or tram stop (C_PT_rmC, C_PT_rmtC), and those that cycle to a rail, metro, tram or intercity stop.

Two numbers in the table are easy to underestimate. The OSM network needs 19 GB while its cache is only 3 GB on disk, so the sources section is not as light as its few minutes suggest. And the four car caches of a part of the day take 2.8 to 3.0 h each, so 11.2 to 12.0 h together. That is about half the time that GeoDMS 20.26.0 needed (see GeoDMS software).

Run the output of one component at a time. Two output runs side by side make a machine with 128 GB of memory page, so that neither of them makes progress. A smaller set of origins, such as one province, needs much less memory. Computing all blocks in one request instead of in portions needs much more memory, because the memory is then freed only at the end, not between the portions.

How to lower the memory peak

The chain step and the output step are split into blocks to limit the peak: the stop blocks of the chain cache (Advanced/MaxStopBlockSize, Advanced/NumberOfStopBlocks) and the origin blocks of the output (Advanced/MaxOrgBlockSize, Advanced/NumberOfOrgBlocks_All, 450). The number of origin blocks of a run, Advanced/NumberOfOrgBlocks, follows from it: NumberOfOrgBlocks_All, or one block for an OD pair. UpdateAll.cmd computes each step in portions of blocks, with a GeoDmsRun per portion. Smaller blocks or portions lower the peak, but the computation takes longer. The number of blocks per portion of the output is Classifications/Components/BlocksPerPortion (see Model parameters).

A component whose estimated peak per origin block is above Advanced/MaxMemoryPerProcess_GB (64 GB by default) computes every block in parts with fewer origins, each behind its own fence. It writes the union of the parts as the file of the block. With 64 GB, this applies in a national run to C_PT_rmtC (two parts) and to the components without a measurement of their own that take its peak. Set MaxMemoryPerProcess_GB somewhat below the memory of your machine; see MaxMemoryPerProcess_GB.

Keep at least 350 GB of disk space free for the source data, the caches and the output. The size of each cache and output is in the column Result on disk of the table above. For the morning rush hour of 2025, the chain cache and the four car caches take 47 to 50 GB together. The output of the seven components of run E takes 17.1 GB, and their merge 21.0 GB. Each further part of the day adds its own chain cache, car caches and output, except the output of WW and CC, which every part of the day shares. Each further merge variant adds its own merged output.

More processor cores make the chain step faster.


Table of contents