<!DOCTYPE html><html lang="en-us" >




  


<head>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="generator" content="Source Themes Academic 4.8.0">

  

  
  
  
  
  
    
    
    
  
  

  <meta name="author" content="Fraunhofer FOKUS">

  
  
  
    
  
  <meta name="description" content="The simulative investigation of communication-based Traffic Management solutions requires combining models from different domains. Eclipse MOSAIC suits very well for this purpose as it couples multiple simulators to model vehicle movement pattern, infrastructure sensors, (variable) traffic signs, as well as different communication links (ITS-G5, 4G/5G) between vehicles and backends, and the application logic in entities like vehicles and a Traffic Management Center.">

  
  <link rel="alternate" hreflang="en-us" href="https://www.eclipse.org/mosaic/post/traffic-control/">

  


  
  
  
  <meta name="theme-color" content="#68145C">
  

  
  
  
  <script src="/mosaic/js/mathjax-config.js"></script>
  

  
  
  
  
    
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/academicons/1.8.6/css/academicons.min.css" integrity="sha512-MCWBwPSput2UWNwyznVFLbD2iUc1e5VsdD1zahsWVzkDSUzyHhMZ4kCS3wgYSRm0mU+glwD/Q9lSJrDPwbUL2A==" crossorigin="anonymous">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.12.0-1/css/all.min.css" integrity="sha512-ZYg+hQvLlM0W9C3P6vTpes5LmJ66G2EsroxDNzwD6qiulckldb29eD9I672HL2X+LH5nRhY1sQqZLJGB+aUUPg==" crossorigin="anonymous">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/fancybox/3.5.7/jquery.fancybox.min.css" integrity="sha512-H9jrZiiopUdsLpg94A333EfumgUBpO9MdbxStdeITo+KEIMaNfHNvwyjjDJb+ERPaRS6DpyRlKbvPUasNItRyw==" crossorigin="anonymous">

    
    
    
      
    
    
      
      
        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/styles/atom-one-light.min.css" crossorigin="anonymous" title="hl-light">
        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/styles/atom-one-light.min.css" crossorigin="anonymous" title="hl-dark" disabled>
      
    

    
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.5.1/leaflet.css" integrity="sha512-xwE/Az9zrjBIphAcBb3F6JVqxf46+CDLwfLMHloNu6KEQCAWi6HcDUbeOfBIptF7tcCzusKFjFw2yuvEpDL9wQ==" crossorigin="anonymous">
    

    

    
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
        <script src="https://cdnjs.cloudflare.com/ajax/libs/lazysizes/5.2.2/lazysizes.min.js" integrity="sha512-TmDwFLhg3UA4ZG0Eb4MIyT1O1Mb+Oww5kFG0uHqXsdbyZz9DcvYQhKpGgNkamAI6h2lGGZq2X8ftOJvF/XjTUg==" crossorigin="anonymous" async></script>
      
    
      

      
      

      
    
      

      
      

      
    
      

      
      

      
        <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/3.1.0/es5/tex-chtml.min.js" integrity="sha512-uwL1UtpYdWra2iqJlAW8Ts0s9Os6IxWLDJDF/BnWdhDmT7DEMFba3GPsFwmV3QiTNcUyl2GB5vsgycB/MOvo9g==" crossorigin="anonymous" async></script>
      
    
      

      
      

      
    
      

      
      

      
    

  

  
  
  
  <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,400i,700,700i%7CRoboto+Mono&display=swap">
  

  
  
  
  
  <link rel="stylesheet" href="/mosaic/css/academic.css">

  




  


  
  

  

  <link rel="manifest" href="/mosaic/index.webmanifest">
  <link rel="icon" type="image/png" href="/mosaic/images/icon_hu6bdfb97c7e23190c70e41ca0e15a9fce_30436_32x32_fill_lanczos_center_2.png">
  <link rel="apple-touch-icon" type="image/png" href="/mosaic/images/icon_hu6bdfb97c7e23190c70e41ca0e15a9fce_30436_192x192_fill_lanczos_center_2.png">

  <link rel="canonical" href="https://www.eclipse.org/mosaic/post/traffic-control/">

  
  
  
  
  
  
  
    
  
  
  <meta property="twitter:card" content="summary_large_image">
  
  <meta property="og:site_name" content="Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility">
  <meta property="og:url" content="https://www.eclipse.org/mosaic/post/traffic-control/">
  <meta property="og:title" content="Studying Traffic Control Algorithms in MOSAIC | Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility">
  <meta property="og:description" content="The simulative investigation of communication-based Traffic Management solutions requires combining models from different domains. Eclipse MOSAIC suits very well for this purpose as it couples multiple simulators to model vehicle movement pattern, infrastructure sensors, (variable) traffic signs, as well as different communication links (ITS-G5, 4G/5G) between vehicles and backends, and the application logic in entities like vehicles and a Traffic Management Center."><meta property="og:image" content="https://www.eclipse.org/mosaic/post/traffic-control/featured.png">
  <meta property="twitter:image" content="https://www.eclipse.org/mosaic/post/traffic-control/featured.png"><meta property="og:locale" content="en-us">
  
    
      <meta property="article:published_time" content="2021-01-18T00:00:00&#43;00:00">
    
    <meta property="article:modified_time" content="2021-01-18T00:00:00&#43;00:00">
  

  


    






  




<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://www.eclipse.org/mosaic/post/traffic-control/"
  },
  "headline": "Studying Traffic Control Algorithms in MOSAIC",
  
  "image": [
    "https://www.eclipse.org/mosaic/post/traffic-control/featured.png"
  ],
  
  "datePublished": "2021-01-18T00:00:00Z",
  "dateModified": "2021-01-18T00:00:00Z",
  
  "author": {
    "@type": "Person",
    "name": "Fraunhofer FOKUS"
  },
  
  "publisher": {
    "@type": "Organization",
    "name": "Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.eclipse.org/mosaic/images/logo.svg"
    }
  },
  "description": "The simulative investigation of communication-based Traffic Management solutions requires combining models from different domains. Eclipse MOSAIC suits very well for this purpose as it couples multiple simulators to model vehicle movement pattern, infrastructure sensors, (variable) traffic signs, as well as different communication links (ITS-G5, 4G/5G) between vehicles and backends, and the application logic in entities like vehicles and a Traffic Management Center."
}
</script>

  

  


  


  





  <title>Studying Traffic Control Algorithms in MOSAIC | Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility</title>

</head>

<body id="top" data-spy="scroll" data-offset="70" data-target="#TableOfContents" class=" page-mosaic page-post page-traffic-control ">

  <aside class="search-results" id="search">
  <div class="container">
    <section class="search-header">

      <div class="row no-gutters justify-content-between mb-3">
        <div class="col-10 col-md-3">
          <div class="logo" style="background-image: url(/mosaic/img/logos/mosaic/EclipseMOSAIC-Logo-RGB-positiv.svg)"></div>
        </div>
        <div class="col-2 col-md-4 col-search-close">
          <a class="js-search" href="#"><i class="fas fa-times-circle text-muted" aria-hidden="true"></i></a>
        </div>
      </div>

      <div id="search-box">
        
        <input name="q" id="search-query" placeholder="Search..." autocapitalize="off"
        autocomplete="off" autocorrect="off" spellcheck="false" type="search">
        
      </div>

    </section>
    <section class="section-search-results">

      <div id="search-hits">
        
      </div>

    </section>
  </div>
</aside>


  






  



  


<nav class="navbar navbar-expand-lg navbar-light compensate-for-scrollbar" id="navbar-main">
  <div class="container">

    <div class="d-none d-lg-inline-flex">
      <a style="visibility:visible;" class="navbar-brand" href="/mosaic/"><img src="/mosaic/images/logo.svg" alt="Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility"></a>
    </div>


    
    <button type="button" class="navbar-toggler" data-bs-toggle="collapse" data-bs-target="#navbar-content-mobile" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
      <span><i class="fas fa-bars"></i></span>
    </button>
    

    
    <div class="navbar-brand-mobile-wrapper d-inline-flex d-lg-none">
      <a class="navbar-brand" href="/mosaic/"><img src="/mosaic/images/logo.svg" alt="Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility"></a>
    </div>
    

    
    
    <div id="navbar-content" class="navbar-collapse main-menu-item collapse justify-content-start">

    
    <ul class="navbar-nav d-md-inline-flex">
      

      

      
      
      
      
      

      
      
      
      
      
      

      <li class="nav-item">
        <a class="nav-link " href="/mosaic/about"><span>About</span></a>
      </li>

      
      

      

      
      
      
      
      

      
      
      
      
      
      

      <li class="nav-item">
        <a class="nav-link " href="/mosaic/news"><span>News</span></a>
      </li>

      
      

      

      
      
      
      
      

      
      
      
      
      
      

      <li class="nav-item">
        <a class="nav-link " href="/mosaic/docs"><span>Documentation</span></a>
      </li>

      
      

      

      
      
      
      
      

      
      
      
      
      
      

      <li class="nav-item">
        <a class="nav-link " href="/mosaic/tutorials"><span>Tutorials</span></a>
      </li>

      
      

      

      
      
      
      
      

      
      
      
      
      
      

      <li class="nav-item">
        <a class="nav-link " href="/mosaic/download"><span>Download</span></a>
      </li>

      
      

      

      
      
      
      
      

      
      
      
      
      
      

      <li class="nav-item">
        <a class="nav-link " href="/mosaic/community"><span>Community</span></a>
      </li>

      
      

      

      
    </ul>
  </div>

    <ul class="nav-icons navbar-nav flex-row ml-auto d-flex pl-md-2">
      
      <li class="nav-item">
        <a class="nav-link js-search" href="#" aria-label="Search"><i class="fas fa-search" aria-hidden="true"></i></a>
      </li>
      

      

      
      <li class="nav-item ">
        <a href="https://github.com/eclipse/mosaic" target="blank">
          <i class="fab fa-github" aria-hidden="true"></i>
        </a>
      </li>
      

      

    </ul>

    
    
    <div id="navbar-content-mobile" class="navbar-collapse main-menu-item collapse justify-content-start d-lg-none">

    
      <ul class="navbar-nav d-inline-flex">
        

        

        
        
        
          
        

        
        
        
        
        
        

        <li class="nav-item">
          <a class="nav-link " href="/mosaic/about"><span>About</span></a>
        </li>

        
        

        

        
        
        
          
        

        
        
        
        
        
        

        <li class="nav-item">
          <a class="nav-link " href="/mosaic/news"><span>News</span></a>
        </li>

        
        

        

        
        
        
          
        

        
        
        
        
        
        

        <li class="nav-item">
          <a class="nav-link " href="/mosaic/docs"><span>Documentation</span></a>
        </li>

        
        

        

        
        
        
          
        

        
        
        
        
        
        

        <li class="nav-item">
          <a class="nav-link " href="/mosaic/tutorials"><span>Tutorials</span></a>
        </li>

        
        

        

        
        
        
          
        

        
        
        
        
        
        

        <li class="nav-item">
          <a class="nav-link " href="/mosaic/download"><span>Download</span></a>
        </li>

        
        

        

        
        
        
          
        

        
        
        
        
        
        

        <li class="nav-item">
          <a class="nav-link " href="/mosaic/community"><span>Community</span></a>
        </li>

        
        

      

        
      </ul>
    </div>

  </div>
</nav>


  <article class="article">

  












  

  
  
  
<div class="article-container pt-3">
  <h1>Studying Traffic Control Algorithms in MOSAIC</h1>

  

  
    


<div class="article-metadata">

  
  

  
  <span class="article-date">
    
    
      
    
    Jan 18, 2021
  </span>
  

  

  
  <span class="middot-divider"></span>
  <span class="article-reading-time">
    8 min read
  </span>
  

  
  
  

  
  

</div>

    














  
</div>



  <div class="article-container">

    <div class="article-style">
      <p><strong>The simulative investigation of communication-based Traffic Management solutions requires combining models from different domains. Eclipse MOSAIC suits very well for this purpose as it couples multiple simulators to model vehicle movement pattern, infrastructure sensors, (variable) traffic signs, as well as different communication links (ITS-G5, 4G/5G) between vehicles and backends, and the application logic in entities like vehicles and a Traffic Management Center.</strong></p>
<p><img src="featured.png" alt="alternative text for search engines"></p>
<p>In a recent, study we analyzed future traffic estimation and control algorithms towards their use on highways
with special focus on mixed traffic of conventional vehicles, connected vehicles, and autonomous vehicles. Connected
vehicles share telematic information with a Traffic Management Center (TMC) which can then estimate the traffic state
and initiate control mechanisms to improve traffic efficiency either via variable message signs as part of the infrastructure, or via V2X communication directly addressing connected vehicles in order to share
speed and lane change advices with the vehicles on the road (e.g. via ETSI IVI message). In a further step,
dynamic lane assignments have been established, which dedicate lanes to autonomous vehicles only to enable
efficient platooning maneuvers. The individual highlights of Eclipse MOSAIC for simulating such a traffic management system are visualized in the video.</p>
<video controls style="width:55%">
  <source src="https://owncloud.fokus.fraunhofer.de/index.php/s/LclLTzGQ0BdziIn/download" type="video/mp4">
</video>
<p>With <strong>Eclipse MOSAIC</strong> this system has been modelled and simulated with all its various aspects in order to analyze
efficiency improvements of such estimation and control algorithms. As traffic simulator, we employed
<strong><a href="/mosaic/docs/simulators/traffic_simulator_sumo/" title="Eclipse SUMO">Eclipse SUMO</a></strong>, which already provides a basic
model for variable <em>speed</em> signs. However, the preferred <a href="/mosaic/docs/simulators/vms_simulator/" title="MOSAIC VMS Simulator">MOSAIC VMS Simulator</a>
realizes a more flexible concept with the dynamic control of the VMS during simulation runtime, including <em>arbitrary sign semantics</em> additional
to <em>speed</em> and featuring a visibility range. The interplay of information from infrastructure elements as well as communicated information
has been modelled in detail with applications covering realistic behavior of human drivers and autonomous vehicles. Additionally,
real estimation and control algorithms from external suppliers have been integrated into the simulation to
provide a software-in-the-loop environment. The <strong><a href="/mosaic/docs/simulators/application_simulator/#eclipse-mosaic-mapping" title="MOSAIC Mapping">MOSAIC Mapping</a></strong>
allowed for a comprehensive configuration of the different application components to the simulated entities (variously equipped vehicles, RSUs and a TMC cloud server).</p>
<p>The final result was a complex simulation scenario for Eclipse MOSAIC,
including a calibrated traffic model, various application and behavior models for automated, connected and conventional vehicles,
different communication links via ITS-G5 and cellular communication, infrastructure models for sensors and variable message signs, and
a new evaluation component in order to gain statistics out of a simulation.</p>
<table>
<thead>
<tr>
<th style="text-align:left">Requirement</th>
<th style="text-align:center"><a href="/mosaic/docs/simulators/traffic_simulator_sumo/" title="SUMO">SUMO</a></th>
<th style="text-align:center"><a href="/mosaic/docs/simulators/application_simulator/" title="MOSAIC Application">MOSAIC Application</a></th>
<th style="text-align:center"><a href="/mosaic/docs/simulators/network_simulator_cell/" title="MOSAIC Cell">MOSAIC Cell</a></th>
<th style="text-align:center"><a href="/mosaic/docs/simulators/network_simulator_sns/" title="MOSAIC SNS">MOSAIC SNS</a></th>
<th style="text-align:center"><a href="/mosaic/docs/simulators/vms_simulator/" title="MOSAIC VMS">MOSAIC VMS</a></th>
<th style="text-align:center"><a href="/mosaic/docs/visualization/statistics/" title="MOSAIC Output">MOSAIC Output</a></th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left">Simulate Vehicle Traffic on Highways</td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Measure Traffic Properties (Flow, Density)</td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Control Traffic dynamically via VMS</td>
<td style="text-align:center">(X)</td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Exchange V2X Messages via ITS-G5 and 4G/5G</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Include Vehicle Functions which react on IVIM</td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Model Traffic Management Center Facilities</td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Integrate real TMC algorithms in Simulation</td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Include Roadside Units with custom Functionality</td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:left">Generate aggregated Statistics from the Simulation</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
</tr>
<tr>
<td style="text-align:left">Generated Detailed Simulation Logs</td>
<td style="text-align:center">(X)</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center">X</td>
</tr>
</tbody>
</table>
<h3 id="the-simulation-setup">The Simulation Setup</h3>
<p>The traffic model in this scenario has been created using real toll-data for the highway AP7 in northern Spain, provided
by the Spanish toll road management (
<a href="https://www.abertis.com" target="_blank" rel="noopener">Abertis Infraestructuras, S.A.</a>). Based on this data, traffic has been
generated in Eclipse SUMO and calibrated in a way,
that the simulated traffic resembles the original toll data as close as possible. This procedure has been done for the
complete highway AP7 and resulted in more than 500.000 vehicles per day in the simulation. However, it would not make real sense
to analyze a whole highway stretch, as the control algorithms under test apply very local changes. Therefore, we decided to extract
a reduced traffic scenario from the calibrated one by measuring the vehicle movements within a smaller area only. Based on those
measurements we were able to create a realistic traffic model on a stretch of 25 kilometers length near Girona.</p>





  
  











<figure id="figure-the-test-site-modelled-in-eclipse-mosaic">


  <a data-fancybox="" href="/mosaic/post/traffic-control/test-site_huc9e68466259c66b25b58dd1cb0735621_545645_2000x2000_fit_lanczos_2.png" data-caption="The test site modelled in Eclipse MOSAIC">


  <img data-src="/mosaic/post/traffic-control/test-site_huc9e68466259c66b25b58dd1cb0735621_545645_2000x2000_fit_lanczos_2.png" class="lazyload" alt="" width="45%" height="551">
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    The test site modelled in Eclipse MOSAIC
  </figcaption>


</figure>

<p>For modelling the infrastructure, the highway has been divided into so-called segments. Each segment, roughly 500m in length, contains
spot sensors at the entry of each segment to measure traffic flow, lane area detectors which model cameras to measure traffic density, and
Variable Message Signs (VMS) displaying speed limits and lane assignments. Modelling VMS was achieved by the new
simulator <strong>MOSAIC VMS</strong>, which let vehicles &ldquo;see&rdquo; oncoming traffic signs showing speed limits or lane assignments. An additional
behavior model for vehicles implemented in the MOSAIC Application Simulator could react on those instructions accordingly.</p>
<p>The segmentation of the highway was very important for the traffic estimation and control algorithms which have been integrated into the scenario. Those
algorithms, provided by the 
<a href="https://www.pem.tuc.gr/index.php?id=5257" target="_blank" rel="noopener">Technical University of Crete</a>, can
estimate the traffic volume on highways using traditional sensors, but also by receiving CAM messages of connected vehicles. Based on the
traffic estimation, additional algorithms can control the traffic by setting speed limits on VMS, or by sending V2X messages (e.g. ETSI IVI messages)
with speed recommendations or lane change advices to individual vehicles. The control algorithms were written in C++ and have already been used in real
traffic management centers. For this study, we integrated them into the <a href="/mosaic/docs/simulators/application_simulator/" title="MOSAIC Application">MOSAIC Application</a>
Simulator using the Java Native Interface (JNI).</p>





  
  











<figure id="figure-integration-of-traffic-control-algorithms-into-mosaic-application-using-jni">


  <a data-fancybox="" href="/mosaic/post/traffic-control/teac-jni_hu8eedbfac73273995571fbc96a05c851b_31297_2000x2000_fit_lanczos_2.png" data-caption="Integration of Traffic Control Algorithms into MOSAIC Application using JNI">


  <img data-src="/mosaic/post/traffic-control/teac-jni_hu8eedbfac73273995571fbc96a05c851b_31297_2000x2000_fit_lanczos_2.png" class="lazyload" alt="" width="45%" height="632">
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    Integration of Traffic Control Algorithms into MOSAIC Application using JNI
  </figcaption>


</figure>

<p>The estimation algorithms rely on information from vehicles and control algorithms are able to send back advices. Therefore, communication
links are required to exchange V2X messages. To achieve this, two separate communications links have been modelled by integrating
the <strong><a href="/mosaic/docs/simulators/network_simulator_sns/" title="MOSAIC Simple Network Simulator">MOSAIC Simple Network Simulator</a></strong> for ITS-G5 communication,
and the  <strong><a href="/mosaic/docs/simulators/network_simulator_cell/" title="MOSAIC Cell Simulator">MOSAIC Cell Simulator</a></strong> for cellular communication (e.g. 5G or LTE-V2X).
In the former case, vehicles exchanged message with Road Side Units along the road, which then forwarded the information to the Traffic Management
Center (TMC). In the latter case, vehicles were directly connected to the TMC.</p>
<p>Finally, application models for connected and automated vehicles have been integrated by using the
<strong><a href="/mosaic/docs/simulators/application_simulator/" title="MOSAIC Application Simulator">MOSAIC Application Simulator</a></strong>. With the help of these applications
vehicles could react on advices sent by the TMC. Depending on the SAE level of the vehicle in the simulation, the vehicles
would execute a certain advice immediately after some safety checks (fully automated vehicle) or with a certain delay
(connected vehicle with a human driver reacting on a lane-change advice).</p>
<h3 id="evaluations">Evaluations</h3>
<p>In a first study, we took a closer look onto the main traffic flow control (MTFC) in general. This algorithm measures the traffic volume
on the highway and adjusts the speed limits shown on VMS based on the current flow and density. In many cases, traffic collapses
near on-ramps when traffic flow on the highway is already high and additional vehicles are entering, resulting in a capacity drop
on the highway and thereby congestion further upstream. To avoid this from happening, the controller reduces the average speed
of the main flow resulting in more capacity available at the bottleneck. This effect could be shown in MOSAIC with the setup described
above as well, as shown in the Figure below. Here you can see, that the congestion which arises at the bottleneck near segment 30 can
be reduced by activating the controller.</p>





  
  











<figure id="figure-speed-over-time-on-the-highway-left-no-control-enabled-right-control-algorithm-active">


  <a data-fancybox="" href="/mosaic/post/traffic-control/teac-no-control-vs-control_hu3f36ae42f5012c9c73c42f4df7e25b4b_269788_2000x2000_fit_lanczos_2.png" data-caption="Speed over time on the highway. Left no control enabled, right control algorithm active.">


  <img data-src="/mosaic/post/traffic-control/teac-no-control-vs-control_hu3f36ae42f5012c9c73c42f4df7e25b4b_269788_2000x2000_fit_lanczos_2.png" class="lazyload" alt="" width="70%" height="400">
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    Speed over time on the highway. Left no control enabled, right control algorithm active.
  </figcaption>


</figure>

<p>In the previous case, the controller adjusted the speed limit shown on VMS along the highway. Those VMS were placed virtually every
500m along the highway, which would be very expensive to implement on real highways. Therefore, we reduced the number of
VMS placed along the highway and tested the algorithm again. VMS were now placed at strategic positions rather than equidistant. To be more
precisely, five VMS were placed between two consecutive on-ramps, having one VMS to control the speed near the bottleneck, three safety VMS which reduce
the speed stepwise further upstream, and one VMS after the on-ramp to release the vehicles from the control area. As a result, we
could spare over 60% of the VMS placed along the specific highway stretch without seeing much difference in the results.</p>





  
  











<figure id="figure-in-the-left-case-vms-are-placed-every-500m-in-the-right-case-only-few-vms-at-strategic-locations">


  <a data-fancybox="" href="/mosaic/post/traffic-control/teac-full-vms-vs-few-vms_hu3f36ae42f5012c9c73c42f4df7e25b4b_266372_2000x2000_fit_lanczos_2.png" data-caption="In the left case, VMS are placed every 500m. In the right case only few VMS at strategic locations.">


  <img data-src="/mosaic/post/traffic-control/teac-full-vms-vs-few-vms_hu3f36ae42f5012c9c73c42f4df7e25b4b_266372_2000x2000_fit_lanczos_2.png" class="lazyload" alt="" width="70%" height="400">
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    In the left case, VMS are placed every 500m. In the right case only few VMS at strategic locations.
  </figcaption>


</figure>

<p>In addition to controlling the traffic by setting VMS, vehicles do receive speed limits or speed advices via communication using IVI messages.
Those messages contain control decisions for each segment and are spread to the vehicles using ITS-G5 adhoc communication. For this purpose,
the simulation scenario is modelled in a way, that a road side unit is placed at each segment entry. Equipped vehicles adjust their speeds and
therefore control the traffic flow as a whole, as other vehicles (e.g. their followers) are forced to adjust their speeds as well. With this fact
given, we did another experiment in which we eliminated all VMS completely and sent speed limits only via V2X communication to
equipped vehicles. This, on one hand, already works with rather low penetration rates of 15 percent equipped vehicles, as shown in the Figure
below. Furthermore, the higher the penetration rate is, the better the controller works. For high penetration rates, this technique even surpasses the classic
approach via VMS slightly, as connected vehicles can react and controlled more precisely.</p>





  
  











<figure id="figure-in-the-left-case-traffic-is-controlled-via-vms-in-the-right-case-only-v2x-messages-are-utilized">


  <a data-fancybox="" href="/mosaic/post/traffic-control/teac-full-vms-vs-ivim_hu3f36ae42f5012c9c73c42f4df7e25b4b_269336_2000x2000_fit_lanczos_2.png" data-caption="In the left case traffic is controlled via VMS. In the right case, only V2X messages are utilized.">


  <img data-src="/mosaic/post/traffic-control/teac-full-vms-vs-ivim_hu3f36ae42f5012c9c73c42f4df7e25b4b_269336_2000x2000_fit_lanczos_2.png" class="lazyload" alt="" width="70%" height="400">
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    In the left case traffic is controlled via VMS. In the right case, only V2X messages are utilized.
  </figcaption>


</figure>

<h3 id="conclusion">Conclusion</h3>
<p>We modelled complex traffic scenarios including road infrastructures (sensors, dynamic traffic signs, road side units), individual driving
behavior for different SAE levels. Furthermore, we integrated real algorithms for traffic estimation and control into MOSAIC Application
enabling software-in-the-loop tests. By creating and calibrating a highway scenario using real toll data, we could test different
traffic control techniques which showed that traffic flow on highways could be improved, even with novel approaches which do not
rely on classic infrastructure such as road sensors and Variable Message Signs, but almost solely on V2X communication.</p>
<hr>
<p>
<a href="https://www.inframix.eu/" target="_blank" rel="noopener"><img src="inframix.png" alt="INFRAMIX EU"></a></p>
<p>This work was part of the 
<a href="https://www.inframix.eu" target="_blank" rel="noopener">INFRAMIX</a> project. INFRAMIX has received funding from
the European Union&rsquo;s Horizon 2020 research and innovation programme under grant
agreement no 723016.</p>

    </div>

    














  
  




  </div>
</article>

      

    
    
    
      <script src="https://code.jquery.com/jquery-3.4.1.min.js" integrity="sha384-vk5WoKIaW/vJyUAd9n/wmopsmNhiy+L2Z+SBxGYnUkunIxVxAv/UtMOhba/xskxh" crossorigin="anonymous"></script>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/2.6.0/umd/popper.min.js" integrity="sha512-BmM0/BQlqh02wuK5Gz9yrbe7VyIVwOzD1o40yi1IsTjriX/NGF37NyXHfmFzIlMmoSIBXgqDiG1VNU6kB5dBbA==" crossorigin="anonymous"></script>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery.imagesloaded/4.1.4/imagesloaded.pkgd.min.js" integrity="sha512-S5PZ9GxJZO16tT9r3WJp/Safn31eu8uWrzglMahDT4dsmgqWonRY9grk3j+3tfuPr9WJNsfooOR7Gi7HL5W2jw==" crossorigin="anonymous"></script>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery.isotope/3.0.6/isotope.pkgd.min.js" integrity="sha512-Zq2BOxyhvnRFXu0+WE6ojpZLOU2jdnqbrM1hmVdGzyeCa1DgM3X5Q4A/Is9xA1IkbUeDd7755dNNI/PzSf2Pew==" crossorigin="anonymous"></script>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/fancybox/3.5.7/jquery.fancybox.min.js" integrity="sha512-uURl+ZXMBrF4AwGaWmEetzrd+J5/8NRkWAvJx5sbPSSuOb0bZLqf+tOzniObO00BjHa/dD7gub9oCGMLPQHtQA==" crossorigin="anonymous"></script>

      
        <script src="https://cdnjs.cloudflare.com/ajax/libs/mermaid/8.4.8/mermaid.min.js" integrity="sha512-1tS1YUns336Mtxl+vkaLcADPwE1CPNVy3WEf7nrI7DGMMb6/FAVBgL2IzAWVBkB6vVuK94s2zVoiXcw1QZ9S1g==" crossorigin="anonymous" title="mermaid"></script>
      

      
        
        <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/highlight.min.js" integrity="sha512-1LdB3V708w6G4QRl7NsVdTr7MDibyRXr9stQZ+EGjEE0ZPMZkA//ir7kCWmFyxdAJNIRXdR/ZeJmCV0boyiCXw==" crossorigin="anonymous"></script>
        
        <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/languages/java.min.js"></script>
        
        <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/languages/json.min.js"></script>
        
        <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/languages/xml.min.js"></script>
        
        <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/languages/shell.min.js"></script>
        
        <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.18.1/languages/dos.min.js"></script>
        
      

    

    
    
      <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.5.1/leaflet.js" integrity="sha512-GffPMF3RvMeYyc1LWMHtK8EbPv0iNZ8/oTtHPx9/cc2ILxQ+u905qIwdpULaqDkyBKgOaB57QTMg7ztg8Jm2Og==" crossorigin="anonymous"></script>
    

    
    
    <script>const code_highlighting = true;</script>
    

    
    
    <script>const isSiteThemeDark = false;</script>
    

    
    
    
    
    
    
    <script>
      const search_config = {"indexURI":"/mosaic/index.json","minLength":1,"threshold":0.3};
      const i18n = {"no_results":"No results found","placeholder":"Search...","results":"results found"};
      const content_type = {
        'post': "Posts",
        'project': "Projects",
        'publication' : "Publications",
        'talk' : "Talks"
        };
    </script>
    

    
    

    
    
    <script id="search-hit-fuse-template" type="text/x-template">
      <div class="search-hit" id="summary-{{key}}">
      <div class="search-hit-content">
        <div class="search-hit-name">
          <a href="{{relpermalink}}">{{title}}</a>
          <div class="article-metadata search-hit-type">{{type}}</div>
          <p class="search-hit-description">{{snippet}}</p>
        </div>
      </div>
      </div>
    </script>
    

    
    
    <script src="https://cdnjs.cloudflare.com/ajax/libs/fuse.js/3.2.1/fuse.min.js" integrity="sha512-o38bmzBGX+hD3JHWUFCDA09btWaqrNmoJ3RXLlrysA7PP01Kgs4UlE4MhelE1v5dJR3+cxlR4qQlotsW7jKsnw==" crossorigin="anonymous"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/mark.js/8.11.1/jquery.mark.min.js" integrity="sha512-mhbv5DqBMgrWL+32MmsDOt/OAvqr/cHimk6B8y/bx/xS88MVkYGPiVv2ixKVrkywF2qHplNRUvFsAHUdxZ3Krg==" crossorigin="anonymous"></script>
    

    
    

    
    

    
    

    
    
    
    
    
    
    
    
    
      
    
    
    
    
    <script type="application/javascript" src="/mosaic/js/academic.min.0992ad8b8d033c3858bb90b03966346a.js"></script>

    

<script type="application/javascript" src="/mosaic/js/mosaic-wg-cards.js"></script>




    <script>
      var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'))
      tooltipTriggerList.map(function (tooltipTriggerEl) {
        return new window.bootstrap.Tooltip(tooltipTriggerEl)
      })
    </script>


  
  
  <div class="footer-wrap">
    <div class="container">
      <footer class="site-footer">
  <div class="row">
  
    
      <div class="col-sm-4 mb-3 mb-md-0">
        <b>Eclipse MOSAIC</b>
        
          <ul>
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/download/" title="Download Eclipse MOSAIC" >
                    
                      Download Eclipse MOSAIC
                    
                  </a>
                </li>
              
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/docs" title="Documentation" >
                    
                      Documentation
                    
                  </a>
                </li>
              
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/tutorials" title="Tutorials" >
                    
                      Tutorials
                    
                  </a>
                </li>
              
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/community/#projects" title="Projects" >
                    
                      Projects
                    
                  </a>
                </li>
              
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/publications" title="Publications" >
                    
                      Publications
                    
                  </a>
                </li>
              
            
          </ul>
        
      </div>
    
  
    
      <div class="col-sm-4 mb-3 mb-md-0">
        <b>Community</b>
        
          <ul>
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/community" title="Eclipse MOSAIC Community" >
                    
                      Eclipse MOSAIC Community
                    
                  </a>
                </li>
              
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/contribution" title="How to contribute" >
                    
                      How to contribute
                    
                  </a>
                </li>
              
            
              
                
                
                  
                    
                  
                
                <li>
                  <a href="https://github.com/eclipse/mosaic" title="Github"  target="_blank" rel="noopener">
                    
                      Github
                    
                  </a>
                </li>
              
            
              
                
                
                  
                
                <li>
                  <a href="/mosaic/get_in_contact" title="Contact &amp; Mailing list" >
                    
                      Contact & Mailing list
                    
                  </a>
                </li>
              
            
          </ul>
        
      </div>
    
  
    
      <div class="col-sm-4 mb-3 mb-md-0">
        <b>Eclipse Foundation</b>
        
          <ul>
            
              
                
                
                  
                    
                  
                
                <li>
                  <a href="https://www.eclipse.org/" title="About Eclipse Foundation"  target="_blank" rel="noopener">
                    
                      About Eclipse Foundation
                    
                  </a>
                </li>
              
            
              
                
                
                  
                    
                  
                
                <li>
                  <a href="https://www.eclipse.org/legal/privacy.php" title="Privacy Policy"  target="_blank" rel="noopener">
                    
                      Privacy Policy
                    
                  </a>
                </li>
              
            
              
                
                
                  
                    
                  
                
                <li>
                  <a href="https://www.eclipse.org/legal/termsofuse.php" title="Website terms of use"  target="_blank" rel="noopener">
                    
                      Website terms of use
                    
                  </a>
                </li>
              
            
              
                
                
                  
                    
                  
                
                <li>
                  <a href="https://www.eclipse.org/legal/copyright.php" title="Copyright"  target="_blank" rel="noopener">
                    
                      Copyright
                    
                  </a>
                </li>
              
            
              
                
                
                  
                    
                  
                
                <li>
                  <a href="https://www.eclipse.org/legal" title="Legal"  target="_blank" rel="noopener">
                    
                      Legal
                    
                  </a>
                </li>
              
            
          </ul>
        
      </div>
    
  











  </div>
  <div class="row justify-content-center mt-3 position-relative">
    <p class="powered-by text-center font-italic mb-0 pb-0">
      Powered by the
      <a href="https://sourcethemes.com/academic/" target="_blank" rel="noopener">Academic theme</a> for
      <a href="https://gohugo.io" target="_blank" rel="noopener">Hugo</a>.
      <br>
      Header image &#169; fanjianhua/ iStock
    </p>
    
      <span class="position-absolute mr-3 mr-md-0" aria-hidden="true" style="right: 0;">
        <a href="#" class="back-to-top">
          <span class="button_icon">
            <i class="fas fa-chevron-up fa-2x"></i>
          </span>
        </a>
      </span>
    
  </div>
</footer>


    </div>
  </div>
  

  
<div id="modal" class="modal fade" role="dialog">
  <div class="modal-dialog">
    <div class="modal-content">
      <div class="modal-header">
        <h5 class="modal-title">Cite</h5>
        <button type="button" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body">
        <pre><code class="tex hljs"></code></pre>
      </div>
      <div class="modal-footer">
        <a class="btn btn-outline-primary my-1 js-copy-cite" href="#" target="_blank">
          <i class="fas fa-copy"></i> Copy
        </a>
        <a class="btn btn-outline-primary my-1 js-download-cite" href="#" target="_blank">
          <i class="fas fa-download"></i> Download
        </a>
        <div id="modal-error"></div>
      </div>
    </div>
  </div>
</div>

</body>
</html>
