def generate_colored_noise(self, noise_intensity, ntau, **kwargs):
self._check_noise_intesity_size(noise_intensity)
eq = equations.Linear(parameters=kwargs.get("parameters", {"a": 1.0, "b": 0.0}))
noise_instance = noise.Additive(ntau=ntau, nsig=noise_intensity,
random_stream=numpy.random.RandomState(seed=NOISE_SEED))
noise_shape = noise_instance.nsig.shape
noise_instance.configure_coloured(dt=1.0 / self.fs, shape=noise_shape)
return noise_instance
class Multiplicative(Noise):
r"""
With "external" fluctuations the intensity of the noise often depends on
the state of the system. This results in the (general) stochastic
differential formulation:
.. math::
dX_t = a(X_t)\,dt + b(X_t)\,dW_t
for appropriate coefficients :math:`a(x)` and :math:`b(x)`, which might be
constants.
From [KloedenPlaten_1995]_, Equation 1.9, page 104.
"""
nsig = arrays.FloatArray(
configurable_noise=True,
label=":math:`D`",
required=True,
default=numpy.array([
1.0,
]),
range=basic.Range(lo=0.0, hi=10.0, step=0.1),
order=1,
doc="""The noise dispersion, it is the standard deviation of the
distribution from which the Gaussian random variates are drawn. NOTE:
Sensible values are typically ~<< 1% of the dynamic range of a Model's
state variables.""")
b = equations.TemporalApplicableEquation(
label=":math:`b`",
default=equations.Linear(parameters={
"a": 1.0,
"b": 0.0
}),
doc=
"""A function evaluated on the state-variables, the result of which enters as the diffusion coefficient."""
)
def gfun(self, state_variables):
"""
Scale the noise by the noise dispersion and the diffusion coefficient.
By default, the diffusion coefficient :math:`b` is a constant.
It reduces to the simplest scheme of a linear SDE with Multiplicative
Noise: homogeneous constant coefficients. See [KloedenPlaten_1995]_,
Equation 4.6, page 119.
"""
self.b.pattern = state_variables
g_x = numpy.sqrt(2.0 * self.nsig) * self.b.pattern
return g_x
def __init__(self, nsig=None, b=None, *args, **kwargs):
if nsig is None:
# The noise dispersion, it is the standard deviation of the
# distribution from which the Gaussian random variates are drawn. NOTE:
# Sensible values are typically ~<< 1% of the dynamic range of a Model's
# state variables.
nsig = numpy.array([1.0], dtype=numpy.float64)
self.nsig = nsig
if b is None:
b = equations.Linear(parameters={"a": 1.0, "b": 0.0})
self.b = b
super(Multiplicative, self).__init__(*args, **kwargs)
#Noise configuration
if model == '11D':
# x1 y1 z x2 y2 g x0 slope Iext1 Iext2 K
noise_intensity = 0.1 * np.array(
[0., 0., 1e-6, 0.0, 1e-6, 0., 1e-7, 1e-2, 1e-7, 1e-2, 1e-8])
elif model == '2D':
# x1 z
noise_intensity = 0.1**numpy.array([0., 5e-5])
else:
# x1 y1 z x2 y2 g
noise_intensity = 0.1**numpy.array([0., 0., 5e-5, 0.0, 5e-5, 0.])
#Preconfigured noise
#Colored noise:
dtN = 1000.0 / fsAVG
eq = equations.Linear(parameters={"a": 0.0, "b": 1.0}) #default = a*y+b
noise_color = noise.Multiplicative(
ntau=10,
nsig=noise_intensity,
b=eq,
random_stream=np.random.RandomState(seed=NOISE_SEED))
noise_shape = noise_color.nsig.shape
noise_color.configure_coloured(dt=dt, shape=noise_shape)
#White noise:
#noise_white.configure_white(dt=dt)
#Now simulate and plot
for hyp in (hyp_ep, ): # ,hyp_exc
settings = SimulationSettings(
length=30000,
integration_step=dt,
def setup_TVB_simulation_from_model_configuration(model_configuration,
connectivity,
dt,
sim_length,
monitor_period,
model_name="EpileptorDP",
zmode=np.array("lin"),
pmode=np.array("z"),
noise_instance=None,
noise_intensity=None,
monitor_expressions=None,
monitors_instance=None):
from tvb_epilepsy.base.constants import ADDITIVE_NOISE, NOISE_SEED
from tvb_epilepsy.base.simulators import SimulationSettings
from tvb_epilepsy.service.epileptor_model_factory import model_build_dict, model_noise_intensity_dict, \
model_noise_type_dict
from tvb_epilepsy.tvb_api.simulator_tvb import SimulatorTVB
from tvb_epilepsy.tvb_api.epileptor_models import EpileptorDPrealistic, EpileptorDP2D
from tvb.datatypes import equations
from tvb.simulator import monitors, noise
from tvb.simulator.models import Epileptor
model = model_build_dict[model_name](model_configuration, zmode=zmode)
if isinstance(model, Epileptor):
model.tt = 0.2 # necessary to get spikes in a realistic frequency range
model.r = 0.000025 # realistic seizures require a larger time scale separation
else:
if isinstance(model, EpileptorDPrealistic):
model.slope = 0.25
model.pmode = pmode
if monitor_expressions is None:
monitor_expressions = VOIS[model._ui_name]
monitor_expressions = [
me.replace('lfp', 'x2 - x1') for me in monitor_expressions
]
if monitor_expressions is not None:
model.variables_of_interest = monitor_expressions
if monitors_instance is None:
monitors_instance = monitors.TemporalAverage()
if monitor_period is not None:
monitors_instance.period = monitor_period
default_noise_intensity = model_noise_intensity_dict[model_name]
default_noise_type = model_noise_type_dict[model_name]
if noise_intensity is None:
noise_intensity = default_noise_intensity
if noise_instance is not None:
noise_instance.nsig = noise_intensity
else:
if default_noise_type is ADDITIVE_NOISE:
noise_instance = noise.Additive(
nsig=noise_intensity,
random_stream=np.random.RandomState(seed=NOISE_SEED))
noise_instance.configure_white(dt=dt)
else:
eq = equations.Linear(parameters={"a": 1.0, "b": 0.0})
noise_instance = noise.Multiplicative(
ntau=10,
nsig=noise_intensity,
b=eq,
random_stream=np.random.RandomState(seed=NOISE_SEED))
noise_shape = noise_instance.nsig.shape
noise_instance.configure_coloured(dt=dt, shape=noise_shape)
settings = SimulationSettings(simulated_period=sim_length,
integration_step=dt,
noise_preconfig=noise_instance,
noise_type=default_noise_type,
noise_intensity=noise_intensity,
noise_ntau=noise_instance.ntau,
monitors_preconfig=monitors_instance,
monitor_type=monitors_instance._ui_name,
monitor_sampling_period=monitor_period,
monitor_expressions=monitor_expressions,
variables_names=model.variables_of_interest)
simulator_instance = SimulatorTVB(connectivity, model_configuration, model,
settings)
return simulator_instance
def test_linear(self):
dt = equations.Linear()
assert dt.parameters == {'a': 1.0, 'b': 0.0}
def test_linear(self):
dt = equations.Linear()
self.assertEqual(dt.parameters, {'a': 1.0, 'b': 0.0})
self.assertEqual(dt.ui_equation, 'a * var + b')
def setup_TVB_simulation_from_model_configuration(model_configuration,
connectivity,
dt,
sim_length,
monitor_period,
model_name="EpileptorDP",
zmode=np.array("lin"),
scale_time=1,
noise_instance=None,
noise_intensity=None,
monitor_expressions=None,
monitors_instance=None):
from tvb_epilepsy.base.constants import ADDITIVE_NOISE, NOISE_SEED
from tvb_epilepsy.base.simulators import SimulationSettings
from tvb_epilepsy.base.epileptor_model_factory import model_build_dict, model_noise_intensity_dict, \
model_noise_type_dict
from tvb_epilepsy.tvb_api.simulator_tvb import SimulatorTVB
from tvb_epilepsy.tvb_api.epileptor_models import EpileptorDPrealistic, EpileptorDP2D
from tvb.datatypes import equations
from tvb.simulator import monitors, noise
from tvb.simulator.models import Epileptor
model = model_build_dict[model_name](model_configuration, zmode=zmode)
if isinstance(model, Epileptor):
model.tt *= scale_time * 0.25
else:
model.tau1 *= scale_time
if isinstance(model, EpileptorDPrealistic):
model.slope = 0.25
model.pmode = np.array("z")
if monitor_expressions is None:
monitor_expressions = []
for i in range(model._nvar):
monitor_expressions.append("y" + str(i))
if not (isinstance(model, EpileptorDP2D)):
monitor_expressions.append("y3 - y0")
if monitor_expressions is not None:
model.variables_of_interest = monitor_expressions
if monitors_instance is None:
monitors_instance = monitors.TemporalAverage()
if monitor_period is not None:
monitors_instance.period = monitor_period
default_noise_intensity = model_noise_intensity_dict[model_name]
default_noise_type = model_noise_type_dict[model_name]
if noise_intensity is None:
noise_intensity = default_noise_intensity
if noise_instance is not None:
noise_instance.nsig = noise_intensity
else:
if default_noise_type is ADDITIVE_NOISE:
noise_instance = noise.Additive(
nsig=noise_intensity,
random_stream=np.random.RandomState(seed=NOISE_SEED))
noise_instance.configure_white(dt=dt)
else:
eq = equations.Linear(parameters={"a": 1.0, "b": 0.0})
noise_instance = noise.Multiplicative(
ntau=10,
nsig=noise_intensity,
b=eq,
random_stream=np.random.RandomState(seed=NOISE_SEED))
noise_shape = noise_instance.nsig.shape
noise_instance.configure_coloured(dt=dt, shape=noise_shape)
settings = SimulationSettings(simulated_period=sim_length,
integration_step=dt,
scale_time=scale_time,
noise_preconfig=noise_instance,
noise_type=default_noise_type,
noise_intensity=noise_intensity,
noise_ntau=noise_instance.ntau,
monitors_preconfig=monitors_instance,
monitor_type=monitors_instance._ui_name,
monitor_sampling_period=monitor_period,
monitor_expressions=monitor_expressions,
variables_names=model.variables_of_interest)
simulator_instance = SimulatorTVB(connectivity, model_configuration, model,
settings)
return simulator_instance
def setup_simulation(model_name,
hypothesis,
dt,
sim_length,
monitor_period,
zmode=numpy.array("lin"),
scale_time=1,
noise_instance=None,
noise_intensity=None,
monitor_expressions=None,
monitors_instance=None,
variables_names=None):
model = model_build_dict[model_name](hypothesis, scale_time, zmode=zmode)
if isinstance(model, EpileptorDP):
# history
simulator_instance = SimulatorTVB(model)
model.tau1 *= scale_time
if variables_names is None:
variables_names = ['x1', 'y1', 'z', 'x2', 'y2', 'g', 'lfp']
elif isinstance(model, EpileptorDP2D):
model.tau1 *= scale_time
simulator_instance = SimulatorTVB(model)
if variables_names is None:
variables_names = ['x1', 'z']
elif isinstance(model, EpileptorDPrealistic):
model.tau1 *= scale_time # default = 0.25
model.slope = 0.25
model.pmode = numpy.array("z") #
simulator_instance = SimulatorTVB(model)
if variables_names is None:
variables_names = [
'x1', 'y1', 'z', 'x2', 'y2', 'g', 'x0ts', 'slopeTS', 'Iext1ts',
'Iext2ts', 'Kts', 'lfp'
]
elif isinstance(model, Epileptor):
model.tt *= scale_time * 0.25
# model.r = 1.0/2857.0 # default = 1.0 / 2857.0
simulator_instance = SimulatorTVB(model)
if variables_names is None:
variables_names = ['x1', 'y1', 'z', 'x2', 'y2', 'g', 'lfp']
if monitor_expressions is None:
monitor_expressions = []
for i in range(model._nvar):
monitor_expressions.append("y" + str(i))
# Monitor adjusted to the model
if not (isinstance(model, EpileptorDP2D)):
monitor_expressions.append("y3 - y0")
if monitors_instance is None:
monitors_instance = monitors.TemporalAverage(period=monitor_period)
else:
if monitor_period is not None:
monitors_instance.period = monitor_period
if noise_instance is None:
if noise_intensity is None:
if numpy.all(noise_intensity is None):
# Noise configuration
if isinstance(model, EpileptorDPrealistic):
# x1 y1 z x2 y2 g x0 slope Iext1 Iext2 K
noise_intensity = numpy.array([
0., 0., 1e-7, 0.0, 1e-7, 0., 1e-8, 1e-3, 1e-8, 1e-3,
1e-9
])
elif isinstance(model, EpileptorDP2D):
# x1 z
noise_intensity = numpy.array([0., 5e-5])
else:
# x1 y1 z x2 y2 g
noise_intensity = numpy.array(
[0., 0., 5e-6, 0.0, 5e-6, 0.])
# Preconfigured noise
if isinstance(model, EpileptorDPrealistic):
# Colored noise for realistic simulations
eq = equations.Linear(parameters={
"a": 1.0,
"b": 0.0
}) # a*y+b, default = (1.0, 1.0)
noise_instance = noise.Multiplicative(
ntau=10,
nsig=noise_intensity,
b=eq,
random_stream=numpy.random.RandomState(seed=NOISE_SEED))
noise_type = "Multiplicative"
noise_shape = noise_instance.nsig.shape
noise_instance.configure_coloured(dt=dt, shape=noise_shape)
else:
# White noise as a default choice:
noise_instance = noise.Additive(
nsig=noise_intensity,
random_stream=numpy.random.RandomState(seed=NOISE_SEED))
noise_instance.configure_white(dt=dt)
noise_type = "Additive"
else:
if noise_intensity is not None:
noise_instance.nsig = noise_intensity
settings = SimulationSettings(simulated_period=sim_length,
integration_step=dt,
scale_time=scale_time,
noise_preconfig=noise_instance,
noise_type=noise_type,
noise_intensity=noise_intensity,
noise_ntau=noise_instance.ntau,
noise_seed=NOISE_SEED,
monitors_preconfig=monitors_instance,
monitor_type=monitors_instance._ui_name,
monitor_sampling_period=monitor_period,
monitor_expressions=monitor_expressions,
variables_names=variables_names)
return simulator_instance, settings, variables_names, model
def test_linear(self):
t = np.linspace(0,1)
dt = equations.Linear()
assert dt.parameters == {'a': 1.0, 'b': 0.0}
np.testing.assert_allclose( dt.evaluate(t)[10:], dt.evaluate(t[10:]))
