Thanks for choosing NEURON for your research, and asking the questions that prompted
this note.
You need (A) an effective development strategy and (B) a good software pattern to
follow in setting up your own network models. Implicit in the whole enterprise are multiple
issues of policy, including how to manage
--the attributes of a cell
--the synaptic mechanisms that are attached to it
--the mechanics of setting up a connection between two cells
and how to deal with collections of objects. Lacking a good set of policies, it is very easy
to be overwhelmed by details. Given a consistent set of policies, implementing them in
code is almost a rote exercise. Indeed, much of it amounts to boilerplate that can be
generated automatically by a computer.
So how should you proceed?
The first step is to define the elementary properties of the your cell classes. This means
creating and testing models of single cells. At this point, an experienced developer may
wish to begin wrapping these inside templates. However, most users should defer
that until later, because NEURON can do it for you automatically, and in a way that will
save you much time and effort. This is because NEURON has tools that will use your cell
and synapse specifications to create templates, and those templates will also contain
procedures that implement policies for setting up connections between cells.
Once you are satisfied that your artificial spiking cells have the desired dynamics, and
that you can create models of individual biophysical cells with appropriate anatomical and
membrane/cytoplasm properties, it is time to focus on biophysical synaptic mechanisms. It
is best to test these on the simplest testbed possible: a passive single compartment.
After that, it becomes time to create the templates that define the cell classes. The tools
in NEURON's Network Builder suite are good at this. The idea is to use them to specify the
properties of the cell classes that will be involved in the network--including biophysical
model cellls such as yours, and also any artificial spiking cells. The development outline is
Code: Select all
For each class of biophysical model cells {
Bring up a new NetReadyCellGUI tool
and use it to place synaptic mechanisms at appropriate locations
}
If there will be any artificial spiking cell classes {
Bring up an ArtCellGui tool
and use it to define the properties of all artificial spiking cell classes
}
Bring up a Network Builder (NetGUI tool) and use it to create a prototype network by:
1. Spawning one instance of each cell class
2. For each biophysical model cell in the prototype net
attach a spike source to each of its synapses
3. For each artificial spiking cell that is to receive spike events
attach a spike source to it
Click on the Network Builder's "Hoc file" button to export a hoc file
that can be mined for reusable code
The "reusable code" will contain class definitions (templates) for each of your cell classes,
and it will also contain examples of how to set up synaptic connections between them.
If the network will involve more than 3 or 4 different kinds of cell classes, or if individual
cell classes have a large number of synapses, it may be a good idea to set up several
tiny protype nets, each with just a small subset of cell types.
For an introduction to the Network Builder, see the Network Builder tutorial (link on this
page
http://www.neuron.yale.edu/neuron/docs). Chapter 11 of The NEURON
Book contains an example of mining reusable code from an exported hoc file. The
"serial" network implementations in this paper are good examples of how to reuse a
biophysical model cell template, created by the Network Builder, in network models:
Hines, M.L. and Carnevale, N.T. Translating network models to parallel hardware in
NEURON. J. Neurosci. Methods
in press.
http://www.neuron.yale.edu/ftp/ted/neur ... _press.pdf
Source code available from
http://senselab.med.yale.edu/modeldb/Sh ... odel=96444
The code in this paper also provides pretty good software patterns to follow when
developing your own network models. At this stage, you should focus on the serial
implementations
ringser.hoc
and
ran3ser.hoc
In addition, it addresses other important issues, e.g. verification of network architecture,
reproducible implementation of randomization in models, but this is beginning to stray from
your original question . . .
OJAG wrote:to make my pyramidal cells connections . . . [/code]
I think you will find it easier to use a mkcells() / connectcells() approach, as illustrated in
the above paper.
So, I think I am not using an IntFire class
True. Looks like they're all biophysical model cells (they have physical dimensions,
membrane capacitance and conductance(s), and calculate membrane potential by
numerical integration of the cable equation).
But when I try to include two different types (pyramidals and fs interneurons) I can't figure out how to include in the connections its biophysical properties to decide when the input is excitatory (glutamatergic from pyramidals) or inhibitory (gabaergic from interneurons)
. . .
Where should I put these mechanisms:
a. in the cell templates by adding artificial answer to voltage values?
Using the NetReadyCellGUI tool, I'd attach an ExpSyn to each location that is supposed
to have a glutamatergic (AMPAergic) synapse, and give it a reversal potential of 0 mV
and a decay time constant of what? 2 ms? 5 ms? How fast should your AMPAergic
synaptic conductance decay?
I'd use Exp2Syns for the GABAergic synapses, with appropriate time constants
(1 or 2 ms for the fast one, and 5 or 10 ms for the slow? you decide, based on
experimental observations in your particular organism and cell class).
The NetReadyCellGUI tool's SynTypeGUI tool lets you define as many different kinds of
synapses as you like, and rename them as you wish. So if you just have AMPAergic
and GABAergic synapses, you might change the name of ExpSyn to AMPA or E,
and change the name of Exp2Syn to GABA or I. And if you had fast AMPA and slow
AMPA synapses, with different decay time constants, use the SynTypeGUI to make
two ExpSyn classes, then change their names to Ef and Es, give them different values
for tau, etc. as needed (think of it as creating derived classes from the ExpSyn base class).
Clicking on the Network Builder's "Hoc file" button makes it emit hoc code that will contain
a template for each of your different cell classes. Each template will contain code that
specifies the anat & biophys properties of your cell, and also the location and properties
of the synaptic mechanisms that are attached to it. For one example of such a file, see
cell.hoc for the ring network in our JNM paper.
how can I create the synapses and connect the cells once those specificcations are defined.
The templates generated by the Network Builder contain all the boilerplate code that will
automatically create an instance of your cells, with their attached synaptic mechanisms,
when you execute statements of the form
Code: Select all
objref foo
foo = new WhateverCell() // creates a new instance of the WhateverCell class
// complete with all synapses, ready to be driven by NetCons
Please let me know if you have any further questions or suggestions.