<!DOCTYPE html>
<html lang="en"><head>
    <title>SUMO User Conference 2020 | Eclipse SUMO - Simulation of Urban MObility</title>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="icon" href="https://www.eclipse.org/sumo/images/favicon.ico" type="image/x-icon">
    <link rel="apple-touch-icon" href="https://www.eclipse.org/sumo/images/sumo_twitter.jpg">
    <meta name="description" content="Get in touch with our international user community">
    <meta name="theme-color" content="#338033">
    <meta name="twitter:card" content="summary">
    <meta name="twitter:image" content="https://www.eclipse.org/sumo/images/sumo_twitter.jpg">
    <meta name="twitter:site" content="@eclipsesumo">
    <meta property="og:title" content="SUMO User Conference 2020 | Eclipse SUMO - Simulation of Urban MObility">
    <meta property="og:description" content="Get in touch with our international user community">
    <meta property="og:site_name" content="Eclipse SUMO - Simulation of Urban MObility">
    <meta property="og:image" content="https://www.eclipse.org/sumo/images/sumo_share.png">
    <meta property="og:type" content="website">
    <meta property="og:url" content="https://www.eclipse.org/sumo/2020/">
    <meta name="keywords" content="SUMO, Eclipse SUMO, Traffic Simulation, Mobility">
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css">
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.16.0/umd/popper.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js"></script>
    <link rel="stylesheet" href="https://www.eclipse.org/sumo/css/custom.css">
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.2/css/all.css" integrity="sha384-oS3vJWv+0UjzBfQzYUhtDYW+Pj2yciDJxpsK1OYPAYjqT085Qq/1cq5FLXAZQ7Ay" crossorigin="anonymous">
    <script async defer src="https://buttons.github.io/buttons.js"></script>

    <script>
        window.onload = function check_if_ie() {
            var msie = window.navigator.userAgent.indexOf("MSIE ");
            if (msie > 0 || !!navigator.userAgent.match(/Trident.*rv\:11\./)) {
                document.getElementById("not_for_ie").style.display = 'none';
            }
            return false;
        }
    </script>

    
    

    

</head><body id="page-top"><!-- navigation -->

    
        <nav class="navbar navbar-expand-lg bg-light navbar-light fixed-top">
          <div class="container">
            <a class="navbar-brand" href="https://www.eclipse.org/sumo/"><img class="img-fluid" src="/sumo/images/logos/sumo-logo-white.svg" id="navbar-logo" style="pointer-events:none;" alt="SUMO logo"></a>
            <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#collapsibleNavbar" aria-label="menu icon">
              <span class="navbar-toggler-icon"></span>
            </button>
            <div class="collapse navbar-collapse text-center" id="collapsibleNavbar">
              <ul class="navbar-nav ml-auto">
                
                  
                  <li class="nav-item dropdown">
                    <a class="nav-link dropdown-toggle" href="#" role="button" data-toggle="dropdown" aria-haspopup="true"
                      aria-expanded="false">
                      About
                    </a>
                    <div class="dropdown-menu">
                      
                      <a class="dropdown-item" href="https://www.eclipse.org/sumo/about">About SUMO</a>
                      
                      <a class="dropdown-item" href="https://projects.eclipse.org/projects/automotive.sumo/who">Who&#39;s involved</a>
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/docs/ChangeLog.html">ChangeLog</a>
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/daily">Status of daily build and tests</a>
                      
                    </div>
                  </li>
                  
                
                  
                  <li class="nav-item">
                    <a class="nav-link" href="https://sumo.dlr.de/download">Download</a>
                  </li>
                  
                
                  
                  <li class="nav-item">
                    <a class="nav-link" href="https://sumo.dlr.de/docs/">Documentation</a>
                  </li>
                  
                
                  
                  <li class="nav-item">
                    <a class="nav-link" href="https://www.eclipse.org/sumo/conference">Conference</a>
                  </li>
                  
                
                  
                  <li class="nav-item dropdown">
                    <a class="nav-link dropdown-toggle" href="#" role="button" data-toggle="dropdown" aria-haspopup="true"
                      aria-expanded="false">
                      References
                    </a>
                    <div class="dropdown-menu">
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/docs/Other/Projects.html">Projects</a>
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/docs/Publications.html">Publications</a>
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/docs/Contributed/index.html">Contributed extensions</a>
                      
                    </div>
                  </li>
                  
                
                  
                  <li class="nav-item dropdown">
                    <a class="nav-link dropdown-toggle" href="#" role="button" data-toggle="dropdown" aria-haspopup="true"
                      aria-expanded="false">
                      Support
                    </a>
                    <div class="dropdown-menu">
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/docs/FAQ.html">FAQ</a>
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/docs/Tutorials/index.html">Tutorials</a>
                      
                      <a class="dropdown-item" href="https://github.com/eclipse/sumo/issues">Report a Bug / Issue</a>
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/daily/doxygen/">Doxygen Documentation</a>
                      
                      <a class="dropdown-item" href="https://sumo.dlr.de/docs/Developer/index.html">Developer Documentation</a>
                      
                    </div>
                  </li>
                  
                
                  
                  <li class="nav-item">
                    <a class="nav-link" href="https://www.eclipse.org/sumo/contact">Contact</a>
                  </li>
                  
                
              </ul>
            </div>
            </div>
          </nav>

<!-- /navigation --><div id="content">
<section class="section">
  <div class="container-fluid header bg-gradient" style="padding: 40px 0 40px 0;">
    <div class="svg-rounded">
      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 144.54 17.34" preserveAspectRatio="none" fill="#f8f8f8"><path d="M144.54,17.34H0V0H144.54ZM0,0S32.36,17.34,72.27,17.34,144.54,0,144.54,0"></path></svg>
    </div>
    <h1 class="text-center" style="margin-top: 80px; color:#17412f;">SUMO User Conference 2020</h1>
  
    
    <h4 style="text-align: center; color: #6d846e;">From Traffic Flow to Mobility Modeling</h4>
    
    <p style="text-align: center; color: #6d846e;"><i class="fas fa-calendar-alt"></i> October 26-28  | <i class="fas fa-map-marker-alt"></i> Online</p>
    
    
  </div>

  <div class="container">
    
<div class="text-right">
  <div class="btn-group" style="margin-bottom:10px;">
      <div class="dropdown">
      <button type="button" class="btn btn-light btn-sm dropdown-toggle" data-toggle="dropdown" title="Explore previous conferences">[Archive] Select previous year</button>
          <div class="dropdown-menu text-center">
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2020">2020</a>
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2019">2019</a>
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2018">2018</a>
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2017">2017</a>
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2016">2016</a>
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2015">2015</a>
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2014">2014</a>
              <a class="dropdown-item" href="https://www.eclipse.org/sumo/2013">2013</a>
              <a class="dropdown-item" href="https://sumo.dlr.de/docs/SumoWorkshop2010.html">Workshop 2010</a>
          </div>
      </div> 
  </div>
  </div>

    

<!-- head image -->

<div class="container-fluid" style="padding:0 !important;">
  <img src="../images/conference_2020.png" style="width:100%;" alt="Conference participants" class="img-responsive" />
</div>

<h3 id="introduction">Introduction</h3>

<p>Traffic simulations are of immense importance for researchers as well as practitioners in the field of transportation. SUMO has been available since 2001 and provides a wide range of traffic planning and simulation applications. SUMO consists of a suite of tools covering road network imports and enrichment, demand generation and assignment, and a state-of-the-art microscopic traffic simulator capable of simulating private and public transport modes, as well as person-based trip chains. Being open source, SUMO is easily extensible by new behavioral models and can be dynamically controlled via a well-defined programming interface. These and other features make SUMO one of the most often used open source traffic simulators with a large and international user community.</p>

<h3 id="call-for-papers">Call for Papers</h3>

<p>The conference focuses on presenting new and unique results in the field of mobility simulation and modeling using openly available tools and data. We expect a large variety of research topics and usage approaches. If you are working on a research project fitting the topics below, you are kindly invited to submit an abstract. Possible areas of interest include (but are not limited to):</p>

<ul>
<li>Mobility and Demand Modelling</li>
<li>Traffic Simulation</li>
<li>Open Tools and Open Data</li>
<li>Modelling Urban Mobility</li>
<li>Traffic Applications</li>
<li>Traffic Management Solutions</li>
<li>Intermodal Transport</li>
<li>Autonomous Driving</li>
<li>Logistics Simulation</li>
<li>Vehicular Communication</li>
<li>E-Mobility</li>
</ul>

<h3 id="sessions-and-presentations">Sessions and Presentations</h3>

<ul>
<li>Tutorial • <a href="https://youtu.be/aiOQbaB-pWo"><i class="fab fa-youtube"></i> Video</a></li>
<li>Ask us anything • <a href="https://sumo.dlr.de/2020/chat_QA.txt"><i class="far fa-file-alt"></i> Q&amp;A Chat</a></li>
<li><strong>Keynote:</strong> Emerging mobility trends and the role of transport simulation models - <em>Jordi Casas</em> • <a href="https://www.youtube.com/watch?v=vJe-2T73UOg"><i class="fab fa-youtube"></i> Video</a></li>
</ul>

<hr />

<p><strong>Eclipse Session</strong></p>

<ul>
<li>Eclipse Foundation • <a href="https://sumo.dlr.de/2020/Eclipse Foundation - Gael Blondelle.pdf"><i class="far fa-file-pdf"></i> Slides</a></li>
<li>openADx Working Group • <a href="https://sumo.dlr.de/2020/openADx - Andreas Riexinger.pdf"><i class="far fa-file-pdf"></i> Slides</a></li>
<li>Eclipse ADORe • <a href="https://sumo.dlr.de/2020/Eclipse ADORe - Daniel Hess.pdf"><i class="far fa-file-pdf"></i> Slides</a></li>
<li>openMobility Working Group • <a href="https://sumo.dlr.de/2020/openMobility - Robert Hilbrich.pdf"><i class="far fa-file-pdf"></i> Slides</a></li>
<li>Eclipse MOSAIC • <a href="https://sumo.dlr.de/2020/Eclipse MOSAIC - Robert Protzmann.pdf"><i class="far fa-file-pdf"></i> Slides</a></li>
</ul>

<hr />

<p><strong>Session 1: Autonomous Vehicles</strong></p>

<ul>
<li>Modeling autonomous dynamic vanpooling services in SUMO by integrating the dynamic routing scheduler - <em>Moeid Qurashi, Hai Jiang and Constantinos Antoniou</em> • <a href="https://www.youtube.com/watch?v=Wr96laltPXA"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_42.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>Simulating demand responsive feeder transit services: A case study of Braunschweig - <em>Maria Giuliana Armellini and Laura Bieker-Walz</em> • <a href="https://www.youtube.com/watch?v=pNG0PqaYp7g"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_8.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
</ul>

<hr />

<p><strong>Session 2: AI</strong></p>

<ul>
<li>Computer Simulation Study of Vehicle Type Classification Using Machine Learning Techniques with Mobile Phone Location Data - <em>Chaninart Eosanurak, Nattida Wongtrakoon, Ei Ei Mon and Chaodit Aswakul</em> • <a href="https://www.youtube.com/watch?v=DGB9iqq-maE"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_33.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>AI-based Disposition using a Reinforcement Learning Approach - <em>Georg Merz</em> • <a href="https://www.youtube.com/watch?v=h9hxio9_aeo"><i class="fab fa-youtube"></i> Video</a>
<div class="alert alert-warning alert-dismissible">
<button type="button" class="close" data-dismiss="alert">&times;</button>
This presentation was voted <b>best presentation</b>, by the conference attendees.
</div></li>
<li>Concept and first insights of a sequential MATSim-SUMO tool-coupling to deduce representative 24h-velocity-profiles for autonomous vehicles - <em>Henriette Triebke</em> • <a href="https://www.youtube.com/watch?v=Y_lG7XV2OEg"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_44.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
</ul>

<hr />

<p><strong>Session 3: Other traffic modes</strong></p>

<ul>
<li>Pedestrian Simulation Methodology of Evacuation in the Area of Cotopaxi’s Lahar Influence with SUMO - <em>Sebastian Bucheli and Oswaldo Padilla</em> • <a href="https://www.youtube.com/watch?v=w0jwUQALo-g"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_40.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>Hierarchical delay-based signal coordination for bicycles and motor vehicles traffic - <em>Seyed Abdollah Hosseini, Georgios Grigoropoulos, Andreas Keler, Fritz Busch and Klaus Bogenberger</em> • <a href="https://www.youtube.com/watch?v=UcDV5IfqLmw"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_16.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>A Mathematical Programming Based Approach to Evaluate Ramp Metering Deployment Through Eclipse SUMO - <em>İsmet Gökşad Erdagi, Sercan Akti, Mehmet Ali Silgu and Hilmi Berk Çelikoğlu</em> • <a href="https://www.youtube.com/watch?v=KDPgvJuXTv0"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_45.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
</ul>

<hr />

<p><strong>Session 4: Micro simulation / other</strong></p>

<ul>
<li>ECN-based Mitigation of Congestion in Urban Traffic Networks - <em>Levente Alekszejenkó and Tadeusz P. Dobrowiecki</em> • <a href="https://www.youtube.com/watch?v=5tsTcpOLrLY"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_26.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>Extending the Intelligent Driver Model in SUMO and Verifying the Drive Off Trajectories with Aerial Measurements - <em>Dominik Salles, Stefan Kaufmann and Hans-Christian Reuss</em> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_28.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>A Slipstreaming Model for Cooperative Driving Simulations in SUMO - <em>Andrea Stedile and Michele Segata</em></li>
</ul>

<hr />

<p><strong>Session 5: Real-world Scenarios</strong></p>

<ul>
<li>SAGA: An Activity-based Multi-modal Mobility Scenario Generator for SUMO - <em>Lara Codeca, Jakob Erdmann, Vinny Cahill and Jérôme Härri</em> • <a href="https://www.youtube.com/watch?v=b-ZvQ0XbVvM"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_20.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>InTAS - The Ingolstadt Traffic Scenario for SUMO - <em>Silas Lobo, Stefan Neumeier, Evelio Fernandez and Christian Facchi</em> • <a href="https://www.youtube.com/watch?v=UgPeBxXzDHc"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_24.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
<li>Estimation of Green House Gas and Contaminant Emissions from Traffic by microsimulation and refined Origin-Destination matrices: a methodological approach - <em>Jorge E. Luzuriaga, Juan A. Moreno, Edgar Lorenzo Sáez, Santiago Mira Prats, Javier Fermín Urchueguía, Lenin Guillermo Lemus Zúñiga, José Vicente Oliver Villanueva and Miguel A. Mateo Pla</em> • <a href="https://www.youtube.com/watch?v=YsLTs8KcFF4"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_12.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
</ul>

<hr />

<p><strong>Session 6: Real-world data</strong></p>

<ul>
<li>Calibration of car-following models by using drone videos of a real-world intersection - <em>András Zsámboki, Jiao Li and Zoltán Baksa</em> • <a href="https://www.youtube.com/watch?v=n-vpGqCq-6k"><i class="fab fa-youtube"></i> Video</a></li>
<li>Generating and calibrating large-scale, mesoscopic SUMO network - <em>Sasan Amini, Lukas Ambühl, Gabriel Tilg, Klaus Bogenberger and Monica Menendez</em> • <a href="https://www.youtube.com/watch?v=ODMVjgf-Lrw"><i class="fab fa-youtube"></i> Video</a></li>
<li>Action-points in human driving and in SUMO - <em>Peter Wagner, Jakob Erdmann and Ronald Nippold</em> • <a href="https://www.youtube.com/watch?v=fc_GuHvoOxo"><i class="fab fa-youtube"></i> Video</a> • <a href="https://sumo.dlr.de/2020/SUMO2020_paper_21.pdf"><i class="far fa-file-pdf"></i> Paper</a></li>
</ul>

<hr />

<p><strong>Poster Session 1: Tools</strong></p>

<ul>
<li>QarSUMO: An Open-source Parallel Framework for Large Scale Traffic Simulation - <em>Ke Yang, Hao Chen, Phillip Taylor, Anuhya Vellore, Giovanna Vantini, Stefano Giovanni Rizzo, Xiaosong Ma and Sanjay Chawla</em> • <a href="https://www.youtube.com/watch?v=mLOLKGuZFZ4"><i class="fab fa-youtube"></i> Video</a></li>
<li>PaSyMo: Developing and Testing a Participatory Modeling Toolbox for Urban Systems - <em>Leonard Higi, Tobias Schröder, Antje Michel and Anne Tauch</em> • <a href="https://www.youtube.com/watch?v=W1OVhEECDYY"><i class="fab fa-youtube"></i> Video</a></li>
<li>Hugely Variant Autonomous Driving Training Data Generation Using SUMO and rFpro - <em>Matt Daley</em> • <a href="https://www.youtube.com/watch?v=Lu0FbXCnEzM"><i class="fab fa-youtube"></i> Video</a></li>
<li>Introducing SumoNetVis: A Tool for Visualizing SUMO Networks and Trajectory Data - <em>Patrick Malcolm, Georgios Grigoropoulos, Andreas Keler, Heather Kaths and Klaus Bogenberger</em></li>
<li>Using results of the simulation experiment SUMO models by portable applications - <em>Alexander Manyashin</em> • <a href="https://www.youtube.com/watch?v=p9So7T7wYTI"><i class="fab fa-youtube"></i> Video</a></li>
</ul>

<hr />

<p><strong>Poster Session 2: Modelling connected and intelligent traffic</strong></p>

<ul>
<li>Improving network performance with V2X services of dispatching takeover requests and safe-spot assignments in an urban transition corridor - <em>Robert Alms and Yun-Pang Flötteröd</em> • <a href="https://www.youtube.com/watch?v=Uw3fKKp5P3A"><i class="fab fa-youtube"></i> Video</a></li>
<li>Simulation of automated and connecting driving traffic in the test field Hamburg - <em>Benedikt Scheier</em> • <a href="https://www.youtube.com/watch?v=1FW7GUu84ws"><i class="fab fa-youtube"></i> Video</a></li>
</ul>

<hr />

<p><strong>Poster Session 3: Simulation Scenarios</strong></p>

<ul>
<li>An emergency vehicle prioritization strategy with simulation results of Brunswick - <em>Laura Bieker-Walz, Sten Ruppe, Ronald Nippold and Daniel Wesemeyer</em> • <a href="https://www.youtube.com/watch?v=Mmp6oBaNUY0"><i class="fab fa-youtube"></i> Video</a></li>
<li>I4Port - <em>Melanie Weber and Johannes Rummel</em> • <a href="https://www.youtube.com/watch?v=Gs2rM6NXElo"><i class="fab fa-youtube"></i> Video</a></li>
<li>SUMOPy - a simulation suite to create traffic scenarios with SUMO - <em>Joerg Schweizer</em> • <a href="https://www.youtube.com/watch?v=0iD2qnjIJsQ"><i class="fab fa-youtube"></i> Video</a></li>
</ul>

<hr />

<p><strong>Poster Session 4: Routing</strong></p>

<ul>
<li>An Analysis of Traffic Simulations Based on Modifiable OpenStreetMap Data - <em>Jakob Smretschnig</em> • <a href="https://www.youtube.com/watch?v=HcpJZakZZGY"><i class="fab fa-youtube"></i> Video</a></li>
<li>Building an on-demand routing platform with tight SUMO integration using an event driven architecture - <em>Adrian Plani, Timothy Hudson, Chen Cai and Hanna Grzybowska</em> • <a href="https://www.youtube.com/watch?v=ZGgLisdA9T8"><i class="fab fa-youtube"></i> Video</a></li>
<li>GeoAware: An R-based Framework for Controlling SUMO and Generating Synthetic Vehicle Datasets - <em>Jameson Morgan and Derek Doran</em> • <a href="https://www.youtube.com/watch?v=TxDkCr4qANU"><i class="fab fa-youtube"></i> Video</a></li>
<li>Verification of Right-turn Behavior in SUMO at a Signalized Intersection - <em>Ken Shirahata, Masaki Ito, Azusa Toriumi and Takashi Oguchi</em> • <a href="https://www.youtube.com/watch?v=ghlT5NvLYHw"><i class="fab fa-youtube"></i> Video</a></li>
</ul>

<hr />

<p>You can find all videos here: <a href="https://www.youtube.com/playlist?list=PLy7t4z5SYNaSbneWArP9heFSFI2ARNZrM"><button type="button" class="btn btn-danger btn-sm"><i class="fab fa-youtube"></i> YouTube playlist</button></a></p>

<h3 id="social-event">Social Event</h3>

<p>We are going to have a fun SUMO-related quiz using <a href="https://www.menti.com/">Menti</a>. Join our Zoom meeting and have a smartphone/tablet ready at hand. Test your knowledge of SUMO and win the glorious and prestigious prize of attaching your name to an easter egg in “sumo-gui”.</p>

<h3 id="language">Language</h3>

<p>The conference language is English.</p>

<h3 id="prices">Prices</h3>

<p>Participation at this year&rsquo;s conference will be <strong>free of charge</strong>!</p>

<h3 id="venue">Venue</h3>

<p>Given the extraordinary situation we are facing, this year&rsquo;s SUMO User Conference will be <strong>online</strong> via <a href="https://zoom.us/download#client_4meeting">Zoom</a>.</p>

<h3 id="contact">Contact</h3>

<p>Please contact the conference team via mail at <a href="mailto:sumo-conference@dlr.de">sumo-conference@dlr.de</a></p>

    
    <div class="d-flex justify-content-end"><a href="https://github.com/eclipse/sumo.website/edit/master/content/2020.md"><button type="button" class="btn btn-light btn-sm" title="Edit this page on GitHub"><i class="fas fa-pencil-alt"></i> Edit</button></a></div>
    
  </div>
</section>

        </div>
<button onclick="goTopFunction()" id="goToTop" title="Go to top"><i class="fa fa-arrow-up"></i></button>

  
  <div style="margin-top: 20px; font-size: 0;">
    <svg class="wave d-none d-md-block" style="display: block; pointer-events: none; height:100px;" fill="#ddd" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg" xlink="http://www.w3.org/1999/xlink" viewBox="0 0 1920 75">
        <defs>
            <style>.a {fill: none;} .b {clip-path: url(#a);} .d {opacity: 0.5; isolation: isolate;}</style>
            <clipPath id="a"><rect class="a" width="1920" height="75"></rect></clipPath>
        </defs>
        <title>wave</title>
        <g class="b"><path class="c" d="M1963,327H-105V65A2647.49,2647.49,0,0,1,431,19c217.7,3.5,239.6,30.8,470,36,297.3,6.7,367.5-36.2,642-28a2511.41,2511.41,0,0,1,420,48"></path></g>
        <g class="b"><path class="d" d="M-127,404H1963V44c-140.1-28-343.3-46.7-566,22-75.5,23.3-118.5,45.9-162,64-48.6,20.2-404.7,128-784,0C355.2,97.7,341.6,78.3,235,50,86.6,10.6-41.8,6.9-127,10"></path></g>
        <g class="b"><path class="d" d="M1979,462-155,446V106C251.8,20.2,576.6,15.9,805,30c167.4,10.3,322.3,32.9,680,56,207,13.4,378,20.3,494,24"></path></g>
        <g class="b"><path class="d" d="M1998,484H-243V100c445.8,26.8,794.2-4.1,1035-39,141-20.4,231.1-40.1,378-45,349.6-11.6,636.7,73.8,828,150"></path></g>
    </svg>
  </div>

<div class="d-block d-md-none" style="margin-top:20px;"></div>
  <footer class="footer" style="background: #ddd; margin-top: 0px; padding-top: 20px;">
          <div class="container">
            <div class="row" style="margin-bottom: 16px;">
              <div class="col-md-12">
          <div class="container-fluid">
          <div class="row" style="font-size: small;">
                  <div class="col-md text-left"><b>SUMO</b>
                  <ul class="ul-no-bullet">
                  <li><a href="https://www.eclipse.org/sumo/about">About</a></li>
                  <li><a href="https://sumo.dlr.de/docs/Downloads.html">Downloads</a></li>
                  <li><a href="https://sumo.dlr.de/docs/ChangeLog.html">ChangeLog</a></li>
                  <li><a href="https://sumo.dlr.de/docs/Libraries_Licenses.html">License</a></li>
                  <li><a href="https://sumo.dlr.de/docs/Other/Projects.html">Projects using SUMO</a></li>
                  <li><a href="https://sumo.dlr.de/docs/Publications.html">Publications</a></li>
                  </ul>
                  </div>
                  <div class="col-md text-left"><b>Project</b>
                    <ul class="ul-no-bullet">
                      <li><a href="https://projects.eclipse.org/projects/automotive.sumo/who">Who's involved</a></li>
                      <li><a href="https://sumo.dlr.de/daily/">Status of daily build and tests</a></li>
                      <li><a href="https://www.github.com/eclipse/sumo">GitHub repository</a></li>
                      <li><a href="https://www.github.com/eclipse/sumo.website">Website GitHub repository</a></li>
                      <li><a href="https://sourceforge.net/projects/sumo/">SourceForge</a></li>
                      <li><a href="https://dlr.de/ts/sumo">SUMO @ DLR</a></li>
                      <li><a href="https://projects.eclipse.org/projects/automotive.sumo">SUMO @ Eclipse</a></li>
                    </ul>
                  </div>
                  <div class="col-md text-left"><b>Community</b>
                    <ul class="ul-no-bullet">
                      <li><a href="https://www.eclipse.org/sumo/contact">Mailing lists</a></li>
                      <li><a href="http://sumo-user.90755.n8.nabble.com/">Forum</a></li>
                      <li><a href="https://www.eclipse.org/sumo/conference">SUMO User Conference</a></li>
                      <li><a href="https://openmobility.eclipse.org/">openMobility Working Group</a></li>
                    </ul>
                  </div>
                  <div class="col-md text-left"><b>Support & Training</b>
                    <ul class="ul-no-bullet">
                    <li><a href="https://www.eclipse.org/sumo/contact">Contact us</a></li>
                    <li><a href="https://sumo.dlr.de/docs/FAQ.html">FAQ</a></li>
                    <li><a href="https://sumo.dlr.de/docs/index.html">Documentation</a></li>
                    <li><a href="https://sumo.dlr.de/docs/Developer/index.html">Developer Documentation</a></li>
                    <li><a href="https://sumo.dlr.de/daily/doxygen/">Doxygen Documentation</a></li>
                    <li><a href="https://sumo.dlr.de/docs/Tutorials/index.html">Tutorials</a></li>
                    <li><a href="https://github.com/eclipse/sumo/issues">Issue Tracking</a></li>
                    </ul>
                  </div>
                  <div class="col-md text-left"><b>Eclipse Foundation</b>
                    <br>
                    <a href="https://www.eclipse.org/"><img class="img-fluid" src="https://www.eclipse.org/sumo/images/logos/eclipse-logo.png" alt="Eclipse Foundation logo" style="margin:10px 0; width: 100px;"></a>
                    <ul class="ul-no-bullet">
                    <li><a href="https://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
                    <li><a href="https://www.eclipse.org/legal/termsofuse.php">Website terms of use</a></li>
                    <li><a href="https://www.eclipse.org/legal/copyright.php">Copyright</a></li>
                    <li><a href="https://www.eclipse.org/legal">Legal</a></li>
                    </ul>
                  </div>
          </div>
          </div>
    
              </div>
              
              
            </div>
            <hr>
            <div class="text-center">Made with <i class="fas fa-heart" style="color: red;"></i> in Berlin</div>

                <br>
             
          </div>
  </footer>
  
  <script>
 
    window.onscroll = function() {scrollFunction()};
    
    function scrollFunction() {
      if (document.body.scrollTop > 20 || document.documentElement.scrollTop > 20) {
        document.getElementById("goToTop").style.display = "block";
        document.getElementById("navbar-logo").style.maxWidth = "60%";
      } else {
        document.getElementById("goToTop").style.display = "none";
        document.getElementById("navbar-logo").style.maxWidth = "100%";
      }
    }
  
    function goTopFunction() {
      document.body.scrollTop = 0;
      document.documentElement.scrollTop = 0;
    }
  </script>
</body>
</html>