about NET_RECEIVE arguments

[OJAG]

Hi Ted,

These are two headings and part of the body of two NET_RECEIVE blocks respectively extracted from one AMPA.mod default NEURON file and another GABA_channel respectively

Code: Select all

NET_RECEIVE(weight, on, r0, t0 (ms)) {
                        :
                        :
                        :

      r0 = r0*exp(-Beta*(t - t0)) : r0 at start of onset state
                        :
                        :
                        :


    r0 = weight*Rinf + (r0 - weight*Rinf)*exp(-(t - t0)/Rtau)
                        :
                        :
                        :
    
    : r0 leaves the "onset" conductance pool,
    :   and joins the "offset" conductance pool
    Ron = Ron - r0
    Roff = Roff + r0
    
    t0 = t
    on = 0

  }
}

and

Code: Select all

NET_RECEIVE(weight,s_tp,tp(ms)) {:tp time of previous spike
	: Calculate current value single synapse state variable at t-epsilon
	UNITSOFF
	:printf("%g  %g\t",t,s_tp)
    s_tp =s_tp*weight*exp(-(t-tp)/tau_d) 
    :printf("%g\t",s_tp)
	UNITSON
	
	 s=s + frac_rec*weight*(1-s_tp)	
         s_tp = s_tp + frac_rec*(1-s_tp)
         tp=t
}
}

In both cases some additional values would be passed within the weight vector to the Netcon object. but when I include both mechanisms at hoc level, I actually pass no different values than the actual weight, so where are they passed to the block or where are they initially defined?..
and the most curious thing is that t0/tp which are of course used within the block are updated at the very end.

Moreover r0 and s_tp are respectively evaluated within the block...

So could you please explain me then the sense of passing these variables within the external arguments to the block and where does it happen?
Thanks a lot


Oscar Javier

[ted]

Oops, somehow I completely missed your question, Oscar. And it's a good one. Sorry about that.

In its most general form, the NET_RECEIVE statement is
NET_RECEIVE (a0, a1, a2 . . . ) {
a0 is generally used to refer to the synaptic strength ("weight"), and for the simplest synaptic mechanisms this is the only item that appears inside the parentheses. If additional ai are present, then each NetCon that targets such a synapse actually has a "weight vector" with storage for as many numerical values as there are items in the parentheses of the NET_RECEIVE statement. This storage is typically used by synaptic mechanisms that have use-dependent plasticity. It allows each NetCon that targets such a mechanism to store "state" information that reflects its past activation history. This state information is calculated inside the NET_RECEIVE block. Each time a new event arrives, the NET_RECEIVE block gets not only the numerical value of a0 but also the numerical values of all the other ai from the weight vector of the NetCon that delivered the event.

This makes it possible for a single instance of the synaptic mechanism to have stream-specific use-dependent plasticity, so that it can represent multiple "real" use-dependent synapses. Without such storage, the state information would have to be preserved in the NET_RECEIVE block, and you'd need a separate synaptic instance for every input stream. For more information about the weight vector, see
http://www.neuron.yale.edu/neuron/stati ... tml#weight