brainpy.neurons.MorrisLecar

class brainpy.neurons.MorrisLecar(*args, input_var=True, noise=None, **kwargs)

The Morris-Lecar neuron model.

Model Descriptions

The Morris-Lecar model [4] (Also known as \(I_{Ca}+I_K\)-model) is a two-dimensional “reduced” excitation model applicable to systems having two non-inactivating voltage-sensitive conductances. This model was named after Cathy Morris and Harold Lecar, who derived it in 1981. Because it is two-dimensional, the Morris-Lecar model is one of the favorite conductance-based models in computational neuroscience.

The original form of the model employed an instantaneously responding voltage-sensitive Ca2+ conductance for excitation and a delayed voltage-dependent K+ conductance for recovery. The equations of the model are:

\[\begin{split}\begin{aligned} C\frac{dV}{dt} =& - g_{Ca} M_{\infty} (V - V_{Ca})- g_{K} W(V - V_{K}) - g_{Leak} (V - V_{Leak}) + I_{ext} \\ \frac{dW}{dt} =& \frac{W_{\infty}(V) - W}{ \tau_W(V)} \end{aligned}\end{split}\]

Here, \(V\) is the membrane potential, \(W\) is the “recovery variable”, which is almost invariably the normalized \(K^+\)-ion conductance, and \(I_{ext}\) is the applied current stimulus.

Model Examples

>>> import brainpy as bp
>>>
>>> group = bp.neurons.MorrisLecar(1)
>>> runner = bp.DSRunner(group, monitors=['V', 'W'], inputs=('input', 100.))
>>> runner.run(1000)
>>>
>>> fig, gs = bp.visualize.get_figure(2, 1, 3, 8)
>>> fig.add_subplot(gs[0, 0])
>>> bp.visualize.line_plot(runner.mon.ts, runner.mon.W, ylabel='W')
>>> fig.add_subplot(gs[1, 0])
>>> bp.visualize.line_plot(runner.mon.ts, runner.mon.V, ylabel='V', show=True)

Model Parameters

Parameter	Init Value	Unit	Explanation
V_Ca	130	mV	Equilibrium potentials of Ca+.(mV)
g_Ca	4.4		Maximum conductance of corresponding Ca+.(mS/cm2)
V_K	-84	mV	Equilibrium potentials of K+.(mV)
g_K	8		Maximum conductance of corresponding K+.(mS/cm2)
V_Leak	-60	mV	Equilibrium potentials of leak current.(mV)
g_Leak	2		Maximum conductance of leak current.(mS/cm2)
C	20		Membrane capacitance.(uF/cm2)
V1	-1.2		Potential at which M_inf = 0.5.(mV)
V2	18		Reciprocal of slope of voltage dependence of M_inf.(mV)
V3	2		Potential at which W_inf = 0.5.(mV)
V4	30		Reciprocal of slope of voltage dependence of W_inf.(mV)
phi	0.04		A temperature factor. (1/s)
V_th	10	mV	The spike threshold.

References

[4]

Lecar, Harold. “Morris-lecar model.” Scholarpedia 2.10 (2007): 1333.

[5]

http://www.scholarpedia.org/article/Morris-Lecar_model

[6]

https://en.wikipedia.org/wiki/Morris%E2%80%93Lecar_model

__init__(*args, input_var=True, noise=None, **kwargs)

Methods

__init__(*args[, input_var, noise])
add_aft_update(key, fun)	Add the after update into this node
add_bef_update(key, fun)	Add the before update into this node
add_inp_fun(key, fun)	Add an input function.
clear_input()	Empty function of clearing inputs.
cpu()	Move all variable into the CPU device.
cuda()	Move all variables into the GPU device.
dV(V, t, W, I)
dW(W, t, V)
get_aft_update(key)	Get the after update of this node by the given key.
get_batch_shape([batch_size])
get_bef_update(key)	Get the before update of this node by the given key.
get_delay_data(identifier, delay_pos, *indices)	Get delay data according to the provided delay steps.
get_delay_var(name)
get_inp_fun(key)	Get the input function.
get_local_delay(var_name, delay_name)	Get the delay at the given identifier (name).
has_aft_update(key)	Whether this node has the after update of the given key.
has_bef_update(key)	Whether this node has the before update of the given key.
init_param(param[, shape, sharding])	Initialize parameters.
init_variable(var_data, batch_or_mode[, ...])	Initialize variables.
jit_step_run(i, *args, **kwargs)	The jitted step function for running.
load_state(state_dict, **kwargs)	Load states from a dictionary.
load_state_dict(state_dict[, warn, compatible])	Copy parameters and buffers from state_dict into this module and its descendants.
nodes([method, level, include_self])	Collect all children nodes.
register_delay(identifier, delay_step, ...)	Register delay variable.
register_implicit_nodes(*nodes[, node_cls])
register_implicit_vars(*variables[, var_cls])
register_local_delay(var_name, delay_name[, ...])	Register local relay at the given delay time.
reset(*args, **kwargs)	Reset function which reset the whole variables in the model (including its children models).
reset_local_delays([nodes])	Reset local delay variables.
reset_state([batch_size])	Reset function which resets local states in this model.
return_info()
save_state(**kwargs)	Save states as a dictionary.
setattr(key, value)	rtype: None
state_dict(**kwargs)	Returns a dictionary containing a whole state of the module.
step_run(i, *args, **kwargs)	The step run function.
sum_inputs(*args[, init, label])	Summarize all inputs by the defined input functions .cur_inputs.
to(device)	Moves all variables into the given device.
tpu()	Move all variables into the TPU device.
tracing_variable(name, init, shape[, ...])	Initialize the variable which can be traced during computations and transformations.
train_vars([method, level, include_self])	The shortcut for retrieving all trainable variables.
tree_flatten()	Flattens the object as a PyTree.
tree_unflatten(aux, dynamic_values)	Unflatten the data to construct an object of this class.
unique_name([name, type_])	Get the unique name for this object.
update([x])	The function to specify the updating rule.
update_local_delays([nodes])	Update local delay variables.
vars([method, level, include_self, ...])	Collect all variables in this node and the children nodes.

Attributes

derivative
mode	Mode of the model, which is useful to control the multiple behaviors of the model.
name	Name of the model.
supported_modes	Supported computing modes.
varshape	The shape of variables in the neuron group.
cur_inputs