models Package

A collection of neuronal dynamics models.

Specific models inherit from the abstract class Model.

class tvb.simulator.models.ModelsEnum(value)

Bases: Enum

An enumeration.

BASE_MODEL = 'Model'

COOMBES_BYRNE = 'CoombesByrne'

COOMBES_BYRNE_2D = 'CoombesByrne2D'

DECO_BALANCED_EXC_INH = 'DecoBalancedExcInh'

DUMONT_GUTKIN = 'DumontGutkin'

EPILEPTOR = 'Epileptor'

EPILEPTOR_2D = 'Epileptor2D'

EPILEPTOR_CODIM_3 = 'EpileptorCodim3'

EPILEPTOR_CODIM_3_SLOW = 'EpileptorCodim3SlowMod'

EPILEPTOR_RS = 'EpileptorRestingState'

GAST_SCHMIDT_KNOSCHE_SD = 'GastSchmidtKnosche_SD'

GAST_SCHMIDT_KNOSCHE_SF = 'GastSchmidtKnosche_SF'

GENERIC_2D_OSCILLATOR = 'Generic2dOscillator'

HOPFIELD = 'Hopfield'

JANSEN_RIT = 'JansenRit'

KURAMOTO = 'Kuramoto'

K_ION_EXCHANGE = 'KIonEx'

LARTER_BREAKSPEAR = 'LarterBreakspear'

LINEAR = 'Linear'

MONTBRIO_PAZO_ROXIN = 'MontbrioPazoRoxin'

REDUCED_SET_FITZ_HUGH_NAGUMO = 'ReducedSetFitzHughNagumo'

REDUCED_SET_HINDMARSH_ROSE = 'ReducedSetHindmarshRose'

REDUCED_WONG_WANG = 'ReducedWongWang'

REDUCED_WONG_WANG_EXC_INH = 'ReducedWongWangExcInh'

SUP_HOPF = 'SupHopf'

WILSON_COWAN = 'WilsonCowan'

ZERLAUT_FIRST_ORDER = 'ZerlautAdaptationFirstOrder'

ZERLAUT_SECOND_ORDER = 'ZerlautAdaptationSecondOrder'

ZETTERBERG_JANSEN = 'ZetterbergJansen'

static get_base_model_subclasses()

get_class()

base

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

class tvb.simulator.models.base.Model(**kwargs)

Bases: HasTraits

Traited class [tvb.simulator.models.base.Model]

Defines the abstract base class for neuronal models.

Attributes declared

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

configure()

Configure base model.

cvar = None

abstract dfun(state_variables, coupling, local_coupling=0.0)

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.

property global_parameter_names

property has_nonint_vars

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

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

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

initial_for_simulator(integrator, shape)

Generate initial conditions with integrator and shape.

property nintvar

The number of integrated state variables in this model.

property nnonintvar

The number of non integrated state variables in this model.

non_integrated_variables: Tuple[str] = None

number_of_modes = 1

property nvar

The number of state variables in this model.

property spatial_param_reshape

Returns reshape argument for a spatialized parameter.

property spatial_parameter_matrix

property spatial_parameter_names

state_variable_boundaries = None

state_variable_mask = None

state_variables: Tuple[str] = ()

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

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()

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)

update_state_variables_before_integration(state_variables, coupling, local_coupling=0.0, stimulus=0.0)

variables_of_interest = ()

class tvb.simulator.models.base.ModelNumbaDfun(**kwargs)

Bases: Model

Traited class [tvb.simulator.models.base.ModelNumbaDfun]

Base model for Numba-implemented dfuns.

Attributes declared

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

property spatial_param_reshape

Returns reshape argument for a spatialized parameter.

epileptor

Hindmarsh-Rose-Jirsa Epileptor model.

class tvb.simulator.models.epileptor.Epileptor(**kwargs)

Bases: ModelNumbaDfun

Traited class [tvb.simulator.models.epileptor.Epileptor]

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.

Attributes declared

atvb.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

btvb.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

ctvb.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

dtvb.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

rtvb.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

stvb.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

x0tvb.simulator.models.epileptor.Epileptor.x0 = NArray(label=’\(x_0\)’, dtype=float64, default=array([-1.6]), dim_names=(), ndim=None, required=True)

Epileptogenicity parameter

Iexttvb.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

slopetvb.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

Iext2tvb.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

tautvb.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

aatvb.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

bbtvb.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

Kvftvb.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.

Kftvb.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.

Kstvb.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

tttvb.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

modificationtvb.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_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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 float64. 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 float64. 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 float64. 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 float64. 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: Tuple[str] = ('x1', 'y1', 'z', 'x2', 'y2', 'g')

tau

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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 float64. 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 float64. 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)

Bases: ModelNumbaDfun

Traited class [tvb.simulator.models.epileptor.Epileptor2D]

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 .. math:

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.

Attributes declared

atvb.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.

btvb.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.

ctvb.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.

dtvb.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}.

rtvb.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).

x0tvb.simulator.models.epileptor.Epileptor2D.x0 = NArray(label=’\(x_0\)’, dtype=float64, default=array([-1.6]), dim_names=(), ndim=None, required=True)

Epileptogenicity parameter.

Iexttvb.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.

slopetvb.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.

Kvftvb.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.

Kstvb.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.

tttvb.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.

modificationtvb.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_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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

\[\begin{split}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}\end{split}\]

modification

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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 float64. 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 float64. 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: Tuple[str] = ('x1', 'z')

tt

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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 float64. 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)

Bases: Model

Traited class [tvb.simulator.models.hopfield.Hopfield]

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.

See also, http://www.scholarpedia.org/article/Hopfield_network

configure()

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

Dynamic equations:

dfun equation

\[\dot{x_{i}} &= 1 / \tau_{x} (-x_{i} + c_0)\]

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.

Attributes declared

tauxtvb.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.

tauTtvb.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.

dynamictvb.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_rangetvb.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_interesttvb.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()

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

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

dfun(state_variables, coupling, local_coupling=0.0)

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)

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 float64. 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: Tuple[str] = ('x', 'theta')

tauT

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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 float64. 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)

Bases: ModelNumbaDfun

Traited class [tvb.simulator.models.jansen_rit.JansenRit]

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 (\(y_4\), \(y_5\)) phase-plane for the Jansen and Rit model.

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}\]

Attributes declared

Atvb.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.

Btvb.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.

atvb.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.

btvb.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.

v0tvb.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_maxtvb.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].

rtvb.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].

Jtvb.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_1tvb.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_2tvb.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_3tvb.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_4tvb.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_mintvb.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_maxtvb.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.

mutvb.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_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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: Tuple[str] = ('y0', 'y1', 'y2', 'y3', 'y4', 'y5')

v0

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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)

Bases: Model

Traited class [tvb.simulator.models.jansen_rit.ZetterbergJansen]

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

Attributes declared

Hetvb.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.

Hitvb.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.

ketvb.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.

kitvb.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.

e0tvb.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_2tvb.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_1tvb.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_1tvb.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_2tvb.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_3tvb.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_4tvb.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_5tvb.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_1Ttvb.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_2Ttvb.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_3Ttvb.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.

Ptvb.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.)

Utvb.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.)

Qtvb.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_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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: Tuple[str] = ('v1', 'y1', 'v2', 'y2', 'v3', 'y3', 'v4', 'y4', 'v5', 'y5', 'v6', 'v7')

update_derived_parameters()

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.

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)

Bases: Model

Traited class [tvb.simulator.models.larter_breakspear.LarterBreakspear]

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

NOTES about parameters

\(\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.

The (\(V\), \(W\)) phase-plane for the Larter-Breakspear model.

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

Attributes declared

gCatvb.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.

gKtvb.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.

gLtvb.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.

phitvb.simulator.models.larter_breakspear.LarterBreakspear.phi = NArray(label=’\(\\phi\)’, dtype=float64, default=array([0.7]), dim_names=(), ndim=None, required=True)

Temperature scaling factor.

gNatvb.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.

TKtvb.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.

TCatvb.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.

TNatvb.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.

VCatvb.simulator.models.larter_breakspear.LarterBreakspear.VCa = NArray(label=’\(V_{Ca}\)’, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)

Ca Nernst potential.

VKtvb.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.

VLtvb.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.

VNatvb.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_Ktvb.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_Ktvb.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_Natvb.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_Catvb.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.

aeitvb.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.

aietvb.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.

btvb.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

Ctvb.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.

anetvb.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.

anitvb.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.

aeetvb.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.

Iexttvb.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.

rNMDAtvb.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.

VTtvb.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_Vtvb.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].

ZTtvb.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_Ztvb.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_maxtvb.simulator.models.larter_breakspear.LarterBreakspear.QV_max = NArray(label=’\(QV_{max}\)’, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)

Maximal firing rate for excitatory populations (kHz)

QZ_maxtvb.simulator.models.larter_breakspear.LarterBreakspear.QZ_max = NArray(label=’\(QZ_{max}\)’, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)

Maximal firing rate for excitatory populations (kHz)

t_scaletvb.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_interesttvb.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_rangetvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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: Tuple[str] = ('V', 'W', 'Z')

t_scale

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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 float64. 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)

Bases: Model

Traited class [tvb.simulator.models.linear.Linear]

Attributes declared

gammatvb.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_rangetvb.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)

\[x = a{\gamma} + b\]

gamma

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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: Tuple[str] = ('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)

Bases: ModelNumbaDfun

Traited class [tvb.simulator.models.oscillator.Generic2dOscillator]

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)

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.

Attributes declared

tautvb.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.

Itvb.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

atvb.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

btvb.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

ctvb.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

dtvb.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.

etvb.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.

ftvb.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.

gtvb.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.

alphatvb.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.

betatvb.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

gammatvb.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_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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 float64. 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 float64. 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 float64. 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 float64. 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: Tuple[str] = ('V', 'W')

tau

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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)

Bases: Model

Traited class [tvb.simulator.models.oscillator.Kuramoto]

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)\]

Attributes declared

omegatvb.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_rangetvb.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_interesttvb.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>, sin=<ufunc 'sin'>, pi2=6.283185307179586)

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 float64. 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: Tuple[str] = ['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)

Bases: ModelNumbaDfun

Traited class [tvb.simulator.models.oscillator.SupHopf]

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.

Attributes declared

atvb.simulator.models.oscillator.SupHopf.a = NArray(label=’\(a\)’, dtype=float64, default=array([-0.5]), dim_names=(), ndim=None, required=True)

Local bifurcation parameter.

omegatvb.simulator.models.oscillator.SupHopf.omega = NArray(label=’\(\\omega\)’, dtype=float64, default=array([1.]), dim_names=(), ndim=None, required=True)

Angular frequency.

state_variable_rangetvb.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_interesttvb.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 float64. 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)

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 float64. 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: Tuple[str] = ['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)

Bases: Model

Traited class [tvb.simulator.models.stefanescu_jirsa.ReducedSetBase]

Attributes declared

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

configure()

Configure base model.

nu = 1500

number_of_modes = 3

nv = 1500

class tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo(**kwargs)

Bases: ReducedSetBase

Traited class [tvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo]

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 (\(\xi\), \(\eta\)) phase-plane for the first mode of a reduced set of Fitz-Hugh Nagumo oscillators.

The (\(\xi\), \(\eta\)) phase-plane for the second mode of a reduced set of Fitz-Hugh Nagumo oscillators.

The (\(\xi\), \(\eta\)) phase-plane for the third mode of a reduced set of Fitz-Hugh Nagumo oscillators.

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()

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

Attributes declared

tautvb.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)

atvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.a = NArray(label=’\(a\)’, dtype=float64, default=array([0.45]), dim_names=(), ndim=None, required=True)

doc…

btvb.simulator.models.stefanescu_jirsa.ReducedSetFitzHughNagumo.b = NArray(label=’\(b\)’, dtype=float64, default=array([0.9]), dim_names=(), ndim=None, required=True)

doc…

K11tvb.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

K12tvb.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

K21tvb.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

sigmatvb.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

mutvb.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_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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 float64. 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 float64. 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: Tuple[str] = ('xi', 'eta', 'alpha', 'beta')

tau

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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()

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)

Bases: ReducedSetBase

Traited class [tvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose]

[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 (\(\xi\), \(\eta\)) phase-plane for the first mode of a reduced set of Hindmarsh-Rose oscillators.

The (\(\xi\), \(\eta\)) phase-plane for the second mode of a reduced set of Hindmarsh-Rose oscillators.

The (\(\xi\), \(\eta\)) phase-plane for the third mode of a reduced set of Hindmarsh-Rose oscillators.

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)

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

Attributes declared

rtvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.r = NArray(label=’\(r\)’, dtype=float64, default=array([0.006]), dim_names=(), ndim=None, required=True)

Adaptation parameter

atvb.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

btvb.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

ctvb.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

dtvb.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

stvb.simulator.models.stefanescu_jirsa.ReducedSetHindmarshRose.s = NArray(label=’\(s\)’, dtype=float64, default=array([4.]), dim_names=(), ndim=None, required=True)

Adaptation paramters, governs feedback

xotvb.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

K11tvb.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

K12tvb.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

K21tvb.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

sigmatvb.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

mutvb.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_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

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 float64. 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 float64. 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 float64. 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 float64. 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: Tuple[str] = ['xi', 'eta', 'tau', 'alpha', 'beta', 'gamma']

update_derived_parameters(corrected_d_p=True)

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 float64. 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)

Bases: ModelNumbaDfun

Traited class [tvb.simulator.models.wilson_cowan.WilsonCowan]

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

Table 0
Parameter	Value
k_e, k_i	0.00
r_e, r_i	0.00
tau_e, tau_i	9.0
c_ee	11.0
c_ei	3.0
c_ie	12.0
c_ii	10.0
a_e	0.2
a_i	0.0
b_e	1.8
b_i	3.0
theta_e	-1.0
theta_i	-1.0
alpha_e	1.0
alpha_i	1.0
P	-1.0
Q	-1.0
c_e, c_i	0.0
shift_sigmoid	True

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_ee	10.0
c_ei	6.0
c_ie	10.0
c_ii	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.0
c_e, c_i	1.0
shift_sigmoid	False
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 (\(E\), \(I\)) phase-plane for the Wilson-Cowan model.

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}\]

Attributes declared

c_eetvb.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_eitvb.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_ietvb.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_iitvb.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_etvb.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_itvb.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_etvb.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_etvb.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_etvb.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_etvb.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_itvb.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_itvb.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_itvb.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_itvb.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_etvb.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_itvb.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_etvb.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_itvb.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

Ptvb.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.

Qtvb.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_etvb.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_itvb.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.

shift_sigmoidtvb.simulator.models.wilson_cowan.WilsonCowan.shift_sigmoid = NArray(label=’\(shift sigmoid\)’, dtype=bool, default=array([ True]), dim_names=(), ndim=None, required=True)

In order to have resting state (E=0 and I=0) in absence of external input, the logistic curve are translated downward S(0)=0

state_variable_rangetvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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 float64. 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)

\[\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 float64. 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 float64. 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 float64. 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 float64. 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.

shift_sigmoid

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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: Tuple[str] = ['E', 'I']

tau_e

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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 float64. 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 float64. 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 float64. 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)

Bases: ModelNumbaDfun

Traited class [tvb.simulator.models.wong_wang.ReducedWongWang]

[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}\]

Attributes declared

atvb.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.

btvb.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.

dtvb.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.

gammatvb.simulator.models.wong_wang.ReducedWongWang.gamma = NArray(label=’\(\\gamma\)’, dtype=float64, default=array([0.641]), dim_names=(), ndim=None, required=True)

Kinetic parameter

tau_stvb.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.

wtvb.simulator.models.wong_wang.ReducedWongWang.w = NArray(label=’\(w\)’, dtype=float64, default=array([0.6]), dim_names=(), ndim=None, required=True)

Excitatory recurrence

J_Ntvb.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_otvb.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_noisetvb.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_rangetvb.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_boundariestvb.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_interesttvb.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 float64. 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 float64. 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 float64. 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 float64. 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()

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

d

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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)

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 float64. 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 float64. 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: Tuple[str] = ['S']

tau_s

Declares a numpy array. dtype enforces the dtype. The default dtype is float64. 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 float64. 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.