Simulace.info - User contributions [en]

Traffic Accident Risk Analysis

2025-01-28T17:15:08Z

Sim timm03:

NLOGO CODE - [[file:Traffic.nlogo]]

== Introduction ==
This page introduces a NetLogo-based simulation that models traffic accident risk. The goal is to understand how road conditions, traffic density, and driver behavior intertwine to create or mitigate accidents. Various research sources underscore the need for a systematic approach to traffic safety, illustrating how driver reliability, infrastructure, and cultural factors shape accident outcomes (Sadauskas, 2011; Gstalter & Fastenmeier, 2010; TSK Praha, 2020; Nordfjærn et al., 2011).

== Definition of the Problem ==
Road traffic accidents remain a pressing public health challenge, especially with the steady growth in vehicle numbers worldwide (Sadauskas, 2011). This proliferation escalates the likelihood of collisions, injuries, and fatalities. A robust traffic safety strategy thus necessitates examining:

Road conditions (from good to very bad).

Driver behavior and risk homeostasis (adjusting behavior based on perceived safety).

Environmental and societal factors that influence compliance with safety rules (Nordfjærn et al., 2011).

Moreover, the complexity of urban intersections can amplify error rates, as drivers face higher cognitive loads and multiple conflict points (Gstalter & Fastenmeier, 2010). In city contexts, baseline accident rates still vary considerably depending on infrastructure, as seen in real-world data (TSK Praha, 2020).

== Method ==
We adopt a multi-pronged, systematic approach to traffic safety, integrating **engineering**, **enforcement**, and **education**—commonly referred to as the “Triple E.(Sadauskas, 2011)

== Engineering ==
Vehicle and road design improvements include:

* **''Intersection geometry optimization:''** Represented in the code by the procedure <code>setup-intersections</code>, which identifies and marks intersection patches. Traffic lights are not working as intended, but are in the code base and interface for user to try.

Additionally, **Human Reliability Analysis (HRA)** was used to determine driver error probabilities, particularly at urban intersections.(Gstalter & Fastenmeier, 2010). By defining “correct” task execution and measuring deviations, HRA quantifies how factors such as road geometry, driver age, and psychosocial influences affect driver reliability.

In the code, this is reflected in the procedure <code>calculate-accident-probability</code>, which scales a base driver-error rate by factors such as:

* Road conditions
* Speed ratio
* Local congestion
* Intersection complexity

== Model ==
This simulation uses NetLogo to create a grid of patches representing:

Road segments: Assigned good, bad, or very bad condition.

Intersections: Potentially with traffic lights.

Cars (turtles): Move according to lane rules and can trigger accidents based on speed, congestion, and driver-error-rate.

Key points:

Accident Probability: Derived from a base driver-error-rate, amplified by intersection complexity, road condition, and local traffic density (Gstalter & Fastenmeier, 2010; Nordfjærn et al., 2011).

Baseline Rates: Inspired by real accident data (e.g., TSK Praha’s ročenka dopravy or Accident risks of different weather conditions) (TSK Praha, 2020) (Malin 2017).

Systematic Approach: Reflects suggestions for engineering (road condition logic), education (driver-error slider), and enforcement (speed constraints) in modeling different scenarios (Sadauskas, 2011).

=== Interface ===

[[File:Interface_timm03.png]]

=== High Density, Poor Roads===

[[File:LowDensity_timm03.png]]

Because there are 100 cars with a fairly high driver-error-rate (0.05), multiple accidents occurred (10 total). However, they tended to happen later in the simulation (average time until accident over 300 ticks).
Most cars (90 out of 100) still reached their destination—likely because accident-duration is very short (1 tick), so blocked patches quickly returned to normal.
The relatively high base speed (0.8) also increased mobility, helping more cars finish faster, but also contributed to a moderate accident rate.

=== Low Density, Strict Limits===

[[File:HighDensity_timm03.png]]

Fewer cars (50), but also a much lower base speed (0.3), so cars move more slowly—leading to a higher average travel time (over 200 ticks).
Because driver-error-rate is only 0.01 (lower chance of human error) and 70% roads are good, only 3 accidents occurred.
Even with slow speed, many cars still took a long time to finish, as shown by the high travel time. Almost all cars managed to complete or crash within the time frame, with 47 successful arrivals.

=== Moderate Density, Extended Accident Duration===

[[File:ModerateDensity_timm03.png]]

Compared to the second screenshot, the big difference is accident-duration = 90 (very long).
Even though speed is still 0.3 and the road condition/distribution is the same, the accident count has climbed to 13, and 16% of the cars ended up in accidents.
Because accidents last 90 ticks on a patch, any collision severely disrupts traffic, likely forcing more cars to queue or collide.
Despite that, 67 cars did manage to exit, though the blocked patches would have contributed to higher accident numbers and more emergent congestion.

== Conclusion ==

This NetLogo simulation allows users to vary key parameters—such as base speed, number of cars (density), road condition (good to very bad), driver-error rate, and accident duration—then observe metrics like average travel time, distance/time until accident, and accident hotspots. Results show that poor roads and high driver-error rates sharply increase collisions, while long accident durations intensify congestion. Conversely, safer infrastructure, lower driver-error rates, and faster incident clearance foster smoother traffic flow and fewer crashes, underlining the value of integrated traffic safety strategies.

== Code ==
Below is the NetLogo code implementing the simulation structure (patch definitions, accident logic, congestion metrics, etc.). Users can copy and paste it into a NetLogo environment to run their own experiments. For a complete listing, see the setup, go, and supporting procedures:

<syntaxhighlight lang="netlogo">

globals [
;; Sliders / Switch in Interface:
;; - number-of-cars (int)
;; - road-spacing (int)
;; - base-speed (float)
;; - driver-error-rate (float)
;; - accident-duration (int)
;; - traffic-lights? (boolean switch)

;; Statistics
total-cars-reached-destination
total-cars-accident ;; how many cars died in accidents (cumulative)
accident-count ;; how many total accidents have started
average-speed
average-congestion
accident-percentage
sum-travel-time ;; sum of time in system for all cars that exit
count-completed-cars ;; how many cars reached destination
average-travel-time ;; output metric
accident-count-good
accident-count-bad
accident-count-very-bad
sum-time-until-accident
sum-distance-until-accident
average-time-until-accident
average-distance-until-accident
]

patches-own [
is-road? ;; boolean: is this patch part of a road?
is-intersection? ;; boolean: is this patch an intersection?
lane-direction ;; forced heading: 0, 90, 180, 270, or -1 if intersection
traffic-light? ;; does this patch have a traffic light?
light-state ;; true=green, false=red
has-accident? ;; boolean: accident currently on this patch?
accident-lifetime ;; integer: how many ticks remain for this accident?
road-condition ;; 0=good, 1=bad, 2=very bad (affects accident prob)
]

breed [ cars car ]
cars-own [
speed
max-speed
stopped-ticks
destination ;; patch or nobody
birth-tick ;; store the tick when the car is created
distance-traveled ;; accumulates how far the car has moved
]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 1. SETUP ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup
clear-all

;; Initialize stats
set total-cars-reached-destination 0
set total-cars-accident 0
set accident-count 0
set average-speed 0
set average-congestion 0

set sum-travel-time 0
set count-completed-cars 0
set average-travel-time 0

set accident-count-good 0
set accident-count-bad 0
set accident-count-very-bad 0

set sum-time-until-accident 0
set sum-distance-until-accident 0
set average-time-until-accident 0
set average-distance-until-accident 0

setup-roads
setup-intersections
setup-traffic-lights
setup-road-conditions

reset-ticks

create-initial-cars
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 2. CREATE ROADS (TWO LANE, ONE-WAY) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-roads
ask patches [
set is-road? false
set is-intersection? false
set traffic-light? false
set light-state false
set has-accident? false
set accident-lifetime 0
set lane-direction 0
set road-condition 0
set pcolor green
]

;; 2-lane roads in x or y dimension
let road-patches patches with [
(abs pxcor mod road-spacing <= 1) or
(abs pycor mod road-spacing <= 1)
]

ask road-patches [
set is-road? true
set pcolor grey
]

;; Assign forced lane headings for non-intersection road patches
ask road-patches [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; purely vertical lane: pick 0 or 180
if (x-road? and not y-road?) [
ifelse (pxcor mod 2 = 0)
[ set lane-direction 0 ] ;; "northbound"
[ set lane-direction 180 ] ;; "southbound"
]

;; purely horizontal lane: pick 90 or 270
if (y-road? and not x-road?) [
ifelse (pycor mod 2 = 0)
[ set lane-direction 90 ] ;; "eastbound"
[ set lane-direction 270 ] ;; "westbound"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 3. INTERSECTIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-intersections
ask patches with [is-road?] [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; Intersection = patch that is both x-road & y-road
if (x-road? and y-road?) [
set is-intersection? true
set pcolor yellow
set lane-direction -1 ;; means "all directions possible here"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 4. TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-traffic-lights
if traffic-lights? [
;; Turn on lights at each intersection
ask patches with [is-intersection?] [
set traffic-light? true
set light-state true
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 5. ROAD CONDITIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-road-conditions
let sum-prob (good-road-probability + bad-road-probability)

ask patches with [is-road?] [
let r random-float 1

ifelse (r < good-road-probability) [
;; (1) "Good" road
set road-condition 0
set pcolor grey

] [
ifelse (r < sum-prob) [
;; (2) "Bad" road
set road-condition 1
set pcolor (grey - 2)

;; 5% chance to become "Very Bad" instead:
if random-float 1 < 0.05 [
set road-condition 2
set pcolor orange
]

] [

set road-condition 0
set pcolor grey
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 6. CREATE INITIAL CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to create-initial-cars
ask cars [ die ] ;; remove any old cars

let valid-starts patches with [
is-road? and
not has-accident? and
not any? cars-here
]

if not any? valid-starts [
user-message "No valid road patches for car creation!"
stop
]

create-cars min list number-of-cars (count valid-starts) [
set shape "car"
set color blue
set size 0.8

;; pick a random road patch
let start-patch one-of valid-starts
move-to start-patch
set valid-starts valid-starts with [self != start-patch]

;; If this patch is an intersection => pick a direction
ifelse ([lane-direction] of patch-here = -1)
[ set heading one-of [0 90 180 270] ]
[ set heading [lane-direction] of patch-here ]

set speed 0
set max-speed base-speed
set stopped-ticks 0
set destination nobody
set distance-traveled 0
set birth-tick ticks
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 7. GO (MAIN LOOP) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
if not any? cars [ stop ]

update-traffic-lights
move-cars
check-accidents
clear-old-accidents
update-statistics

tick
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 8. UPDATE TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-traffic-lights
if traffic-lights? [
ask patches with [is-intersection? and traffic-light?] [
;; simple toggle every 30 ticks
if (ticks mod 30 = 0) [
set light-state not light-state
set pcolor ifelse-value light-state [green] [red]
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 9. MOVE CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to move-cars
ask cars [
;; Force lane direction
let patch-lane [lane-direction] of patch-here

ifelse patch-lane = -1 [
;; intersection => pick a new direction each tick or once
set heading one-of [0 90 180 270]
]
[
;; normal lane => enforce that heading
set heading patch-lane
]

;; Decide if it's safe to move
let safe-to-move? true

;; Check traffic light
if [traffic-light?] of patch-here [
if not ([light-state] of patch-here) [
set safe-to-move? false
]
]

;; Check for cars ahead in same lane
if any? cars-on patch-ahead 1 [
set safe-to-move? false
]

;; Move or slow
ifelse safe-to-move? [
set speed min (list (speed + 0.1) max-speed)
forward speed
set distance-traveled distance-traveled + speed
set stopped-ticks 0
] [
set speed max (list (speed - 0.2) 0)
set stopped-ticks (stopped-ticks + 1)
]

;; if the car leaves the grid:
if not is-patch? patch-here [

set count-completed-cars (count-completed-cars + 1)

;; Add to sum-travel-time:
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

;; Then die
die
]

if (max-pxcor - abs xcor) < 1 or (max-pycor - abs ycor) < 1 [
set total-cars-reached-destination (total-cars-reached-destination + 1)

set count-completed-cars (count-completed-cars + 1)
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

die
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 10. ACCIDENT LOGIC (EXPANDED) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to check-accidents
;; For each car, compute probability of an accident
ask cars [
if random-float 1 < calculate-accident-probability self [
create-accident self
]
]
end

to-report calculate-accident-probability [ c ]
;; Base accident probability from driver error
let base (driver-error-rate * 0.00025)

;; Find the patch under turtle c (using c's pxcor, pycor)
let p patch ([pxcor] of c) ([pycor] of c)

;; Road condition effect
if [road-condition] of p = 1 [
set base (base * 2)
]
if [road-condition] of p = 2 [
set base (base * 2.6)
]

;; Speed factor
let speed-ratio ([speed] of c / [max-speed] of c)
set base (base * (speed-ratio + 0.1)) ;; +0.1 so even slow cars have some chance

;; Congestion effect: how many other cars are within radius 1.5 of c
let nearby-cars count cars with [ distance c < 1.5 ]
set base (base + (nearby-cars * 0.0005))

;; Intersection effect
if [is-intersection?] of p [
set base (base * 1.5)
]

;; Cap at 1% (0.01) to avoid extreme probabilities
report min (list base 0.1)

end

to create-accident [ c ]
set accident-count (accident-count + 1)
set total-cars-accident (total-cars-accident + 1)

;; Mark the patch
let px ([pxcor] of c)
let py ([pycor] of c)
ask patch px py [
set has-accident? true
set pcolor red
set accident-lifetime accident-duration

;; Accidents by Road Condition:
if (road-condition = 0) [ set accident-count-good (accident-count-good + 1) ]
if (road-condition = 1) [ set accident-count-bad (accident-count-bad + 1) ]
if (road-condition = 2) [ set accident-count-very-bad (accident-count-very-bad + 1) ]
]

;; Time & Distance to Accident:
let time-until-accident (ticks - [birth-tick] of c)
let dist-until-accident ([distance-traveled] of c)
set sum-time-until-accident (sum-time-until-accident + time-until-accident)
set sum-distance-until-accident (sum-distance-until-accident + dist-until-accident)

;; kill the car
ask c [ die ]
end

to clear-old-accidents
;; Decrement accident-lifetime. When it hits 0, clear the patch.
ask patches with [has-accident?] [
set accident-lifetime (accident-lifetime - 1)
if (accident-lifetime <= 0) [
set has-accident? false
;; restore color based on road-condition
if (road-condition = 0) [
set pcolor grey
]
if (road-condition = 1) [
set pcolor (grey - 2)
]
if (road-condition = 2) [
set pcolor orange
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 11. STATISTICS & PLOTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-statistics
let car-count count cars
let total-speed 0

if car-count > 0 [
set total-speed sum [speed] of cars
set average-speed (total-speed / car-count)
]
if car-count = 0 [
set average-speed 0
]

set average-congestion count cars with [
(stopped-ticks >= 2) and (any? cars-on patch-ahead 1)
]
if number-of-cars > 0 [
set accident-percentage ((accident-count / number-of-cars) * 100)
]
;;Average travel time for cars that completed trip
if count-completed-cars > 0 [
set average-travel-time (sum-travel-time / count-completed-cars)
]
;;Averages for time & distance until accident
if accident-count > 0 [
set average-time-until-accident (sum-time-until-accident / accident-count)
set average-distance-until-accident (sum-distance-until-accident / accident-count)
]
;; Plot them
carefully [
set-current-plot "Average Speed"
plot average-speed

set-current-plot "Total Accidents"
plot accident-count

set-current-plot "Average Congestion"
plot average-congestion
] []
end

</syntaxhighlight>

== References ==

Sadauskas, V. (2011). ''Traffic safety strategies'', Transport, 18(2), 79–83. DOI: 10.1080/16483840.2003.10414070

Gstalter, H., & Fastenmeier, W. (2010). ''Reliability of drivers in urban intersections.'' Accident Analysis & Prevention, 42(1), 225–234. [https://doi.org/10.1016/j.aap.2009.07.021 Link]

TSK Praha (2020). ''Ročenka dopravy – 2020.'' [https://www.tsk-praha.cz/static/udi-rocenka-2020-vm-cz-HTML/kapitola_01.html Link]

Nordfjærn, T., Jørgensen, S., & Rundmo, T. (2011). ''A cross-cultural comparison of road traffic risk perceptions, attitudes towards traffic safety, and driver behaviour.'' Journal of Risk Research, 14(6), 657–684. [https://doi.org/10.1080/13669877.2010.547259 Link]

Fanny Malin (2017). ''Accident risks in different weather conditions.'' [https://nordicroads.com/accident-risks-different-weather-conditions/?utm_source=chatgpt.com Link]

File:Traffic.nlogo

2025-01-28T17:14:41Z

Sim timm03: Sim timm03 uploaded a new version of File:Traffic.nlogo

Traffic Accident Risk Analysis

2025-01-28T17:10:42Z

Sim timm03:

== Introduction ==
This page introduces a NetLogo-based simulation that models traffic accident risk. The goal is to understand how road conditions, traffic density, and driver behavior intertwine to create or mitigate accidents. Various research sources underscore the need for a systematic approach to traffic safety, illustrating how driver reliability, infrastructure, and cultural factors shape accident outcomes (Sadauskas, 2011; Gstalter & Fastenmeier, 2010; TSK Praha, 2020; Nordfjærn et al., 2011).

== Definition of the Problem ==
Road traffic accidents remain a pressing public health challenge, especially with the steady growth in vehicle numbers worldwide (Sadauskas, 2011). This proliferation escalates the likelihood of collisions, injuries, and fatalities. A robust traffic safety strategy thus necessitates examining:

Road conditions (from good to very bad).

Driver behavior and risk homeostasis (adjusting behavior based on perceived safety).

Environmental and societal factors that influence compliance with safety rules (Nordfjærn et al., 2011).

Moreover, the complexity of urban intersections can amplify error rates, as drivers face higher cognitive loads and multiple conflict points (Gstalter & Fastenmeier, 2010). In city contexts, baseline accident rates still vary considerably depending on infrastructure, as seen in real-world data (TSK Praha, 2020).

== Method ==
We adopt a multi-pronged, systematic approach to traffic safety, integrating **engineering**, **enforcement**, and **education**—commonly referred to as the “Triple E.(Sadauskas, 2011)

== Engineering ==
Vehicle and road design improvements include:

* **''Intersection geometry optimization:''** Represented in the code by the procedure <code>setup-intersections</code>, which identifies and marks intersection patches. Traffic lights are not working as intended, but are in the code base and interface for user to try.

Additionally, **Human Reliability Analysis (HRA)** was used to determine driver error probabilities, particularly at urban intersections.(Gstalter & Fastenmeier, 2010). By defining “correct” task execution and measuring deviations, HRA quantifies how factors such as road geometry, driver age, and psychosocial influences affect driver reliability.

In the code, this is reflected in the procedure <code>calculate-accident-probability</code>, which scales a base driver-error rate by factors such as:

* Road conditions
* Speed ratio
* Local congestion
* Intersection complexity

== Model ==
This simulation uses NetLogo to create a grid of patches representing:

Road segments: Assigned good, bad, or very bad condition.

Intersections: Potentially with traffic lights.

Cars (turtles): Move according to lane rules and can trigger accidents based on speed, congestion, and driver-error-rate.

Key points:

Accident Probability: Derived from a base driver-error-rate, amplified by intersection complexity, road condition, and local traffic density (Gstalter & Fastenmeier, 2010; Nordfjærn et al., 2011).

Baseline Rates: Inspired by real accident data (e.g., TSK Praha’s ročenka dopravy or Accident risks of different weather conditions) (TSK Praha, 2020) (Malin 2017).

Systematic Approach: Reflects suggestions for engineering (road condition logic), education (driver-error slider), and enforcement (speed constraints) in modeling different scenarios (Sadauskas, 2011).

=== Interface ===

[[File:Interface_timm03.png]]

=== High Density, Poor Roads===

[[File:LowDensity_timm03.png]]

Because there are 100 cars with a fairly high driver-error-rate (0.05), multiple accidents occurred (10 total). However, they tended to happen later in the simulation (average time until accident over 300 ticks).
Most cars (90 out of 100) still reached their destination—likely because accident-duration is very short (1 tick), so blocked patches quickly returned to normal.
The relatively high base speed (0.8) also increased mobility, helping more cars finish faster, but also contributed to a moderate accident rate.

=== Low Density, Strict Limits===

[[File:HighDensity_timm03.png]]

Fewer cars (50), but also a much lower base speed (0.3), so cars move more slowly—leading to a higher average travel time (over 200 ticks).
Because driver-error-rate is only 0.01 (lower chance of human error) and 70% roads are good, only 3 accidents occurred.
Even with slow speed, many cars still took a long time to finish, as shown by the high travel time. Almost all cars managed to complete or crash within the time frame, with 47 successful arrivals.

=== Moderate Density, Extended Accident Duration===

[[File:ModerateDensity_timm03.png]]

Compared to the second screenshot, the big difference is accident-duration = 90 (very long).
Even though speed is still 0.3 and the road condition/distribution is the same, the accident count has climbed to 13, and 16% of the cars ended up in accidents.
Because accidents last 90 ticks on a patch, any collision severely disrupts traffic, likely forcing more cars to queue or collide.
Despite that, 67 cars did manage to exit, though the blocked patches would have contributed to higher accident numbers and more emergent congestion.

== Conclusion ==

This NetLogo simulation allows users to vary key parameters—such as base speed, number of cars (density), road condition (good to very bad), driver-error rate, and accident duration—then observe metrics like average travel time, distance/time until accident, and accident hotspots. Results show that poor roads and high driver-error rates sharply increase collisions, while long accident durations intensify congestion. Conversely, safer infrastructure, lower driver-error rates, and faster incident clearance foster smoother traffic flow and fewer crashes, underlining the value of integrated traffic safety strategies.

== Code ==
Below is the NetLogo code implementing the simulation structure (patch definitions, accident logic, congestion metrics, etc.). Users can copy and paste it into a NetLogo environment to run their own experiments. For a complete listing, see the setup, go, and supporting procedures:

<syntaxhighlight lang="netlogo">

globals [
;; Sliders / Switch in Interface:
;; - number-of-cars (int)
;; - road-spacing (int)
;; - base-speed (float)
;; - driver-error-rate (float)
;; - accident-duration (int)
;; - traffic-lights? (boolean switch)

;; Statistics
total-cars-reached-destination
total-cars-accident ;; how many cars died in accidents (cumulative)
accident-count ;; how many total accidents have started
average-speed
average-congestion
accident-percentage
sum-travel-time ;; sum of time in system for all cars that exit
count-completed-cars ;; how many cars reached destination
average-travel-time ;; output metric
accident-count-good
accident-count-bad
accident-count-very-bad
sum-time-until-accident
sum-distance-until-accident
average-time-until-accident
average-distance-until-accident
]

patches-own [
is-road? ;; boolean: is this patch part of a road?
is-intersection? ;; boolean: is this patch an intersection?
lane-direction ;; forced heading: 0, 90, 180, 270, or -1 if intersection
traffic-light? ;; does this patch have a traffic light?
light-state ;; true=green, false=red
has-accident? ;; boolean: accident currently on this patch?
accident-lifetime ;; integer: how many ticks remain for this accident?
road-condition ;; 0=good, 1=bad, 2=very bad (affects accident prob)
]

breed [ cars car ]
cars-own [
speed
max-speed
stopped-ticks
destination ;; patch or nobody
birth-tick ;; store the tick when the car is created
distance-traveled ;; accumulates how far the car has moved
]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 1. SETUP ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup
clear-all

;; Initialize stats
set total-cars-reached-destination 0
set total-cars-accident 0
set accident-count 0
set average-speed 0
set average-congestion 0

set sum-travel-time 0
set count-completed-cars 0
set average-travel-time 0

set accident-count-good 0
set accident-count-bad 0
set accident-count-very-bad 0

set sum-time-until-accident 0
set sum-distance-until-accident 0
set average-time-until-accident 0
set average-distance-until-accident 0

setup-roads
setup-intersections
setup-traffic-lights
setup-road-conditions

reset-ticks

create-initial-cars
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 2. CREATE ROADS (TWO LANE, ONE-WAY) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-roads
ask patches [
set is-road? false
set is-intersection? false
set traffic-light? false
set light-state false
set has-accident? false
set accident-lifetime 0
set lane-direction 0
set road-condition 0
set pcolor green
]

;; 2-lane roads in x or y dimension
let road-patches patches with [
(abs pxcor mod road-spacing <= 1) or
(abs pycor mod road-spacing <= 1)
]

ask road-patches [
set is-road? true
set pcolor grey
]

;; Assign forced lane headings for non-intersection road patches
ask road-patches [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; purely vertical lane: pick 0 or 180
if (x-road? and not y-road?) [
ifelse (pxcor mod 2 = 0)
[ set lane-direction 0 ] ;; "northbound"
[ set lane-direction 180 ] ;; "southbound"
]

;; purely horizontal lane: pick 90 or 270
if (y-road? and not x-road?) [
ifelse (pycor mod 2 = 0)
[ set lane-direction 90 ] ;; "eastbound"
[ set lane-direction 270 ] ;; "westbound"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 3. INTERSECTIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-intersections
ask patches with [is-road?] [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; Intersection = patch that is both x-road & y-road
if (x-road? and y-road?) [
set is-intersection? true
set pcolor yellow
set lane-direction -1 ;; means "all directions possible here"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 4. TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-traffic-lights
if traffic-lights? [
;; Turn on lights at each intersection
ask patches with [is-intersection?] [
set traffic-light? true
set light-state true
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 5. ROAD CONDITIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-road-conditions
let sum-prob (good-road-probability + bad-road-probability)

ask patches with [is-road?] [
let r random-float 1

ifelse (r < good-road-probability) [
;; (1) "Good" road
set road-condition 0
set pcolor grey

] [
ifelse (r < sum-prob) [
;; (2) "Bad" road
set road-condition 1
set pcolor (grey - 2)

;; 5% chance to become "Very Bad" instead:
if random-float 1 < 0.05 [
set road-condition 2
set pcolor orange
]

] [

set road-condition 0
set pcolor grey
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 6. CREATE INITIAL CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to create-initial-cars
ask cars [ die ] ;; remove any old cars

let valid-starts patches with [
is-road? and
not has-accident? and
not any? cars-here
]

if not any? valid-starts [
user-message "No valid road patches for car creation!"
stop
]

create-cars min list number-of-cars (count valid-starts) [
set shape "car"
set color blue
set size 0.8

;; pick a random road patch
let start-patch one-of valid-starts
move-to start-patch
set valid-starts valid-starts with [self != start-patch]

;; If this patch is an intersection => pick a direction
ifelse ([lane-direction] of patch-here = -1)
[ set heading one-of [0 90 180 270] ]
[ set heading [lane-direction] of patch-here ]

set speed 0
set max-speed base-speed
set stopped-ticks 0
set destination nobody
set distance-traveled 0
set birth-tick ticks
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 7. GO (MAIN LOOP) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
if not any? cars [ stop ]

update-traffic-lights
move-cars
check-accidents
clear-old-accidents
update-statistics

tick
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 8. UPDATE TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-traffic-lights
if traffic-lights? [
ask patches with [is-intersection? and traffic-light?] [
;; simple toggle every 30 ticks
if (ticks mod 30 = 0) [
set light-state not light-state
set pcolor ifelse-value light-state [green] [red]
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 9. MOVE CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to move-cars
ask cars [
;; Force lane direction
let patch-lane [lane-direction] of patch-here

ifelse patch-lane = -1 [
;; intersection => pick a new direction each tick or once
set heading one-of [0 90 180 270]
]
[
;; normal lane => enforce that heading
set heading patch-lane
]

;; Decide if it's safe to move
let safe-to-move? true

;; Check traffic light
if [traffic-light?] of patch-here [
if not ([light-state] of patch-here) [
set safe-to-move? false
]
]

;; Check for cars ahead in same lane
if any? cars-on patch-ahead 1 [
set safe-to-move? false
]

;; Move or slow
ifelse safe-to-move? [
set speed min (list (speed + 0.1) max-speed)
forward speed
set distance-traveled distance-traveled + speed
set stopped-ticks 0
] [
set speed max (list (speed - 0.2) 0)
set stopped-ticks (stopped-ticks + 1)
]

;; if the car leaves the grid:
if not is-patch? patch-here [

set count-completed-cars (count-completed-cars + 1)

;; Add to sum-travel-time:
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

;; Then die
die
]

if (max-pxcor - abs xcor) < 1 or (max-pycor - abs ycor) < 1 [
set total-cars-reached-destination (total-cars-reached-destination + 1)

set count-completed-cars (count-completed-cars + 1)
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

die
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 10. ACCIDENT LOGIC (EXPANDED) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to check-accidents
;; For each car, compute probability of an accident
ask cars [
if random-float 1 < calculate-accident-probability self [
create-accident self
]
]
end

to-report calculate-accident-probability [ c ]
;; Base accident probability from driver error
let base (driver-error-rate * 0.00025)

;; Find the patch under turtle c (using c's pxcor, pycor)
let p patch ([pxcor] of c) ([pycor] of c)

;; Road condition effect
if [road-condition] of p = 1 [
set base (base * 2)
]
if [road-condition] of p = 2 [
set base (base * 2.6)
]

;; Speed factor
let speed-ratio ([speed] of c / [max-speed] of c)
set base (base * (speed-ratio + 0.1)) ;; +0.1 so even slow cars have some chance

;; Congestion effect: how many other cars are within radius 1.5 of c
let nearby-cars count cars with [ distance c < 1.5 ]
set base (base + (nearby-cars * 0.0005))

;; Intersection effect
if [is-intersection?] of p [
set base (base * 1.5)
]

;; Cap at 1% (0.01) to avoid extreme probabilities
report min (list base 0.1)

end

to create-accident [ c ]
set accident-count (accident-count + 1)
set total-cars-accident (total-cars-accident + 1)

;; Mark the patch
let px ([pxcor] of c)
let py ([pycor] of c)
ask patch px py [
set has-accident? true
set pcolor red
set accident-lifetime accident-duration

;; Accidents by Road Condition:
if (road-condition = 0) [ set accident-count-good (accident-count-good + 1) ]
if (road-condition = 1) [ set accident-count-bad (accident-count-bad + 1) ]
if (road-condition = 2) [ set accident-count-very-bad (accident-count-very-bad + 1) ]
]

;; Time & Distance to Accident:
let time-until-accident (ticks - [birth-tick] of c)
let dist-until-accident ([distance-traveled] of c)
set sum-time-until-accident (sum-time-until-accident + time-until-accident)
set sum-distance-until-accident (sum-distance-until-accident + dist-until-accident)

;; kill the car
ask c [ die ]
end

to clear-old-accidents
;; Decrement accident-lifetime. When it hits 0, clear the patch.
ask patches with [has-accident?] [
set accident-lifetime (accident-lifetime - 1)
if (accident-lifetime <= 0) [
set has-accident? false
;; restore color based on road-condition
if (road-condition = 0) [
set pcolor grey
]
if (road-condition = 1) [
set pcolor (grey - 2)
]
if (road-condition = 2) [
set pcolor orange
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 11. STATISTICS & PLOTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-statistics
let car-count count cars
let total-speed 0

if car-count > 0 [
set total-speed sum [speed] of cars
set average-speed (total-speed / car-count)
]
if car-count = 0 [
set average-speed 0
]

set average-congestion count cars with [
(stopped-ticks >= 2) and (any? cars-on patch-ahead 1)
]
if number-of-cars > 0 [
set accident-percentage ((accident-count / number-of-cars) * 100)
]
;;Average travel time for cars that completed trip
if count-completed-cars > 0 [
set average-travel-time (sum-travel-time / count-completed-cars)
]
;;Averages for time & distance until accident
if accident-count > 0 [
set average-time-until-accident (sum-time-until-accident / accident-count)
set average-distance-until-accident (sum-distance-until-accident / accident-count)
]
;; Plot them
carefully [
set-current-plot "Average Speed"
plot average-speed

set-current-plot "Total Accidents"
plot accident-count

set-current-plot "Average Congestion"
plot average-congestion
] []
end

</syntaxhighlight>

[[Media:traffic.nlogo]]

== References ==

Sadauskas, V. (2011). ''Traffic safety strategies'', Transport, 18(2), 79–83. DOI: 10.1080/16483840.2003.10414070

Gstalter, H., & Fastenmeier, W. (2010). ''Reliability of drivers in urban intersections.'' Accident Analysis & Prevention, 42(1), 225–234. [https://doi.org/10.1016/j.aap.2009.07.021 Link]

TSK Praha (2020). ''Ročenka dopravy – 2020.'' [https://www.tsk-praha.cz/static/udi-rocenka-2020-vm-cz-HTML/kapitola_01.html Link]

Nordfjærn, T., Jørgensen, S., & Rundmo, T. (2011). ''A cross-cultural comparison of road traffic risk perceptions, attitudes towards traffic safety, and driver behaviour.'' Journal of Risk Research, 14(6), 657–684. [https://doi.org/10.1080/13669877.2010.547259 Link]

Fanny Malin (2017). ''Accident risks in different weather conditions.'' [https://nordicroads.com/accident-risks-different-weather-conditions/?utm_source=chatgpt.com Link]

Traffic Accident Risk Analysis

2025-01-28T17:09:04Z

Sim timm03:

== Introduction ==
This page introduces a NetLogo-based simulation that models traffic accident risk. The goal is to understand how road conditions, traffic density, and driver behavior intertwine to create or mitigate accidents. Various research sources underscore the need for a systematic approach to traffic safety, illustrating how driver reliability, infrastructure, and cultural factors shape accident outcomes (Sadauskas, 2011; Gstalter & Fastenmeier, 2010; TSK Praha, 2020; Nordfjærn et al., 2011).

== Definition of the Problem ==
Road traffic accidents remain a pressing public health challenge, especially with the steady growth in vehicle numbers worldwide (Sadauskas, 2011). This proliferation escalates the likelihood of collisions, injuries, and fatalities. A robust traffic safety strategy thus necessitates examining:

Road conditions (from good to very bad).

Driver behavior and risk homeostasis (adjusting behavior based on perceived safety).

Environmental and societal factors that influence compliance with safety rules (Nordfjærn et al., 2011).

Moreover, the complexity of urban intersections can amplify error rates, as drivers face higher cognitive loads and multiple conflict points (Gstalter & Fastenmeier, 2010). In city contexts, baseline accident rates still vary considerably depending on infrastructure, as seen in real-world data (TSK Praha, 2020).

== Method ==
We adopt a multi-pronged, systematic approach to traffic safety, integrating **engineering**, **enforcement**, and **education**—commonly referred to as the “Triple E.(Sadauskas, 2011)

== Engineering ==
Vehicle and road design improvements include:

* **''Intersection geometry optimization:''** Represented in the code by the procedure <code>setup-intersections</code>, which identifies and marks intersection patches. Traffic lights are not working as intended, but are in the code base and interface for user to try.

Additionally, **Human Reliability Analysis (HRA)** was used to determine driver error probabilities, particularly at urban intersections.(Gstalter & Fastenmeier, 2010). By defining “correct” task execution and measuring deviations, HRA quantifies how factors such as road geometry, driver age, and psychosocial influences affect driver reliability.

In the code, this is reflected in the procedure <code>calculate-accident-probability</code>, which scales a base driver-error rate by factors such as:

* Road conditions
* Speed ratio
* Local congestion
* Intersection complexity

== Model ==
This simulation uses NetLogo to create a grid of patches representing:

Road segments: Assigned good, bad, or very bad condition.

Intersections: Potentially with traffic lights.

Cars (turtles): Move according to lane rules and can trigger accidents based on speed, congestion, and driver-error-rate.

Key points:

Accident Probability: Derived from a base driver-error-rate, amplified by intersection complexity, road condition, and local traffic density (Gstalter & Fastenmeier, 2010; Nordfjærn et al., 2011).

Baseline Rates: Inspired by real accident data (e.g., TSK Praha’s ročenka dopravy or Accident risks of different weather conditions) (TSK Praha, 2020) (Malin 2017).

Systematic Approach: Reflects suggestions for engineering (road condition logic), education (driver-error slider), and enforcement (speed constraints) in modeling different scenarios (Sadauskas, 2011).

=== Interface ===

[[File:Interface_timm03.png]]

=== High Density, Poor Roads===

[[File:LowDensity_timm03.png]]

Because there are 100 cars with a fairly high driver-error-rate (0.05), multiple accidents occurred (10 total). However, they tended to happen later in the simulation (average time until accident over 300 ticks).
Most cars (90 out of 100) still reached their destination—likely because accident-duration is very short (1 tick), so blocked patches quickly returned to normal.
The relatively high base speed (0.8) also increased mobility, helping more cars finish faster, but also contributed to a moderate accident rate.

=== Low Density, Strict Limits===

[[File:HighDensity_timm03.png]]

Fewer cars (50), but also a much lower base speed (0.3), so cars move more slowly—leading to a higher average travel time (over 200 ticks).
Because driver-error-rate is only 0.01 (lower chance of human error) and 70% roads are good, only 3 accidents occurred.
Even with slow speed, many cars still took a long time to finish, as shown by the high travel time. Almost all cars managed to complete or crash within the time frame, with 47 successful arrivals.

=== Moderate Density, Extended Accident Duration===

[[File:ModerateDensity_timm03.png]]

Compared to the second screenshot, the big difference is accident-duration = 90 (very long).
Even though speed is still 0.3 and the road condition/distribution is the same, the accident count has climbed to 13, and 16% of the cars ended up in accidents.
Because accidents last 90 ticks on a patch, any collision severely disrupts traffic, likely forcing more cars to queue or collide.
Despite that, 67 cars did manage to exit, though the blocked patches would have contributed to higher accident numbers and more emergent congestion.

== Conclusion ==

This NetLogo simulation allows users to vary key parameters—such as base speed, number of cars (density), road condition (good to very bad), driver-error rate, and accident duration—then observe metrics like average travel time, distance/time until accident, and accident hotspots. Results show that poor roads and high driver-error rates sharply increase collisions, while long accident durations intensify congestion. Conversely, safer infrastructure, lower driver-error rates, and faster incident clearance foster smoother traffic flow and fewer crashes, underlining the value of integrated traffic safety strategies.

== Code ==
Below is the NetLogo code implementing the simulation structure (patch definitions, accident logic, congestion metrics, etc.). Users can copy and paste it into a NetLogo environment to run their own experiments. For a complete listing, see the setup, go, and supporting procedures:

<syntaxhighlight lang="netlogo">

globals [
;; Sliders / Switch in Interface:
;; - number-of-cars (int)
;; - road-spacing (int)
;; - base-speed (float)
;; - driver-error-rate (float)
;; - accident-duration (int)
;; - traffic-lights? (boolean switch)

;; Statistics
total-cars-reached-destination
total-cars-accident ;; how many cars died in accidents (cumulative)
accident-count ;; how many total accidents have started
average-speed
average-congestion
accident-percentage
sum-travel-time ;; sum of time in system for all cars that exit
count-completed-cars ;; how many cars reached destination
average-travel-time ;; output metric
accident-count-good
accident-count-bad
accident-count-very-bad
sum-time-until-accident
sum-distance-until-accident
average-time-until-accident
average-distance-until-accident
]

patches-own [
is-road? ;; boolean: is this patch part of a road?
is-intersection? ;; boolean: is this patch an intersection?
lane-direction ;; forced heading: 0, 90, 180, 270, or -1 if intersection
traffic-light? ;; does this patch have a traffic light?
light-state ;; true=green, false=red
has-accident? ;; boolean: accident currently on this patch?
accident-lifetime ;; integer: how many ticks remain for this accident?
road-condition ;; 0=good, 1=bad, 2=very bad (affects accident prob)
]

breed [ cars car ]
cars-own [
speed
max-speed
stopped-ticks
destination ;; patch or nobody
birth-tick ;; store the tick when the car is created
distance-traveled ;; accumulates how far the car has moved
]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 1. SETUP ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup
clear-all

;; Initialize stats
set total-cars-reached-destination 0
set total-cars-accident 0
set accident-count 0
set average-speed 0
set average-congestion 0

set sum-travel-time 0
set count-completed-cars 0
set average-travel-time 0

set accident-count-good 0
set accident-count-bad 0
set accident-count-very-bad 0

set sum-time-until-accident 0
set sum-distance-until-accident 0
set average-time-until-accident 0
set average-distance-until-accident 0

setup-roads
setup-intersections
setup-traffic-lights
setup-road-conditions

reset-ticks

create-initial-cars
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 2. CREATE ROADS (TWO LANE, ONE-WAY) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-roads
ask patches [
set is-road? false
set is-intersection? false
set traffic-light? false
set light-state false
set has-accident? false
set accident-lifetime 0
set lane-direction 0
set road-condition 0
set pcolor green
]

;; 2-lane roads in x or y dimension
let road-patches patches with [
(abs pxcor mod road-spacing <= 1) or
(abs pycor mod road-spacing <= 1)
]

ask road-patches [
set is-road? true
set pcolor grey
]

;; Assign forced lane headings for non-intersection road patches
ask road-patches [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; purely vertical lane: pick 0 or 180
if (x-road? and not y-road?) [
ifelse (pxcor mod 2 = 0)
[ set lane-direction 0 ] ;; "northbound"
[ set lane-direction 180 ] ;; "southbound"
]

;; purely horizontal lane: pick 90 or 270
if (y-road? and not x-road?) [
ifelse (pycor mod 2 = 0)
[ set lane-direction 90 ] ;; "eastbound"
[ set lane-direction 270 ] ;; "westbound"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 3. INTERSECTIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-intersections
ask patches with [is-road?] [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; Intersection = patch that is both x-road & y-road
if (x-road? and y-road?) [
set is-intersection? true
set pcolor yellow
set lane-direction -1 ;; means "all directions possible here"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 4. TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-traffic-lights
if traffic-lights? [
;; Turn on lights at each intersection
ask patches with [is-intersection?] [
set traffic-light? true
set light-state true
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 5. ROAD CONDITIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-road-conditions
let sum-prob (good-road-probability + bad-road-probability)

ask patches with [is-road?] [
let r random-float 1

ifelse (r < good-road-probability) [
;; (1) "Good" road
set road-condition 0
set pcolor grey

] [
ifelse (r < sum-prob) [
;; (2) "Bad" road
set road-condition 1
set pcolor (grey - 2)

;; 5% chance to become "Very Bad" instead:
if random-float 1 < 0.05 [
set road-condition 2
set pcolor orange
]

] [

set road-condition 0
set pcolor grey
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 6. CREATE INITIAL CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to create-initial-cars
ask cars [ die ] ;; remove any old cars

let valid-starts patches with [
is-road? and
not has-accident? and
not any? cars-here
]

if not any? valid-starts [
user-message "No valid road patches for car creation!"
stop
]

create-cars min list number-of-cars (count valid-starts) [
set shape "car"
set color blue
set size 0.8

;; pick a random road patch
let start-patch one-of valid-starts
move-to start-patch
set valid-starts valid-starts with [self != start-patch]

;; If this patch is an intersection => pick a direction
ifelse ([lane-direction] of patch-here = -1)
[ set heading one-of [0 90 180 270] ]
[ set heading [lane-direction] of patch-here ]

set speed 0
set max-speed base-speed
set stopped-ticks 0
set destination nobody
set distance-traveled 0
set birth-tick ticks
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 7. GO (MAIN LOOP) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
if not any? cars [ stop ]

update-traffic-lights
move-cars
check-accidents
clear-old-accidents
update-statistics

tick
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 8. UPDATE TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-traffic-lights
if traffic-lights? [
ask patches with [is-intersection? and traffic-light?] [
;; simple toggle every 30 ticks
if (ticks mod 30 = 0) [
set light-state not light-state
set pcolor ifelse-value light-state [green] [red]
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 9. MOVE CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to move-cars
ask cars [
;; Force lane direction
let patch-lane [lane-direction] of patch-here

ifelse patch-lane = -1 [
;; intersection => pick a new direction each tick or once
set heading one-of [0 90 180 270]
]
[
;; normal lane => enforce that heading
set heading patch-lane
]

;; Decide if it's safe to move
let safe-to-move? true

;; Check traffic light
if [traffic-light?] of patch-here [
if not ([light-state] of patch-here) [
set safe-to-move? false
]
]

;; Check for cars ahead in same lane
if any? cars-on patch-ahead 1 [
set safe-to-move? false
]

;; Move or slow
ifelse safe-to-move? [
set speed min (list (speed + 0.1) max-speed)
forward speed
set distance-traveled distance-traveled + speed
set stopped-ticks 0
] [
set speed max (list (speed - 0.2) 0)
set stopped-ticks (stopped-ticks + 1)
]

;; if the car leaves the grid:
if not is-patch? patch-here [

set count-completed-cars (count-completed-cars + 1)

;; Add to sum-travel-time:
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

;; Then die
die
]

if (max-pxcor - abs xcor) < 1 or (max-pycor - abs ycor) < 1 [
set total-cars-reached-destination (total-cars-reached-destination + 1)

set count-completed-cars (count-completed-cars + 1)
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

die
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 10. ACCIDENT LOGIC (EXPANDED) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to check-accidents
;; For each car, compute probability of an accident
ask cars [
if random-float 1 < calculate-accident-probability self [
create-accident self
]
]
end

to-report calculate-accident-probability [ c ]
;; Base accident probability from driver error
let base (driver-error-rate * 0.00025)

;; Find the patch under turtle c (using c's pxcor, pycor)
let p patch ([pxcor] of c) ([pycor] of c)

;; Road condition effect
if [road-condition] of p = 1 [
set base (base * 2)
]
if [road-condition] of p = 2 [
set base (base * 2.6)
]

;; Speed factor
let speed-ratio ([speed] of c / [max-speed] of c)
set base (base * (speed-ratio + 0.1)) ;; +0.1 so even slow cars have some chance

;; Congestion effect: how many other cars are within radius 1.5 of c
let nearby-cars count cars with [ distance c < 1.5 ]
set base (base + (nearby-cars * 0.0005))

;; Intersection effect
if [is-intersection?] of p [
set base (base * 1.5)
]

;; Cap at 1% (0.01) to avoid extreme probabilities
report min (list base 0.1)

end

to create-accident [ c ]
set accident-count (accident-count + 1)
set total-cars-accident (total-cars-accident + 1)

;; Mark the patch
let px ([pxcor] of c)
let py ([pycor] of c)
ask patch px py [
set has-accident? true
set pcolor red
set accident-lifetime accident-duration

;; Accidents by Road Condition:
if (road-condition = 0) [ set accident-count-good (accident-count-good + 1) ]
if (road-condition = 1) [ set accident-count-bad (accident-count-bad + 1) ]
if (road-condition = 2) [ set accident-count-very-bad (accident-count-very-bad + 1) ]
]

;; Time & Distance to Accident:
let time-until-accident (ticks - [birth-tick] of c)
let dist-until-accident ([distance-traveled] of c)
set sum-time-until-accident (sum-time-until-accident + time-until-accident)
set sum-distance-until-accident (sum-distance-until-accident + dist-until-accident)

;; kill the car
ask c [ die ]
end

to clear-old-accidents
;; Decrement accident-lifetime. When it hits 0, clear the patch.
ask patches with [has-accident?] [
set accident-lifetime (accident-lifetime - 1)
if (accident-lifetime <= 0) [
set has-accident? false
;; restore color based on road-condition
if (road-condition = 0) [
set pcolor grey
]
if (road-condition = 1) [
set pcolor (grey - 2)
]
if (road-condition = 2) [
set pcolor orange
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 11. STATISTICS & PLOTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-statistics
let car-count count cars
let total-speed 0

if car-count > 0 [
set total-speed sum [speed] of cars
set average-speed (total-speed / car-count)
]
if car-count = 0 [
set average-speed 0
]

set average-congestion count cars with [
(stopped-ticks >= 2) and (any? cars-on patch-ahead 1)
]
if number-of-cars > 0 [
set accident-percentage ((accident-count / number-of-cars) * 100)
]
;;Average travel time for cars that completed trip
if count-completed-cars > 0 [
set average-travel-time (sum-travel-time / count-completed-cars)
]
;;Averages for time & distance until accident
if accident-count > 0 [
set average-time-until-accident (sum-time-until-accident / accident-count)
set average-distance-until-accident (sum-distance-until-accident / accident-count)
]
;; Plot them
carefully [
set-current-plot "Average Speed"
plot average-speed

set-current-plot "Total Accidents"
plot accident-count

set-current-plot "Average Congestion"
plot average-congestion
] []
end

</syntaxhighlight>

[[Media:Traffic.nlogo]]

== References ==

Sadauskas, V. (2011). ''Traffic safety strategies'', Transport, 18(2), 79–83. DOI: 10.1080/16483840.2003.10414070

Gstalter, H., & Fastenmeier, W. (2010). ''Reliability of drivers in urban intersections.'' Accident Analysis & Prevention, 42(1), 225–234. [https://doi.org/10.1016/j.aap.2009.07.021 Link]

TSK Praha (2020). ''Ročenka dopravy – 2020.'' [https://www.tsk-praha.cz/static/udi-rocenka-2020-vm-cz-HTML/kapitola_01.html Link]

Nordfjærn, T., Jørgensen, S., & Rundmo, T. (2011). ''A cross-cultural comparison of road traffic risk perceptions, attitudes towards traffic safety, and driver behaviour.'' Journal of Risk Research, 14(6), 657–684. [https://doi.org/10.1080/13669877.2010.547259 Link]

Fanny Malin (2017). ''Accident risks in different weather conditions.'' [https://nordicroads.com/accident-risks-different-weather-conditions/?utm_source=chatgpt.com Link]

Traffic Accident Risk Analysis

2025-01-28T17:08:44Z

Sim timm03:

== Introduction ==
This page introduces a NetLogo-based simulation that models traffic accident risk. The goal is to understand how road conditions, traffic density, and driver behavior intertwine to create or mitigate accidents. Various research sources underscore the need for a systematic approach to traffic safety, illustrating how driver reliability, infrastructure, and cultural factors shape accident outcomes (Sadauskas, 2011; Gstalter & Fastenmeier, 2010; TSK Praha, 2020; Nordfjærn et al., 2011).

== Definition of the Problem ==
Road traffic accidents remain a pressing public health challenge, especially with the steady growth in vehicle numbers worldwide (Sadauskas, 2011). This proliferation escalates the likelihood of collisions, injuries, and fatalities. A robust traffic safety strategy thus necessitates examining:

Road conditions (from good to very bad).

Driver behavior and risk homeostasis (adjusting behavior based on perceived safety).

Environmental and societal factors that influence compliance with safety rules (Nordfjærn et al., 2011).

Moreover, the complexity of urban intersections can amplify error rates, as drivers face higher cognitive loads and multiple conflict points (Gstalter & Fastenmeier, 2010). In city contexts, baseline accident rates still vary considerably depending on infrastructure, as seen in real-world data (TSK Praha, 2020).

== Method ==
We adopt a multi-pronged, systematic approach to traffic safety, integrating **engineering**, **enforcement**, and **education**—commonly referred to as the “Triple E.(Sadauskas, 2011)

== Engineering ==
Vehicle and road design improvements include:

* **''Intersection geometry optimization:''** Represented in the code by the procedure <code>setup-intersections</code>, which identifies and marks intersection patches. Traffic lights are not working as intended, but are in the code base and interface for user to try.

Additionally, **Human Reliability Analysis (HRA)** was used to determine driver error probabilities, particularly at urban intersections.(Gstalter & Fastenmeier, 2010). By defining “correct” task execution and measuring deviations, HRA quantifies how factors such as road geometry, driver age, and psychosocial influences affect driver reliability.

In the code, this is reflected in the procedure <code>calculate-accident-probability</code>, which scales a base driver-error rate by factors such as:

* Road conditions
* Speed ratio
* Local congestion
* Intersection complexity

== Model ==
This simulation uses NetLogo to create a grid of patches representing:

Road segments: Assigned good, bad, or very bad condition.

Intersections: Potentially with traffic lights.

Cars (turtles): Move according to lane rules and can trigger accidents based on speed, congestion, and driver-error-rate.

Key points:

Accident Probability: Derived from a base driver-error-rate, amplified by intersection complexity, road condition, and local traffic density (Gstalter & Fastenmeier, 2010; Nordfjærn et al., 2011).

Baseline Rates: Inspired by real accident data (e.g., TSK Praha’s ročenka dopravy or Accident risks of different weather conditions) (TSK Praha, 2020) (Malin 2017).

Systematic Approach: Reflects suggestions for engineering (road condition logic), education (driver-error slider), and enforcement (speed constraints) in modeling different scenarios (Sadauskas, 2011).

=== Interface ===

[[File:Interface_timm03.png]]

=== High Density, Poor Roads===

[[File:LowDensity_timm03.png]]

Because there are 100 cars with a fairly high driver-error-rate (0.05), multiple accidents occurred (10 total). However, they tended to happen later in the simulation (average time until accident over 300 ticks).
Most cars (90 out of 100) still reached their destination—likely because accident-duration is very short (1 tick), so blocked patches quickly returned to normal.
The relatively high base speed (0.8) also increased mobility, helping more cars finish faster, but also contributed to a moderate accident rate.

=== Low Density, Strict Limits===

[[File:HighDensity_timm03.png]]

Fewer cars (50), but also a much lower base speed (0.3), so cars move more slowly—leading to a higher average travel time (over 200 ticks).
Because driver-error-rate is only 0.01 (lower chance of human error) and 70% roads are good, only 3 accidents occurred.
Even with slow speed, many cars still took a long time to finish, as shown by the high travel time. Almost all cars managed to complete or crash within the time frame, with 47 successful arrivals.

=== Moderate Density, Extended Accident Duration===

[[File:ModerateDensity_timm03.png]]

Compared to the second screenshot, the big difference is accident-duration = 90 (very long).
Even though speed is still 0.3 and the road condition/distribution is the same, the accident count has climbed to 13, and 16% of the cars ended up in accidents.
Because accidents last 90 ticks on a patch, any collision severely disrupts traffic, likely forcing more cars to queue or collide.
Despite that, 67 cars did manage to exit, though the blocked patches would have contributed to higher accident numbers and more emergent congestion.

== Conclusion ==

This NetLogo simulation allows users to vary key parameters—such as base speed, number of cars (density), road condition (good to very bad), driver-error rate, and accident duration—then observe metrics like average travel time, distance/time until accident, and accident hotspots. Results show that poor roads and high driver-error rates sharply increase collisions, while long accident durations intensify congestion. Conversely, safer infrastructure, lower driver-error rates, and faster incident clearance foster smoother traffic flow and fewer crashes, underlining the value of integrated traffic safety strategies.

== Code ==
Below is the NetLogo code implementing the simulation structure (patch definitions, accident logic, congestion metrics, etc.). Users can copy and paste it into a NetLogo environment to run their own experiments. For a complete listing, see the setup, go, and supporting procedures:

<syntaxhighlight lang="netlogo">

globals [
;; Sliders / Switch in Interface:
;; - number-of-cars (int)
;; - road-spacing (int)
;; - base-speed (float)
;; - driver-error-rate (float)
;; - accident-duration (int)
;; - traffic-lights? (boolean switch)

;; Statistics
total-cars-reached-destination
total-cars-accident ;; how many cars died in accidents (cumulative)
accident-count ;; how many total accidents have started
average-speed
average-congestion
accident-percentage
sum-travel-time ;; sum of time in system for all cars that exit
count-completed-cars ;; how many cars reached destination
average-travel-time ;; output metric
accident-count-good
accident-count-bad
accident-count-very-bad
sum-time-until-accident
sum-distance-until-accident
average-time-until-accident
average-distance-until-accident
]

patches-own [
is-road? ;; boolean: is this patch part of a road?
is-intersection? ;; boolean: is this patch an intersection?
lane-direction ;; forced heading: 0, 90, 180, 270, or -1 if intersection
traffic-light? ;; does this patch have a traffic light?
light-state ;; true=green, false=red
has-accident? ;; boolean: accident currently on this patch?
accident-lifetime ;; integer: how many ticks remain for this accident?
road-condition ;; 0=good, 1=bad, 2=very bad (affects accident prob)
]

breed [ cars car ]
cars-own [
speed
max-speed
stopped-ticks
destination ;; patch or nobody
birth-tick ;; store the tick when the car is created
distance-traveled ;; accumulates how far the car has moved
]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 1. SETUP ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup
clear-all

;; Initialize stats
set total-cars-reached-destination 0
set total-cars-accident 0
set accident-count 0
set average-speed 0
set average-congestion 0

set sum-travel-time 0
set count-completed-cars 0
set average-travel-time 0

set accident-count-good 0
set accident-count-bad 0
set accident-count-very-bad 0

set sum-time-until-accident 0
set sum-distance-until-accident 0
set average-time-until-accident 0
set average-distance-until-accident 0

setup-roads
setup-intersections
setup-traffic-lights
setup-road-conditions

reset-ticks

create-initial-cars
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 2. CREATE ROADS (TWO LANE, ONE-WAY) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-roads
ask patches [
set is-road? false
set is-intersection? false
set traffic-light? false
set light-state false
set has-accident? false
set accident-lifetime 0
set lane-direction 0
set road-condition 0
set pcolor green
]

;; 2-lane roads in x or y dimension
let road-patches patches with [
(abs pxcor mod road-spacing <= 1) or
(abs pycor mod road-spacing <= 1)
]

ask road-patches [
set is-road? true
set pcolor grey
]

;; Assign forced lane headings for non-intersection road patches
ask road-patches [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; purely vertical lane: pick 0 or 180
if (x-road? and not y-road?) [
ifelse (pxcor mod 2 = 0)
[ set lane-direction 0 ] ;; "northbound"
[ set lane-direction 180 ] ;; "southbound"
]

;; purely horizontal lane: pick 90 or 270
if (y-road? and not x-road?) [
ifelse (pycor mod 2 = 0)
[ set lane-direction 90 ] ;; "eastbound"
[ set lane-direction 270 ] ;; "westbound"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 3. INTERSECTIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-intersections
ask patches with [is-road?] [
let x-road? (abs pxcor mod road-spacing <= 1)
let y-road? (abs pycor mod road-spacing <= 1)

;; Intersection = patch that is both x-road & y-road
if (x-road? and y-road?) [
set is-intersection? true
set pcolor yellow
set lane-direction -1 ;; means "all directions possible here"
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 4. TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-traffic-lights
if traffic-lights? [
;; Turn on lights at each intersection
ask patches with [is-intersection?] [
set traffic-light? true
set light-state true
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 5. ROAD CONDITIONS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup-road-conditions
let sum-prob (good-road-probability + bad-road-probability)

ask patches with [is-road?] [
let r random-float 1

ifelse (r < good-road-probability) [
;; (1) "Good" road
set road-condition 0
set pcolor grey

] [
ifelse (r < sum-prob) [
;; (2) "Bad" road
set road-condition 1
set pcolor (grey - 2)

;; 5% chance to become "Very Bad" instead:
if random-float 1 < 0.05 [
set road-condition 2
set pcolor orange
]

] [

set road-condition 0
set pcolor grey
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 6. CREATE INITIAL CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to create-initial-cars
ask cars [ die ] ;; remove any old cars

let valid-starts patches with [
is-road? and
not has-accident? and
not any? cars-here
]

if not any? valid-starts [
user-message "No valid road patches for car creation!"
stop
]

create-cars min list number-of-cars (count valid-starts) [
set shape "car"
set color blue
set size 0.8

;; pick a random road patch
let start-patch one-of valid-starts
move-to start-patch
set valid-starts valid-starts with [self != start-patch]

;; If this patch is an intersection => pick a direction
ifelse ([lane-direction] of patch-here = -1)
[ set heading one-of [0 90 180 270] ]
[ set heading [lane-direction] of patch-here ]

set speed 0
set max-speed base-speed
set stopped-ticks 0
set destination nobody
set distance-traveled 0
set birth-tick ticks
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 7. GO (MAIN LOOP) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
if not any? cars [ stop ]

update-traffic-lights
move-cars
check-accidents
clear-old-accidents
update-statistics

tick
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 8. UPDATE TRAFFIC LIGHTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-traffic-lights
if traffic-lights? [
ask patches with [is-intersection? and traffic-light?] [
;; simple toggle every 30 ticks
if (ticks mod 30 = 0) [
set light-state not light-state
set pcolor ifelse-value light-state [green] [red]
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 9. MOVE CARS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to move-cars
ask cars [
;; Force lane direction
let patch-lane [lane-direction] of patch-here

ifelse patch-lane = -1 [
;; intersection => pick a new direction each tick or once
set heading one-of [0 90 180 270]
]
[
;; normal lane => enforce that heading
set heading patch-lane
]

;; Decide if it's safe to move
let safe-to-move? true

;; Check traffic light
if [traffic-light?] of patch-here [
if not ([light-state] of patch-here) [
set safe-to-move? false
]
]

;; Check for cars ahead in same lane
if any? cars-on patch-ahead 1 [
set safe-to-move? false
]

;; Move or slow
ifelse safe-to-move? [
set speed min (list (speed + 0.1) max-speed)
forward speed
set distance-traveled distance-traveled + speed
set stopped-ticks 0
] [
set speed max (list (speed - 0.2) 0)
set stopped-ticks (stopped-ticks + 1)
]

;; if the car leaves the grid:
if not is-patch? patch-here [

set count-completed-cars (count-completed-cars + 1)

;; Add to sum-travel-time:
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

;; Then die
die
]

if (max-pxcor - abs xcor) < 1 or (max-pycor - abs ycor) < 1 [
set total-cars-reached-destination (total-cars-reached-destination + 1)

set count-completed-cars (count-completed-cars + 1)
set sum-travel-time (sum-travel-time + (ticks - birth-tick))

die
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 10. ACCIDENT LOGIC (EXPANDED) ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to check-accidents
;; For each car, compute probability of an accident
ask cars [
if random-float 1 < calculate-accident-probability self [
create-accident self
]
]
end

to-report calculate-accident-probability [ c ]
;; Base accident probability from driver error
let base (driver-error-rate * 0.00025)

;; Find the patch under turtle c (using c's pxcor, pycor)
let p patch ([pxcor] of c) ([pycor] of c)

;; Road condition effect
if [road-condition] of p = 1 [
set base (base * 2)
]
if [road-condition] of p = 2 [
set base (base * 2.6)
]

;; Speed factor
let speed-ratio ([speed] of c / [max-speed] of c)
set base (base * (speed-ratio + 0.1)) ;; +0.1 so even slow cars have some chance

;; Congestion effect: how many other cars are within radius 1.5 of c
let nearby-cars count cars with [ distance c < 1.5 ]
set base (base + (nearby-cars * 0.0005))

;; Intersection effect
if [is-intersection?] of p [
set base (base * 1.5)
]

;; Cap at 1% (0.01) to avoid extreme probabilities
report min (list base 0.1)

end

to create-accident [ c ]
set accident-count (accident-count + 1)
set total-cars-accident (total-cars-accident + 1)

;; Mark the patch
let px ([pxcor] of c)
let py ([pycor] of c)
ask patch px py [
set has-accident? true
set pcolor red
set accident-lifetime accident-duration

;; Accidents by Road Condition:
if (road-condition = 0) [ set accident-count-good (accident-count-good + 1) ]
if (road-condition = 1) [ set accident-count-bad (accident-count-bad + 1) ]
if (road-condition = 2) [ set accident-count-very-bad (accident-count-very-bad + 1) ]
]

;; Time & Distance to Accident:
let time-until-accident (ticks - [birth-tick] of c)
let dist-until-accident ([distance-traveled] of c)
set sum-time-until-accident (sum-time-until-accident + time-until-accident)
set sum-distance-until-accident (sum-distance-until-accident + dist-until-accident)

;; kill the car
ask c [ die ]
end

to clear-old-accidents
;; Decrement accident-lifetime. When it hits 0, clear the patch.
ask patches with [has-accident?] [
set accident-lifetime (accident-lifetime - 1)
if (accident-lifetime <= 0) [
set has-accident? false
;; restore color based on road-condition
if (road-condition = 0) [
set pcolor grey
]
if (road-condition = 1) [
set pcolor (grey - 2)
]
if (road-condition = 2) [
set pcolor orange
]
]
]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; 11. STATISTICS & PLOTS ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to update-statistics
let car-count count cars
let total-speed 0

if car-count > 0 [
set total-speed sum [speed] of cars
set average-speed (total-speed / car-count)
]
if car-count = 0 [
set average-speed 0
]

set average-congestion count cars with [
(stopped-ticks >= 2) and (any? cars-on patch-ahead 1)
]
if number-of-cars > 0 [
set accident-percentage ((accident-count / number-of-cars) * 100)
]
;;Average travel time for cars that completed trip
if count-completed-cars > 0 [
set average-travel-time (sum-travel-time / count-completed-cars)
]
;;Averages for time & distance until accident
if accident-count > 0 [
set average-time-until-accident (sum-time-until-accident / accident-count)
set average-distance-until-accident (sum-distance-until-accident / accident-count)
]
;; Plot them
carefully [
set-current-plot "Average Speed"
plot average-speed

set-current-plot "Total Accidents"
plot accident-count

set-current-plot "Average Congestion"
plot average-congestion
] []
end

</syntaxhighlight>

[[Media:Traffic.nlogo]

== References ==

Sadauskas, V. (2011). ''Traffic safety strategies'', Transport, 18(2), 79–83. DOI: 10.1080/16483840.2003.10414070

Gstalter, H., & Fastenmeier, W. (2010). ''Reliability of drivers in urban intersections.'' Accident Analysis & Prevention, 42(1), 225–234. [https://doi.org/10.1016/j.aap.2009.07.021 Link]

TSK Praha (2020). ''Ročenka dopravy – 2020.'' [https://www.tsk-praha.cz/static/udi-rocenka-2020-vm-cz-HTML/kapitola_01.html Link]

Nordfjærn, T., Jørgensen, S., & Rundmo, T. (2011). ''A cross-cultural comparison of road traffic risk perceptions, attitudes towards traffic safety, and driver behaviour.'' Journal of Risk Research, 14(6), 657–684. [https://doi.org/10.1080/13669877.2010.547259 Link]

Fanny Malin (2017). ''Accident risks in different weather conditions.'' [https://nordicroads.com/accident-risks-different-weather-conditions/?utm_source=chatgpt.com Link]

Assignments WS 2024/2025

2024-12-07T15:11:52Z

Sim timm03:

{{Ambox
| text = <div>
Please, put here your assignments. Do not forget to sign them. You can use <nowiki>~~~~</nowiki> (four tildas) for an automatic signature. Use Show preview in order to check the result before your final sumbition.
</div>
}}

{{Ambox
| text = <div>
Please, strive to formulate your assignment carefully. We expect an adequate effort to formulate the assignment as it is your semestral paper. Do not forget that your main goal is a research paper. It means your simulation model must generate the results that are specific, measurable and verifiable. Think twice how you will develop your model, which entities you will use, draw a model diagram, consider what you will measure. No sooner than when you have a good idea about the model, submit your assignment. And of course, read [[How to deal with the simulation assignment|How to deal with the simulation assignment]].
</div>
}}

{{Ambox
| text = <div>
Topics on gambling, cards, etc. are not welcome.
</div>
}}

{{Ambox
| type = content
| text = <div>
In order to avoid possible confusion, please, check if you have added '''approved''' in bold somewhere in our comment under your submission. If there is no '''approved''', it means the assignment was not approved yet.
</div>
}}

{{Ambox
| text = <div>
'''Criteria for evaluation of the simulation proposal'''

The proposal must contain:
*What you will simulate
*The goal of the simulation (what you analyze - i.e. not "to simulate balloon factory", but what problem should the simulation solve).
*Who would actually use such simulation (example of such user) and how would it help him
*What method and simulation environment you plan to use. Choose only from the development environments that we have used in the course.
*What variables will be incorporated
*What variables will be random
*What exact data you will base values of your variables on
*(In case of Monte Carlo) What exact data you will base your determination of probability distribution of your random variables on
*What exact data you will base your formulas in the simulation (simulation behavior) on

'''If any of the above points are missing from the simulation proposal, the proposal is considered incomplete. Unless the proposal contains all of the above points it will not be evaluated at all (and therefore cannot be approved).'''

# Is it clear from the proposed assignment how the simulation will work?
# Does the simulation make sense?
# Is the simulation model complex enough to simulate credibly the real-world phenomenon that the simulation tries to simulate?
# Is the data used real and relevant for the real-world phenomenon that the simulation tries to simulate?
# Is the simulation feasible? (in given time by the course)

'''If the answer to any of the above points is no, you need to improve your proposal. Don't wait for us to tell you so - you're wasting your time.'''

</div>
}}

'''Assignment Proposal (Draft) Title:'''
*Simulation of pension reform in the Czech Republic: Analysis of long-term sustainability

'''What will be simulated:'''
*A system dynamics model of the Czech pension system that simulates the long-term financial sustainability under varying demographic, economic, and policy scenarios. The simulation will project future balances of the pension system, incorporating the flows of revenues (social insurance contributions) and expenditures (pension payouts)

'''Goal of the simulation (What problem should the simulation solve):'''
*The main goal is to analyze how different pension reform strategies (e.g., adjusting retirement age, altering contribution rates, changing the indexation formula of pensions) will affect the long-term stability of the Czech pension system. The simulation aims to identify specific policy levers and thresholds that ensure the pension system’s financial equilibrium over a multi-decade horizon, despite changing demographic and economic conditions.

'''Who would use the simulation and how it helps them:'''
*The potential users include not only the Ministry of Finance, the Ministry of Labour and Social Affairs, but also the general public and the media. Although the model does not simulate the pension system in complete detail, it provides a general overview and helps users understand the basic mechanisms and trends that will shape the future of the pension system. In this way, users can:
**Gain a preliminary orientation and inspiration: By experimenting with simple scenarios (e.g., raising the retirement age or altering contribution rates), users can gain a clearer picture of how different reform steps could influence the stability of the pension system.
**Provide context for public debate: The model can assist citizens, journalists, and non-profit organizations in better understanding the issues surrounding pension reform. This allows them to critically evaluate political proposals or expert recommendations.
**Lead to more informed decision-making: While this is not a tool for detailed macroeconomic forecasting, the simulation provides a general insight into potential long-term trends. This can contribute to a broader understanding of the necessity for reforms and their impact on future generations.

'''Method and simulation environment:'''

*Method: System Dynamics
*Simulation environment: Vensim PLE (freely available for academic use)

'''Variables in the model (deterministic and random):'''

*Core Population Variables:
**Number of children (new entrants to future workforce)
**Number of working-age population (workers contributing to the system)
**Number of pensioners (beneficiaries)

*Policy Variables:
**Statutory retirement age
**Contribution rate to social insurance (percentage of wage)
**Pension benefit formula and indexation mechanism

*Economic Variables:
**Average wage (influences contributions)
**Inflation rate (influences indexation of pensions and wage growth)

*Fiscal Variables:
**Total contributions collected (based on number of workers, contribution rate, and average wage)
**Total pension expenditure (based on number of pensioners and average pension)
**Pension system reserve fund (if applicable) and its depletion or accumulation

*Random Variables:
**The model will incorporate stochastic elements through probability distributions derived from historical data and OECD/EUROSTAT projections to reflect uncertainty in:
***Fertility rate (affects future workforce size; random from projected distribution)
***Mortality rate / Life expectancy changes (stochastic variation around central OECD forecasts)
***Inflation rate (stochastic variation around central forecast from CNB/OECD data)
***Retirement rate (number of people retire each year +-)

'''Data sources (for deterministic baseline and to derive distributions):'''
*Czech Statistical Office (ČSÚ) for historical demographic data
*OECD demographic and economic projections for Czech Republic
*Eurostat long-term demographic projections for EU countries

'''Formulas in the simulation (examples):'''
*Pension Expenditure: Total Pension Expenditure = Number of Pensioners * Average Pension
*Average Pension Calculation: Average Pension(t+1) = Average Pension(t) * (1 + InflationIndex)
*Contribution Revenue: Total Contributions = Number of Workers * Average Wage * Contribution Rate
*System Balance: Annual Balance = Total Contributions - Total Pension Expenditure
*Accumulation or depletion of the pension reserve fund is then modeled as a stock: Reserve(t+1) = Reserve(t) + Annual Balance.

'''Model complexity and data linking:'''
*'''Causal loop diagrams (CLD):''' Will illustrate feedback loops such as how employment and wage growth influence contributions, and how demographic changes influence the ratio of workers to retirees.
*'''Stock and Flow Diagrams:''' Will detail population stocks (children, workers, retirees), and financial stocks (pension fund reserves), along with flows (entrants to workforce, retirees, death rates, pension contributions, and payouts).

'''Specific, measurable, and verifiable results:'''
*Specificity: The model will project the pension system’s financial status from year X to year X+50 under various reform scenarios, providing exact quantitative outcomes (e.g., fund balance in billions CZK, pension-to-wage ratio).

*Measurable metrics:
**Dependency ratio (number of pensioners per 100 workers)
**Pension system annual balance (CZK) and cumulative reserves over time
**Average replacement rate (pension/average wage ratio)
**Sensitivity of sustainability gap to changes in retirement age or contribution rate

*Verifiability: The initial model run will be calibrated against historical data for the past decade. Adjustments to parameters and comparison with known OECD and ČSÚ forecasts will verify the model’s credibility.

[[User:Omaj01|Omaj01]] ([[User talk:Omaj01|talk]])
::'''APPROVED'''[[User:Oleg.Svatos|Oleg.Svatos]] ([[User talk:Oleg.Svatos|talk]]) 17:57, 6 December 2024 (CET)

----

''' Simulation concept – Invasive Plant Species vs. Native Plants vs. Herbivores Jan César (cesj05) '''

''' Objectives: '''

Understand the dynamics of competition between invasive plant species and native plants in a shared environment

Explore the conditions under which either the invasive species dominates, coexists, or fails to establish.

''' Environment: '''

Each patch represents a piece of land that can grow either a natrive or invasive plant (or remain empty)

Plants compete for resources on each path

''' Agents: '''

Native Plants: Slower growth but more resistant to herbivores or harsh conditions.

Invasive Plants: Faster growth and higher seed dispersal rate but less resistant to herbivores.

Herbivores: Agents that eat plants, with a preference for invasive or native species (modifiable by the user).

''' Methods '''

Initialization:

Randomly populate the grid with a mix of invasive and native plants.

Set up resource levels for each patch.

Place herbivores randomly across the grid.

''' Simulation Steps (Turtles/Agents): '''

Each plant (agent) checks:

Whether it has resources to grow or reproduce.

If conditions are favorable, it spreads seeds to nearby patches.

Herbivores move and consume plants on the patches they visit.

Competition between plants on shared patches determines which survives.

''' Interaction Dynamics: Modify the probability of herbivory or the effectiveness of seed dispersal as sliders to explore different scenarios.

The simulation will be done in NetLogo, as for the data, it will not be used from real world, but it will be set up, so the behaviour of agents will be as close as it can to real life.

Used studies for setting up the behaviour of plants and herbivores will be:
https://www.mdpi.com/1424-2818/16/6/317
https://academic.oup.com/jpe/article/17/2/rtae007/7589693

If needed, more studies will be used.

This simulation can be used by gardeners trying to maintain their garden. [[User:Cesj05|Cesj05]] ([[User talk:Cesj05|talk]]) 17:53, 6 December 2024 (CET)
----
== Simulation Concept – Traffic Accident Risk Analysis ==

=== Objectives ===
* Understand the dynamics of traffic accidents based on road conditions, traffic density, and driver behavior.
* Explore the conditions under which accidents become frequent, and how they impact overall traffic flow.
* Test mitigation strategies like improved road quality or stricter speed limits.

=== Environment ===
* '''Patches''': Represent road segments and intersections, each with a defined condition:
** '''Good''': Low accident probability.
** '''Bad''': Increased accident probability.
** '''Under Construction''': High accident probability and slower movement for cars.
* '''Road Network''': A grid-based layout with straight roads and intersections where traffic can flow.

=== Agents ===
# '''Cars (Turtles):'''
## Each car has a speed, a destination, and a probability of making a driving error.
## Movement is influenced by traffic density and road conditions.
# '''Accidents:'''
## Simulated as blocked road segments.
## Cause delays and force cars to reroute.
# '''Traffic Lights (Optional):'''
## Located at intersections to control flow.
## Can be toggled on/off to explore their impact on accidents.

=== Methods ===
==== Initialization ====
* Randomly distribute cars across the road network with initial speeds and destinations.
* Assign random conditions (good, bad, under construction) to road segments based on user input.

==== Simulation Steps (Turtles/Agents) ====
# '''Movement:'''
## Cars follow road segments, moving faster on good roads and slower on bad/under-construction ones.
# '''Accident Risk:'''
## Probability of an accident increases with:
### Poor road conditions.
### High speed.
### High traffic density.
# '''Accident Handling:'''
## If an accident occurs, the road segment is temporarily blocked.
## Cars reroute to avoid the blocked segment, increasing congestion elsewhere.
# '''Recovery:'''
## Accidents are cleared after a set duration, restoring traffic flow.

==== Interaction Dynamics ====
* '''User Controls:'''
** Traffic density, road condition distribution, speed limits, and driver error probabilities can be adjusted with sliders.
* '''Scenarios:'''
** Test high traffic density with poor roads versus low traffic density with good roads.
** Simulate stricter traffic laws by reducing driver errors and imposing speed limits.

=== Simulation Details ===
* '''Platform''': NetLogo.
* '''Data Source''': Synthetic data will be used to mimic real-world traffic dynamics based on studies and assumptions.
* '''Behavior Setup''': Modeled on findings from traffic and safety research:
** [https://www.tandfonline.com/doi/full/10.1080/13669877.2010.547259 Study 1]
** [https://www.tandfonline.com/doi/pdf/10.1080/23311916.2020.1834659 Study 2]
** [https://www.tandfonline.com/doi/pdf/10.1080/16483840.2003.10414070 Study 3]
* Additional studies will be incorporated if needed to refine parameters.
[[User:Sim timm03|Sim timm03]] ([[User talk:Sim timm03|talk]]) 16:11, 7 December 2024 (CET)