Beckmann (BMW) Traffic Assignment Model

Table of Contents Beckmann (BMW) Traffic Assignment Model Overview of the Beckmann Objective Function Travel Time Function (BPR Function) Model Formulation Objective Function Constraints 1. Flow Conservation 2. Non-Negativity of Flow Network Structure in Pyomo References

Beckmann (BMW) Traffic Assignment Model

The **Beckmann Traffic Assignment Model** (BMW model), introduced by Beckmann, McGuire, and Winsten, provides a mathematical framework for solving the **User Equilibrium (UE)** problem in traffic assignment. It converts the UE problem into a convex optimization problem, allowing us to compute traffic flows that minimize travel times across a network.

Overview of the Beckmann Objective Function

The Beckmann transformation allows us to formulate the UE problem as a **convex minimization problem**. This approach is based on the concept that travelers will adjust their routes until no individual can reduce their travel time by switching paths, achieving a state of equilibrium.

The objective function, often known as the **Beckmann objective function**, is given by:

<math>Z_{\text{UE}}(x) = \sum_{a \in C} \int_0^{x_a} t_a(u) \, du</math>

where:

• <math>t_a(u)</math> is the travel time on link <math>a</math> as a function of flow <math>u</math>.
• <math>x_a</math> is the flow on link <math>a</math>.

Travel Time Function (BPR Function)

In many cases, the travel time function <math>t_a(u)</math> is represented using the **Bureau of Public Roads (BPR) function**:

<math>t_a(u) = t_a^0 \left( 1 + \alpha \left( \frac{u}{\text{capacity}_a} \right)^{\beta} \right)</math>

where:

• <math>t_a^0</math>: Free-flow travel time on link <math>a</math>,
• <math>\alpha</math> and <math>\beta</math>: Parameters defining the sensitivity of travel time to congestion,
• <math>\text{capacity}_a</math>: Capacity of link <math>a</math>.

Model Formulation

The Beckmann model for User Equilibrium is formulated as follows:

Objective Function

<math>\min_{x_a} Z_{\text{UE}}(x) = \sum_{a \in C} t_a^0 \left( x_a + \frac{\alpha x_a^{\beta + 1}}{\text{capacity}_a^{\beta} \cdot (\beta + 1)} \right)</math>

This objective function minimizes the cumulative travel time across all links in the network, balancing flows based on link congestion levels.

Constraints

1. Flow Conservation

For each origin-destination (OD) pair <math>(r, s)</math>, the flow conservation constraint ensures that the total flow on paths between <math>r</math> and <math>s</math> equals the demand, <math>q_{rs}</math>:

<math>\sum_{p \in \mathcal{P}_{rs}} f_p = q_{rs} \quad \forall r, s</math>

where:

• <math>q_{rs}</math>: Total demand between origin <math>r</math> and destination <math>s</math>,
• <math>f_p</math>: Flow on path <math>p</math> between nodes <math>r</math> and <math>s</math>,
• <math>\mathcal{P}_{rs}</math>: Set of all paths between the origin-destination pair <math>(r, s)</math>.

2. Non-Negativity of Flow

The flow on each link <math>x_a</math> must be non-negative:

<math>x_a \geq 0 \quad \forall a \in C</math>

This constraint ensures that flows are feasible within the physical network.

Network Structure in Pyomo

In a Pyomo implementation, the network structure is defined by nodes and links, with parameters such as free flow time, capacity, and demand. The BPR-based objective function and flow conservation constraints can be coded as follows:

<syntaxhighlight lang="python"> from pyomo.environ import *

1. Define model

model = ConcreteModel()

1. Define the sets of nodes and links

model.nodes = Set(initialize=[1,]) model.links = Set(initialize=[(1,])

1. Define parameters for free flow time and capacity on each link

free_flow_time = {(1, 3): 10, (3, 2): 10, (1, 4): 15, (4, 2): 15} capacity = {(1, 3): 4000, (3, 2): 4000, (1, 4): 3000, (4, 2): 4000}

1. BPR parameters

alpha = 0.15 beta = 4

1. Demand and node indicators

demand_vehicle = 8000 origin_node = {1: 1, 2: 0, 3: 0, 4: 0} destination_node = {1: 0, 2: 1, 3: 0, 4: 0} intermediate_node = {i: (1 - origin_node[i]) * (1 - destination_node[i]) for i in model.nodes}

1. Define Pyomo variables for link flows

model.x = Var(model.links, domain=NonNegativeReals)

1. Define the Beckmann objective function

def objective_rule(model): return sum( free_flow_time[i,] * ( model.x[i,] + (alpha * model.x[i,] ** (beta + 1)) / (capacity[i,] ** beta * (beta + 1)) ) for (i, j) in model.links ) model.obj = Objective(rule=objective_rule, sense=minimize)

1. Flow conservation constraints

def flow_conservation_rule(model, node): inflow = sum(model.x[i,] for (i, j) in model.links if j == node) outflow = sum(model.x[i,] for (i, j) in model.links if i == node) if origin_node[node] == 1: return outflow - inflow == demand_vehicle elif destination_node[node] == 1: return inflow - outflow == demand_vehicle elif intermediate_node[node] == 1: return inflow == outflow else: return Constraint.Skip model.flow_conservation = Constraint(model.nodes, rule=flow_conservation_rule)

1. Solve the problem

solver = SolverFactory('ipopt') solver.solve(model, tee=True)

1. Display results

print("Optimal Flows on Links:") for (i, j) in model.links: print(f"Flow on link ({i}, {j}): {model.x[i,].value}") </syntaxhighlight>

References

• Beckmann, M., McGuire, C., & Winsten, C. (1956). Studies in the Economics of Transportation. Yale University Press.
• Bureau of Public Roads (1964). Traffic Assignment Manual. U.S. Department of Commerce.

This Pyomo-based formulation captures the essence of the Beckmann-based User Equilibrium traffic assignment model, making it a powerful tool for solving real-world traffic flow optimization problems.

---

Note: This model assumes a static demand and flow assignment. For dynamic models, further temporal considerations may be integrated.