Lane-merge optimization

• Project name: Lane-merge optimization
• Course: 4IT496 Simulation of Systems course at University of Economics, Prague
• Author: Martin Zima (xzimm000, mailATzimamartinDOTcz)
• Model type: Agent-based simulation
• Software used: NetLogo 5.3

The model presented by this paper is simulating the situation of car multi-lane merging.

Preface

During the past centuries, once technologies became advanced enough to start the industrial revolution, the importance of transportation became obvious. Companies need efficient means of transport for their manufacturing logistics just as much as regular passengers for their every-day travels do. Managing an efficient traffic flow has always been a challenging task ever since these days, as it encompasses lots of aspects and requirements: it is necessary to provide a performant (efficient), reliable, safe and sustainable traffic flow control and figuring-out the best rules or configuration, let alone ensuring the adherence to them, has not ever been an easy task. One of the most complicated transportation types for this has been the road (car) traffic - not only for its limitation regarding the spatial dispositions (roads vs. air, sea, etc.), but also for the amount of its interacting agents and their nature.

In comparison with other means of transport, car traffic has many peculiarities of its own: for starters, there is usually a significantly higher of agents interacting at one moment a place on the road. Furthermore, the agents are usually not trained specialists: the usual requirement for their involvement in the system is the possession of a driver's license, which guarantees only an obligatory minimum experience and knowledge of the traffic rules. As any other human beings, these agents are even more prone to making mistakes while driving and making bad decisions, leading to even worse performing traffic (and finally, to situations commonly dubbed as traffic jams or congestions). There is a number of specific critical scenarios, where determining the optimal traffic control becomes even harder or is depending on so many external parameters and influences that we cannot predict a single, simple general rule, that would be best for the agents to follow. On the other hand, technology has become nowadays so advanced, there are already many ongoing projects analyzing and developing smarter computer-based systems, that could save resources (transportation costs, time...) and moreover, actually relief the traffic. Self-driven autonomous cars or interconnected smart traffic signalization are just a few of the examples of optimizations we might be hoping for in the near future.

This is where comes an opportunity for this paper - to be able to implement such optimizations, we first must know at what areas of the problem to focus on (there is this saying, 'premature optimization is the root of evil'...). One of typical examples of the aforementioned critical road traffic scenarios is the lane-merge. In simple words, a lane-merge is a situation, where two or more lanes (of one direction) merge into one. The reasons for a lane-merge are numerous - ranging from a simple street narrowing to various traffic obstructions (car accident, roadworks...). Due to its nature (lower number of lanes will always lead to theoretically lower maximum throughput), but also possibly due to human error, different agents' driving opinions, inexperience and perhaps also different law regulations (generally, sub-optimal behavior of agents), lane-merges tend to be one of the most typical traffic jams causes. Because of the multitude of possible factors, it is almost impossible to analyze this in a mathematical (hand-computation) fashion, but is quite well suited for a computer-assisted simulation.

Problem definition

The primary goal of this paper is to create a plausible real-world model of car lane merges to study and determine factors and circumstances that influence the continuity of traffic flow and cause traffic jams, and in consequence how to avoid them, and to determine the best settings for an optimized traffic performance. Primarily, the model should take into account the common inefficiencies of human agents (human error...) and also offer another solution utilizing agents that act in a more consistent, rule-coherent, autonomously-driven-, computer-based-car-alike way. To verify and deliver the results of such model, a computer-based simulation will be developed. Based on the results of this simulation, we should be able to compare the different approaches and configurations and to measure (at least in orders of magnitude) their impact on the traffic fluency. The paper should conclude how observed phenomena affect the car traffic and whether it might be worth to enforce certain rules for the lane merges (or to implement them in the future autonomous computer-based agents).

Method

World visualization in NetLogo 5.3

Software environment

Because of the multi-agent and spatial nature of the model, whose representation should be able to convey the traffic flow phenomena, NetLogo 5.3 software has been chosen as the simulation environment, being deemed suitable for the considered task.

Simulation world

The simulation space (world in NetLogo terminology) itself has been used as one continuous area of the road, heading uni-directionally from bottom to the top, and being horizontally split into a number of parallel lanes (the number is a configurable parameter). The first (first as in the sense of the part, where the cars appear first, i.e. the bottom) part of the world is the full-width section of the road; from the middle and further, the lanes start to merge (for simplicity, we consider only right-to-left merges, but in our case scenario, the results should be similar even with left-to-right, which are not that common). There is configurable (but fixed during one simulation run) number of cars spawning per unit of time (which is measured using fixed timesteps, which NetLogo calls 'ticks'). These new agents, randomly (but uniformly) distributed across the lanes, start at the beginning of a lane and try to get to the end of the road (as a result of which, some of them must change the lane in the end) as fast as possible (although obeying certain rules and simulation settings and affected by some of their own preferences, of course). Once an agent gets past the end of road (end of the world), he disappears from the simulation and no longer affects its further progress.

Behavior of agents

The objective of this paper was to primarily simulate the natural behavior of human agents driving cars. To achieve this, the model tries to mimic number of aspects of the typical human driver behavior. First of all, because our goal is not to simulate car crash accidents (we simply assume no agent makes such a crude error - otherwise we would be simulating a completely different thing), the priority number one of every agent is maintaining a safe speed and distance between cars (i.e. him and the possible car ahead of him). If circumstances allow (environment and other surrounding agents), the agent will also then accelerate up to his desired speed. For the simplicity of this simulation and also to reduce possible undesired effects, we assume the agents have an immediate reaction while braking and are able to decelerate to zero instantly (unlike the positive acceleration, which takes time).

Moreover, unless there is a lane merger nearby (which would prevent him from doing it), he may also overtake a slower-driving agent in front of him, using the lane to the left (if there is one). Once he finishes this maneuver, he pulls back to his original lane (and eventually any other lane to the right of him as long as there is enough free space and he reached his desired speed). Presented simulation better corresponds to the situation of a city street road than other multi-lane roads (like highways), because it allows a faster agent to overtake another agent also using the lane on the right of him (which is usually forbidden in many countries), as long he was in that lane first.

Agent switches to a slightly different behavior once he approaches a line merge (the point, where a lane ends, and he is forced to switch the lane). From certain distance to the lane end, the agent starts to check if there enough space in the lane he wants to merge to, and in case there is, then if he is the last one in his lane or if he prefers an early merge, he starts to switch the lane. If the agent does not succeeds with this, then, after another certain distance-to-lane-end value, he starts to 'worry' he might not make it in time, resulting in a sudden deceleration to lower speed. During this period, if there happens to be another agent to his right willing to let him merge ('zip'), the agent to the right slows down and lets him merge. If he does not succeed with this either, he might eventually get to a point, where he is forced to stop the car completely (speed set to zero).

Parameters

There is a number of different parameters that configure the model values and affect the overall outcome of the simulation. Moreover, many of these parameters are simply ranges with every agent randomly picking his own value falling inside this range (agent's preferences influencing his decisions).

Environment parameters

• Number of lanes
• Car inflow (car spawned/time unit)

Agent behavior

• Min/max range for desired speed
• Min/max range for acceleration (this covers both technical possibilities of a cars and agents' reaction time)
• Early-merge method inclination (%)
• Willingness to let another car zip-merge (%)
• Min/max range for distance to lane end at which agent ideally wants to merge
• Min/max range for distance at which agent starts to slow-down if unable to merge
• Speed slow-down ratio if agent is unable to merge
• Min/max range for distance at which agent stops if unable to merge
• Inclination to overtake slower drivers (%)
• Min/max range for safe distance between cars required by an agent