Modeling an external input voltage to the circuit?

Support
1

Hi there!

Say I have a circuit, not unlike the following:

import numpy as np
from brian2 import Synapses, NeuronGroup, ms, mV, Hz, SpikeMonitor, Network, PoissonInput

params = {
    'v_0'       : -52 * mV,               # resting potential
    'v_rst'     : -52 * mV,               # reset potential after spike
    'v_th'      : -45 * mV,               # threshold for spiking
    't_mbr'     :  20 * ms,               # membrane time scale (capacitance * resistance = .002 * uF * 10. * Mohm)
    't_rfc'     : 2.2 * ms,
    'tau'       : 5 * ms,                 # time constant
    'r_poi'     : 150 * Hz,
    'f_poi'     : 250,
    'w_syn'     :0.275 * mV,
    "t_run": 1000 * ms,  # duration of trial
}

if __name__ == '__main__':
    connectivity_matrix = np.asarray([
        [0, 5, 0],
        [0, 0, -2],
        [0, 0, 0],
    ])
    eqs = '''
    dv/dt = (v_0 - v + g) / t_mbr : volt (unless refractory)
    dg/dt = -g / tau               : volt (unless refractory) 
    rfc                            : second
    '''

    neu = NeuronGroup(  # create neurons
        N=len(connectivity_matrix),
        model=eqs,
        method='linear',
        threshold='v > v_th',
        reset='v = v_rst; w = 0; g = 0 * mV',
        refractory='rfc',
        name='default_neurons',
        namespace=params
    )
    neu.v =-52 * mV
    neu.g = 0
    neu.rfc = 2.2 * ms

    sources, targets = connectivity_matrix.nonzero()
    syn = Synapses(neu, neu, 'w : volt', on_pre='g += w', delay=1.8 * ms, name='default_synapses')
    syn.connect(i=sources, j=targets)

    weight_per_synapse = 0.5*mV
    syn.w[:] = connectivity_matrix[(sources, targets)] * weight_per_synapse

    spike_monitor = SpikeMonitor(neu)
    net = Network(neu, syn, spike_monitor, *p_groups)
    net.run(duration=params['t_run'], report="stdout")
    print(spike_monitor.spike_trains().values())

As I understand it, without an Input Stimuli, the neural circuit will still fire over time and all that, based on the equations I put in (yes?). I’m basing this conclusion after reading through a few of the examples, like the IF_curve_Hodgkin_Huxley example. That’s great, if true. However, say I want to simulate what happens to the circuit if I were to apply an external voltage to some (or all) of the neurons, and to see how it affects the dynamics of the system? Sort of if I connected a battery to some neurons in a circuit?

From the documentation in the Input Stimuli page, I see

You can also generate an explicit list of spikes given via arrays using [SpikeGeneratorGroup]This object behaves just like a [NeuronGroup] in that you can connect it to other groups via a [Synapses] object, but you specify three bits of information: N the number of neurons in the group; indices an array of the indices of the neurons that will fire; and times an array of the same length as indices with the times that the neurons will fire a spike. The indices and times arrays are matching, so for example indices=[0,2,1] and times=[1*ms,2*ms,3*ms] means that neuron 0 fires at time 1 ms, neuron 2 fires at 2 ms and neuron 1 fires at 3 ms. Example use:

but that gives me the impression that I am connecting other neurons to the one of interest and simulating their firing times? Is that correct? Could it still be applicable for my use-case? I’m not a neuroscientist, so Ive got a lot of questions (as I’m sure you can see) Is N the number of neurons in my circuit, or the number of neurons that I’d like to be firing throughout the process?

2

Hi @itq. Injecting an external current into a neuron with an electrode is actually something that is done quite commonly in experiments (the technical term is “current clamp”). To inject such a current, you include it in the equations. This is what is done in the HH model you linked to:

# The model
eqs = Equations('''
dv/dt = (gl*(El-v) - g_na*(m*m*m)*h*(v-ENa) - g_kd*(n*n*n*n)*(v-EK) + I)/Cm : volt
# ...
I : amp
''')
group = NeuronGroup(...)
group.v = El
group.I = '0.7*nA * i / num_neurons'

The I is an injected current that is set to a value between 0 and 0.7nA, linearly spaced based on the index i of each neuron.

Now, your model is formulated slightly differently for simplicity, basically things are divided by gl from the HH equations. In your case, you’d therefore indeed “add a constant voltage” to the neuron, which physics-wise is a bit odd to say, but it’ll do :slight_smile:

You can either do:

    v_ext = 1*mV  # external input
    eqs = '''
    dv/dt = (v_0 - v + g + v_ext) / t_mbr : volt (unless refractory)
    dg/dt = -g / tau               : volt (unless refractory) 
    rfc                            : second
    '''

for the same input to all neurons, or:

    eqs = '''
    dv/dt = (v_0 - v + g + v_ext) / t_mbr : volt (unless refractory)
    dg/dt = -g / tau               : volt (unless refractory) 
    rfc                            : second
    v_ext                          : volt (constant)
    '''
    ...
    neu.v_ext = ... # one value for each neuron

to have a different input into each neuron.

Hope that helps!