<< Main Manual

Tutorial #1. Building and Running a Simple Single-Neuron Simulation

For this example, we are going to use the XPPAUT implementation of the CA1 pyramidal neuron of Golomb, Yue, and Yaari (2006) as a starting point. That results in a neuron that behaves like this:

xpp example

1.1. Building the Simulator Code

IMPORTANT: For the purposes of this and the remaining tutorials we will assume that all the tutorials will be run out of a working directory in the user's home tree called "nne_models". On Linux and MacOS one can create this directory from a terminal application using the following command:

> mkdir ~/nne_models

First, the simulator needs to know how to implement the neuron's equations. We achieve this by defining an .oden file, which is analogous to XPPAUT's .ode files. Save the following block of code in a file called zca.oden in a directory that you wish to run a simulation (use "~/nne_models" for now).

zca.oden:

# Excitatory cortical neurons, 0 [Ca].
#
number C_m=1.0
number pms=3,pns=4
number V_Na=55.0,tau_h=-40.5,tau_n=-27.0
number theta_a=-50.0,sigma_a=20.0,theta_b=-80.0,sigma_b=-6.0,tau_Bs=15.0
number sigma_m=9.5,sigma_h=-7.0,sigma_n=10.0,sigma_z=5.0,sigma_k=7
#
p g_Na=35.0,g_Kdr=6.0,g_L=0.05,I_app=0.661914
p g_A=1.4,g_NaP=0.3,g_Z=1.0
p theta_z=-39.0,tau_Zs=75.0
p phi=10.0, theta_h=-45.0
p theta_m=-30.0,theta_n=-35.0,theta_p=-47.0,sigma_p=3.0
p V_K=-90.0,V_L=-70.0

#
GAMMAF(VV,theta,sigma)=1.0/(1.0+exp(-(VV-theta)/sigma))
#
V'=(-g_L*(V-V_L)-I_Na-I_NaP-I_Kdr-I_A-I_z+I_appx)/C_m
hhs'=phi*(GAMMAF(V,theta_h,sigma_h)-hhs)/(1.0+7.5*GAMMAF(V,tau_h,-6.0))
nns'=phi*(GAMMAF(V,theta_n,sigma_n)-nns)/(1.0+5.0*GAMMAF(V,tau_n,-15.0))
bbs'=(GAMMAF(V,theta_b,sigma_b)-bbs)/tau_Bs
zzs'=(GAMMAF(V,theta_z,sigma_z)-zzs)/tau_Zs
#
I_appx=I_app
#Iappx=if(t<=3.0)then(Iapp)else(0.0)
Minfs=GAMMAF(V,theta_m,sigma_m)
Pinfs=GAMMAF(V,theta_p,sigma_p)
Ainfs=GAMMAF(V,theta_a,sigma_a)
#
I_Na=g_Na*(Minfs^pms)*hhs*(V-V_Na)
I_NaP=g_NaP*Pinfs*(V-V_Na)
I_Kdr=g_Kdr*(nns^pns)*(V-V_K)
I_A=g_A*Ainfs^3*bbs*(V-V_K)
I_z=g_Z*zzs*(V-V_K)
#
init V=-71.81327
init hhs=0.98786
init nns=0.02457
init bbs=0.203517
init zzs=0.00141

This code is very similar to the original zca.ode file used by XPPAUT, except the XPPAUT-specific '@' lines were removed for clarity, and we changed the "VVs" variable to "V" to represent a more conventional name for membrane voltage. We changed the file extension from .ode to .oden to reflect the fact that the .oden file format diverges from XPPAUT's .ode file format in some cases. In most cases, however, XPPAUT .ode files should work without significant adjustments (except for the file extension change). For specific details on the syntax of the .oden file, see the .oden file documentation.

Then, from a terminal, switch to the working directory ("~/nne_models" for the tutorials) and type the following:

> cd ~/nne_models
> nne_build

This will generate the C++ library for this neuron model using the .oden files found in the working directory (called libodens.so.1).

If all goes well, you will now have a library that you can use with the installed NeuronetExperimenter executable to run simulations.

1.2. Running a Simulation

When running a simulation, the executable requires 3 minimum files: a .net file that defines the parameters of each neuron and the arrangement of neuronal connections, a .setup file that describes what to run, and a .exp file that describes how a specific experiment within the simulator should run. Consult the documentation for each file type for further information on the files.

The easiest way to get these files is to use the generated binary to autogenerate stubs of each file. To achieve this do the following:

> nne_run zca

This will generate the following three files for the 'zca' model (comments for you are in blue, and text in red will needed to be changed to reflect those values to get the results we will show below):

zca.setup:

Network zca.net
Dt 0.05 # with a timestep of 0.05
Print Step Size 1 # and should output data every time step
Output t V hhs nns bbs zzs # and should output time and each of the state variables for all the neurons
Experiment control 1 # and should run the experiment in control.exp once

control.exp:

Time: 500 # Indicates the simulator should run 500 ms for this experiment iteration

zca.net:

ID:   1
Name: zca

     Initial conditions:
     V           -71.81327
     hhs         0.98786
     nns         0.02457
     bbs         0.203517
     zzs         0.00141

     Associated Variable Values:
     C_m         1
     I_app       0.661914
     V_K         -90
     V_L         -70
     V_Na        55
     g_A         1.4
     g_Kdr       6
     g_L         0.05
     g_Na        35
     g_NaP       0.3
     g_Z         1
     phi         10
     pms         3
     pns         4
     sigma_a     20
     sigma_b     -6
     sigma_h     -7
     sigma_k     7
     sigma_m     9.5
     sigma_n     10
     sigma_p     3
     sigma_z     5
     tau_Bs      15
     tau_Zs      75
     tau_h       -40.5
     tau_n       -27
     theta_a     -50
     theta_b     -80
     theta_h     -45
     theta_m     -30
     theta_n     -35
     theta_p     -47
     theta_z     -39

Notice that the parameters and initial conditions were pulled directly from the .oden file in the stub generation. This makes it easier to transfer simulations from XPPAUT to NeuronetExperimenter. However, the actual parameters and initial conditions that will be used for a simulation run will be in the .net file. So any of these values can be overwritten in the .net file rather than changing them in the .oden file and rebuilding the simulator. The only time the simulator needs to be rebuilt is when the equations for a model has changed, or new neuron types are added.

Finally, to run the simulation, simply type the following:

> nne_run zca.setup

The simulator will run quickly and the final output is "Saving Network" before terminal control returns to the user. The output data is placed into a subdirectory of the .setup file with the name of the .setup file (in this case simulations/ca1/zca/). In the simulations/ca1/zca/neuron_1.txt file are the values of the state variables as follows:

zca/neuron_1.txt:

t       V       hhs    nns    bbs    zzs
0    -71.7802    0.987335    2.45734e-02    0.203516    1.41e-03
5.e-02   -71.7473    0.986834    2.45831e-02    0.203511    1.41001e-03
0.1    -71.7144    0.986357    2.45986e-02    0.203504    1.41003e-03
0.15    -71.6817    0.985901    2.46194e-02    0.203493    1.41005e-03
... ... ... ... ... ...

'Dt' and 'Print Step Size' in the zca.setup file determines the rate at which these data points are output (in this case 1 row of samples per 0.05 ms).

We can plot the state variables as a function of time, using the following, which matches well the first figure on this page from XPPAUT:

> nne_plotNeuron zca.setup 1

or for brevity (where nne_plotNeuron defaults to using the first .setup file it can find in the directory):

> nne_plotNeuron 1

This completes the example showing a single-neuron simulation in NeuronetExperimenter. In the next tutorial, we will show how to couple this CA1 neuron to another CA1 neuron to achieve synchronous bursting.

>> Tutorial #2. Coupling Neurons through Synaptic Connections