def __init__(self):
"""
Initialise the structural information, coupling function, and monitors.
"""
# Initialise some Monitors with period in physical time
raw = monitors.Raw()
gavg = monitors.GlobalAverage(period=2 ** -2)
subsamp = monitors.SubSample(period=2 ** -2)
tavg = monitors.TemporalAverage(period=2 ** -2)
# DON'T load a projection because it'll make this behave like it
# has a surface and do very, very bad things
eeg = monitors.EEG(sensors=SensorsEEG(load_file="eeg_brainstorm_65.txt"),
period=2 ** -2)
eeg2 = monitors.EEG(sensors=SensorsEEG(load_file="eeg_brainstorm_65.txt"),
period=2 ** -2,
reference='Fp2') # EEG with a reference electrode
meg = monitors.MEG(sensors=SensorsMEG(load_file='meg_brainstorm_276.txt'),
period=2 ** -2)
self.monitors = (raw, gavg, subsamp, tavg, eeg, eeg2, meg)
self.method = None
self.sim = None
def setUp(self):
"""
Reset the database before each test.
"""
self.test_user = TestFactory.create_user("UserPM")
self.test_project = TestFactory.create_project(self.test_user)
zip_path = os.path.join(os.path.dirname(tvb_data.sensors.__file__),
'eeg_brainstorm_65.txt')
TestFactory.import_sensors(self.test_user, self.test_project, zip_path,
Sensors_Importer.EEG_SENSORS)
zip_path = os.path.join(os.path.dirname(tvb_data.surfaceData.__file__),
'cortex_16384.zip')
TestFactory.import_surface_zip(self.test_user, self.test_project,
zip_path, CORTICAL, True)
self.surface = TestFactory.get_entity(self.test_project,
CorticalSurface())
self.assertTrue(self.surface is not None)
self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
self.assertTrue(self.sensors is not None)
self.importer = TestFactory.create_adapter(
'tvb.adapters.uploaders.projection_matrix_importer',
'ProjectionMatrixSurfaceEEGImporter')
def launch(self, matfile, fdtfile):
self.mat = loadmat(matfile)
self.fs = self.mat['EEG']['srate'][0, 0][0, 0]
self.nsamp = self.mat['EEG']['pnts'][0, 0][0, 0]
self.data = numpy.fromfile(fdtfile, dtype=numpy.float32)
self.data = self.data.reshape((self.nsamp, -1)).T
self.nchan = self.data.shape[0]
self.labels = [
c[0] for c in self.mat['EEG']['chanlocs'][0, 0]['labels'][0]
]
ch = SensorsEEG(storage_path=self.storage_path,
labels=self.labels,
number_of_sensors=len(self.labels))
self._capture_operation_results([ch])
ts = TimeSeriesEEG(sensors=ch, storage_path=self.storage_path)
# (nchan x ntime) -> (t, sv, ch, mo)
dat = self.data.T[:, numpy.newaxis, :, numpy.newaxis]
# write data
ts.write_data_slice(dat)
# fill in header info
ts.length_1d, ts.length_2d, ts.length_3d, ts.length_4d = dat.shape
ts.labels_ordering = 'Time 1 Channel 1'.split()
ts.write_time_slice(numpy.r_[:dat.shape[0]] * 1.0 / self.fs)
ts.start_time = 0.0
ts.sample_period_unit = 's'
ts.sample_period = 1.0 / float(self.fs)
ts.close_file()
return ts
def test_launch_eeg(self):
"""
Check that all required keys are present in output from EegSensorViewer launch.
"""
## Import Sensors
zip_path = os.path.join(os.path.dirname(tvb_data.sensors.__file__),
'eeg_unitvector_62.txt.bz2')
TestFactory.import_sensors(self.test_user, self.test_project, zip_path,
Sensors_Importer.EEG_SENSORS)
sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
## Import EEGCap
cap_path = os.path.join(os.path.dirname(tvb_data.obj.__file__),
'eeg_cap.obj')
TestFactory.import_surface_obj(self.test_user, self.test_project,
cap_path, EEG_CAP)
eeg_cap_surface = TestFactory.get_entity(self.test_project, EEGCap())
viewer = SensorsViewer()
viewer.current_project_id = self.test_project.id
## Launch with EEG Cap selected
result = viewer.launch(sensors, eeg_cap_surface)
self.assert_compliant_dictionary(self.EXPECTED_KEYS_EEG, result)
for key in ['urlVertices', 'urlTriangles', 'urlLines', 'urlNormals']:
assert result[
key] is not None, "Value at key %s should not be None" % key
## Launch without EEG Cap
result = viewer.launch(sensors)
self.assert_compliant_dictionary(self.EXPECTED_KEYS_EEG, result)
for key in ['urlVertices', 'urlTriangles', 'urlLines', 'urlNormals']:
assert not result[key] or result[key] == "[]", "Value at key %s should be None or empty, " \
"but is %s" % (key, result[key])
def test_projection_surface_eeg(self):
dt = projections.ProjectionSurfaceEEG(sensors=SensorsEEG(),projection_data=numpy.array([]), sources=CorticalSurface())
assert dt.sources is not None
assert dt.skin_air is None
assert dt.skull_skin is None
assert dt.sensors is not None
assert dt.projection_data is not None
def test_launch_eeg(self):
"""
Tests successful launch of a BrainEEG and that all required keys are present in returned template dictionary
"""
zip_path = os.path.join(os.path.dirname(sensors_dataset.__file__),
'EEG_unit_vectors_BrainProducts_62.txt.bz2')
TestFactory.import_sensors(self.test_user, self.test_project, zip_path,
'EEG Sensors')
sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
time_series = self.datatypeFactory.create_timeseries(
self.connectivity, 'EEG', sensors)
time_series.configure()
viewer = BrainEEG()
result = viewer.launch(time_series)
expected_keys = [
'urlVertices', 'urlNormals', 'urlTriangles',
'urlMeasurePointsLabels', 'title', 'time_series', 'shelfObject',
'pageSize', 'labelsStateVar', 'nrOfPages', 'labelsModes',
'minActivityLabels', 'minActivity', 'measure_points',
'maxActivity', 'isOneToOneMapping', 'isAdapter', 'extended_view',
'base_activity_url', 'alphas_indices'
]
for key in expected_keys:
self.assertTrue(key in result and result[key] is not None)
self.assertTrue(result['extended_view'])
def launch(self, vhdr, dat):
self.filename = vhdr
self.wd, _ = os.path.split(vhdr)
# read file
with open(vhdr, 'r') as fd:
self.srclines = fd.readlines()
# config parser expects each section to have header
# but vhdr has some decorative information at the beginning
while not self.srclines[0].startswith('['):
self.srclines.pop(0)
self.sio = StringIO()
self.sio.write('\n'.join(self.srclines))
self.sio.seek(0)
self.cp = ConfigParser.ConfigParser()
self.cp.readfp(self.sio)
for opt in self.cp.options('Common Infos'):
setattr(self, opt, self.cp.get('Common Infos', opt))
self.binaryformat = self.cp.get('Binary Infos', 'BinaryFormat')
self.labels = [
self.cp.get('Channel Infos', o).split(',')[0]
for o in self.cp.options('Channel Infos')
]
self.fs = self.srate = 1e6 / float(self.samplinginterval)
self.nchan = int(self.numberofchannels)
# important if not in same directory
self.datafile = os.path.join(self.wd, self.datafile)
self.read_data()
# create TVB datatypes
ch = SensorsEEG(storage_path=self.storage_path,
labels=self.labels,
number_of_sensors=len(self.labels))
uid = vhdr + '-sensors'
self._capture_operation_results([ch], uid=uid)
ts = TimeSeriesEEG(sensors=ch, storage_path=self.storage_path)
dat = self.data.T[:, numpy.newaxis, :, numpy.newaxis]
ts.write_data_slice(dat)
ts.length_1d, ts.length_2d, ts.length_3d, ts.length_4d = dat.shape
ts.labels_ordering = 'Time 1 Channel 1'.split()
ts.write_time_slice(numpy.r_[:dat.shape[0]] * 1.0 / self.fs)
ts.start_time = 0.0
ts.sample_period_unit = 's'
ts.sample_period = 1.0 / float(self.fs)
ts.close_file()
return ts
def test_timeserieseeg(self):
data = numpy.random.random((10, 10))
dt = time_series.TimeSeriesEEG(data=data, sensors=SensorsEEG())
assert dt.data.shape == (10, 10)
assert ('Time', '1', 'EEG Sensor', '1') == dt.labels_ordering
assert dt.sample_period == 1.0
assert dt.sample_rate == 1.0
assert dt.sensors is not None
assert dt.start_time == 0.0
assert dt.time is None
def launch(self, sensors_file, sensors_type):
"""
Creates required sensors from the uploaded file.
:param sensors_file: the file containing sensor data
:param sensors_type: a string from "EEG Sensors", "MEG sensors", "Internal Sensors"
:returns: a list of sensors instances of the specified type
:raises LaunchException: when
* no sensors_file specified
* sensors_type is invalid (not one of the mentioned options)
* sensors_type is "MEG sensors" and no orientation is specified
"""
if sensors_file is None:
raise LaunchException(
"Please select sensors file which contains data to import")
self.logger.debug("Create sensors instance")
if sensors_type == self.EEG_SENSORS:
sensors_inst = SensorsEEG()
elif sensors_type == self.MEG_SENSORS:
sensors_inst = SensorsMEG()
elif sensors_type == self.INTERNAL_SENSORS:
sensors_inst = SensorsInternal()
else:
exception_str = "Could not determine sensors type (selected option %s)" % sensors_type
raise LaunchException(exception_str)
sensors_inst.storage_path = self.storage_path
locations = self.read_list_data(sensors_file, usecols=[1, 2, 3])
# NOTE: TVB has the nose pointing -y and left ear pointing +x
# If the sensors are in CTF coordinates : nose pointing +x left ear +y
# to rotate the sensors by -90 along z uncomment below
# locations = numpy.array([[0, 1, 0], [-1, 0, 0], [0, 0, 1]]).dot(locations.T).T
sensors_inst.locations = locations
sensors_inst.labels = self.read_list_data(sensors_file,
dtype=numpy.str,
usecols=[0])
if isinstance(sensors_inst, SensorsMEG):
try:
sensors_inst.orientations = self.read_list_data(
sensors_file, usecols=[4, 5, 6])
except IndexError:
raise LaunchException(
"Uploaded file does not contains sensors orientation.")
self.logger.debug("Sensors instance ready to be stored")
return [sensors_inst]
def test_import_eeg_sensors(self):
"""
This method tests import of a file containing EEG sensors.
"""
eeg_sensors = self._import(self.EEG_FILE, self.importer.EEG_SENSORS, SensorsEEG())
expected_size = 62
self.assertTrue(eeg_sensors.labels is not None)
self.assertEqual(expected_size, len(eeg_sensors.labels))
self.assertEqual(expected_size, len(eeg_sensors.locations))
self.assertEqual((expected_size, 3), eeg_sensors.locations.shape)
self.assertEqual(expected_size, eeg_sensors.number_of_sensors)
def setUp(self):
"""
Reset the database before each test.
"""
self.test_user = TestFactory.create_user("UserPM")
self.test_project = TestFactory.import_default_project(self.test_user)
self.surface = TestFactory.get_entity(self.test_project,
CorticalSurface())
self.assertTrue(self.surface is not None)
self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
self.assertTrue(self.sensors is not None)
def test_import_eeg_sensors(self):
"""
This method tests import of a file containing EEG sensors.
"""
eeg_sensors = self._import(self.EEG_FILE, self.importer.EEG_SENSORS,
SensorsEEG())
expected_size = 62
assert eeg_sensors.labels is not None
assert expected_size == len(eeg_sensors.labels)
assert expected_size == len(eeg_sensors.locations)
assert (expected_size, 3) == eeg_sensors.locations.shape
assert expected_size == eeg_sensors.number_of_sensors
def launch(self, sensors_file, sensors_type):
"""
Creates required sensors from the uploaded file.
:param sensors_file: the file containing sensor data
:param sensors_type: a string from "EEG Sensors", "MEG sensors", "Internal Sensors"
:returns: a list of sensors instances of the specified type
:raises LaunchException: when
* no sensors_file specified
* sensors_type is invalid (not one of the mentioned options)
* sensors_type is "MEG sensors" and no orientation is specified
"""
if sensors_file is None:
raise LaunchException(
"Please select sensors file which contains data to import")
sensors_inst = None
self.logger.debug("Create sensors instance")
if sensors_type == self.EEG_SENSORS:
sensors_inst = SensorsEEG()
elif sensors_type == self.MEG_SENSORS:
sensors_inst = SensorsMEG()
elif sensors_type == self.INTERNAL_SENSORS:
sensors_inst = SensorsInternal()
else:
exception_str = "Could not determine sensors type (selected option %s)" % sensors_type
raise LaunchException(exception_str)
sensors_inst.storage_path = self.storage_path
sensors_inst.locations = read_list_data(sensors_file,
usecols=[1, 2, 3])
sensors_inst.labels = read_list_data(sensors_file,
dtype=numpy.str,
usecols=[0])
if isinstance(sensors_inst, SensorsMEG):
try:
sensors_inst.orientations = read_list_data(sensors_file,
usecols=[4, 5, 6])
except IndexError:
raise LaunchException(
"Uploaded file does not contains sensors orientation.")
self.logger.debug("Sensors instance ready to be stored")
return [sensors_inst]
def deserialize_simulator(simulator_gid, storage_path):
simulator_in_path = h5.path_for(storage_path, SimulatorH5,
simulator_gid)
simulator_in = SimulatorAdapterModel()
with SimulatorH5(simulator_in_path) as simulator_in_h5:
simulator_in_h5.load_into(simulator_in)
simulator_in.connectivity = simulator_in_h5.connectivity.load()
simulator_in.stimulus = simulator_in_h5.stimulus.load()
simulator_in.history_gid = simulator_in_h5.simulation_state.load()
if isinstance(simulator_in.monitors[0], Projection):
# TODO: simplify this part
with SimulatorH5(simulator_in_path) as simulator_in_h5:
monitor_h5_path = simulator_in_h5.get_reference_path(
simulator_in.monitors[0].gid)
monitor_h5_class = h5_factory.monitor_h5_factory(
type(simulator_in.monitors[0]))
with monitor_h5_class(monitor_h5_path) as monitor_h5:
sensors_gid = monitor_h5.sensors.load()
region_mapping_gid = monitor_h5.region_mapping.load()
sensors = ABCAdapter.load_traited_by_gid(sensors_gid)
if isinstance(simulator_in.monitors[0], EEG):
sensors = SensorsEEG.build_sensors_subclass(sensors)
elif isinstance(simulator_in.monitors[0], MEG):
sensors = SensorsMEG.build_sensors_subclass(sensors)
elif isinstance(simulator_in.monitors[0], iEEG):
sensors = SensorsInternal.build_sensors_subclass(sensors)
simulator_in.monitors[0].sensors = sensors
region_mapping = ABCAdapter.load_traited_by_gid(region_mapping_gid)
simulator_in.monitors[0].region_mapping = region_mapping
if simulator_in.surface:
cortex_path = h5.path_for(storage_path, CortexH5,
simulator_in.surface.gid)
with CortexH5(cortex_path) as cortex_h5:
simulator_in.surface.local_connectivity = cortex_h5.local_connectivity.load(
)
simulator_in.surface.region_mapping_data = cortex_h5.region_mapping_data.load(
)
rm_index = dao.get_datatype_by_gid(
simulator_in.surface.region_mapping_data.hex)
simulator_in.surface.surface_gid = uuid.UUID(
rm_index.surface_gid)
return simulator_in
def test_launch_eeg(self):
"""
Tests successful launch of a BrainEEG and that all required keys are present in returned template dictionary
"""
sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
time_series = self.datatypeFactory.create_timeseries(
self.connectivity, 'EEG', sensors)
time_series.configure()
viewer = DualBrainViewer()
viewer.current_project_id = self.test_project.id
result = viewer.launch(time_series)
for key in TestBrainViewer.EXPECTED_KEYS + TestBrainViewer.EXPECTED_EXTRA_KEYS:
assert key in result and result[key] is not None
assert result['extended_view']
def build(type="EEG", nr_sensors=3):
if type == "EEG":
return SensorsEEG(sensors_type=type,
labels=numpy.array(["s"] * nr_sensors),
locations=numpy.ones((nr_sensors, 3)),
number_of_sensors=nr_sensors,
has_orientation=True,
orientations=numpy.zeros((nr_sensors, 3)),
usable=numpy.array([True] * nr_sensors))
return Sensors(sensors_type=type,
labels=numpy.array(["s"] * nr_sensors),
locations=numpy.ones((nr_sensors, 3)),
number_of_sensors=nr_sensors,
has_orientation=True,
orientations=numpy.zeros((nr_sensors, 3)),
usable=numpy.array([True] * nr_sensors))
def __init__(self,
region_mapping=None,
sensors=None,
projection=None,
*args,
**kwargs):
if region_mapping is None:
region_mapping = RegionMapping()
self.region_mapping = region_mapping
if sensors is None:
sensors = SensorsEEG()
self.sensors = sensors
self.projection = projection
super(Projection, self).__init__(*args, **kwargs)
def launch(self, sensors_file, sensors_type):
"""
Creates required sensors from the uploaded file.
:param sensors_file: the file containing sensor data
:param sensors_type: a string from "EEG Sensors", "MEG sensors", "Internal Sensors"
:returns: a list of sensors instances of the specified type
:raises LaunchException: when
* no sensors_file specified
* sensors_type is invalid (not one of the mentioned options)
* sensors_type is "MEG sensors" and no orientation is specified
"""
if sensors_file is None:
raise LaunchException("Please select sensors file which contains data to import")
self.logger.debug("Create sensors instance")
if sensors_type == self.EEG_SENSORS:
sensors_inst = SensorsEEG()
elif sensors_type == self.MEG_SENSORS:
sensors_inst = SensorsMEG()
elif sensors_type == self.INTERNAL_SENSORS:
sensors_inst = SensorsInternal()
else:
exception_str = "Could not determine sensors type (selected option %s)" % sensors_type
raise LaunchException(exception_str)
sensors_inst.storage_path = self.storage_path
locations = self.read_list_data(sensors_file, usecols=[1, 2, 3])
# NOTE: TVB has the nose pointing -y and left ear pointing +x
# If the sensors are in CTF coordinates : nose pointing +x left ear +y
# to rotate the sensors by -90 along z uncomment below
# locations = numpy.array([[0, 1, 0], [-1, 0, 0], [0, 0, 1]]).dot(locations.T).T
sensors_inst.locations = locations
sensors_inst.labels = self.read_list_data(sensors_file, dtype=numpy.str, usecols=[0])
if isinstance(sensors_inst, SensorsMEG):
try:
sensors_inst.orientations = self.read_list_data(sensors_file, usecols=[4, 5, 6])
except IndexError:
raise LaunchException("Uploaded file does not contains sensors orientation.")
self.logger.debug("Sensors instance ready to be stored")
return [sensors_inst]
def configure_simulation(stimulate):
"""
Set up a Simulator object (a brain network model and all its individual
components + output modalities)
"""
# eeg projection matrix from regions to sensors
LOG.info("Reading sensors info")
pr = ProjectionSurfaceEEG(load_default=True)
sensors = SensorsEEG.from_file(source_file="eeg_brainstorm_65.txt")
rm = RegionMapping(load_default=True)
#Initialise a Model, Connectivity, Coupling, set speed.
oscilator = models.Generic2dOscillator(a=-0.5, b=-10., c=0.0, d=0.02)
white_matter = connectivity.Connectivity(load_default=True)
white_matter.speed = numpy.array([4.0])
white_matter_coupling = coupling.Linear(a=0.042)
#Initialise an Integrator
hiss = noise.Additive(nsig=numpy.array([0.00])) # nsigm 0.015
heunint = integrators.HeunStochastic(dt=2**-6, noise=hiss)
# Recording techniques
what_to_watch = (monitors.TemporalAverage(period=1e3 / 4096.),
monitors.EEG(projection=pr,
sensors=sensors,
region_mapping=rm,
period=1e3 / 4096.))
# Stimulation paradigm
if stimulate:
stimulus = build_stimulus(white_matter)
else:
stimulus = None
#Initialise a Simulator -- Model, Connectivity, Integrator, and Monitors.
sim = simulator.Simulator(model=oscilator,
connectivity=white_matter,
coupling=white_matter_coupling,
integrator=heunint,
monitors=what_to_watch,
stimulus=stimulus)
sim.configure()
return sim
def launch(self, sensors_file, sensors_type):
"""
Created required sensors from the uploaded file.
"""
if sensors_file is None:
raise LaunchException(
"Please select sensors file which contains data to import")
sensors_inst = None
self.logger.debug("Create sensors instance")
if sensors_type == self.EEG_SENSORS:
sensors_inst = SensorsEEG()
elif sensors_type == self.MEG_SENSORS:
sensors_inst = SensorsMEG()
elif sensors_type == self.INTERNAL_SENSORS:
sensors_inst = SensorsInternal()
else:
exception_str = "Could not determine sensors type (selected option %s)" % sensors_type
raise LaunchException(exception_str)
sensors_inst.storage_path = self.storage_path
sensors_inst.locations = read_list_data(sensors_file,
usecols=[1, 2, 3])
sensors_inst.labels = read_list_data(sensors_file,
dtype=numpy.str,
usecols=[0])
if isinstance(sensors_inst, SensorsMEG):
try:
sensors_inst.orientations = read_list_data(sensors_file,
usecols=[4, 5, 6])
except IndexError:
raise LaunchException(
"Uploaded file does not contains sensors orientation.")
self.logger.debug("Sensors instance ready to be stored")
return [sensors_inst]
def setUp(self):
"""
Reset the database before each test.
"""
self.test_user = TestFactory.create_user('CFF_User')
self.test_project = TestFactory.create_project(self.test_user,
"CFF_Project")
TestFactory.import_cff(test_user=self.test_user,
test_project=self.test_project)
zip_path = os.path.join(os.path.dirname(sensors_dataset.__file__),
'EEG_unit_vectors_BrainProducts_62.txt.bz2')
TestFactory.import_sensors(self.test_user, self.test_project, zip_path,
'EEG Sensors')
self.connectivity = TestFactory.get_entity(self.test_project,
Connectivity())
self.assertTrue(self.connectivity is not None)
self.surface = TestFactory.get_entity(self.test_project,
CorticalSurface())
self.assertTrue(self.surface is not None)
self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
self.assertTrue(self.sensors is not None)
def launch(self, sensors_file, sensors_type):
"""
Creates required sensors from the uploaded file.
:param sensors_file: the file containing sensor data
:param sensors_type: a string from "EEG Sensors", "MEG sensors", "Internal Sensors"
:returns: a list of sensors instances of the specified type
:raises LaunchException: when
* no sensors_file specified
* sensors_type is invalid (not one of the mentioned options)
* sensors_type is "MEG sensors" and no orientation is specified
"""
if sensors_file is None:
raise LaunchException ("Please select sensors file which contains data to import")
sensors_inst = None
self.logger.debug("Create sensors instance")
if sensors_type == self.EEG_SENSORS:
sensors_inst = SensorsEEG()
elif sensors_type == self.MEG_SENSORS:
sensors_inst = SensorsMEG()
elif sensors_type == self.INTERNAL_SENSORS:
sensors_inst = SensorsInternal()
else:
exception_str = "Could not determine sensors type (selected option %s)" % sensors_type
raise LaunchException(exception_str)
sensors_inst.storage_path = self.storage_path
sensors_inst.locations = read_list_data(sensors_file, usecols=[1,2,3])
sensors_inst.labels = read_list_data(sensors_file, dtype=numpy.str, usecols=[0])
if isinstance(sensors_inst, SensorsMEG):
try:
sensors_inst.orientations = read_list_data(sensors_file, usecols=[4,5,6])
except IndexError:
raise LaunchException("Uploaded file does not contains sensors orientation.")
self.logger.debug("Sensors instance ready to be stored")
return [sensors_inst]
def test_launch(self):
"""
Check that all required keys are present in output from BrainViewer launch.
"""
zip_path = os.path.join(os.path.dirname(sensors_dataset.__file__),
'EEG_unit_vectors_BrainProducts_62.txt.bz2')
TestFactory.import_sensors(self.test_user, self.test_project, zip_path,
'EEG Sensors')
sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
time_series = self.datatypeFactory.create_timeseries(
self.connectivity, 'EEG', sensors)
viewer = EegMonitor()
result = viewer.launch(time_series)
expected_keys = [
'tsStateVars', 'tsModes', 'translationStep', 'total_length',
'title', 'timeSetPaths', 'number_of_visible_points',
'normalizedSteps', 'noOfChannels', 'labelsForCheckBoxes',
'label_x', 'graphLabels', 'entities', 'channelsPage'
]
for key in expected_keys:
self.assertTrue(key in 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_launch(self):
"""
Check that all required keys are present in output from BrainViewer launch.
"""
zip_path = os.path.join(os.path.dirname(sensors_dataset.__file__),
'EEG_unit_vectors_BrainProducts_62.txt.bz2')
TestFactory.import_sensors(self.test_user, self.test_project, zip_path,
'EEG Sensors')
sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
time_series = self.datatypeFactory.create_timeseries(
self.connectivity, 'EEG', sensors)
viewer = EegMonitor()
result = viewer.launch(time_series)
expected_keys = [
'tsNames', 'groupedLabels', 'tsModes', 'tsStateVars',
'longestChannelLength', 'label_x', 'entities', 'page_size',
'number_of_visible_points', 'extended_view', 'initialSelection',
'ag_settings', 'ag_settings'
]
for key in expected_keys:
self.assertTrue(key in result, "key not found %s" % key)
expected_ag_settings = [
'channelsPerSet', 'channelLabels', 'noOfChannels',
'translationStep', 'normalizedSteps', 'nan_value_found',
'baseURLS', 'pageSize', 'nrOfPages', 'timeSetPaths', 'totalLength',
'number_of_visible_points', 'extended_view',
'measurePointsSelectionGIDs'
]
ag_settings = json.loads(result['ag_settings'])
for key in expected_ag_settings:
self.assertTrue(key in ag_settings,
"ag_settings should have the key %s" % key)
def configure_simulation(stimulate):
"""
Set up a Simulator object (a brain network model and all its individual
components + output modalities)
"""
# eeg projection matrix from regions to sensors
LOG.info("Reading sensors info")
pr = ProjectionSurfaceEEG(load_default=True)
sensors = SensorsEEG.from_file(source_file="eeg_brainstorm_65.txt")
rm = RegionMapping(load_default=True)
#Initialise a Model, Connectivity, Coupling, set speed.
oscilator = models.Generic2dOscillator(a=-0.5, b=-10., c=0.0, d=0.02)
white_matter = connectivity.Connectivity(load_default=True)
white_matter.speed = numpy.array([4.0])
white_matter_coupling = coupling.Linear(a=0.042)
#Initialise an Integrator
hiss = noise.Additive(nsig=numpy.array([0.00])) # nsigm 0.015
heunint = integrators.HeunStochastic(dt=2 ** -6, noise=hiss)
# Recording techniques
what_to_watch = (monitors.TemporalAverage(period=1e3 / 4096.),
monitors.EEG(projection=pr, sensors=sensors, region_mapping=rm, period=1e3 / 4096.))
# Stimulation paradigm
if stimulate:
stimulus = build_stimulus(white_matter)
else:
stimulus = None
#Initialise a Simulator -- Model, Connectivity, Integrator, and Monitors.
sim = simulator.Simulator(model=oscilator, connectivity=white_matter, coupling=white_matter_coupling,
integrator=heunint, monitors=what_to_watch, stimulus=stimulus)
sim.configure()
return sim
def from_tvb_file(self, filepath, remove_leading_zeros_from_labels=False):
self._tvb = TVBSensorsEEG.from_file(filepath, self._tvb)
if len(self._tvb.labels) > 0:
if remove_leading_zeros_from_labels:
self.remove_leading_zeros_from_labels()
return self
class EEG(Projection):
"""
Forward solution monitor for electroencephalogy (EEG). If a
precomputed lead field is not available, a single sphere analytic
formula due to Sarvas 1987 is used.
**References**:
.. [Sarvas_1987] Sarvas, J., *Basic mathematical and electromagnetic
concepts of the biomagnetic inverse problem*, Physics in Medicine and
Biology, 1987.
"""
_ui_name = "EEG"
projection = ProjectionSurfaceEEG(
default=None, label='Projection matrix', order=2,
doc='Projection matrix to apply to sources.')
reference = basic.String(required=False, label="EEG Reference", order=5,
doc='EEG Electrode to be used as reference, or "average" to '
'apply an average reference. If none is provided, the '
'produced time-series are the idealized or reference-free.')
sensors = SensorsEEG(required=True, label="EEG Sensors", order=1,
doc='Sensors to use for this EEG monitor')
sigma = basic.Float(label="Conductivity (w/o projection)", default=1.0, order=4,
doc='When a projection matrix is not used, this provides '
'the value of conductivity in the formula for the single '
'sphere approximation of the head (Sarvas 1987).')
@classmethod
def from_file(cls, sensors_fname='eeg_brainstorm_65.txt', projection_fname='projection_eeg_65_surface_16k.npy', **kwargs):
return Projection.from_file.im_func(cls, sensors_fname, projection_fname, **kwargs)
def config_for_sim(self, simulator):
super(EEG, self).config_for_sim(simulator)
self._ref_vec = numpy.zeros((self.sensors.number_of_sensors, ))
if self.reference:
if self.reference.lower() != 'average':
sensor_names = self.sensors.labels.tolist()
self._ref_vec[sensor_names.index(self.reference)] = 1.0
else:
self._ref_vec[:] = 1.0 / self.sensors.number_of_sensors
self._ref_vec_mask = numpy.isfinite(self.gain).all(axis=1)
self._ref_vec = self._ref_vec[self._ref_vec_mask]
def analytic(self, loc, ori):
"Equation 12 of [Sarvas_1987]_"
# r => sensor positions
# r_0 => source positions
# a => vector from sources_to_sensor
# Q => source unit vectors
r_0, Q = loc, ori
center = numpy.mean(r_0, axis=0)[numpy.newaxis, ]
radius = 1.05125 * max(numpy.sqrt(numpy.sum((r_0 - center)**2, axis=1)))
loc = self.sensors.locations.copy()
sen_dis = numpy.sqrt(numpy.sum((loc)**2, axis=1))
loc = loc / sen_dis[:, numpy.newaxis] * radius + center
V_r = numpy.zeros((loc.shape[0], r_0.shape[0]))
for sensor_k in numpy.arange(loc.shape[0]):
a = loc[sensor_k, :] - r_0
na = numpy.sqrt(numpy.sum(a**2, axis=1))[:, numpy.newaxis]
V_r[sensor_k, :] = numpy.sum(Q * (a / na**3), axis=1 ) / (4.0 * numpy.pi * self.sigma)
return V_r
def sample(self, step, state):
maybe_sample = super(EEG, self).sample(step, state)
if maybe_sample is not None:
time, sample = maybe_sample
sample -= self._ref_vec.dot(sample[:, self._ref_vec_mask])[:, numpy.newaxis]
return time, sample.reshape((state.shape[0], -1, 1))
def create_time_series(self, storage_path, connectivity=None, surface=None,
region_map=None, region_volume_map=None):
return TimeSeriesEEG(storage_path=storage_path,
sensors=self.sensors,
sample_period=self.period,
title=' ' + self.__class__.__name__,
**self._transform_user_tags())
def launch(self, view_model):
# type: (SensorsImporterModel) -> [SensorsIndex]
"""
Creates required sensors from the uploaded file.
:returns: a list of sensors instances of the specified type
:raises LaunchException: when
* no sensors_file specified
* sensors_type is invalid (not one of the mentioned options)
* sensors_type is "MEG sensors" and no orientation is specified
"""
if view_model.sensors_file is None:
raise LaunchException(
"Please select sensors file which contains data to import")
self.logger.debug("Create sensors instance")
if view_model.sensors_type == SensorsEEG.sensors_type.default:
sensors_inst = SensorsEEG()
elif view_model.sensors_type == SensorsMEG.sensors_type.default:
sensors_inst = SensorsMEG()
elif view_model.sensors_type == SensorsInternal.sensors_type.default:
sensors_inst = SensorsInternal()
else:
exception_str = "Could not determine sensors type (selected option %s)" % view_model.sensors_type
raise LaunchException(exception_str)
locations = self.read_list_data(view_model.sensors_file,
usecols=[1, 2, 3])
# NOTE: TVB has the nose pointing -y and left ear pointing +x
# If the sensors are in CTF coordinates : nose pointing +x left ear +y
# to rotate the sensors by -90 along z uncomment below
# locations = numpy.array([[0, 1, 0], [-1, 0, 0], [0, 0, 1]]).dot(locations.T).T
sensors_inst.locations = locations
sensors_inst.labels = self.read_list_data(view_model.sensors_file,
dtype=MEMORY_STRING,
usecols=[0])
sensors_inst.number_of_sensors = sensors_inst.labels.size
if isinstance(sensors_inst, SensorsMEG):
try:
sensors_inst.orientations = self.read_list_data(
view_model.sensors_file, usecols=[4, 5, 6])
sensors_inst.has_orientation = True
except IndexError:
raise LaunchException(
"Uploaded file does not contains sensors orientation.")
sensors_inst.configure()
self.logger.debug("Sensors instance ready to be stored")
return h5.store_complete(sensors_inst, self.storage_path)
eeg_projection_file=eeg_fname)
ctx.configure()
print("cortex loaded")
pyplot.figure()
ax = pyplot.subplot(111, projection='3d')
x, y, z = ctx.vertices.T
ax.plot_trisurf(x, y, z, triangles=ctx.triangles, alpha=0.1, edgecolor='k')
# pyplot.show()
print("cortex plot ready")
# unit vectors that describe the location of eeg sensors
sensoreeg_fname = os.path.join(master_path, 'DH_20120806_EEGLocations.txt')
rm = RegionMapping.from_file(region_fname)
sensorsEEG = SensorsEEG.from_file(sensoreeg_fname)
prEEG = ProjectionSurfaceEEG.from_file(eeg_fname)
fsamp = 1e3 / 1024.0 # 1024 Hz
mon = monitors.EEG(sensors=sensorsEEG,
projection=prEEG,
region_mapping=rm,
period=fsamp)
sim = simulator.Simulator(
connectivity=conn,
# conduction speed: 3 mm/ms
# coupling: linear - rescales activity propagated
# stimulus: None - can be a spatiotemporal function
# model: Generic 2D Oscillator - neural mass has two state variables that
eeg_fname = "/home/annajo/git/tvb/tvb-data/tvb_data/berlinSubjects/DH_20120806/DH_20120806_ProjectionMatrix.mat"
ctx = Cortex(load_file=ctx_fname, region_mapping_data=rm)
ctx.configure()
print("cortex loaded")
pyplot.figure()
ax = pyplot.subplot(111, projection='3d')
x, y, z = ctx.vertices.T
ax.plot_trisurf(x, y, z, triangles=ctx.triangles, alpha=0.1, edgecolor='k')
# pyplot.show()
print("cortex plot ready")
# unit vectors that describe the location of eeg sensors
sensoreeg_fname = "/home/annajo/git/tvb/tvb-data/tvb_data/berlinSubjects/DH_20120806/DH_20120806_EEGLocations.txt"
sensorsEEG = SensorsEEG(load_file=sensoreeg_fname)
prEEG = ProjectionSurfaceEEG(load_file=eeg_fname)
fsamp = 1e3 / 1024.0 # 1024 Hz
mon = monitors.EEG(sensors=sensorsEEG,
projection=prEEG,
region_mapping=rm,
period=fsamp)
sim = simulator.Simulator(
connectivity=conn,
# conduction speed: 3 mm/ms
# coupling: linear - rescales activity propagated
# stimulus: None - can be a spatiotemporal function
# model: Generic 2D Oscillator - neural mass has two state variables that
def __init__(self,Ps):
"""
Initialize simulation
----------------------
"""
sim_length = Ps['sim_params']['length']
outdir = Ps['sim_params']['outdir']
if not os.path.isdir(outdir): os.mkdir(outdir)
print '\nConfiguring sim...'
sim = simulator.Simulator()
_classes = [models, connectivity, coupling, integrators, monitors ]
_names = ['model', 'connectivity', 'coupling', 'integrator', 'monitors']
for _class,_name in zip(_classes,_names):
if _name is 'monitors':
thisattr = tuple([getattr(_class,m['type'])(**m['params']) for m in Ps['monitors'] ])
else:
if 'type' in Ps[_name]:
thisattr = getattr(_class,Ps[_name]['type'])(**Ps[_name]['params'])
setattr(sim,_name,thisattr)
# Additionals - parameters that are functions of other classes
# (example = larter_breakdspear demo)
if 'additionals' in Ps:
for a in Ps['additionals']:
setattr(eval(a[0]), a[1],eval(a[2]))
#sim,eval(a[0]),eval(a[1]))
# Stochastic integrator
if 'HeunStochastic' in Ps['integrator']:
from tvb.simulator.lab import noise
hiss = noise.Additive(nsig=np.array(Ps['integrator']['stochastic_nsig'])) # nsigm 0.015
sim.integrator.noise = hiss
# Non-default connectivity
# (to add here:
# - load from other data structures, e.g. .cff file
# - load weights, lengths, etc. directly from data matrices etc
if 'connectivity' in Ps:
if 'folder_path' in Ps['connectivity']: # (this is from the deterministic_stimulus demo)
sim.connectivity.default.reload(sim.connectivity, Ps['connectivity']['folder_path'])
sim.connectivity.configure()
# EEG projections
# (need to do this separately because don't seem to be able to do EEG(projection_matrix='<file>')
for m_it, m in enumerate(Ps['monitors']): # (yes I know enumerate isn't necessary here; but it's more transparent imho)
# assumption here is that the sim object doesn't re-order the list of monitors for any bizarre reason...
# (which would almost certainly cause an error anyway...)
#if m['type'] is 'EEG' and 'proj_mat_path' in m:
# proj_mat = loadmat(m['proj_mat_path'])['ProjectionMatrix']
# pr = projections.ProjectionRegionEEG(projection_data=proj_mat)
# sim.monitors[m_it].projection_matrix_data=pr
if m['type'] is 'EEG':
if m['proj_surf'] is 'default': pr = ProjectionSurfaceEEG(load_default=True)
else: pr = ProjectionSurfaceEEG.from_file(m['proj_surf'])
eeg_sens = SensorsEEG.from_file(source_file=m['source_file'])
if m['reg_map'] is 'default':
rm = RegionMapping(load_default=True)
else: rm = RegionMapping.from_file(m['reg_map'])
sim.monitors[m_it].projection = pr
sim.monitors[m_it].sensors = eeg_sens
sim.monitors[m_it].region_mapping = rm
# Surface
if 'surface' in Ps:
surf = getattr(surfaces,Ps['surface']['surface_type']).default()
if 'local_connectivity_params' in Ps['surface']:
localsurfconn = getattr(surfaces,'LocalConnectivity')(**Ps['surface']['local_connectivity_params'])
for ep in Ps['surface']['local_connectivity_equation_params'].items():
localsurfconn.equation.parameters[ep[0]] = ep[1]
surf.local_connectivity = localsurfconn
localcoupling = np.array( Ps['surface']['local_coupling_strength'] )
surf.coupling_strength = localcoupling
sim.surface = surf
# Stimulus
if 'stimulus' in Ps:
stim = getattr(patterns,Ps['stimulus']['type'])()
if 'equation' in Ps['stimulus']: # looks like need to do this to keep the other params as default; slightly different to above
stim_eqn_params = Ps['stimulus']['equation']['params']
# use this if need to evaluate text
# (stim_eqn_params = {p[0]: eval(p[1]) for p in Ps['stimulus']['equation']['params'].items() } (
stim_eqn_t = getattr(equations,Ps['stimulus']['equation']['type'])()
stim_eqn_t.parameters.update(**stim_eqn_params)
stim.temporal = stim_eqn_t
elif 'equation' not in Ps['stimulus']:
# (still need to do this...)
print 'something to do here'
sim.connectivity.configure()
stim_weighting = np.zeros((sim.connectivity.number_of_regions,))
stim_weighting[Ps['stimulus']['nodes']] = np.array(Ps['stimulus']['node_weightings'])
stim.connectivity = sim.connectivity
stim.weight = stim_weighting
sim.stimulus = stim
# Configure sim
sim.configure()
# Configure smooth parameter variation (if used)
spv = {}
if 'smooth_pvar' in Ps:
par_length = eval(Ps['smooth_pvar']['par_length_str'])
spv['mon_type'] = Ps['smooth_pvar']['monitor_type']
spv['mon_num'] = [m_it for m_it, m in enumerate(Ps['monitors']) if m == spv['mon_type'] ] # (yes, a bit clumsy..)
# a) as an equally spaced range
if 'equation' not in Ps['smooth_pvar']:
spv['a'] = eval(Ps['smooth_pvar']['spv_a_str'])
# b) using an Equation datadtype
else:
spv['params'] = {}
for p in Ps['smooth_pvar']['equation']['params'].items():
spv['params'][p[0]] = eval(p[1])
#sim_length = Ps['sim_params']['length'] # temporary fix]
#spv_a_params = {p[0]: eval(p[1]) for p in Ps['smooth_pvar']['equation']['params'].items() }
spv['eqn_t'] = getattr(equations,Ps['smooth_pvar']['equation']['type'])()
spv['eqn_t'].parameters.update(**spv['params'])
spv['pattern'] = eval(Ps['smooth_pvar']['equation']['pattern_str'])
spv['a'] = spv['pattern'] # omit above line? At moment this follows tutorial code
# recent additions....
self.sim = sim
self.Ps = Ps
self.sim_length = sim_length
self.spv = spv
