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