<!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 built-in Eclipse MOSAIC Cell Simulator enables the applications to use cellular network communication. The simulation of cellular communication in Eclipse MOSAIC consists of two parts:
 The Cellular Simulator itself and The applications that can communicate over cellular networks in the Application Simulator  These changes are done in a generic way, making the cellular simulator exchangeable.">

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

  


  
  
  
  <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/simulators/network_simulator_cell/">

  
  
  
  
  
  
  
    
    
  
  
  <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/simulators/network_simulator_cell/">
  <meta property="og:title" content="Network Simulator Cell | Eclipse MOSAIC – A Multi-Domain and Multi-Scale Simulation Framework for Connected and Automated Mobility">
  <meta property="og:description" content="The built-in Eclipse MOSAIC Cell Simulator enables the applications to use cellular network communication. The simulation of cellular communication in Eclipse MOSAIC consists of two parts:
 The Cellular Simulator itself and The applications that can communicate over cellular networks in the Application Simulator  These changes are done in a generic way, making the cellular simulator exchangeable."><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>Network Simulator Cell | 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-simulators page-network_simulator_cell ">

  <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 21.1-SNAPSHOT." href="https://github.com/eclipse/mosaic">
    <i class="fab fa-github"></i>&nbsp;Eclipse MOSAIC 21.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/application_mapping/">Application - Mapping</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 class="active">
          <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 >
          <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/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/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/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>
      <ul>
        <li><a href="#cellambassador-folder-structure">CellAmbassador folder structure</a></li>
        <li><a href="#installation">Installation</a></li>
        <li><a href="#configuration">Configuration</a></li>
        <li><a href="#server-configuration">Server configuration</a></li>
        <li><a href="#delay-regions">Delay regions</a></li>
        <li><a href="#transmission-simulation">Transmission simulation</a></li>
        <li><a href="#operation">Operation</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>Network Simulator Cell</h1>

          <div class="article-style">
            <p>The built-in Eclipse MOSAIC Cell Simulator enables the applications to use cellular network communication.
The simulation of cellular communication in Eclipse MOSAIC consists of two parts:</p>
<ol>
<li>The Cellular Simulator itself and</li>
<li>The applications that can communicate over cellular networks in the Application Simulator</li>
</ol>
<p>These changes are done in a generic way, making the cellular simulator exchangeable. Users interested
in a different kind of simulation of cellular communication may use other simulators and develop
ambassadors connecting them to Eclipse MOSAIC.</p>
<p>The Cellular Simulator in the current state consists of three main modules:</p>
<ol>
<li>UplinkModule</li>
<li>GeocasterModule</li>
<li>DownlinkModule</li>
</ol>
<p>The Geocaster module simulates a mandatory component for ITS communication. It is inspired by
the several architectures from research projects as simTD or CONVERGE to enable ITS use cases over
cellular networks. It mainly takes over the task of an addressing and routing component with geographic
knowledge to support geo-addressing. However, it also supports regular topological addressing.
The Uplink and DownlinkModule are responsible for the transmission simulation. They account for the
aspects of transmission delays, packet losses and available data rates. In this context,Uplink and Downlink
always refer to the direction towards respectively from the Geocaster. For instance, a transmission
from an Internet-based server towards a vehicle would include an Uplink between the server and the
Geocaster and a Downlink between the Geocaster and the vehicle. While the Uplink direction only allows
point-to-point communication (Unicast), the Downlink supports point-to-point (Unicast) as well as
point-to-multipoint (Multicast).</p>
<h3 id="cellambassador-folder-structure">CellAmbassador folder structure</h3>
<p>The Eclipse MOSAIC Cell simulator can be configured via three distinct configuration files, which can be
found within the scenarios' folder structure:</p>
<pre><code class="language-plaintext">└─ &lt;scenario_name&gt;
   └─ cell
      ├─ cell_config.json ................. Cell ambassador configuration file
      ├─ network.json ..................... Network configuration file
      └─ regions.json ..................... Regions configuration file
</code></pre>
<p>The network and regions configuration files are referenced in the cellular ambassador configuration
file.</p>
<div class="alert alert-tip">
  <div>
<p>Read the detailed documentation of the 





  
  

    

    
    
      
      
      
      
    

    
    

    
  

<a href="/mosaic/docs/mosaic_configuration/cell_network_config/">
    Network
</a>
 and 





  
  

    

    
    
      
      
      
      
    

    
    

    
  

<a href="/mosaic/docs/mosaic_configuration/cell_region_config/">
    Regions Configuration
</a>
.</p>
  </div>
</div>
<h3 id="installation">Installation</h3>
<p>This simulator does not need to be installed. It is delivered as part of the Eclipse MOSAIC-installation package.</p>
<h3 id="configuration">Configuration</h3>
<p>We provide a cellular configuration file in the example scenarios of Tiergarten and Barnim. Please note
that in the default configuration of this scenario the Cellular Simulator is deactivated. To activate the
cellular simulator just enable the <code>cell</code> federate in the <code>scenario_config.json</code>:</p>
<pre><code class="language-json">&quot;federates&quot;: {
    ...
    &quot;cell&quot;: true,
    ...
}
</code></pre>
<p>The central configuration for the cellular simulator in the file
<code>&lt;scenarioName&gt;/cell/cell_config.json</code> could look like this:</p>
<pre><code class="language-Json">{
    &quot;debugGeocasting&quot;: false,
    &quot;visualizeRegions&quot;: true,
    &quot;networkConfigurationFile&quot;: &quot;network.json &quot;,
    &quot;regionConfigurationFile&quot;: &quot;regions.json &quot;
}
</code></pre>
<p>The <code>visualizeRegions</code> option from the <code>cell_config.json</code> is used to write a KML-file that visualizes the
used cell regions. Google Earth can be used to display it.</p>
<div class="alert alert-tip">
  <div>
<p>Read the detailed documentations of:</p>
<ul>
<li>
<p>





  
  

    

    
    
      
      
      
      
    

    
    

    
  

<a href="/mosaic/docs/mosaic_configuration/cell_network_config/">
    Cell Network Configuration
</a>
</p>
</li>
<li>
<p>





  
  

    

    
    
      
      
      
      
    

    
    

    
  

<a href="/mosaic/docs/mosaic_configuration/cell_region_config/">
    Cell Region Configuration
</a>
</p>
</div>
</li>
</ul>
</div>
<p>The configuration for the global network in the cellular simulator in the file
<code>&lt;scenarioName&gt;/cell/network.json</code> could look like this:</p>
<pre><code class="language-json">{
    &quot;globalNetwork&quot;: {
        &quot;uplink&quot;: {
            &quot;delay&quot;: {
                &quot;type&quot;: &quot;ConstantDelay&quot;,
                &quot;delay&quot;: &quot;100 ms&quot;
            },
            &quot;transmission&quot;: {
                &quot;lossProbability&quot;: 0.0,
                &quot;maxRetries&quot;: 2
            },
            &quot;capacity&quot;: 28000000
        },
        &quot;downlink&quot;: {
            &quot;unicast&quot;: {
                &quot;delay&quot;: {
                    &quot;type&quot;: &quot;ConstantDelay&quot;,
                    &quot;delay&quot;: &quot;50 ms&quot;
                },
                &quot;transmission&quot;: {
                    &quot;lossProbability&quot;: 0.0,
                    &quot;maxRetries&quot;: 2
                }
            },
            &quot;multicast&quot;: {
                &quot;delay&quot;: {
                    &quot;type&quot;: &quot;ConstantDelay&quot;,
                    &quot;delay&quot;: &quot;100 ms&quot;
                },
                &quot;transmission&quot;: {
                    &quot;lossProbability&quot;: 0.0
                },
                &quot;usableCapacity&quot;: 0.6
            },
            &quot;capacity&quot;: 42200000
        }
    }
}
</code></pre>
<p>The <code>network.json</code> also allows setting the fields <code>defaultDownlinkCapacity</code> and <code>defaultUplinkCapacity</code>,
which are used if you don&rsquo;t specify any bitrates in your <code>CellConfiguration</code>s inside your applications.
These values are set to 100 Gigabit by default, so if you aren&rsquo;t interested in capacity/bandwidth observations you can
probably just leave them as is.</p>
<h3 id="server-configuration">Server configuration</h3>
<p>MOSAIC supports a type of simulation units, called servers. Traffic Management Centers are a specialised type of server.
What differentiates servers from other units is, that
they are treated as having no geographical location and instead are located &ldquo;inside the internet.&rdquo;. This concept omits prior shortcoming,
where one would have to configure RSU&rsquo;s as servers.<br>
Servers are also configured in the <code>network.json</code> as follows:</p>
<pre><code class="language-json">{
    &quot;defaultDownlinkCapacity&quot;: &quot;10 Gbps&quot;,
    &quot;defaultUplinkCapacity&quot;: &quot;10 Gbps&quot;,
    &quot;globalNetwork&quot;: {
           [...]
    },
    &quot;servers&quot;: {
        {
            &quot;id&quot;: &quot;TestServer&quot;,
            &quot;uplink&quot;: {
                &quot;delay&quot;: {
                    &quot;type&quot;: &quot;ConstantDelay&quot;,
                    &quot;delay&quot;: &quot;200 ms&quot;
                },
                &quot;transmission&quot;: {
                    &quot;lossProbability&quot;: 0.5,
                    &quot;maxRetries&quot;: 2
                }
            },
            &quot;downlink&quot;: {
                &quot;unicast&quot;: {
                    &quot;delay&quot;: {
                        &quot;type&quot;: &quot;SimpleRandomDelay&quot;,
                        &quot;steps&quot;: 5,
                        &quot;minDelay&quot;: &quot;100 ms&quot;,
                        &quot;maxDelay&quot;: &quot;200 ms&quot;
                    },
                    &quot;transmission&quot;: {
                        &quot;lossProbability&quot;: 0.1,
                        &quot;maxRetries&quot;: 2
                    }
                }
            }
        },
        {
            [...]
        }
    }
}
</code></pre>
<blockquote>
<p>Note: The fields <code>defaultDownlinkCapacity</code>, <code>defaultUplinkCapacity</code> are used if you don&rsquo;t define any bitrates for your cell configurations
their default values are 100 Gigabit, so you usually don&rsquo;t need to set them.</p>
</blockquote>
<p>Servers get their configuration for the delay and retransmission models from the <code>network.json</code> and the configuration for the
capacity-model has to be made from within an application, by activating the <code>CellModule</code> and properly setting the bit rates.
This could look as follows:</p>
<pre><code class="language-java">        getOs().getCellModule().enable(
                new CellModuleConfiguration()
                        .maxUlBitrate(10000)
                        .maxDlBitrate(10000)
        );

        // Alternatively using default values from network.json
        getOs().getCellModule().enable();
</code></pre>
<p>For the CellAmbassador to be able to recognize servers, the <code>group</code>-field in the mapping must match the <code>id</code>-field in the <code>network.json</code>,
this also allows for multiple servers to utilize the same configuration. A <code>mapping_config.json</code> using the configuration from
above could look as follows:</p>
<pre><code class="language-json">{
    ...,
    &quot;tmcs&quot;: [
        {
            &quot;group&quot;: &quot;TestServer&quot;,
            &quot;applications&quot;: [ &quot;TestApplication&quot; ],
            &quot;inductionLoops&quot;: [ ],
            &quot;laneAreaDetectors&quot;: [ ]
        }
    ],    
    &quot;servers&quot;: [
        {
            &quot;group&quot;: &quot;TestServer&quot;,
            &quot;applications&quot;: [ &quot;TestApplication&quot; ]
        }
    ],
    ...
}
</code></pre>
<blockquote>
<p>Note that all bandwidths are given in bit per second and all delays in nanoseconds, unless explicitly defined differently.
Also, every json configuration goes through a minifier, so comments are allowed in the configuration files. An example
would be the comment before the <code>globalNetwork</code> option.</p>
</blockquote>
<h3 id="delay-regions">Delay regions</h3>
<p>Additionally, the user has the option to define regions with individual delays. This can be used to simulate
areas with bad reception, crowded areas etc.</p>
<p>The regions should be stored in <code>&lt;scenarioName&gt;/cell/regions.json</code>. An
example definition for a single region called <code>Ernst-Reuter-Platz</code> could look like this:</p>
<pre><code class="language-Json">{
    &quot;regions&quot;:[
        {
            &quot;id&quot;: &quot;Ernst-Reuter-Platz&quot;,
            &quot;area&quot;: {
                &quot;nw&quot;: { &quot;lon&quot;:13.3249, &quot;lat&quot;:52.5131 },
                &quot;se&quot;: { &quot;lon&quot;:13.3273, &quot;lat&quot;:52.5125 }
            },
            &quot;uplink&quot;: {
                &quot;delay&quot;: {
                    &quot;type&quot;:         &quot;SimpleRandomDelay&quot;,
                    &quot;steps&quot;:        4,
                    &quot;minDelay&quot;:     &quot;50 ms&quot;,
                    &quot;maxDelay&quot;:     &quot;200 ms&quot;
                },
                 &quot;transmission&quot;: {
                     &quot;lossProbability&quot;: 0.8,
                     &quot;maxRetries&quot;: 2
                },
                &quot;capacity&quot;:         28000000
            },
            &quot;downlink&quot;: {
                &quot;unicast&quot;: {
                    &quot;delay&quot;: {
                        &quot;type&quot;:         &quot;SimpleRandomDelay&quot;,
                        &quot;steps&quot;:        3,
                        &quot;minDelay&quot;:     &quot;100 ms&quot;,
                        &quot;maxDelay&quot;:     &quot;200 ms&quot;
                    },
                    &quot;transmission&quot;: {
                        &quot;maxRetries&quot;: 2
                    }
                },
                &quot;multicast&quot;: {
                    &quot;delay&quot;: {
                        &quot;type&quot;:         &quot;SimpleRandomDelay&quot;,
                        &quot;steps&quot;:        3,
                        &quot;minDelay&quot;:     &quot;120 ms&quot;,
                        &quot;maxDelay&quot;:     &quot;220 ms&quot;
                    },
                    &quot;transmission&quot;: {
                        &quot;lossProbability&quot;: 0.8
                    },
                    &quot;usableCapacity&quot;:   0.6
                },
                &quot;capacity&quot;:             42200000
            }
        }
    ]
}
</code></pre>
<p>Note that <code>nw</code> represents the upper-left (north-west) point of the rectangle and <code>se</code> the lower-right (southeast).
For further information about the possible options, please refer to the Eclipse MOSAIC API documentation.</p>
<p>The actual configuration of the uplink and the downlink modules for each region exhibits the identical
format as configuration of the globalNetwork in the <code>network.json</code>.</p>
<p>When no regions are found, or if a node (a vehicle) is not within a specified region, the globalNetwork
defined in the <code>network.json</code>-File will be used as the delay model.</p>
<h3 id="transmission-simulation">Transmission simulation</h3>
<p>One of the most important feature of the cellular simulator is an estimation of the delay experienced
through the transport over the cellular network.</p>
<p>The cellular simulator offers various modes to estimate the delay of the transmissions. The type of
estimation is specified with by <code>delayType</code> for the uplink and downlink for each region. You may also refer to the






  
  

    

    
    
      
      
      
      
    

    
    

    
  

<a href="/mosaic/docs/extending_mosaic/delay_models/">
    Delay-Chapter
</a>
.</p>
<ul>
<li><code>delay.type = ’ConstantDelay’</code>: The message is transmitted with the latency being exactly equal to delay.</li>
<li><code>delay.type = ’SimpleRandomDelay’</code>: The latency can assume different (randomly generated and uniformly distributed) values between
<code>minDelay</code> and <code>maxDelay</code>. The number of different values is determined by <code>steps</code>.</li>
<li><code>delay.type = ’GammaRandomDelay’</code>: A gamma distribution is used to estimate the latency, with $ \alpha $ = 2 and  $ \beta $= 2. The
minimal delay <code>minDelay</code> is added to the result. The curve is fitted so that the maximum likelihood for the delay is exactly equal to
<code>expDelay</code>.</li>
<li><code>delay.type = ’GammaSpeedDelay’</code>: This mode closely resembles the GammaRandomDelay. Additionally, a penalty for the velocity with which
the node is moving is calculated. This penalty is then added to the original delay. The GammaRandomDelay and the GammaSpeedDelay are
derived from a measurement campaign during a research project at the DCAITI.</li>
</ul>
<p>The two different modes for the downlink are <code>unicast</code> and <code>multicast</code> which are configured separately. Multicast aims to simulate the
features of Multimedia Broadcast Multicast Service (MBMS). The main difference in terms of the transmission for unicast and multicast
is the handling of undeliverable messages. For unicast, the options <code>lossProbability</code> and <code>maxRetries</code> are used. Pr is short for
packet retransmit and denotes the probability for a failed delivery and a subsequent retransmit. The maximum number of retries
for the retransmission is configured through the <code>maxRetries</code>-option. The probability of a successful
retransmit is recalculated on every try.</p>
<p>In case of multicast the <code>lossProbability</code> is used as packet loss rate. The value is factored into the delay calculation.
In contrast to the unicast, just one transmission attempt is made for multicast.</p>
<h3 id="operation">Operation</h3>
<p>Beside the transmission simulation, the Addressing and Routing is the other important aspect of the Cellular Simulator. This task is enabled
by the Geocaster.</p>
<p>The Geocaster evaluates the message headers for cellular messages, which are created by the communicating applications in the
Application Simulator.</p>
<p>It supports the following addressing and casting schemes.</p>
<p><strong><code>[CellTopocast](/docs/develop_applications/communication#cellular-topocast)</code></strong> is the normal unicast, where the Geocaster simply resolves
the single receiver via theIPResolver. Hence, the CellTopocast directly routes the message further. Currently, Topocast doesn&rsquo;t allow
broadcast or anycast addresses, but any transmission protocols (tcp, udp).</p>
<p><strong><code>[CellGeoUnicast](/docs/develop_applications/communication#cellular-geocast)</code></strong> addresses every node in the destination area individually.
In this way it takes a geographic address and results in a loop to generate multiple unicasts.</p>
<p><strong><code>[CellGeoBroadcast](/docs/develop_applications/communication#cellular-geobroadcast)</code></strong>, which is basically MBMS, uses one broadcast to all
nodes in the destined regions.The MBMS uses the different transmission mode of multicast in the downlink. CellGeoUnicast as well as
CellGeoBroadcast require broadcast, but don’t allow tcp (as ack for broadcasts is denied).</p>

          </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/simulators/network_simulator_sns/" rel="next">Simple Network Simulator (SNS)</a>
      
    </div>

    <div class="post-nav-item col-6 align-self-end">
      
      
        <div class="meta-nav">Next</div>
        <a href="/mosaic/docs/simulators/environment_simulator/" rel="prev">Environment Simulator</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>
