def test_region_boundaries(self):
cortex = Cortex.from_file()
white_matter = connectivity.Connectivity(load_default=True)
white_matter.configure()
rb = region_boundaries.RegionBoundaries(cortex)
assert len(
rb.region_neighbours.keys()) == white_matter.number_of_regions
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 test_cortex_reg_map_without_subcorticals(self):
dt = Cortex.from_file()
dt.region_mapping_data.connectivity = Connectivity.from_file()
self.add_subcorticals_to_conn(dt.region_mapping_data.connectivity)
dt.region_mapping_data.connectivity.configure()
assert isinstance(dt, Cortex)
assert dt.region_mapping is not None
assert numpy.unique(
dt.region_mapping
).size == dt.region_mapping_data.connectivity.number_of_regions
def test_cortexdata(self):
dt = Cortex.from_file(
local_connectivity_file="local_connectivity_16384.mat")
dt.region_mapping_data.connectivity = Connectivity.from_file()
assert isinstance(dt, Cortex)
assert dt.region_mapping is not None
dt.configure()
assert dt.vertices.shape == (16384, 3)
assert dt.vertex_normals.shape == (16384, 3)
assert dt.triangles.shape == (32760, 3)
def test_cortexdata(self):
dt = Cortex.from_file()
dt.__setattr__('valid_for_simulations', True)
assert isinstance(dt, Cortex)
assert dt.region_mapping is not None
## Initialize Local Connectivity, to avoid long computation time.
dt.local_connectivity = LocalConnectivity.from_file()
dt.configure()
assert dt.vertices.shape == (16384, 3)
assert dt.vertex_normals.shape == (16384, 3)
assert dt.triangles.shape == (32760, 3)
def test_assign_complex_attr(self):
"""
Test scientific methods are executed
"""
default_cortex = Cortex.from_file()
default_cortex.coupling_strength = 0.0121
self.assertTrue(default_cortex.local_connectivity is None)
#default_cortex.local_connectivity = surfaces.LocalConnectivity(cutoff=2, surface=default_cortex)
#default_cortex.compute_local_connectivity()
#self.assertTrue(default_cortex.local_connectivity is not None)
default_lc = LocalConnectivity(load_default=True, cutoff=2)
other_cortex = Cortex(local_connectivity=default_lc)
self.assertTrue(other_cortex.local_connectivity is not None)
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()
#
#
"""
.. moduleauthor:: Stuart A. Knock <*****@*****.**>
"""
from tvb.datatypes.cortex import Cortex
from tvb.simulator.lab import *
from tvb.simulator.region_boundaries import RegionBoundaries
from tvb.simulator.region_colours import RegionColours
CORTEX = Cortex.from_file()
CORTEX_BOUNDARIES = RegionBoundaries(CORTEX)
region_colours = RegionColours(CORTEX_BOUNDARIES.region_neighbours)
colouring = region_colours.back_track()
#Make the hemispheres symmetric
# TODO: should prob. et colouring for one hemisphere then just stack two copies...
number_of_regions = len(CORTEX_BOUNDARIES.region_neighbours)
for k in range(int(number_of_regions)):
colouring[k + int(number_of_regions)] = colouring[k]
mapping_colours = list("rgbcmyRGBCMY")
colour_rgb = {"r": numpy.array([255, 0, 0], dtype=numpy.uint8),
"g": numpy.array([ 0, 255, 0], dtype=numpy.uint8),
#Initialise some Monitors with period in physical time
mon_tavg = monitors.TemporalAverage(period=2**-2)
mon_savg = monitors.SpatialAverage(period=2**-2)
mon_eeg = monitors.EEG(period=2**-2)
#Bundle them
what_to_watch = (mon_tavg, mon_savg, mon_eeg)
#Initialise a surface
local_coupling_strength = numpy.array([0.0121])
grey_matter = LocalConnectivity(equation=equations.Gaussian(), cutoff=60.0)
grey_matter.equation.parameters['sigma'] = 10.0
grey_matter.equation.parameters['amp'] = 1.0
default_cortex = Cortex.from_file(
eeg_projection_file="surface_reg_13_eeg_62.mat")
default_cortex.local_connectivity = grey_matter
default_cortex.coupling_strength = local_coupling_strength
#Define the stimulus
eqn_t = equations.Gaussian()
eqn_t.parameters["amp"] = 1.0
eqn_t.parameters["midpoint"] = 8.0
eqn_x = equations.Gaussian()
eqn_x.parameters["amp"] = -0.0625
eqn_x.parameters["sigma"] = 28.0
stimulus = patterns.StimuliSurface(surface=default_cortex,
temporal=eqn_t,
spatial=eqn_x,
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()
from tvb.simulator.lab import *
from tvb.datatypes.time_series import TimeSeriesSurface
from tvb.simulator.plot import timeseries_interactive as timeseries_interactive
import tvb.analyzers.pca as pca
#Load the demo surface timeseries dataset
try:
data = numpy.load("demo_data_surface_8s_2048Hz.npy")
except IOError:
LOG.error("Can't load demo data. Run demos/generate_surface_demo_data.py")
raise
period = 0.00048828125 # s
#Initialse a default surface
default_cortex = Cortex.from_file()
#Put the data into a TimeSeriesSurface datatype
tsr = TimeSeriesSurface(surface=default_cortex,
data=data,
sample_period=period)
tsr.configure()
#Create and run the analyser
pca_analyser = pca.PCA(time_series=tsr)
pca_data = pca_analyser.evaluate()
#Generate derived data, such as, component time series, etc.
pca_data.configure()
#Put the data into a TimeSeriesSurface datatype
* connectivity data (white matter weights, tract-lengths) -> Diffusion Toolkit + TrackVis
* region mapping between parcellation and number of vertices in the cortical surface.
+ lead-field matrices (ie, projection matrices) mapping nodes onto EEG/MEG space
.. moduleauthor:: Paula Sanz Leon <*****@*****.**>
"""
from tvb.datatypes.cortex import Cortex
from tvb.simulator.lab import *
# From the inside out
connectome = connectivity.Connectivity(load_default=True)
cortical_surface = Cortex.from_file()
brain_skull = surfaces.BrainSkull(load_default=True)
skull_skin = surfaces.SkullSkin(load_default=True)
skin_air = surfaces.SkinAir(load_default=True)
# Get info
centres = connectome.centres
try:
from tvb.simulator.plot.tools import mlab
fig_tvb = mlab.figure(figure='John Doe', bgcolor=(0.0, 0.0, 0.0))
region_centres = mlab.points3d(centres[:, 0],
centres[:, 1],
centres[:, 2],
