<!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 tool scenario-convert is part of MOSAIC Extended.
However, you can use scenario-convert for free to generate scenarios which are executable with Eclipse MOSAIC. Get it here.
  Download scenario-convert from DCAITI mirror  scenario-convert is a useful tool, which can be used to create new scenarios or import and export data from external sources like OpenStreetMap, SUMO etc into your existing scenarios.">

  
  <link rel="alternate" hreflang="en-us" href="https://www.eclipse.org/mosaic/docs/building_scenarios/scenario_convert/">

  


  
  
  
  <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/docs/building_scenarios/scenario_convert/">

  
  
  
  
  
  
  
    
    
  
  
  <meta property="twitter:card" content="summary">
  
  <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/docs/building_scenarios/scenario_convert/">
  <meta property="og:title" content="Scenario Convert | Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility">
  <meta property="og:description" content="The tool scenario-convert is part of MOSAIC Extended.
However, you can use scenario-convert for free to generate scenarios which are executable with Eclipse MOSAIC. Get it here.
  Download scenario-convert from DCAITI mirror  scenario-convert is a useful tool, which can be used to create new scenarios or import and export data from external sources like OpenStreetMap, SUMO etc into your existing scenarios."><meta property="og:image" content="https://www.eclipse.org/mosaic/images/logo.svg">
  <meta property="twitter:image" content="https://www.eclipse.org/mosaic/images/logo.svg"><meta property="og:locale" content="en-us">
  
    
      <meta property="article:published_time" content="2019-05-05T00:00:00&#43;01:00">
    
    <meta property="article:modified_time" content="2019-05-05T00:00:00&#43;01:00">
  

  



  


  


  





  <title>Scenario Convert | 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-docs page-building_scenarios page-scenario_convert ">

  <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  active" 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  active" 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>


  

<div class="docs container">
  <div class="row flex-xl-nowrap">
    <div class="docs-sidebar col-12 col-md-3 col-xl-3">
      





  
    
  





<div class="docs-version">
  
  
  
  <a class="" data-bs-toggle="tooltip" data-bs-placement="bottom" title="The documentation corresponds to the latest version of Eclipse MOSAIC 20.1-SNAPSHOT." href="https://github.com/eclipse/mosaic">
    <i class="fab fa-github"></i>&nbsp;Eclipse MOSAIC 20.1-SNAPSHOT
  </a>
</div>

<form class="docs-search d-flex align-items-center">
  <button class="btn docs-toggle d-md-none p-0 mr-3" type="button" data-bs-toggle="collapse" data-bs-target="#docs-nav" aria-controls="docs-nav" aria-expanded="false" aria-label="Toggle section navigation">
    <span><i class="fas fa-bars"></i></span>
  </button>

  
  <input name="q" type="search" class="form-control" placeholder="Search..." autocomplete="off">
  
</form>

<nav class="collapse docs-links" id="docs-nav">
  
  
    
    
    
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/getting_started/">Getting Started</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/getting_started/">Download</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/getting_started/run_mosaic/">Run Eclipse MOSAIC</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/getting_started/results/">Simulation Results</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/visualization/">Visualization</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/visualization/">WebSocket Visualizer</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/visualization/filevis/">File Output</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/visualization/statistics/">Statistics Output</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/visualization/itef/">ITEF</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/visualization/phabmap/">PHABMap</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/simulators/">Simulators</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/simulators/">Overview</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/application_simulator/">Application Simulator</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/traffic_simulator_sumo/">Traffic - Eclipse SUMO</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/network_simulator_omnetpp/">Network - OMNeT&#43;&#43;</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/network_simulator_ns3/">Network - ns-3</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/network_simulator_sns/">Network - SNS</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/network_simulator_cell/">Network - Cell</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/environment_simulator/">Environment Simulator</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/battery_simulator/">Battery Simulator</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/simulators/vms_simulator/">VMS Simulator</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/building_scenarios/">Building Scenarios</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/building_scenarios/">Simulation Scenarios</a>
        </li>
        
        <li class="active">
          <a href="/mosaic/docs/building_scenarios/scenario_convert/">Scenario Convert</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/building_scenarios/scenario_configuration/">Additional Scenario Configuration</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/develop_applications/">Create Applications</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/develop_applications/">Basics</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/develop_applications/communication/">V2X Communication</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/develop_applications/event_scheduler/">Event Scheduling</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/develop_applications/road_traffic/">Scenario Database</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/extending_mosaic/">Extending Eclipse MOSAIC</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/extending_mosaic/">Core Concepts</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/extending_mosaic/simulator_coupling/">Simulator Coupling</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/extending_mosaic/interactions/">Interactions</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/extending_mosaic/application_ambassador_details/">Application Ambassador</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/extending_mosaic/sumo_ambassador_details/">Sumo Ambassador</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/extending_mosaic/omnetpp_details/">OMNeT&#43;&#43; Federate</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/extending_mosaic/delay_models/">Delay Models</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/mosaic_configuration/">MOSAIC Configuration</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/">Configuration Files</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/scenario_config/">Scenario Configuration</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/mapping_ambassador_config/">Mapping Configuration</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/environment_config/">Environment Configuration</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/sns_config/">SNS Configuration</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/cell_config/">Cell Basic Configuration</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/cell_network_config/">Cell Network Configuration</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/cell_region_config/">Cell Region Configuration</a>
        </li>
        
        <li >
          <a href="/mosaic/docs/mosaic_configuration/sumo_config/">SUMO Configuration</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="docs-toc-item">
      <a class="docs-toc-link" href="/mosaic/docs/api_docs/">API Documentation</a>
      <ul class="nav docs-sidenav">
        
        <li >
          <a href="/mosaic/docs/api_docs/">Javadoc</a>
        </li>
        
      </ul>
      

    </div>
    
    <div class="nav-bottom">
      <img src="/mosaic/img/logos/mosaic/EclipseMOSAIC-Medallion-RGB-single-navy.svg">
    </div>
  
</nav>

    </div>

    
    <div class="docs-toc d-none d-xl-block col-xl-2">
      <ul class="nav toc-top">
        <li><a href="#" id="back_to_top" class="docs-toc-title">Contents</a></li>
      </ul>

      <nav id="TableOfContents">
  <ul>
    <li><a href="#creating-a-complete-eclipse-mosaic-scenario-from-an-osm-file-with-one-command">Creating a complete Eclipse MOSAIC-scenario from an OSM-file with one command</a></li>
    <li><a href="#importing-routes-to-your-scenario">Importing Routes to your scenario</a>
      <ul>
        <li><a href="#attached-files">Attached Files</a></li>
      </ul>
    </li>
    <li><a href="#reference-documentation-for-scenario-convert">Reference documentation for scenario-convert</a>
      <ul>
        <li><a href="#usage-of-scenario-convert">Usage of scenario-convert</a></li>
        <li><a href="#configuration-files-for-scenario-convert">Configuration-files for scenario-convert</a></li>
        <li><a href="#speed-files">Speed-files</a></li>
      </ul>
    </li>
  </ul>
</nav>

      
    </div>
    

    <style>
      @media (min-width:1140px) {
        .docs-sidebar {
          flex: 0 1 320px;
        }
        .docs-toc {
          flex: 0 1 280px;
        }
        main.docs-content.no-docs-toc {
          padding-bottom: 0 !important;
          max-width: calc(100% - 320px) !important;
          flex: 0 1 calc(100% - 320px);
          width: 100%;
        }
        main.docs-content {
          padding-bottom: 0 !important;
          max-width: calc(100% - 600px) !important;
          flex: 0 1 calc(100% - 600px);
          width: 100%;
        }
      }
      @media (max-width: 770px) {
        main.docs-content {
          max-width: 100% !important;
          width: 100%;
        }
      }
      @media (min-width: 771px) and(max-width: 1139px) {
        main.docs-content.no-docs-toc {
          padding-bottom: 0 !important;
          max-width: calc(100% - 320px) !important;
          width: 100%;
        }
      }
    </style>
    <main class="docs-content col-12 col-md-9 col-xl-auto py-md-3 pl-md-4" role="main">

      <article class="article">

        <div class="docs-article-container">
          <h1>Scenario Convert</h1>

          <div class="article-style">
            <div class="alert alert-extended">
  <span class="extended-icon" style="background-image: url(/mosaic/img/alert-extended.svg)"></span>
  <div>
  <p>The tool <strong>scenario-convert</strong> is part of <strong><a href="/download#overview">MOSAIC Extended</a></strong>.</p>
<p>However, you can use scenario-convert <strong>for free</strong> to generate scenarios which are executable with Eclipse MOSAIC. <strong><a href="https://www.dcaiti.tu-berlin.de/research/simulation/download/">Get it here</a>.</strong></p>
  </div>
</div>
<div style="text-align: center;">


    

<a class="mosaic-btn mosaic-btn-primary" href="https://www.dcaiti.tu-berlin.de/research/simulation/download/" title="Download scenario-convert from DCAITI mirror"><i class="fas fa-download"></i>Download scenario-convert from DCAITI mirror</a>

</div>
<p><strong>scenario-convert</strong> is a useful tool, which can be used to create new scenarios or import and export data from
external sources like OpenStreetMap, SUMO etc into your existing scenarios.<br>
It will create a database, which is the basis for all map-related tasks performed by Eclipse MOSAIC (e.g. navigation,
route calculation&hellip;).<br>
Based on a MOSAIC database, scenario-convert can export the data to SUMO-conform formats.
Furthermore one can choose, whether to use routes generated by <code>scenario-convert</code>, use existing
routes or  build own routes via route generation tools (e.g. DUAROUTER by SUMO).</p>
<p>This chapter intends to highlight the most common workflows for the work with <code>scenario-convert</code>.
We will be using 





  
  

    

    
    

    
    
      
        
          
            
            
            
          
        
      
    

    
  

<a href="/mosaic/docs/building_scenarios/files/steglitz.osm" target="_blank" rel="noopener">
    steglitz.osm
</a>
 OSM-file for most of the
use cases So feel free to follow along with the steps to get a better understanding on how the <code>scenario-convert</code>-script functions.</p>
<div class="alert alert-note">
  <div>
<p><a href="#reference-documentation-for-scenario-convert">Here</a> you can find a complete reference to all options scenario-convert offers.</p>
  </div>
</div>















<figure id="figure-osm-file-of-steglitz">


  <a data-fancybox="" href="../images/osm_uncleaned.png" data-caption="OSM-File of Steglitz">


  <img src="../images/osm_uncleaned.png" alt=""  >
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    OSM-File of Steglitz
  </figcaption>


</figure>

<h2 id="creating-a-complete-eclipse-mosaic-scenario-from-an-osm-file-with-one-command">Creating a complete Eclipse MOSAIC-scenario from an OSM-file with one command</h2>
<p>This is the most straight forward way to create a scenario from your OSM-file.
We will use the option <code>--osm2mosaic</code>, which is a combination of the options <code>--osm2db</code>
and <code>--db2mosaic</code>.<br>
Let&rsquo;s start off by showing you how a complete call could look like:</p>
<pre><code class="language-bash">java -jar scenario-convert.jar --osm2mosaic -i steglitz.osm
</code></pre>
<div class="alert alert-note">
  <div>
<p>In this section we use the scenario name <code>steglitz.<em></code> as synonym for <code>path/to/steglitz.</em></code>.</p>
  </div>
</div>
<p>This achieves a couple of things. First off the script is going to create a SQLite-database,
which is used by Eclipse MOSAIC. Furthermore, a directory will be created, which should look like this:</p>
<pre><code class="language-plaintext">└─ &lt;working-directory&gt;
   └─ steglitz
       ├─ steglitz.osm
       ├─ application
       |  └─ steglitz.db
       ├─ cell
       |  ├─ cell_config.json
       |  ├─ network.json
       |  └─ regions.json
       ├─ environment
       |  └─ environment_config.json
       ├─ mapping
       |  └─ mapping_config.json
       ├─ ns3
       |  ├─ ns3_config.json
       |  └─ ns3_federate_config.xml
       ├─ omnetpp
       |  ├─ omnetpp_config.json
       |  └─ omnetpp.ini      
       ├─ output
       |  └─ output_config.xml
       ├─ sns
       |  └─ sns_config.json
       ├─ sumo
       |  ├─ steglitz.net.xml
       |  └─ steglitz.sumocfg
       └─ scenario_config.json .................. Basic configuration of the simulation scenario
</code></pre>
<p>Let&rsquo;s walk through all these files:</p>
<ol>
<li>First the <code>steglitz.db</code> will be created using the <code>steglitz.osm</code>-file.</li>
<li>The <code>steglitz.db</code> will be used to create <code>steglitz.con.xml</code>, <code>steglitz.edg.xml</code> and <code>steglitz.nod.xml</code>, which are files used by SUMO.</li>
<li>




<a href="https://sumo.dlr.de/wiki/NETCONVERT" target="_blank" rel="noopener">
    SUMO Netconvert
</a>
 is used to create <code>steglitz.net.xml</code>, which is a 




<a href="https://sumo.dlr.de/wiki/Networks/SUMO_Road_Networks" target="_blank" rel="noopener">
    network representation
</a>
 in SUMO.</li>
<li>Now the SUMO-configuration <code>steglitz.sumo.cfg</code> is written.</li>
<li>Afterwards the <code>mapping_config.json</code> and <code>scenario_config.json</code> are created and all files are moved to the right place.
In the <code>scenario_config.json</code> values like the center coordinate will automatically be set using data from the SUMO related files.</li>
</ol>
<p>While this is technically sufficient to start working on your scenario there are a couple of other things
you can do to achieve better results.</p>
<p><strong>Clean the OSM-file using Osmosis</strong><br>
Osmosis will automatically be used to create a new OSM-file with the suffix <code>_cleaned</code>. The created
file will contain much less clutter and usually is better suited for simulation purposes.
Check the images below to see the difference the clean-up process can make.</p>
<pre><code class="language-bash">java -jar scenario-convert.jar --osm2mosaic -i steglitz.osm
</code></pre>
<div class="row">
    <div class="col-6">
        














<figure id="figure-uncleaned-osm-file">


  <a data-fancybox="" href="../images/osm_uncleaned.png" data-caption="Uncleaned OSM-file">


  <img src="../images/osm_uncleaned.png" alt=""  >
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    Uncleaned OSM-file
  </figcaption>


</figure>

    </div>
    <div class="col-6">
        














<figure id="figure-cleaned-osm-file">


  <a data-fancybox="" href="../images/osm_cleaned.png" data-caption="Cleaned OSM-file">


  <img src="../images/osm_cleaned.png" alt=""  >
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    Cleaned OSM-file
  </figcaption>


</figure>

    </div>
</div>
<div class="row">
    <div class="col-6">
        














<figure id="figure-uncleaned-net-file">


  <a data-fancybox="" href="../images/netfile_uncleaned.png" data-caption="Uncleaned Net-file">


  <img src="../images/netfile_uncleaned.png" alt=""  >
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    Uncleaned Net-file
  </figcaption>


</figure>

    </div>
    <div class="col-6">
        














<figure id="figure-cleaned-net-file">


  <a data-fancybox="" href="../images/netfile_cleaned.png" data-caption="Cleaned Net-file">


  <img src="../images/netfile_cleaned.png" alt=""  >
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    Cleaned Net-file
  </figcaption>


</figure>

    </div>
</div>
<p>To avoid &ldquo;cleaning&rdquo; the OSM-file, please use the option &ldquo;skip-osm-filter&rdquo;.</p>
<pre><code class="language-bash">java -jar scenario-convert.jar --osm2mosaic -i steglitz.osm --skip-osm-filter
</code></pre>
<p><strong>Generating Routes</strong><br>
The scenario-convert also offers the option <code>--generate-routes</code>, which will generate
a route-file, given some additional information. For example purposes we will run the
following command:</p>
<pre><code class="language-bash">java -jar scenario-convert.jar --osm2mosaic -i steglitz.osm --generate-routes
--route-begin-latlon 52.4551693,13.3193474 --route-end-latlon 52.4643101,13.3206834 --number-of-routes 3
</code></pre>
<p>This will calculate three routes between the two given coordinates.</p>
<p>Alternatively you can use the following command in order to generate routes with node-id&rsquo;s as start and end point, which can be found in the <code>steglitz.nod.xml</code> file.</p>
<pre><code class="language-bash">java -jar scenario-convert.jar --osm2mosaic -i steglitz.osm -o --generate-routes
--route-begin-node-id 267350668 --route-end-node-id 313139970 --number-of-routes 3
</code></pre>
<p>See 





  
  

<a href="#reference-documentation-for-scenario-convert">
    below
</a>
 for all command line options.</p>
<p><strong>Conlusion</strong><br>
This wraps up one of the main workflows with the scenario-convert-script.
A quick reminder on what we achieved:</p>
<ul>
<li>Cleaned up an OSM-file to only contain relevant data.</li>
<li>Converted that OSM-file to formats that Eclipse MOSAIC/SUMO can handle.</li>
<li>Created the project structure for a scenario.</li>
<li>Calculated routes between two coordinates.</li>
</ul>
<p>With all of this you can now start further developing your scenario. For a more detailed description on the next steps
please have a look 





  
  

    

    
    
      
      
      
      
    

    
    

    
  

<a href="/mosaic/docs/building_scenarios/">
    here (Simulation Scenarios)
</a>
 and






  
  

    

    
    
      
      
      
      
    

    
    

    
  

<a href="/mosaic/docs/develop_applications/">
    here (Application Development)
</a>
.<br>
While this is the &lsquo;happy world&rsquo; workflow it is often necessary to manually adapt routes and
insert them into your scenario. The following workflow
will explain how that is done and you will also get a more detailed overview of the scenario-convert-functions.</p>
<h2 id="importing-routes-to-your-scenario">Importing Routes to your scenario</h2>
<p>As mentioned above your routes won&rsquo;t always be created by the scenario-convert script. We generated some routes
for the steglitz-scenario using SUMO&rsquo;s 




<a href="http://sumo.dlr.de/wiki/DUAROUTER" target="_blank" rel="noopener">
    duarouter
</a>
, which you can find






  
  

    

    
    

    
    
      
        
          
            
            
            
          
        
      
    

    
  

<a href="/mosaic/docs/building_scenarios/files/steglitz.rou.xml" target="_blank" rel="noopener">
    here
</a>
. We&rsquo;ll start with only the <code>steglitz.osm</code> and
<code>steglitz.rou.xml</code> files:</p>
<pre><code class="language-plaintext">└─ &lt;working-directory&gt;
   ├─ steglitz.osm
   └─ steglitz.rou.xml
</code></pre>
<p><strong>Creating the database</strong><br>
We&rsquo;ll start off by solely creating the database and applying OSMOSIS with the following command:</p>
<pre><code class="language-bash">java -jar scenario-convert.jar --osm2db -i steglitz.osm
</code></pre>
<p>The directory should look like this:</p>
<pre><code class="language-plaintext">└─ &lt;working-directory&gt;
   ├─ steglitz.db
   ├─ steglitz.osm
   ├─ steglitz.rou.xml
   └─ steglitz_cleaned.osm
</code></pre>
<p><strong>Importing the route-file</strong></p>
<p>Let&rsquo;s import our routes into the database.<br>
We achieve this by calling:</p>
<pre><code>java -jar scenario-convert.jar --sumo2db -i steglitz.rou.xml -d .\steglitz.db
</code></pre>
<p>Now all new routes are imported into our database. The following image shows a visualization of one of
the created routes.</p>















<figure id="figure-visualization-of-one-of-the-routes">


  <a data-fancybox="" href="../images/steglitz_route.png" data-caption="Visualization of one of the routes">


  <img src="../images/steglitz_route.png" alt=""  >
</a>


  
  
  <figcaption data-pre="Figure " data-post=":" class="numbered">
    Visualization of one of the routes
  </figcaption>


</figure>

<p><strong>Creating the scenario</strong><br>
The final step is to create the scenario from the files we created so far.</p>
<pre><code>java -jar scenario-convert.jar --db2mosaic -d .\steglitz.db
</code></pre>
<p>Instead of copying our SUMO-files this will generate all necessary files and move them into a Eclipse MOSAIC-conform
folder structure:</p>
<pre><code class="language-plaintext">└─ &lt;working-directory&gt;
   ├─ steglitz.osm
   └─ steglitz
      ├─ application
      |  └─ steglitz.db
      ├─ mapping
      |  └─ mapping_config.json
      ├─ sumo
      |  ├─ steglitz.net.xml
      |  └─ steglitz.sumocfg
      └─ scenario_config.json
</code></pre>
<p>As you can see the resulting folder structure looks just like the final output from the first workflow described.</p>
<p><strong>Conclusion</strong><br>
You should now know how you can manually add routes to your scenario and have a deeper understanding of the way that
some of the script parameters work.</p>
<h3 id="attached-files">Attached Files</h3>
<p>A list of all attached files in this chapter:</p>
<ul>
<li>





  
  

    

    
    

    
    
      
        
          
            
            
            
          
        
      
    

    
  

<a href="/mosaic/docs/building_scenarios/files/steglitz.osm" target="_blank" rel="noopener">
    Steglitz OSM-file
</a>
</li>
<li>





  
  

    

    
    

    
    
      
        
          
            
            
            
          
        
      
    

    
  

<a href="/mosaic/docs/building_scenarios/files/steglitz.rou.xml" target="_blank" rel="noopener">
    Steglitz Route-file
</a>
</li>
</ul>
<h2 id="reference-documentation-for-scenario-convert">Reference documentation for scenario-convert</h2>
<h3 id="usage-of-scenario-convert">Usage of scenario-convert</h3>
<p>The following listing shows an overview for the usage of scenario-convert:</p>
<pre><code>usage: scenario-convert [OPERATION] [OPTIONS]

Examples:
1. Import an osm file and write data into database
   &gt; scenario-convert --osm2db -i &lt;OSMFILE&gt; [-d &lt;DATABASE&gt;]
2. Export database content to SUMO-readable files
   &gt; scenario-convert --db2sumo -d &lt;DATABASE&gt; [-s &lt;SUMOPREFIX&gt;]
3. Import a SUMO routefile into a database
   &gt; scenario-convert --sumo2db -d &lt;DATABASE&gt; -i &lt;ROUTEFILE&gt;.rou.xml
4. Combine steps 1 and 2
   &gt; scenario-convert --osm2sumo -d &lt;DATABASE&gt; -i &lt;OSMFILE&gt; [-s &lt;SUMOPREFIX&gt;]
5. Export db content to Shapefile format
   &gt; scenario-convert --db2shp -d &lt;DATABASE&gt;
6. Import an srtm file and write elevation data to nodes of an existing database
   &gt; scenario-convert --srtm2db -i &lt;SRTMFILE&gt; -d &lt;DATABASE&gt;
7. Create a complete MOSAIC scenario from an osm file
   &gt; scenario-convert --osm2mosaic -i &lt;OSMFILE&gt;
8. Create a scenario database from an SUMO net file
   &gt; scenario-convert --sumo2db -i &lt;NETFILE&gt;.net.xml
9. Calculate a route from node 123 to node 456
   &gt; scenario-convert --generate-routes -d &lt;DATABASE&gt; --route-begin-node-id 123 --route-end-node-id 456

The following arguments are available:
 -h,--help                                 Prints this help screen.

 -c,--config-file &lt;PATH&gt;                   Optional, refers to a configuration file which contains all parameters in
                                           JSON format.
    --osm2db                               Converts a OpenStreetMap file to a new scenario database.
    --sumo2db                              Imports a SUMO Network/Routefile. Be aware that you may have to re-export an
                                           imported network.
    --srtm2db                              Imports an SRTM file and writes elevation data to nodes.
    --db2sumo                              Exports the network to SUMO node and edge files.
    --db2shp                               Exports the database into Shapefile format.
    --db2mosaic                            Creates directory structure for a MOSAIC scenario based on the database
                                           contents.
    --osm2sumo                             Combination of osm2db and db2sumo.
    --osm2mosaic                           Combination of osm2db and db2mosaic.
    --update                               Updates the database to the current scheme.

 -d,--database &lt;PATH&gt;                      The path to the database.
                                           For import: File to import to. If not given, a new file is created.
                                           For export: File to load from.
                                           For update operations: file to update.
 -i,--input &lt;PATH&gt;                         Defines an input file to use in an import. File type depends on the import
                                           operation (OSM File/Database file/SUMO net file/SUMO rou file).
 -s,--sumo-prefix &lt;STRING&gt;                 Prefix for the generated sumo files  (uses database name when not defined).
 -f,--force                                Force overwrite of existing files instead of incrementing file names.
 -m,--mapping-file &lt;PATH&gt;                  Uses the given mapping configuration to export existing vehicleTypes and
                                           vehicles data to *.rou.xml.
    --import-lat &lt;DOUBLE&gt;                  Center latitude of imported region to project coordinates.
    --import-lon &lt;DOUBLE&gt;                  Center longitude of imported region to project coordinates.
    --import-zone &lt;STRING&gt;                 UTM zone of location for projecting coords in default format (e.g. 32n).

 -g,--generate-routes                      Generates route(s) from one point to another. The begin and end for the route
                                           must be known (see below options).
    --route-begin-lat &lt;DOUBLE&gt;             Latitude of the starting point, needs --route-begin-lon as well.
    --route-begin-lon &lt;DOUBLE&gt;             Longitude of the starting point, needs --route-begin-lat as well.
    --route-begin-latlon &lt;DOUBLE,DOUBLE&gt;   [latitude],[longitude] of the starting point.
    --route-begin-node-id &lt;STRING&gt;         OSM node id of the starting point (use instead of lat/lon).
    --route-end-lat &lt;DOUBLE&gt;               Latitude of the starting point, needs --route-end-lon as well.
    --route-end-lon &lt;DOUBLE&gt;               Longitude of the starting point, needs --route-end-lat as well.
    --route-end-latlon &lt;DOUBLE,DOUBLE&gt;     [latitude],[longitude] of the ending point.
    --route-end-node-id &lt;STRING&gt;           OSM node id of the ending point (use instead of lat/lon).
    --route-matrix &lt;STRING,STRING,...&gt;     Calculates all possible routes starting and ending at the given nodes, given
                                           as comma-separated list (e.g. 12345,87123,89123)
    --number-of-routes &lt;INTEGER&gt;           Defines the number of alternative routes to be calculated (default=1).

    --skip-osm-filter                      Skips automatic filtering of the OSM file (only with osm2xxx).
    --skip-turn-restrictions               Ignore all defined turn restrictions on OSM import.
    --skip-graph-cleanup                   Turns off the removal of unconnected parts from the main traffic network
                                           graph . Since several components of VSimRTI require one main graph without
                                           disconnected ways and nodes, this option should be used only if the cleanup
                                           procedure is faulty.
    --skip-netconvert                      Skips starting sumo netconvert for creating netfile (only with xxx2sumo).
    --skip-traffic-lights-export           Skips exporting traffic light information for nodes (only with xxx2sumo).
    --osm-speeds-file &lt;PATH&gt;               Define a property file which contains speed information which are used to set
                                           the speed for OSM ways without a max speed tag (only with osm2xxx).
    --osm-speeds-overwrite                 If set to true , the maxspeed tags of ways are ignored and replaced by either
                                           default values , or by speed information defined via the --osm-speeds-file
                                           option (only with osm2xxx).

</code></pre>
<h3 id="configuration-files-for-scenario-convert">Configuration-files for scenario-convert</h3>
<p>Scenario-convert offers a way to safe your conversion-parameters in a <code>JSON</code> configuration file using
the option <code>-c</code> or <code>--config-file</code>.<br>
The following listing shows how to save the options used in the example above:</p>
<pre><code>{
  &#34;operatingMode&#34;: &#34;osm2mosaic&#34;,
  &#34;inputFile&#34;: &#34;steglitz.osm&#34;,
  &#34;executeOsmosis&#34;: true,
  &#34;generateRoutes&#34;: true,
  &#34;routeBeginLatLon&#34;: &#34;52.457616,13.318392&#34;,
  &#34;routeEndLatLon&#34;: &#34;52.454774,13.333554&#34;,
  &#34;numberOfRoutes&#34;: 3
}
</code></pre>
<h3 id="speed-files">Speed-files</h3>
<p>Below you can find a properties file which can be used during the import of OSM data
in order to define speeds for ways, which do not have a maxspeeds-tag defined. For this purpose use the
option <code>--osm-speeds-file &lt;FILE&gt;</code>. In the speed properties file, for each way type a speed value can
be defined, according to the OSM 




<a href="http://wiki.openstreetmap.org/wiki/Key:highway" target="_blank" rel="noopener">
    <code>highway</code>
</a>
 key.</p>
<pre><code># the unit the speed values are defined in [kmh, ms]
speed.unit = kmh

# the default speed for all way types which are not defined here
speed.default = 30
        
# autobahn
highway.motorway = 130
highway.motorway_link = 70

# bundesstrasse (germany)
highway.trunk = 70
highway.trunk_link = 65

# linking bigger town
highway.primary = 65
highway.primary_link = 60

# linking towns &#43; villages
highway.secondary = 60
highway.secondary_link = 50

#streets without middle line separation
highway.tertiary = 50
highway.tertiary_link = 40
highway.residential = 30

#special roads
highway.living_street = 5
highway.service = 20

# unclassified roads
highway.unclassified = 30
highway.road = 20

# forest tracks
highway.track 15
</code></pre>

          </div>

          



          
          <div class="article-widget">
            
<div class="post-nav prev-next-pages col-12">
  <div class="row">
    <div class="post-nav-item col-6">
      
        
          
          
            <div class="meta-nav">Previous</div>
            <a href="/mosaic/docs/building_scenarios/" rel="next">Simulation Scenarios</a>
          
        
      
    </div>

    <div class="post-nav-item col-6 align-self-end">
      
      
        <div class="meta-nav">Next</div>
        <a href="/mosaic/docs/building_scenarios/scenario_configuration/" rel="prev">Additional Scenario Configuration</a>
      
    </div>
  </div>
</div>

          </div>
          
        </div>

        
          

          

          

          
  
  


        


        <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>
    
  </div>
</footer>



      </article>
    </main>
  </div>
</div>


      

    
    
    
      <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 src="https://cdnjs.cloudflare.com/ajax/libs/anchor-js/4.1.1/anchor.min.js" integrity="sha512-aZotBPy6dqn8yVaLJwSrkJ+QxuxV695A4dgodAMvTU5JyNi5mhrr+LeaD3GSS+lx1SMFKNs0tu5ZMJEgNZQP2Q==" crossorigin="anonymous"></script>
    <script>
      anchors.add();
    </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 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>
