Neuron (software)

Neuron is a simulation environment for modeling individual neurons and networks of neurons. As of version 7.3, Neuron is capable of handling diffusion-reaction models, and integrating diffusion functions into models of synapses and cellular networks.^[1] It was primarily developed by Michael Hines, John W. Moore, and Ted Carnevale at Yale and Duke.

Neuron models individual neurons via the use of sections which are subdivided into individual compartments by the program, instead of requiring the user to manually create the compartments. The primary scripting language that is used to interact with it is hoc but a Python interface is also available. The programs for it can be written interactively in a shell, or loaded from a file. Neuron supports parallelization via the MPI protocol. Also, starting with Neuron 7.0 parallelization is possible via internal multithreaded routines, for use on computers with multiple cores.^[2] The properties of the membrane channels of the neuron are simulated using compiled mechanisms written using the NMODL language or by compiled routines operating on internal data structures that are set up with a GUI tool (Channel Builder).

Neuron along with the analogous software platform GENESIS are used as the basis for instruction in computational neuroscience in many courses and laboratories around the world.

GUI

Neuron features a GUI, accessible to individuals with minimal programming experience. The GUI comes equipped with a builder for single and multiple compartment cells, networks, network cells, channels, and linear electric circuits. Single and multiple compartment cells differ in that multiple compartment cells will features several "sections," each with potentially distinct parameters for dimensions and kinetics. Several tutorials are available on the Neuron website, including those for getting basic models out of the cell, channel, and network builders. With these builders, the user can form the basis of all simulations and models.

Cell Builder

The cell builder menu with the six options visible

When opened, the cell builder presents a menu with six options; Topology, Subsets, Geometry, Biophysics, and Management.

'Topology' allows the user to generate the simplest stick figure structure of the cell. The user can create, connect, reposition, relabel, and delete sections of the cell. These sections form the basis of what will later be defined as functionally distinct areas of the neuron.^[3]

'Subsets' allows the user to define functionally distinct groups of the sections created in the topology menu. Here, several sections all branching from one other can be labeled "dendrites," while another, single section that projects from the same central one can be labeled as the "axon." Subsets also allows the user to define parameters along which certain values are variable as a function across a section. For instance, path length along a subset can be defined as a domain, the functions along which can then be defined at later steps. ^[4][5]

The 'Geometry' window allows the user to select either individual sections, or groups as defined in the topology and subsets options, respectively, and set precise parameters for length, diameter, area, length constant, among others, for that group or section. Any of these values can be set as a function of length or some other parameter of the corresponding section specified in Subsets. Also, in the Geometry section the user can set the number of functional segments in a section, which is a strategy for spatial resolution. The higher the number of segments, the more precisely Neuron can handle a function in a section. These same segments are the points where point process managers can be associated.^[6]

'Biophysics' works similarly to the Geometry window, except that here parameters are defined for kinetic and electro-physiological functions across both subsets and sections. Neuron comes equipped with a probabilistic model of Hodgkin-Huxley giant squid axon kinetics, as well as a function to model passive leak channel kinetics. Both of these functions, and the features they describe, can be added to the membrane of the constructed cell. Values for leak rate, sodium conductance, and potassium conductance can be set for modeling these kinetics and, again, they can be set as functions over a parameterized domain. This is a link to the creation of a function describing differential conductance of several ions, taking the paramaterized path length of a section as a domain, described in a tutorial When channels are built in the channel builder module in Neuron, the channels will become available for implementation in a cell membrane in the Biophysics window. This is a link to the functionality of the Biophysics menu of the cell builder described in a tutorial

The 'Management' menu deals with naming, exporting, importing, and generally managing data of constructed cells.^[7]

Channel Builder With the channel builder, the user can generate both voltage and ligand gated channel models, that can be implemented in the Biophysics section of the cell builder. The channel builder allows both local point channels, generally used for single, large channels whose function is to be modeled, or general channels whose density across the cell can be defined, again, in the cell builder channel. Maximum conductance, reversal potential, ligand sensitivity, ion permeability, as well as precise dynamics of transitional states using activation and inactivation variables, and including differential conductance, can be defined in the channel builder module.^[8] The reference for this page is a tutorial for creating a simple Hodgkin-Huxley model governed gate.

Network and Network Cell Builder Neuron allows for the generation of mixed models, populated with both artificial cells and neurons. Artificial cells essentially function as point processes, described below, except implemented into the network itself. When built, artificial cells require only a point process, with its parameters defined. The network cell builder opens all three of the following a cell builder, a synapse builder, and a network cell module. The cell builder functions exactly as described above, allowing the user to create the structure and dynamics of the network cell. The synapse builder allows one to create and name synapses, using simulated synapse point processes described below as archetypes. Parameters on these point processes can be manipulated to simulate both inhibitory and excitatory synapses. The network cell module is where synapses can be placed on specific segments of the constructed cell, wherein, again, they will behave as point processes, except that they are sensitive to the activity of a pre-synaptic element, to be identified and connected at a later step. Here, the cell can be named and managed as a whole. This is a link to a screenshot of the network builder, with a completed simple network visible. The Network Builder allows the user to create the basic grid of cells in the network, taking previously completed network cells as archetypes. As many duplicates of each already constructed network cell as desired can be used. Connections can be defined, by clicking and dragging, between source cells and target synapses on other cells. The cell containing the target synapse becomes the post-synaptic element, whereas the source cells function as pre-synaptic elements. Weights can be added to define strength of activation of a synapse by the pre-synaptic cell. A plot option appears in this module, which can be activated to open a graph of spikes across time for individual neurons. A tutorial that precisely describes the interface and process of creating a network, step by step, can be found in the following reference. ^[9]

Stimulation and recording The Neuron GUI comes equipped with a slew of simulated tools. Most notably, it includes several "point processes," which are simple functions at a particular segment of a cell. Point processes include simulations of voltage, patch, single electrode, and current clamps, as well as several simulated synapses. Synapse point processes are distinct for their ability to model stimulation intensities that vary non-linearly across time. These can be placed on any segment of any section of a built cell, individual or network, and their precise values, including amplitude and duration of stimulation, delay time of activation in a run,(see below) and time decay parameters (for synapses), can be defined from the point process manager module from the tools list of the main menu. When being implemented into a network as synapses, point process parameters are defined in the synapse builder for a particular network cell.^[10] Graphs describing both voltage, conductance, and current axes over time can be used to describe changes in electrical state at the location of any segment on the cell. Neuron allows for graphs of change at both individual points over time, and across an entire section through time. ^[11][12] To begin a simulation, the user need open the "run control" module, available through the tools tab in the Neuron GUI main menu. Duration of run can be set through this module, and the "Init & Run" button will start the run timer at zero and progress to the set stop time. All point processes, including those standing for cells or synapses artificial neurons, and all graphs operate in this "run" time. This is a link to a tutorial covering rudimentary use of run control, point process managers, and graphs

Examples

This example will create a simple cell, with a single compartment soma and a multi compartment axon. It will have the dynamics of the cell membrane simulated using Hodgkin-Huxley squid axon kinetics. Then, it will stimulate it using a stimulus, and run for 50 ms.

//create two sections, the body of the neuron and a very long axon
create soma, axon

soma {
	//length is set to 100 micrometers	
	L = 100
	//diameter is set to 100 micrometers
	diam = 100
	//insert a mechanism simulating the standard squid Hodgkin–Huxley channels
	insert hh
	//insert a mechanism simulating the passive membrane properties
	insert pas
}
axon {
	L = 5000
	diam = 10
	insert hh
	insert pas
	//the axon shall be simulated using 10 compartments. By default a single compartment is used
	nseg = 10
}

//connect the proximal end of the axon to the distal end of the soma
connect axon(0), soma(1)

//declare and insert a current clamp into the middle of the soma
objref stim
soma stim = new IClamp(0.5)

//define some parameters of the stimulus: delay, duration (both in ms) and amplitude (in nA)
stim.del = 10
stim.dur = 5
stim.amp = 10

//load a default NEURON library file that defines the run routine
load_file("stdrun.hoc")
//set the simulation to run for 50 ms
tstop = 50

//run the simulation
run()

If run from the GUI, a plot can be generated showing the voltage traces starting from the soma and the distal end of the axon. As expected, the action potential at the end of the axon arrives slightly later than it appears in the soma at the point of stimulation. The plot is membrane voltage versus time.

This link is to a zip file that can be opened in Neuron. The init file will use the two .ses files and create a full model of a simple neuron, with a voltage vs time and voltage vs distance across time graphs open and ready to use. The neuron exhibits Hodgkin-Huxley model biophysics, the parameters of which are themselves parameterized by distance from the cell body. The user need simply to press "init&run" to activate the model. Manipulating the "dt" slows the rate of progress of the model with respect to actual time, so that voltage change can be observed more precisely. A tutorial exists for constructing this model, and can be found here.

References

External links

• NEURON software website
• The NEURON Book
• A Neuron tutorial