Exascale-ready simulation technology: NEST, Arbor and TVB

The focus of this key result is the improvement of simulation software and work to ensure their readiness for current and future HPC systems. We have considerably advanced the capabilities of the NEST simulator with releases 2.18.0 and 2.20.0 and are very close to releasing NEST 3.0 with a much more expressive and efficient interface for network construction.

During the second phase of SGA2 we further worked towards reproducibility and standardisation. The development and refinement of domain-specific languages such as NESTML (to support the automatic code generation of neuron and synaptic models at point neuron scale) and NeuroML (to support automatic code generation of neural mass models targeting multiple backends such as CUDA and numba) help neuroscientists use simulation engines in an easier and more efficient way, while preserving the flexibility required to allow new models to be incorporated by end users.

Progress concerning TVB-HPC was the release of a first version, including parameter-fitting framework and automatic code generation of simulation kernels. This result connects neural mass modelling with high performance computing in order to allow highly efficient parameter fitting.

For Arbor, the simulation software for large networks of multi-compartment cells on HPC systems, written as a C++ library with a Python front end. Work over the last year has focused on the Arbor core C++ library and its Python wrapper, to release the first full-featured and user-accessible version of Arbor.

Moreover, the NEST user experience and sustainability has improved strongly. Based on a workshop on documentation approaches early in SGA2, NEST documentation has been re-worked technically (now available on readthedocs.io: https://nest-simulator.readthedocs.io/en/stable/) and revised for completeness, correctness and consistency. At the same time, the NEST community has been further strengthened with very successful NEST conferences in 2018 and 2019 and regular NEST hackathons bringing developers and in some cases users together for focused development sprints. Outside the conference and hackathons, NEST developers meet every other Monday for an Open Developer Video Conference to discuss current topics in development and review open pull requests, issues and mailing list requests.

Between 25 and 40 developers have contributed code, documentation or examples to recent NEST releases. Systematic code review, continuous integration testing and refactoring maintain and improve NEST code quality ensuring long-term sustainability.


In the second year of SGA2, NEST 2.18.0 (M15) and NEST 2.20.0 (M22) were released (C209). At the same time, online documentation for NEST has been strongly improved, both in technical delivery (now on readthedocs.io3), consistency and quality. NEST now incorporates the infrastructure for the representation of third factor plasticity rules. As an example, the Clopath plasticity rule was released with NEST 2.18.0. In addition, a pull request against NEST has been made for the compartmentalised third factor plasticity rule by Urbanczik and Senn (C2696). The prototype implementation of a vastly improved, unified user interface and back end for connectivity generation (C2678) was integrated into the NEST master branch early in M23 and is thus available for public testing; at this time, it is planned to release this work as part of NEST 3.0 towards the end of Q1/2020.

A new NESTML version has been released (C2679), which improves the development workflow and usability for the end user and enhances the automated processing of differential equations.

Functional validation of neuron model correctness has been implemented, as an important step towards improving the NEST Simulator code base maintainability in the coming years.

The specification of synapse models has been enhanced to cover advanced plasticity rules including spike-timing dependent plasticity (STDP).

Component Content URL
C209 Software Repository https://github.com/nest/nest-simulator
Technical Documentation https://nest-simulator.readthedocs.io/en/stable/
User Documentation https://www.nest-simulator.org/documentation/
C510 Software Repository https://github.com/nest/nest-simulator
Technical Documentation https://github.com/ReScience-Archives/Senden-Schuecker-Hahne-Diesmann- Goebel-2018
User Documentation https://github.com/ReScience-Archives/Senden-Schuecker-Hahne-Diesmann- Goebel-2018


Software Repository https://github.com/nest/nestml
Technical Documentation https://github.com/nest/nestml/pull/459/files#diff- 1e77cba9d6acc33693cda56a75663f9d
User Documentation https://github.com/nest/nestml/blob/036b07469b2df65a3d04dcbb527e419374ff ef10/doc/synapses_in_nestml.rst
C2789 Software Repository https://github.com/nest/nest-simulator
Technical Documentation https://collab.humanbrainproject.eu/#/collab/264/nav/325519
User Documentation https://nest-simulator.org/documentation
C2696 Software Repository https://github.com/nest/nest-simulator
Technical Documentation
User Documentation https://nest- simulator.readthedocs.io/en/v2.20.0/models/clopath_synapse.html
C2678 Software Repository https://github.com/nest/nest-simulator


Arbor is simulation software for large networks of multi-compartment cells on HPC systems, written as a C++ library with a Python front end. It has been developed entirely within the HBP to provide efficient, state-of-the-art, future-proof simulation technology. Arbor will facilitate beyond state-of-the-art modelling in the HBP in three key ways. First, Arbor is the only multi-compartment simulation engine to natively support NVIDIA GPUs, and is also the only one that can be easily extended to new architectures. Arbor also provides a model description interface that is both flexible and user-friendly, with a clean separation between model description and implementation, required for portable model descriptions. Finally, Arbor provides a rich API for input and output, which will facilitate robust coupling with other simulation tools (namely NEST and TVB on EBRAINS in the next HBP phase SGA3).

Work in the last year has focused on the Arbor core C++ library and its Python wrapper, to release the first full-featured and user-accessible version of Arbor.

The Python wrapper for Arbor was released with full documentation, including a “getting started” guide, available online. The wrapper makes all features of the C++ library available to scientists, plus a Python-only single cell workflow that facilitates rapid model development and testing. It has been tested on laptops, desktop computers and HPC clusters at CSCS, with support for all CPU and GPU architectures available through the HPAC Platform.

One of the most challenging and time-consuming aspects of modelling morphologically-detailed cells is describing the morphology and the location of ion channels, synapses and electrical properties thereon. This was addressed by Arbor’s new “morphology engine”, for describing cell models and properties that are both flexible and easy for users to read and write:

  • a low-level morphology representation compatible with morphologies from SWC, Neurolucida and NeuroML file formats;
  • a Domain Specific Language (DSL) for compactly representing regions and sets of locations on a morphology;
  • a method for associating ion channels and synapses with regions and locations;
  • a new back end that hides implementation details from end users.

Support for the NMODL language, used to describe ion channel and synapse dynamics, has been improved significantly to be able to support all widely-used dynamics.

The NSuite benchmarking and validation suite (released previously in SGA2) has been updated to benchmark and validate the latest version of Arbor.

Component Content URL
NSuite Software Repository https://github.com/arbor-sim/nsuite
Technical Documentation https://nsuite.readthedocs.io
User Documentation https://nsuite.readthedocs.io
Arbor Software Repository https://github.com/arbor-sim/arbor
Technical Documentation https://arbor.readthedocs.io/
User Documentation https://arbor.readthedocs.io/


During the second year of SGA2 we released the first version of TVB-HPC including the parameter- fitting framework and automatic code generation of simulation kernels. The current release is available via the public GitHub repository (https://github.com/the-virtual-brain/tvb-hpc). The current version of TVB-HPC includes automatic code generation for CUDA, Python and numba kernels generated from a NeuroML description. NeuroML, together with LEMS, has been extended in order to support the requirements of neural mass models. The first set of unit tests have been added to the release and the full benchmarking suite will be available by the end of Q1/2020. An example workflow to generate automatic kernels from the Collaboratory will be also available by Q1/2020.

This result connects neural mass modelling with high performance computing in order to allow highly efficient parameter fitting. This will substantially reduce the time used to bring models closer to experimental data and will allow for a better understanding of the mechanisms of the brain at this scale of description. Automatic code generation is also essential to lower the entry barrier for researchers around the field of neuroscience to efficiently using simulation technology.

Software repository, technical and user documentation: https://github.com/the-virtual-brain/tvb-hpc

Multi-simulator multi-scale interaction

The first version of the NeuGen-VRL-Plugin has been published as planned. The users can directly generate and visualise the neuron networks in VRL-Studio. To achieve this, NeuGen was optimised to minimise its dependence on the GUI. New VRL interfaces were implemented, and visualisation functions had to be newly implemented using VRL libraries.

UG4 can receive and send continuous data through the music-plugin, thus it can receive the membrane potential sent by NEURON using the Neuron-UG-plugin. To achieve this, Music-dependent classes were implemented in UG4, and a MusicRuntime Object was created in LUA-script for calling the tick function and accessing the time provided by MUSIC. More details can be found in ug4_music_specification.pdf5, see below.

A model with full spatial resolution for the extracellular potential activity was developed using ug4 (C2694). The creation of a model which uses transmembrane currents (for example delivered by MUSIC) to calculate the extracellular potential in three-dimensional space is documented in a PhD Thesis which is not published yet. See ug4_music_specification.pdf5 for further details.

C2695 (software that couples the relevant scales for network simulation with a 3D model) is still being processed since it strongly depends on Component ID 2693 (NEST-NEURON-UG Coupling) and Component ID 2694 (3D model).

Component Content URL
NeuGen Software Repository https://gcsc.uni-frankfurt.de/simulation-and-modelling/projects
Technical Documentation https://durus.gcsc.uni-frankfurt.de/~neugen/publications.html
User Documentation https://durus.gcsc.uni- frankfurt.de/~neugen/documentationneugenmanual.html
UG4 plugins Software Repository

Music- and Neuron-UG-plugins in UG4 (https://github.com/UG4/ugcore)

Technical Documentation

N/A (not yet released) ug4_music_specification.pdf (see https://collab.humanbrainproject.eu/#/collab/264/nav/1975 nest_neuron-ug.md)

C2694 model Model Repository http://doi.org/10.3389/fncom.2015.00094
UG4 Technical Documentation http://ug4.github.io/docs/
User Documentation https://github.com/UG4/ugcore/blob/master/README.md

Publication highlights