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.
C++ / Python reader for SONATA circuit files
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.
MLCE stands for Matrix of Lowest Coupling Energies and they can be used to represent the region of the protein lowest dynamically coupled. 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.
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).
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.
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.
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.
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.
Results: 37 - 54 of 108
EBRAINS is open and free. Sign up now for complete access to our tools and services.