All Tools

This repository contains the code for the EBRAINS Live Papers REST API. EBRAINS live papers are structured and interactive supplementary documents to complement journal publications, that allow users to readily access, explore and utilize the various kinds of data underlying scientific studies. Interactivity is a prominent feature with several integrated tools and services that will allow users to download, visualise or simulate data, models and results presented in the corresponding publications. The REST API is used by the Live Papers web apps to communicate with other EBRAINS services, in particular the EBRAINS Knowledge Graph.

This repository contains the code for the EBRAINS Live Papers web app. EBRAINS live papers are structured and interactive supplementary documents to complement journal publications, that allow users to readily access, explore and utilize the various kinds of data underlying scientific studies. Interactivity is a prominent feature with several integrated tools and services that will allow users to download, visualise or simulate data, models and results presented in the corresponding publications. The web app allows anyone to view and interact with published live papers. It also includes an authoring tool, the live paper builder, which requires an EBRAINS account.

In this form, you can describe key aspects of your dataset so that other researchers will be able to find, reuse and cite your work. You can use the navigation bar above to explore the different sections and categories of metadata collected through this form.

The EBRAINS Model Catalog contains information about models developed and/or used within the EBRAINS research infrastructure. It allows you to find information about models and results obtained using those models, showcasing how those models have been validated against experimental findings.

A Python package for working with the EBRAINS Model Validation Framework.

The EBRAINS Collaboratory (initially known as Collaboratory 2.0) offers researchers and developers an environment to work in teams and share their work with users, teams or all of the Internet. Workspaces in the Collaboratory are known as collabs. The Collaboratory is composed of a collection of software for web services. The IAM service of the Collaboratory manages user identification and team management for EBRAINS services. Users can be grouped into units, groups and collab teams for simpler management. The Wiki service of the Collaboratory hosts the main interface to access all other Collaboratory services. It also offers a handy way of documenting your work with a simple wiki user interface. The Drive service offers each collab its own storage space for files. The drive provides easy access to files from Jupyter Notebooks. All files are under version control. The Drive is intended for smaller files that change more often. The Lab service provides a JupyterLab environment for your notebooks with official releases of EBRAINS tools pre-installed. It’s a great way of programming interactively and of sharing your notebooks with other users. The Office service handles Office documents (Word, PowerPoint or Excel) which can be edited collaboratively online. Whether it is for taking live minutes in a meeting or to finalize/review a report, the collaborative mode is very handy. The Bucket service offers each collab its own storage space for large files. The bucket provides programmatic access to files from Jupyter Notebooks via the bucket API. Datasets, videos and other files too large for the Drive should be stored here. The Chat service offers instant messaging with all users that have an EBRAINS account and that have entered the chat at least once. The chat offers channels, discussions and direct messaging. Client apps are available for desktop and mobile devices. Users that are not active in the Chat also receive notifications by email.

Python client interface for EBRAINS Collaboratory Drive (Seafile) and Bucket (Data-Proxy) storage. Based on the Seafile Python SDK.

A Python SDK for interacting conveniently with the EBRAINS KG Core.

The Electrophys Feature Extraction Library (eFEL) allows neuroscientists to automatically extract features from time series data recorded from neurons (both in vitro and in silico). Examples are the action potential width and amplitude in voltage traces recorded during whole-cell patch clamp experiments. The user of the library provides a set of traces and selects the features to be calculated. The library will then extract the requested features and return the values to the user. The core of the library is written in C++, and a Python wrapper is included. At the moment we provide a way to automatically compile and install the library as a Python module.

This test shall take as input a BluePyOpt optimized output file. The validation test would then evaluate the model for all parameter sets against various eFEL features. It should be noted that the reference data used is that located within the model, so this test can be considered as a quantification of the goodness of fitting the model. The results are registered on the HBP Validation Framework app.

The Python library Electrophysiology Analysis Toolkit (Elephant) provides tools for analysing neuronal activity data, such as spike trains, local field potentials and intracellular data. In addition to providing a platform for sharing analysis codes from different laboratories, Elephant provides a consistent and homogeneous framework for data analysis built on a modular foundation. The underlying data model is the Neo library. This framework easily captures a wide range of neuronal data types and methods, including dozens of file formats and network simulation tools. A common data description, as the Neo library provides, is essential for developing interoperable analysis workflows.

This software provides an efficient implementation for embedded devices of a QRS complex detection method that works on non-uniformly sampled ECG signals.

ExploreASL is a pipeline and toolbox for image processing and statistics of arterial spin labeling perfusion MR images. It is designed as a multi-OS, open source, collaborative framework that facilitates cross-pollination between image processing method developers and clinical investigators. The software provides a complete head-to-tail approach that runs fully automatically, encompassing all necessary tasks from data import and structural segmentation, registration and normalization, up to CBF quantification. In addition, the software package includes and quality control (QC) procedures and region-of-interest (ROI) as well as voxel-wise analysis on the extracted data. To-date, ExploreASL has been used for processing ~10000 ASL datasets from all major MRI vendors and ASL sequences, and a variety of patient populations, representing ~30 studies. The ultimate goal of ExploreASL is to combine data from multiple studies to identify disease related perfusion patterns that may prove crucial in using ASL as a diagnostic tool and enhance our understanding of the interplay of perfusion and structural changes in neurodegenerative pathophysiology. Additionally, this (semi-)automatic pipeline allows us to minimize manual intervention, which increases the reproducibility of studies.

Extra-P is an automatic performance-modeling tool that supports the user in the identification of scalability bugs. A scalability bug is a part of the program whose scaling behavior is unintentionally poor, that is, much worse than expected. Extra-P uses measurements of various performance metrics at different processor configurations as input to represent the performance of code regions (including their calling context) as a function of the number of processes. All it takes to search for scalability issues even in full-blown codes is to run a manageable number of small-scale performance experiments, launch Extra-P, and compare the asymptotic or extrapolated performance of the worst instances to the expectations. Besides the number of processes, it is also possible to consider other parameters such as the input problem size. Extra-P generates not only a list of potential scalability bugs but also human-readable models for all performance metrics available such as floating-point operations or bytes sent by MPI calls that can be further analyzed and compared to identify the root causes of scalability issues.

Extrae is a dynamic instrumentation package to trace programs compiled and run with the shared memory model (like OpenMP and pthreads), the message passing (MPI) programming model or both programming models (different MPI processes using OpenMP or pthreads within each MPI process). Instrumentation of CUDA, CUPTI, OpenCL, Python multiprocessing, Java threads and relevant system, dynamic memory and I/O calls is also supported. Extrae generates trace files that can be visualized with Paraver. Extrae is currently available on different architectures and operating systems, including: GNU/Linux (x86, x86_64, ARM, POWER), IBM AIX, SGI Altix, Open Solaris, FreeBSD, Android, Fujitsu FX10/100, Cray XT, IBM Blue Gene, Intel Xeon Phi, GPUs and FPGAs. The combined use of Extrae and Paraver offers an enormous analysis potential, both qualitative and quantitative. With these tools the actual performance bottlenecks of parallel applications can be identified. The microscopic view of the program behavior that the tools provide is very useful to optimize the parallel program performance.

The fiber architecture constructor (FAConstructor) allows a simple and effective creation of fiber models based on mathematical functions or the manual input of data points. Models are visualized during creation and can be interacted with by translating them in the 3-dimensional space.

Rationale The approach assumes that segmented (into GM, WM and background) images have been aligned, so does not require the additional complexity of a convolutional approach. The use of segmented images is to make the approach less dependent on the particular image contrasts so it generalises better to a wider variety of brain scans. The approach assumes that there are only a relatively small number of labelled images, but many images that are unlabelled. It therefore uses a semi-supervised learning approach, with an underlying Bayesian generative model that has relatively few weights to learn. Model The approach is patch based. For each patch, a set of basis functions model both the (categorical) image to label, and the corresponding (categorical) label map. A common set of latent variables control the two sets of basis functions, and the results are passed through a softmax so that the model encodes the means of a multinouli distribution (Böhning, 1992; Khan et al, 2010). Continuity over patches is achieved by modelling the probability of the latent variables within each patch conditional on the values of the latent variables in the six adjacent patches, which is a type of conditional random field (Zhang et al, 2015; Brudfors et al, 2019). This model (with Wishart priors) gives the prior mean and covariance of a Gaussian prior over the latent variables of each patch. Patches are updated using an iterative red-black checkerboard scheme. Labelling After training, labelling a new image is relatively fast because optimising the latent variables can be formulated within a scheme similar to a recurrent Res-Net (He et al, 2016)."

fairgraph is a Python library for working with metadata in the HBP/EBRAINS Knowledge Graph, with a particular focus on data reuse, although it is also useful in metadata registration/curation. The basic idea of the library is to represent metadata nodes from the Knowledge Graph as Python objects. Communication with the Knowledge Graph service is through a client object, for which an access token associated with an EBRAINS account is needed.

A collection of repositories for applications of fast spike-based sampling: compared to conventional neural networks, physical model devices offer a fast, efficient, and inherently parallel substrate capable of related forms of Markov chain Monte Carlo sampling. This software suite enables the use of a neuromorphic chip to replicate the properties of quantum systems through spike-based sampling.

This repository contains the code for simulating and fitting large-scale brain dynamics using the Dynamic Mean-Field (DMF) model. FastDMF enables efficient whole-brain simulations across spatial scales—from 90 to 1,000 regions—by combining a C++ core with Python and MATLAB interfaces. It features an analytic solution for Feedback Inhibition Control (FIC), and a Bayesian optimization framework for parameter fitting to empirical fMRI data. The repository is organized into the following components: (1) src, C++ implementation of the DMF equations; (2) matlab_interface, MATLAB bindings for running simulations; (3) python_interface, Python wrapper for model configuration and execution; (4) data, example connectomes and parcellation files; (5) optimization, Bayesian parameter fitting tools; (6) examples, usage demos for different parcellation scales and parameter regimes. For detailed methodology and usage instructions, please consult the README file: README.md (https://github.com/decolab/fastDMF/blob/main/README.md).