Transportation Engineering

Transportation engineering encompasses the planning, design, operation, and management of transportation systems. This field ensures that people and goods can move safely, efficiently, and sustainably through highway networks, transit systems, airports, and other transportation infrastructure.

Traffic Flow Fundamentals

Basic Parameters

Flow (q): Number of vehicles passing a point per unit time

q = \frac{n}{t} \quad \text{(vehicles/hour)}

Density (k): Number of vehicles per unit length of roadway

k = \frac{n}{L} \quad \text{(vehicles/km or vehicles/mile)}

Speed:

Space mean speed: $\bar{v}_s = \frac{L}{t_{avg}}$
Time mean speed: $\bar{v}_t = \frac{1}{n}\sum v_i$

Fundamental Relationship

q = k \cdot v

Flow = Density × Speed

Speed-Density Relationship

Greenshields' linear model:

v = v_f \left(1 - \frac{k}{k_j}\right)

Where:

$v_f$ = free-flow speed
$k_j$ = jam density

Flow-Density Relationship

q = k \cdot v_f \left(1 - \frac{k}{k_j}\right) = v_f k - \frac{v_f}{k_j}k^2

Maximum flow (capacity) occurs at:

k_c = \frac{k_j}{2}, \quad v_c = \frac{v_f}{2}

q_{max} = \frac{v_f k_j}{4}

Time Headway and Space Headway

Time headway (h): Time between successive vehicles

h = \frac{1}{q} \quad \text{(seconds/vehicle)}

Space headway (s): Distance between successive vehicles

s = \frac{1}{k} = v \cdot h \quad \text{(meters/vehicle)}

Highway Geometric Design

Design Speed

The maximum safe speed that can be maintained over a specified section of highway when conditions are favorable.

Typical design speeds:

Urban arterials: 50-70 km/h
Rural highways: 80-120 km/h
Freeways: 100-130 km/h

Stopping Sight Distance (SSD)

SSD = v \cdot t_r + \frac{v^2}{2g(f \pm G)}

Where:

$v$ = design speed (m/s)
$t_r$ = perception-reaction time (typically 2.5 s)
$f$ = coefficient of friction
$G$ = grade (+ for uphill, - for downhill)

Or in practical units:

SSD = 0.278 V t_r + \frac{V^2}{254(f \pm G)}

Where $V$ is in km/h and SSD is in meters.

Passing Sight Distance (PSD)

For two-lane highways:

PSD = d_1 + d_2 + d_3 + d_4

Where:

$d_1$ = distance during perception-reaction
$d_2$ = distance during passing maneuver
$d_3$ = clearance distance
$d_4$ = distance traveled by opposing vehicle

Typical values: 400-800 m depending on design speed.

Horizontal Curve Design

Minimum Radius:

R_{min} = \frac{V^2}{127(e + f)}

Where:

$V$ = design speed (km/h)
$e$ = superelevation rate (max typically 0.08-0.12)
$f$ = side friction factor

Superelevation:

e = \frac{V^2}{127R} - f

Curve Length (for transition):

L = \frac{e \cdot V^3}{3.6^3 \cdot C \cdot R}

Where $C$ = rate of change of centripetal acceleration.

Horizontal Curve Elements

Element	Formula
Tangent length (T)	$T = R \tan(\Delta/2)$
Curve length (L)	$L = R \Delta$ (in radians)
Middle ordinate (M)	$M = R(1 - \cos(\Delta/2))$
External distance (E)	$E = R(\sec(\Delta/2) - 1)$
Long chord (C)	$C = 2R \sin(\Delta/2)$

Vertical Curve Design

Crest Curves (based on SSD):

L = \frac{AS^2}{100(\sqrt{2h_1} + \sqrt{2h_2})^2}

Where:

$A$ = algebraic difference in grades (%)
$S$ = sight distance (m)
$h_1$ = driver eye height (1.08 m)
$h_2$ = object height (0.60 m for SSD)

If $S > L$ :

L = 2S - \frac{200(\sqrt{h_1} + \sqrt{h_2})^2}{A}

Sag Curves (based on headlight illumination):

L = \frac{AS^2}{120 + 3.5S}

Vertical Curve Properties

Rate of grade change:

K = \frac{L}{A}

Elevation on curve:

y = y_{BVC} + g_1 x + \frac{(g_2 - g_1)x^2}{2L}

High/low point location:

x = \frac{g_1 L}{g_1 - g_2}

Intersection Design

Level of Service (LOS)

LOS	Description	Delay (signalized)
A	Free flow	≤ 10 s
B	Stable flow	10-20 s
C	Stable flow	20-35 s
D	Approaching unstable	35-55 s
E	Unstable flow	55-80 s
F	Forced/breakdown	> 80 s

Signal Timing (Webster's Formula)

Optimal cycle length:

C_o = \frac{1.5L + 5}{1 - Y}

Where:

$L$ = total lost time per cycle
$Y$ = sum of critical flow ratios

Minimum green time:

g_{min} = \frac{C \cdot y_i}{Y} - l_i

Saturation Flow Rate

s = s_0 \cdot N \cdot f_w \cdot f_{HV} \cdot f_g \cdot f_p \cdot f_{bb} \cdot f_a \cdot f_{LU} \cdot f_{LT} \cdot f_{RT} \cdot f_{Lpb} \cdot f_{Rpb}

Where $s_0$ = base saturation flow (typically 1900 pcphgpl).

Capacity at Signalized Intersection

c = s \cdot \frac{g}{C}

Where $g/C$ is the green ratio.

v/c Ratio

X = \frac{v}{c} = \frac{v \cdot C}{s \cdot g}

Delay Calculation

Average delay per vehicle:

d = d_1 + d_2 + d_3

Where:

$d_1$ = uniform delay
$d_2$ = incremental delay
$d_3$ = initial queue delay

Uniform delay:

d_1 = \frac{0.5C(1 - g/C)^2}{1 - \min(1, X) \cdot g/C}

Pavement Design

Flexible Pavement (Asphalt)

AASHTO design equation:

\log W_{18} = Z_R S_0 + 9.36\log(SN + 1) - 0.20 + \frac{\log(\Delta PSI / (4.2 - 1.5))}{0.4 + 1094/(SN + 1)^{5.19}} + 2.32\log M_R - 8.07

Structural Number:

SN = a_1 D_1 + a_2 D_2 m_2 + a_3 D_3 m_3

Where:

$a_i$ = layer coefficients
$D_i$ = layer thickness
$m_i$ = drainage coefficients

Rigid Pavement (Concrete)

Westergaard's equation for edge stress:

\sigma_e = \frac{3P}{h^2}\left[1 + 0.54\mu\right]\left[\log\left(\frac{Eh^3}{100k}\right) - 0.71\right]

Where:

$P$ = wheel load
$h$ = slab thickness
$k$ = modulus of subgrade reaction
$\mu$ = Poisson's ratio

Real-World Application: Highway Curve Design

Designing a horizontal curve with proper superelevation and sight distance.

Curve Design Example

import math

# Design parameters
design_params = {
    'design_speed': 100,      # km/h
    'deflection_angle': 45,   # degrees
    'max_superelevation': 0.08,
    'friction_factor': 0.12,
    'terrain': 'rolling',
}

V = design_params['design_speed']
delta = math.radians(design_params['deflection_angle'])
e_max = design_params['max_superelevation']
f = design_params['friction_factor']

# Calculate minimum radius
R_min = V**2 / (127 * (e_max + f))

# Use a larger radius for comfort (1.5x minimum)
R_design = math.ceil(R_min * 1.5 / 50) * 50  # Round to nearest 50m

# Calculate required superelevation
e_required = V**2 / (127 * R_design) - f
e_design = min(e_required, e_max)
e_design = max(e_design, 0.02)  # Minimum for drainage

print(f"Horizontal Curve Design")
print(f"=" * 40)
print(f"\nDesign Parameters:")
print(f"  Design speed: {V} km/h")
print(f"  Deflection angle: {design_params['deflection_angle']} degrees")
print(f"  Maximum superelevation: {e_max}")
print(f"  Side friction factor: {f}")

print(f"\nCurve Geometry:")
print(f"  Minimum radius: {R_min:.0f} m")
print(f"  Design radius: {R_design} m")
print(f"  Design superelevation: {e_design:.3f}")

# Calculate curve elements
T = R_design * math.tan(delta / 2)
L = R_design * delta
M = R_design * (1 - math.cos(delta / 2))
E = R_design * (1 / math.cos(delta / 2) - 1)
C = 2 * R_design * math.sin(delta / 2)

print(f"\nCurve Elements:")
print(f"  Tangent length (T): {T:.2f} m")
print(f"  Curve length (L): {L:.2f} m")
print(f"  Middle ordinate (M): {M:.2f} m")
print(f"  External distance (E): {E:.2f} m")
print(f"  Long chord (C): {C:.2f} m")

# Stopping sight distance
t_r = 2.5  # seconds
SSD = 0.278 * V * t_r + V**2 / (254 * (f + 0))  # Level grade

print(f"\nSight Distance:")
print(f"  Stopping sight distance: {SSD:.0f} m")

# Check if SSD is less than curve length
if SSD < L:
    print(f"  SSD < L: Full sight distance available on curve")
else:
    # Calculate required middle ordinate for sight distance
    M_required = R_design * (1 - math.cos(SSD / (2 * R_design)))
    print(f"  Required clear zone from centerline: {M_required:.2f} m")

# Superelevation transition length
# Rate of change = 1/200 (AASHTO)
e_rate = 1 / 200
L_transition = abs(e_design) * (V * 1000 / 3600) / e_rate

print(f"\nTransition:")
print(f"  Superelevation runoff length: {L_transition:.0f} m")

Your Challenge: Traffic Signal Timing

Design signal timing for a four-leg intersection.

Goal: Determine optimal cycle length and green times for given traffic volumes.

Problem Setup

import math

# Intersection data
intersection_config = {
    # Volume (veh/hr) for each approach
    'NB_through': 450,
    'NB_left': 120,
    'SB_through': 520,
    'SB_left': 100,
    'EB_through': 380,
    'EB_left': 80,
    'WB_through': 400,
    'WB_left': 90,

    # Saturation flow (veh/hr/lane)
    'saturation_flow': 1800,

    # Timing parameters
    'yellow_time': 4,         # seconds
    'all_red_time': 2,        # seconds
    'min_green': 10,          # seconds
    'max_cycle': 120,         # seconds

    # Number of lanes
    'through_lanes': 2,
    'left_turn_lanes': 1,
}

# Calculate critical flow ratios
s = intersection_config['saturation_flow']

# Phase 1: NB/SB through + right
v1 = max(intersection_config['NB_through'], intersection_config['SB_through'])
y1 = v1 / (s * intersection_config['through_lanes'])

# Phase 2: NB/SB left turns (protected)
v2 = max(intersection_config['NB_left'], intersection_config['SB_left'])
y2 = v2 / (s * intersection_config['left_turn_lanes'])

# Phase 3: EB/WB through + right
v3 = max(intersection_config['EB_through'], intersection_config['WB_through'])
y3 = v3 / (s * intersection_config['through_lanes'])

# Phase 4: EB/WB left turns (protected)
v4 = max(intersection_config['EB_left'], intersection_config['WB_left'])
y4 = v4 / (s * intersection_config['left_turn_lanes'])

# Total critical flow ratio
Y = y1 + y2 + y3 + y4

# Lost time per phase
lost_time_per_phase = intersection_config['yellow_time'] + intersection_config['all_red_time'] - 2
L = 4 * lost_time_per_phase  # 4 phases

# Webster's optimal cycle length
if Y < 1:
    C_opt = (1.5 * L + 5) / (1 - Y)
else:
    C_opt = intersection_config['max_cycle']

C_design = min(max(60, round(C_opt / 5) * 5), intersection_config['max_cycle'])

# Green time allocation
effective_green_total = C_design - L
g1 = effective_green_total * y1 / Y
g2 = effective_green_total * y2 / Y
g3 = effective_green_total * y3 / Y
g4 = effective_green_total * y4 / Y

# Apply minimum green constraint
g1 = max(g1, intersection_config['min_green'])
g2 = max(g2, intersection_config['min_green'])
g3 = max(g3, intersection_config['min_green'])
g4 = max(g4, intersection_config['min_green'])

print(f"Traffic Signal Timing Design")
print(f"=" * 40)
print(f"\nCritical Flow Ratios:")
print(f"  Phase 1 (NS through): y1 = {y1:.3f}")
print(f"  Phase 2 (NS left): y2 = {y2:.3f}")
print(f"  Phase 3 (EW through): y3 = {y3:.3f}")
print(f"  Phase 4 (EW left): y4 = {y4:.3f}")
print(f"  Total Y: {Y:.3f}")

print(f"\nCycle Length:")
print(f"  Optimal cycle: {C_opt:.0f} s")
print(f"  Design cycle: {C_design} s")
print(f"  Total lost time: {L} s")

print(f"\nGreen Times (seconds):")
print(f"  Phase 1 (NS through): {g1:.0f} s")
print(f"  Phase 2 (NS left): {g2:.0f} s")
print(f"  Phase 3 (EW through): {g3:.0f} s")
print(f"  Phase 4 (EW left): {g4:.0f} s")

# Calculate v/c ratios
X1 = intersection_config['NB_through'] * C_design / (s * intersection_config['through_lanes'] * g1)
X3 = intersection_config['EB_through'] * C_design / (s * intersection_config['through_lanes'] * g3)

print(f"\nVolume-to-Capacity Ratios:")
print(f"  NS approach: {X1:.3f}")
print(f"  EW approach: {X3:.3f}")

if max(X1, X3) < 0.85:
    print(f"  LOS Assessment: Acceptable (X < 0.85)")
else:
    print(f"  LOS Assessment: May need optimization")

How would you modify the timing if you wanted to implement an actuated signal instead of fixed-time operation?

Transportation Engineering

Transportation Engineering

Traffic Flow Fundamentals

Basic Parameters

Fundamental Relationship

Speed-Density Relationship

Flow-Density Relationship

Time Headway and Space Headway

Highway Geometric Design

Design Speed

Stopping Sight Distance (SSD)

Passing Sight Distance (PSD)

Horizontal Curve Design

Horizontal Curve Elements

Vertical Curve Design

Vertical Curve Properties

Intersection Design

Level of Service (LOS)

Signal Timing (Webster's Formula)

Saturation Flow Rate

Capacity at Signalized Intersection

v/c Ratio

Delay Calculation

Pavement Design

Flexible Pavement (Asphalt)

Rigid Pavement (Concrete)

Real-World Application: Highway Curve Design

Curve Design Example

Your Challenge: Traffic Signal Timing

Problem Setup

ELI10 Explanation

Self-Examination