Skip to content

Model Steps

Jump to bottom
Binny Paul edited this page Nov 30, 2020 · 111 revisions

Model Flow

The ABM is run via the RunModel.bat DOS batch file. The model system has been developed as a ‘turnkey’ system; the user has only to code the model inputs and run the model through the batch file. It will run all model components, iterate the system, and write all outputs. The batch file performs the following sequential steps:

  1. Set properties and empty outputs folder

  2. Check model inputs for errors

  3. Build networks for skimming in VISUM + Python for TAZs, then MAZs, and then TAPs

  4. Create skims using "warm start" speeds in VISUM + Python for TAZs, then MAZs, and then TAPs

  5. Run the commercial vehicle model and external model in R

  6. Start a feedback loop up to max iterations

    1. Run OR-RAMP ABM in Java
    2. Build MAZ, TAZ, and TAP trip demand matrices for assignment
    3. Create skims and assignments using congested speeds in VISUM + Python for TAZs and then TAPs
    4. Check for completion and repeat feedback loop if needed

More details on the RunModel.bat script can be found here. The subsequent sections describe these steps in detail.

Step 0 – Set Properties and Empty Outputs Folder

Before running any modeling procedures, software paths and scenario properties are set for the model run. These settings are automatically determined and are logged to the console. Meaning that the user doesn't need to change any file or directory pointers, those are all recalculated on the fly. This allows a model setup (i.e. scenario) to be easily copied from one scenario to another, and from one machine to another. The outputs folder and the subfolders are emptied to ensure model steps do not run with old input files.

Step 1 – Check Model Inputs for Errors

The next step after setting all properties is to review the model inputs for any errors. The inputs are reviewed by calling the Input Checker Tool

Step 2 – Build Networks for Skimming

The first step in the model process is to build the TAZ, TAP, and MAZ networks for skimming based on the input master VISUM version file – SOABM.ver [PRIVATE].

TAZ Network

The first network created is the TAZ network, which is used for auto skims. This network is created using the taz_initial entry point in the Master_Runner.py Python script. The taz_initial call of the script does the following:

  1. Starts VISUM via the Python win32 COM server
  2. Loads the inputs/SOABM.ver master version file
  3. Codes TAZs connectors. Note this is a feature that can be used when first developing the network. This procedure generated a reasonable set of TAZ connectors that the user can (and has) further edit. As a result of the manual revisions to the connectors, the codeTAZConnectors() function that implements this step is currently commented out in the script. When it is being applied, coding TAZ connectors starts by finding all candidate nodes, which are network nodes that serve arterial and collector link facility types (see Link Attributes). Next, the procedure creates a TAZ connector for up to the four closest candidate nodes and calculates the travel time at 25 mph. The final step is to go back through the set of connectors generated and remove any that are too close to one another. Connectors are deemed too close if their network nodes are within 500 feet of one another.
  4. Save the version file for TAZ skimming to outputs\networks\Highway_Skimming_Assignment_Setup.ver
  5. Closes VISUM

TAP Network

The second network created is the TAP network, which is used for transit skims from boarding TAP through any potential transfer TAPs, to alighting TAP. This network is created using the tap_initial entry point in the Master_Runner.py Python script. The tap_initial call of the script does the following:

  1. Starts VISUM via the Python win32 COM server
  2. Loads the inputs/SOABM.ver master version file
  3. Assigns VISUM stops areas (TAPs) to transit access nodes so trips can get from TAPs to the network. The results are essentially transit access connectors. The procedure selects all candidate network nodes (all links except for freeways and ramps) and then assigns each stop area to the closest candidate node by setting the StopArea’s NodeNo attribute.
  4. Switches the VISUM Zone objects from TAZs to TAPs. The initial ABM version file has Zones coded as TAZs and transit stop areas coded as TAPs. In order to generate TAP to TAP skims, the procedure deletes the TAZ zones and creates TAP zones. Each stop area X and Y is used to create a new zone X and Y centroid. Then a zone connector is created to the previously defined transit access node. The travel time is calculated at 3 mph.
  5. Save the version file for TAP skimming to outputs\networks\Transit_Skimming_Assignment_Setup.ver
  6. Creates the TAP lines file – outputs\skims\tapLines.csv. The TAP lines file contains a list of the line routes served at each TAP (stop area). This file is used by CT-RAMP to trim the available set of boarding and alighting stops to consider when doing transit virtual path building. Only stops that are further away and serve new lines are considered when building walk-transit paths.
  7. Creates the fare matrix – outputs\skims\fare.omx. Fares are modeled as TAP to TAP OD and assigned using the StopArea FAREZONE attribute and the input fares.csv file [PRIVATE]. Each StopArea is coded as either Grants Pass or Rogue Valley. The fares.csv file includes fares by OD in the form of FROMFAREZONE, TOFAREZONE, and FARE.
  8. Closes VISUM

MAZ Network

The third network created is the MAZ network, which is used to calculate non-motorized times and distances, including access and egress walking times between MAZs and boarding\alighting TAPs, and walk\bike times between close MAZs. Drive times to TAPs are calculated after TAZ skims are created in the next model step. This network is created using the maz_initial entry point in the Master_Runner.py Python script. The maz_initial call of the script does the following:

  1. Starts VISUM via the Python win32 COM server

  2. Loads the inputs/SOABM.ver master version file

  3. Assigns VISUM stops areas (TAPs) to transit access nodes so trips can get from TAPs to the network. The results are essentially transit access connectors. The procedure selects all candidate network nodes (all links except for freeways and ramps) and then assigns each stop area to the closest candidate node by setting the StopArea’s NodeNo attribute. This is required for creating the MAZ to TAP walk access distance files.

  4. Switches the VISUM Zone objects from TAZs to MAZs. The initial ABM version file has Zones coded as TAZs and Mainzones coded as MAZs. In order to generate MAZ to MAZ/TAP distances, the procedure deletes the TAZ zones and creates MAZ zones. Each mainzone X and Y is used to create a new zone X and Y centroid. Then up to four zone connectors are created to the closest candidate nodes. Candidate nodes are all links with walk or bike in the TSysSet. Finally, all mainzone user-defined attributes are copied over to the zone attributes, including the zone polygons as well-known-text (WKT).

  5. Calculates CT-RAMP MAZ density measures as zone attributes. The attributes are:

    1. DUDEN – total MAZ households / total MAZ acres within a ½ mile of each MAZ centroid
    2. EMPDEN – total MAZ employment / total MAZ acres within a ½ mile of each MAZ centroid
    3. TOTINT – total intersections within a ½ mile of each MAZ centroid
    4. POPDEN – total MAZ population / total MAZ acres within a ½ mile of each MAZ centroid
    5. RETDEN – total MAZ retail employment / total MAZ acres within a ½ mile of each MAZ centroid

  6. Sets the SEQMAZ attribute as 1 to the number of MAZs since this is required for CT-RAMP

  7. Save the version file for MAZ skimming to outputs\networks\MAZ_Level_Processing_Setup.ver

  8. Creates the CT-RAMP sub-model destination alternative files in the output folder.

    1. ParkLocationAlts.csv – Alt, MAZ, ParkArea type (see Park Location Alternatives)
    2. DestinationChoiceAlternatives.csv - Alt, MAZ, TAZ (see Destination Choice Alternatives)
    3. SoaTazDistAlternatives.csv – Alt, TAZ (see Sample of Alternatives)
    4. ParkLocationSampleAlts.csv – Alt, MAZ (see Park Location Sampling)

  9. Writes the MAZ land use data output file to inputs\maz_data_export.csv. This is the key land use input file to CT-RAMP and contains the fields in MAZ Data File Export.

  10. Closes VISUM

Go to Top

Step 3 – Create Skims

The next step in the model is to create skims using the TomTom link speed data. As shown in TomTom Data Integration below, the VISUM master version file includes TomTom link speeds by time-of-day (TOD).

TomTom Data Integration

TAZ SKIMS

The first set of skims created are the TAZ (auto) skims. The TAZ skims are created by calling the taz_skim_speed entry point in the Master_Runner.py Python script. The taz_skim_speed call of the script does the following by time-of-day:

  1. Starts VISUM via the Python win32 COM server

  2. Loads the outputs/networks/taz_skim_initial.ver version file

  3. Loads and run the TAZ skimming procedures stored in config/visum/taz_skim_[TOD]_speed.xml. The procedures do the following:

    1. Set time-of-day link number of lanes based on the generic number of lanes
    2. Set time-of-day link capacity based on number of lanes (LANES_[TOD], capacity per lane (LANECAP), and time-of-day (NETWORK\TOD_FACTOR_[TOD])
    3. Saves V0PrT to FFSPEED so it can be used in subsequent iterations of skimming.
    4. Set the time-of-day link speed [TOD]_SPEED using the linkSpeeds.csv input file [PRIVATE], which looks up a time-of-day speed based on link PLANNO (facility type), SPEED (free flow speed), and TOD (time-of-day).
    5. Calculates and output skims in OMX format, as defined in TAZ Skim Matrices.
    6. The procedures define the link generalized cost by demand segment and volume-delay functions under Calculate + Procedures + General Procedure Settings + PrT Settings + Impedance & Volume-delay functions as:
      • GenCost = 1 * Tcur_PrTSys([DSEG]) + (3600/[VOT]) * Toll_PrTSys([DSEG]) + (3600 * [AOC]/[VOT] * Length)
      • 6 Global (network) user attributes have been set in Visum for use in this equation, they are:
        • AOC_AUTO = 0.18 ($/mi) Auto Operating Costs for the Auto Mode
        • VOT_AUTO_PK = 19.27 ($/hr) Value of Time for the Auto Mode for Peak Periods
        • VOT_AUTO_OPK = 12.82 ($/hr) Value of Time for the Auto Mode for Off-Peak Periods
        • AOC_TRUCK = 0.75 ($/mi) Auto Operating Costs for the Truck Mode
        • VOT_TRUCK_PK = 39.00 ($/hr) Value of Time for the Truck Mode for Peak Periods
        • VOT_TRUCK_OPK = 39.00 ($/hr) Value of Time for the Truck Mode for Off-Peak Periods (there is currently no research to suggest that Truck VOT varies by time of day, but the option exists in the code to change it, if new time-of-day VOT information for Trucks is found or desired to be tested)
      • The above parameters use Metro VOT assumptions in 2010 dollars exactly as provided from Metro - $39.00/hr for trucks, $19.27/hr for auto peak, and $12.82/hr for auto off-peak.
      • AOC_AUTO is set to use the global fleet average of 0.18 ($/mi) for light duty vehicles.
      • AOC_TRUCK is based on an annual survey conducted by ATRI and reported in "An Analysis of the Operation Costs of Trucking: 2019 Update." The averaged Truck AOC includes fuel, repair & maintenance, and tires - total cost of approximately $0.75/mile (adjusted to 2010 dollars).
      • VDF = Modified BPR; connectors have fixed travel times

  4. Save the version file, which includes the skims, to outputs\networks\Highway_Assignment_Results_[TOD].ver

  5. Creates the TAZ to TAP drive access time information for drive transit impedance. The procedure gets the SOV time, distance, and toll skims, as well as the list of TAPs with CANPNR=1 (true). It then assigns each TAP centroid to the nearest TAZ centroid. This information is written to the outputs/skims/tap_data.csv file required by CT-RAMP. The final step is to loop through all TAZs and TAPs with CANPNR=1 and write data for the interchanges that are within the max distance. The procedure has a different max distance by transit sub-mode, which is currently set to 4 miles for local bus. The results are written to outputs/skims/drive_taz_tap.csv. See Taps Input File and TAZ to near TAPs for more information on the output files.

  6. Closes VISUM

MAZ SKIMS

The second set of “skims” created are the MAZ (non-motorized) skims. The MAZ skims are created by calling the maz_skim entry point in the Master_Runner.py Python script. The maz_skim call of the script does the following for bike and then for walk:

  1. Starts VISUM via the Python win32 COM server

  2. Loads the outputs/networks/maz_skim_initial.ver version file

  3. Creates the MAZ to TAP output files – outputs/skims/tap2maz_[walk|bike].csv (see TAP to MAZ DIstances). The procedure loops by TAP node and runs the VISUM Isochrone procedure to code the travel distance from the TAP node to all network elements (including MAZ centroids). The setting by mode are (code can be seen here):

    1. Walk - 3 mph and 2 miles max
    2. Bike – 10 mph and 5 miles max

  4. Loads and run the MAZ to MAZ skimming procedures stored in config/visum/maz_skim_[walk|bike].xml. The output distance skim is stored in the version file. The walk network is all links with walk in the TSysSet. The bike network is all links with bike in the TSysSet.

  5. Creates the nearby MAZ file by looping through cells in the MAZ to MAZ skim matrix and writing to the output CSV file all OD pairs less than the maximum distances. The output file is outputs/skims/maz2maz_[walk|bike].csv (as defined in MAZ to MAZ Distances).

  6. Save the version [file], which includes the walk skims, to outputs\networks[walk|bike]_MAZ_Skim_Setup.ver

  7. Closes VISUM

TAP SKIMS

The third set of skims created are the TAP (transit stop-to-stop) skims. The TAP skims are created by calling the tap_skim_speed entry point in the Master_Runner.py Python script. The tap_skim_speed call of the script does the following by time-of-day and skim set:

  1. Starts VISUM via the Python win32 COM server

  2. Loads the outputs/networks/taz-skim-[TOD]_speed.ver version file and writes the link speeds to a CSV file for updating the transit run times - outputs/networks/taz-skim-[TOD]-speed_linkspeeds.csv. The link speed used in the VCur_PrTSys(HOV3Toll) attribute (see TAZ Assignment Speeds).

  3. Loads the outputs/networks/tap_skim_initial.ver version file and loads the link speeds written out earlier into the link V0PrT attribute in order to set the transit runtimes as a function of the highway congested link times.

  4. Loads and runs the config/visum/tap_skim_speed_[TOD].xml procedure file to calculate the transit run and dwell times and skims. The transit run and dwell time functions, plus the path-finding settings are below:

    1. Link runtime for freeways = tCur / 0.9
    2. Link runtime for other facilities = tCur / 0.75
    3. Node dwell time = 120 seconds per mile traveled
    4. Path finding choice using ‘optimal strategies’
    5. Path finding weights for set 1 * = IVT=1, WLK=2, OWT=2, TWT=2, NTR=10min (default)
    6. Path finding weights for set 2 * = IVT=1, WLK=2, OWT=2, TWT=2, NTR=10min (same as set1 for now)
    7. Path finding weights for set 3 * = IVT=1, WLK=2, OWT=2, TWT=2, NTR=10min (same as set1 for now)
    8. Headway attribute = LineRoute[TOD]_HEADWAY (seconds)
    9. Transit walk links are permitted and max walk time is set to 30 minutes
    10. Uses 0.0001 for one OD pair in order to trick VISUM to run assignment and skimming

    * IVT: In-Vehicle Time, WLK: Walk Time, OWT: Origin Wait Time, TWT: Transfer Wait Time, NTR: Number of Transfers

  5. Writes the skims to OMX files using the config/visum/tap_skim_[TOD]_set[SETID].par file. The skims are defined in TAP Skim Matrices.

  6. Save the version file, which includes the skims, to outputs/networks/tap_skim_[TOD]_speed_set[SETID].ver

  7. Updates the fare matrix created in the skimming procedure (which is 0) with the custom fare matrix created earlier – outputs\skims\fare.omx

  8. Revises skims across skim sets with duplicate levels-of-service in order to avoid CT-RAMP seeing duplicate service. This is done by setting all skims to 0 if the total time in an OD pair (IVT+OWT+TWT+WKT) is the same across skim sets. This is done only in the OMX files and not in the skims in the VISUM version files.

  9. Closes VISUM

Go to Top

Step 4 – Run The Commercial Vehicle Model

The next step in the model is to run the commercial vehicle model (CVM). The CVM model is run via RSCRIPT and is called by running the scripts\cvm.R script. The CVM model input and output files are described in CVM Outputs. The CVM is a trip-based commercial vehicle model that produces trips by car, single-unit truck, and multi-unit truck by time-of-day.

Step 5 – Run The External Model

The next step in the model is to run the SWIM external model. The SWIM external model is run via RSCRIPT and is called by running the scripts\externalModel_SWIM.R script. The SWIM external model input and output files are described on the External Model page. The SWIM external model, based on the Oregon statewide integrated model runs select link analysis in the SWIM assignment at each SOABM external station in order to build traversal matrices by mode and time-of-day for the SOABM external flows (as shown for example in Swim Flows).

Swim Flows Entering Southern Oregon at Station 1 (I-5 NORTH)

Start Feedback Loop (Steps 6-8)

This step starts the overall model feedback loop which runs up to iterations equal to %MAX_ITER%, set in Step 0 (at the beginning of this page). The feedback loop is used to equilibrate the person travel demand models and the network capacity models. First, the model generates estimates of person trips. The person trips and auxiliary trips (commercial trips and external trips) are then loaded onto the network. As a result, congestion occurs on select links and new OD travel times are calculated using the link volume-delay functions. After generating new travel time matrices, the person travel models are re-run and new destinations, modes, etc. are chosen and the trips re-loaded onto the network. This process is repeated until an acceptable level of convergence is achieved.

The model makes use of assignment warm starting in order to smooth convergence. The VISUM highway assignment procedure files - config/visum/taz_skim_[TOD].xml - are set to use the existing paths in the version file if available as the starting point for assignment.

Go to Top

Step 6 – Run OR-RAMP ABM

OR-RAMP, the Oregon DOT version of CT-RAMP described in greater detail in Activity Based Model, is run in this model step. The procedure starts by instantiating three Java processes:

  1. Household data server to store all households and their persons, tours, and trips
  2. Matrix data server to store all the TAZ and TAP matrices required for the model
  3. The main model process that starts the model run, reads in the households, runs each household through the synthetic travel diary creation process, and then writes out tour and trip files for each household.

For ABM, all three processes are run on the same machine. OR-RAMP can be setup to run on multiple machines if required (i.e. faster runtimes and/or more RAM is required).

The OR-RAMP model flow chart is shown in Activity-Based Model. The model starts with long-term and mobility choice models such as auto ownership and usual work and school location choice. Next, the model simulates a typical day of travel for each individual in the region. It starts with day pattern – whether a person stays at home on the simulation day, makes mandatory travel (work and/or school), and/or non-mandatory travel. For each type of travel, it then generates tours and assigns all the required attributes – purpose, destination, time-of-day, and mode. After generating tours, each tour is processed to assign the number of stops along the tour, their purpose, location, and time-of-day. These stops are then processed as trips to assign mode and parking location. Finally, trips are aggregated into demand matrices for assignment at the TAZ and TAP level in VISUM.

OR-RAMP Properties File presents the properties in the OR-RAMP properties file. The following are the key inputs to model:

The key outputs of OR-RAMP are:

Go to Top

Step 7 – Build Trip Demand Matrices

After running the microsimulation person travel models, the trips output need to be aggregated to demand matrices for assignment in VISUM. This is done with the build_trip_matrices entry point in the Master_Runner.py Python script. The procedure has two steps:

  1. build CT-RAMP MAZ, TAZ and TAP matrices
  2. load the CT-RAMP matrices + the CVM and external matrices into VISUM

The following trip matrices by mode and time period are created from the CT-RAMP trips:

  • outputs\trips\ctrampTazTrips.omx
    • SOV_[TOD]
    • SOVToll_[TOD]
    • HOV2_[TOD]
    • HOV2Toll_[TOD]
    • HOV3_[TOD]
    • HOV3Toll_[TOD]
  • outputs\trips\ctrampTapTrips.omx
    • Set1_[TOD]
    • Set2_[TOD]
    • Set3_[TOD]
  • outputs\trips\ctrampNmTrips.omx
    • Walk_[TOD]
    • Bike_[TOD]

The person trips are converted to vehicle trips using an assumed occupancy of 2 for HOV2 and 3.33 for HOV3+. If a trip selected a different parking zone from its destination zone (in the constrained parking areas only), then trip destination is changed to the parking destination in the trip matrix. For escort trips, any case where the driver person number is equal to the escort person number, the trip is converted to one vehicle trip with an occupancy equal to the occupancy for the mode. For park and ride and kiss and ride trips, an auto trip from the MAZ to the TAP is added into the auto trip matrices as well (SOV for park and ride and HOV2 for kiss and ride). The matrices are scaled by the household sample rate at this point in the model to ensure the number of trips is consistent with the link capacities when calculating congested travel times. For example, if a 50% sample of households is run, then each trip generated by CT-RAMP is multiplied by 2.
When loading the matrices into VISUM for assignment, the demand matrices are aggregated as follows:

  • SOV (matrix 100) = cvm_car + ext_hbw + ext_nhbnw + ext_hbo + ext_hbcoll + ext_hbr + ext_hbs + ext_hbsch + ext_nhbw + ct_sov
  • HOV2hov2 (matrix 101) = ct_hov2
  • HOV3 (matrix 102) = ct_hov3
  • Truck (matrix 103) = cvm_su + cvm_mu + ext_truck
  • SOVToll (matrix 104) = ct_sovtoll
  • HOV2Toll (matrix 105) = ct_hov2toll
  • HOV3Toll (matrix 106) = ct_hov3toll
  • Transit (matrix 107) = ct_transit #each transit set is in a different version file
  • Walk (matrix 150) = ct_walk # walk and bike demand matrices are in separate version files
  • Bike (matrix 151) = ct_bike # walk and bike demand matrices are in separate version files where,
    • ct = CT-RAMP
    • cvm = commercial vehicle model
    • ext = external model

Go to Top

Step 8 – Create Skims and Assignments Using Congested Speeds

The next step in the model is to assign the trip demand matrices to the network and to re-generate the TAZ and TAP skims as a function of congestion. The resident, commercial, and external trips generated in previous step are already in VISUM at this point, so this step essentially loads the previously created VISUM skimming version files and run different skimming and assignment procedures that use congested travel times instead of travel times calculated from TomTom speeds. The MAZ level network impedances remained unchanged because they are a function of shortest path network distances. This step is split into two entry points in the Master_Runner.py Python script: taz_skim and tap_skim.

TAZ Skims

The TAZ skims are created by calling the taz_skim entry point in the Master_Runner.py Python script. The taz_skim call of the script does the following by time-of-day:

  1. Starts VISUM via the Python win32 COM server
  2. Loads the outputs/networks/Highway_Assignment_Results__[TOD].ver version file created earlier
  3. Loads and run the TAZ skimming procedures stored in config/visum/taz_skim_[TOD].xml. The procedures do the following:
    1. Set time-of-day link number of lanes based on the generic number of lanes
    2. Set time-of-day link capacity based on number of lanes (LANES_[TOD], capacity per lane (LANECAP), and time-of-day (NETWORK\TOD_FACTOR_[TOD])
    3. Set link speed using FFSPEED set earlier as V0PrT
    4. Runs equilibrium assignment with a relative gap of 10-4, 100 iterations, and warm starting
    5. Calculates and output skims in OMX format, as defined in TAZ Skims Matrices.
    6. The settings are the same as the previous skimming procedures
  4. Save the version file, which includes the skims and assignment paths, to outputs\networks\Highway_Assignment_Results_[TOD].ver
  5. Creates the same TAZ to TAP drive access time information file as before
  6. Closes VISUM

TAP SKIMS

The TAP skims are created by calling the tap_skim entry point in the Master_Runner.py Python script. The tap_skim call of the script does the following by time-of-day and skim set:

  1. Starts VISUM via the Python win32 COM server
  2. Loads the outputs/networks/Highway_Assignment_Results_[TOD].ver version file and writes the link speeds to a CSV file for updating the transit run times - outputs/networks/Highway_Assignment_Link_Speeds_[TOD].csv. The link speed used in the VCur_PrTSys(HOV3Toll) attribute (see TAZ Assignment Speeds).
  3. Loads the outputs/networks/Transit_Skimming_Assignment_Setup.ver version file created earlier and loads the link speeds written out earlier into the link V0PrT attribute in order to set the transit runtimes as a function of the highway congested link times.
  4. Loads and runs the config/visum/tap_skim_[TOD].par procedure file to calculate the transit run and dwell times and skims using the same function as before. This time it assigns trips as opposed to using a very small number of trips for one OD pair.
  5. Writes the skims to OMX files using the config/visum/Transit_Assignment_Results_[TOD]_set[SETID].xml file. The skims are defined in Tap Skim Matrices.
  6. Save the version file, which includes the skims, to outputs/networks/Transit_Assignment_Results_[TOD]_set[SETID].ver
  7. Revises skims across skim sets that have duplicate levels-of-service like before.
  8. Closes VISUM

Step 9 – Feedback Loop

If the max number of overall model iterations (loops) has not been completed, then the model returns to the start of the feedback loop, runs CT-RAMP with the new set of skim matrices and then runs assignment and skimming as well.

Step 10 - Non-motorized Assignment

After the completion of feedback loops, the final walk and bike demand matrices are assigned to the all-streets network. The non-motorized assignment is performed by calling the nm_assignment entry point in the Master_Runner.py Python script. The nm_assignment call of the script does the following by time-of-day for both bike and walk mode:

  1. Starts VISUM via the Python win32 COM server
  2. Loads the outputs/networks/Walk_Bike_Assignment_Results_[TOD].ver version file created earlier
  3. Loads and run the MAZ assignment procedures stored in config/visum/maz_assign_[walk/bike].xml. The procedures runs equilibrium assignment using link length as the impedance with a relative gap of 10-4, 100 iterations.
  4. Save the version file to outputs/networks/Walk_Bike_Assignment_Results_[TOD].ver
  5. Closes VISUM

Once the non-motorized assignment has been completed, then model run is finished, and the output summary visualizer is generated.

Go to Top

Home

Guides

Model Description

Appendix

Clone this wiki locally