TITLE multiple AMPA receptors
COMMENT
-----------------------------------------------------------------------------
Mechanism for handling multiple presynaptic entries to the same compartment;
up to 1000 synapses can be handled using a different pointer that must be set
for each presynaptic variable using addlink. Optimization algorithm from
Lytton, W.W., Neural Computation, in press, 1996. This mechanism allows
considerable acceleration of the simulation time if many receptors of the same
type must be simulated in the same compartment.
This file was configured for AMPA receptors. The mechanism was a first-order
kinetic model with pulse of transmitter (see Destexhe, A., Mainen, Z. and
Sejnowski, T.J. Neural Computation, 6: 14-18, 1994).
Parameters were obtained from fitting the model to whole-cell recorded AMPA
postsynaptic currents (Xiang et al., Soc Neurosci. Abstracts 18: 1350, 1992).
The fit was performed using a simplex algorithm using short pulses of
transmitter (0.5 mM during 0.3 ms).
-----------------------------------------------------------------------------
EXAMPLE OF HOW TO USE:
create POST,PRE[10] // create compartments
objectvar c // create an object
c = new multiAMPA() // create multiple AMPA kinetic synapses
POST c.loc(0.5) // localize synapse on postsyn compartment
c.gmax = 0.001 // assign max conductance of each syn (mu S)
c.allocate(10) // allocate space for 10 presyn variables
for i=0,9 { // link presynaptic variables
c.addlink(&PRE[i].v)
}
-----------------------------------------------------------------------------
WARNINGS:
- only ok for synaptic mechanisms where all weights are equal
(see Lytton paper for implementation of different weights)
Alain Destexhe, Laval University, 1995
-----------------------------------------------------------------------------
ENDCOMMENT
: defines maximal number of possible links to presynaptic variables
: this number should correpond to the number of pointers pre00, pre01, ...
: defined in the NEURON block
DEFINE MAXSYNAMPA 250
VERBATIM
static int MAXSYNAMPA = 250;
ENDVERBATIM
INDEPENDENT {t FROM 0 TO 1 WITH 1 (ms)}
NEURON {
POINT_PROCESS multiAMPA
NONSPECIFIC_CURRENT i
RANGE Ron, Roff, ri, nsyn, non, g, gmax
GLOBAL Cmax, Cdur, Alpha, Beta, Erev, Prethresh, Deadtime, Rinf, Rtau
}
UNITS {
(nA) = (nanoamp)
(mV) = (millivolt)
(umho) = (micromho)
(mM) = (milli/liter)
}
PARAMETER {
dt (ms)
Cmax = 0.5 (mM) : max transmitter concentration
Cdur = 0.3 (ms) : transmitter duration (rising phase)
Alpha = 0.94 (/ms mM) : forward (binding) rate
Beta = 0.18 (/ms) : backward (unbinding) rate
Erev = 0 (mV) : reversal potential
gmax (umho) : maximum conductance of each synapse
Prethresh = 0 : voltage level nec for release
Deadtime = 1 (ms) : mimimum time between release events
}
ASSIGNED {
on[MAXSYNAMPA] : state of each synapse
TL[MAXSYNAMPA] (ms) : time since last event for each synapse
ri[MAXSYNAMPA] : state variable of each synapse
lastrelease[MAXSYNAMPA] (ms) : last release for each synapse
Ron : sum of all "on" synapses
Roff : sum of all "off" synapses
nsyn : number of synapses
non : number of synapses on
Rinf : steady state channels open
Rtau (ms) : time constant of channel binding
v (mV) : postsynaptic voltage
i (nA) : total current = g*(v - Erev)
g (umho) : total conductance
trel (ms) : temp var
ptr_array_ampa : pointer array
}
INITIAL { LOCAL j
FROM j=0 TO nsyn-1 {
on[j] = 0
TL[j] = -9e9
lastrelease[j] = -9e9
ri[j] = 0
}
Ron = 0
Roff = 0
non = 0
Rinf = Cmax*Alpha / (Cmax*Alpha + Beta)
Rtau = 1 / ((Alpha * Cmax) + Beta)
}
BREAKPOINT {
if(gmax > 0) {
SOLVE release
g = gmax * (Ron+Roff)
i = g*(v - Erev)
} else {
i = 0
}
}
PROCEDURE release() { LOCAL q,j
FROM j=0 TO nsyn-1 { : update Ron, Roff, non for each synapse
trel = ((t - lastrelease[j]) - Cdur) : time since last release ended
if (trel > Deadtime) { : ready for another release?
if (presynaptic(j) > Prethresh) { : spike occured?
on[j] = 1 : start new release
non = non + 1
lastrelease[j] = t : memorize release time
ri[j] = ri[j] * exptable( - Beta * (t-TL[j]))
: evaluate state variable
TL[j] = t : memorize last event
Ron = Ron + ri[j] : increase Ron
Roff = Roff - ri[j] : decrease Roff
if(Roff < 1e-9) { Roff = 0 } : prevent roundoff errors
}
} else if (trel < 0) { : still releasing?
: do nothing
} else if (on[j] > 0) { : end of release ?
on[j] = 0 : stop release
non = non - 1
ri[j] = Rinf + (ri[j]-Rinf) * exptable(- (t-TL[j]) / Rtau)
: evaluate state variable
TL[j] = t : memorize last event
Ron = Ron - ri[j] : decrease Ron
Roff = Roff + ri[j] : increase Roff
if(Ron < 1e-9) { Ron = 0 } : prevent roundoff errors
}
}
if(Roff > 0) { : update Roff
Roff = Roff * exptable(- Beta * dt)
if(Roff < 1e-9) { Roff = 0 } : prevent roundoff errors
}
if(non > 0) { : update Ron
q = non * Rinf
Ron = q + (Ron - q) * exptable(- dt / Rtau)
}
}
FUNCTION exptable(x) {
TABLE FROM -25 TO 25 WITH 10000
if ((x > -25) && (x < 25)) {
exptable = exp(x)
} else {
exptable = 0.
}
}
:FUNCTION exptable(x) {
: TABLE FROM -10 TO 10 WITH 10000
:
: if ((x > -10) && (x < 10)) {
: exptable = exp(x)
: } else {
: exptable = 0.
: }
:}
:FUNCTION exptable(x) {
: if(x > -50) {
: exptable = exp(x)
: } else {
: exptable = 0.
: }
:}
:-------------------------------------------------------------------
: Procedures for pointer arrays in nmodl
: create a pointer array and link its pointers to variables passed
: from hoc (adapted from Mike Hines)
:-------------------------------------------------------------------
VERBATIM
#define ppampa ((double***)(&(ptr_array_ampa)))
extern double* hoc_pgetarg();
ENDVERBATIM
:
: Procedure to allocate space for n pointers
:
PROCEDURE allocate(n) {
VERBATIM
if (*ppampa) {
free(*ppampa);
}
*ppampa = ((double**) hoc_Ecalloc((int)_ln, sizeof(double *))), hoc_malchk();
ENDVERBATIM
}
:
: procedure to get the value of a presynaptic variable
: index is the number of the presynaptic var
:
FUNCTION presynaptic(index) {
VERBATIM
if(_lindex >= nsyn) {
printf("Warning: attempt to use pointer outside range\n");
printf(" trying to use pointer number %d\n",(int)_lindex);
printf(" but number of defined pointers was nsyn=%d.\n",(int) nsyn);
}
_lpresynaptic = *((*ppampa)[(int)_lindex]);
ENDVERBATIM
}
:
: procedure to add a new presynaptic variable
: the address of the variable is passed as argument (from hoc)
: a new pointer is then linked to that variable
:
PROCEDURE addlink() {
VERBATIM
if(++nsyn > MAXSYNAMPA) {
printf("Exceeding maximum of allowed links MAXSYNAMPA=%d\n",MAXSYNAMPA);
printf(" edit the nmodl code to increase the maximum allowed.\n");
exit(-1);
}
(*ppampa)[(int)(nsyn-1)] = hoc_pgetarg(1);
ENDVERBATIM
}