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 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,
noise,
monitors,
initial_conditions=None,
**kwargs):
if isinstance(self.model_configuration.model_connectivity,
numpy.ndarray):
tvb_connectivity = self._vep2tvb_connectivity(
self.connectivity, self.model_configuration.model_connectivity)
else:
tvb_connectivity = self._vep2tvb_connectivity(self.connectivity)
tvb_coupling = coupling.Difference(a=1.)
integrator = getattr(integrators,
kwargs.get("integrator", "HeunStochastic"))(
dt=self.simulation_settings.integration_step,
noise=noise)
self.simTVB = simulator.Simulator(
model=self.model,
connectivity=tvb_connectivity,
coupling=tvb_coupling,
integrator=integrator,
monitors=monitors,
simulation_length=self.simulation_settings.simulated_period)
self.simTVB.configure()
self.configure_initial_conditions(
initial_conditions=initial_conditions)
def config_simulation(self, noise, monitors):
model = model_builder_from_model_config_fun(self.model_configuration)
# The Epileptor doesn't expose by default all its state variables to the monitor...:
if model._ui_name == "Epileptor":
model.variables_of_interest = VOIS[model._ui_name].tolist()
tvb_connectivity = self._vep2tvb_connectivity()
tvb_coupling = coupling.Difference(a=1.0)
integrator = getattr(integrators, self.settings.integrator_type) \
(dt=self.settings.integration_step, noise=noise)
self.simTVB = simulator.Simulator(
model=model,
connectivity=tvb_connectivity,
coupling=tvb_coupling,
integrator=integrator,
monitors=monitors,
simulation_length=self.settings.simulation_length)
self.simTVB.configure()
self.configure_initial_conditions()
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 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 test_difference_coupling(self):
k = coupling.Difference()
assert k.a, 0.1
result = self._apply_coupling(k)
assert result.shape, (1, 2 == 1
) # One state variable, two nodes, one mode
result = result[0, :, 0].tolist()
expected_result = [
k.a * (self.weights[0, 0] *
(self.state_1sv[0, 0, 0] - self.state_1sv[0, 0, 0]) +
self.weights[0, 1] *
(self.state_1sv[0, 1, 0] - self.state_1sv[0, 0, 0])),
k.a * (self.weights[1, 0] *
(self.state_1sv[0, 0, 0] - self.state_1sv[0, 1, 0]) +
self.weights[1, 1] *
(self.state_1sv[0, 1, 0] - self.state_1sv[0, 1, 0]))
]
assert self.almost_equal(result, expected_result)
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 test_difference_coupling(self):
k = coupling.Difference()
self.assertEqual(k.a, 0.1)
self._apply_coupling(k)
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
