brainpy.neurons.MorrisLecar

class brainpy.neurons.MorrisLecar(*args, input_var=True, **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, **kwargs)

Methods

__init__(*args[, input_var])
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[, label, category])	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])
return_info()
save_state(**kwargs)	Save states as a dictionary.
setattr(key, value)
state_dict(**kwargs)	Returns a dictionary containing a whole state of the module.
step_run(i, *args, **kwargs)	The step run function.
sum_current_inputs(*args[, init, label])	Summarize all current inputs by the defined input functions .current_inputs.
sum_delta_inputs(*args[, init, label])	Summarize all delta inputs by the defined input functions .delta_inputs.
sum_inputs(*args, **kwargs)
to(device)	Moves all variables into the given device.
tpu()	Move all variables into the TPU device.
tracing_variable(name, init, shape[, ...])	Initialize a variable that 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

after_updates
before_updates
cur_inputs
current_inputs
delta_inputs
derivative
implicit_nodes
implicit_vars
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.