<!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="List of publications and thesis related to Eclipse MOSAIC.">

  
  <link rel="alternate" hreflang="en-us" href="https://staging.eclipse.org/mosaic/contribution/">

  


  
  
  
  <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://staging.eclipse.org/mosaic/contribution/">

  
  
  
  
  
  
  
    
    
  
  
  <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://staging.eclipse.org/mosaic/contribution/">
  <meta property="og:title" content="Contribution to Eclipse MOSAIC | Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility">
  <meta property="og:description" content="List of publications and thesis related to Eclipse MOSAIC."><meta property="og:image" content="https://staging.eclipse.org/mosaic/images/logo.svg">
  <meta property="twitter:image" content="https://staging.eclipse.org/mosaic/images/logo.svg"><meta property="og:locale" content="en-us">
  
    
      <meta property="article:published_time" content="2019-01-01T00:00:00&#43;00:00">
    
    <meta property="article:modified_time" content="2019-01-01T00:00:00&#43;00:00">
  

  



  


  


  





  <title>Contribution to Eclipse 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="#navbar-main" class=" page-mosaic page-contribution ">

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


  
<span class="js-widget-page d-none"></span>





  
  
  
  




  
  
  

  

  

  
  

  
  
  

  
  
  
  
  

  
  

  

  

  <section id="page_header" class="home-section wg-page-header   bg-image parallax "  >
  
    
    
      
      
    
    
    
    
      
    
    <div class="page-header-background" style="background-image: url(https://staging.eclipse.org/mosaic/img/background-home-02.jpg);opacity: 0.3;"></div>
  
    <div class="container">
      




<div class="page-header row">
  
    <div class="col-12 alignment-center">
      <div class="row justify-content-center">
        
        
        <div class="section-heading col-12 col-md-5 mb-4 text-center">
          
          <h1>How to Contribute</h1>
          
          <p>We are waiting for your contributions. First read the following few lines, then fork our repository on GitHub and get started.</p>
        </div>
        

        

        
        <div class="buttons col-12 mb-4">
          <div class="row justify-content-center">
            
              
                <div class="button mb-2">
                  <a class="mosaic-btn mosaic-btn-light" href="https://github.com/eclipse/mosaic" title="&lt;i class=&#34;fab fa-github&#34;&gt;&lt;/i&gt; Eclipse MOSAIC @ GitHub">
                    
                    <i class="fab fa-github"></i> Eclipse MOSAIC @ GitHub
                    
                  </a>
                </div>
              
            
          </div>
        </div>
        
      </div>
    </div>
  

  

</div>


  <hr class="vertical-span" />


    </div>
  </section>

  
  
  

  

  

  
  

  
  
  

  
  
  
  
  

  
  

  
    

    
  

  

  <section id="contribution" class="home-section wg-text-image   "  >
  
    <div class="container">
      



  <div class="row text-image">
    
    

    
    
    <div class="col-md-12">
      <h2 id="issues">Issues</h2>
<p>You are more than welcomed to report bugs or suggest enhancements on our 




<a href="https://github.com/eclipse/mosaic" target="_blank" rel="noopener">
    GitHub repository
</a>
.
Before creating a new issue, please check if the problem or feature was not reported already by someone else.</p>
<p>When reporting bugs, please follow the guidelines
proposed by 




<a href="https://bugs.eclipse.org/bugs/page.cgi?id=bug-writing.html" target="_blank" rel="noopener">
    Eclipse
</a>
:</p>
<ul>
<li>Be precise</li>
<li>Be clear - explain it so others can reproduce the bug</li>
<li>One bug per report</li>
<li>No bug is too trivial to report - small bugs may hide big bugs</li>
<li>Clearly separate fact from speculation</li>
</ul>
<p>If you want to suggest a new feature or enhancement, please provide as many details as possible:</p>
<ul>
<li>What exact enhancement do you think of  what&rsquo;s the purpose of it?</li>
<li>Why do you need this feature?</li>
<li>Do you already have ideas about how this could be implemented?</li>
</ul>
<h2 id="prerequisites">Prerequisites</h2>
<p>Eclipse MOSAIC is an Eclipse Project and therefore requires all committers to follow the Eclipse Development process. Each contributor
is obligated to execute the following steps in order to us to be able to accept her or his contributions:</p>
<ul>
<li>Create a user account for the Eclipse Foundation. If you don&rsquo;t already have such an account, please register





<a href="https://dev.eclipse.org/site_login/createaccount.php" target="_blank" rel="noopener">
    on the Eclipse web site
</a>
.</li>
<li>Sign the 




<a href="https://www.eclipse.org/legal/CLA.php" target="_blank" rel="noopener">
    Contributor License Agreement
</a>
 (see <code>My Account/Contributor License Aggreement</code> tab in your profile.)</li>
<li>Add your GitHub username to your Eclipse Foundation profile.</li>
</ul>
<h2 id="contribute">Contribute</h2>
<p>Please first discuss the change you wish to make via issue or email with us as the owners of this repository.
To share contributions with us,  create a GitHub pull request following the steps below. All your commits
have to be <em>Signed-off</em> (<code>-s</code>) using the email address used for your Eclipse account.
More details can be found 




<a href="https://wiki.eclipse.org/Development_Resources/Contributing_via_Git" target="_blank" rel="noopener">
    here
</a>
.</p>
<pre><code>git commit -s -m &quot;This is a message&quot;  
</code></pre>
<p>Make your changes by following those steps:</p>
<ul>
<li>Create a fork of this repository on GitHub</li>
<li>Create a new branch</li>
<li>Make your changes</li>
<li>Add new tests for new functionality and extend tests before refactoring code.</li>
<li>Check your contribution carefully (see Definition of Done below):
<ul>
<li>All unit tests must pass with your changes (<code>mvn clean install</code> must succeed).</li>
<li>No additional spotbugs warnings must be found.</li>
<li>The code format should follow our Codestyle (see below).</li>
<li>Check for any missing license headers.</li>
</ul>
</li>
<li>Commit your changes into your branch:
<ul>
<li><strong>Use meaningful commit messages</strong>.</li>
<li>Ideally there&rsquo;s only one single commit per contribution. If you have more than one, squash them into a single commit.</li>
<li>Make sure the <code>-s</code> flag is used when committing (see above).</li>
</ul>
</li>
<li>Push your changes to your branch.</li>
<li>Create a pull request with a meaningful description of your changes.</li>
</ul>
<h2 id="definition-of-done">Definition of Done</h2>
<ul>
<li>The code is well documented.</li>
<li>Existing documentation has been updated.</li>
<li>Your solution observes our coding and testing guidelines (see below).</li>
<li>New functionality of your solution is covered by either unit or integration tests - The code coverage must not decrease!</li>
<li>SpotBugs does not report any new warnings.</li>
<li>There are no new <code>FIXME</code>/<code>TODO</code> in your code.</li>
<li>New files contain a valid license header.</li>
<li>The main branch of this repository has been merged into your fork.</li>
<li>Everything&rsquo;s Green! - All related builds and integration tests on Jenkins are successful.</li>
</ul>
<h2 id="coding-conventions">Coding Conventions</h2>
<p>We understand that each developer has different preferences in regard to code formatting, especially when it comes to indentation and braces.
However, the look of our codebase needs to be consistent and therefore the following conventions must be followed.</p>
<h3 id="code-style">Code Style</h3>
<p>Eclipse MOSAIC follows the 




<a href="https://github.com/google/styleguide" target="_blank" rel="noopener">
    Google Java Style Guide
</a>
. Please stick to those conventions to
get your contribution accepted.</p>
<ul>
<li>No tab characters, 4-space indentation!</li>
<li>One statement per line</li>
<li>Column limit of 140 characters per line. The shorter the better.</li>
<li>Braces follow Kernighan and Ritchie Style:
<ul>
<li>No line break before the opening brace.</li>
<li>Line break after the opening brace.</li>
<li>Line break before the closing brace.</li>
<li>Line break after the closing brace. (exception: else after if, catch after try)</li>
</ul>
</li>
<li>Horizontal whitespaces
<ul>
<li>Separate any reserved word (e.g. if, for, catch) from an open parenthesis</li>
<li>Separate any reserved word (e.g. else, catch) from a closing curly brace</li>
<li>Before any curly brace (except array definitions): <code>for (int i=0; i&lt;10; i++) {</code></li>
<li>After the closing parenthesis of a cast, e.g. <code>Target target = ((Target) object);</code></li>
<li>On both sides of any binary or ternary operator, e.g. <code>a == 1 &amp;&amp; b == 3</code></li>
</ul>
</li>
<li>Methods should be as short as possible. Classes should focus on one thing only.</li>
<li>UTF-8 file encoding</li>
<li>No asterisk sign for imports</li>
<li>Grouping and ordering of imports (blank line between groups):
<ul>
<li>Imports from <code>org.eclipse.mosaic</code></li>
<li>Imports from third-party-libraries</li>
<li>Standard libraries</li>
</ul>
</li>
</ul>
<p>The Code style can be checked using a <em>Checkstyle</em> plugin in your IDE. A <code>checkstyle.xml</code> file can be found in the root of the repository.</p>
<h3 id="naming-conventions">Naming conventions</h3>
<table>
<thead>
<tr>
<th>Element</th>
<th>Casing</th>
<th>Example</th>
</tr>
</thead>
<tbody>
<tr>
<td>Class</td>
<td>UpperCamelCase</td>
<td>AppDomain</td>
</tr>
<tr>
<td>Interface</td>
<td>UpperCamelCase</td>
<td>IBusinessService</td>
</tr>
<tr>
<td>Enumeration type</td>
<td>UpperCamelCase</td>
<td>ErrorLevel</td>
</tr>
<tr>
<td>Enumeration values</td>
<td>UPPER_CASE</td>
<td>FATAL</td>
</tr>
<tr>
<td>Field</td>
<td>lowerCamelCase</td>
<td>mainPanel</td>
</tr>
<tr>
<td>Final field</td>
<td>lowerCamelCase</td>
<td>maximumItems</td>
</tr>
<tr>
<td>Read-only static field</td>
<td>UPPER_CASE</td>
<td>RED_VALUE</td>
</tr>
<tr>
<td>Variable</td>
<td>lowerCamelCase</td>
<td>listOfValues</td>
</tr>
<tr>
<td>Method</td>
<td>lowerCamelCase</td>
<td>toString</td>
</tr>
<tr>
<td>Package</td>
<td>lowercase</td>
<td>org.eclipse</td>
</tr>
<tr>
<td>Parameter</td>
<td>lowerCamelCase</td>
<td>typeName</td>
</tr>
<tr>
<td>Type Parameter</td>
<td>UPPER_CASE</td>
<td>T</td>
</tr>
</tbody>
</table>
<ul>
<li>All names should reflect the purpose of the class, method, or field.</li>
<li>Class names should be nouns.</li>
<li>Interfaces should be adjectives (e.g. Clonable, Moveable) or nouns if they resemble a family of classes
(e.g. <code>Map</code>, <code>Vehicle</code>). Interfaces should <em>not</em> start with an <code>I</code> prefix (e.g. <code>IVehicle</code>).</li>
<li>Abbreviations should be avoided, unless they&rsquo;re very common (e.g. IP, V2X, DENM, etc). When written, only the first letter is
in upper case, e.g. <code>V2xMessage</code>, <code>DenmContent</code> <code>getIpAddress</code>.</li>
<li>Methods returning a boolean preferably start with <code>is</code> or <code>has</code>.</li>
</ul>
<h3 id="commenting">Commenting</h3>
<ul>
<li>Add license header at the top of each source file (see below).</li>
<li>Use <code>//</code> in code for inline comments. Describe <em>why</em>, not <em>what</em>&rsquo;s happening.</li>
<li>Use standard javadoc (<code>/** ... */</code>) and its annotations (<code>@param</code>, <code>@return</code>) for all <em>public</em> classes, constructors,
and methods. Simple self-explaining methods, like Getters and Setters do not require a method comment.</li>
</ul>
<h2 id="license-header">License header</h2>
<p>Each Java file must include the following license header at the top of each file:</p>
<pre><code class="language-java">/*
 * Copyright (c) 2020 Fraunhofer FOKUS and others. All rights reserved.
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contact: mosaic@fokus.fraunhofer.de
 */
</code></pre>
<p>If this is your first contribution, please also add your Copyright information to 




<a href="https://github.com/eclipse/mosaic/blob/main/NOTICE.md" target="_blank" rel="noopener">
    NOTICE.md
</a>
.</p>

    </div>
    
    <div class="buttons row col-md-12 justify-content-center">
      
    </div>
  </div>


    </div>
  </section>



      

    
    
    
      <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 type="application/javascript" src="/mosaic/js/mosaic-docs.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>
