def setup_method(self):
oscillator = models.Generic2dOscillator()
white_matter = connectivity.Connectivity.from_file(
'connectivity_%d.zip' % (self.n_regions, ))
white_matter.speed = numpy.array([self.speed])
white_matter_coupling = coupling.Difference(a=self.coupling_a)
heunint = integrators.HeunStochastic(
dt=2**-4, noise=noise.Additive(nsig=numpy.array([
2**-10,
])))
mons = (
monitors.EEG.from_file(period=self.period),
monitors.MEG.from_file(period=self.period),
monitors.iEEG.from_file(period=self.period),
)
local_coupling_strength = numpy.array([2**-10])
region_mapping = RegionMapping.from_file('regionMapping_16k_%d.txt' %
(self.n_regions, ))
default_cortex = Cortex(region_mapping_data=region_mapping,
load_default=True)
default_cortex.coupling_strength = local_coupling_strength
self.sim = simulator.Simulator(model=oscillator,
connectivity=white_matter,
coupling=white_matter_coupling,
integrator=heunint,
monitors=mons,
surface=default_cortex)
self.sim.configure()
def config_simulation(self, model):
# TODO: generate model from self.model_configuration for every specific implementation
tvb_connectivity = self._vp2tvb_connectivity(TIME_DELAYS_FLAG)
tvb_coupling = coupling.Difference(a=1.0)
noise_instance = noise.Additive(nsig=self.settings.noise_intensity,
random_stream=numpy.random.RandomState(
seed=self.settings.noise_seed))
integrator = getattr(integrators, self.settings.integrator_type) \
(dt=self.settings.integration_step, noise=noise_instance)
monitor = monitors.TemporalAverage()
monitor.period = self.settings.monitor_sampling_period
self.simTVB = simulator.Simulator(
model=model,
connectivity=tvb_connectivity,
coupling=tvb_coupling,
integrator=integrator,
monitors=[monitor],
simulation_length=self.settings.simulation_length)
self.simTVB.configure()
self.configure_initial_conditions()
def generate_white_noise(self, noise_intensity):
self._check_noise_intesity_size(noise_intensity)
noise_instance = noise.Additive(
nsig=noise_intensity,
random_stream=numpy.random.RandomState(seed=NOISE_SEED))
noise_instance.configure_white(dt=1.0 / self.fs)
return noise_instance
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
def generate_colored_noise(self, noise_intensity, ntau, **kwargs):
self._check_noise_intesity_size(noise_intensity)
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
def make_sim(sim_len=1000.0):
sim = simulator.Simulator(
connectivity=connectivity.Connectivity.from_file(),
model=models.MontbrioPazoRoxin(),
integrator=integrators.HeunStochastic(
dt=0.1, noise=noise.Additive(nsig=np.r_[0.001])),
monitors=[monitors.Raw()],
simulation_length=sim_len)
sim.configure()
return sim
def test_surface_sim_with_projections(self):
# Setup Simulator obj
oscillator = models.Generic2dOscillator()
white_matter = connectivity.Connectivity.from_file('connectivity_%d.zip' % (self.n_regions,))
white_matter.speed = numpy.array([self.speed])
white_matter_coupling = coupling.Difference(a=self.coupling_a)
heunint = integrators.HeunStochastic(
dt=2 ** -4,
noise=noise.Additive(nsig=numpy.array([2 ** -10, ]))
)
mons = (
monitors.EEG.from_file(period=self.period),
monitors.MEG.from_file(period=self.period),
# monitors.iEEG.from_file(period=self.period),
# SEEG projection data is not part of tvb-data on Pypi, thus this can not work generic
)
local_coupling_strength = numpy.array([2 ** -10])
region_mapping = RegionMapping.from_file('regionMapping_16k_%d.txt' % (self.n_regions,))
region_mapping.surface = CorticalSurface.from_file()
default_cortex = Cortex.from_file()
default_cortex.region_mapping_data = region_mapping
default_cortex.coupling_strength = local_coupling_strength
sim = simulator.Simulator(model=oscillator, connectivity=white_matter, coupling=white_matter_coupling,
integrator=heunint, monitors=mons, surface=default_cortex)
sim.configure()
# check configured simulation connectivity attribute
conn = sim.connectivity
assert conn.number_of_regions == self.n_regions
assert conn.speed == self.speed
# test monitor properties
lc_n_node = sim.surface.local_connectivity.matrix.shape[0]
for mon in sim.monitors:
assert mon.period == self.period
n_sens, g_n_node = mon.gain.shape
assert g_n_node == sim.number_of_nodes
assert n_sens == mon.sensors.number_of_sensors
assert lc_n_node == g_n_node
# check output shape
ys = {}
mons = 'eeg meg seeg'.split()
for key in mons:
ys[key] = []
for data in sim(simulation_length=3.0):
for key, dat in zip(mons, data):
if dat:
_, y = dat
ys[key].append(y)
for mon, key in zip(sim.monitors, mons):
ys[key] = numpy.array(ys[key])
assert ys[key].shape[2] == mon.gain.shape[0]
def configure(self,
dt=2**-3,
model=models.Generic2dOscillator,
speed=4.0,
coupling_strength=0.00042,
method="HeunDeterministic",
surface_sim=False,
default_connectivity=True):
"""
Create an instance of the Simulator class, by default use the
generic plane oscillator local dynamic model and the deterministic
version of Heun's method for the numerical integration.
"""
self.method = method
if default_connectivity:
white_matter = Connectivity(load_default=True)
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_76.txt")
else:
white_matter = Connectivity.from_file(
source_file="connectivity_192.zip")
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_192.txt")
white_matter_coupling = coupling.Linear(a=coupling_strength)
white_matter.speed = speed
dynamics = model()
if method[-10:] == "Stochastic":
hisss = noise.Additive(nsig=numpy.array([2**-11]))
integrator = eval("integrators." + method + "(dt=dt, noise=hisss)")
else:
integrator = eval("integrators." + method + "(dt=dt)")
if surface_sim:
local_coupling_strength = numpy.array([2**-10])
default_cortex = Cortex(load_default=True,
region_mapping_data=region_mapping)
default_cortex.coupling_strength = local_coupling_strength
default_cortex.local_connectivity = LocalConnectivity(
load_default=default_connectivity, surface=default_cortex)
else:
default_cortex = None
# Order of monitors determines order of returned values.
self.sim = simulator.Simulator(model=dynamics,
connectivity=white_matter,
coupling=white_matter_coupling,
integrator=integrator,
monitors=self.monitors,
surface=default_cortex)
self.sim.configure()
def config_simulation(self,
hypothesis,
head,
vep_settings=SimulationSettings(),
zmode=numpy.array("lin")):
tvb_conn = self._vep2tvb_connectivity(head.connectivity)
self.model = self.builder_model(
hypothesis,
variables_of_interest=vep_settings.monitor_expr,
zmode=zmode)
coupl = coupling.Difference(a=1.)
if isinstance(vep_settings.noise_preconfig, noise.Noise):
integrator = integrators.HeunStochastic(
dt=vep_settings.integration_step,
noise=vep_settings.noise_preconfig)
else:
vep_settings.noise_intensity = numpy.array(
vep_settings.noise_intensity)
if vep_settings.noise_intensity.size == 1:
vep_settings.noise_intensity = numpy.repeat(
numpy.squeeze(vep_settings.noise_intensity),
self.model.nvar)
if numpy.min(vep_settings.noise_intensity) > 0:
thisNoise = noise.Additive(
nsig=vep_settings.noise_intensity,
random_stream=numpy.random.RandomState(
seed=vep_settings.integration_noise_seed))
integrator = integrators.HeunStochastic(
dt=vep_settings.integration_step, noise=thisNoise)
else:
integrator = integrators.HeunDeterministic(
dt=vep_settings.integration_step)
mon_tavg = monitors.TemporalAverage(
period=vep_settings.monitor_sampling_period)
what_to_watch = mon_tavg
sim = simulator.Simulator(
model=self.model,
connectivity=tvb_conn,
coupling=coupl,
integrator=integrator,
monitors=what_to_watch,
simulation_length=vep_settings.simulated_period)
return sim
def config_simulation(self):
if isinstance(self.model_configuration.connectivity_matrix, numpy.ndarray):
tvb_connectivity = self._vep2tvb_connectivity(self.connectivity,
self.model_configuration.connectivity_matrix)
else:
tvb_connectivity = self._vep2tvb_connectivity(self.connectivity)
tvb_coupling = coupling.Difference(a=1.)
# Set noise:
if isinstance(self.simulation_settings.noise_preconfig, noise.Noise):
integrator = integrators.HeunStochastic(dt=self.simulation_settings.integration_step,
noise=self.simulation_settings.noise_preconfig)
else:
self.simulation_settings.noise_intensity = numpy.array(self.simulation_settings.noise_intensity)
if self.simulation_settings.noise_intensity.size == 1:
self.simulation_settings.noise_intensity = numpy.repeat(
numpy.squeeze(self.simulation_settings.noise_intensity), self.model.nvar)
if numpy.min(self.simulation_settings.noise_intensity) > 0:
thisNoise = noise.Additive(nsig=self.simulation_settings.noise_intensity,
random_stream=numpy.random.RandomState(
seed=self.simulation_settings.noise_seed))
self.simulation_settings.noise_type = "Additive"
integrator = integrators.HeunStochastic(dt=self.simulation_settings.integration_step, noise=thisNoise)
else:
integrator = integrators.HeunDeterministic(dt=self.simulation_settings.integration_step)
self.simulation_settings.noise_type = "None"
# Set monitors:
what_to_watch = []
if isinstance(self.simulation_settings.monitors_preconfig, monitors.Monitor):
what_to_watch = (self.simulation_settings.monitors_preconfig,)
elif isinstance(self.simulation_settings.monitors_preconfig, tuple) or isinstance(
self.simulation_settings.monitors_preconfig, list):
for monitor in self.simulation_settings.monitors_preconfig:
if isinstance(monitor, monitors.Monitor):
what_to_watch.append(monitor)
what_to_watch = tuple(what_to_watch)
self.simTVB = simulator.Simulator(model=self.model, connectivity=tvb_connectivity, coupling=tvb_coupling,
integrator=integrator, monitors=what_to_watch,
simulation_length=self.simulation_settings.simulated_period)
self.simTVB.configure()
self.configure_initial_conditions()
def setup_method(self):
oscillator = models.Generic2dOscillator()
white_matter = connectivity.Connectivity(load_file='connectivity_' +
str(self.n_regions) + '.zip')
white_matter.speed = numpy.array([self.speed])
white_matter_coupling = coupling.Difference(a=self.coupling_a)
heunint = integrators.HeunStochastic(
dt=2**-4, noise=noise.Additive(nsig=numpy.array([
2**-10,
])))
mons = (
monitors.EEG(projection=ProjectionMatrix(
load_file='projection_eeg_65_surface_16k.npy'),
sensors=SensorsEEG(load_file="eeg_brainstorm_65.txt"),
period=self.period),
monitors.MEG(
projection=ProjectionMatrix(
load_file='projection_meg_276_surface_16k.npy'),
sensors=SensorsMEG(load_file='meg_brainstorm_276.txt'),
period=self.period),
monitors.iEEG(projection=ProjectionMatrix(
load_file='projection_seeg_588_surface_16k.npy'),
sensors=SensorsInternal(load_file='seeg_588.txt'),
period=self.period),
)
local_coupling_strength = numpy.array([2**-10])
region_mapping = RegionMapping(load_file='regionMapping_16k_' +
str(self.n_regions) + '.txt')
default_cortex = Cortex(
region_mapping_data=region_mapping, load_file="cortex_16384.zip"
) #region_mapping_file="regionMapping_16k_192.txt")
default_cortex.coupling_strength = local_coupling_strength
self.sim = simulator.Simulator(model=oscillator,
connectivity=white_matter,
coupling=white_matter_coupling,
integrator=heunint,
monitors=mons,
surface=default_cortex)
self.sim.configure()
def configure(self,
dt=2**-3,
model=ModelsEnum.GENERIC_2D_OSCILLATOR.get_class(),
speed=4.0,
coupling_strength=0.00042,
method=HeunDeterministic,
surface_sim=False,
default_connectivity=True,
with_stimulus=False):
"""
Create an instance of the Simulator class, by default use the
generic plane oscillator local dynamic model and the deterministic
version of Heun's method for the numerical integration.
"""
self.method = method
if default_connectivity:
white_matter = Connectivity.from_file()
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_76.txt")
else:
white_matter = Connectivity.from_file(
source_file="connectivity_192.zip")
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_192.txt")
region_mapping.surface = CorticalSurface.from_file()
white_matter_coupling = coupling.Linear(
a=numpy.array([coupling_strength]))
white_matter.speed = numpy.array(
[speed]) # no longer allow scalars to numpy array promotion
dynamics = model()
if issubclass(method, IntegratorStochastic):
hisss = noise.Additive(nsig=numpy.array([2**-11]))
integrator = method(dt=dt, noise=hisss)
else:
integrator = method(dt=dt)
if surface_sim:
local_coupling_strength = numpy.array([2**-10])
default_cortex = Cortex.from_file()
default_cortex.region_mapping_data = region_mapping
default_cortex.coupling_strength = local_coupling_strength
if default_connectivity:
default_cortex.local_connectivity = LocalConnectivity.from_file(
)
else:
default_cortex.local_connectivity = LocalConnectivity()
default_cortex.local_connectivity.surface = default_cortex.region_mapping_data.surface
# TODO stimulus
else:
default_cortex = None
if with_stimulus:
weights = StimuliRegion.get_default_weights(
white_matter.weights.shape[0])
weights[self.stim_nodes] = 1.
stimulus = StimuliRegion(temporal=Linear(parameters={
"a": 0.0,
"b": self.stim_value
}),
connectivity=white_matter,
weight=weights)
# Order of monitors determines order of returned values.
self.sim = simulator.Simulator()
self.sim.surface = default_cortex
self.sim.model = dynamics
self.sim.integrator = integrator
self.sim.connectivity = white_matter
self.sim.coupling = white_matter_coupling
self.sim.monitors = self.monitors
if with_stimulus:
self.sim.stimulus = stimulus
self.sim.configure()
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_additive(self):
noise_additive = noise.Additive()
assert noise_additive.ntau == 0.0
class Projection(Monitor):
"Base class monitor providing lead field suppport."
_ui_name = "Projection matrix"
region_mapping = Attr(
RegionMapping,
required=False,
label="region mapping", #order=3,
doc=
"A region mapping specifies how vertices of a surface correspond to given regions in the"
" connectivity. For iEEG/EEG/MEG monitors, this must be specified when performing a region"
" simulation but is optional for a surface simulation.")
obsnoise = Attr(noise.Noise,
label="Observation Noise",
default=noise.Additive(),
required=False,
doc="""The monitor's noise source. It incorporates its
own instance of Numpy's RandomState.""")
@staticmethod
def oriented_gain(gain, orient):
"Apply orientations to gain matrix."
return (gain.reshape((gain.shape[0], -1, 3)) * orient).sum(axis=-1)
@classmethod
def projection_class(cls):
if hasattr(cls, 'projection'):
return cls.projection.field_type
else:
return projections_module.ProjectionMatrix
@classmethod
def from_file(cls,
sensors_fname,
projection_fname,
rm_f_name="regionMapping_16k_76.txt",
period=1e3 / 1024.0,
**kwds):
"""
Build Projection-based monitor from sensors and projection files, and
any extra keyword arguments are passed to the monitor class constructor.
"""
result = cls(period=period, **kwds)
result.sensors = cls.sensors.field_type.from_file(sensors_fname)
result.projection = cls.projection_class().from_file(projection_fname)
result.region_mapping = RegionMapping.from_file(rm_f_name)
return result
def analytic(self, loc, ori):
"Construct analytic or default set of spatial filters for simulation."
# this will not be implemented but kept for API uniformity
raise NotImplementedError(
"No general purpose analytic formula available for spatial "
"projection matrices. Please select an appropriate projection "
"matrix.")
def config_for_sim(self, simulator):
"Configure projection matrix monitor for given simulation."
super(Projection, self).config_for_sim(simulator)
self._sim = simulator
if hasattr(self, 'sensors'):
self.sensors.configure()
# handle observation noise and configure white/coloured noise
# pass in access to the: i) dt and ii) sample shape
if self.obsnoise is not None:
# configure the noise level
if self.obsnoise.ntau > 0.0:
noiseshape = self.sensors.labels[:, numpy.newaxis].shape
self.obsnoise.configure_coloured(dt=self.dt, shape=noiseshape)
else:
self.obsnoise.configure_white(dt=self.dt)
# handle region vs simulation, analytic vs numerical proj, cortical vs subcortical.
# setup convenient locals
surf = simulator.surface
conn = simulator.connectivity
using_cortical_surface = surf is not None
if using_cortical_surface:
non_cortical_indices, = numpy.where(
numpy.bincount(surf.region_mapping) == 1)
self.rmap = surf.region_mapping
else:
# assume all cortical if no info
if conn.cortical.size == 0:
conn.cortical = numpy.array([True] * conn.weights.shape[0])
non_cortical_indices, = numpy.where(~conn.cortical)
if self.region_mapping is None:
raise Exception(
"Please specify a region mapping on the EEG/MEG/iEEG monitor when "
"performing a region simulation.")
else:
self.rmap = self.region_mapping
self.log.debug(
'Projection used in region sim has %d non-cortical regions',
non_cortical_indices.size)
have_subcortical = len(non_cortical_indices) > 0
# determine source space
if using_cortical_surface:
sources = {'loc': surf.vertices, 'ori': surf.vertex_normals}
else:
sources = {
'loc': conn.centres[conn.cortical],
'ori': conn.orientations[conn.cortical]
}
# compute analytic if not provided
if not hasattr(self, 'projection'):
self.log.debug(
'Precomputed projection not unavailable using analytic approximation.'
)
self.gain = self.analytic(**sources)
# reduce to region lead field if region sim
if not using_cortical_surface and self.gain.shape[1] == self.rmap.size:
gain = numpy.zeros((self.gain.shape[0], conn.number_of_regions))
numpy_add_at(gain.T, self.rmap, self.gain.T)
self.log.debug('Region mapping gain shape %s to %s',
self.gain.shape, gain.shape)
self.gain = gain
# append analytic sub-cortical to lead field
if have_subcortical:
# need matrix of shape (proj.shape[0], len(sc_ind))
src = conn.centres[non_cortical_indices], conn.orientations[
non_cortical_indices]
self.gain = numpy.hstack((self.gain, self.analytic(*src)))
self.log.debug(
'Added subcortical analytic gain, for final shape %s',
self.gain.shape)
if self.sensors.usable is not None and not self.sensors.usable.all():
mask_unusable = ~self.sensors.usable
self.gain[mask_unusable] = 0.0
self.log.debug('Zeroed gain coefficients for %d unusable sensors',
mask_unusable.sum())
# unconditionally zero NaN elements; framework not prepared for NaNs.
nan_mask = numpy.isfinite(self.gain).all(axis=1)
self.gain[~nan_mask] = 0.0
self.log.debug('Zeroed %d NaN gain coefficients', nan_mask.sum())
# attrs used for recording
self._state = numpy.zeros((self.gain.shape[0], len(self.voi)))
self._period_in_steps = int(self.period / self.dt)
self.log.debug('State shape %s, period in steps %s', self._state.shape,
self._period_in_steps)
self.log.info('Projection configured gain shape %s', self.gain.shape)
def configure(self, *args, **kwargs):
self.sensors.configure()
def sample(self, step, state):
"Record state, returning sample at sampling frequency / period."
self._state += self.gain.dot(state[self.voi].sum(axis=-1).T)
if step % self._period_in_steps == 0:
time = (step - self._period_in_steps / 2.0) * self.dt
sample = self._state.copy() / self._period_in_steps
# add observation noise if available
if self.obsnoise is not None:
sample += self.obsnoise.generate(shape=sample.shape)
self._state[:] = 0.0
return time, sample.T[..., numpy.newaxis] # for compatibility
_gain = None
@property
def gain(self):
if self._gain is None:
self._gain = self.projection.projection_data
return self._gain
@gain.setter
def gain(self, new_gain):
self._gain = new_gain
_rmap = None
def _reg_map_data(self, reg_map):
return getattr(reg_map, 'array_data', reg_map)
@property
def rmap(self):
"Normalize obtaining reg map vector over various possibilities."
if self._rmap is None:
self._rmap = self._reg_map_data(self.region_mapping)
return self._rmap
@rmap.setter
def rmap(self, reg_map):
if self._rmap is not None:
self._rmap = self._reg_map_data(self.region_mapping)
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 config_simulation(self,
hypothesis,
head_connectivity,
settings=SimulationSettings()):
tvb_conn = self._vep2tvb_connectivity(head_connectivity)
coupl = coupling.Difference(a=1.)
# Set noise:
if isinstance(settings.noise_preconfig, noise.Noise):
integrator = integrators.HeunStochastic(
dt=settings.integration_step, noise=settings.noise_preconfig)
else:
settings.noise_intensity = numpy.array(settings.noise_intensity)
if settings.noise_intensity.size == 1:
settings.noise_intensity = numpy.repeat(
numpy.squeeze(settings.noise_intensity), self.model.nvar)
if numpy.min(settings.noise_intensity) > 0:
thisNoise = noise.Additive(
nsig=settings.noise_intensity,
random_stream=numpy.random.RandomState(
seed=settings.noise_seed))
settings.noise_type = "Additive"
integrator = integrators.HeunStochastic(
dt=settings.integration_step, noise=thisNoise)
else:
integrator = integrators.HeunDeterministic(
dt=settings.integration_step)
settings.noise_type = "None"
# Set monitors:
what_to_watch = []
if isinstance(settings.monitors_preconfig, monitors.Monitor):
what_to_watch = (settings.monitors_preconfig, )
elif isinstance(settings.monitors_preconfig, tuple) or isinstance(
settings.monitors_preconfig, list):
for monitor in settings.monitors_preconfig:
if isinstance(monitor, monitors.Monitor):
what_to_watch.append(monitor)
what_to_watch = tuple(what_to_watch)
# TODO: Find a better way to define monitor expressions without the need to modify the model...
if settings.monitor_expressions is not None:
self.model.variables_of_interest = settings.monitor_expressions
# Create and configure TVB simulator object
sim = simulator.Simulator(model=self.model,
connectivity=tvb_conn,
coupling=coupl,
integrator=integrator,
monitors=what_to_watch,
simulation_length=settings.simulated_period)
sim.configure()
sim.initial_conditions = self.prepare_initial_conditions(
hypothesis, sim.good_history_shape[0])
# Update simulation settings
settings.integration_step = integrator.dt
settings.simulated_period = sim.simulation_length
settings.integrator_type = integrator._ui_name
settings.noise_ntau = integrator.noise.ntau
settings.noise_intensity = numpy.array(settings.noise_intensity)
settings.monitor_type = what_to_watch[0]._ui_name
# TODO: find a way to store more than one monitors settings
settings.monitor_sampling_period = what_to_watch[0].period
settings.monitor_expressions = self.model.variables_of_interest
settings.initial_conditions = sim.initial_conditions
return sim, settings
def test_additive(self):
noise_additive = noise.Additive()
self.assertEqual(noise_additive.ntau, 0.0)
##----------------------------------------------------------------------------##
##- Perform the simulation -##
##----------------------------------------------------------------------------##
LOG.info("Configuring...")
#Initialise a Model, Coupling, and Connectivity.
jrm = models.JansenRit()
nsigma = 0.022
white_matter = connectivity.Connectivity()
white_matter.speed = numpy.array([4.0])
white_matter_coupling = coupling.Linear(a=0.0)
#Initialise an Integrator adding noise to only one state variable
hiss = noise.Additive(nsig=numpy.array([0., 0., 0., 0., nsigma, 0.]))
heunint = integrators.HeunStochastic(dt=2**-4, noise=hiss)
#Initialise some Monitors with period in physical time
momo = monitors.Raw()
mama = monitors.TemporalAverage(period=2**-2)
#Bundle them
what_to_watch = list((momo, mama))
#Initialise Simulator -- Model, Connectivity, Integrator, Monitors, and stimulus.
sim = simulator.Simulator(model=jrm,
connectivity=white_matter,
coupling=white_matter_coupling,
integrator=heunint,
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 configure(self,
dt=2**-3,
model=models.Generic2dOscillator,
speed=4.0,
coupling_strength=0.00042,
method=HeunDeterministic,
surface_sim=False,
default_connectivity=True):
"""
Create an instance of the Simulator class, by default use the
generic plane oscillator local dynamic model and the deterministic
version of Heun's method for the numerical integration.
"""
self.method = method
if default_connectivity:
white_matter = Connectivity.from_file()
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_76.txt")
else:
white_matter = Connectivity.from_file(
source_file="connectivity_192.zip")
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_192.txt")
region_mapping.surface = CorticalSurface.from_file()
white_matter_coupling = coupling.Linear(
a=numpy.array([coupling_strength]))
white_matter.speed = numpy.array(
[speed]) # no longer allow scalars to numpy array promotion
dynamics = model()
if issubclass(method, IntegratorStochastic):
hisss = noise.Additive(nsig=numpy.array([2**-11]))
integrator = method(dt=dt, noise=hisss)
else:
integrator = method(dt=dt)
if surface_sim:
local_coupling_strength = numpy.array([2**-10])
default_cortex = Cortex.from_file()
default_cortex.region_mapping_data = region_mapping
default_cortex.coupling_strength = local_coupling_strength
if default_connectivity:
default_cortex.local_connectivity = LocalConnectivity.from_file(
)
else:
default_cortex.local_connectivity = LocalConnectivity()
default_cortex.local_connectivity.surface = default_cortex.region_mapping_data.surface
else:
default_cortex = None
# Order of monitors determines order of returned values.
self.sim = simulator.Simulator()
self.sim.surface = default_cortex
self.sim.model = dynamics
self.sim.integrator = integrator
self.sim.connectivity = white_matter
self.sim.coupling = white_matter_coupling
self.sim.monitors = self.monitors
self.sim.configure()
