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