Coupling

Integrators

models Package¶

A collection of neuronal dynamics models.

Specific models inherit from the abstract class Model.

class tvb.simulator.models.ModelsEnum[source]

Bases: enum.Enum

An enumeration.

BASE_MODEL = <ModelsEnum.BASE_MODEL: 'Model'>
COOMBES_BYRNE = <ModelsEnum.COOMBES_BYRNE: 'CoombesByrne'>
COOMBES_BYRNE_2D = <ModelsEnum.COOMBES_BYRNE_2D: 'CoombesByrne2D'>
DUMONT_GUTKIN = <ModelsEnum.DUMONT_GUTKIN: 'DumontGutkin'>
EPILEPTOR = <ModelsEnum.EPILEPTOR: 'Epileptor'>
EPILEPTOR_2D = <ModelsEnum.EPILEPTOR_2D: 'Epileptor2D'>
EPILEPTOR_CODIM_3 = <ModelsEnum.EPILEPTOR_CODIM_3: 'EpileptorCodim3'>
EPILEPTOR_CODIM_3_SLOW = <ModelsEnum.EPILEPTOR_CODIM_3_SLOW: 'EpileptorCodim3SlowMod'>
EPILEPTOR_RS = <ModelsEnum.EPILEPTOR_RS: 'EpileptorRestingState'>
GAST_SCHMIDT_KNOSCHE_SD = <ModelsEnum.GAST_SCHMIDT_KNOSCHE_SD: 'GastSchmidtKnosche_SD'>
GAST_SCHMIDT_KNOSCHE_SF = <ModelsEnum.GAST_SCHMIDT_KNOSCHE_SF: 'GastSchmidtKnosche_SF'>
GENERIC_2D_OSCILLATOR = <ModelsEnum.GENERIC_2D_OSCILLATOR: 'Generic2dOscillator'>
HOPFIELD = <ModelsEnum.HOPFIELD: 'Hopfield'>
JANSEN_RIT = <ModelsEnum.JANSEN_RIT: 'JansenRit'>
KURAMOTO = <ModelsEnum.KURAMOTO: 'Kuramoto'>
LARTER_BREAKSPEAR = <ModelsEnum.LARTER_BREAKSPEAR: 'LarterBreakspear'>
LINEAR = <ModelsEnum.LINEAR: 'Linear'>
MONTBRIO_PAZO_ROXIN = <ModelsEnum.MONTBRIO_PAZO_ROXIN: 'MontbrioPazoRoxin'>
REDUCED_SET_FITZ_HUGH_NAGUMO = <ModelsEnum.REDUCED_SET_FITZ_HUGH_NAGUMO: 'ReducedSetFitzHughNagumo'>
REDUCED_SET_HINDMARSH_ROSE = <ModelsEnum.REDUCED_SET_HINDMARSH_ROSE: 'ReducedSetHindmarshRose'>
REDUCED_WONG_WANG = <ModelsEnum.REDUCED_WONG_WANG: 'ReducedWongWang'>
REDUCED_WONG_WANG_EXCH_INH = <ModelsEnum.REDUCED_WONG_WANG_EXCH_INH: 'ReducedWongWangExcInh'>
SUP_HOPF = <ModelsEnum.SUP_HOPF: 'SupHopf'>
WILSON_COWAN = <ModelsEnum.WILSON_COWAN: 'WilsonCowan'>
ZERLAUT_FIRST_ORDER = <ModelsEnum.ZERLAUT_FIRST_ORDER: 'ZerlautAdaptationFirstOrder'>
ZERLAUT_SECOND_ORDER = <ModelsEnum.ZERLAUT_SECOND_ORDER: 'ZerlautAdaptationSecondOrder'>
ZETTERBERG_JANSEN = <ModelsEnum.ZETTERBERG_JANSEN: 'ZetterbergJansen'>
static get_base_model_subclasses()[source]
get_class()[source]

base¶

This module defines the common imports and abstract base class for model definitions.

class tvb.simulator.models.base.Model(**kwargs)[source]
Defines the abstract base class for neuronal models.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

configure()[source]

Configure base model.

cvar = None
dfun(state_variables, coupling, local_coupling=0.0)[source]

Defines the dynamic equations. That is, the derivative of the state-variables given their current state state_variables, the past state from other regions of the brain currently arriving coupling, and the current state of the “local” neighbourhood local_coupling.

global_parameter_names[source]
has_nonint_vars[source]

Flag to determine if there are any non integrated state variables.

initial(dt, history_shape, rng=<module 'numpy.random' from '/opt/conda/envs/tvb-run/lib/python3.7/site-packages/numpy/random/__init__.py'>)[source]

Generates uniformly distributed initial conditions, bounded by the state variable limits defined by the model.

initial_for_simulator(integrator, shape)[source]

Generate initial conditions with integrator and shape.

nintvar[source]

The number of integrated state variables in this model.

nnonintvar[source]

The number of non integrated state variables in this model.

non_integrated_variables = None
number_of_modes = 1
nvar[source]

The number of state variables in this model.

spatial_param_reshape[source]

Returns reshape argument for a spatialized parameter.

spatial_parameter_matrix[source]
spatial_parameter_names[source]
state_variable_boundaries = None
state_variables = ()
stationary_trajectory(coupling=array([[0.]]), initial_conditions=None, n_step=1000, n_skip=10, dt=0.0625, map=<class 'map'>)[source]

Computes the state space trajectory of a single mass model system where coupling is static, with a deterministic Euler method.

Models expect coupling of shape (n_cvar, n_node), so if this method is called with coupling (:, n_cvar, n_ode), it will compute a stationary trajectory for each coupling[i, ...]

stvar = None
update_derived_parameters()[source]

When needed, this should be a method for calculating parameters that are calculated based on paramaters directly set by the caller. For example, see, ReducedSetFitzHughNagumo. When not needed, this pass simplifies code that updates an arbitrary models parameters – ie, this can be safely called on any model, whether it’s used or not.

update_state_variables_after_integration(state_variables)[source]
update_state_variables_before_integration(state_variables, coupling, local_coupling=0.0, stimulus=0.0)[source]
variables_of_interest = ()

Base model for Numba-implemented dfuns.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

spatial_param_reshape[source]

epileptor¶

Hindmarsh-Rose-Jirsa Epileptor model.

class tvb.simulator.models.epileptor.Epileptor(**kwargs)[source]

The Epileptor is a composite neural mass model of six dimensions which has been crafted to model the phenomenology of epileptic seizures. (see [Jirsaetal_2014])

Equations and default parameters are taken from [Jirsaetal_2014].

Table 1
Parameter Value
I_rest1 3.1
I_rest2 0.45
r 0.00035
x_0 -1.6
slope 0.0
Integration parameter
dt 0.1
simulation_length 4000
Noise
nsig [0., 0., 0., 1e-3, 1e-3, 0.]
Jirsa et al. 2014
 [Jirsaetal_2014] (1, 2) Jirsa, V. K.; Stacey, W. C.; Quilichini, P. P.; Ivanov, A. I.; Bernard, C. On the nature of seizure dynamics. Brain, 2014.

Variables of interest to be used by monitors: -y[0] + y[3]

$\begin{split}\dot{x_{1}} &=& y_{1} - f_{1}(x_{1}, x_{2}) - z + I_{ext1} \\ \dot{y_{1}} &=& c - d x_{1}^{2} - y{1} \\ \dot{z} &=& \begin{cases} r(4 (x_{1} - x_{0}) - z-0.1 z^{7}) & \text{if } x<0 \\ r(4 (x_{1} - x_{0}) - z) & \text{if } x \geq 0 \end{cases} \\ \dot{x_{2}} &=& -y_{2} + x_{2} - x_{2}^{3} + I_{ext2} + 0.002 g - 0.3 (z-3.5) \\ \dot{y_{2}} &=& 1 / \tau (-y_{2} + f_{2}(x_{2}))\\ \dot{g} &=& -0.01 (g - 0.1 x_{1})\end{split}$
where:
$\begin{split}f_{1}(x_{1}, x_{2}) = \begin{cases} a x_{1}^{3} - b x_{1}^2 & \text{if } x_{1} <0\\ -(slope - x_{2} + 0.6(z-4)^2) x_{1} &\text{if }x_{1} \geq 0 \end{cases}\end{split}$

and:

$\begin{split}f_{2}(x_{2}) = \begin{cases} 0 & \text{if } x_{2} <-0.25\\ a_{2}(x_{2} + 0.25) & \text{if } x_{2} \geq -0.25 \end{cases}\end{split}$

Note Feb. 2017: the slow permittivity variable can be modify to account for the time difference between interictal and ictal states (see [Proixetal_2014]).

 [Proixetal_2014] Proix, T.; Bartolomei, F; Chauvel, P; Bernard, C; Jirsa, V.K. * Permittivity coupling across brain regions determines seizure recruitment in partial epilepsy.* J Neurosci 2014, 34:15009-21.
a : tvb.simulator.models.epileptor.Epileptor.a = NArray(label=’$$a$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Coefficient of the cubic term in the first state variable
b : tvb.simulator.models.epileptor.Epileptor.b = NArray(label=’$$b$$‘, dtype=float64, default=array([3.]), dim_names=(), ndim=None, required=True)
Coefficient of the squared term in the first state variabel
c : tvb.simulator.models.epileptor.Epileptor.c = NArray(label=’$$c$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Additive coefficient for the second state variable, called $$y_{0}$$ in Jirsa paper
d : tvb.simulator.models.epileptor.Epileptor.d = NArray(label=’$$d$$‘, dtype=float64, default=array([5.]), dim_names=(), ndim=None, required=True)
Coefficient of the squared term in the second state variable
r : tvb.simulator.models.epileptor.Epileptor.r = NArray(label=’$$r$$‘, dtype=float64, default=array([0.00035]), dim_names=(), ndim=None, required=True)
Temporal scaling in the third state variable, called $$1/\tau_{0}$$ in Jirsa paper
s : tvb.simulator.models.epileptor.Epileptor.s = NArray(label=’$$s$$‘, dtype=float64, default=array([4.]), dim_names=(), ndim=None, required=True)
Linear coefficient in the third state variable
x0 : tvb.simulator.models.epileptor.Epileptor.x0 = NArray(label=’$$x_0$$‘, dtype=float64, default=array([-1.6]), dim_names=(), ndim=None, required=True)
Epileptogenicity parameter
Iext : tvb.simulator.models.epileptor.Epileptor.Iext = NArray(label=’$$I_{ext}$$‘, dtype=float64, default=array([3.1]), dim_names=(), ndim=None, required=True)
External input current to the first population
slope : tvb.simulator.models.epileptor.Epileptor.slope = NArray(label=’$$slope$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Linear coefficient in the first state variable
Iext2 : tvb.simulator.models.epileptor.Epileptor.Iext2 = NArray(label=’$$I_{ext2}$$‘, dtype=float64, default=array([0.45]), dim_names=(), ndim=None, required=True)
External input current to the second population
tau : tvb.simulator.models.epileptor.Epileptor.tau = NArray(label=’$$\\tau$$‘, dtype=float64, default=array([10.]), dim_names=(), ndim=None, required=True)
Temporal scaling coefficient in fifth state variable
aa : tvb.simulator.models.epileptor.Epileptor.aa = NArray(label=’$$aa$$‘, dtype=float64, default=array([6.]), dim_names=(), ndim=None, required=True)
Linear coefficient in fifth state variable
bb : tvb.simulator.models.epileptor.Epileptor.bb = NArray(label=’$$bb$$‘, dtype=float64, default=array([2.]), dim_names=(), ndim=None, required=True)
Linear coefficient of lowpass excitatory coupling in fourth state variable
Kvf : tvb.simulator.models.epileptor.Epileptor.Kvf = NArray(label=’$$K_{vf}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Coupling scaling on a very fast time scale.
Kf : tvb.simulator.models.epileptor.Epileptor.Kf = NArray(label=’$$K_{f}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Correspond to the coupling scaling on a fast time scale.
Ks : tvb.simulator.models.epileptor.Epileptor.Ks = NArray(label=’$$K_{s}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Permittivity coupling, that is from the fast time scale toward the slow time scale
tt : tvb.simulator.models.epileptor.Epileptor.tt = NArray(label=’$$K_{tt}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Time scaling of the whole system
modification : tvb.simulator.models.epileptor.Epileptor.modification = NArray(label=’$$modification$$‘, dtype=bool, default=array([False]), dim_names=(), ndim=None, required=True)
When modification is True, then use nonlinear influence on z. The default value is False, i.e., linear influence.
state_variable_range : tvb.simulator.models.epileptor.Epileptor.state_variable_range = Final(field_type=<class ‘dict’>, default={‘x1’: array([-2., 1.]), ‘y1’: array([-20., 2.]), ‘z’: array([2., 5.]), ‘x2’: array([-2., 0.]), ‘y2’: array([0., 2.]), ‘g’: array([-1., 1.])}, required=True)
Typical bounds on state variables in the Epileptor model.
variables_of_interest : tvb.simulator.models.epileptor.Epileptor.variables_of_interest = List(of=<class ‘str’>, default=(‘x2 - x1’, ‘z’), required=True)
Quantities of the Epileptor available to monitor.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

Iext

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Iext2

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Kf

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Ks

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Kvf

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

aa

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

bb

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([0, 3], dtype=int32)
d

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

dfun(x, c, local_coupling=0.0)[source]

Computes the derivatives of the state variables of the Epileptor with respect to time.

Implementation note: we expect this version of the Epileptor to be used in a vectorized manner. Concretely, y has a shape of (6, n) where n is the number of nodes in the network. An consequence is that the original use of if/else is translated by calculated both the true and false forms and mixing them using a boolean mask.

Variables of interest to be used by monitors: -y[0] + y[3]

$\begin{split}\dot{x_{1}} &=& y_{1} - f_{1}(x_{1}, x_{2}) - z + I_{ext1} \\ \dot{y_{1}} &=& c - d x_{1}^{2} - y{1} \\ \dot{z} &=& \begin{cases} r(4 (x_{1} - x_{0}) - z-0.1 z^{7}) & \text{if } x<0 \\ r(4 (x_{1} - x_{0}) - z) & \text{if } x \geq 0 \end{cases} \\ \dot{x_{2}} &=& -y_{2} + x_{2} - x_{2}^{3} + I_{ext2} + 0.002 g - 0.3 (z-3.5) \\ \dot{y_{2}} &=& 1 / \tau (-y_{2} + f_{2}(x_{2}))\\ \dot{g} &=& -0.01 (g - 0.1 x_{1})\end{split}$
where:
$\begin{split}f_{1}(x_{1}, x_{2}) = \begin{cases} a x_{1}^{3} - b x_{1}^2 & \text{if } x_{1} <0\\ -(slope - x_{2} + 0.6(z-4)^2) x_{1} &\text{if }x_{1} \geq 0 \end{cases}\end{split}$
and:
$\begin{split}f_{2}(x_{2}) = \begin{cases} 0 & \text{if } x_{2} <-0.25\\ a_{2}(x_{2} + 0.25) & \text{if } x_{2} \geq -0.25 \end{cases}\end{split}$
modification

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

r

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

s

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

slope

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('x1', 'y1', 'z', 'x2', 'y2', 'g')
tau

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

tt

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

x0

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

class tvb.simulator.models.epileptor.Epileptor2D(**kwargs)[source]

Two-dimensional reduction of the Epileptor.

Taking advantage of time scale separation and focusing on the slower time scale, the five-dimensional Epileptor reduces to a two-dimensional system (see [Proixetal_2014, Proixetal_2017]).

Note: the slow permittivity variable can be modify to account for the time difference between interictal and ictal states (see [Proixetal_2014]).

Equations and default parameters are taken from [Proixetal_2014]:

$\begin{split}\dot{x_{1,i}} &=& - x_{1,i}^{3} - 2x_{1,i}^{2} + 1 - z_{i} + I_{ext1,i} \\ \dot{z_{i}} &=& r(h - z_{i})\end{split}$
with
h = begin{cases} x_{0} + 3 / (exp((x_{1} + 0.5)/0.1)) & text{if } modification\ 4 (x_{1,i} - x_{0}) & text{else } end{cases}
References:

[Proixetal_2014] Proix, T.; Bartolomei, F; Chauvel, P; Bernard, C; Jirsa, V.K. * Permittivity coupling across brain regions determines seizure recruitment in partial epilepsy.* J Neurosci 2014, 34:15009-21.

[Proixetal_2017] Proix, T.; Bartolomei, F; Guye, M.; Jirsa, V.K. Individual brain structure and modelling predict seizure propagation. Brain 2017, 140; 641–654.

a : tvb.simulator.models.epileptor.Epileptor2D.a = NArray(label=’$$a$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Coefficient of the cubic term in the first state-variable.
b : tvb.simulator.models.epileptor.Epileptor2D.b = NArray(label=’$$b$$‘, dtype=float64, default=array([3.]), dim_names=(), ndim=None, required=True)
Coefficient of the squared term in the first state-variable.
c : tvb.simulator.models.epileptor.Epileptor2D.c = NArray(label=’$$c$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Additive coefficient for the second state-variable x_{2}, called $$y_{0}$$ in Jirsa paper.
d : tvb.simulator.models.epileptor.Epileptor2D.d = NArray(label=’$$d$$‘, dtype=float64, default=array([5.]), dim_names=(), ndim=None, required=True)
Coefficient of the squared term in the second state-variable x_{2}.
r : tvb.simulator.models.epileptor.Epileptor2D.r = NArray(label=’$$r$$‘, dtype=float64, default=array([0.00035]), dim_names=(), ndim=None, required=True)
Temporal scaling in the slow state-variable, called $$1\tau_{0}$$ in Jirsa paper (see class Epileptor).
x0 : tvb.simulator.models.epileptor.Epileptor2D.x0 = NArray(label=’$$x_0$$‘, dtype=float64, default=array([-1.6]), dim_names=(), ndim=None, required=True)
Epileptogenicity parameter.
Iext : tvb.simulator.models.epileptor.Epileptor2D.Iext = NArray(label=’$$I_{ext}$$‘, dtype=float64, default=array([3.1]), dim_names=(), ndim=None, required=True)
External input current to the first state-variable.
slope : tvb.simulator.models.epileptor.Epileptor2D.slope = NArray(label=’$$slope$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Linear coefficient in the first state-variable.
Kvf : tvb.simulator.models.epileptor.Epileptor2D.Kvf = NArray(label=’$$K_{vf}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Coupling scaling on a very fast time scale.
Ks : tvb.simulator.models.epileptor.Epileptor2D.Ks = NArray(label=’$$K_{s}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Permittivity coupling, that is from the fast time scale toward the slow time scale.
tt : tvb.simulator.models.epileptor.Epileptor2D.tt = NArray(label=’$$tt$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Time scaling of the whole system to the system in real time.
modification : tvb.simulator.models.epileptor.Epileptor2D.modification = NArray(label=’$$modification$$‘, dtype=bool, default=array([False]), dim_names=(), ndim=None, required=True)
When modification is True, then use nonlinear influence on z. The default value is False, i.e., linear influence.
state_variable_range : tvb.simulator.models.epileptor.Epileptor2D.state_variable_range = Final(field_type=<class ‘dict’>, default={‘x1’: array([-2., 1.]), ‘z’: array([2., 5.])}, required=True)
Typical bounds on state-variables in the Epileptor 2D model.
variables_of_interest : tvb.simulator.models.epileptor.Epileptor2D.variables_of_interest = List(of=<class ‘str’>, default=(‘x1’,), required=True)
Quantities of the Epileptor 2D available to monitor.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

Iext

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Ks

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Kvf

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([0], dtype=int32)
d

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

dfun(x, c, local_coupling=0.0)[source]

Computes the derivatives of the state-variables of the Epileptor 2D with respect to time.

Equations and default parameters are taken from [Proixetal_2014]:

$\begin{split}\dot{x_{1,i}} &=& - x_{1,i}^{3} - 2x_{1,i}^{2} + 1 - z_{i} + I_{ext1,i} \\ \dot{z_{i}} &=& r(h - z_{i})\end{split}$
with
h = begin{cases} x_{0} + 3 / (exp((x_{1} + 0.5)/0.1)) & text{if } modification\ 4 (x_{1,i} - x_{0}) & text{else } end{cases}
modification

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

r

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

slope

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('x1', 'z')
tt

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

x0

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

hopfield¶

Hopfield model with modifications following Golos & Daucé.

class tvb.simulator.models.hopfield.Hopfield(**kwargs)[source]

The Hopfield neural network is a discrete time dynamical system composed of multiple binary nodes, with a connectivity matrix built from a predetermined set of patterns. The update, inspired from the spin-glass model (used to describe magnetic properties of dilute alloys), is based on a random scanning of every node. The existence of a fixed point dynamics is guaranteed by a Lyapunov function. The Hopfield network is expected to have those multiple patterns as attractors (multistable dynamical system). When the initial conditions are close to one of the ‘learned’ patterns, the dynamical system is expected to relax on the corresponding attractor. A possible output of the system is the final attractive state (interpreted as an associative memory).

Various extensions of the initial model have been proposed, among which a noiseless and continuous version [Hopfield 1984] having a slightly different Lyapunov function, but essentially the same dynamical properties, with more straightforward physiological interpretation. A continuous Hopfield neural network (with a sigmoid transfer function) can indeed be interpreted as a network of neural masses with every node corresponding to the mean field activity of a local brain region, with many bridges with the Wilson Cowan model [WC_1972].

References:

 [Hopfield1982] Hopfield, J. J., Neural networks and physical systems with emergent collective computational abilities, Proc. Nat. Acad. Sci. (USA) 79, 2554-2558, 1982.
 [Hopfield1984] Hopfield, J. J., Neurons with graded response have collective computational properties like those of two-sate neurons, Proc. Nat. Acad. Sci. (USA) 81, 3088-3092, 1984.
configure()[source]

Set the threshold as a state variable for a dynamical threshold.

Dynamic equations:

dfun equation
$\begin{split}\dot{x_{i}} &= 1 / \tau_{x} (-x_{i} + c_0)\end{split}$
dfun dynamic equation
$\begin{split}\dot{x_{i}} &= 1 / \tau_{x} (-x_{i} + c_0(i)) \\ \dot{\theta_{i}} &= 1 / \tau_{\theta_{i}} (-\theta + c_1(i))\end{split}$

The phase-plane for the Hopfield model.

taux : tvb.simulator.models.hopfield.Hopfield.taux = NArray(label=’$$\\tau_{x}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
The fast time-scale for potential calculus $$x$$, state-variable of the model.
tauT : tvb.simulator.models.hopfield.Hopfield.tauT = NArray(label=’$$\\tau_{\\theta}$$‘, dtype=float64, default=array([5.]), dim_names=(), ndim=None, required=True)
The slow time-scale for threshold calculus $$\theta$$, state-variable of the model.
dynamic : tvb.simulator.models.hopfield.Hopfield.dynamic = NArray(label=’Dynamic’, dtype=int64, default=array([0]), dim_names=(), ndim=None, required=True)
Boolean value for static/dynamic threshold theta for (0/1).
state_variable_range : tvb.simulator.models.hopfield.Hopfield.state_variable_range = Final(field_type=<class ‘dict’>, default={‘x’: array([-1., 2.]), ‘theta’: array([0., 1.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.hopfield.Hopfield.variables_of_interest = List(of=<class ‘str’>, default=(‘x’,), required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random initial conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

configure()[source]

Set the threshold as a state variable for a dynamical threshold.

cvar = array([0], dtype=int32)
dfun(state_variables, coupling, local_coupling=0.0)[source]

The fast, $$x$$, and slow, $$\theta$$, state variables are typically considered to represent a membrane potentials of nodes and the global inhibition term, respectively:

$\begin{split}\dot{x_{i}} &= 1 / \tau_{x} (-x_{i} + c_0)\end{split}$
dfunDyn(state_variables, coupling, local_coupling=0.0)[source]

The fast, $$x$$, and slow, $$\theta$$, state variables are typically considered to represent a membrane potentials of nodes and the inhibition term(s), respectively:

$\begin{split}\dot{x_{i}} &= 1 / \tau_{x} (-x_{i} + c_0(i)) \\ \dot{\theta_{i}} &= 1 / \tau_{\theta_{i}} (-\theta + c_1(i))\end{split}$

where c_0 is the coupling term and c_1 should be the direct output.

dynamic

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('x', 'theta')
tauT

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

taux

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

jansen_rit¶

Jansen-Rit and derivative models.

class tvb.simulator.models.jansen_rit.JansenRit(**kwargs)[source]

The Jansen and Rit is a biologically inspired mathematical framework originally conceived to simulate the spontaneous electrical activity of neuronal assemblies, with a particular focus on alpha activity, for instance, as measured by EEG. Later on, it was discovered that in addition to alpha activity, this model was also able to simulate evoked potentials.

 [JR_1995] (1, 2) Jansen, B., H. and Rit V., G., Electroencephalogram and visual evoked potential generation in a mathematical model of coupled cortical columns, Biological Cybernetics (73) 357:366, 1995.
 [J_1993] Jansen, B., Zouridakis, G. and Brandt, M., A neurophysiologically-based mathematical model of flash visual evoked potentials

The dynamic equations were taken from [JR_1995]

$\begin{split}\dot{y_0} &= y_3 \\ \dot{y_3} &= A a\,S[y_1 - y_2] - 2a\,y_3 - a^2\, y_0 \\ \dot{y_1} &= y_4\\ \dot{y_4} &= A a \,[p(t) + \alpha_2 J + S[\alpha_1 J\,y_0]+ c_0] -2a\,y - a^2\,y_1 \\ \dot{y_2} &= y_5 \\ \dot{y_5} &= B b (\alpha_4 J\, S[\alpha_3 J \,y_0]) - 2 b\, y_5 - b^2\,y_2 \\ S[v] &= \frac{2\, \nu_{max}}{1 + \exp^{r(v_0 - v)}}\end{split}$
A : tvb.simulator.models.jansen_rit.JansenRit.A = NArray(label=’$$A$$‘, dtype=float64, default=array([3.25]), dim_names=(), ndim=None, required=True)
Maximum amplitude of EPSP [mV]. Also called average synaptic gain.
B : tvb.simulator.models.jansen_rit.JansenRit.B = NArray(label=’$$B$$‘, dtype=float64, default=array([22.]), dim_names=(), ndim=None, required=True)
Maximum amplitude of IPSP [mV]. Also called average synaptic gain.
a : tvb.simulator.models.jansen_rit.JansenRit.a = NArray(label=’$$a$$‘, dtype=float64, default=array([0.1]), dim_names=(), ndim=None, required=True)
Reciprocal of the time constant of passive membrane and all other spatially distributed delays in the dendritic network [ms^-1]. Also called average synaptic time constant.
b : tvb.simulator.models.jansen_rit.JansenRit.b = NArray(label=’$$b$$‘, dtype=float64, default=array([0.05]), dim_names=(), ndim=None, required=True)
Reciprocal of the time constant of passive membrane and all other spatially distributed delays in the dendritic network [ms^-1]. Also called average synaptic time constant.
v0 : tvb.simulator.models.jansen_rit.JansenRit.v0 = NArray(label=’$$v_0$$‘, dtype=float64, default=array([5.52]), dim_names=(), ndim=None, required=True)

Firing threshold (PSP) for which a 50% firing rate is achieved. In other words, it is the value of the average membrane potential corresponding to the inflection point of the sigmoid [mV].

The usual value for this parameter is 6.0.

nu_max : tvb.simulator.models.jansen_rit.JansenRit.nu_max = NArray(label=’$$\\nu_{max}$$‘, dtype=float64, default=array([0.0025]), dim_names=(), ndim=None, required=True)
Determines the maximum firing rate of the neural population [s^-1].
r : tvb.simulator.models.jansen_rit.JansenRit.r = NArray(label=’$$r$$‘, dtype=float64, default=array([0.56]), dim_names=(), ndim=None, required=True)
Steepness of the sigmoidal transformation [mV^-1].
J : tvb.simulator.models.jansen_rit.JansenRit.J = NArray(label=’$$J$$‘, dtype=float64, default=array([135.]), dim_names=(), ndim=None, required=True)
Average number of synapses between populations.
a_1 : tvb.simulator.models.jansen_rit.JansenRit.a_1 = NArray(label=’$$\\alpha_1$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Average probability of synaptic contacts in the feedback excitatory loop.
a_2 : tvb.simulator.models.jansen_rit.JansenRit.a_2 = NArray(label=’$$\\alpha_2$$‘, dtype=float64, default=array([0.8]), dim_names=(), ndim=None, required=True)
Average probability of synaptic contacts in the slow feedback excitatory loop.
a_3 : tvb.simulator.models.jansen_rit.JansenRit.a_3 = NArray(label=’$$\\alpha_3$$‘, dtype=float64, default=array([0.25]), dim_names=(), ndim=None, required=True)
Average probability of synaptic contacts in the feedback inhibitory loop.
a_4 : tvb.simulator.models.jansen_rit.JansenRit.a_4 = NArray(label=’$$\\alpha_4$$‘, dtype=float64, default=array([0.25]), dim_names=(), ndim=None, required=True)
Average probability of synaptic contacts in the slow feedback inhibitory loop.
p_min : tvb.simulator.models.jansen_rit.JansenRit.p_min = NArray(label=’$$p_{min}$$‘, dtype=float64, default=array([0.12]), dim_names=(), ndim=None, required=True)
Minimum input firing rate.
p_max : tvb.simulator.models.jansen_rit.JansenRit.p_max = NArray(label=’$$p_{max}$$‘, dtype=float64, default=array([0.32]), dim_names=(), ndim=None, required=True)
Maximum input firing rate.
mu : tvb.simulator.models.jansen_rit.JansenRit.mu = NArray(label=’$$\\mu_{max}$$‘, dtype=float64, default=array([0.22]), dim_names=(), ndim=None, required=True)
Mean input firing rate
state_variable_range : tvb.simulator.models.jansen_rit.JansenRit.state_variable_range = Final(field_type=<class ‘dict’>, default={‘y0’: array([-1., 1.]), ‘y1’: array([-500., 500.]), ‘y2’: array([-50., 50.]), ‘y3’: array([-6., 6.]), ‘y4’: array([-20., 20.]), ‘y5’: array([-500., 500.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.jansen_rit.JansenRit.variables_of_interest = List(of=<class ‘str’>, default=(‘y0’, ‘y1’, ‘y2’, ‘y3’), required=True)
This represents the default state-variables of this Model to be monitored. It can be overridden for each Monitor if desired. The corresponding state-variable indices for this model are $$y0 = 0$$, $$y1 = 1$$, $$y2 = 2$$, $$y3 = 3$$, $$y4 = 4$$, and $$y5 = 5$$

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

A

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

B

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

J

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a_1

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a_2

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a_3

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a_4

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([1, 2], dtype=int32)
dfun(y, c, local_coupling=0.0)[source]

The dynamic equations were taken from [JR_1995]

$\begin{split}\dot{y_0} &= y_3 \\ \dot{y_3} &= A a\,S[y_1 - y_2] - 2a\,y_3 - 2a^2\, y_0 \\ \dot{y_1} &= y_4\\ \dot{y_4} &= A a \,[p(t) + \alpha_2 J S[\alpha_1 J\,y_0]+ c_0] -2a\,y - a^2\,y_1 \\ \dot{y_2} &= y_5 \\ \dot{y_5} &= B b (\alpha_4 J\, S[\alpha_3 J \,y_0]) - 2 b\, y_5 - b^2\,y_2 \\ S[v] &= \frac{2\, \nu_{max}}{1 + \exp^{r(v_0 - v)}}\end{split}$

$$p(t)$$ can be any arbitrary function, including white noise or random numbers taken from a uniform distribution, representing a pulse density with an amplitude varying between 120 and 320

For Evoked Potentials, a transient component of the input, representing the impulse density attribuable to a brief visual input is applied. Time should be in seconds.

$\begin{split}p(t) = q\,(\frac{t}{w})^n \, \exp{-\frac{t}{w}} \\ q = 0.5 \\ n = 7 \\ w = 0.005 [s]\end{split}$
mu

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

nu_max

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

p_max

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

p_min

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

r

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('y0', 'y1', 'y2', 'y3', 'y4', 'y5')
v0

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

class tvb.simulator.models.jansen_rit.ZetterbergJansen(**kwargs)[source]

Zetterberg et al derived a model inspired by the Wilson-Cowan equations. It served as a basis for the later, better known Jansen-Rit model.

 [ZL_1978] Zetterberg LH, Kristiansson L and Mossberg K. Performance of a Model for a Local Neuron Population. Biological Cybernetics 31, 15-26, 1978.
 [JB_1995] Jansen, B., H. and Rit V., G., Electroencephalogram and visual evoked potential generation in a mathematical model of coupled cortical columns, Biological Cybernetics (73) 357:366, 1995.
 [JB_1993] Jansen, B., Zouridakis, G. and Brandt, M., A neurophysiologically-based mathematical model of flash visual evoked potentials
 [M_2007] Moran
 [S_2010] Spiegler
 [A_2012] Auburn
He : tvb.simulator.models.jansen_rit.ZetterbergJansen.He = NArray(label=’$$H_e$$‘, dtype=float64, default=array([3.25]), dim_names=(), ndim=None, required=True)
Maximum amplitude of EPSP [mV]. Also called average synaptic gain.
Hi : tvb.simulator.models.jansen_rit.ZetterbergJansen.Hi = NArray(label=’$$H_i$$‘, dtype=float64, default=array([22.]), dim_names=(), ndim=None, required=True)
Maximum amplitude of IPSP [mV]. Also called average synaptic gain.
ke : tvb.simulator.models.jansen_rit.ZetterbergJansen.ke = NArray(label=’$$\\kappa_e$$‘, dtype=float64, default=array([0.1]), dim_names=(), ndim=None, required=True)
Reciprocal of the time constant of passive membrane and all other spatially distributed delays in the dendritic network [ms^-1]. Also called average synaptic time constant.
ki : tvb.simulator.models.jansen_rit.ZetterbergJansen.ki = NArray(label=’$$\\kappa_i$$‘, dtype=float64, default=array([0.05]), dim_names=(), ndim=None, required=True)
Reciprocal of the time constant of passive membrane and all other spatially distributed delays in the dendritic network [ms^-1]. Also called average synaptic time constant.
e0 : tvb.simulator.models.jansen_rit.ZetterbergJansen.e0 = NArray(label=’$$e_0$$‘, dtype=float64, default=array([0.0025]), dim_names=(), ndim=None, required=True)
Half of the maximum population mean firing rate [ms^-1].
rho_2 : tvb.simulator.models.jansen_rit.ZetterbergJansen.rho_2 = NArray(label=’$$\\rho_2$$‘, dtype=float64, default=array([6.]), dim_names=(), ndim=None, required=True)
Firing threshold (PSP) for which a 50% firing rate is achieved. In other words, it is the value of the average membrane potential corresponding to the inflection point of the sigmoid [mV]. Population mean firing threshold.
rho_1 : tvb.simulator.models.jansen_rit.ZetterbergJansen.rho_1 = NArray(label=’$$\\rho_1$$‘, dtype=float64, default=array([0.56]), dim_names=(), ndim=None, required=True)
Steepness of the sigmoidal transformation [mV^-1].
gamma_1 : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_1 = NArray(label=’$$\\gamma_1$$‘, dtype=float64, default=array([135.]), dim_names=(), ndim=None, required=True)
Average number of synapses between populations (pyramidal to stellate).
gamma_2 : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_2 = NArray(label=’$$\\gamma_2$$‘, dtype=float64, default=array([108.]), dim_names=(), ndim=None, required=True)
Average number of synapses between populations (stellate to pyramidal).
gamma_3 : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_3 = NArray(label=’$$\\gamma_3$$‘, dtype=float64, default=array([33.75]), dim_names=(), ndim=None, required=True)
Connectivity constant (pyramidal to interneurons)
gamma_4 : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_4 = NArray(label=’$$\\gamma_4$$‘, dtype=float64, default=array([33.75]), dim_names=(), ndim=None, required=True)
Connectivity constant (interneurons to pyramidal)
gamma_5 : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_5 = NArray(label=’$$\\gamma_5$$‘, dtype=float64, default=array([15.]), dim_names=(), ndim=None, required=True)
Connectivity constant (interneurons to interneurons)
gamma_1T : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_1T = NArray(label=’$$\\gamma_{1T}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Coupling factor from the extrinisic input to the spiny stellate population.
gamma_2T : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_2T = NArray(label=’$$\\gamma_{2T}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Coupling factor from the extrinisic input to the pyramidal population.
gamma_3T : tvb.simulator.models.jansen_rit.ZetterbergJansen.gamma_3T = NArray(label=’$$\\gamma_{3T}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Coupling factor from the extrinisic input to the inhibitory population.
P : tvb.simulator.models.jansen_rit.ZetterbergJansen.P = NArray(label=’$$P$$‘, dtype=float64, default=array([0.12]), dim_names=(), ndim=None, required=True)
Maximum firing rate to the pyramidal population [ms^-1]. (External stimulus. Constant intensity.Entry point for coupling.)
U : tvb.simulator.models.jansen_rit.ZetterbergJansen.U = NArray(label=’$$U$$‘, dtype=float64, default=array([0.12]), dim_names=(), ndim=None, required=True)
Maximum firing rate to the stellate population [ms^-1]. (External stimulus. Constant intensity.Entry point for coupling.)
Q : tvb.simulator.models.jansen_rit.ZetterbergJansen.Q = NArray(label=’$$Q$$‘, dtype=float64, default=array([0.12]), dim_names=(), ndim=None, required=True)
Maximum firing rate to the interneurons population [ms^-1]. (External stimulus. Constant intensity.Entry point for coupling.)
state_variable_range : tvb.simulator.models.jansen_rit.ZetterbergJansen.state_variable_range = Final(field_type=<class ‘dict’>, default={‘v1’: array([-100., 100.]), ‘y1’: array([-500., 500.]), ‘v2’: array([-100., 50.]), ‘y2’: array([-100., 6.]), ‘v3’: array([-100., 6.]), ‘y3’: array([-100., 6.]), ‘v4’: array([-100., 20.]), ‘y4’: array([-100., 20.]), ‘v5’: array([-100., 20.]), ‘y5’: array([-500., 500.]), ‘v6’: array([-100., 20.]), ‘v7’: array([-100., 20.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.jansen_rit.ZetterbergJansen.variables_of_interest = List(of=<class ‘str’>, default=(‘v6’, ‘v7’, ‘v2’, ‘v3’, ‘v4’, ‘v5’), required=True)
This represents the default state-variables of this Model to be monitored. It can be overridden for each Monitor if desired. The corresponding state-variable indices for this model are $$v_6 = 0$$, $$v_7 = 1$$, $$v_2 = 2$$, $$v_3 = 3$$, $$v_4 = 4$$, and $$v_5 = 5$$

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

He

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Heke = None
Hi

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Hiki = None
P

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Q

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

U

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([10], dtype=int32)
dfun(state_variables, coupling, local_coupling=0.0)[source]

Zetterberg et al derived a model inspired by the Wilson-Cowan equations. It served as a basis for the later, better known Jansen-Rit model.

e0

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_1

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_1T

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_2

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_2T

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_3

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_3T

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_4

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma_5

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

ke

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

ke_2 = None
keke = None
ki

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

ki_2 = None
kiki = None
rho_1

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

rho_2

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

sigma_fun(sv)[source]

Neuronal activation function. This sigmoidal function increases from 0 to Q_max as “sv” increases. sv represents a membrane potential state variable (V).

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('v1', 'y1', 'v2', 'y2', 'v3', 'y3', 'v4', 'y4', 'v5', 'y5', 'v6', 'v7')
update_derived_parameters()[source]
variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

larter_breakspear¶

Larter-Breakspear model based on the Morris-Lecar equations.

class tvb.simulator.models.larter_breakspear.LarterBreakspear(**kwargs)[source]

A modified Morris-Lecar model that includes a third equation which simulates the effect of a population of inhibitory interneurons synapsing on the pyramidal cells.

 [Larteretal_1999] Larter et.al. A coupled ordinary differential equation lattice model for the simulation of epileptic seizures. Chaos. 9(3): 795, 1999.
 [Breaksetal_2003_a] (1, 2) Breakspear, M.; Terry, J. R. & Friston, K. J. Modulation of excitatory synaptic coupling facilitates synchronization and complex dynamics in an onlinear model of neuronal dynamics. Neurocomputing 52–54 (2003).151–158
 [Breaksetal_2003_b] (1, 2, 3) M. J. Breakspear et.al. Modulation of excitatory synaptic coupling facilitates synchronization and complex dynamics in a biophysical model of neuronal dynamics. Network: Computation in Neural Systems 14: 703-732, 2003.
 [Honeyetal_2007] Honey, C.; Kötter, R.; Breakspear, M. & Sporns, O. * Network structure of cerebral cortex shapes functional connectivity on multiple time scales*. (2007) PNAS, 104, 10240
 [Honeyetal_2009] Honey, C. J.; Sporns, O.; Cammoun, L.; Gigandet, X.; Thiran, J. P.; Meuli, R. & Hagmann, P. Predicting human resting-state functional connectivity from structural connectivity. (2009), PNAS, 106, 2035-2040
 [Alstottetal_2009] Alstott, J.; Breakspear, M.; Hagmann, P.; Cammoun, L. & Sporns, O. Modeling the impact of lesions in the human brain. (2009)), PLoS Comput Biol, 5, e1000408

Equations and default parameters are taken from [Breaksetal_2003_b]. All equations and parameters are non-dimensional and normalized. For values of d_v < 0.55, the dynamics of a single column settles onto a solitary fixed point attractor.

Parameters used for simulations in [Breaksetal_2003_a] Table 1. Page 153. Two nodes were coupled. C=0.1

Table 1
Parameter Value
I 0.3
a_ee 0.4
a_ei 0.1
a_ie 1.0
a_ne 1.0
a_ni 0.4
r_NMDA 0.2
delta 0.001
Breakspear et al. 2003
Table 2
Parameter Value
gK 2.0
gL 0.5
gNa 6.7
gCa 1.0
a_ne 1.0
a_ni 0.4
a_ee 0.36
a_ei 2.0
a_ie 2.0
VK -0.7
VL -0.5
VNa 0.53
VCa 1.0
phi 0.7
b 0.1
I 0.3
r_NMDA 0.25
C 0.1
TCa -0.01
d_Ca 0.15
TK 0.0
d_K 0.3
VT 0.0
ZT 0.0
TNa 0.3
d_Na 0.15
d_V 0.65
d_Z d_V
QV_max 1.0
QZ_max 1.0
Alstott et al. 2009

$$\delta_V$$ : for $$\delta_V$$ < 0.55, in an uncoupled network, the system exhibits fixed point dynamics; for 0.55 < $$\delta_V$$ < 0.59, limit cycle attractors; and for $$\delta_V$$ > 0.59 chaotic attractors (eg, d_V=0.6,aee=0.5,aie=0.5, gNa=0, Iext=0.165)

$$\delta_Z$$ this parameter might be spatialized: ones(N,1).*0.65 + modn*(rand(N,1)-0.5);

$$C$$ The long-range coupling $$\delta_C$$ is ‘weak’ in the sense that the model is well behaved for parameter values for which C < a_ee and C << a_ie.

Dynamic equations:

$\begin{split}\dot{V}_k & = - (g_{Ca} + (1 - C) \, r_{NMDA} \, a_{ee} \, Q_V + C \, r_{NMDA} \, a_{ee} \, \langle Q_V\rangle^{k}) \, m_{Ca} \, (V - VCa) \\ & \,\,- g_K \, W \, (V - VK) - g_L \, (V - VL) \\ & \,\,- (g_{Na} \, m_{Na} + (1 - C) \, a_{ee} \, Q_V + C \, a_{ee} \, \langle Q_V\rangle^{k}) \,(V - VNa) \\ & \,\,- a_{ie} \, Z \, Q_Z + a_{ne} \, I \\ & \\ \dot{W}_k & = \phi \, \dfrac{m_K - W}{\tau_{K}} \\ & \nonumber\\ \dot{Z}_k &= b (a_{ni}\, I + a_{ei}\,V\,Q_V) \\ Q_{V} &= Q_{V_{max}} \, (1 + \tanh\left(\dfrac{V_{k} - VT}{\delta_{V}}\right)) \\ Q_{Z} &= Q_{Z_{max}} \, (1 + \tanh\left(\dfrac{Z_{k} - ZT}{\delta_{Z}}\right))\end{split}$

See Equations (7), (3), (6) and (2) respectively in [Breaksetal_2003_a]. Pag: 705-706

gCa : tvb.simulator.models.larter_breakspear.LarterBreakspear.gCa = NArray(label=’$$g_{Ca}$$‘, dtype=float64, default=array([1.1]), dim_names=(), ndim=None, required=True)
Conductance of population of Ca++ channels.
gK : tvb.simulator.models.larter_breakspear.LarterBreakspear.gK = NArray(label=’$$g_{K}$$‘, dtype=float64, default=array([2.]), dim_names=(), ndim=None, required=True)
Conductance of population of K channels.
gL : tvb.simulator.models.larter_breakspear.LarterBreakspear.gL = NArray(label=’$$g_{L}$$‘, dtype=float64, default=array([0.5]), dim_names=(), ndim=None, required=True)
Conductance of population of leak channels.
phi : tvb.simulator.models.larter_breakspear.LarterBreakspear.phi = NArray(label=’$$\\phi$$‘, dtype=float64, default=array([0.7]), dim_names=(), ndim=None, required=True)
Temperature scaling factor.
gNa : tvb.simulator.models.larter_breakspear.LarterBreakspear.gNa = NArray(label=’$$g_{Na}$$‘, dtype=float64, default=array([6.7]), dim_names=(), ndim=None, required=True)
Conductance of population of Na channels.
TK : tvb.simulator.models.larter_breakspear.LarterBreakspear.TK = NArray(label=’$$T_{K}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Threshold value for K channels.
TCa : tvb.simulator.models.larter_breakspear.LarterBreakspear.TCa = NArray(label=’$$T_{Ca}$$‘, dtype=float64, default=array([-0.01]), dim_names=(), ndim=None, required=True)
Threshold value for Ca channels.
TNa : tvb.simulator.models.larter_breakspear.LarterBreakspear.TNa = NArray(label=’$$T_{Na}$$‘, dtype=float64, default=array([0.3]), dim_names=(), ndim=None, required=True)
Threshold value for Na channels.
VCa : tvb.simulator.models.larter_breakspear.LarterBreakspear.VCa = NArray(label=’$$V_{Ca}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Ca Nernst potential.
VK : tvb.simulator.models.larter_breakspear.LarterBreakspear.VK = NArray(label=’$$V_{K}$$‘, dtype=float64, default=array([-0.7]), dim_names=(), ndim=None, required=True)
K Nernst potential.
VL : tvb.simulator.models.larter_breakspear.LarterBreakspear.VL = NArray(label=’$$V_{L}$$‘, dtype=float64, default=array([-0.5]), dim_names=(), ndim=None, required=True)
Nernst potential leak channels.
VNa : tvb.simulator.models.larter_breakspear.LarterBreakspear.VNa = NArray(label=’$$V_{Na}$$‘, dtype=float64, default=array([0.53]), dim_names=(), ndim=None, required=True)
Na Nernst potential.
d_K : tvb.simulator.models.larter_breakspear.LarterBreakspear.d_K = NArray(label=’$$\\delta_{K}$$‘, dtype=float64, default=array([0.3]), dim_names=(), ndim=None, required=True)
Variance of K channel threshold.
tau_K : tvb.simulator.models.larter_breakspear.LarterBreakspear.tau_K = NArray(label=’$$\\tau_{K}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Time constant for K relaxation time (ms)
d_Na : tvb.simulator.models.larter_breakspear.LarterBreakspear.d_Na = NArray(label=’$$\\delta_{Na}$$‘, dtype=float64, default=array([0.15]), dim_names=(), ndim=None, required=True)
Variance of Na channel threshold.
d_Ca : tvb.simulator.models.larter_breakspear.LarterBreakspear.d_Ca = NArray(label=’$$\\delta_{Ca}$$‘, dtype=float64, default=array([0.15]), dim_names=(), ndim=None, required=True)
Variance of Ca channel threshold.
aei : tvb.simulator.models.larter_breakspear.LarterBreakspear.aei = NArray(label=’$$a_{ei}$$‘, dtype=float64, default=array([2.]), dim_names=(), ndim=None, required=True)
Excitatory-to-inhibitory synaptic strength.
aie : tvb.simulator.models.larter_breakspear.LarterBreakspear.aie = NArray(label=’$$a_{ie}$$‘, dtype=float64, default=array([2.]), dim_names=(), ndim=None, required=True)
Inhibitory-to-excitatory synaptic strength.
b : tvb.simulator.models.larter_breakspear.LarterBreakspear.b = NArray(label=’$$b$$‘, dtype=float64, default=array([0.1]), dim_names=(), ndim=None, required=True)
Time constant scaling factor. The original value is 0.1
C : tvb.simulator.models.larter_breakspear.LarterBreakspear.C = NArray(label=’$$C$$‘, dtype=float64, default=array([0.1]), dim_names=(), ndim=None, required=True)
Strength of excitatory coupling. Balance between internal and local (and global) coupling strength. C > 0 introduces interdependences between consecutive columns/nodes. C=1 corresponds to maximum coupling between node and no self-coupling. This strenght should be set to sensible values when a whole network is connected.
ane : tvb.simulator.models.larter_breakspear.LarterBreakspear.ane = NArray(label=’$$a_{ne}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Non-specific-to-excitatory synaptic strength.
ani : tvb.simulator.models.larter_breakspear.LarterBreakspear.ani = NArray(label=’$$a_{ni}$$‘, dtype=float64, default=array([0.4]), dim_names=(), ndim=None, required=True)
Non-specific-to-inhibitory synaptic strength.
aee : tvb.simulator.models.larter_breakspear.LarterBreakspear.aee = NArray(label=’$$a_{ee}$$‘, dtype=float64, default=array([0.4]), dim_names=(), ndim=None, required=True)
Excitatory-to-excitatory synaptic strength.
Iext : tvb.simulator.models.larter_breakspear.LarterBreakspear.Iext = NArray(label=’$$I_{ext}$$‘, dtype=float64, default=array([0.3]), dim_names=(), ndim=None, required=True)
Subcortical input strength. It represents a non-specific excitation or thalamic inputs.
rNMDA : tvb.simulator.models.larter_breakspear.LarterBreakspear.rNMDA = NArray(label=’$$r_{NMDA}$$‘, dtype=float64, default=array([0.25]), dim_names=(), ndim=None, required=True)
Ratio of NMDA to AMPA receptors.
VT : tvb.simulator.models.larter_breakspear.LarterBreakspear.VT = NArray(label=’$$V_{T}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Threshold potential (mean) for excitatory neurons. In [Breaksetal_2003_b] this value is 0.
d_V : tvb.simulator.models.larter_breakspear.LarterBreakspear.d_V = NArray(label=’$$\\delta_{V}$$‘, dtype=float64, default=array([0.65]), dim_names=(), ndim=None, required=True)
Variance of the excitatory threshold. It is one of the main parameters explored in [Breaksetal_2003_b].
ZT : tvb.simulator.models.larter_breakspear.LarterBreakspear.ZT = NArray(label=’$$Z_{T}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Threshold potential (mean) for inihibtory neurons.
d_Z : tvb.simulator.models.larter_breakspear.LarterBreakspear.d_Z = NArray(label=’$$\\delta_{Z}$$‘, dtype=float64, default=array([0.7]), dim_names=(), ndim=None, required=True)
Variance of the inhibitory threshold.
QV_max : tvb.simulator.models.larter_breakspear.LarterBreakspear.QV_max = NArray(label=’$$Q_{max}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Maximal firing rate for excitatory populations (kHz)
QZ_max : tvb.simulator.models.larter_breakspear.LarterBreakspear.QZ_max = NArray(label=’$$Q_{max}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Maximal firing rate for excitatory populations (kHz)
t_scale : tvb.simulator.models.larter_breakspear.LarterBreakspear.t_scale = NArray(label=’$$t_{scale}$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Time scale factor
variables_of_interest : tvb.simulator.models.larter_breakspear.LarterBreakspear.variables_of_interest = List(of=<class ‘str’>, default=(‘V’,), required=True)
This represents the default state-variables of this Model to be monitored. It can be overridden for each Monitor if desired.
state_variable_range : tvb.simulator.models.larter_breakspear.LarterBreakspear.state_variable_range = Final(field_type=<class ‘dict’>, default={‘V’: array([-1.5, 1.5]), ‘W’: array([-1.5, 1.5]), ‘Z’: array([-1.5, 1.5])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

C

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Iext

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

QV_max

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

QZ_max

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

TCa

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

TK

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

TNa

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

VCa

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

VK

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

VL

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

VNa

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

VT

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

ZT

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

aee

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

aei

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

aie

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

ane

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

ani

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([0], dtype=int32)
d_Ca

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

d_K

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

d_Na

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

d_V

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

d_Z

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

dfun(state_variables, coupling, local_coupling=0.0)[source]

Dynamic equations:

$\begin{split}\dot{V}_k & = - (g_{Ca} + (1 - C) \, r_{NMDA} \, a_{ee} \, Q_V + C \, r_{NMDA} \, a_{ee} \, \langle Q_V\rangle^{k}) \, m_{Ca} \, (V - VCa) \\ & \,\,- g_K \, W \, (V - VK) - g_L \, (V - VL) \\ & \,\,- (g_{Na} \, m_{Na} + (1 - C) \, a_{ee} \, Q_V + C \, a_{ee} \, \langle Q_V\rangle^{k}) \,(V - VNa) \\ & \,\,- a_{ie} \, Z \, Q_Z + a_{ne} \, I \\ & \\ \dot{W}_k & = \phi \, \dfrac{m_K - W}{\tau_{K}} \\ & \nonumber\\ \dot{Z}_k &= b (a_{ni}\, I + a_{ei}\,V\,Q_V) \\ Q_{V} &= Q_{V_{max}} \, (1 + \tanh\left(\dfrac{V_{k} - VT}{\delta_{V}}\right)) \\ Q_{Z} &= Q_{Z_{max}} \, (1 + \tanh\left(\dfrac{Z_{k} - ZT}{\delta_{Z}}\right))\end{split}$
gCa

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gK

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gL

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gNa

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

phi

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

rNMDA

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('V', 'W', 'Z')
t_scale

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

tau_K

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

linear¶

Generic linear model.

class tvb.simulator.models.linear.Linear(**kwargs)[source]
gamma : tvb.simulator.models.linear.Linear.gamma = NArray(label=’$$\\gamma$$‘, dtype=float64, default=array([-10.]), dim_names=(), ndim=None, required=True)
The damping coefficient specifies how quickly the node’s activity relaxes, must be larger than the node’s in-degree in order to remain stable.
state_variable_range : tvb.simulator.models.linear.Linear.state_variable_range = Final(field_type=<class ‘dict’>, default={‘x’: array([-1, 1])}, required=True)
Range used for state variable initialization and visualization.

variables_of_interest : tvb.simulator.models.linear.Linear.variables_of_interest = List(of=<class ‘str’>, default=(‘x’,), required=True)

coupling_terms : tvb.simulator.models.linear.Linear.coupling_terms = Final(field_type=<class ‘list’>, default=[‘c’], required=True)

state_variable_dfuns : tvb.simulator.models.linear.Linear.state_variable_dfuns = Final(field_type=<class ‘dict’>, default={‘x’: ‘gamma * x + c’}, required=True)

parameter_names : tvb.simulator.models.linear.Linear.parameter_names = List(of=<class ‘str’>, default=(‘gamma’,), required=True)

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

coupling_terms

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

cvar = array([0], dtype=int32)
dfun(state, coupling, local_coupling=0.0)[source]
$x = a{\gamma} + b$
gamma

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

parameter_names

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

state_variable_dfuns

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('x',)
variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

oscillator¶

Oscillator models.

class tvb.simulator.models.oscillator.Generic2dOscillator(**kwargs)[source]

The Generic2dOscillator model is a generic dynamic system with two state variables. The dynamic equations of this model are composed of two ordinary differential equations comprising two nullclines. The first nullcline is a cubic function as it is found in most neuron and population models; the second nullcline is arbitrarily configurable as a polynomial function up to second order. The manipulation of the latter nullcline’s parameters allows to generate a wide range of different behaviours.

Equations:

$\begin{split}\dot{V} &= d \, \tau (-f V^3 + e V^2 + g V + \alpha W + \gamma I) \\ \dot{W} &= \dfrac{d}{\tau}\,\,(c V^2 + b V - \beta W + a)\end{split}$

See:

 [FH_1961] FitzHugh, R., Impulses and physiological states in theoretical models of nerve membrane, Biophysical Journal 1: 445, 1961.
 [Nagumo_1962] Nagumo et.al, An Active Pulse Transmission Line Simulating Nerve Axon, Proceedings of the IRE 50: 2061, 1962.
 [SJ_2011] Stefanescu, R., Jirsa, V.K. Reduced representations of heterogeneous mixed neural networks with synaptic coupling. Physical Review E, 83, 2011.
 [SJ_2010] Jirsa VK, Stefanescu R. Neural population modes capture biologically realistic large-scale network dynamics. Bulletin of Mathematical Biology, 2010.
 [SJ_2008_a] Stefanescu, R., Jirsa, V.K. A low dimensional description of globally coupled heterogeneous neural networks of excitatory and inhibitory neurons. PLoS Computational Biology, 4(11), 2008).

The model’s ($$V$$, $$W$$) time series and phase-plane its nullclines can be seen in the figure below.

The model with its default parameters exhibits FitzHugh-Nagumo like dynamics.

Table 1
EXCITABLE CONFIGURATION
Parameter Value
a -2.0
b -10.0
c 0.0
d 0.02
I 0.0
limit cycle if a is 2.0
Table 2
BISTABLE CONFIGURATION
Parameter Value
a 1.0
b 0.0
c -5.0
d 0.02
I 0.0
monostable regime: fixed point if Iext=-2.0 limit cycle if Iext=-1.0
Table 3
EXCITABLE CONFIGURATION
(similar to Morris-Lecar)
Parameter Value
a 0.5
b 0.6
c -4.0
d 0.02
I 0.0
excitable regime if b=0.6 oscillatory if b=0.4
Table 4
GhoshetAl, 2008 KnocketAl, 2009
Parameter Value
a 1.05
b -1.00
c 0.0
d 0.1
I 0.0
alpha 1.0
beta 0.2
gamma -1.0
e 0.0
g 1.0
f 1/3
tau 1.25
frequency peak at 10Hz
Table 5
SanzLeonetAl 2013
Parameter Value
a
• 0.5
b -10.0
c 0.0
d 0.02
I 0.0
intrinsic frequency is approx 10 Hz

NOTE: This regime, if I = 2.1, is called subthreshold regime. Unstable oscillations appear through a subcritical Hopf bifurcation.

The ($$V$$, $$W$$) phase-plane for the generic 2D population model for default parameters. The dynamical system has an equilibrium point.
dfun(vw, c, local_coupling=0.0)[source]

The two state variables $$V$$ and $$W$$ are typically considered to represent a function of the neuron’s membrane potential, such as the firing rate or dendritic currents, and a recovery variable, respectively. If there is a time scale hierarchy, then typically $$V$$ is faster than $$W$$ corresponding to a value of $$\tau$$ greater than 1.

The equations of the generic 2D population model read

$\begin{split}\dot{V} &= d \, \tau (-f V^3 + e V^2 + g V + \alpha W + \gamma I) \\ \dot{W} &= \dfrac{d}{\tau}\,\,(c V^2 + b V - \beta W + a)\end{split}$

where external currents $$I$$ provide the entry point for local, long-range connectivity and stimulation.

tau : tvb.simulator.models.oscillator.Generic2dOscillator.tau = NArray(label=’$$\\tau$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
A time-scale hierarchy can be introduced for the state variables $$V$$ and $$W$$. Default parameter is 1, which means no time-scale hierarchy.
I : tvb.simulator.models.oscillator.Generic2dOscillator.I = NArray(label=’$$I_{ext}$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Baseline shift of the cubic nullcline
a : tvb.simulator.models.oscillator.Generic2dOscillator.a = NArray(label=’$$a$$‘, dtype=float64, default=array([-2.]), dim_names=(), ndim=None, required=True)
Vertical shift of the configurable nullcline
b : tvb.simulator.models.oscillator.Generic2dOscillator.b = NArray(label=’$$b$$‘, dtype=float64, default=array([-10.]), dim_names=(), ndim=None, required=True)
Linear slope of the configurable nullcline
c : tvb.simulator.models.oscillator.Generic2dOscillator.c = NArray(label=’$$c$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Parabolic term of the configurable nullcline
d : tvb.simulator.models.oscillator.Generic2dOscillator.d = NArray(label=’$$d$$‘, dtype=float64, default=array([0.02]), dim_names=(), ndim=None, required=True)
Temporal scale factor. Warning: do not use it unless you know what you are doing and know about time tides.
e : tvb.simulator.models.oscillator.Generic2dOscillator.e = NArray(label=’$$e$$‘, dtype=float64, default=array([3.]), dim_names=(), ndim=None, required=True)
Coefficient of the quadratic term of the cubic nullcline.
f : tvb.simulator.models.oscillator.Generic2dOscillator.f = NArray(label=’$$f$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Coefficient of the cubic term of the cubic nullcline.
g : tvb.simulator.models.oscillator.Generic2dOscillator.g = NArray(label=’$$g$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Coefficient of the linear term of the cubic nullcline.
alpha : tvb.simulator.models.oscillator.Generic2dOscillator.alpha = NArray(label=’$$\\alpha$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Constant parameter to scale the rate of feedback from the slow variable to the fast variable.
beta : tvb.simulator.models.oscillator.Generic2dOscillator.beta = NArray(label=’$$\\beta$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Constant parameter to scale the rate of feedback from the slow variable to itself
gamma : tvb.simulator.models.oscillator.Generic2dOscillator.gamma = NArray(label=’$$\\gamma$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Constant parameter to reproduce FHN dynamics where excitatory input currents are negative. It scales both I and the long range coupling term.
state_variable_range : tvb.simulator.models.oscillator.Generic2dOscillator.state_variable_range = Final(field_type=<class ‘dict’>, default={‘V’: array([-2., 4.]), ‘W’: array([-6., 6.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random initial conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.oscillator.Generic2dOscillator.variables_of_interest = List(of=<class ‘str’>, default=(‘V’,), required=True)
The quantities of interest for monitoring for the generic 2D oscillator.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

I

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

alpha

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

beta

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([0], dtype=int32)
d

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

dfun(vw, c, local_coupling=0.0)[source]

The two state variables $$V$$ and $$W$$ are typically considered to represent a function of the neuron’s membrane potential, such as the firing rate or dendritic currents, and a recovery variable, respectively. If there is a time scale hierarchy, then typically $$V$$ is faster than $$W$$ corresponding to a value of $$\tau$$ greater than 1.

The equations of the generic 2D population model read

$\begin{split}\dot{V} &= d \, \tau (-f V^3 + e V^2 + g V + \alpha W + \gamma I) \\ \dot{W} &= \dfrac{d}{\tau}\,\,(c V^2 + b V - \beta W + a)\end{split}$

where external currents $$I$$ provide the entry point for local, long-range connectivity and stimulation.

e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

f

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

g

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

gamma

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('V', 'W')
tau

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

class tvb.simulator.models.oscillator.Kuramoto(**kwargs)[source]

The Kuramoto model is a model of synchronization phenomena derived by Yoshiki Kuramoto in 1975 which has since been applied to diverse domains including the study of neuronal oscillations and synchronization.

See:

 [YK_1975] Y. Kuramoto, in: H. Arakai (Ed.), International Symposium on Mathematical Problems in Theoretical Physics, Lecture Notes in Physics, page 420, vol. 39, 1975.
 [SS_2000] S. H. Strogatz. From Kuramoto to Crawford: exploring the onset of synchronization in populations of coupled oscillators. Physica D, 143, 2000.
 [JC_2011] J. Cabral, E. Hugues, O. Sporns, G. Deco. Role of local network oscillations in resting-state functional connectivity. NeuroImage, 57, 1, 2011.

The $$\theta$$ variable is the phase angle of the oscillation.

Dynamic equations:
$\dot{\theta}_{k} = \omega_{k} + \mathbf{\Gamma}(\theta_k, \theta_j, u_{kj}) + \sin(W_{\zeta}\theta)$
omega : tvb.simulator.models.oscillator.Kuramoto.omega = NArray(label=’$$\\omega$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
$$\omega$$ sets the base line frequency for the Kuramoto oscillator in [rad/ms]
state_variable_range : tvb.simulator.models.oscillator.Kuramoto.state_variable_range = Final(field_type=<class ‘dict’>, default={‘theta’: array([0. , 6.28318531])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random initial conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.oscillator.Kuramoto.variables_of_interest = List(of=<class ‘str’>, default=(‘theta’,), required=True)
This represents the default state-variables of this Model to be monitored. It can be overridden for each Monitor if desired. The Kuramoto model, however, only has one state variable with and index of 0, so it is not necessary to change the default here.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

cvar = array([0], dtype=int32)
dfun(state_variables, coupling, local_coupling=0.0, ev=<function evaluate at 0x7f014ab4f7a0>, sin=<ufunc 'sin'>, pi2=6.283185307179586)[source]

The $$\theta$$ variable is the phase angle of the oscillation.

$\dot{\theta}_{k} = \omega_{k} + \mathbf{\Gamma}(\theta_k, \theta_j, u_{kj}) + \sin(W_{\zeta}\theta)$

where $$I$$ is the input via local and long range connectivity, passing first through the Kuramoto coupling function,

omega

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ['theta']
variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

class tvb.simulator.models.oscillator.SupHopf(**kwargs)[source]

The supHopf model describes the normal form of a supercritical Hopf bifurcation in Cartesian coordinates. This normal form has a supercritical bifurcation at a=0 with a the bifurcation parameter in the model. So for a < 0, the local dynamics has a stable fixed point and the system corresponds to a damped oscillatory state, whereas for a > 0, the local dynamics enters in a stable limit cycle and the system switches to an oscillatory state.

See for examples:

 [Kuznetsov_2013] Kuznetsov, Y.A. Elements of applied bifurcation theory. Springer Sci & Business Media, 2013, vol. 112.
 [Deco_2017a] Deco, G., Kringelbach, M.L., Jirsa, V.K., Ritter, P. The dynamics of resting fluctuations in the brain: metastability and its dynamical cortical core Sci Reports, 2017, 7: 3095.

The equations of the supHopf equations read as follows:

$\begin{split}\dot{x}_{i} &= (a_{i} - x_{i}^{2} - y_{i}^{2})x_{i} - {\omega}{i}y_{i} \\ \dot{y}_{i} &= (a_{i} - x_{i}^{2} - y_{i}^{2})y_{i} + {\omega}{i}x_{i}\end{split}$

where a is the local bifurcation parameter and omega the angular frequency.

a : tvb.simulator.models.oscillator.SupHopf.a = NArray(label=’$$a$$‘, dtype=float64, default=array([-0.5]), dim_names=(), ndim=None, required=True)
Local bifurcation parameter.
omega : tvb.simulator.models.oscillator.SupHopf.omega = NArray(label=’$$\\omega$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Angular frequency.
state_variable_range : tvb.simulator.models.oscillator.SupHopf.state_variable_range = Final(field_type=<class ‘dict’>, default={‘x’: array([-5., 5.]), ‘y’: array([-5., 5.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random initial conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.oscillator.SupHopf.variables_of_interest = List(of=<class ‘str’>, default=(‘x’,), required=True)
Quantities of supHopf available to monitor.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([0, 1], dtype=int32)
dfun(x, c, local_coupling=0.0)[source]

Computes the derivatives of the state-variables of supHopf with respect to time.

The equations of the supHopf equations read as follows:

$\begin{split}\dot{x}_{i} &= (a_{i} - x_{i}^{2} - y_{i}^{2})x_{i} - {\omega}{i}y_{i} \\ \dot{y}_{i} &= (a_{i} - x_{i}^{2} - y_{i}^{2})y_{i} + {\omega}{i}x_{i}\end{split}$

where a is the local bifurcation parameter and omega the angular frequency.

omega

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ['x', 'y']
variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

stefanescu_jirsa¶

Models developed by Stefanescu-Jirsa, based on reduced-set analyses of infinite populations.

class tvb.simulator.models.stefanescu_jirsa.ReducedSetBase(**kwargs)[source]

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

configure()[source]
nu = 1500
number_of_modes = 3
nv = 1500
class tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo(**kwargs)[source]

A reduced representation of a set of Fitz-Hugh Nagumo oscillators, [SJ_2008].

The models ($$\xi$$, $$\eta$$) phase-plane, including a representation of the vector field as well as its nullclines, using default parameters, can be seen below:

The system’s equations for the i-th mode at node q are:

$\begin{split}\dot{\xi}_{i} &= c\left(\xi_i-e_i\frac{\xi_{i}^3}{3} -\eta_{i}\right) + K_{11}\left[\sum_{k=1}^{o} A_{ik}\xi_k-\xi_i\right] - K_{12}\left[\sum_{k =1}^{o} B_{i k}\alpha_k-\xi_i\right] + cIE_i \\ &\, + \left[\sum_{k=1}^{o} \mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o} W_{\zeta}\cdot\xi_{kr} \right] \\ \dot{\eta}_i &= \frac{1}{c}\left(\xi_i-b\eta_i+m_i\right) \\ & \\ \dot{\alpha}_i &= c\left(\alpha_i-f_i\frac{\alpha_i^3}{3}-\beta_i\right) + K_{21}\left[\sum_{k=1}^{o} C_{ik}\xi_i-\alpha_i\right] + cII_i \\ & \, + \left[\sum_{k=1}^{o} \mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o} W_{\zeta}\cdot\xi_{kr}\right] \\ & \\ \dot{\beta}_i &= \frac{1}{c}\left(\alpha_i-b\beta_i+n_i\right)\end{split}$
update_derived_parameters()[source]

Calculate coefficients for the Reduced FitzHugh-Nagumo oscillator based neural field model. Specifically, this method implements equations for calculating coefficients found in the supplemental material of [SJ_2008].

Include equations here...

#NOTE: In the Article this modelis called StefanescuJirsa2D

tau : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.tau = NArray(label=’$$\\tau$$‘, dtype=float64, default=array([3.]), dim_names=(), ndim=None, required=True)
doc...(prob something about timescale seperation)
a : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.a = NArray(label=’$$a$$‘, dtype=float64, default=array([0.45]), dim_names=(), ndim=None, required=True)
doc...
b : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.b = NArray(label=’$$b$$‘, dtype=float64, default=array([0.9]), dim_names=(), ndim=None, required=True)
doc...
K11 : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.K11 = NArray(label=’$$K_{11}$$‘, dtype=float64, default=array([0.5]), dim_names=(), ndim=None, required=True)
Internal coupling, excitatory to excitatory
K12 : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.K12 = NArray(label=’$$K_{12}$$‘, dtype=float64, default=array([0.15]), dim_names=(), ndim=None, required=True)
Internal coupling, inhibitory to excitatory
K21 : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.K21 = NArray(label=’$$K_{21}$$‘, dtype=float64, default=array([0.15]), dim_names=(), ndim=None, required=True)
Internal coupling, excitatory to inhibitory
sigma : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.sigma = NArray(label=’$$\\sigma$$‘, dtype=float64, default=array([0.35]), dim_names=(), ndim=None, required=True)
Standard deviation of Gaussian distribution
mu : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.mu = NArray(label=’$$\\mu$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Mean of Gaussian distribution
state_variable_range : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.state_variable_range = Final(field_type=<class ‘dict’>, default={‘xi’: array([-4., 4.]), ‘eta’: array([-3., 3.]), ‘alpha’: array([-4., 4.]), ‘beta’: array([-3., 3.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.variables_of_interest = List(of=<class ‘str’>, default=(‘xi’, ‘alpha’), required=True)
This represents the default state-variables of this Model to be monitored. It can be overridden for each Monitor if desired. The corresponding state-variable indices for this model are $$\xi = 0$$, $$\eta = 1$$, $$\alpha = 2$$, and $$\beta= 3$$.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

Aik = None
Bik = None
Cik = None
IE_i = None
II_i = None
K11

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

K12

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

K21

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([0, 2], dtype=int32)
dfun(state_variables, coupling, local_coupling=0.0)[source]

The system’s equations for the i-th mode at node q are:

$\begin{split}\dot{\xi}_{i} &= c\left(\xi_i-e_i\frac{\xi_{i}^3}{3} -\eta_{i}\right) + K_{11}\left[\sum_{k=1}^{o} A_{ik}\xi_k-\xi_i\right] - K_{12}\left[\sum_{k =1}^{o} B_{i k}\alpha_k-\xi_i\right] + cIE_i \\ &\, + \left[\sum_{k=1}^{o} \mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o} W_{\zeta}\cdot\xi_{kr} \right] \\ \dot{\eta}_i &= \frac{1}{c}\left(\xi_i-b\eta_i+m_i\right) \\ & \\ \dot{\alpha}_i &= c\left(\alpha_i-f_i\frac{\alpha_i^3}{3}-\beta_i\right) + K_{21}\left[\sum_{k=1}^{o} C_{ik}\xi_i-\alpha_i\right] + cII_i \\ & \, + \left[\sum_{k=1}^{o} \mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o} W_{\zeta}\cdot\xi_{kr}\right] \\ & \\ \dot{\beta}_i &= \frac{1}{c}\left(\alpha_i-b\beta_i+n_i\right)\end{split}$
e_i = None
f_i = None
m_i = None
mu

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

n_i = None
sigma

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ('xi', 'eta', 'alpha', 'beta')
tau

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

update_derived_parameters()[source]

Calculate coefficients for the Reduced FitzHugh-Nagumo oscillator based neural field model. Specifically, this method implements equations for calculating coefficients found in the supplemental material of [SJ_2008].

Include equations here...

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

class tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose(**kwargs)[source]
 [SJ_2008] (1, 2, 3, 4, 5, 6) Stefanescu and Jirsa, PLoS Computational Biology, A Low Dimensional Description of Globally Coupled Heterogeneous Neural Networks of Excitatory and Inhibitory 4, 11, 26–36, 2008.

The models ($$\xi$$, $$\eta$$) phase-plane, including a representation of the vector field as well as its nullclines, using default parameters, can be seen below:

The dynamic equations were orginally taken from [SJ_2008].

The equations of the population model for i-th mode at node q are:

$\begin{split}\dot{\xi}_i &= \eta_i-a_i\xi_i^3 + b_i\xi_i^2- \tau_i + K_{11} \left[\sum_{k=1}^{o} A_{ik} \xi_k - \xi_i \right] - K_{12} \left[\sum_{k=1}^{o} B_{ik} \alpha_k - \xi_i\right] + IE_i \\ &\, + \left[\sum_{k=1}^{o} \mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o} W_{\zeta}\cdot\xi_{kr} \right] \\ & \\ \dot{\eta}_i &= c_i-d_i\xi_i^2 -\tau_i \\ & \\ \dot{\tau}_i &= rs\xi_i - r\tau_i -m_i \\ & \\ \dot{\alpha}_i &= \beta_i - e_i \alpha_i^3 + f_i \alpha_i^2 - \gamma_i + K_{21} \left[\sum_{k=1}^{o} C_{ik} \xi_k - \alpha_i \right] + II_i \\ &\, +\left[\sum_{k=1}^{o}\mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o}W_{\zeta}\cdot\xi_{kr}\right] \\ & \\ \dot{\beta}_i &= h_i - p_i \alpha_i^2 - \beta_i \\ \dot{\gamma}_i &= rs \alpha_i - r \gamma_i - n_i\end{split}$
update_derived_parameters(corrected_d_p=True)[source]

Calculate coefficients for the neural field model based on a Reduced set of Hindmarsh-Rose oscillators. Specifically, this method implements equations for calculating coefficients found in the supplemental material of [SJ_2008].

Include equations here...

#NOTE: In the Article this modelis called StefanescuJirsa3D

r : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.r = NArray(label=’$$r$$‘, dtype=float64, default=array([0.006]), dim_names=(), ndim=None, required=True)
a : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.a = NArray(label=’$$a$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Dimensionless parameter as in the Hindmarsh-Rose model
b : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.b = NArray(label=’$$b$$‘, dtype=float64, default=array([3.]), dim_names=(), ndim=None, required=True)
Dimensionless parameter as in the Hindmarsh-Rose model
c : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.c = NArray(label=’$$c$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Dimensionless parameter as in the Hindmarsh-Rose model
d : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.d = NArray(label=’$$d$$‘, dtype=float64, default=array([5.]), dim_names=(), ndim=None, required=True)
Dimensionless parameter as in the Hindmarsh-Rose model
s : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.s = NArray(label=’$$s$$‘, dtype=float64, default=array([4.]), dim_names=(), ndim=None, required=True)
Adaptation paramters, governs feedback
xo : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.xo = NArray(label=’$$x_{o}$$‘, dtype=float64, default=array([-1.6]), dim_names=(), ndim=None, required=True)
Leftmost equilibrium point of x
K11 : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.K11 = NArray(label=’$$K_{11}$$‘, dtype=float64, default=array([0.5]), dim_names=(), ndim=None, required=True)
Internal coupling, excitatory to excitatory
K12 : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.K12 = NArray(label=’$$K_{12}$$‘, dtype=float64, default=array([0.1]), dim_names=(), ndim=None, required=True)
Internal coupling, inhibitory to excitatory
K21 : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.K21 = NArray(label=’$$K_{21}$$‘, dtype=float64, default=array([0.15]), dim_names=(), ndim=None, required=True)
Internal coupling, excitatory to inhibitory
sigma : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.sigma = NArray(label=’$$\\sigma$$‘, dtype=float64, default=array([0.3]), dim_names=(), ndim=None, required=True)
Standard deviation of Gaussian distribution
mu : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.mu = NArray(label=’$$\\mu$$‘, dtype=float64, default=array([3.3]), dim_names=(), ndim=None, required=True)
Mean of Gaussian distribution
state_variable_range : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.state_variable_range = Final(field_type=<class ‘dict’>, default={‘xi’: array([-4., 4.]), ‘eta’: array([-25., 20.]), ‘tau’: array([ 2., 10.]), ‘alpha’: array([-4., 4.]), ‘beta’: array([-20., 20.]), ‘gamma’: array([ 2., 10.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.variables_of_interest = List(of=<class ‘str’>, default=(‘xi’, ‘eta’, ‘tau’), required=True)
This represents the default state-variables of this Model to be monitored. It can be overridden for each Monitor if desired. The corresponding state-variable indices for this model are $$\xi = 0$$, $$\eta = 1$$, $$\tau = 2$$, $$\alpha = 3$$, $$\beta = 4$$, and $$\gamma = 5$$

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

A_ik = None
B_ik = None
C_ik = None
IE_i = None
II_i = None
K11

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

K12

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

K21

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a_i = None
b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b_i = None
c

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c_i = None
cvar = array([0, 3], dtype=int32)
d

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

d_i = None
dfun(state_variables, coupling, local_coupling=0.0)[source]

The equations of the population model for i-th mode at node q are:

$\begin{split}\dot{\xi}_i &= \eta_i-a_i\xi_i^3 + b_i\xi_i^2- \tau_i + K_{11} \left[\sum_{k=1}^{o} A_{ik} \xi_k - \xi_i \right] - K_{12} \left[\sum_{k=1}^{o} B_{ik} \alpha_k - \xi_i\right] + IE_i \\ &\, + \left[\sum_{k=1}^{o} \mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o} W_{\zeta}\cdot\xi_{kr} \right] \\ & \\ \dot{\eta}_i &= c_i-d_i\xi_i^2 -\tau_i \\ & \\ \dot{\tau}_i &= rs\xi_i - r\tau_i -m_i \\ & \\ \dot{\alpha}_i &= \beta_i - e_i \alpha_i^3 + f_i \alpha_i^2 - \gamma_i + K_{21} \left[\sum_{k=1}^{o} C_{ik} \xi_k - \alpha_i \right] + II_i \\ &\, +\left[\sum_{k=1}^{o}\mathbf{\Gamma}(\xi_{kq}, \xi_{kr}, u_{qr})\right] + \left[\sum_{k=1}^{o}W_{\zeta}\cdot\xi_{kr}\right] \\ & \\ \dot{\beta}_i &= h_i - p_i \alpha_i^2 - \beta_i \\ \dot{\gamma}_i &= rs \alpha_i - r \gamma_i - n_i\end{split}$
e_i = None
f_i = None
h_i = None
m_i = None
mu

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

n_i = None
p_i = None
r

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

s

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

sigma

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ['xi', 'eta', 'tau', 'alpha', 'beta', 'gamma']
update_derived_parameters(corrected_d_p=True)[source]

Calculate coefficients for the neural field model based on a Reduced set of Hindmarsh-Rose oscillators. Specifically, this method implements equations for calculating coefficients found in the supplemental material of [SJ_2008].

Include equations here...

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

xo

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

wilson_cowan¶

Wilson-Cowan equations based model definition.

class tvb.simulator.models.wilson_cowan.WilsonCowan(**kwargs)[source]

References:

 [WC_1972] (1, 2) Wilson, H.R. and Cowan, J.D. Excitatory and inhibitory interactions in localized populations of model neurons, Biophysical journal, 12: 1-24, 1972.
 [WC_1973] Wilson, H.R. and Cowan, J.D A Mathematical Theory of the Functional Dynamics of Cortical and Thalamic Nervous Tissue
 [D_2011] Daffertshofer, A. and van Wijk, B. On the influence of amplitude on the connectivity between phases Frontiers in Neuroinformatics, July, 2011

Used Eqns 11 and 12 from [WC_1972] in dfun. P and Q represent external inputs, which when exploring the phase portrait of the local model are set to constant values. However in the case of a full network, P and Q are the entry point to our long range and local couplings, that is, the activity from all other nodes is the external input to the local population.

The default parameters are taken from figure 4 of [WC_1972], pag. 10

In [WC_1973] they present a model of neural tissue on the pial surface is. See Fig. 1 in page 58. The following local couplings (lateral interactions) occur given a region i and a region j:

E_i-> E_j E_i-> I_j I_i-> I_j I_i-> E_j
Table 1
SanzLeonetAl, 2014
Parameter Value
k_e, k_i 1.00
r_e, r_i 0.00
tau_e, tau_i 10.0
c_1 10.0
c_2 6.0
c_3 1.0
c_4 1.0
a_e, a_i 1.0
b_e, b_i 0.0
theta_e 2.0
theta_i 3.5
alpha_e 1.2
alpha_i 2.0
P 0.5
Q 0
c_e, c_i 1.0
alpha_e 1.2
alpha_i 2.0
frequency peak at 20 Hz

The parameters in Table 1 reproduce Figure A1 in [D_2011] but set the limit cycle frequency to a sensible value (eg, 20Hz).

Model bifurcation parameters:
• $$c_1$$
• $$P$$

The models ($$E$$, $$I$$) phase-plane, including a representation of the vector field as well as its nullclines, using default parameters, can be seen below:

The general formulation for the textit{textbf{Wilson-Cowan}} model as a dynamical unit at a node $k$ in a BNM with $l$ nodes reads:

$\begin{split}\dot{E}_k &= \dfrac{1}{\tau_e} (-E_k + (k_e - r_e E_k) \mathcal{S}_e (\alpha_e \left( c_{ee} E_k - c_{ei} I_k + P_k - \theta_e + \mathbf{\Gamma}(E_k, E_j, u_{kj}) + W_{\zeta}\cdot E_j + W_{\zeta}\cdot I_j\right) ))\\ \dot{I}_k &= \dfrac{1}{\tau_i} (-I_k + (k_i - r_i I_k) \mathcal{S}_i (\alpha_i \left( c_{ie} E_k - c_{ee} I_k + Q_k - \theta_i + \mathbf{\Gamma}(E_k, E_j, u_{kj}) + W_{\zeta}\cdot E_j + W_{\zeta}\cdot I_j\right) ))\end{split}$
c_ee : tvb.simulator.models.wilson_cowan.WilsonCowan.c_ee = NArray(label=’$$c_{ee}$$‘, dtype=float64, default=array([12.]), dim_names=(), ndim=None, required=True)
Excitatory to excitatory coupling coefficient
c_ei : tvb.simulator.models.wilson_cowan.WilsonCowan.c_ei = NArray(label=’$$c_{ei}$$‘, dtype=float64, default=array([4.]), dim_names=(), ndim=None, required=True)
Inhibitory to excitatory coupling coefficient
c_ie : tvb.simulator.models.wilson_cowan.WilsonCowan.c_ie = NArray(label=’$$c_{ie}$$‘, dtype=float64, default=array([13.]), dim_names=(), ndim=None, required=True)
Excitatory to inhibitory coupling coefficient.
c_ii : tvb.simulator.models.wilson_cowan.WilsonCowan.c_ii = NArray(label=’$$c_{ii}$$‘, dtype=float64, default=array([11.]), dim_names=(), ndim=None, required=True)
Inhibitory to inhibitory coupling coefficient.
tau_e : tvb.simulator.models.wilson_cowan.WilsonCowan.tau_e = NArray(label=’$$\\tau_e$$‘, dtype=float64, default=array([10.]), dim_names=(), ndim=None, required=True)
Excitatory population, membrane time-constant [ms]
tau_i : tvb.simulator.models.wilson_cowan.WilsonCowan.tau_i = NArray(label=’$$\\tau_i$$‘, dtype=float64, default=array([10.]), dim_names=(), ndim=None, required=True)
Inhibitory population, membrane time-constant [ms]
a_e : tvb.simulator.models.wilson_cowan.WilsonCowan.a_e = NArray(label=’$$a_e$$‘, dtype=float64, default=array([1.2]), dim_names=(), ndim=None, required=True)
The slope parameter for the excitatory response function
b_e : tvb.simulator.models.wilson_cowan.WilsonCowan.b_e = NArray(label=’$$b_e$$‘, dtype=float64, default=array([2.8]), dim_names=(), ndim=None, required=True)
Position of the maximum slope of the excitatory sigmoid function
c_e : tvb.simulator.models.wilson_cowan.WilsonCowan.c_e = NArray(label=’$$c_e$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
The amplitude parameter for the excitatory response function
theta_e : tvb.simulator.models.wilson_cowan.WilsonCowan.theta_e = NArray(label=’$$\\theta_e$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Excitatory threshold
a_i : tvb.simulator.models.wilson_cowan.WilsonCowan.a_i = NArray(label=’$$a_i$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
The slope parameter for the inhibitory response function
b_i : tvb.simulator.models.wilson_cowan.WilsonCowan.b_i = NArray(label=’$$b_i$$‘, dtype=float64, default=array([4.]), dim_names=(), ndim=None, required=True)
Position of the maximum slope of a sigmoid function [in threshold units]
theta_i : tvb.simulator.models.wilson_cowan.WilsonCowan.theta_i = NArray(label=’$$\\theta_i$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
Inhibitory threshold
c_i : tvb.simulator.models.wilson_cowan.WilsonCowan.c_i = NArray(label=’$$c_i$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
The amplitude parameter for the inhibitory response function
r_e : tvb.simulator.models.wilson_cowan.WilsonCowan.r_e = NArray(label=’$$r_e$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Excitatory refractory period
r_i : tvb.simulator.models.wilson_cowan.WilsonCowan.r_i = NArray(label=’$$r_i$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Inhibitory refractory period
k_e : tvb.simulator.models.wilson_cowan.WilsonCowan.k_e = NArray(label=’$$k_e$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Maximum value of the excitatory response function
k_i : tvb.simulator.models.wilson_cowan.WilsonCowan.k_i = NArray(label=’$$k_i$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
Maximum value of the inhibitory response function
P : tvb.simulator.models.wilson_cowan.WilsonCowan.P = NArray(label=’$$P$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
External stimulus to the excitatory population. Constant intensity.Entry point for coupling.
Q : tvb.simulator.models.wilson_cowan.WilsonCowan.Q = NArray(label=’$$Q$$‘, dtype=float64, default=array([0.]), dim_names=(), ndim=None, required=True)
External stimulus to the inhibitory population. Constant intensity.Entry point for coupling.
alpha_e : tvb.simulator.models.wilson_cowan.WilsonCowan.alpha_e = NArray(label=’$$\\alpha_e$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
External stimulus to the excitatory population. Constant intensity.Entry point for coupling.
alpha_i : tvb.simulator.models.wilson_cowan.WilsonCowan.alpha_i = NArray(label=’$$\\alpha_i$$‘, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)
External stimulus to the inhibitory population. Constant intensity.Entry point for coupling.
state_variable_range : tvb.simulator.models.wilson_cowan.WilsonCowan.state_variable_range = Final(field_type=<class ‘dict’>, default={‘E’: array([0., 1.]), ‘I’: array([0., 1.])}, required=True)
The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn’t started from an explicit history, it is also provides the default range of phase-plane plots.
variables_of_interest : tvb.simulator.models.wilson_cowan.WilsonCowan.variables_of_interest = List(of=<class ‘str’>, default=(‘E’,), required=True)
This represents the default state-variables of this Model to be monitored. It can be overridden for each Monitor if desired. The corresponding state-variable indices for this model are $$E = 0$$ and $$I = 1$$.

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

P

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

Q

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

alpha_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

alpha_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c_ee

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c_ei

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c_ie

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

c_ii

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

cvar = array([0, 1], dtype=int32)
dfun(state_variables, coupling, local_coupling=0.0)[source]
$\begin{split}\tau \dot{x}(t) &= -z(t) + \phi(z(t)) \\ \phi(x) &= \frac{c}{1-exp(-a (x-b))}\end{split}$
k_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

k_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

r_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

r_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ['E', 'I']
tau_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

tau_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

theta_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

theta_i

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

wong_wang¶

Models based on Wong-Wang’s work.

class tvb.simulator.models.wong_wang.ReducedWongWang(**kwargs)[source]
 [WW_2006] Kong-Fatt Wong and Xiao-Jing Wang, A Recurrent Network Mechanism of Time Integration in Perceptual Decisions. Journal of Neuroscience 26(4), 1314-1328, 2006.
 [DPA_2013] (1, 2) Deco Gustavo, Ponce Alvarez Adrian, Dante Mantini, Gian Luca Romani, Patric Hagmann and Maurizio Corbetta. Resting-State Functional Connectivity Emerges from Structurally and Dynamically Shaped Slow Linear Fluctuations. The Journal of Neuroscience 32(27), 11239-11252, 2013.

Equations taken from [DPA_2013] , page 11242

$\begin{split}x_k &= w\,J_N \, S_k + I_o + J_N \mathbf\Gamma(S_k, S_j, u_{kj})\\ H(x_k) &= \dfrac{ax_k - b}{1 - \exp(-d(ax_k -b))}\\ \dot{S}_k &= -\dfrac{S_k}{\tau_s} + (1 - S_k) \, H(x_k) \, \gamma\end{split}$
a : tvb.simulator.models.wong_wang.ReducedWongWang.a = NArray(label=’$$a$$‘, dtype=float64, default=array([0.27]), dim_names=(), ndim=None, required=True)
[n/C]. Input gain parameter, chosen to fit numerical solutions.
b : tvb.simulator.models.wong_wang.ReducedWongWang.b = NArray(label=’$$b$$‘, dtype=float64, default=array([0.108]), dim_names=(), ndim=None, required=True)
[kHz]. Input shift parameter chosen to fit numerical solutions.
d : tvb.simulator.models.wong_wang.ReducedWongWang.d = NArray(label=’$$d$$‘, dtype=float64, default=array([154.]), dim_names=(), ndim=None, required=True)
[ms]. Parameter chosen to fit numerical solutions.
gamma : tvb.simulator.models.wong_wang.ReducedWongWang.gamma = NArray(label=’$$\\gamma$$‘, dtype=float64, default=array([0.641]), dim_names=(), ndim=None, required=True)
Kinetic parameter
tau_s : tvb.simulator.models.wong_wang.ReducedWongWang.tau_s = NArray(label=’$$\\tau_S$$‘, dtype=float64, default=array([100.]), dim_names=(), ndim=None, required=True)
Kinetic parameter. NMDA decay time constant.
w : tvb.simulator.models.wong_wang.ReducedWongWang.w = NArray(label=’$$w$$‘, dtype=float64, default=array([0.6]), dim_names=(), ndim=None, required=True)
Excitatory recurrence
J_N : tvb.simulator.models.wong_wang.ReducedWongWang.J_N = NArray(label=’$$J_{N}$$‘, dtype=float64, default=array([0.2609]), dim_names=(), ndim=None, required=True)
Excitatory recurrence
I_o : tvb.simulator.models.wong_wang.ReducedWongWang.I_o = NArray(label=’$$I_{o}$$‘, dtype=float64, default=array([0.33]), dim_names=(), ndim=None, required=True)
[nA] Effective external input
sigma_noise : tvb.simulator.models.wong_wang.ReducedWongWang.sigma_noise = NArray(label=’$$\\sigma_{noise}$$‘, dtype=float64, default=array([1.e-09]), dim_names=(), ndim=None, required=True)
[nA] Noise amplitude. Take this value into account for stochatic integration schemes.
state_variable_range : tvb.simulator.models.wong_wang.ReducedWongWang.state_variable_range = Final(field_type=<class ‘dict’>, default={‘S’: array([0., 1.])}, required=True)
Population firing rate
state_variable_boundaries : tvb.simulator.models.wong_wang.ReducedWongWang.state_variable_boundaries = Final(field_type=<class ‘dict’>, default={‘S’: array([0., 1.])}, required=True)
The values for each state-variable should be set to encompass the boundaries of the dynamic range of that state-variable. Set None for one-sided boundaries
variables_of_interest : tvb.simulator.models.wong_wang.ReducedWongWang.variables_of_interest = List(of=<class ‘str’>, default=(‘S’,), required=True)
default state variables to be monitored

gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)

I_o

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

J_N

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

a

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

b

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

configure()[source]
cvar = array([0], dtype=int32)
d

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

dfun(x, c, local_coupling=0.0)[source]

Equations taken from [DPA_2013] , page 11242

$\begin{split}x_k &= w\,J_N \, S_k + I_o + J_N \mathbf\Gamma(S_k, S_j, u_{kj})\\ H(x_k) &= \dfrac{ax_k - b}{1 - \exp(-d(ax_k -b))}\\ \dot{S}_k &= -\dfrac{S_k}{\tau_s} + (1 - S_k) \, H(x_k) \, \gamma\end{split}$
gamma

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

sigma_noise

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

state_variable_boundaries

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variable_range

An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python

state_variables = ['S']
tau_s

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.

variables_of_interest

The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it

w

Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.