IITA - Iterative Integer Traffic Assignment

High-performance C++ implementation of the Iterative Integer Traffic Assignment (I-ITA) algorithm for transportation network analysis.

Overview

IITA is a traffic assignment algorithm that assigns discrete vehicle trips to network paths using K-shortest paths with Logit-based path choice. This implementation features:

• K-Shortest Paths: Multiple path enumeration per OD pair
• MSA Convergence: Method of Successive Averages for flow updates
• Path Size Logit (PSL): Correction for path overlap
• Adaptive Theta: OD-specific scale parameter calibration
• Multi-threaded: Parallel computation for large networks
• BPR Function: Bureau of Public Roads link performance

Version

IITA 0.2 (no shp)

Requirements

• C++17 compiler (GCC 7+, Clang 6+, MSVC 2017+)
• CMake 3.16+
• POSIX threads (Linux/macOS) or Windows threads

Build

mkdir build && cd build
cmake ..
cmake --build . --config Release

The executable iita (or iita.exe on Windows) will be created in the build directory.

Usage

./iita --data <data_directory> --k <K_value> --output <output_directory>

Options

Option	Description	Default
--data, -d	Network data directory (required)	-
--k, -k	Number of paths per OD pair (required)	-
--output, -o	Output directory (required)	-
--theta	Scale factor for Logit model	2.0
--no-adaptive-theta	Disable OD-specific theta calibration	off
--no-psl	Disable Path Size Logit correction	off
--overlap-threshold	Overlap filtering threshold	0.9

Example

./iita -d networkDatasets/SiouxFalls -k 2 -o results/siouxfalls_k2
./iita -d networkDatasets/chicago-regional -k 5 -o results/chicago_k5 --theta 1.5

Input Data Format

The program expects TNTP (Transportation Network Test Problems) format files:

<data_directory>/
├── <network>_net.tntp    # Link/edge data
├── <network>_node.tntp   # Node coordinates (optional)
└── <network>_trips.tntp  # OD demand matrix

Network File Format (_net.tntp)

Tab-separated fields:

• init_node: Origin node ID
• term_node: Destination node ID
• capacity: Link capacity (vehicles/hour)
• length: Link length (feet or miles)
• free_flow_time: Free-flow travel time (minutes)
• b: BPR function coefficient (default: 0.15)
• power: BPR function power (default: 4)
• speed: Speed limit
• toll: Toll cost
• link_type: Link classification

Trips File Format (_trips.tntp)

<origin> <destination> <demand>

Output Files

File	Description
summary.csv	Aggregate statistics per run
link_flows.csv	Per-link flows and travel times
path_flows.csv	Per-path flow assignments
turning_volumes.csv	Intersection turning movement counts

Output Metrics

• VKT: Vehicle-Kilometers Traveled
• VHT: Vehicle-Hours Traveled
• TSTT: Total System Travel Time (veh-min)
• VOC: Volume-to-Capacity ratio
• Congested Links: Links with V/C > 0.8

Network Datasets

Included benchmark networks:

Network	Zones	Nodes	Links
SiouxFalls	24	24	76
Anaheim	384	416	914
Chicago-Sketch	387	933	2,950
Chicago-Regional	1,790	12,982	39,018
Philadelphia	1,525	13,389	40,003

Algorithm Details

I-ITA Algorithm

1. Path Generation: Enumerate K-shortest paths for each OD pair
2. Flow Assignment: Assign integer flows using Logit/PSL probabilities
3. Travel Time Update: Recalculate link travel times via BPR function
4. Convergence Check: Compare flow differences across iterations
5. MSA Update: Average flows if not converged

BPR Link Performance Function

t = t0 * (1 + b * (v/c)^power)

Where:

• t: Actual travel time
• t0: Free-flow travel time
• v: Volume (flow)
• c: Capacity
• b: Coefficient (default: 0.15)
• power: Exponent (default: 4)

Path Size Logit (PSL)

Corrects for path overlap in route choice:

P(path) = exp(V + ln(PS)) / sum(exp(V' + ln(PS')))

Project Structure

ITAM_CPP/
├── CMakeLists.txt          # Build configuration
├── main.cpp                # Entry point
├── src/
│   ├── network.h           # Network data structures
│   ├── parser.h/cpp        # TNTP file parser
│   ├── integer_assignment.h/cpp  # I-ITA algorithm
│   ├── metrics.h/cpp       # Performance metrics
│   └── export.h/cpp        # CSV export utilities
└── networkDatasets/        # Benchmark networks
    ├── SiouxFalls/
    ├── Anaheim/
    ├── Chicago-Sketch/
    ├── chicago-regional/
    └── Philadelphia/

License

MIT License

References

• Transportation Network Test Problems (TNTP): https://github.com/bstabler/TransportationNetworks
• Sheffi, Y. (1985). Urban Transportation Networks
• Bekhor, S., & Prato, C. G. (2009). Methodological transcription of path-size logit model