def simulate(self,
current=input_factory.get_zero_current(),
time=10 * b2.ms,
rheo_threshold=None,
v_rest=None,
v_reset=None,
delta_t=None,
time_scale=None,
resistance=None,
threshold=None,
adapt_volt_c=None,
adapt_tau=None,
adapt_incr=None):
if (v_rest == None):
v_rest = self.rest_pot
if (v_reset == None):
v_reset = self.reset_pot
if (rheo_threshold == None):
rheo_threshold = self.rheo_threshold
if (delta_t == None):
delta_t = self.delta_t
if (time_scale == None):
time_scale = self.time_scale
if (resistance == None):
resistance = self.resistance
if (threshold == None):
threshold = self.threshold
if (adapt_volt_c == None):
adapt_volt_c = self.adapt_volt_c
if (adapt_tau == None):
adapt_tau = self.adapt_tau
if (adapt_incr == None):
adapt_incr = self.adapt_incr
v_spike_str = "v>{:f}*mvolt".format(threshold / b2.mvolt)
eqs = """
dv/dt = (-(v-v_rest) +delta_t*exp((v-rheo_threshold)/delta_t)+ resistance * current(t,i) - resistance * w)/(time_scale) : volt
dw/dt=(adapt_volt_c*(v-v_rest)-w)/adapt_tau : amp
"""
neuron = b2.NeuronGroup(1,
model=eqs,
threshold=v_spike_str,
reset="v=v_reset;w+=adapt_incr",
method="euler")
neuron.v = v_rest
neuron.w = 0.0 * b2.pA
state_monitor = b2.StateMonitor(neuron, ["v", "w"], record=True)
spike_monitor = b2.SpikeMonitor(neuron)
b2.run(time)
return state_monitor, spike_monitor
def simulate_exponential_IF_neuron(tau=MEMBRANE_TIME_SCALE_tau,
R=MEMBRANE_RESISTANCE_R,
v_rest=V_REST,
v_reset=V_RESET,
v_rheobase=RHEOBASE_THRESHOLD_v_rh,
v_spike=FIRING_THRESHOLD_v_spike,
delta_T=SHARPNESS_delta_T,
I_stim=input_factory.get_zero_current(),
simulation_time=200 * b2.ms):
"""
Implements the dynamics of the exponential Integrate-and-fire model
Args:
tau (Quantity): Membrane time constant
R (Quantity): Membrane resistance
v_rest (Quantity): Resting potential
v_reset (Quantity): Reset value (vm after spike)
v_rheobase (Quantity): Rheobase threshold
v_spike (Quantity) : voltage threshold for the spike condition
delta_T (Quantity): Sharpness of the exponential term
I_stim (TimedArray): Input current
simulation_time (Quantity): Duration for which the model is simulated
Returns:
(voltage_monitor, spike_monitor):
A b2.StateMonitor for the variable "v" and a b2.SpikeMonitor
"""
eqs = """
dv/dt = (-(v-v_rest) +delta_T*exp((v-v_rheobase)/delta_T)+ R * I_stim(t,i))/(tau) : volt
"""
neuron = b2.NeuronGroup(1,
model=eqs,
reset="v=v_reset",
threshold="v>v_spike",
method="euler")
neuron.v = v_rest
# monitoring membrane potential of neuron and injecting current
voltage_monitor = b2.StateMonitor(neuron, ["v"], record=True)
spike_monitor = b2.SpikeMonitor(neuron)
# run the simulation
net = b2.Network(neuron, voltage_monitor, spike_monitor)
net.run(simulation_time)
return voltage_monitor, spike_monitor
def simulate_exponential_IF_neuron(
tau=MEMBRANE_TIME_SCALE_tau,
R=MEMBRANE_RESISTANCE_R,
v_rest=V_REST,
v_reset=V_RESET,
v_rheobase=RHEOBASE_THRESHOLD_v_rh,
v_spike=FIRING_THRESHOLD_v_spike,
delta_T=SHARPNESS_delta_T,
I_stim=input_factory.get_zero_current(),
simulation_time=200 * b2.ms):
"""
Implements the dynamics of the exponential Integrate-and-fire model
Args:
tau (Quantity): Membrane time constant
R (Quantity): Membrane resistance
v_rest (Quantity): Resting potential
v_reset (Quantity): Reset value (vm after spike)
v_rheobase (Quantity): Rheobase threshold
v_spike (Quantity) : voltage threshold for the spike condition
delta_T (Quantity): Sharpness of the exponential term
I_stim (TimedArray): Input current
simulation_time (Quantity): Duration for which the model is simulated
Returns:
(voltage_monitor, spike_monitor):
A b2.StateMonitor for the variable "v" and a b2.SpikeMonitor
"""
eqs = """
dv/dt = (-(v-v_rest) +delta_T*exp((v-v_rheobase)/delta_T)+ R * I_stim(t,i))/(tau) : volt
"""
neuron = b2.NeuronGroup(1, model=eqs, reset="v=v_reset", threshold="v>v_spike", method="euler")
neuron.v = v_rest
# monitoring membrane potential of neuron and injecting current
voltage_monitor = b2.StateMonitor(neuron, ["v"], record=True)
spike_monitor = b2.SpikeMonitor(neuron)
# run the simulation
net = b2.Network(neuron, voltage_monitor, spike_monitor)
net.run(simulation_time)
return voltage_monitor, spike_monitor
def getting_started():
"""
Simple example to get started
"""
from neurodynex.tools import plot_tools
current = input_factory.get_step_current(10, 200, 1. * b2.ms, 500 * b2.pA)
ic = input_factory.get_zero_current()
state_monitor, spike_monitor = simulate_AdEx_neuron(I_stim=current,
simulation_time=300 *
b2.ms)
# plot_tools.plot_network_activity(rate_monitor, spike_monitor, state_monitor)
# plt.show()
plot_tools.plot_voltage_and_current_traces(state_monitor,
current,
title="AdEx neuron simulations")
plt.show()
plot_adex_state(state_monitor)
print("nr of spikes: {}".format(spike_monitor.count[0]))
def simulate(self,
current=input_factory.get_zero_current(),
time=10 * b2.ms,
rheo_threshold=None,
v_rest=None,
v_reset=None,
delta_t=None,
time_scale=None,
resistance=None,
threshold=None):
if (v_rest == None):
v_rest = self.rest_pot
if (v_reset == None):
v_reset = self.reset_pot
if (rheo_threshold == None):
rheo_threshold = self.rheo_threshold
if (delta_t == None):
delta_t = self.delta_t
if (time_scale == None):
time_scale = self.time_scale
if (resistance == None):
resistance = self.resistance
if (threshold == None):
threshold = self.threshold
eqs = "dv/dt = (-(v-v_rest) +delta_t*exp((v-rheo_threshold)/delta_t)+ resistance * current(t,i))/(time_scale) : volt"
neuron = b2.NeuronGroup(1,
model=eqs,
reset="v=v_reset",
threshold="v>threshold",
method="euler")
neuron.v = v_rest
voltage_monitor = b2.StateMonitor(neuron, ["v"], record=True)
spike_monitor = b2.SpikeMonitor(neuron)
net = b2.Network(neuron, voltage_monitor, spike_monitor)
net.run(time)
return voltage_monitor, spike_monitor
def simulate_AdEx_neuron(tau_m=MEMBRANE_TIME_SCALE_tau_m,
R=MEMBRANE_RESISTANCE_R,
v_rest=V_REST,
v_reset=V_RESET,
v_rheobase=RHEOBASE_THRESHOLD_v_rh,
a=ADAPTATION_VOLTAGE_COUPLING_a,
b=SPIKE_TRIGGERED_ADAPTATION_INCREMENT_b,
v_spike=FIRING_THRESHOLD_v_spike,
delta_T=SHARPNESS_delta_T,
tau_w=ADAPTATION_TIME_CONSTANT_tau_w,
I_stim=input_factory.get_zero_current(),
simulation_time=200 * b2.ms):
"""
Implementation of the AdEx model with a single adaptation variable w.
The Brian2 model equations are:
.. math::
\frac{dv}{dt} = (-(v-v_rest) +delta_T*exp((v-v_rheobase)/delta_T)+ R * I_stim(t,i) - R * w)/(tau_m) : volt \\
\frac{dw}{dt} = (a*(v-v_rest)-w)/tau_w : amp
Args:
tau_m (Quantity): membrane time scale
R (Quantity): membrane restistance
v_rest (Quantity): resting potential
v_reset (Quantity): reset potential
v_rheobase (Quantity): rheobase threshold
a (Quantity): Adaptation-Voltage coupling
b (Quantity): Spike-triggered adaptation current (=increment of w after each spike)
v_spike (Quantity): voltage threshold for the spike condition
delta_T (Quantity): Sharpness of the exponential term
tau_w (Quantity): Adaptation time constant
I_stim (TimedArray): Input current
simulation_time (Quantity): Duration for which the model is simulated
Returns:
(state_monitor, spike_monitor):
A b2.StateMonitor for the variables "v" and "w" and a b2.SpikeMonitor
"""
v_spike_str = "v>{:f}*mvolt".format(v_spike / b2.mvolt)
# EXP-IF
eqs = """
dv/dt = (-(v-v_rest) +delta_T*exp((v-v_rheobase)/delta_T)+ R * I_stim(t,i) - R * w)/(tau_m) : volt
dw/dt=(a*(v-v_rest)-w)/tau_w : amp
"""
neuron = b2.NeuronGroup(1,
model=eqs,
threshold=v_spike_str,
reset="v=v_reset;w+=b",
method="euler")
# initial values of v and w is set here:
neuron.v = v_rest
neuron.w = 0.0 * b2.pA
# Monitoring membrane voltage (v) and w
state_monitor = b2.StateMonitor(neuron, ["v", "w"], record=True)
spike_monitor = b2.SpikeMonitor(neuron)
# rate_monitor = b2.PopulationRateMonitor(neuron)
# running simulation
b2.run(simulation_time)
return state_monitor, spike_monitor
def simulate_AdEx_neuron(
tau_m=MEMBRANE_TIME_SCALE_tau_m,
R=MEMBRANE_RESISTANCE_R,
v_rest=V_REST,
v_reset=V_RESET,
v_rheobase=RHEOBASE_THRESHOLD_v_rh,
a=ADAPTATION_VOLTAGE_COUPLING_a,
b=SPIKE_TRIGGERED_ADAPTATION_INCREMENT_b,
v_spike=FIRING_THRESHOLD_v_spike,
delta_T=SHARPNESS_delta_T,
tau_w=ADAPTATION_TIME_CONSTANT_tau_w,
I_stim=input_factory.get_zero_current(),
simulation_time=200 * b2.ms):
r"""
Implementation of the AdEx model with a single adaptation variable w.
The Brian2 model equations are:
.. math::
\frac{dv}{dt} = (-(v-v_rest) +delta_T*exp((v-v_rheobase)/delta_T)+ R * I_stim(t,i) - R * w)/(tau_m) : volt \\
\frac{dw}{dt} = (a*(v-v_rest)-w)/tau_w : amp
Args:
tau_m (Quantity): membrane time scale
R (Quantity): membrane restistance
v_rest (Quantity): resting potential
v_reset (Quantity): reset potential
v_rheobase (Quantity): rheobase threshold
a (Quantity): Adaptation-Voltage coupling
b (Quantity): Spike-triggered adaptation current (=increment of w after each spike)
v_spike (Quantity): voltage threshold for the spike condition
delta_T (Quantity): Sharpness of the exponential term
tau_w (Quantity): Adaptation time constant
I_stim (TimedArray): Input current
simulation_time (Quantity): Duration for which the model is simulated
Returns:
(state_monitor, spike_monitor):
A b2.StateMonitor for the variables "v" and "w" and a b2.SpikeMonitor
"""
v_spike_str = "v>{:f}*mvolt".format(v_spike / b2.mvolt)
# EXP-IF
eqs = """
dv/dt = (-(v-v_rest) +delta_T*exp((v-v_rheobase)/delta_T)+ R * I_stim(t,i) - R * w)/(tau_m) : volt
dw/dt=(a*(v-v_rest)-w)/tau_w : amp
"""
neuron = b2.NeuronGroup(1, model=eqs, threshold=v_spike_str, reset="v=v_reset;w+=b", method="euler")
# initial values of v and w is set here:
neuron.v = v_rest
neuron.w = 0.0 * b2.pA
# Monitoring membrane voltage (v) and w
state_monitor = b2.StateMonitor(neuron, ["v", "w"], record=True)
spike_monitor = b2.SpikeMonitor(neuron)
# running simulation
b2.run(simulation_time)
return state_monitor, spike_monitor
