Skip to content

Script reference

Jump to bottom
MaartenHilferink edited this page Nov 9, 2026 · 31 revisions

This page is a reference for developers who work on the model or extend it. It describes how the GeoDMS scripts of the public transport analysis are structured, which containers and templates they define, and how they relate to each other. For the method, see the Public transport page.

Contents

File overview

PublicTransport_Prep.dms and PublicTransport.dms are in cfg/main/NetworkSetup, the files they include in the subfolders PublicTransport_Prep and PublicTransport, and Classifications.dms in cfg/main.

File Role
PublicTransport_Prep.dms The container /NetworkSetup/PublicTransport_Prep: everything that does not depend on the origin block or the departure moment. Its impl defines the origins and destinations, Places, the stop subsets, the two network subsets Set_R and Set_L, BlockSelections and BlockDomain, and includes MakeODs.dms. Outside impl it builds the walking and cycling networks (Create_Optimised_Network_Walking, Create_Optimised_Network_Cycling), the direct trips (Direct, Direct_OD), the pre- and post-transport caches (PrePostTransport) and the candidate legs (Legs), the unique time-stop units, the transfers (Transfers.dms), the chain generation per stop block (ChainGeneration_PerBlock) and the chain cache with its readers (PT_Chains_Blocks, PT, PT_V). It includes OD_Chains.dms, ChainJoiner_T.dms, CreateTransfers_T.dms and Get_Windowed_Agency_Set_T.dms.
Get_Windowed_Agency_Set_T.dms Template that selects the links of the GTFS network in the time window and of an operator set, and builds the NodeSet of unique (time, stop, route) triples and the node references F1 and F2 for the Dijkstra.
MakeODs.dms Defines OD_L and OD_R as impedance_matrix calls on Set_L and Set_R, with their prices and selections (Result, and Result_ToD for the OD pair mode). Includes OD_extra_attributen.dms and OD_traveldist.dms.
OD_extra_attributen.dms Attribute fragment included in both OD_L and OD_R: the stops, times, route, agency and mode of each ride from the NodeSet, Traveltime, IsBoardAlightAllowed and ModeCode, and in impl the fare table lookup for regional transport and the NS station pair key c_NS_start_end_rel.
OD_traveldist.dms Attribute fragment included in OD_L/Result and OD_R/Result: the distance per mode (Traveldist_Bus, Traveldist_Metro, Traveldist_Tram, Traveldist_Rail, Traveldist_Ferry).
Transfers.dms Instantiates CreateTransfers_T for the four pairs of fare groups: Transfers_R_R, Transfers_R_L, Transfers_L_L, Transfers_L_R.
CreateTransfers_T.dms Template that joins the unique arrival events to the unique departure events within walking distance. It computes walking and waiting times, checks validity and computes transfer costs.
ChainJoiner_T.dms Template that joins left chains, a transfer set and a set of right rides. It computes the combined travel time and prices, applies the grade-separated transfer penalty, and keeps the Pareto-optimal chains per group.
OD_Chains.dms Only in the OD pair mode (Impl/IsOD, #129): the stops of the origin and destination (OD_Stops) and the rides and transfers of each chain of the pair (OD_Chains).
PublicTransport.dms Included once per origin block, in /NetworkSetup/ConfigurationPerBlock/<block>/PublicTransport. The block holds all post-transport legs (N), the output request of the block with its counts (Generate_Output), and WriterPart, the block part whose writers write the output of the whole block. Each block part is a container PerPart/<part> of the template BlockPart_T (via for_each_ne over NetworkSetup/impl/OrgParts), with the pre-transport legs of its origins (V), the chains that board where these legs end (PT_InBlock), the direct trips of its origins (Direct_OD) and PerDepartureMoment_T per departure moment (PerDepartureMoment, via for_each_ne over MeasureMoments). See step 3 of From chains to journeys.
PerDepartureMoment_T.dms Template instantiated once per block part and departure moment. For a public transport component it selects the chains in the window of the pre-transport and joins the pre-transport and the post-transport to them; for a direct component it takes the direct trips instead. It condenses in two Pareto steps, unites the block parts and writes the output of the block. Includes OD_Output.dms from the subfolder PerDepartureMoment_T.
OD_Output.dms Only in the OD pair mode: the options of the front with their parts and links, written as a GeoPackage.
Classifications.dms Defines Agencies (with IsNS, IsRO and IsLnet), Chains (the chain combinations), TimeInvariantTypes (the pre- and post-transport types), ChainJoinerParetoAttr, CandidateParetoAttr, FinalParetoAttr, OwnershipParetoAttr and OutputParetoAttr.

Key data types and index units

c_Time_Stops (uint64)

This is the central join key for all time-expanded lookups. It combines a time index and a stop index, combine_unit_uint64(Time, RelevantSelection/Stops), defined as /SourceData/Infrastructure/GTFS/c_Time_Stops:

c_Time_Stop_rel = uint64(Time_rel) * uint64(#Stops) + uint64(Stop_rel)

Decoding:

Time_rel := value(c_Time_Stop_rel / uint64(#Stops), Time)
Stop_rel := value(c_Time_Stop_rel % uint64(#Stops), Stops)

OD_L and OD_R, the transfer sets, the chain joiner and PT use this encoding. The nodes of the time-expanded graph add the route: c_Time_Stop_Routes := combine_unit_uint64(c_Time_Stops, Routes).

uq_c_FromTime_Stop and uq_c_ToTime_Stop

These are units of the unique boarding and alighting events, computed in PublicTransport_Prep from impl/All_Time_Stops, the union of OD_L/Result and OD_R/Result:

uq_c_FromTime_Stop := unique_uint64(impl/All_Time_Stops/c_FromTime_Stop_rel)
uq_c_ToTime_Stop   := unique_uint64(impl/All_Time_Stops/c_ToTime_Stop_rel)
  • Every row of OD_L/Result and OD_R/Result has a uq_c_FromTime_Stop_rel and a uq_c_ToTime_Stop_rel that index into these units.
  • The transfer sets have uq_c_Exit_rel (into uq_c_ToTime_Stop) and uq_c_Reboard_rel (into uq_c_FromTime_Stop).
  • The chain joiner uses equality of these indices as its join keys, which is what makes join_equal_values_uint64 efficient. c_FromTS_ToTS := combine_unit_uint64(uq_c_FromTime_Stop, uq_c_ToTime_Stop) is the key of a pair of events.
  • Each event also carries its time, stop, place and (time, place) index (From_Time_rel, From_Stop_rel, From_Place_rel and c_FromTime_Place_rel, and the same for an alighting event: To_Time_rel and so on). uq_c_FromTime_Stop/IsVBoarding says whether a pre-transport leg of the component ends at the stop.

c_Time_Places (uint64)

This unit is like c_Time_Stops, but at the level of Places: the union of PT_net/SL_Places, the origins (org) and the destinations (dest), in PublicTransport_Prep/impl.

c_Time_Places := combine_unit_uint64(Time, Places)

Decoding:

From_Place_rel := value(c_FromTime_Place_rel % uint64(#Places), Places)
From_Time_rel  := value(c_FromTime_Place_rel / uint64(#Places), Time)

PerDepartureMoment_T uses this index to join the chains (at the stop level) with the pre- and post-transport legs (at the place level). The event units derive it through Stops/Place_rel, and PT_InBlock looks up c_FromTime_Place_rel and c_ToTime_Place_rel per chain; PT has the same attributes.

c_NS_start_end

A combined unit for NS station pairs:

c_NS_start_end := /SourceData/Infrastructure/OVprijzen/NS/NS_TariffUnits_matrix/c_NS_start_end

It is the key of the NS prices in TariffUnitsMatrix (NS_TariffUnits_matrix/ODMatrix, column Price_ct).

  • OD_L builds the key of a ride from its first and last NS station: impl/c_NS_start_end_rel from From_NS_Stations_rel and To_NS_Stations_rel.
  • ChainJoiner_T builds the key of a through fare with combine_data(c_NS_start_end, left_rel->First_NS_Station, right_rel->Last_NS_Station).

Template: Get_Windowed_Agency_Set_T

Parameter: selection_str, a string appended to the selection condition on the GTFS network.

The two instantiations in PublicTransport_Prep/impl are below; PTnet stands for the GTFS network impl/PT_path_str (SourceData/Infrastructure/GTFS/PublicTransportNet):

Set_R := Get_Windowed_Agency_Set_T(
    ' && PTnet_prep/IsRegionalLink && PTnet_prep/IsRideLink' + FlexSelection_str)

Set_L := Get_Windowed_Agency_Set_T(
    ' && ((PTnet/Agency_rel->IsLnet && not(PTnet/Route_rel->IsWithoutNSTicket))
          || (PTnet/Mode_rel == impl/Modes/V/Waiting && IsDefined(PTnet/c_NS_start_end_rel)))
       && PTnet_prep/IsRideLink' + FlexSelection_str)

PTnet_prep/IsRegionalLink takes a link by the agency of its route (Classifications/Agencies/IsRO). For a scheduled link that is its own agency; a waiting link has no agency of its own, and so Set_R holds the waiting links of the regional trips as well. PTnet_prep/IsRideLink keeps the links over which a ride can run: a link with a positive Duration, and a scheduled link of 0 seconds between two different stops, where the vehicle reaches the next stop in the same minute of the feed (#172). A row of WaitingAtStop without a next moment has no Duration and stays out. FlexSelection_str is empty when flex transport takes part (Advanced/IncludeFlex), and otherwise removes the links of flex lines (PTnet_prep/IsFlexLink).

The base filter, whatever selection_str is, keeps the links in the time window: PTnet_prep/IsSub_from (From_Time_rel >= FirstDepartureMoment), IsSub_to (To_Time_rel < LastArrivalMoment) and IsSub_dur (duration <= MaxPTTime).

After filtering, the template:

  1. computes c_fromTime_Stop_rel and c_toTime_Stop_rel for each link, and with its route c_fromTime_Stop_Route_rel and c_toTime_Stop_Route_rel;
  2. constructs doubledLinks, the union of the from-events and the to-events of all links, each with its route;
  3. takes NodeSet := unique(doubledLinks/c_Time_Stop_Route_rel), the set of unique (time, stop, route) triples, so that a ride stays on one route; NodeSet/CanBoard and CanAlight say whether the GTFS allows boarding and alighting there, and DepTrip_rel gives the trip of a departing link;
  4. computes F1 := rlookup(c_fromTime_Stop_Route_rel, NodeSet/c_Time_Stop_Route_rel) and F2 := rlookup(c_toTime_Stop_Route_rel, NodeSet/c_Time_Stop_Route_rel), the from-node and to-node of each link for impedance_matrix.

Output: the unit Set with all filtered links, F1, F2 and NodeSet.

Template: CreateTransfers_T

Parameters: FromDomain and ToDomain, both sets of rides (OD_R/Result or OD_L/Result).

Steps:

  1. Uq_From := unique_uint32(FromDomain/c_ToTime_Stop_rel): the unique arrival events in FromDomain.
  2. Uq_To := unique_uint32(ToDomain/c_FromTime_Stop_rel): the unique departure events in ToDomain.
  3. Transfers := join_near_values_uint32(Uq_From/To_Point, Uq_To/From_Point, MaxTransferDist): a spatial join that gives all pairs of events whose stops lie within that straight-line distance.
  4. For each candidate pair: uq_c_Exit_rel, uq_c_Reboard_rel, Walking_Dist, Walking_Time_rel, Transfer_Time_rel, WaitingAtStop_Time_rel, and MinTransfer_Time_rel. MinTransfer_Time_rel is the walking time, or, between two rail stops of the same NS station, the larger of the walking time and the IFF transfer time of the station (Stops/IFF_TransferTime_rel, Advanced/IFF_TransferTime, #123).
  5. IsValidTransfer: Transfer_Time_rel >= MinTransfer_Time_rel, To_Time_rel > From_Time_rel, Transfer_Time_rel > 0 and Transfer_time <= MaxPTTime (see step 4 of Public transport).
  6. ValidTransfers: the valid transfers, each with Walking_Time_cost, Waiting_Time_cost and Time_cost.

Output: Result := Transfers/ValidTransfers.

Template: ChainJoiner_T

Parameters: Left (the left chains, a Result of a shorter chain or of a single ride), Right (a set of rides, OD_R/Result or OD_L/Result), Transfers (a transfer result unit), LeftStr (the name of the left chain, like 'R' or 'RL') and RightStr ('R' or 'L').

LeftStr and RightStr give Boolean flags:

  • HasLeft_RO, HasRight_RO: whether the left or right part contains regional rides (R).
  • HasLeft_NS, HasRight_NS: whether the left or right part contains NS rides (L or K).
  • NS_transfer_possible: both parts have NS rides; a through fare may apply.
  • NS_through_fare_certain: the left name ends with 'L' and the right name starts with 'L'; the through fare always applies.
  • RO_transfer_possible: both parts have regional rides; the continuation fare (O) may apply.

When the template is instantiated, the flags select which expression an attribute gets. Such an attribute is defined with = followed by a string expression that gives the expression text. GeoDMS has no if at the level of types, so a chain without NS rides carries no NS price computation at all.

Joining:

  • Join_Left_Transf0 := join_equal_values_uint64(Left/uq_c_ToTime_Stop_rel, Transfers/uq_c_Exit_rel). Join_Left_Transf keeps the combinations that can stay within MaxPTTime with the shortest right ride (CanStayWithinMaxPT, MinRightTraveltime).
  • Join_Left_Transf_Pareto := select_with_org_rel(Join_Left_Transf/IsParetoOptimal): pareto_optimal_eps per Group_key (the pair of uq_c_FromTime_Stop_rel of the left chain and uq_c_Reboard_rel of the transfer in c_FromTS_ReboardTS, First_NS_Station, and with GradeSeparatedTransferPenalty above 0 also whether the last ride of the left chain is boarded at street level) on TravelTime and Price_Added, with a regional ride also Price_I and RO_state, with an NS ride also NS_key and NS_key_rev, all with epsilon 0.
  • Join_LeftT_Right := join_equal_values_uint64(Join_Left_Transf_Pareto/transfers_rel->uq_c_Reboard_rel, Right/uq_c_FromTime_Stop_rel).

Combined travel time:

Traveltime_wo_Penalty := Left_rel -> traveltime + Transfers_rel -> Transfer_Time + Right_rel -> traveltime
Traveltime := NeedsTranferTimePenalty
              ? Traveltime_wo_Penalty + GradeSeparatedTransferPenalty
              : Traveltime_wo_Penalty

NeedsTranferTimePenalty is true unless both modes are boarded at street level (Modes/IsStreetLevel), and false when the level of a ride is unknown. Result/ModeCode := Left_rel -> ModeCode * Right/ModeFactor + Right_rel -> ModeCode adds the mode of the right ride in 4 bits, only for the chains that stay.

Validity and Pareto filtering (see the Public transport page for the method):

  1. Is_valid_connection: not IsTravelToSameStop and not IsJourneyLongerThanAllowed (Traveltime above MaxPTTime). Valid1 holds the valid combinations with their prices (Price_I, Price_O, Price_L, Price_S, Price_T, Price_F, Price, Price_augm) and remaining times (remaining_time_excl_NS_transfer, remaining_time_excl_RO_transfer).
  2. The group of the selection is Part_key: the pair of events (OD_pair_key) and the first NS station of the current NS journey (First_NS_Station).
  3. Pareto_condition is pareto_optimal_eps(Part_key, ...) on the criteria of ChainJoinerParetoAttr.

Output: Result := Fence/Result, a uint32 unit of the Pareto-optimal chains through Left, Transfers and Right, with ModeFactor, ModeCode, the prices, TravelTime and two parts of it, the distances per mode, First_NS_Station, Last_NS_Station, Last_NS_AlightTime and Last_RO_AlightTime. The two parts of the travel time are TransferWalkTime, the walking at the transfers of the chain, with the grade-separated penalty, and PTWaitTime, the waiting at the transfers plus the extra time per boarding of a flex ride or a train with a trip surcharge, which a single ride gets in OD_extra_attributen.dms.

The container x holds the result. Fence := PhaseContainer(x, ...) signals progress and separates the result from the intermediate computation graph. This avoids a deadlock in the GeoDMS dependency resolver (see issue 965).

Template: ChainGeneration_PerBlock_T

Instantiated per stop block as ChainGeneration_PerBlock/<block>, via for_each_ne over impl/BlockDomain/name. Parameter: BlockDomain_id, a reference into impl/BlockDomain.

Steps:

  1. Chain_Generation/L/result and Chain_Generation/R/result select the rides of OD_L/Result and OD_R/Result whose boarding stop lies in the block (BlockSelections/Block_rel[From_Stop_rel] == BlockDomain_id) and that board no later than impl/LastBoardingMoment. Block_rel is a random permutation of the stops divided by MaxStopBlockSize, or in the OD pair mode the one block of the stops of the origin.
  2. Chain_Generation instantiates ChainJoiner_T for each chain type of impl/ToBeCalculated_Chains with a right part. It joins the left chains <left>/Result, the transfer set Transfers/<transfer_name>/Result and the right rides OD_<right>/Result over the whole network (in the OD pair mode Result_ToD for the last ride of the longest chains).
  3. Allowed_Chains unites the results of all chain types of impl/Allowed_ChainsK, the single rides included.
  4. A Pareto selection per pair (uq_c_FromTime_Stop_rel, To_Stop_rel), the key OD_pair_key in StarEvent2Stop, on FinalParetoAttr, with pareto_optimal_eps.
  5. BlockResultContainer/Result holds the Pareto-optimal chains (in the OD pair mode only those that end at a stop of the destination, EndsAtD), behind Fence.
  6. Write writes them to the block cache (see The chain cache).

The block key uses To_Stop_rel (the alighting stop) rather than uq_c_ToTime_Stop_rel (the arrival event). So the model collapses different arrival times at the same alighting stop and keeps only the Pareto-optimal chains. The arrival time is still known from uq_c_ToTime_Stop_rel, which stays on the result for the step per departure moment.

The chain cache

With Advanced/PT_Chains_PerBlock (default TRUE), each stop block writes its chains to its own parquet file, <StorageBlockDir_Str>/<n>of<N>.parquet (ChainGeneration_PerBlock/<block>/Parquet, requested through Write). So the results do not stay in memory, and an interrupted chain step resumes at the first missing block. Without it ChainGeneration_Single/Write writes one cache with the chains of all blocks (ChainGeneration_Single/Calc).

  • PT_Chains_Signature holds all parameters that affect the chains; the name of the cache (StorageBase_Str) holds the analysis date, the time window (PT_Chains_Window) and a hash of the signature. PT_Chains_Sig writes the signature in signature.txt in the folder of the cache and checks it on reading.
  • PT_Chains_Blocks/PerBlock/<block> (ReadBlock_T) reads a block cache (Read) and selects the chains that board at a stop where a pre-transport leg of the component ends (VBoarding).
  • PT_Chains_Blocks/ToDo lists the blocks without a cache, and ToDo_List writes their writers to batch\log\chain_blocks_todo.txt for batch\WriteChainBlocks.ps1. PerBlock/<block>/IsWritten tests <n>of<N>.done, which ChainGeneration_PerBlock/<block>/Write writes after the parquet of the block is complete. So the model does not skip a block that was half written when the step was aborted; it makes the block again (see After an abort).
  • PT reads all chains, from the block caches or from the one cache (ChainGeneration_Single/Read), with the derived relations. PT_V reads only the chains of VBoarding, from which each block part takes its own (PT_InBlock).
  • The one cache follows the storage rules of GeoDMS for an MMD (GeoDMS #1245). ChainGeneration_Single/Read is a bare reader that declares nothing, because a read-only MMD reader may declare no items: the dictionary of the cache gives its columns, and PT holds the derived relations. The writer refuses any item with DisableStorage under it, so ChainGeneration_Single/Write writes only the result columns, and the tracing attributes Block_rel and result_rel stay in ChainGeneration_Single/Calc.

The caches of the pre- and post-transport connections (PrePostTransport) and the candidate legs per type (Legs) are described on Walking and cycling legs.

Template: PerDepartureMoment_T

Parameters: inTime (the departure moment as a uint32 time index) and inTime_string (its name). It is instantiated per block part and departure moment as PerPart/<part>/PerDepartureMoment/<moment>, in BlockPart_T in PublicTransport.dms. That gives it the units of the block part, V, PT_InBlock and Direct_OD, and of the block, N.

Main units:

  • Within_VW_Window: the chains of PT_InBlock with inTime <= From_Time_rel <= inTime + Max_V_Time + MaxWaitingTimeAtOrigin, where Max_V_Time is Impl/PT_Max_V_Time. UqModeCode decodes ModeUsed from ModeCode.
  • Add_V_to_PT: join_equal_values_uint64(V/To_Place_rel, Within_VW_Window/From_Place_rel), with the validity IsValid: the waiting time at the origin within MaxWaitingTimeAtOrigin, the arrival at the stop no later than the departure of the chain (IsWaitingTimeValid), IsVTimeNotTooLong and IsPT_departureEvent_ActualPT.
  • Add_V_to_PT/Result: the valid V+PT combinations, with IsFront: the exact pareto_optimal front per origin and arrival place of the chain (OrgArrival_key, uq_OrgArrival) on the criteria of Classifications/OutputParetoAttr.
  • Add_V_to_PT/Front: the combinations of Result with IsFront, which go on to the post-transport; Result_rel is their row in Result.
  • Add_N_to_VPT: join_equal_values_uint64(Add_V_to_PT/Front/To_Place_rel, N/From_Place_rel), with only Traveltime and the validity IsValid: MaxTravelTime and IsNTimeNotTooLong.
  • Add_N_to_VPT/Result: the valid V+PT+N combinations, with Front_rel, PT_rel (the row of Add_V_to_PT/Result) and N_rel, through which it derives the other columns.
  • DirectCar_M: with the time-dependent car trip, the car trips of the component Car at this moment (CarCache, CarRows, DirectCar).
  • AllOptions: the journeys of the component of the run. For a public transport component (WithPT) these are Add_N_to_VPT/Result. For a direct component they are the direct trips (Direct: DirectCar_M with the time-dependent car trip, otherwise Direct_OD), which fill the pre-transport columns.
  • First condensation: Pareto over (uq_c_FromTime_Place_rel, To_Place_rel), producing Result_AfterFirstCondensation.
  • Second condensation: Pareto over (From_Place_rel, To_Place_rel), producing Result_AfterSecondCondensation, the final set of the block part.
  • Result_Fence: that final set behind a fence (PhaseContainer), so that GeoDMS frees the intermediate results of the block part before the next block part starts.
  • BlockResult: the fenced final sets of all block parts of the departure moment, one after the other (PartResults), with the columns that the writers and the counts derive from them.
  • CreateExports: the output file of the block and moment, <OutputDir>/PerBlock/tt_<moment>_<n>of<N>, written from BlockResult; Generate_Output of the block requests only the writers of the first block part (WriterPart). LongFormat/File writes the csv, with the columns of Columns (ExportColumns: those of kind dist only with Export_TravelledDistance, those of kind price only with Export_PriceInformation). With OutputFormat 'parquet', the writer Parquet_Direct, Parquet_Car or Parquet_PT of the component (Impl/ExportClass) writes the parquet. Results_Traveltime/Generate requests the writer, and Results_Traveltime/Counts counts the rows and pairs.
  • OD_Output: only in the OD pair mode.

The front of Add_V_to_PT and both condensations use the criteria of Classifications/OutputParetoAttr.

The ModeUsed string of the output is built per departure moment: the pre-transport type, the PT modes and the post-transport type, separated by underscores. The PT modes come from ModeCode, a uint32 with 4 bits per ride that the chain joiner builds at each join step (see Public transport). The template decodes it once per distinct code (UqModeCode, Classifications/GTFS_Modes/CodeDigits). A direct trip has its letter twice: WW, CC or AA.

Pareto attribute configuration

The Pareto attributes are configured in Classifications.dms.

ChainJoinerParetoAttr

Used inside ChainJoiner_T, selected from ChainJoinerParetoAttr_Candidates:

  • Price when the final front uses Price (IsPriceFinal), otherwise Price_augm;
  • remaining_time_excl_RO_transfer and remaining_time_excl_NS_transfer, always: they keep a chain that is slightly more expensive but can still get a favourable fare at the next transfer;
  • TravelTime, only with a time penalty (HasTimePenalty: GradeSeparatedTransferPenalty above 0, FlexHasTimePenalty or TripSurchargeHasTimePenalty) and when the final front uses time;
  • Price_augm as a tie-break (epsilon 1.0) when the final front uses Price.

The epsilons (EpsilonExpr) are 0 for the prices and remaining times and ChainParetoTimeEpsilon for TravelTime.

CandidateParetoAttr and FinalParetoAttr

CandidateParetoAttr is the pool of candidate attributes: Price, Price_augm and TravelTime, with the FileNameElement values Price, Price_augm and Time and the epsilons 0, 0 and ChainParetoTimeEpsilon.

  • Which of these are active (IsFinalParetoSelection) is set by ModelParameters/MinimiseCriteria, or in the merge of the components by ModelParameters/MergeCriteria: a string with any combination of the FileNameElement values, case-insensitive.
  • If both Price and Price_augm are named, Price is left out.
  • FinalParetoAttr holds the active rows. The block-level selection in ChainGeneration_PerBlock_T uses it.
  • ParetoArgs gives the arguments for pareto_optimal_eps: the first criterion only sets the order and gets no epsilon.

OwnershipParetoAttr and OutputParetoAttr

See Car and bicycle ownership as criteria and #117.

  • OwnershipParetoAttr selects the Boolean criteria NeedsCar and NeedsBike from OwnershipParetoAttr_Candidates, when MinimiseCriteria (when merging, MergeCriteria) names Car or Bike and the criterion can differ between options (IsRelevant).
  • OutputParetoAttr is FinalParetoAttr plus OwnershipParetoAttr. The two condensations per departure moment use it; the chain generation keeps ChainJoinerParetoAttr and FinalParetoAttr, so the chain cache does not depend on it.
  • Its ParetoArgs gives the arguments of each criterion for pareto_optimal_eps: a number with its epsilon, a Boolean without.

Important model parameters

Parameter Location Meaning
MaxPTTime ModelParameters Maximum time in public transport, including transfers and waiting (90 min).
MaxTravelTime ModelParameters Maximum total journey time including pre- and post-transport (90 min).
Max_transfers ModelParameters Maximum number of transfers (3, from 1 to 4, and at most 3 in the OD pair mode); sets the longest chain in Classifications/Chains.
Transfer_Walking_Time_Costs ModelParameters Cost per minute of walking at a transfer (0.19 euro/min).
Transfer_Waiting_Time_Costs ModelParameters Cost per minute of waiting at a transfer stop (0.05 euro/min).
PreTransport, PostTransport, DirectWalking, DirectCycling, DirectCar ModelParameters The variant: a switch per pre- and post-transport type and per direct trip. Every pre-transport type that is on with every post-transport type that is on is a component, and so is every direct trip that is on; UpdateAll.cmd computes one component per GeoDmsRun step (Impl/ComponentName, from ConfigSettings/Overridable/RunComponent). See Components and merging.
Merge, MergeCriteria, MergeRunNr ModelParameters Whether UpdateAll.cmd merges the components of the variant into one front, the criteria of that front, and the number of its output folder.
MergeVariants ModelParameters The merge variants: per row a name, the components, the criteria and the number of a merge, which UpdateAll.cmd -variant <name> uses instead of the switches of the variant, MergeCriteria and MergeRunNr (Impl/HasVariant, from ConfigSettings/Overridable/Variant). See Merge variants and settings per call.
MaxTransferDist ModelParameters/Advanced Maximum straight-line distance of a transfer walk (500 m).
TransferEffectiveSpeed ModelParameters/Advanced Walking speed of a transfer over the straight distance: TransferWalkingSpeed (4.5 km/h) divided by TransferDetourFactor (1.2), in m/s.
IFF_TransferTime ModelParameters/Advanced Whether a transfer between two rail stops of the same NS station takes at least the IFF transfer time of the station (TRUE).
MaxTransferTimeForBoardingSurcharge ModelParameters/Advanced Maximum time between a check-out and the next check-in to stay within one fare journey: the regional continuation fare (O) and the NS through fare (35 min).
GradeSeparatedTransferPenalty ModelParameters/Advanced Extra time for a transfer from or to a mode that is not boarded at street level (0 min).
MaxStopBlockSize ModelParameters/Advanced Maximum number of stops per stop block (104).
NumberOfStopBlocks ModelParameters/Advanced Number of stop blocks (500, 1 in the OD pair mode); MaxStopBlockSize * NumberOfStopBlocks must exceed the number of stops.
PT_Chains_PerBlock ModelParameters/Advanced Whether each stop block writes its own chain cache (TRUE).
MaxWaitingTimeAtOrigin ModelParameters/Advanced Maximum waiting time at the origin before departing (899 s).
IncludeWaitingAtHomeInTravelTime ModelParameters/Advanced Whether the waiting time at the origin counts in the travel time (FALSE).
Cycling_PreTransport_Penalty ModelParameters/Advanced Extra time at the end of every cycling pre-transport leg (0 min).
AllowDirectWalking, AllowDirectCycling, AllowDirectCar ModelParameters/Impl Which direct trip the component of the run is (Impl/ComponentName); all three FALSE for a public transport component.
IncludeCyclingCostsInPrice, IncludeWalkingCostsInPrice ModelParameters/Advanced Whether the costs of cycling on an own bike (the costs per kilometre as an amount per minute) or of walking (a valuation of the time) count in the monetary Price, and not only in Price_augm (TRUE, FALSE).
MinimiseCriteria ModelParameters The criteria of the front of a component ('Price,Time'); Car and Bike add the ownership criteria to the condensations. In the signature of the chain cache.
Analysis_date ModelParameters/Impl The day of the analysis: ModelParameters/AnalysisDay when that is set, otherwise the analysis date of AnalysisMoment; in the name and signature of the chain cache and the output.
PriceExportsAndIntegrityChecksNeeded ModelParameters/Impl Derived: true when MinimiseCriteria names a price or Export_PriceInformation is on. If false, the chain cache keeps no prices and the price integrity checks are skipped.

NetworkModel PBL documentation

© Object Vision BV. Documentation under CC BY-SA 4.0, source code under GNU GPL v3.

Clone this wiki locally