All Tools

3D Slicer is: A software platform for the analysis (including registration and interactive segmentation) and visualization (including volume rendering) of medical images and for research in image guided therapy. A free, open source software available on multiple operating systems: Linux, MacOSX and Windows Extensible, with powerful plug-in capabilities for adding algorithms and applications. Features include: Multi organ: from head to toe. Support for multi-modality imaging including, MRI, CT, US, nuclear medicine, and microscopy. Bidirectional interface for devices. There is no restriction on use, but Slicer is not approved for clinical use and intended for research. Permissions and compliance with applicable rules are the responsibility of the user.

A Structure Tensor Analysis (STA) tool for the characterization of local 3D orientation in TIFF image stacks. This tool is based on the evaluation of local image intensity gradients. In addition to the local 3D orientation, it also provides a full analysis of local gradient strength, structure disarray, shape and fractional anisotropy indices.

A MATLAB® toolbox that given a three-dimensional spine reconstruction computes a set of characteristic morphological measures that unequivocally determine the spine shape.

Dendritic spines of pyramidal neurons are the targets of most excitatory synapses in the cerebral cortex and their morphology appears to be critical from the functional point of view. Thus, characterizing this morphology is necessary to link structural and functional spine data and thus interpret and make them more meaningful. We have used a large database of more than 7,000 individually 3D reconstructed dendritic spines from human cortical pyramidal neurons that is first transformed into a set of 54 quantitative features characterizing spine geometry mathematically. The resulting data set is grouped into spine clusters based on a probabilistic model with Gaussian finite mixtures. We uncover six groups of spines whose discriminative characteristics are identified with machine learning methods as a set of rules. The clustering model allows us to simulate accurate spines from human pyramidal neurons to suggest new hypotheses of the functional organization of these cells.

SynapsesSA is a tool designed to process and analyze patterns in the three-dimensional spatial distribution of cortical synapses. It brings a variety of both innovative and well-known techniques from the spatial statistics field and a web-based graphical interface compatible with most common browsers. Functionality: Process and visualize data from cortical synapses Model the spatial distribution of the synapses Replicate, via simulation, samples of cortical synapses Compare several indicators obtained from data of different layers

This repository provides the Python implementation of a whole-brain computational modeling framework developed to study the differential influence of amyloid-beta (Aβ) and tau protein accumulation in Alzheimer’s disease (AD). The model integrates subject-specific structural connectomes, resting-state fMRI, and PET-derived biomarker maps from the ADNI cohort to simulate altered brain dynamics using a Hopf oscillator model. The computational pipeline supports parameter optimization, group-level comparisons across diagnostic categories, and biomarker-based classification using the AT(N) framework. It allows researchers to investigate the specific contributions of Aβ and tau to functional reactivity, network integrity, and disease progression, supporting mechanistic insights into AD pathology and potential neurostimulation targets. For methodology, input structure, and usage instructions, see the full README file: README.md (https://github.com/decolab/AD_tau_Amyloid_modeling/blob/main/README.md)

Dockerized Atlas-based Imaging Data Analysis Pipeline (AIDA) for structural and functional MRI of the mouse brain. Accepts Bruker raw data, BIDS and Nifty files as input. Performs a range of data conversion and pre-processing steps including the multi-step registration with the Allen Mouse Brain Atlas.

ML Classification of Alzheimer's Disease vs. Mild Cognitive Impairment vs. Healthy Controls by combining empirical and simulated features as implemented for Triebkorn et al. 2022

An app for acquiring and storing data from multiple sensors. Currently, can be used with the following devices: Empatica E4 Tablet/Smartphone built-in sensors MetaMotion R In order to improve reliability, a bipartite structure has been implemented. In particular, the Main Activity acts as an interface between the user and the main service that constitutes the principal actor. The latter performs scans, handles the user's requests to connect remote devices, all the unexpected disconnection that may happen and receives the data from the wireless sensors.

AnonyMI is a tool for deidentifying MRIs while preserving the geometrical properties of the images. It uses a relatively low-resolution 3D reconstruction of the face to crop the MRI volume in order to keep the shape of the head and the face but remove identifiable information. It is implemented as a plug-in of 3D Slicer, a widely used software for 3D visualization and analysis, and includes a use-friendly interface, manual and automatic selection of the areas to mask, a batch processing mode for large datasets, fast and efficient 3D rendering of the results for quality control, and a command line interface.

AnyWave is a free, multi-platform software that can be used to visualize electrophysiological data, as well as being used as a development framework in order to build custom plug-ins. AnyWave uses plug-ins to load or write files formats. A set of reader and writer plug-ins is bundled with AnyWave and brings the possibility to read several EEG or MEG manufacturers’ formats. The plug-ins are also used to add entirely new signal processing, data analysis and visualization capabilities to AnyWave. AnyWave opens and displays the contents of EEG or MEG files. Acquired signals are then displayed by AnyWave as well as markers that might be stored in the file. Markers can be read from a file, added by the user or even by a signal processing plug-in. Markers can be saved to or loaded from a specific AnyWave format.

Arbor is a high-performance library for computational neuroscience simulations with multi-compartment, morphologically-detailed cells, from single cell models to very large networks. Arbor is written from the ground up with many-cpu and gpu architectures in mind, to help neuroscientists effectively use contemporary and future HPC systems to meet their simulation needs. Arbor supports NVIDIA and AMD GPUs as well as explicit vectorization on CPUs from Intel (AVX, AVX2 and AVX512) and ARM (Neon and SVE). When coupled with low memory overheads, this makes Arbor an order of magnitude faster than the most widely-used comparable simulation software. Arbor is open source and openly developed, and we use development practices such as unit testing, continuous integration, and validation.

Arbor is a high-performance library for computational neuroscience simulations with multi-compartment, morphologically-detailed cells, from single cell models to very large networks. Arbor is written from the ground up with many-cpu and gpu architectures in mind, to help neuroscientists effectively use contemporary and future HPC systems to meet their simulation needs. Arbor supports NVIDIA and AMD GPUs as well as explicit vectorization on CPUs from Intel (AVX, AVX2 and AVX512) and ARM (Neon and SVE). When coupled with low memory overheads, this makes Arbor an order of magnitude faster than the most widely-used comparable simulation software. Arbor is open source and openly developed, and we use development practices such as unit testing, continuous integration, and validation.

ArDock employs the arbitrary docking method to reveal potential interaction sites on the surface of a protein by computationally docking a set of random protein “probes”. The random probes interact in a non-random manner on protein surfaces, and the targeted regions are enriched in biological interfaces. Docking is performed on input protein structures using the Hex software. The ArDock webserver performs the docking calculations and provides tools for the combined analysis of protein structures and sequences and for the visualization of the results to identify interaction sites.

Automated Region of Interest Streamline Extraction (ARISE) software container. The ARISE pipeline creates connectome extraction for two use-cases: 1. extracting streamline based connectomes for two sets of ROI masks 2. Using a single ROI mask, e.g. a pathology lesion mask, to extract the corresponding disconnectome.

A SciUnit library for data-driven testing of basal ganglia models. Employed for testing via the HBP Validation Framework. This test shall take as input a BluePyOpt optimized output file, containing a hall_of_fame.json file specifying a collection of parameter sets. The validation test would then evaluate the model for all (or specified) parameter sets against various eFEL features.

Manually driven processes for data storing can lead to human errors, which cannot be tolerated in the context of a clinical data sets. The Bids manager offers a secure system to import and structure patient’s clinical data sets in Brain Imaging Data Structure (BIDS). BIDS is an initiative aiming at establishing a common standard to describe data and its organization on disk for both neuroimaging and electrophysiological data. Bids Manager is a software for clinicians and researchers with a user-friendly interface.

A tool to generate openMINDS metadata from BIDS datasets

Software library for interoperable biomolecular simulation workflows

BioExcel Building Blocks Workflows is a collection of biomolecular workflows to explore the flexibility and dynamics of macromolecules, including signal transduction proteins or molecules related to the Central Nervous System. Molecular dynamics setup for protein and protein-ligand complexes are examples of workflows available as Jupyter Notebooks.
The workflows are built using the BioBB software library, developed in the framework of the BioExcel Centre of Excellence. BioBBis a collection of Python wrappers on top of popular biomolecular simulation tools, offering a layer of interoperability between the wrapped tools, which make them compatible and prepared to be directly interconnected to build complex biomolecular workflows.

BioExcel-CV19 is a platform designed to provide web-access to atomistic-molecular dynamics trajectories for macromolecules involved in the COVID-19 disease. The BioExcel-CV19 web server interface presents simulated trajectories, with a set of quality control analyses, system information and interactive and graphical information on key structural and flexibility features. All the analyses integrated in the web portal are completely interactive. Whenever possible, a direct link from the analysis to the 3D representation is offered, using the NGL viewer tool. All data produced is available to download from an associated programmatic access API.

BluePyEfe aims at easing the process of reading experimental recordings and extracting batches of electrical features from these recordings. To do so, it combines trace reading functions and features extraction functions from the eFel library. BluePyEfe outputs protocols and features files in the format used by BluePyOpt for neuron electrical model building.

When building a network simulation, biophysically detailed electrical models (e-models) need to be tested for every morphology that is possibly used in the circuit. E-models can e.g. be obtained using BluePyOpt by data-driven model parameter optimization. Developing e-models can take a lot of time and computing resources. Therefore, these models are not reoptimized for every morphology in the network. Instead we want to test if an existing e-model matches that particular morphology `well enough’. This process is called Cell Model Management (MM). It takes as input a morphology release, a circuit recipe and a set of e-models with some extra information. Next, it finds all possible (morphology, e-model)-combinations (me-combos) based on e-type, m-type, and layer as described by the circuit recipe, and calculates the scores for every combination. Finally, it writes out the resulting accepted me-combos to a database, and produces a report with information on the number of matches – BluePyMM. This software is also part of the Human Brain Project Brain Simulation Platform.

The Blue Brain Python Optimisation Library (BluePyOpt) is an extensible framework for data-driven model parameter optimisation that wraps and standardises several existing open-source tools. It simplifies the task of creating and sharing these optimisations, and the associated techniques and knowledge. This is achieved by abstracting the optimisation and evaluation tasks into various reusable and flexible discrete elements according to established best-practices. Further, BluePyOpt provides methods for setting up both small- and large-scale optimisations on a variety of platforms, ranging from laptops to Linux clusters and cloud-based compute infrastructures.

Blue Brain Simulation and Neural network Analysis Productivity layer (Blue Brain SNAP). Blue Brain SNAP is a Python library for accessing BlueBrain circuit models represented in SONATA format.

The Brain Simulation Platform Service Account allows developers to submit jobs, on behalf of the HBP Collaboratory users, on the remote HPC systems made available in the HBP framework. The service leverages the UNICORE APIs and uses the token generated for individual users (upon logging in on the HBP Collaboratory) for tracking general information on job submission and status.

A tool for translating between common coordinate frameworks using deformation matrices.

Simulate or emulate spiking neural networks on BrainScaleS. Models and simulation experiments can be described in a Python script using the PyNN API and submitted either through the EBRAINS Collaboratory website or via our web API (python client available). Results can be viewed via browser and downloaded as data files for analysis, making use e.g. of the data analysis capabilities EBRAINS offers.

The BrainScaleS Operating System (BrainScaleS OS) is a software stack designed for the user-friendly operation of the BrainScaleS spiking neuromorphic computing architectures.

Brainstorm is a collaborative, open-source application dedicated to the analysis of brain recordings: MEG, EEG, fNIRS, ECoG, depth electrodes and animal electrophysiology. Any time you want to use Brainstorm, be sure to pull the latest version from their GitHub Repository first. Our objective is to share a comprehensive set of user-friendly tools with the scientific community using MEG/EEG as an experimental technique. For physicians and researchers, the main advantage of Brainstorm is its rich and intuitive graphic interface, which does not require any programming knowledge. We are also putting the emphasis on practical aspects of data analysis (e.g., with scripting for batch analysis and intuitive design of analysis pipelines) to promote reproducibility and productivity in MEG/EEG research. Finally, although Brainstorm is developed with Matlab (and Java), it does not require users to own a Matlab license: an executable, platform-independent (Windows, MacOS, Linux) version is made available in the downloadable package. To get an overview of the interface, you can watch this introduction video.

Brayns is a visualizer that can interactively perform high-quality and high-fidelity rendering of neuroscience large data sets. It provides an abstraction of the underlying rendering engines, so that the best possible acceleration libraries can be used for the relevant hardware (CPU or GPU). Thanks to its client/server architecture, Brayns can be run in the cloud as well as on a supercomputer and stream the rendering to any browser, either in a web UI or a Jupyter notebook.

Brion provides two libraries Brion and Brain. The former is a collection of file readers and writers intended for low level access to the data model. The latter is a set of higher level classes that wrap low level data objects with a use-case oriented API. IO library This is the core library provided by Brion. It includes classes for reading and writing files which store the Blue Brain data model. Fast and low-overhead read access to: Blue configs (brion::BlueConfig) Circuit description (brion::Circuit) H5 Synapses data (brion::SynapseSummary, brion::Synapse) Target (brion::Target) BBP binary meshes (brion::Mesh) BBP H5 morphologies and SWC morphologies (brion::Morphology) Compartment reports (brion::CompartmentReport) Spike reports (brion::SpikeReport) Fast and low-overhead write access to: Compartment reports (brion::CompartmentReport) BBP binary meshes (brion::Mesh) BBP H5 morphologies (brion::Morphology) Spike reports (brion::SpikeReport) Basic data types to work with the loaded data using Boost, Lunchbox High level library The higher level library is called Brain and it provides: brain::Circuit to facilitate loading information about cells, morphologies (in local and global circuit coordinates) and synapses. brain::neuron::Morphology with higher level functions to deal with morphologies. brain::Synapses and brain::Synapse for array and object access to synapses.

The BSB is a framework for reconstructing and simulating multi-paradigm neuronal network models. It removes much of the repetitive work associated with writing the required code and lets you focus on the parts that matter. It helps write organized, well-parametrized and explicit code understandable and reusable by your peers. This package is intended to facilitate spatially, topologically and morphologically detailed simulations of brain regions developed by the Department of Brain and Behavioral Sciences at the University of Pavia.

Web application that displays scientific use cases and creates the environment that allows end users to run them flawlessly. Different categories of use cases like morphology analysis, trace analysis, simulation and different scales such as brain area, single cell, etc. are shown to be run in Ebrains infrastructure. Some of the use cases are web apps, others jupyter notebooks. This is part of Interactive Workflows for Cellular Level Modeling in Ebrains

Central Nervous System (CNS) is a platform designed to efficiently generate and parameterize bioactive conformers of ligands binding to neuronal proteins. The project is part of the Parameter generation and mechanistic studies of neuronal cascades using multi-scale molecular simulations of the Human Brain Project. CNS conformers are generated using a powerful multilevel strategy that combines a low-level (LL) method for sampling the conformational minima and high-level (HL) ab-initio calculations for estimating their relative stability. CNS database presents the results in a graphical user interface, displaying small molecule properties, analyses and generated 3D conformers. All data produced by the project is available to download. CNS will contribute in the improvement of the understanding of neuronal signalling cascades by protein structure-based simulations, calculating thermodynamics and kinetics constants of the molecular processes.

Central Nervous System (CNS) ligands is a platform designed to efficiently generate and parameterize bioactive conformers of ligands binding to neuronal proteins. CNS conformers are generated using a powerful multilevel strategy that combines a low-level (LL) method for sampling the conformational minima and high-level (HL) ab-initio calculations for estimating their relative stability.CNS database presents the results in a graphical user interface, displaying small molecule properties, analyses and generated 3D conformers. All data produced is available to download. CNS ligands provides important data for workflows for parameter generation and mechanistic studies of neuronal cascades using multi-scale molecular simulations in the Human Brain Project.

This repository provides the code, configuration and morphology data to reconstruct and simulate cerebellar cortex circuits using the Brain Scaffold Builder framework. These models are based on the iterative work of the Department of Brain and Behavioral Sciences (DBBS) of the university of Pavia.

A SciUnit library for data-driven testing of cerebellum models. CerebTests is one of the four components of CerebUnit, the others being CerebModels, CerebData and CerebStats.

Advances in coarse-grained molecular dynamics (CGMD) simulations have extended the use of computational studies on biological macromolecules and their complexes, as well as the interactions of membrane protein and lipid complexes at a reduced level of representation, allowing longer and larger molecular dynamics simulations. Here, we present a computational platform dedicated to the preparation, running, and analysis of CGMD simulations. The platform is built on a completely revisited version of our Martini coarsE gRained MembrAne proteIn Dynamics (MERMAID) web server, and it integrates this with other three dedicated services. In its current version, the platform expands the existing implementation of the Martini force field for membrane proteins to also allow the simulation of soluble proteins using the Martini and the SIRAH force fields. Moreover, it offers an automated protocol for carrying out the backmapping of the coarse-grained description of the system into an atomistic one.

The Coarse-grained Molecular dynamics(CGMD) platform is a publicly available web server for preparing and running coarse-grained molecular dynamics simulations using different force-fields. The input file is a protein structure. The user is guided through the preparation of the systems, either in a membrane or in solvent, and the running of short simulations following standard protocols.

ChemBioServer is a publicly available web application for effectively mining and filtering chemical compounds used in drug discovery. It provides researchers with the ability to (i) browse and visualize compounds along with their properties, (ii) filter chemical compounds for a variety of properties such as steric clashes and toxicity, (iii) apply perfect match substructure search, (iv) cluster compounds according to their physicochemical properties providing representative compounds for each cluster, (v) build custom compound mining pipelines and (vi) quantify through property graphs the top ranking compounds in drug discovery procedures. ChemBioServer allows for pre-processing of compounds prior to an in silico screen, as well as for post-processing of top-ranked molecules resulting from a docking exercise with the aim to increase the efficiency and the quality of compound selection that will pass to the experimental test phase.

Clint Explorer is an application that uses supervised and unsupervised learning techniques to cluster neurobiological dataset. The main contributions of this software is that incorporates the expert’s know-how in the clustering process. Besides, it allows to interpret the results providing different metrics.

Cobrawap is an adaptable and reusable analysis pipeline for the multi-scale, multi-methodology analysis of cortical wave activity. The pipeline ingests data from multiple measurements types of spatially organized neuronal activity, such as ECoG or calcium imaging recordings. The pipeline returns statistical measures to quantify the dynamic wave-like activity patterns found in the data.

The EBRAINS Collaboratory offers researchers and developers a secure environment to work with others. You control the level of collaboration by sharing your projects with specific users, teams or all of the Internet. Many researchers are sharing their work already; several services, tools, datasets and other resources are publicly available, and many more are available for registered users.

The COMP Superscalar (COMPSs) framework is mainly composed of a task-based programming model which aims to ease the development of parallel applications for distributed infrastructures, such as Clusters, Clouds and containerized platforms, and a runtime system that exploits the inherent parallelism of applications at execution time. The framework is complemented by a set of tools for facilitating the development, execution monitoring and post-mortem performance analysis.

To better understand the relationships between interindividual variability in brain regions’ connectivity and behavioural phenotypes, we are developing a connectivity-based psychometric prediction framework (CBPP). Preliminary to the development of this region-wise machine learning approach, we performed an extensive assessment of the general connectivity-based psychometric prediction (CBPP) framework based on whole-brain connectivity information. Because a systematic evaluation of different parameters was lacking from previous literature, we evaluated several approaches pertaining to the different steps of a CBPP study. We hence tested 72 different approach combinations (3 types of preprocessing x 4 parcellation granularity x 2 connectivity methods x 3 regression methods = 72 combinations) in a cohort of over 900 healthy adults across 98 psychometric variables. Overall, our extensive evaluation combined to an innovative region-wise machine learning approach offer a framework that optimises both, prediction performance and neurobiological validity (and hence interpretability) for studying brain-behaviour relationships.

CoreNeuron supports a reduced set of the functionalities offered by the open source simulator NEURON. The software aims at supporting an efficient and scalable simulation of the electrical activity of neuronal networks that include morphologically detailed neurons. CoreNeuron has been implemented with the goal of minimising memory footprint and obtaining optimal performance, relying on the use of a single MPI process per node and 64 OpenMP threads on IBM BlueGene/Q systems.

CreateZoom is a service for converting large images to DZI format, integrating the EBRAINS data infrastructure

Cube, which is used as performance report explorer for Scalasca and Score-P, is a generic tool for displaying a multi-dimensional performance space consisting of the dimensions (i) performance metric, (ii) call path, and (iii) system resource. Each dimension can be represented as a tree, where non-leaf nodes of the tree can be collapsed or expanded to achieve the desired level of granularity. In addition, Cube can display multi-dimensional Cartesian process topologies. The Cube 4.x series report explorer and the associated Cube4 data format is provided for Cube files produced with the Score-P performance instrumentation and measurement infrastructure or the Scalasca version 2.x trace analyzer (and other compatible tools). However, for backwards compatibility, Cube 4.x can also read and display Cube 3.x data.

CxSystem2 is a simulation framework for cortical networks, which operates on personal computers. It is implemented in Python on top of the popular Brian2 simulator, and runs on Linux, Windows and MacOS. There is also a web-based version available via the Human Brain Project Brain Simulation Platform (BSP). CxSystem2 embraces the main goal of Brian – minimizing development time – by providing the user with a simplified interface. While many simple models can be written in pure Brian code, more complex models can get hard to manage due to the large number of biological details. We currently provide two interfaces for constructing networks: a browser-based interface (locally or via the BSP), and a file-based interface (json or csv). Before incorporating neuron models into a network, the user can explore their behavior using the Neurodynlib submodule. Spike output and 3D structure of network simulations can be visualized using ViSimpl, a visualization tool developed by the GMRV Lab.

PostgreSQL relational database schema for tracking the provenance of data for all software components and files involved in the data transformation process. This project provides a Docker container including Alembic and a Python model of the Data Catalog schema to setup and migrate this schema in a target database.

DC Explorer focuses on statistical analysis of data subsets. In this regard, it provides a treemap visualization to facilitate the subset definition. Treemapping is used to visualize the filtering operations that define each subset by grouping the data in different compartments, color coding each item and sorting them by their value. Once the subsets have been defined different statistical tests are automatically performed in order to analyze relationship between the selected subsets.

DeepSlice is a python library which automatically aligns coronal mouse histology section images with the Allen brain atlas common coordinate framework. The alignments are viewable, and refinable, using the QuickNII software package.

Demics is a library for the Python programming language, adding support for distributed computational operations for very large, multi-dimensional arrays and matrices. Such operations include Deep Learning inference models from the libraries TensorFlow and PyTorch. The software focuses on the segmentation and detection of objects in particularly large image data.

deNEST is a Python library for specifying networks and running simulations using the NEST simulator. deNEST allows the user to concisely specify large-scale networks and simulations in hierarchically-organized declarative parameter files. From these parameter files, a network is instantiated in NEST (layers of neurons and stimulation devices, their connections, and recorder devices), and a simulation is run in sequential steps ("sessions"), during which the network parameters can be modified and the network can be stimulated, recorded, etc. Some advantages of the declarative approach: Parameters and code are separated Simulations are easier to reason about, reuse, and modify Parameters are more readable and succinct Parameter files can be easily version controlled and diffs are smaller and more interpretable Clean separation between the specification of the "network" (the simulated neuronal system) and the "simulation" (structured stimulation and recording of the network), which facilitates running different experiments using the same network Parameter exploration is more easily automated The complexity of interacting with NEST is hidden, which makes some tricky operations (such as connecting a weight_recorder) easy.

Distance-Fluctuation (DF) Analysis is a Python tool that performs analysis of the results of a MD simulation using the Distance Fluctuation matrices (DF), based on the Coordination Propensity (CP) hypothesis. Specifically, low CP values, corresponding to low pair-distance fluctuations, highlight groups of residues that move in a mechanically coordinated way. The script can analyze a MD trajectory and identify the coordinated motions between residues. It can then filter the output matrix based on the distance to identify long-range coordinated motions.

Distance-Fluctuation (DF) Analysis is a Python tool that performs analysis of the results of a MD simulation using the Distance Fluctuation matrices (DF), based on the Coordination Propensity (CP) hypothesis. Specifically, low CP values, corresponding to low pair-distance fluctuations, highlight groups of residues that move in a mechanically coordinated way. The script can analyze a MD trajectory and identify the coordinated motions between residues. It can then filter the output matrix based on the distance to identify long-range coordinated motions.

Library for the simulation of rate-based neuron models with conductance-based synapses in feedforward architectures. Supports synaptic plasticity. Both models with instantaneous membrane response and dynamic models are available. Dynamic models are integrated with Runge-Kutta 2/3 to increase stability for larger timesteps. For theoretical details see https://arxiv.org/abs/2104.13238.

This is the source code for the EBRAINS CodeMeta Generator app, which provides a web-form to help software developers who wish to make their software tools or web services available through EBRAINS create CodeMeta files. It was inspired by the original CodeMeta generator created by Software Heritage, but enforces the stricter requirements needed for registration in EBRAINS.

In this form, you will be asked to provide some information about yourself and your dataset, model, or software. This should take around 15 min. Please note that all information provided can be adjusted later on.

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

The Fiber Architecture Simulation Toolbox for PLI (fastpli) is a toolbox for polarized light imaging (PLI) with three main purposes: Sandbox - designing of nerve fiber models: The first module allows the user to create different types of nerve fiber bundles and additionally fill them with individual nerve fibers. Details Tutorial Solver - generating collision free models: The second module takes as input a configuration of nerve fibers and checks them for spatial collisions. Since nerve fibers cannot overlap in reality, one must ensure that the models follow the same rules. The solver module implements a simple algorithm that checks for collisions and, if it finds any, pushes the colliding segments of the fibers slightly apart. This is repeated until all collisions are solved. Details Tutorial Simulation - simulation of 3D-Polarized Light Imaging: The simulation module enables the simulation of 3D Polarized Light Imaging (3D-PLI). This is a microscopic technique that allows the polarization change of light moving through a brain section to be measured. Due to the birefringence property of the myelin surrounding the nerve fibers, the polarization state changes. This change enables the calculation of the 3d orientation of the nerve fibers in the brain slice. Details Tutorial

The Feature Extraction Graphical User Interface (GUI) is a web application that allows users to extract an ensemble of electrophysiological properties from voltage traces recorded upon electrical stimulation of neuronal cells. The main outcome of the application is the generation of two files - features.json and protocol.json - that can be used for later model parameter optimizations.

MATLAB implementation of Feature-specific Information Transfer (FIT) and conditional FIT (cFIT) measures. FIT quantifies the amount of information transmitted from a sender brain region X to a receiver brain region Y about a specific external feature S. This approach goes beyond classic methodologies to study causal communication, such as Transfer Entropy (TE), which quantify the overall activity propagated from the sender to the receiver region. By isolating the feature-specific information flowing from one region to another, FIT sheds light on the actual content of the communication. For the details on FIT mathematical derivation and test on simulated and rael data please read: M. Celotto et al. An information-theoretic quantification of the content of communication between brain regions. biorXiv, 2023.

This library is meant to be a light-weight Python library that handles functional alignment tasks. It is compatible with and inspired from Nilearn. Alternative implementations of these ideas can be found in the pymvpa or brainiak packages.

Preprocessing of functional MRI (fMRI) involves numerous steps to clean and standardize the data before statistical analysis. Generally, researchers create ad hoc preprocessing workflows for each dataset, building upon a large inventory of available tools. The complexity of these workflows has snowballed with rapid advances in acquisition and processing. fMRIPrep is an analysis-agnostic tool that addresses the challenge of robust and reproducible preprocessing for task-based and resting fMRI data. fMRIPrep automatically adapts a best-in-breed workflow to the idiosyncrasies of virtually any dataset, ensuring high-quality preprocessing without manual intervention. fMRIPrep robustly produces high-quality results on diverse fMRI data. Additionally, fMRIPrep introduces less uncontrolled spatial smoothness than observed with commonly used preprocessing tools. fMRIPrep equips neuroscientists with an easy-to-use and transparent preprocessing workflow, which can help ensure the validity of inference and the interpretability of results. The workflow is based on Nipype and encompases a large set of tools from well-known neuroimaging packages, including [FSL](<https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/), ANTs, FreeSurfer, AFNI, and Nilearn. This pipeline was designed to provide the best software implementation for each state of preprocessing, and will be updated as newer and better neuroimaging software becomes available. fMRIPrep performs basic preprocessing steps (coregistration, normalization, unwarping, noise component extraction, segmentation, skullstripping etc.) providing outputs that can be easily submitted to a variety of group level analyses, including task-based or resting-state fMRI, graph theory measures, surface or volume-based statistics, etc. fMRIPrep allows you to easily do the following: Take fMRI data from unprocessed (only reconstructed) to ready for analysis. Implement tools from different software packages. Achieve optimal data processing quality by using the best tools available. Generate preprocessing-assessment reports, with which the user can easily identify problems. Receive verbose output concerning the stage of preprocessing for each subject, including meaningful errors. Automate and parallelize processing steps, which provides a significant speed-up from typical linear, manual processing.

Foa3D (3D Fiber Orientation Analysis) is a Python tool for multiscale nerve fiber enhancement and 3D orientation analysis in large high-resolution volumetric images acquired by two-photon scanning or light-sheet fluorescence microscopy.

Frites allows the characterisation of task-related cognitive brain networks. Neural correlates of cognitive functions can be extracted both at the single brain area (or channel) and network level. The toolbox includes time-resolved directed (e.g., Granger causality) and undirected (e.g., Mutual Information) Functional Connectivity metrics. In addition, it includes cluster-based and permutation-based statistical methods for single-subject and group-level inference.

Classifies the given interneuron morphology into one of the 7 possible classes. The model has been trained with layer L2/3 to layer L6 interneurons and thus only interneurons from those layers are allowed as input.

This repository provides the MATLAB implementation of the GABIC (Generative Anatomically-Constrained Bidirectional Connectivity) framework developed to estimate directed effective connectivity by fitting whole-brain Hopf oscillator models to empirical neuroimaging data. The model integrates structural connectivity (SC) matrices derived from diffusion MRI and NDTE (Normalized Directed Transfer Entropy) flow from resting-state fMRI to infer asymmetric coupling parameters that best reproduce empirically observed causal interactions across brain regions. The computational pipeline employs particle swarm optimization to fit model dynamics to NDTE targets, enabling the exploration of functional hierarchies and causal roles of specific regions, including the global neuronal workspace. It allows researchers to conduct in silico lesion analyses, examine information flow, and test mechanistic hypotheses about brain coordination and hierarchy. For methodology, input structure, and usage instructions, see the full README file: README.md (https://github.com/decolab/GABIC/blob/master/README.md)

Among fiber tracking methods, spin glass tractography approaches propose an efficient framework to perform a global optimization of the inference of the structural brain connectivity from diffusion MRI HARDI or HYDI dataset. In addition, spin-glass based global tractography allows to add further regularization potentials to better constrain the energy landscape using anatomical or microstructural priors and thus help discard false positives. The proposed global tractography tools allows to compute from any diffusion MRI dataset a dense tractogram of virtual white matter fibers, under the constraint of a bending energy ensuring low curvature of fibres and robust inference of fibers in regions depicting several fiber populations (kissings, crossings, splittings), of anatomical prior (pial surface to drive the ending of fibers), and of microstructural priors (like the intraxonal volume fraction or the orientation dispersion of fibers, to allow sharp turns of fibres when connecting to the cortical ribbon).

Ginkgo/MEDUSA (Microstructure Environment Designer Using Sphere Atoms) is a HPC compatible simulation tool that allows an all-in one simulation of brain tissue microstructure and their diffusion MRI signal relying on 3 simulation features: The Ginkgo/MEDUSA tool is dedicated to the development of computational models of brain tissue microstructure in order to go beyond existing analytical models known to be limited to accurately represent the complexity of brain cellular environments

The Glycine Receptor Allosteric Ligand Library (GRALL) is the first database of allosteric modulators of a synaptic receptor with structural annotation.

Plotting tool to make plotting with many subfigures easier, especially for publications. After installation gridspeccer can be used from the command line to create plots.

This library implements Cartesian genetic programming (e.g, Miller and Thomson, 2000; Miller, 2011) for symbolic regression in pure Python, targeting applications with expensive fitness evaluations. It provides Python data structures to represent and evolve two-dimensional directed graphs (genotype) that are translated into computational graphs (phenotype) implementing mathematical expressions. The computational graphs can be compiled as Python functions, SymPy expressions (Meurer et al., 2017) or PyTorch modules (Paszke et al., 2017). The library currently implements an evolutionary algorithm, specifically (mu + lambda) evolution strategies adapted from Deb et al. (2002), to evolve a population of symbolic expressions in order to optimize an objective function.

An HTTP backend for transforming coordinates and data between the core template spaces of the HBP. The cross-template transformations are diffeomorphisms, which are computed based on the alignment of the folding pattern across the different brains (DISCO method) and maximization of the grey–white matter segmentation overlap (DARTEL).

The foundation for the EBRAINS HealthDataCloud is an existing GDPR compliant and EBRAINS interoperableVirtual Research Environment (VRE) – located at the Charité – that provides a secure and scalable data platform enabling multi-institutional research teams to store, share and analyze complex multi-modal health datasets.

Data recorded with intracerebral EEG (iEEG) electrodes in patients are notoriously hard to navigate through and synthetize, because of the high spatial variability and sparsity of the recordings. The HiBoP software is the first of its kind to allow conveniently the visualization and manipulation of multimodal data (iEEG, as well as fMRI, PET …) both at the individual level and at the group level (up to 200 and more).

This package contains validation tests for models of hippocampus, based on the SciUnit framework and the NeuronUnit package. As in SciUnit, in HippoUnit tests four main classes are implemented: the Test class, the Model class, the Capabilities class and the Score class. The tests of HippoUnit automatically run simulations on single-cell models that mimic the electrophysiological protocol from which the target experimental data were derived. Then the behavior of the model is evaluated and quantitatively compared to the experimental data using various feature-based error functions. Current tests cover somatic behavior and signal propagation and integration in apical dendrites of hippocampal CA1 pyramidal cell models.

The Hodgkin-Huxley Neuron Builder implements a Use Case of the Brain Simulation Platform. It allows the user to interactively go through the entire cell model building pipeline. The workflow consists of three steps: 1) electrophysiological feature extraction from voltage traces; 2) model parameter optimization; 3) in silico experiments using the optimized model cell. The user is provided with a friendly interface enabling to interact with both the HBP Collaboratory storage and the High Performance Computing (HPC) resources. The application has been built in a flexible way to allow the user to enter the workflow at any desired step, by either interacting with HBP resources or uploading his own files.

The EBRAINS multilevel human brain atlas provides detailed information on anatomy, connectivity, and function. It links macroanatomical concepts and their intersubject variability with measurements of the microstructural composition and intrinsic variance of brain regions.

The HPC Status Monitor allows to check the status of the HPC systems available for job submission from the HBP Collaboratory and the remaining quotas reserved to the user on each of them. In order to run a job in the HPC systems, the HBP user needs to be mapped on and to be part of (at least) a project on those systems. If the user does not have any access and allocation to any systems, she/he can still submit jobs (with limited quotas) through the available service accounts.

The Human Intracerebral EEG Platform (HIP) is an open-source platform designed for collecting, managing, analyzing, and sharing iEEG data at an international level. Its primary mission is to promote the development of large-scale iEEG research projects by facilitating international collaborations in the field.

The Hybrid MM/CG Webserver automatizes and speeds up the hybrid Molecular-Mechanics/CoarseGrained (MM/CG) simulations set-up of G-Protein coupled receptors/ligand complexes. The server allows for the equilibration of the systems, either fully automatically or interactively. It allows the visualization of results online (using both interactive 3D visualizations and analysis plots), helping the user to identify possible issues and modify the set-up parameters accordingly

This Python package gives the pipeline used to process the MRI data obtained in the Individual Brain Charting Project. More info on the data can be found at IBC public protocols and IBC webpage. Latest collection of raw data is available on OpenNeuro, data accession no.002685. Latest collection of unthresholded statistical maps can be found on NeuroVault, id collection=6618. Install Under the main working directory of this repository in your computer, run the following command in a command prompt: pip install -e . Example usage One can import the entire package with import ibc_public or use specific parts of the package: from ibc_public import utils_data utils_data.make_surf_db(derivatives="/path/to/ibc/derivatives", mesh="fsaverage5") Details These script make it possible to preprocess the data run topup distortion correction run motion correction run coregistration of the fMRI scans to the individual T1 image run spatial normalization of the data run a general linear model to obtain brain activity maps for the main contrasts of the experiment. Core scripts The core scripts are in the scripts folder pipeline.py lunches the full analysis on fMRI data (pre-processing + GLM) glm_only.py launches GLM analyses on the data surface_based_analyses launches surface extraction and registration with Freesurfer; it also projects fMRI data to the surface surface_glm_analysis.py runs glm analyses on the surface dmri_preprocessing (WIP) is for diffusion daat. It relies on dipy. anatomical mapping (WIP) yields T1w, T2w and MWF surrogates from anatomical acquisitions. script_retino.py yields some post-processing for retinotopic acquisitions (derivation of retinotopic representations from fMRI maps) Dependencies Dependencies are : FSL (topup) SPM12 for preprocessing Freesurfer for surface-based analysis Nipype to call SPM12 functions Pypreprocess to generate preprocessing reports Nilearn for various functions Nistats to run general Linear models. The scripts have been used with the following versions of software and environment: Python 3.5 Ubuntu 16.04 Nipype v0.14.0 Pypreprocess v0.0.1.dev FSL v5.0.9 SPM12 rev 7219 Nilearn v0.4.0 Nistats v0.0.1.a Future work More high-level analyses scripts Scripts for additional datasets not yet available scripts for surface-based analysis Contributions Please feel free to report any issue and propose improvements on Github.

Ilastik is a simple, user-friendly tool for interactive image classification, segmentation and analysis. It is built as a modular software framework, which currently has workflows for automated (supervised) pixel- and object-level classification, automated and semi automated object tracking, semi-automated segmentation and object counting without detection. Most analysis operations are performed lazily, which enables targeted interactive processing of data subvolumes, followed by complete volume analysis in offline batch mode. Using it requires no experience in image processing.

ImageJ is an open source image processing program designed for scientific multidimensional images. ImageJ is highly extensible, with thousands of plugins and scripts for performing a wide variety of tasks, and a large user community. Open source: ImageJ is a tool for the scientific community. To maintain transparency, the ImageJ application and its source code will always be freely available. Reproducible: Powerful tools such as the Script Editor and personal update sites help you develop and share reproducible analysis workflows. Interoperable: ImageJ is not an island. Use the best tool for the job, including KNIME, ITK, MATLAB, and a multitude of scripting languages.

SPM-based Matlab toolbox for processing intracranial EEG recordings (SEEG and ECOG), including basic (data conversion, electrode positioning, montage, filtering, time-frequency decomposition) and advanced (epileptogenicity mapping, statistical analyses) for the analysis of epileptic seizures and cortico-cortical evoked potentials. All the functions can be used both from the toolbox interface and from Matlab scripts. They are written in Matlab and assume the data are saved in SPM EEG data format.

This server-side tool is meant to be used for the creation of provenance tracks in context of interactive analysis tools and visualization applications. It is capable of tracking multi-view and multiple applications for one user using this ensemble. It further is able to extract these tracks from the internal data base into a XML-based standard format, such as the W3C Prov-Model or the OPM format. This enables the integration to other tools used for provenance tracking and will finally end up in the UP.

Insite provides a middleware that enables users to acquire data from neural simulators via the in-transit paradigm. In-transit approaches allow users to access data from a running simulation while the simulation is still going on. In the traditional approach data from simulations is written to disk first, and can only be accessed after the simulation has finished. However, this has two main constraints: Data can only be further processed after the whole simulation has finished. Disk speed can be a bottleneck when simulating, as data has to be written out. Data must be completely stored on the machine, leading to large files. Using Insite allows users to develop data consumer, such as visualizations and analysis tools that allow early insight into the data without storing data with virtually zero dependencies. Insite was specifically designed to be ease-to-integrate and easy-to-use to allow a wide range of users to take advantage of in-transit approaches in the context of brain simulation. Insite uses off-the-shelf dataformats and protocols to make integration as easy as possible. Data can be queried via an HTTP REST API from Insite's access node, which represents a single point of contact for the user. Insite support the following three simulators: NEST, Arbor, TVB.

The Human Brain Project hosts a rich web-based 3D atlas viewer („NeHuBa“), that is capable of displaying very large brain volumes, including oblique slicing, a whole brain overview, surface meshes, and maps. It allows to interactively choose different template spaces and reference parcellations, find brain areas by name or visual selection, and browse additional region-specific multimodal data. The rendering of large volumetric data builds on the opensource project neuroglancer. Some important atlases and templates can be directly accessed, including the „Big Brain“ (Amunts et al., Science 2013) the JulichBrain cytoarchitectonic atlas and the Waxholm Space Atlas of the Sprague Dawley Rat Brain.

Work through a number of pipelines for single cell model optimization of different brain region cells, run in silico experiments of individual neurons, small circuits and entire brain regions, perform ad hoc data analysis on electrophysiological data, synaptic events fitting, morphology analysis and visualization.

A software to visualize electrodes implantation on image data and prepare database for group studies. Multimodality and electrode implantation with 3D display and easy co-registration between modalities. (MRI : T1, T2, FLAIR, fMRI, DTI; CT ; PET) Semi-automatic estimation of the volume of resection Importation of SEEG files (for now only .TRC, Micromed©) Display of cortico-cortical evoked potential mapping Automatic exportation of "dictionaries" containing the information of contact positions in the native and MNI coordinate systems, associated parcels in different atlas (MarsAtlas, Destrieux – Freesurfer, Brodmann, AAL, etc.), white/grey matter labeling, and resection labeling. Automatic exportation of dictionaries containing the total volume of the resection and percentage of MarsAtlas or Destrieux parcels which have been considered by the resection (for now only assumes no brain deformation due to the resection). Display of Epileptogenicity maps coregistered with other modalities (all statistical maps registered in the T1 pre space are loadable). groupDisplay can be used to visualize electrode contacts from many patients over images in the MNI referential and to research patients according to different keywords. IntranatElectrodes software is based on BrainVISA, Morphologist and Cortical Surface. It uses ANTs and spm12 for multimodality coregistration and spm12 for estimation of the deformation field to convert into MNI Space. It needs a Matlab license to run the normalisation and groupDisplay interface.

Decoding the chain from genes to cognition requires detailed insights how areas with specific gene activities and microanatomical architectures contribute to brain function and dysfunction. The Allen Human Brain Atlas contains regional gene expression data, while the JuBrain Atlas offers three-dimensional cytoarchitectonic maps reflecting the interindividual variability. JuGEx offers an integrated framework that combines the analytical benefits of both repositories towards a multi-level brain atlas of adult humans. JuGEx is a new method for integrating tissue transcriptome and cytoarchitectonic segregation.

An extensible environment for interactive and reproducible computing, based on the Jupyter Notebook and Architecture. Currently ready for users. JupyterLab is the next-generation user interface for Project Jupyter offering all the familiar building blocks of the classic Jupyter Notebook (notebook, terminal, text editor, file browser, rich outputs, etc.) in a flexible and powerful user interface. JupyterLab will eventually replace the classic Jupyter Notebook. JupyterLab can be extended using npm packages that use our public APIs. To find JupyterLab extensions, search for the npm keyword jupyterlab-extension or the GitHub topic jupyterlab-extension. To learn more about extensions, see the user documentation. The current JupyterLab releases are suitable for general usage, and the extension APIs will continue to evolve for JupyterLab extension developers.

The heart of the MarmotGraph is called "Core" and provides the API you are looking for if you want to integrate or interact with MarmotGraph by scripts. It consists of a graph database and a service layer providing the necessary business logic. The MarmotGraph Core is also responsible for the authorization of the users.

KnowledgeSpace (KS) is a community-based encyclopedia for neuroscience that links brain research concepts to the data, models, and literature that support them. The KS framework: combines the general descriptions of neuroscience concepts found in wikipedia with more their more detailed desrciptions from InterLex links the latest PubMed citations with the descriptions of neuroscience concepts, and provides users with access to the data and models linked to neuroscience research concepts found in some of the world’s leading neuroscience repositories. Further, it serves as a framework where large-scale neuroscience projects can expose their data to the neuroscience community-at-large. KnowledgeSpace is a joint development between the Human Brain Project (HBP), the International Neuroinformatics Coordinating Facility (INCF), and the Neuroscience Information Framework (NIF).

The lesion aware automated processing pipeline (LeAPP, Bey et al. 2024) allows the user to automatically create TVB-ready neuroimaging data for patients with pathological artefacts, in particular ischemic stroke lesions, in a reproducible and FAIR way. Building upon the human connectome minimal processing pipeline (Glasser et al. 2013) the presented pipeline introduces established correction measures, such as cost function masking (Brett et al. 2001) and virtual brain transplant (Solodkin et al. 2010) and implemented processing steps appropriate for modalities and properties commonly found in the clinical context of acute stroke patient data acquisition. The current software is provided as containerized image for robust and reproducible dissemination. We acknowledge the important contribution of our colleagues from UKE who by providing the data set Longitudinal multimodal magnetic resonance imaging data for ischemic stroke patients and healthy controls – a BIDS data set enabled the development of the presented pipeline.

The module allows to compute the Perturbational Complexity (LZ) of Casarotto et al. (2016). A Python Notebook gives a step-by-step explanation of the steps needed to calculate the perturbational complexity index (PCI). The same notebook illustrates how PCI changes across two different brains states, the wake and the sleep stages. It is assumed that an inverse solution has already been obtained from the TMS/EEG data. In the notebook a 3-spheres BERG method was used to obtain the cortical currents (as in the 3-sphere BERG). Inverse solutions can be obtained from TMS/EEG data by the well known MNE Python module. (Casarotto S, Comanducci A, Rosanova M, Sarasso S, Fecchio M, Napolitani M, et al. Stratification of unresponsive patients by an independently validated index of brain complexity: Complexity Index. Annals of Neurology. 2016;80: 718–729)

Given a sequence of stimuli, fMRI data from subjects exposed to these sequence one or several models making quantitative predictions from each stimulus in the sequence, the code allows you build a flexible analysis pipeline combining functions that allow you to generate R² or r maps. Function types can be for example: For example, the pipeline programmed in main.py fits stimuli-representations of several lanuage models to fMRI data obtained from participants listening to an audiobook (in 9 runs). R² are computed from a nested-cross validated Ridge-regression. The pipeline runs for tuples (1 subject, 1 model), to facilitate distributing the code on a cluster.

LFPy is a Python module for the calculation of extracellular potentials and magnetic signals from activity in multicompartment neuron and network models. It relies on the NEURON simulator (http://www.neuron.yale.edu/neuron) and uses the Python interface (http://www.frontiersin.org/neuroinformatics/10.3389/neuro.11.001.2009/abstract) it provides.

This Python module contain freestanding implementations of electrostatic forward models incorporated in [LFPy] (https://github.com/LFPy/LFPy)(docs). The aim of the LFPykit module is to provide electrostatic models in a manner that facilitates forward-model predictions of extracellular potentials and related measures from multicompartment neuron models, but without explicit dependencies on neural simulation software such as NEURON, Arbor, or even LFPy. The LFPykit module can then be more easily incorporated with these simulators, or in various projects that utilize them such as LFPy, BMTK, etc.

C++ / Python reader for SONATA circuit files

Livre (Large-scale Interactive Volume Rendering Engine) is an out-of-core, multi-node, multi-gpu, OpenGL volume rendering engine to visualise large volumetric data sets. It provides the following major features to facilitate rendering of large volumetric data sets: Visualisation of pre-processed UVF format (source code) volume data sets. Real-time voxelisation of different data sources (surface meshes, BBP morphologies, local-field potentials, etc) through the use of plugins. Multi-node, multi-gpu rendering (Currently only sort-first rendering)

LocaliZoom allows the viewing and exploring of high-resolution images with superimposed atlas overlays, and the extraction of coordinates of annotated points within those images for viewing in 3D brain atlas space. It is well suited for the extraction of a limited number of coordinates, e.g. representing an electrode track or labelling within a small region of interest.

This is a Python software to build a model of the primate retina and convert various visual stimuli to ganglion cell action potentials. The simulator is primarily for research, with the intention of providing biologically plausible spike trains for downstream visual cortex simulations.

We built the MarmotGraph (formerly "EBRAINS Knowledge Graph") to help you find and share the data you need to make your next discovery. We also built it to connect you to the software and hardware tools which will help you analyse the data you have and the data you find. MarmotGraph supports rich terminologies, ontologies and controlled vocabularies. The system is built by design to support iterative elaborations of common standards and supports these by probabilistic suggestion and review systems. MarmotGraph is a multi-modal metadata store which brings together information from different fields on brain research. At the core of MarmotGraph, a graph database tracks the linkage between experimental data and neuroscientific data science supporting more extensive data reuse and complex computational research than would be possible otherwise.

Collaboratively create and edit the metadata through the MarmotGraph Editor which supports you by input aids and built-in ontologies. With the MarmotGraph Editor, managing data "on the graph", reviewing and publishing revisions of your metadata is easy to achieve and allows to keep up with high quality standards.

You want to query metadata to use in your own application or reports? Make use of the easy-to-use MarmotGraph Query Builder - a UI that allows you to define your queries and collect just the metadata you want conveniently in your web browser.

Finding data through the MarmotGraph is easy: Use MarmotGraph Search to filter and explore the content of the graph.

The MD-IFP is a python workflow for the generation and analysis of protein-ligand interaction fingerprints from Molecular Dynamics trajectories. If used for the analysis of RAMD (Random Accelaration Molecular Dynamics) trajectories, it can help to investigate dissociation mechanisms by characterizing transition states as well as the determinants and hot-spots for dissociation. As such, the combined use of τRAMD and MD-IFP may assist the early stages of drug discovery campaigns for the design of new molecules or ligand optimization.

The Medical Informatics Platform (MIP) is designed to help clinicians, clinical scientists, and clinical data scientists aiming to adopt advanced analytics for clinical research. Users can explore harmonized medical data extracted from pre-processed neuroimaging, neurophysiological and medical records and research cohort datasets without transferring original clinical data.

MEDIUM is a Python tool that uses the DF matrices to extract global information on the protein. It works directly on DF images and uses a Convolutional Neural Network (CNN) machine learning approach to train the model in recognising specific patterns in the DF matrix capable of classifying the protein in a specific state in the presence of a ligand (e.g., HOLO or APO states). Then, the trained model can be used to classify the protein state in presence of different ligands, by testing new DF matrices arising from short simulations performed on the new system.

The application of data visualization to exploratory analysis has proven its effectiveness in different scientific fields. Unfortunately, each discipline suffers from specific problems, making it difficult to apply general solutions. MeLVin is a graphical meta-framework for our MEta Language for Visualization. It was created to facilitate the design of interactive coordinated views applications for visual exploration of data using different technologies. The platform is conceived as an abstraction layer placed over existing data visualization and processing environments, enabling their integration. The data analysis workflow can be seamlessly defined using data-flow diagrams. Unlike most data-flow diagram-based data mining applications, MeLVin allows users to include visualizations as part of the analysis process and not just as a tool to display final results. Please, find additional information on our project web page: https://gmrv.es/gmrvvis/melvin/ If you are interested in the project, you can test its functionalities at: https://gmrv.es/gmrvvis/melvin/app/auth

This repository provides a MATLAB implementation of a whole-brain node-metastability (ignition) analysis framework, developed to examine the effects of menstrual cycle phase, hormone levels, and age on dynamical brain activity in healthy women. The pipeline processes resting-state fMRI and structural connectivity data to compute subject-specific ignition metrics, allowing quantification of functional reactivity and complexity across cortical networks such as DMN, salience, and somatomotor systems. This tool enables individualised whole-brain modelling relevant for neuroendocrinology and women's brain health research. For methodology, data structure, and usage instructions, see the full README file: README.md (https://github.com/decolab/menstrualcycle_ignition/blob/main/README.md)

MeshView is a web application for real-time 3D display of surface mesh data representing structural parcellations from volumetric atlases, such as the Waxholm Space Atlas of the Sprague Dawley Rat Brain. MeshView is available as an EBRAINS community app, accessible via a collab (further info: https://wiki.ebrains.eu/bin/view/Collabs/image-registration-and-analysis-demo/) Key features: orbiting view with toggleable opaque/transparent/hidden parcellation meshes rendering user defined cut surface as if meshes were solid objects rendering point-clouds (simple type-in, or loaded from a JSON format) coordinate system is compatible with QuickNII (https://www.nitrc.org/projects/quicknii)

Platform for rapidly deploying globally distributed services. It supports clustering, security, monitoring and more out of the box. It is based on Cisco's Mantl cloud project (https://github.com/CiscoCloud/mantl). The aim of this project is to support the deployment of many services in the MIP and provide an environment for big data software such as Apache Spark.

MLCE-predictions of PPIs is a Python tool that predicts the region in a protein most likely to be involved in interactions with external partners (i.e., other proteins or supramolecular assemblies of the same monomer. It is based on the Matrix of Lowest Coupling Energies, an energy decomposition method that performs in multiple steps, through initial decomposition of interaction energies, approximation to the first eigenvector and then filtration to select only the residue in close contact. MLCE thus represents the regions of the protein lowest dynamically coupled and this means that they are also the most prone to be involved in interaction with external partners.

The Hybrid Molecular Mechanics/Coarse-Grained (MM/CG) is a server that helps in the preparation and running of multiscale molecular dynamics simulations of G protein-coupled receptors (GPCR) in complex with their ligands. The Hybrid MM/CG Webserver requires the structure of a GPCR/ligand complex as input and then guides the user through the preparation and running of the simulation.

MoDEL_CNS is a platform designed to provide web-access to atomistic molecular dynamics trajectories for relevant signal transduction proteins. MoDEL_CNS expands the Molecular Dynamics Extended Library (MoDEL) database of atomistic Molecular Dynamics trajectories with proteins involved in Central Nervous System (CNS) processes, including membrane proteins. MoDEL_CNS web server interface presents the resulting trajectories, analyses, and protein properties. All data produced by the project is available to download. MoDEL_CNS will contribute to the improvement of the understanding of neuronal signalling cascades by protein structure-based simulations, calculating molecular flexibility and dynamics, and guiding systems level modelling.

Monsteer is a library for Interactive Supercomputing in the neuroscience domain. Monsteer facilitates the coupling of running simulations (currently NEST) with interactive visualization and analysis applications. Monsteer supports streaming of simulation data to clients (currenty only spikes) as well as control of the simulator from the clients (also kown as computational steering). Monsteer's main components are a C++ library, a MUSIC-based application and Python helpers.

MorphIO is a library for reading and writing neuron morphology files. It supports the following formats: SWC ASC (aka. neurolucida) H5 v1 H5 v2 is not supported anymore, see H5v2_ It provides 3 C++ classes that are the starting point of every morphology analysis: Soma: contains the information related to the soma. Section: a section is the succession of points between two bifurcations. To the bare minimum the Section object will contain the section type, the position and diameter of each point. Morphology: the morphology object contains general information about the loaded cell but also provides accessors to the different sections. One important concept is that MorphIO is split into a read-only part and a read/write one.

MorphoUnit is a SciUnit library for data-driven testing of neuronal morphologies. Employed for testing via the HBP Validation Framework.

A toolbox for morphology editing. It aims to provide small helper programs that perform simple tasks. Utility toolkit for morphologies. Different usable functions that can't be fit into NeuroR or NeuroM. MorphTool provides a morphology diffing tool (via CLI or python), a file converter: to convert morphology files from/to the following formats: SWC, ASC, H5 and a soma area calculator (as computed by NEURON, requires the NEURON python module).

The Allen mouse brain atlas is a comprehensive digital resource that provides detailed information on the structure and function of the mouse brain. A wide range of structural and functional experimental data mapped to the Allen mouse brain atlas are shared via the EBRAINS research infrastructure.

MRIcroGL allows you to view 2D slices and renderings of your brain imaging data. It can display many image formats and includes a graphical interface for dcm2nii to convert DICOM images to NIfTI format. It allows you to draw regions of interest which can aid lesion mapping and fMRI analysis. It provides sophisticated volume rendering. It uses Python as a scripting language allowing repetitve tasks to be automated.

MRIcron is a cross-platform NIfTI format image viewer. It is a stand-alone program which does not require any other software that runs natively on Windows, Linux and Macintosh computers. It can load multiple layers of images, generate volume renderings and draw volumes of interest. It also provides dcm2nii for converting DICOM images to NIfTI format and NPM for statistics.

MRtrix3 provides a large suite of tools for image processing, analysis and visualisation, with a focus on the analysis of white matter using diffusion-weighted MRI. Features include the estimation of fibre orientation distributions using constrained spherical deconvolution, a probabilisitic streamlines algorithm for fibre tractography of white matter, fixel-based analysis of apparent fibre density and fibre cross-section, quantitative structural connectivity analysis, and non-linear spatial registration of fibre orientation distribution images. MRtrix3 also offers comprehensive visualisation tools in mrview.

This BIDS App enables generation and subsequent group analysis of structural connectomes generated from diffusion MRI data. The analysis pipeline relies primarily on the MRtrix3 software package, and includes a number of state-of-the-art methods for image processing, tractography reconstruction, connectome generation and inter-subject connection density normalisation.

A compact and general-purpose Python package for Multi-perturbation Shapley value Analysis.

MSPViz is a web-based visualisation tool for structural plasticity models. It uses a novel visualisation technique based on the representation of neuronal information through the use of abstract levels and a set of representations in each level. This hierarchical representation lets the user interact and change the representation, modifying the degree of detail of the information to be analysed in a simple and intuitive way, through the navigation of different views at different levels of abstraction. The designed representations in each view only contain the necessary variables to achieve the desired tasks, thus avoiding overwhelming saturation of information. The multilevel structure and the design of the representations provide organised views, which facilitate visual analysis tasks. Moreover, each view has been enhanced adding line and bar charts to analyse trends in simulation data. Filtering and sorting capabilities can be applied on each view to ease the analysis. Additionally, some other views, such as connectivity matrices and force-directed layouts, have been incorporated, enriching the already existing views and improving the analysis process. Finally, this tool has been optimised to lower render and data loading times, even from remote sources such as WebDav servers.

Multi-Brain: Unified segmentation of population neuroimaging data The Multi-Brain (MB) model has the general aim of integrating a number of disparate image analysis components within a single unified generative modelling framework (segmentation, nonlinear registration, image translation, etc.). The model is described in Brudfors et al [2020], and it builds on a number of previous works. Its objective is to achieve diffeomorphic alignment of a wide variaty of medical image modalities into a common anatomical space. This involves the ability to construct a "tissue probability template" from a population of scans through group-wise alignment [Ashburner & Friston, 2009; Blaiotta et al, 2018]. Diffeomorphic deformations are computed within a geodesic shooting framework [Ashburner & Friston, 2011], which is optimised with a Gauss-Newton strategy that uses a multi-grid approach to solve the system of linear equations [Ashburner, 2007]. Variability among image contrasts is modelled using a much more sophisticated version of the Gaussian mixture model with bias correction framework originally proposed by Ashburner & Friston [2005], and which has been extended to account for known variability of the intensity distributions of different tissues [Blaiotta et al, 2018]. This model has been shown to provide a good model of the intensity distributions of different imaging modalities [Brudfors et al, 2019].

This Python package offers a convenient interface to set-up co-simulation models that simulate TVB large-scale brain network models that interact with NEST spiking neuron models. NEST simulates neural activity at the microscopic spatial scale of single neurons or neuron networks. On the other hand, The Virtual brain simulates at the mesoscopic or macroscopic scales of large neural populations or brain regions. Here, both are brought together to enable neuroscientists to study how these different scales interact and how different scales inform activity "from the bottom up" and "down from the top". A generic Python interface allows users to quickly and conveniently set up a parallel simulation in TVB and in NEST and automatically handles the exchange of currents, spikes, voltages, etc. between the different scales. Although the technical aspect of this tool is realized, the scientific part is a work in progress and we are continuously enriching the coupling between scales such that biophysical plausibility is maintained. The TVB+NEST bundle software package -- available as an easy-to-use Docker image container -- combines the sophistication and flexibility of NEST's spiking neuron simulation infrastructure with TVB's whole-brain simulation, processing, analyses and visualisation capabilities.

The EBRAINS Macaque Monkey Brain Atlas is a comprehensive resource that provides in-depth insights into the anatomy, connectivity, and functions of the macaque monkey brain. It includes detailed information about the organization of the monkey brain at multiple levels, ranging from the microscopic level to the macroscopic level of the entire brain.

PIPSA is a tool for the comparison of the electrostatic interaction properties of proteins. It permits the classification of proteins according to their interaction properties. The PIPSA similarity analysis procedure consists of several steps : (0) preparation step - making a directory for similarity calculations and arranging pdb files there (1) calculating protein interaction field grid (2) calculating similarity matrix from pdb files and protein interaction field grids (2a) adding additional protein(s) to an already processed set (without repeating previously done pair-wise similarity calculations) (3) phylogenic tree anaysis or other visualisation (4) correlate kinetic parameters with average interaction field differences The multipipsa python wrapper is designed to run Protein Interaction Properties comparisons on multiple sites of a protein (all CA atoms) and calculate scores according to Tong, Wade and Bruce, Proteins 2016; 84:1844-1858

MUSIC is an API allowing large scale neuron simulators using MPI internally to exchange data during runtime. MUSIC provides mechanisms to transfer massive amounts of event information and continuous values from one parallel application to another. Special care has been taken to ensure that existing simulators can be adapted to MUSIC. In particular, MUSIC handles data transfer between applications that use different time steps and different data allocation strategies. This is the MUSIC pilot implementation. The two most important components built from this software distribution is the music library 'libmusic.a' and the music utility 'music'. A MUSIC-aware simulator links against the C++ library and can be launched using mpirun together with the music utility as described in the README in the code repository. MUSIC can also be used from a C program using the API in music-c.h.

This repository provides a MATLAB implementation of the Generative Connectivity of the Arrow of Time (GCAT) framework, developed to investigate how the hierarchical organisation of brain activity changes under naturalistic conditions. Specifically, it enables the analysis of fMRI data from the Human Connectome Project (HCP), comparing movie-watching and rest. The GCAT metric quantifies directionally-resolved effective connectivity across cortical regions, offering a novel approach to assess the breakdown of hierarchical brain structures during ecologically valid stimulation. For methodology, usage, and reproducibility guidelines, see README.md (https://github.com/decolab/gec/blob/main/README.md)

NEAT is a python library for the study, simulation and simplification of morphological neuron models. NEAT accepts morphologies in the de facto standard .swc format, and implements high-level tools to interact with and analyze the morphologies. NEAT also allows for the convenient definition of morphological neuron models. These models can be simulated, through an interface with the NEURON simulator, or can be analyzed with two classical methods: The separation of variables method to obtain impedance kernels as a superposition of exponentials and Koch's method to compute impedances with linearized ion channels analytically in the frequency domain. Furthermore, NEAT implements the neural evaluation tree framework and an associated C++ simulator, to analyze subunit independence. Finally, NEAT implements a new and powerful method to simplify morphological neuron models into compartmental models with few compartments. For these models, NEAT also provides a NEURON interface so that they can be simulated directly, and will soon also provide a NEST interface.

Nehuba is a core part of the SP5 atlas tool suite, and currently being extended by interactive components to cover more use cases than browsing of reference atlases. This is the viewer that will include the components for interactive analysis with ilastik and be used for overlaying volumetric data with high-resolution atlases on the web

Neo is a Python package for working with electrophysiology data in Python, together with support for reading a wide range of neurophysiology file formats, including Spike2, NeuroExplorer, AlphaOmega, Axon, Blackrock, Plexon, Tdt, and support for writing to a subset of these formats plus non-proprietary formats including HDF5. The goal of Neo is to improve interoperability between Python tools for analyzing, visualizing and generating electrophysiology data by providing a common, shared object model. In order to be as lightweight a dependency as possible, Neo is deliberately limited to represention of data, with no functions for data analysis or visualization. Neo is used by a number of other software tools, including SpykeViewer (data analysis and visualization), Elephant (data analysis), the G-node suite (databasing), PyNN (simulations), tridesclous (spike sorting) and ephyviewer (data visualization). OpenElectrophy (data analysis and visualization) uses an older version of neo. Neo implements a hierarchical data model well adapted to intracellular and extracellular electrophysiology and EEG data with support for multi-electrodes (for example tetrodes). Neo's data objects build on the quantities package, which in turn builds on NumPy by adding support for physical dimensions. Thus Neo objects behave just like normal NumPy arrays, but with additional metadata, checks for dimensional consistency and automatic unit conversion. A project with similar aims but for neuroimaging file formats is NiBabel.

The Neo Viewer Service is a Django app that provides a REST API for reading electrophysiology data from any file format supported by Neo and exposing it in JSON format.

NEST is a simulator for spiking neural network models that focuses on the dynamics, size and structure of neural systems, rather than on the exact morphology of individual neurons. It is ideal for networks of any size, including models of information processing (e.g. in the visual or auditory cortex of mammals), models of network activity dynamics (e.g. laminar cortical networks or balanced random networks) and models of learning and plasticity. NEST is openly available for download.

NEST Desktop is a web-based GUI application for NEST Simulator, an advanced simulation tool for computational neuroscience. NEST Desktop enables the rapid construction, parametrization, and instrumentation of neuronal network models. It offers interactive tools for visual network construction, running simulations in NEST and applying visualization to support the analysis of simulation results. NEST Desktop mainly consists of two views and a connection to a server-based NEST instance, which can be controlled using the web-based NEST Desktop front-end. The first view of NEST Desktop enables the user to create point neuron network models interactively. A visual modeling language is provided and a simulation script is automatically created from this visual model. The second view enables the user to analyze the returned simulation results using various visualization methods. NEST Desktop offers additional functionality, such as employing Elephant for more sophisticated statistical analyses.

The NEST Instrumentation App is a graphical interface to connect recording and stimulation devices to networks. The interface is easy to use, is versatile, and gives a good visualization of the connection between devices and neurons. After having selected the desired connections, the projections can be sent to NEST to run simulations.

NESTML is a domain-specific language that supports the specification of neuron models in a precise and concise syntax. It was developed to address the maintainability issues that follow from an increasing number of models, model variants, and an increased model complexity in computational neuroscience. Our aim is to ease the modelling process for neuroscientists both with and without prior training in computer science. This is achieved without compromising on performance by automatic source-code generation, allowing the same model file to target different hardware or software platforms by changing only a command-line parameter. While originally developed in the context of NEST Simulator, the language itself as well as the associated toolchain are lightweight, modular and extensible, by virtue of using a parser generator and internal abstract syntax tree (AST) representation, which can be operated on using well-known patterns such as visitors and rewriting. Model equations can either be given as a simple string of mathematical notation or as an algorithm written in the built-in procedural language. The equations are analyzed by the associated toolchain ODE-toolbox, to compute an exact solution if possible or to invoke an appropriate numeric solver otherwise.

NetPyNE provides programmatic and graphical interfaces to develop data-driven multiscale brain neural circuit models using Python and NEURON. Users can define models using a standardised JSON-compatible, rule-based, declarative format Based on these specifications, NetPyNE will generate the network in NEURON, enabling users to run parallel simulations, optimize and explore network parameters through automated batch runs, and use built-in functions for visualization and analysis (e.g.,generate connectivity matrices, voltage traces, spike raster plots, local field potentials, and information theoretic measures). NetPyNE also facilitates model sharing by exporting and importing standardized formats: NeuroML and SONATA.

The UI splits the workflows in two tabs available at the top of the screen: define your network and create network. The NetPyNE GUI is implemented on top of Geppetto, an open-source platform that provides the infrastructure for building tools for visualizing neuroscience models and data and for managing simulations in a highly accessible way. The GUI is defined using JavaScript, React and HTML5. This offers a flexible and intuitive way to create advanced layouts while still enabling each of the elements of the interface to be synchronized with the Python model. The interactive Python backend is implemented as a Jupyter Notebook extension which provides direct communication with the Python kernel. This makes it possible to synchronize the data model underlying the GUI with a custom Python-based NetPyNE model. This functionality is at the heart of the GUI and means any change made to the NetPyNE model in the Python kernel is immediately reflected in the GUI and vice versa. The tool’s GUI is available at https://github.com/Neurosim-lab/NetPyNE-UI and is under active development.

The NetworkUnit module builds upon the formalized validation scheme of the SciUnit package, which enables the validation of models against experimental data (or other models) via tests. A test is matched to the model by capabilities and quantitatively evaluated by a score.

Neurolucida is a microscopy system specifically designed for performing accurate neuron reconstructions directly from histological specimens. It is capable of over 500 quantitative morphometric analyses, including: The number of dendrites, axons, branches, synapses, varicosities, and spines The length, width, and volume of dendrites and axons The area and volume of somas The complexity and extension of neurons A complete Neurolucida system includes all necessary hardware—including a microscope, computer, motorized XY stage, and camera—as well as technical and research support from MBF Bioscience to optimize your experimental design and analysis. The Neurolucida software and hardware work in harmony to deliver a powerful, easy to use neuron reconstruction system.

NeuroM is a Python toolkit for the analysis and processing of neuron morphologies It includes functionality to analyze (features like radial distances, volumes, neurite type counts, sholl anaylsis, etc.), visualize, and check neuron morphologies (disconnected neurites, duplicated points, zero diameters, etc). It can be used as a library, but also includes a command line interface to perform more common operations.

The Neuromorphic Computing Platform allows neuroscientists and engineers to perform experiments with configurable neuromorphic computing systems. The platform provides two complementary, large-scale neuromorphic systems built in custom hardware at locations in Heidelberg, Germany (the “BrainScaleS” system, also known as the “physical model” or PM system) and Manchester, United Kingdom (the “SpiNNaker” system, also known as the “many core” or MC system). Both systems enable energy-efficient, large-scale neuronal network simulations with simplified spiking neuron models. The BrainScaleS system is based on physical (analogue) emulations of neuron models and offers highly accelerated operation (104 x real time). The SpiNNaker system is based on a digital many-core architecture and provides real-time operation. The Python client allows scripted access to the Platform. The same client software is used both by end users for submitting jobs to the queue, and by the hardware systems to take jobs off the queue and to post the results.

NEURON's computational engine employs special algorithms that achieve high efficiency by exploiting the structure of the equations that describe neuronal properties. It has functions that are tailored for conveniently controlling simulations, and presenting the results of real neurophysiological problems graphically in ways that are quickly and intuitively grasped. Instead of forcing users to reformulate their conceptual models to fit the requirements of a general purpose simulator, NEURON is designed to let them deal directly with familiar neuroscience concepts. Consequently, users can think in terms of the biophysical properties of membrane and cytoplasm, the branched architecture of neurons, and the effects of synaptic communication between cells.

This tool allows for neuronal soma segmentation in fluorescence microscopy imaging datasets with the use of a parametrized family of deeplearning-based models based on the original U-Net model by Ronneberger et al. with some additional features such as residual links and tile-based frame reconstruction.

This tool presents a new technique for the generation of three-dimensional models for neuronal cells from the morphological information extracted through computed-aided tracing applications. The 3D polygonal meshes that approximate the cell membrane can be generated at different resolution levels, allowing balance to be reached between the complexity and the quality of the final model. Neuronize implements a novel approach to generate a realistic 3D shape of the soma from the incomplete information stored in the digitally traced neuron using a physical deformation technique. The addition of a set of spines along the dendrites completes the model, generating a final 3D neuronal cell suitable for its visualization in a wide range of 3D environments.

NeuroR is a collection of tools to repair morphologies. There are presently three types of repair which are outlined below. Sanitization This is the process of sanitizing a morphological file. It currently: ensures it can be loaded with MorphIO raises if the morphology has no soma or of invalid format removes unifurcations set negative diameters to zero raises if the morphology has a neurite whose type changes along the way removes segments with near zero lengths (shorter than 1e-4) Note: more functionality may be added in the future Cut plane repair The cut plane repair aims at regrowing part of a morphologies that have been cut out when the cell has been experimentally sliced. neuror cut-plane repair contains the collection of CLIs to perform this repair. Additionally, there are CLIs for the cut plane detection and writing detected cut planes to JSON files: If the cut plane is aligned with one of the X, Y or Z axes, the cut plane detection can be done automatically with the CLIs: neuror cut-plane file neuror cut-plane folder If the cut plane is not one the X, Y or Z axes, the detection has to be performed through the helper web application that can be launched with the following CLI: neuror cut-plane hint Unravelling Unravelling is the action of “stretching” the cell that has been shrunk because of the dehydratation caused by the slicing. The unravelling CLI sub-group is: neuror unravel The unravelling algorithm can be described as follows: Segments are unravelled iteratively. Each segment direction is replaced by the averaged direction in a sliding window around this segment. The original segment length is preserved. The start position of the new segment is the end of the latest unravelled segment.

NeuroScheme uses schematic representations, such as icons and glyphs to encode attributes of neural structures (i.e. neurons, columns, layers, populations, etc.). This abstraction alleviates problems with displaying, navigating, and analysing, large datasets. It has been designed specifically to manage hierarchically organised neural structures; one can navigate through the levels of the hierarchy, and hone in on their desired level of details. NeuroScheme works using what we call "domains". These domains specify which entities, attributes and relationships are going to be used for a specific use case. NeuroScheme currently has two built-in domains: “cortex” and “congen”. The “cortex” domain is designed for navigating and analysing cerebral cortex structures (i.e. neurons, micro-columns, columns, layers, etc.). The “congen” domain can be used to define the properties of both cells and connections, create circuits composed of neurons, and build populations. Groups of populations can be easily moved to a higher level of abstraction (such as column or layer), allowing one to create complex networks with little effort. These circuits can be exported afterwards and used for further analysis and simulations.

Neurosift is a browser-based tool designed for the visualization of NWB (Neurodata Without Borders) files, whether stored locally or hosted remotely, and enables interactive exploration of the DANDI Archive.

The C++ Neuroanatomy library provides analysis and editing functionalities for 3D traced neurons. Imports traced neurons written in SWC and 'Neurolucida' DAT and ASC format and validates them. A extensive set of predefined measures are included, but new measures can be added easily.

The goal of neurostr is, to provide an R interface to the NeuroSTR C++ neuroanatomy toolbox. The 'neurostr' package provides a subset of functionalities, via wrappers for the NeuroSTR precompiled tools: Node Feature Extractor; Branch Feature Extractor; Format converter; Neuron Validator.

NeuroSuites is an online platform to run multiple neuroscience tools in a very easy way. To start using NeuroSuites just click on your preferred category on the tab at the top of the page. It provides you multiple tools to analyze neuroscience data. You will not need to install anything to run the tools provided, everything is online. Furthermore, when you are done, you can export your results to your own computer. There are many available tools, some are focused in analyzing neurons morphology reconstructions and the others are general purpose tools like the statistics engine, supervised classification models, Bayesian networks, etc.

Visualise neurons and neural circuits consisting of a large number of cells with NeuroTessMesh on your desktop. It enables the visualisation of the 3D morphology of cells included in open databases, such as NeuroMorpho, and provides the tools needed to approximate missing information such as the soma’s morphology. NeuroTessMesh takes morphological tracings of cells acquired by neuroscientists as its only input. It generates 3D models that approximate the neuronal membrane. The resolution of the models can be adapted at the time of visualisation. NeuroTessMesh can assign different colours to different morphologies, in order to visually codify relevant morphological variables, or even neuronal activity.

Nilearn makes it easy to use many advanced machine learning, pattern recognition and multivariate statistical techniques on neuroimaging data for applications such as MVPA (Mutli-Voxel Pattern Analysis), decoding, predictive modelling, functional connectivity, brain parcellations, connectomes. Nilearn can readily be used on task fMRI, resting-state, or VBM data. For a machine-learning expert, the value of nilearn can be seen as domain-specific feature engineering construction, that is, shaping neuroimaging data into a feature matrix well suited to statistical learning, or vice versa.

The NMODL Framework is a code generation engine for NEURON MODeling Language (NMODL). It is designed with modern compiler and code generation techniques to: Provide modular tools for parsing, analysing and transforming NMODLProvide easy to use, high level Python APIGenerate optimised code for modern compute architectures including CPUs, GPUs Flexibility to implement new simulator backendsSupport for full NMODL specification.

The HBP Neurorobotics platform is the backbone of the EBRAINS Closed-Loop Neuroscience service. It provides access to an online, physically realistic environment within which users can simulate and use neural models (including spiking neural networks running on neuromorphic chips) composed into functional architectures, connected to physical incarnations (musculoskeletal models, robotic systems). The functional connection of neural models to physical agents allows to explore performance of a number of tasks of interest in closed loop, spanning a range from lower level of abstraction sensorimotor tasks, to multimodal perception or dexterous motion control, to cognitive functions extending to contextual awareness and decision making. The service allows cognitive and computational neuroscientists to explore, in an embodied setting, connections between neural models considered (their structure), their dynamical behavior (activity), and function, expressed through the physical agent. It provides roboticists direct access to cutting-edge neuroscience research, with the tools to investigate efficacy of functional neural models in addressing problems in robotics and embodied AI. The service is currently available as an online platform accessible and usable remotely through a standard browser, or as a local version (using Docker image or through a full source installation).

NSuite is a framework for maintaining and running benchmarks and validation tests for multi-compartment neural network simulations on HPC systems. NSuite automates the process of building simulation engines, and running benchmarks and validation tests. NSuite is specifically designed to allow easy deployment on HPC systems in testing workflows, such as benchmark-driven development or continuous integration. There are three motivations for the development of NSuite: The need for a definitive resource for comparing performance and correctness of simulation engines on HPC systems. The need to verify the performance and correctness of individual simulation engines as they change over time. The need to test that changes to an HPC system do not cause performance or correctness regressions in simulation engines. The framework currently supports the simulation engines Arbor, NEURON, and CoreNeuron, while allowing other simulation engines to be added.

Nutil aims to simplify the pre-and-post processing of 2D brain section image data from mouse, rat and other small animal models. It can be used to preprocess images in preparation for analysis, and used as part of the QUINT workflow to perform spatial analysis of labelled features relative to a reference brain atlas. Nutil is developed as a stand-alone application with a simple user-interface, requiring little-to-no experience to execute.

Choosing the optimal solver for systems of ordinary differential equations (ODEs) is a critical step in dynamical systems simulation. ODE-toolbox is a Python package that assists in solver benchmarking, and recommends solvers on the basis of a set of user-configurable heuristics. For all dynamical equations that admit an analytic solution, ODE-toolbox generates propagator matrices that allow the solution to be calculated at machine precision. For all others, first-order update expressions are returned based on the Jacobian matrix. In addition to continuous dynamics, discrete events can be used to model instantaneous changes in system state, such as a neuronal action potential. These can be generated by the system under test as well as applied as external stimuli, making ODE-toolbox particularly well-suited for applications in computational neuroscience.

openMINDS MATLAB is a toolbox to support the creation and use of openMINDS metadata models and schemas in MATLAB, with import and export in JSON-LD format. The package contains all openMINDS schemas as MATLAB classes in addition to schema base classes and utility methods.

This Jupyter notebook contains Python code for creating openMINDS JSON-LD metadata collections for TVB-ready data. The code in this notebook was used to generate openMINDS metadata for curation of TVB-on-EBRAINS datasets using openMINDS v1. An overview over TVB-on-EBRAINS services is provided in the preprint https://arxiv.org/abs/2102.05888 The openMINDS schema standard specification is hosted in the repository https://github.com/HumanBrainProject/openMINDS

openMINDS Python is a small library to support the creation and use of openMINDS metadata models and schemas in your Python application, with import and export in JSON-LD format. The package contains all openMINDS schemas as Python classes in addition to schema base classes and utility methods. Installation pip install openMINDS Usage from datetime import date from openminds import Collection, IRI import openminds.latest.core as omcore # Create an empty metadata collection collection = Collection() # Create some metadata mgm = omcore.Organization( full_name="Metro-Goldwyn-Mayer Studios, Inc.", short_name="MGM", homepage=IRI("https://www.mgm.com") ) stan = omcore.Person( given_name="Stan", family_name="Laurel", affiliations=omcore.Affiliation(member_of=mgm, start_date=date(1942, 1, 1)) ) ollie = omcore.Person( given_name="Oliver", family_name="Hardy", affiliations=omcore.Affiliation(member_of=mgm, start_date=date(1942, 1, 1)) ) # Add the metadata to the collection collection.add(stan, ollie, mgm) # Check the metadata are valid failures = collection.validate() # Save the collection in a single JSON-LD file collection.save("my_collection.jsonld") # Save each node in the collection to a separate file collection.save("my_collection", individual_files=True) # creates files within the 'my_collection' directory # Load a collection from file new_collection = Collection() new_collection.load("my_collection.jsonld")

OptiNiSt(Optical Neuroimage Studio) is a GUI based workflow pipeline tools for processing calcium imaging data. OptiNiSt helps researchers try multiple data analysis methods, visualize the results, and construct the data analysis pipelines easily and quickly on GUI. OptiNiSt's data-saving format follows NWB standards. OptiNiSt also supports reproducibility of scientific research, standardization of analysis protocols, and developments of novel analysis tools as plug-in.

The Open Trace Format Version 2 (OTF2) is a highly scalable, memory efficient event trace data format plus support library. It is the standard trace format for Scalasca, Vampir, and Tau and is open for other tools. OTF2 is the common successor format for the Open Trace Format (OTF) and the Epilog trace format. It preserves the essential features as well as most record types of both and introduces new features such as support for multiple read/write substrates, in-place time stamp manipulation, and on-the-fly token translation. In particular, it will avoid copying during unification of parallel event streams.

Paraver was developed to respond to the need to have a qualitative global perception of the application behavior by visual inspection and then to be able to focus on the detailed quantitative analysis of the problems. Expressive power, flexibility and the capability of efficiently handling large traces are key features addressed in the design of Paraver. The clear and modular structure of Paraver plays a significant role towards achieving these targets. Paraver is a very flexible data browser that is part of the CEPBA-Tools toolkit. Its analysis power is based on two main pillars. First, its trace format has no semantics; extending the tool to support new performance data or new programming models requires no changes to the visualizer, just to capture such data in a Paraver trace. The second pillar is that the metrics are not hardwired on the tool but programmed. To compute them, the tool offers a large set of time functions, a filter module, and a mechanism to combine two time lines. This approach allows displaying a huge number of metrics with the available data. To capture the experts knowledge, any view or set of views can be saved as a Paraver configuration file. After that, re-computing the view with new data is as simple as loading the saved file. The tool has been demonstrated to be very useful for performance analysis studies, giving much more details about the applications behaviour than most performance tools. Some Paraver features are the support for: Detailed quantitative analysis of program performance Concurrent comparative analysis of several traces Customizable semantics of the visualized information Cooperative work, sharing views of the tracefile Building of derived metrics

ParaView is an open-source, multi-platform data analysis and visualization application. ParaView users can quickly build visualizations to analyze their data using qualitative and quantitative techniques. The data exploration can be done interactively in 3D or programmatically using ParaView’s batch processing capabilities. ParaView was developed to analyze extremely large datasets using distributed memory computing resources. It can be run on supercomputers to analyze datasets of petascale as well as on laptops for smaller data. ParaView is an application framework as well as a turn-key application. The ParaView code base is designed in such a way that all of its components can be reused to quickly develop vertical applications. This flexibility allows ParaView developers to quickly develop applications that have specific functionality for a specific problem domain. ParaView runs on distributed and shared memory parallel and single processor systems. It has been successfully deployed on Windows, Mac OS X, Linux, SGI, IBM Blue Gene, Cray and various Unix workstations, clusters and supercomputers. Under the hood, ParaView uses the Visualization Toolkit (VTK) as the data processing and rendering engine and has a user interface written using Qt® The goals of the ParaView team include the following: Develop an open-source, multi-platform visualization application. Support distributed computation models to process large data sets. Create an open, flexible, and intuitive user interface. Develop an extensible architecture based on open standards.

The Perturbational Complexity Index (PCI) was recently introduced to assess the capacity of thalamocortical circuits to engage in complex patterns of causal interactions. While showing high accuracy in detecting consciousness in brain-injured patients, PCI depends on elaborate experimental setups and offline processing, and has restricted applicability to other types of brain signals beyond transcranial magnetic stimulation and high-density EEG (TMS/hd-EEG) recordings. We aim to address these limitations by introducing PCIST, a fast method for estimating perturbational complexity of any given brain response signal. PCIST is based on dimensionality reduction and state transitions (ST) quantification of evoked potentials. The index was validated on a large dataset of TMS/hd-EEG recordings obtained from 108 healthy subjects and 108 brain-injured patients, and tested on sparse intracranial recordings (SEEG) of 9 patients undergoing intracranial single-pulse electrical stimulation (SPES) during wakefulness and sleep. When calculated on TMS/hd-EEG potentials, PCIST performed with the same accuracy as the original PCI, while improving on the previous method by being computed in less than a second and requiring a simpler set-up. In SPES/SEEG signals, the index was able to quantify a systematic reduction of intracranial complexity during sleep, confirming the occurrence of state-dependent changes in the effective connectivity of thalamocortical circuits, as originally assessed through TMS/hd-EEG. PCIST represents a fundamental advancement towards the implementation of a reliable and fast clinical tool for the bedside assessment of consciousness as well as a general measure to explore the neuronal mechanisms of loss/recovery of brain complexity across scales and models.

PIPSA (Protein Interaction Property Similarity Analysis) is a method to compare proteins according to their interaction properties. PIPSA may assist in function assignment, and the estimation of binding properties and enzyme kinetic parameters. The PIPSA webserver, webPIPSA, computes protein electrostatic potentials and corresponding similarity indices for a user-defined set of proteins. The standalone code, multipipsa, which includes a python wrapper, provides further options, including running PIPSA on multiple sites on a protein and performing a comparative analysis of the binding properties of user-defined groups of proteins.

Platform for Human Imaging (PHI)

The PLIViewer is visualization software for 3D-Polarized Light Imaging (3D-PLI), to interactively explore the scalar and vector datasets; it provides additional methods to transform data, thus revealing new insights that are not available in the raw representations. The high resolution provided by 3D-PLI produces massive, terabyte-scale datasets, which makes visualization challenging. The PLIViewer tackles this problem by providing functionality to select areas of interests from the dataset, and options for downscaling. It makes it possible to interactively compute and visualize Orientation Distribution Functions (ODFs) and polar plots from the vector field, which reveal mesoscopic and macroscopic scale information from the microscopic dataset without significant loss of detail. The PLIViewer equips the neuroscientist with specialized visualization tools needed to explore 3D-PLI datasets through direct and interactive visualization of the data.

This repository provides the MATLAB implementation of two complementary computational tools—the Leading Eigenvector Dynamics Analysis (LEiDA) framework and the whole-brain Hopf model—used in the study “Re-awakening the brain: Forcing transitions in disorders of consciousness by external in silico perturbation” (Dagnino et al., 2024, PLoS Computational Biology). The study investigates dynamic brain state transitions in patients with disorders of consciousness (DoC), including unresponsive wakefulness syndrome (UWS) and minimally conscious state (MCS), using both model-free and model-based approaches. The LEiDA framework extracts probabilistic metastable substates (PMS) from empirical resting-state fMRI data to characterize clinical phenotypes. The Hopf whole-brain model simulates large-scale dynamics informed by structural and functional connectivity, enabling in silico perturbation to evaluate regional sensitivity and transitions between low- and high-consciousness states. This work supports mechanistic insights into consciousness recovery and the design of computational neurostimulation strategies. For code structure and usage instructions, see the full README file: README.md (https://github.com/decolab/reawakening_DoC/blob/main/README.md)

PoSCE (Population Shrinkage Covariance Embedding) is a functional connectivity estimator from rfMRI (resting-state functional Magnetic Resonance Images) timeseries. It relies on the Riemannian geometry of covariances and integrates prior knowledge of covariance distribution over a population. This is an implementation of the work introduced in: M. Rahim, B. Thirion and G. Varoquaux. Population shrinkage of covariance (PoSCE) for better individual brain functional-connectivity estimation, in Medical Image Analysis (2019).

PyCOMPSs is the Python binding of COMPSs, a programming model and runtime which aims to ease the development of parallel applications for distributed infrastructures, such as Clusters and Clouds. The Programming model offers a sequential interface but at execution time the runtime system is able to exploit the inherent parallelism of applications at task level. The framework is complemented by a set of tools for facilitating the development, execution monitoring and post-mortem performance analysis. A PyCOMPSs application is composed of tasks, which are methods annotated with decorators following the PyCOMPSs syntax. At execution time, the runtime builds a task graph that takes into account the data dependencies between tasks, and from this graph schedules and executes the tasks in the distributed infrastructure, taking also care of the required data transfers between nodes.

GAlib works on adjacency matrices, represented as 2D numpy arrays. This choice certainly limits the size of the networks that the library can handle but it also allows to exploit the powers of numpy to manipulate arrays and boost the performance far beyond pure Python code. As a result, GAlib is simple to use and to extend; easy to read, access and modify. It has no hidden code, so you always know what every function actually does. GAlib includes I/O and statistics tools, and a large set of functions for the analysis of graphs including clustering, distances and paths, matching index, assortativity, roles of nodes in modular networks, rih-club coefficients, K-core decomposition, etc. It also includes functions to generate random networks of different types, randomizing networks, as-well-as many examples and ready-to-use scripts useful also for complete beginners.

Find a set of differentially expressed genes between two user defined volumes of interest based on JuBrain maps. The tool downloads expression values of user specified sets of genes from Allen Brain API. Then, it uses zscores to find which genes are expressed differentially between the user specified regions of interests. This tool is available as a Python package.

The PyJUSBB are bunch of python-based scripts that give a sample of individuals, identifies associations between summary measures of gray matter volume (extracted from preprocessed (with CAT12 software: http://www.neuro.uni-jena.de/cat/) T1Weighted data) and a broad range of behavioural scores. The tools further provide a ranking of the top correlating scores and assess stability of the outcomes within two independent sample of age and sex-matched individuals from the whole sample. The output is either a Figure or a CSV file.

PyNN (pronounced 'pine') is a simulator-independent language for building neuronal network models. In other words, you can write the code for a model once, using the PyNN API and the Python programming language, and then run it without modification on any simulator that PyNN supports (currently NEURON, NEST and Brian 2) and on a number of neuromorphic hardware systems. The PyNN API aims to support modelling at a high-level of abstraction (populations of neurons, layers, columns and the connections between them) while still allowing access to the details of individual neurons and synapses when required. PyNN provides a library of standard neuron, synapse and synaptic plasticity models, which have been verified to work the same on the different supported simulators. PyNN also provides a set of commonly-used connectivity algorithms (e.g. all-to-all, random, distance-dependent, small-world) but makes it easy to provide your own connectivity in a simulator-independent way. Even if you don't wish to run simulations on multiple simulators, you may benefit from writing your simulation code using PyNN's powerful, high-level interface. In this case, you can use any neuron or synapse model supported by your simulator, and are not restricted to the standard models.

It consists of a set of functionalities that allow possible regional differences in the pyramidal cell architecture to be interactively discovered by combining quantitative morphological information about the structure of the cell with implemented functional models. The key contribution of this tool is the morpho-functional oriented design that allows the user to navigate within the 3D dataset, filter and perform Content-Based Retrieval operations. As a case study, we present a human pyramidal neuron with over 9000 dendritic spines in its apical and basal dendritic trees. Using PyramidalExplorer, we were able to find unexpected differential morphological attributes of dendritic spines at particular compartments of the neuron, revealing new aspects of the morpho-functional organization of the pyramidal neuron.

QCAlign was developed to support the use of the QUINT workflow for high-throughput studies. The QUINT workflow supports spatial analysis of labelling in series of brain sections from mouse and rat based on registration to a reference atlas.

A Python package for handling physical quantities. Quantities is designed to handle arithmetic and conversions of physical quantities, which have a magnitude, dimensionality specified by various units, and possibly an uncertainty. Quantities builds on the popular numpy library and is designed to work with numpy ufuncs, many of which are already supported.

QuickNII is a stand-alone tool for user guided affine spatial registration (anchoring) of sectional image data, typically high resolution microscopic images, to a 3D reference atlas space. QuickNII is one of several tools developed by the Human Brain Project (HBP) with the aim of facilitating brain atlas based analysis and integration of experimental data and knowledge about the human and rodent brain. A key feature in the tool is the capability to generate user defined cut planes through the atlas templates, matching the orientation of the cut plane of the 2D experimental image data. The reference atlas is transformed to match anatomical landmarks in the corresponding experimental images. In this way, the spatial relationship between experimental image and atlas is defined, without introducing transformations in the original experimental images. Following anchoring of a limited number of sections containing key landmarks, transformations are propagated across the entire series of images to reduce the amount of manual steps required.

The QUINT workflow comprises a suite of software designed to support atlas-based quantification. All the software have user interfaces, with no coding ability required. It generates object counts and percentage coverage per atlas-region, in addition to point clouds for visualising the features in 3D.

The Waxholm Space rat brain atlas is a detailed volumetric atlas of the rat brain, to which a wide range of anatomical and functional data have been registered, including detailed data showing cellular distributions, axonal pathways, and gene expression patterns. EBRAINS provides a visualization interface, enabling researchers to explore and compare different aspects of the rat brain in 3D space.

Genetically-encoded biosensors are heavily used in biology to monitor biological processes in real time within living cells. Many of such biosensors use two different emission wavelengths that change in opposite directions: the biological signal is measured as a change in the ratio of these two emissions. This so-called ratiometric quantification is standard and applies to many situations. Ratioscope, which runs in the Igor Pro environment, offers two packages: Ratio analysis of fluorescence images: image corrections, display in pseudocolor, measurements, kymograph, analysis of periodic activity, movies... Fusion module: statistics on series of experiments, to compare different experimental conditions; generate editor-ready graphs and plots.

The Remote Connection Manager (RCM) is an application that wraps vnc client. It allows HPC-users to perform remote visualization on HPC clusters. The tool offers to: Visualize the data produced on Cineca’s HPC systems (scientific visualization); Analyse and inspect data directly on the systems; Debug and profile parallel codes running on the HPC clusters. Debugging and profiling tools have to be interfaced to the compute nodes which execute the parallel code; they can benefit from tools enabling a graphic connection to the compute nodes. Scientific visualization can exploit the hardware (GPUs, memory and CPUs) available on the server side, enabling the user to remotely access their data and display them in an efficient way on their local client. The graphical interface of RCM allows the HPC users to easily create remote displays and to manage them (connect, kill, refresh).

ReMoToo is a system service that is able to stream the desktop to web remote clients, making it possible to have interactive sessions over remote high performance systems or even regular systems through a standard web browser. The key aspects of ReMoToo are the high quality visualization it provides as well as its low latency. To achieve it, ReMoToo uses video compression on the server side and sends the generated video stream to the client in a transparent and easy way. On the server side, several ReMoToo instances are managed by another service called ReMoLON. This service is in charge of the initiation, control and stop of ReMoToo visualization streams. The ReMoLON system service is connected through the ReMoLON_FrontEnd, a simple web server running on the login node/s. This FrontEnd is in charge of the user authentication and configuration of the ReMoToo instances through the ReMoLON system services.

An R package that solves a series of initial value problems in C via the GNU scientific library (ode solvers). The C code calls gsl_odeiv2 module functions to solve the problem or problems. The goal is to offload as much work as possible to the C code and keep the overhead minimal. That is why this package expects to solve a set of problems, rather than one, for the same model file (varying in e.g.: initial conditions, or parameters). The package contains 3 interface functions, they accept different ways of defining a set of problems,each with their own drawbacks and advantages. The interface functions are described in the following Sections. The ODE has to exist as a shared library (.so) file (currently in the current working directory: ?setwd and ?getwd ). There are some assumptions we make about the contents of the shared library file. Here we assume that the solutions serve some scientific purpose and the lab experiments come with observables, some measureable values that depend on the system's state (but are not the full state vector). We call the part of the model that calculates the observables ${ModelName}_func() (vfgen also calls them Functions of the model).

This toolbox is aimed to retrieve the onsets of pseudo-events triggering an hemodynamic response from resting state fMRI BOLD voxel-wise signal. It is based on point process theory, and fits a model to retrieve the optimal lag between the events and the HRF onset, as well as the HRF shape, using a choice of basis functions (the canonical shape with two derivatives, (smoothed) Finite Impulse Response, mixture of gammas).

RTNeuron is a scalable real-time rendering tool for the visualisation of neuronal simulations based on cable models. Its main utility is twofold: the interactive visual inspection of structural and functional features of the cortical column model and the generation of high quality movies and images for presentations and publications. The package provides three main components: A high level C++ library. A Python module that wraps the C++ library and provides additional tools. The Python application script rtneuron-app.py A wide variety of scenarios is covered by rtneuron-app.py. In case the user needs a finer control of the rendering, such as in movie production or to speed up the exploration of different data sets, the Python wrapping is the way to go. The Python wrapping can be used through an IPython shell started directly from rtneuron-app.py or importing the module rtneuron into own Python programs. GUI overlays can be created for specific use cases using PyQt and QML.

Convert a model that has been hand written in the Sbtab format to VFGEN's format, NEURON's MOD file format, and optionally SBML (this is done if libsbml is installed with R bindings). This model conversion tool can be used by scientists working in the field of systems biology and all adjacent fields that work with ordinary differential equation (ODE) models. It can be helpful when collaborating with other researchers as it keeps the model separate from any programming language choice. The user writes the model in SBtab form, a simple, human readable format; afterwards this SBtab model can be converted to an ODE and further processed via vfgen (an alternative to vfgen is being worked on, if needed). The final result is code for the ODE right hand side function and analytical jacobian function (among other things) in the chosen programming language. This tool prepares a model M for use in numerical analysis application such as parameter estimation

SCAIView-NEURO is an semantic search engine especially built for translational neurodegeneration research. It supports literature mining in PubMed abstracts and PubMedCentral full text publications.

Scalasca is a software tool that supports the performance optimization of parallel programs by measuring and analyzing their runtime behavior. The analysis identifies potential performance bottlenecks – in particular those concerning communication and synchronization – and offers guidance in exploring their causes. Scalasca supports the performance optimization of simulation codes on a wide range of current HPC platforms. Its powerful analysis and intuitive result presentation guides the developer through the tuning process. Scalasca targets mainly scientific and engineering applications based on the programming interfaces MPI and OpenMP, including hybrid applications based on a combination of the two. The tool has been specifically designed for use on large-scale systems including IBM Blue Gene and Cray XT, but is also well suited for small- and medium-scale HPC platforms.

Score-P is a software system that provides a measurement infrastructure for profiling, event trace recording, and online analysis of High Performance Computing (HPC) applications. It is being developed with the objective of creating a common basis for several complementary optimization tools in the service of enhanced scalability, improved interoperability, and reduced maintenance cost. Currently, it works with the analysis tools Cube, Extra-P, Periscope, Scalasca Trace Tools, Vampir, and Tau and is open for other tools.

SDA (Simulation of Diffusional Association) is a Brownian dynamics simulation software package for the simulation of the diffusion of biomacromolecules in aqueous solution. SDA can be used to compute bimolecular diffusional association rate constants and to predict the structures of diffusional encounter complexes. It can also be used to simulate dilute or concentrated protein solutions and to investigate the adsorption of proteins to solid surfaces. SDA7 is available for standalone use and a subset of the functionality is implemented in the webSDA webserver.

SDA7 can be used to carry out Brownian dynamics simulations of the diffusional association in a continuum aqueous solvent of two solute molecules, e.g. proteins, or of a solute molecule to an inorganic surface. SDA7 can also be used to simulate the diffusion of multiple proteins, in dilute or concentrated solutions, e.g., to study the effects of macromolecular crowding. If the 3D structure of the bound complex is unknown, SDA can be used for rigid-body docking to predict the structure of the diffusional encounter complex or the orientation in which a protein binds to a surface. The configurations obtained from SDA can subsequently be refined by running molecular dynamics simulations to obtain structures for fully bound complexes. If the 3D structure of the bound complex is known, SDA can be used to calculate bimolecular association rate constants. It can also be used to record Brownian dynamics trajectories or encounter complexes and to calculate bimolecular electron transfer rate constants. While these Brownian dynamics simulations are usually carried out with rigid solutes, in SDA7 we give a possibility to assign more than one conformation to each solute molecule. This allows some large-scale internal dynamics of macromolecules to be considered in the simulations. In this SDA distribution, there is a single executable, sda_flex, which will execute different types of simulation: Compute the bimolecular diffusional association rate constant for 2 solutes using a user-defined set of intermolecular contact distances as reaction criteria Compute the rate constants for electron transfer from the relative diffusion of two proteins Perform rigid-body docking of two macromolecules Perform rigid-body docking of a solute and a surface Calculate the time during which user-defined contacts are maintained; this gives an approximation for the lifetimes of a complex. The starting configurations may be from a crystal structure or recorded from a simulation Re-calculate energies for a recorded set of configurations Compute PMFs for protein/surface binding Perform simulations of the diffusion of multiple proteins The simulations can be run in serial or in parallel mode on a shared-memory computer architecture.

SeriesZoom is one of several tools developed by the Nesys laboratory, University of Oslo and participating to EBRAINS with the aim of facilitating brain atlas based analysis and integration of experimental data and knowledge about the human and rodent brain. SeriesZoom is an online viewer, typically used for high resolution histological images. Building on the open standard Deep Zoom Image (DZI) format, it is able to efficiently visualise very large brain images in the gigapixel range, allowing to zoom from common, display-sized overview resolutions down to the microscopic resolution without downloading the underlying very large image dataset.

siibra-api is an HTTP API for querying and retrieving contents of EBRAINS atlases. Originally built as a backend service for the interactive atlas viewer siibra-explorer, the API has been documented for connecting the brain atlases to other applications and web services.

siibra-explorer is built around an interactive 3D view of the brain displaying a unique selection of detailed templates and parcellation maps for the human, macaque, rat or mouse brain, including BigBrain as a microscopic resolution human brain model at its full resolution of 20 micrometres.

The Python library siibra-python is designed for integrating EBRAINS atlases into scripts and computational workflows. Besides providing programmatic access to all functionalities available in the interactive viewer siibra-explorer, it enables more advanced utilization of atlas information.

The current version of the Single Cell Model Builder Notebook implements a Use Case of the Brain Simulation Platform. It allows to select among self-consistent configuration files from previous optimizations. The user may choose and visualize an existing morphology from HBP data, choose a self-consistent set of configuration files for the chosen morphology, visualize the electrophysiological features that will be used as reference by the optimization process, visualize and change the parameters of an existing optimization, configure the BluePyOpt optimization algorithm and run the optimization procedure on CSCS and NSG systems. The Use Case allows the user also to choose either a previous optimization from a CSCS container; or choose the result of his/her own optimization from the Collab storage, and then run and save an analysis of the results.

The current version of the Single Cell Model ReBuilder Notebook implements a Use Case of the Brain Simulation Platform. It allows to select models obtained in previous optimizations. The user may visualize the electrophysiological features for the chosen model, that will be used as reference by the optimization process, visualize and change parameters of an existing optimization, configure the BluePyOpt optimization algorithm and run the optimization procedure on CSCS and NSG systems. The Use Case allows the user also to choose either a previous optimization from a CSCS container; or choose the result of his/her own optimization from the Collab storage, and then run and save an analysis of the results.

Using the Job Submit Plugin API of the Slurm Workload Manager this plugin is intended for use in a multi-tiered storage cluster. Having considered two storage tiers, called low performance storage (lps) and high performance storage (hps), this plugin allows for the co-allocation of compute and data resources by passing the job storage requirements of jobs individually.

A fully spiking solution of constraint satisfaction problem.

SNT is ImageJ's framework for semi-automated tracing, visualization, quantitative analyses and modeling of neuronal morphology distributed with Fiji. SNT supports modern multi-dimensional microscopy data, features advanced visualization and quantification tools, and interacts with all major morphology databases. All aspects of the program can be controlled from a user-friendly interface or programmatically, using several of Fiji's supported scripting languages.

Snudda is a tool that allows the user to place neurons within multiple volumes, then performs touch detection to infer where putative synapses are based on reconstructed neuron morphologies. To match experimental pair-wise recordings the putative synapses are then pruned to get the final set of synapses. Using neuron models optimised with BluePyOpt the entire network can be simulated using the NEURON simulator.

The SpiNNaker Allocation Service (Spalloc) allows the board of the SpiNNaker 1Million machine to be split up into user allocations of groups of a number of connected boards. These boards are isolated from the rest of the machine by the service, ensuring that one user’s simulation does not interfere with another. The service allows users to log in using EBRAINS usernames and passwords to see and control their existing allocations. The service also provides a proxy connection to the boards using websockets, which allows the allocation to be used from anywhere in the world. This is used by the SpiNNaker software to enable access to the machine from the EBRAINS Jupyter lab.

Spectralsegmentation is a pipeline that can be used to detect active neurons and dendrites in ca-imageing data. A series of steps are defined to achieve this. After image stabilization and transposing an image sequence to the (time x pixel) space, Cross-spectral analysis is applied to low frequency(<1Hz) decimated pixel traces. This results in images representing the cross spectral power of each pixel with it's surrounding pixels at increasing frequency components (0.017Hz steps - 0.4Hz). These images are used to define preliminary ROIs using morphological criteria. The ROIs are then constrained to contain only pixels with possitive correlations. The pipeline includes a graphical user interface to edit the automatically extracted ROIs, to add new ones or delete ROIs by further constraining their properties.

Helper library for spike-based sampling in PyNN-supported neural simulators. Spike-based-sampling, sbs, is a software suite that takes care of calibrating spiking neurons for given target distributions and allows the evaluation of these distributions as they are produced by stochastic spiking networks.

Spikify is a Python package designed to transform raw signals into spike trains that can be fed into Spiking Neural Networks (SNNs). This package implements a variety of spike encoding techniques based on recent research to facilitate the integration of time-varying signals into neuromorphic computing frameworks. Spiking Neural Networks (SNNs) are a novel type of artificial neural network that operates using discrete events (spikes) in time, inspired by the behavior of biological neurons. They are characterized by their potential for low energy consumption and computational cost, making them suitable for edge computing and IoT applications. However, traditional digital signals must be encoded into spike trains before they can be processed by SNNs. This package provides a suite of spike encoding techniques that convert time-varying signals into spikes, enabling seamless integration with neuromorphic computing technologies. The encoding techniques implemented in this package are based on the research article: "Spike Encoding Techniques for IoT Time-Varying Signals Benchmarked on a Neuromorphic Classification Task" (Forno et al., 2022).

Simulate or emulate spiking neural networks on SpiNNaker. Models and simulation experiments can be described in a Python script using the PyNN API and submitted either through the EBRAINS Collaboratory website or via our web API (python client available). Results can be viewed via browser and downloaded as data files for analysis, making use e.g. of the data analysis capabilities EBRAINS offers. For real time SpiNNaker simulations, direct use in a neurorobotics simulated environment is also possible.

It is based on the Neo library, which enables it to load a wide variety of data formats used in electrophysiology. At its core, Spyke Viewer includes functionality for navigating Neo object hierarchies and performing operations on them. A central design goal of Spyke Viewer is flexibility. For this purpose, it includes an embedded Python console for exploratory analysis, a filtering system, and a plugin system. Filters are used to semantically define data subsets of interest. Spyke Viewer comes with a variety of plugins implementing common neuroscientific plots (e.g. rasterplot, peristimulus time histogram, correlogram, and signal plot). Custom plugins for other analyses or plots can be easily created and modified using the integrated Python editor or external editors. Users can download and share additional plugins and other extensions at the Spyke Repository. Among the extensions hosted at the site are plugins for spike detection and spike sorting.

sPyNNaker is a software package for simulating PyNN-defined spiking neural networks (SNNs) on the SpiNNaker neuromorphic platform. Operations underpinning realtime SNN execution are presented, including an event-based operating system facilitating efficient time-driven neuron state updates and pipelined event-driven spike processing. Preprocessing, realtime execution, and neuron/synapse model implementations are discussed, all in the context of a simple example SNN. Simulation results are demonstrated, together with performance profiling providing insights into how software interacts with the underlying hardware to achieve realtime execution. System performance is shown to be within a factor of 2 of the original design target of 10,000 synaptic events per millisecond, however SNN topology is shown to influence performance considerably. A cost model is therefore developed characterizing the effect of network connectivity and SNN partitioning. This model enables users to estimate SNN simulation performance, allows the SpiNNaker team to make predictions on the impact of performance improvements, and helps demonstrate the continued potential of the SpiNNaker neuromorphic hardware.

The SSB Toolkit is a Python library specifically designed for conducting simulations of mathematical models that represent the signal-transduction pathways of G-protein coupled receptors (GPCRs). This library consists of a set of systems biology simulation routines, enabling the investigation of pharmacodynamic models associated with GPCRs. It provides a means to explore how the structural characteristics of these receptors influence subcellular signaling dynamics.

STEPS is a package for exact stochastic simulation of reaction-diffusion systems in arbitrarily complex 3D geometries. Our core simulation algorithm is an implementation of Gillespie's SSA, extended to deal with diffusion of molecules over the elements of a 3D tetrahedral mesh. While it was mainly developed for simulating detailed models of neuronal signaling pathways in dendrites and around synapses, it is a general tool and can be used for studying any biochemical pathway in which spatial gradients and morphology are thought to play a role. STEPS also supports accurate and efficient computational of local membrane potentials on tetrahedral meshes, with the addition of voltage-gated channels and currents. Tight integration between the reaction-diffusion calculations and the tetrahedral mesh potentials allows detailed coupling between molecular activity and local electrical excitability. We have implemented STEPS as a set of Python modules, which means STEPS users can use Python scripts to control all aspects of setting up the model, generating a mesh, controlling the simulation and generating and analyzing output. The core computational routines are still implemented as C/C++ extension modules for maximal speed of execution. STEPS 3.0.0 and above provide early parallel solution for stochastic spatial reaction-diffusion and electric field simulation. STEPS 3.6.0 and above provide a new set of APIs (API2) to speedup STEPS model development. Models developed with the old API (API1) are still supported.

The toolset includes interoperable modules for: model building, calibration (parameter estimation) and model analysis. All information needed to perform these tasks are stored in a structured, human- and machine-readable file format based on SBtab. This information includes: models, experimental calibration data and prior assumptions on parameter distributions. The toolset enables simulations of the same model in simulators with different characteristics, e.g. STEPS, NEURON, MATLAB’s Simbiology and R via automatic code generation.

This tool allows import of SBML model files from the subcellular model building and calibration toolset workflow or other external sources. The tool allows users to setup and configure BioNetGen and STEPS simulations. Users can populate mesh models of spines and other neural structures, and run stochastic simulations of signalling pathways.

The subcellular application was designed as a hub web based environment for creation and simulation of reaction-diffusion models integrated with the molecular repository. It allows also to import, combine and simulate existing models expressed with BNGL and SBML languages. Two types of models are supported: rule-based models convenient and computationally efficient for modeling big protein signaling complexes and chemical reaction network models. The subcellular application is integrated with a number of solvers for reaction-diffusion systems of equations. It supports simulation of spatially distributed systems using STEPS (stochastic engine for pathway simulation) – which provides spatial stochastic and deterministic solvers for simulation of reactions and diffusion on tetrahedral meshes. The application provides as well a number of facilities for visualizing the models geometry and the results of the simulations. The molecular repository is a publicly available database of biological information, relevant for brain molecular network modeling. It accommodates several types of biological information which are not available from existing public databases, such as concentrations of proteins in different subcellular compartments of neuronal and glial cells, kinetic data on protein interactions specific for brain and synaptic signaling and plasticity, data on molecules mobility. The repository is integrated with the subcellular application. They share the same set of entities described by BioNetGen expressions. The molecular repository can be queried from the subcellular application and the results of the query can be added to a molecular network model.

This workflow has been developed to tackle the challenge of building and analyzing biochemical pathway models, combining pre-existing tools and custom-made software. At the root of our implementation is the Sbtab format, a file format that can store biochemical models and associated data in an easily readable and expandable way.

Surf Ice is a tool for surface rendering the cortex with overlays to illustrate tractography, network connections, anatomical atlases and statistical maps. While there are many alternatives, Surf Ice is easy to use and uses advances shaders to generate stunning images. It supports many popular mesh formats [3ds, ac3d, BrainVoyager (srf), ctm, Collada (dae), dfs, dxf, FreeSurfer (Asc, Srf, Curv, gcs, Pial, W), GIfTI (gii), gts, lwo, ms3d, mz3, nv, obj, off, ply, stl, vtk], connectome formats (edge/node) and tractography formats [bfloat, pdb, tck, trk, vtk]. Surf Ice uses three stages to draw your image. The first two stages are computed in 3D and create both an image (left column) and a depth buffer (right column). The first stage draws all the items, while the second stage omits the background anatomical image. The final stage uses the 2D outputs of the prior stages. The depth map from the first stage is used to estimate ambient occlusion (SSAO), and the difference between the depth maps from the previous stages allows the software to infer the depth of the overlays behind the background (depth). The SSAO and depth images are composited with the images from the first two stages to generate the final image.

The Synaptic events fitting Notebook implements a Use Case of the Brain Simulation Platform. Starting from any given model description (.mod file) in the NEURON simulation environment, the procedure exploits user-defined constraints, dependencies, and rules for the parameters of the model to fit the time course of individual spontaneous synaptic events that are recorded experimentally. The traces and the model are stored in the Knowledge Graph. The user can run the fitting procedure using UNICORE authentication on JURECA or on the NSG, check the job status and download and analyse the results.

This software is developed in a jupyter notebook inside Collaboratory v1 of the HBP. It allows a user to configure and test, through an intuitive GUI, different synaptic plasticity models and protocols on any of the single cell optimized models present in the model catalog. It consists of two tabs: "Config", where the user can specify the plasticity model to use and synaptic parameters such as location, initial weight, activation pattern, additional somatic current injections, or voltage clamp parameter, and "Sim", where the user can define the recording location, weight's evolution, and also the number of simulations to run (to obtain average results). The results are plotted at the end of the simulation and the traces can be downloaded for further analysis.

This repository contains the code to run the model-free and model-based approaches as well as some inputs using the Schaefer 1000 7 RSNs parcellation. The repository is organized in six folders: (1) model-free – whole-brain turbulent-like dynamics; (2) model-based – Hopf whole-brain model with intact structural connectivity; (3) model-based-lesions – Hopf model after simulated attacks; (4) CONN_preprocessing – CONN toolbox denoising outputs; (5) time-series – inputs for model-free/model-based analyses; (6) lesion-masks – code for the simulated attack approach.

A fast implementation of The Virtual Brain brain network simulator is written in C using a host of optimizations that make brain simulation faster parallelized (multithreading) containerized (can be conveniently run e.g. through Docker, Shifter or Singularity, without the need to install dependencies or set up environment) uses the Deco-Wang (aka "ReducedWongWang") neural mass model to simulate local brain region activity as described in Deco et al., 2014, Journal of Neuroscience or Schirner et al., 2018, eLife An overview over TVB-on-EBRAINS services is provided in the preprint https://arxiv.org/abs/2102.05888

Jupyter notebook is a language-agnostic HTML notebook application for Project Jupyter. In 2015, Jupyter notebook was released as a part of The Big Split™ of the IPython codebase. IPython 3 was the last major monolithic release containing both language-agnostic code, such as the IPython notebook, and language specific code, such as the IPython kernel for Python. As computing spans across many languages, Project Jupyter will continue to develop the language-agnostic Jupyter notebook in this repo and with the help of the community develop language specific kernels which are found in their own discrete repos.

The Virtual Brain (TVB) is an open-source platform for constructing and simulating personalised brain network models. The TVB-on-EBRAINS ecosystem includes a variety of prepackaged modules, integrated simulation tools, pipelines and data sets for easy and immediate use on EBRAINS. Process your large cohort databases and use these results to develop potential medical treatments, therapies or diagnostic procedures.

Access the TVB GUI from the Internet and simulate brain network models on HCP. TheVirtualBrain is a framework for the simulation of the dynamics of large-scale brain networks with biologically realistic connectivity. TheVirtualBrain uses tractographic data (DTI/DSI) to generate connectivity matrices and build cortical and subcortical brain networks. The connectivity matrix defines the connection strengths and time delays via signal transmission between all network nodes. Various neural mass models are available in the repertoire of TheVirtualBrain and define the dynamics of a network node. Together, the neural mass models at the network nodes and the connectivity matrix define the Virtual Brain. TheVirtualBrain simulates and generates the time courses of various forms of neural activity including Local Field Potentials (LFP) and firing rate, as well as brain imaging data such as EEG, MEG and BOLD activations as observed in fMRI. TheVirtualBrain is foremost a scientific simulation platform and provides all means necessary to generate, manipulate and visualize connectivity and network dynamics. In addition, TheVirtualBrain comprises a set of classical time series analysis tools, structural and functional connectivity analysis tools, as well as parameter exploration facilities. An overview over TVB-on-EBRAINS services is provided in the preprint https://arxiv.org/abs/2102.05888

Intel® Threading Building Blocks (Intel® TBB) is a widely used C++ library for shared memory parallel programming and heterogeneous computing (intra-node distributed memory programming). The library provides a wide range of features for parallel programming that include: *Generic parallel algorithms *Concurrent containers *A scalable memory allocator *Work-stealing task scheduler *Low-level synchronization primitives Additionally, it fully supports nested parallelism, so you can build larger parallel components from smaller parallel components. To use the library, you specify tasks, not threads, and let the library map tasks onto threads in an efficient manner. It does not require any special compiler support and has ports to multiple architectures that include Intel® architectures and ARM.

Tide (Tiled Interactive Display Environment) is a distributed application that can run on multiple machines to power display walls or projection systems of any size. Its user interface is designed to offer an intuitive experience on touch walls. It works just as well on non touch-capable installations by using its web interface from any web browser. Tide helps users with: Presenting and collaborating on a variety of media such as high-resolution images, movies and pdfs. Sharing multiple desktop or laptop screens using the DesktopStreamer application. Sketching new ideas by drawing on a whiteboard and browsing websites. Interacting with content streamed from remote sources such as high-performance visualisation machines through the Deflect protocol. In particular all Equalizer-based applications as well as Brayns ray-tracing engine have built-in support. Viewing high-resolution, immersive stereo 3D streams on compatible hardware.

Module treem provides data structure and command-line tools for accessing and manipulating the digital reconstructions of the neuron morphology in Stockley-Wheal-Cannon format (SWC).

A viewer that allows users to view brain atlasses on top of a 3d brain model. The Brain Atlas Viewer allows users to inspect the location and shape of different brain regions and their associated function. Brain regions can be selected by anatomy or by function. Descriptions are available in English, Arabic, Hebrew, and German. Regions are annotated with their function. TVB Brain Atlas Viewer is an interactive software that can be operated via touch screen. It was part of the HBP Travelling Exhibition that started in July 2019 at Bloomfield Museum in Jerusalem organized by the HBP Museum Program (SP11). An overview over TVB-on-EBRAINS services is provided in the preprint https://arxiv.org/abs/2102.05888

The TVB pipeline allows neuroscientists to automatically extract structural connectomes from diffusion-weighted MRI data and functional connectomes from fMRI data based on a number of state-of-the-art methods for image processing, tractography reconstruction and connectome generation. Pipeline output can be directly uploaded to The Virtual Brain neuroinformatics platform for large-scale brain simulation. Further pipeline outputs include: raw tractography output (track streamlines), structural (coupling weights and distances) and functional connectomes, region-wise fMRI time series, M/EEG region-wise source activity time series. The pipeline supports the following atlasses: AAL, AAL2, Craddock200, Craddock400, Desikan Killiany, Destrieux, Human Connectome Project Multimodal Parcellation and Perry512. The pipeline is available as a Docker container based on the BIDS MRtrix3 App containing environment and software for connectome extraction (e.g. FreeSurfer, FSL, MRtrix). The container makes use of parallelized software that can be run with multiple threads locally or on supercomputers. Input data must be provided in BIDS format. As a minimum, dwMRI and strucutral MRI scans need to be provided. In addition, the pipeline can process fMRI (region-wise fMRI time courses and functional connectomes), EEG and MEG data (region-wise source activity time courses).

This is an EBRAINS Lab extension providing a file browser for the Data-Proxy straight into Jupyter Lab while bringing the power of drag & drop to manage files from and into local storage, EBRAINS Drive or Data-Proxy (Bucket).

This is a jupyter lab extension which offers a UI component to monitor HPC jobs through Unicore interface. It allows users to easily switch between computing sites, retrieve details about the jobs, and also cancel them.

This is a jupyterlab extension built as a prototype for building EBRAINS (including TVB simulator, Siibra API) workflows in a visual and interactive manner. It extends the already existent Xircuits jupyterlab extension by adding new components and new features on top.

TVB-HPC provides a framework for generating high-performance computational kernels which can be run on HPC systems with or without hardware accelerators for large scale parameter fitting of brain models An overview over TVB-on-EBRAINS services is provided in the preprint https://arxiv.org/abs/2102.05888

TheVirtualBrain - Widgets is a package with somehow generic GUI components, but developed for EBRAINS Showcases in particular. The showcases developed in the last phase of the HBP are meant to illustrate the full potential of technical and scientific features offered by EBRAINS.

UG4 (Unstructured Grids 4) is an extensive, flexible, cross-platform open source simulation framework for the numerical solution of systems of partial differential equations. Using Finite Element and Finite Volume methods on hybrid, adaptive, unstructured multigrid hierarchies, UG4 allows for the simulation of complex real world models (physical, biological etc.) on massively parallel computer architectures. UG4 is implemented in the C++ programming language and provides grid management, discretization and (linear as well as non-linear) solver utilities. It is extensible and customizable via its plugin mechanism. The highly scalable MPI based parallelization of UG4 has been shown to scale to hundred thousands of cores. Simulation workflows are defined either using the Lua scripting language or the graphical VRL interface https://vrl-studio.mihosoft.eu/. Besides that, UG4 can be used as a library for third-party code. Several examples are provided in the Examples application that can be used for simulations of the corresponding phenomena but also serve as demonstration modules for implementing user-defined plugins and scripts. By developing custom plugins, users can extend the functionality of the framework for their particular purposes. The framework provides coupling facilities for the models implemented in different plugins. Key elements of UG4 are: Efficient solvers on distributed, adaptive multigrid hierarchies. A flexible component based discretization system. Efficient support for massively parallel computer architectures. Full scripting support. A modular plugin based architecture.

UNICORE (UNiform Interface to COmputing REsources) provides tools and services for building federated systems, making high-performance computing and data resources accessible in a seamless and secure way for a wide variety of applications in intranets and the internet. UNICORE's server components are installed at the resource provider site (e.g. JSC or CSCS) to provide a set of REST APIs for submitting and managing HPC jobs and related tasks like data access and data movement. UNICORE handles security aspects like federated authentication, user mapping and authorization.

Uncertainty quantification via ABC-MCMC with copulas as well as global sensitivity analysis for ODE models in systems biology. This R package can approximate the posterior probability density of Parameters for Ordinary Differential Equation models. The ABC sampler used here is developed to be fairly model agnostic, but the supplied tool set and R functions specifically target ODEs as they are fast enough to simulate to permit Bayesian methods. Bayesian methods for parameter estimation are resource intensive and therefore require some consideration of efficiency in simulation. Other modeling frameworks exist, with benefits of higher accuracy in specific scenarios (e.g. low molecule count), or reduced complexity (rule based models). We have written a sibling library for R that facilitates the simulation of systems biology specific models using the GNU scientific library solvers (and models written in C). With powerful enough computing hardware, or small enough models, these frameworks can be combined with this package. We write models using the SBtab format and automatically generate C-code as well as R-code for them, the R-code can be used with deSolve (an R package) while the C-code is compatible with gsl_odeiv2 solvers. Code generation is done via SBtabVFGEN (an R package) and vfgen (a standalone software). In addition, we are writing our own substitution for vfgen, to avoid single points of failure. But the model setup phase can be completely sidestepped by writing the C-code manually (or generating it in any other way).

Vaa3D is a handy, fast, and versatile 3D/4D/5D Image Visualization and Analysis System for Bioimages and Surface Objects. It also provides many unique functions that you may not find in other software. It is Open Source, and supports a very simple and powerful plugin interface and thus can be extended and enhanced easily. Vaa3D is cross-platform (Mac, Linux, and Windows). This software suite is powerful for visualizing large- or massive-scale (giga-voxels and even tera-voxels) 3D image stacks and various surface data. Vaa3D is also a container of powerful modules for 3D image analysis (cell segmentation, neuron tracing, brain registration, annotation, quantitative measurement and statistics, etc) and data management. This makes Vaa3D suitable for various bioimage informatics applications, and a nice platform to develop new 3D image analysis algorithms for high-throughput processing. In short, Vaa3D streamlines the workflow of visualization-assisted analysis. Vaa3D can render 5D (spatial-temporal) data directly in 3D volume-rendering mode; it supports convenient and interactive local and global 3D views at different scales... it comes with a number of plugins and toolboxes. Importantly, you can now write your own plugins to take advantage of the Vaa3D platform, possibly within minutes!

The Virtual Brain Inference (VBI) toolkit is an open-source, flexible solution tailored for probabilistic inference on virtual brain models. It integrates computational models with personalized anatomical data to deepen the understanding of brain dynamics and neurological processes. VBI supports fast simulations, comprehensive feature extraction, and employs deep neural density estimators to handle various neuroimaging data types. Its goal is to bridge the gap in solving the inverse problem of identifying control parameters that best explain observed data, thereby making these models applicable for clinical settings. VBI leverages high-performance computing through GPU acceleration and C++ code to ensure efficiency in processing.

A nascent Jax-based package for virtual brain modeling.

This software package offers a solution for epileptogenic zone network (EZN) diagnosis based on stimulation-induced seizures. Estimating the epileptogenic zone network (EZN) is an important part of the diagnosis of drug-resistant focal epilepsy and plays a pivotal role in treatment and intervention. Both invasive SEEG stimulation and non-invasive temporal interference (TI) stimulation are considered as a complementary approach. Inference step is based on STAN.

VIOLA (Visualization Of Layer Activity) is a lightweight, open-source, web-based, and platform-independent application combining and adapting modern interactive visualization paradigms, such as coordinated multiple views, for massively parallel neurophysiological data. It gives an insight into spatially resolved time series such as simulation results of neural networks with 2D geometry. With the multiple coordinated views, an explorative and qualitative assessment of the spatiotemporal features of neuronal activity can be performed upfront of a detailed quantitative data analysis of specific aspects of the data.

DC Explorer, Pyramidal Explorer and Clint Explorer are the core of an application suite designed to help scientists to explore their data. Vishnu is a communication framework that allows them to interchange information and cooperate in real-time. It provides a unique access point to the three applications and manages a database with the users’ data sets.

ViSimpl involves two components: SimPart and StackViz. SimPart is a three-dimensional visualizer for spatio-temporal data that allow spatio/temporal analysis of the simulation data, using particle-based rendering. StackViz illustrates how the electrophysiological variables evolve over time and provides a temporal representation of the data at different aggregation levels. They allow users to visually discriminate the activity of different groups of neurons, and provide detailed information about individual neurons of interest. These components share synchroniszed playback control of the simulation being analyzsed and work together as linked views, although they are loosely coupled and can also be used independently. They are ready to be used with BlueConfig Datasets among other file formats such as specific HDF5 and CSV. VisSimpl can be coupled with NeuroScheme for adding functionality such as navigate through the underlying structure of the data using symbolic representations and different levels of abstraction.

VisuAlign is one of several tools developed by the Human Brain Project (HBP) with the aim of facilitating brain atlas based analysis and integration of experimental data and knowledge about the human and rodent brain. VisuAlign is a tool for applying user-guided nonlinear refinements (inplane) to an existing, affine 2D-to-3D registration, such as created using QuickNII.

Viziphant is a Python module for easy visualization of Neo objects and Elephant results. It provides a high-level API to easily generate plots and interactive visualizations of neuroscientific data and analysis results. This API uses and extends the same structure as in Elephant to ensure intuitive usage for scientists that are used to Elephant.

voluba is an interactive web application which allows anchoring of volumetric image data to large reference image volumes at microscopic resolutions. The application is implemented around a 3D image viewer, and provides multiple reference brain templates as anchoring targets. Users can upload data from their own imaging experiments to a private working space to perform the alignment. The anchoring process includes interactive manipulation of image position, scale, and orientation, flipping of coordinate axes, as well as entering of anatomical point landmark pairs in 3D. From given landmarks, voluba calculates a 4x4 transformation matrix between the source and target image volumes. The transformation can be chosen with different degrees of freedom, including rigid, similarity and affine types. The result can be downloaded in a predefined json format which includes unique coordinate space identifiers. Furthermore, the aligned volume can be opened in the interactive atlas viewer siibra-explorer to link it to brain regions and related informations of the EBRAINS reference atlases.

voluba-mriwarp is a desktop application that integrates whole brain T1-weighted MRI scans into the anatomical context of the Julich Brain Atlas. It incorporates all required components like skull stripping, registration to ICBM MNI152 2009c nonlinear asymmetric space, and detailed analysis with the siibra toolsuite. The corresponding functionalities are provided via open-source tools like HD-BET, ANTs and siibra-python. voluba-mriwarp is primarily designed for Windows 10 but can also be executed on Linux.

VTK is an open-source software system for image processing, 3D graphics, volume rendering and visualization. VTK includes many advanced algorithms (e.g., surface reconstruction, implicit modelling, decimation) and rendering techniques (e.g., hardware-accelerated volume rendering, LOD control). VTK is used by academicians for teaching and research; by government research institutions such as Los Alamos National Lab in the US or CINECA in Italy; and by many commercial firms who use VTK to build or extend products. The origin of VTK is with the textbook "The Visualization Toolkit, an Object-Oriented Approach to 3D Graphics" originally published by Prentice Hall and now published by Kitware, Inc. (Third Edition ISBN 1-930934-07-6). VTK has grown (since its initial release in 1994) to a world-wide user base in the commercial, academic, and research communities.

One of the biggest recent changes in high-performance computing is the increasing use of accelerators. Accelerators contain processing cores that independently are inferior to a core in a typical CPU, but these cores are replicated and grouped such that their aggregate execution provides a very high computation rate at a much lower power. Current and future CPU processors also require much more explicit parallelism. Each successive version of the hardware packs more cores into each processor, and technologies like hyperthreading and vector operations require even more parallel processing to leverage each core’s full potential. VTK-m is a toolkit of scientific visualization algorithms for emerging processor architectures. VTK-m supports the fine-grained concurrency for data analysis and visualization algorithms required to drive extreme scale computing by providing abstract models for data and execution that can be applied to a variety of algorithms across many different processor architectures.

WebAlign is an online tool for spatial registration of histological section images from rodent brains to reference 3D atlases. Different experimental datasets registered to the same reference atlas allows you to spatially integrate, analyse and navigate these datasets within a standardised coordinate system. The output of WebAlign can be used for analysis in the online QUINT workflow. WebAlign is available as an EBRAINS community app, accessible via the EBRAINS Collaboratory. For more information, see: https://wiki.ebrains.eu/bin/view/Collabs/image-registration-and-analysis-demo/

WebWarp is an online tool for nonlinear refinement of spatial registration of histological section images from rodent brains to reference 3D atlases. Webwarp is compatible with registration performed with the WebAlign tool. Different experimental datasets registered to the same reference atlas allows you to spatially integrate, analyse and navigate these datasets within a standardised coordinate system. The output of Webwarp can be used for analysis in the online QUINT workflow.

These Python notebooks reproduce some figures in the following preprint using the libraries pyMOU and NetDynFlow: https://www.biorxiv.org/content/10.1101/531830v2 The notebook 1_MOUEC_Estimation.ipynb should be executed first to tune the model to the fMRI data. The other notebooks can be used for classification and interpretation of the model (using the flow for network analysis). The data files are: BOLD time series in ts_emp.npy structural connectivity in SC_anat.npy ROI labels in ROI_labels.npy ####Notebook 1_MOUEC_Estimation.ipynb This notebook calculates the functional connectivity and the model-based effective connectivity for each session (or run) and subject from the BOLD time series. The model is a multivariate Ornstein-Uhlenbeck (MOU) process, whose estimation procedure is implemented in the pyMOU library. The model estimates and other measures are stored in the form of arrays in the model_param_movie folder. ####Notebooks 2a_ClassificationTasks.ipynb and 2b_ClassificationSubjects.ipynb These notebooks compare the performances of the several type of connectivity measures (including functional and effective connectivity) in identifying cognitive tasks and subjects. They rely on the scikit.learn library. ####Notebook 3a_Flow.ipynb This notebook uses the NetDynFlow library to calculate the flow, which is network-oriented analysis of the MOU model fitted to the BOLD data. The flow corresponds to the input response of the network to perturbation (or stimulation of given regions). The flow captures network effects that arise from the recurrent connectivity, i.e. also taking into account indirect paths between all pairs of regions. ####Notebook 3b_Communities.ipynb This notebook detects communities based on the flow, namely brain regions are grouped together if they exchange strong flow in the network. It also compares the community structure between rest and movie.

Woken provides a web service and an API to execute on demand data analytics and machine learning algorithms encapsulated in Docker containers. Algorithms and their runtime are fetched from the Algorithm Repository, a Docker registry containing approved and compatible algorithms and their runtimes. Woken provides the algorithms with data loaded from a database, monitors the execution of the algorithm other one machine of a cluster, then it collects the result formatted as a PFA document and returns a response to the client. Woken tracks provenance information, runs cross-validation of the models produced by the ML algorithms.

ZetaStitcher was designed to stitch the large volumetric datasets that are produced, for example, with Light-Sheet Microscopy when imaging large samples (such as a whole mouse brain) at high resolution. This tool computes optimal alignment of adjacent tiles by evaluating the cross-correlation of overlapping areas at selected stack depths. This ensures a high throughput, since a large dataset need not be processed in its entirety. Cross-correlation is computed efficiently by means of FFT. The software is fully written in Python and exposes an Application Programming Interface (API) that can be used to perform queries on the stitched dataset for further processing.

The τRAMD (τ-Random Acceleration Molecular Dynamics) technique makes use of RAMD simulations to compute relative residence times (or dissociation rates) of protein-ligand complexes. In the RAMD method, the egress of a small molecule from a target receptor is accelerated by the application of an adaptive randomly oriented force on the ligand. This enables ligand egress events to be observed in short, nanosecond timescale simulations without imposing any bias regarding the ligand egress route taken. Apart from the estimation of relative residence times, the τRAMD method can be used to investigate dissociation mechanisms and characterize transition states by analysing the RAMD trajectories with the MD-IFP (Molecular Dynamics - Interaction Fingerprint) tool. The combined use of τRAMD and MD-IFP may assist the early stages of drug discovery campaigns for the design of new molecules or ligand optimization.