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