Tutorials & E-Library

A large body of experimental data indicates that neuronal membrane properties can be nonuniform. For example, in some cell classes there is evidence that channel densities vary with location in a systematic manner. With the CellBuilder it is possible to specify that channel densities and other biophysical properties are functions of position.

The CellBuilder can be very helpful for specifying the spatial grid and biophysical properties of cell models that are based on detailed morphometric reconstructions. In this tutorial, we will construct a model cell that borrows the anatomy of the pyramidal neuron that is included with NEURON's demonstration program.

These tutorials show how to use the CellBuilder, a powerful and convenient tool for constructing and managing models of individual neurons. Given a conceptual model that has a simple branched topology, we implement a computational model. This introduces material that is helpful in the following tutorials.

These tutorials show how to use the CellBuilder, a powerful and convenient tool for constructing and managing models of individual neurons. The CellBuilder is a "graphical form for specifying the properties of a model cell." It breaks the job of model specification into a sequence of tasks :
1. Setting up model topology (branching pattern).
2. Grouping sections with shared properties into subsets.
3. Assigning geometric properties (length, diameter) to subsets or individual sections, and specifying a discretization strategy (i.e. how to set nseg).
4. Assigning biophysical properties (Ra, cm, ion channels, buffers, pumps, etc.) to subsets or individual sections.

These are the same things we would have to do, and pretty much the same sequence we'd follow, in order to define a model by writing hoc code. However, the CellBuilder helps us keep it all nice and organized, and eliminates a lot of error-prone typgin . . . ptyngi . . . typing.

This outline is based on my first talk at our course "Using the NEURON Simulation Environment" that was presented on Oct. 25, 1997 at the 27th Annual Meeting of the Society for Neuroscience in New Orleans, LA. It will help you get started creating models and managing them with the graphical user interface.

NEURON is an extensible nerve modelling and simulation program. It allows you to create complex nerve models by connecting multiple one-dimensional sections together to form arbitrary neuron morphologies, and allows you to insert multiple membrane properties into these sections (including channels, synapses, and ionic concentrations). The interface was designed to present the neural modeller with an intuitive environment and hide the details of the numerical methods used in the simulation.

This tutorial is divided into 5 parts (A - E) and will take you, step by step, through the process of creating a complex simulation. In part A we start with the basics: how to create a single compartment neuron model with Hodgkin-Huxley conductances, how to run the simulator and how to display the simulation results. In part B we move into the more advanced topics of building multi-compartmental neurons and using different types of graphs to display the results. In part C we will replicate neurons using templates and connect these neurons together. In part D we will add new membrane mechanisms to the simulator and incorporate them in our neurons. Finally, in part E we will look at ways of saving data from the simulations and methods for increasing simulation speed.

This notebook tutorial will guide you through model management with the help of BluePyMM.

Model management consists of three phases:
1. prepare: processing of input data, finding all possible morphology/electrical model combinations (me-combinations), and preparation of a database
2. run: run all me-combinations
3. select: compare all me-combinations against input thresholds, select successful combinations and write them out to file; generate report

You will be learn how to navigate these stages with the following tutorial.

This is the final part of the series where we build a multicompartment cell and evolve it into a network of cells running on a parallel machine (which is basically all computers made within the last decade). On this page, we translate the classes we have previously constructed so that they operate in either a parallel or serial mode.

This is the third part of a tutorial series where we build a multicompartment cell and evolve it into a network of cells running on a parallel machine. In this part, we take the functionality of the ring network we constructed in the previous page and encapsulate it into various classes so that the network is more extensible. We also begin parameterizing the model so that particular values are not hard-coded, but remain variable so that the model is flexible.

This page is the second in a series where we build a multicompartment cell and evolve it into a network of cells running on a parallel machine. In this page, we build a ring network of ball-and-stick cells created in the previous page. In this case, we make N cells where cell n makes an excitatory synapse onto cell n + 1 and the last, Nth cell in the network projects to the first cell. We will drive the first cell and visualize the spikes of the network.

In practice, you will likely want to separate the specification of the cell type and the use of that cell type into separate files, but we'll ignore that here.

This is the first part of a several page tutorial that will ultimately build a ring network of mutlicompartment neurons running on a parallel machine.

Best software engineering practice is to carefully design both the model and code. A well-designed system is easier to debug, maintain, and extend.

This tutorial will take a functional bottom-up approach, building key components and refactoring as needed for a better software design instead of describing a complex design and filling in the pieces.

This part of the tutorial builds a two-compartment neuron consisting of a soma and dendrite. This representation is known as a ball-and-stick model. After building the cell, we will attach some instrumentation to it to simulate and monitor its dynamics.

This example follows the same general approach described for segmenting simulations of a model cell, but the data to be saved is a record of spike times and the associated unique identifiers of the spike sources. The conceptual model is very simple: a spontaneously active cell that fires spikes at random intervals.