def test_modifying_attributes(self):
"""
Test that when modifying an instance attributes, they are only visible on that instance.
"""
eqn_t = equations.Gaussian()
eqn_t.parameters["midpoint"] = 8.0
eqn_x = equations.Gaussian()
eqn_x.parameters["amp"] = -0.0625
assert eqn_t.parameters is not None
assert eqn_t.parameters['amp'] == 1.0
assert eqn_t.parameters['midpoint'] == 8.0
assert eqn_x.parameters is not None
assert eqn_x.parameters['amp'] == -0.0625
assert eqn_x.parameters['midpoint'] == 0.0
a1 = numpy.array([20.0, ])
a2 = deepcopy(a1)
a2 = numpy.array([42.0, ])
assert a1[0] != a2[0]
model1 = ReducedSetHindmarshRose()
model1.a = numpy.array([55.0, ])
model1.number_of_modes = 10
model2 = ReducedSetHindmarshRose()
model2.a = numpy.array([42.0])
model2.number_of_modes = 15
assert model1.number_of_modes != model2.number_of_modes
assert model1.a[0] != model2.a[0]
def test_gaussian(self):
dt = equations.Gaussian()
assert dt.parameters == {
'amp': 1.0,
'sigma': 1.0,
'midpoint': 0.0,
'offset': 0.0
}
def test_gaussian(self):
dt = equations.Gaussian()
self.assertEqual(dt.parameters, {
'amp': 1.0,
'sigma': 1.0,
'midpoint': 0.0,
'offset': 0.0
})
def test_gaussian(self):
dt = equations.Gaussian()
self.assertEqual(dt.parameters, {
'amp': 1.0,
'sigma': 1.0,
'midpoint': 0.0
})
self.assertEqual(
dt.ui_equation,
'amp * 2.71**(-((var-midpoint)**2 / (2.0 * sigma**2)))')
def test_modifying_attributes(self):
"""
Test that when modifying an instance attributes, they are only visible on that instance.
"""
eqn_t = equations.Gaussian()
eqn_t.parameters["midpoint"] = 8.0
eqn_x = equations.Gaussian()
eqn_x.parameters["amp"] = -0.0625
self.assertTrue(eqn_t.parameters is not None)
self.assertEqual(eqn_t.parameters['amp'], 1.0)
self.assertEqual(eqn_t.parameters['midpoint'], 8.0)
self.assertTrue(eqn_x.parameters is not None)
self.assertEqual(eqn_x.parameters['amp'], -0.0625)
self.assertEqual(eqn_x.parameters['midpoint'], 0.0)
a1 = arrays.FloatArray()
a1.data = numpy.array([
20.0,
])
a2 = deepcopy(a1)
a2.data = numpy.array([
42.0,
])
self.assertNotEqual(a1.data[0], a2.data[0])
model1 = ReducedSetHindmarshRose()
model1.a = numpy.array([
55.0,
])
model1.number_of_modes = 10
model2 = ReducedSetHindmarshRose()
model2.a = numpy.array([42.0])
model2.number_of_modes = 15
self.assertNotEqual(model1.number_of_modes, model2.number_of_modes)
self.assertNotEqual(model1.a[0], model2.a[0])
def test_spatiotemporalpattern(self):
dt = patterns.SpatioTemporalPattern()
dt.spatial = equations.DoubleGaussian()
dt.temporal = equations.Gaussian()
dt.configure_space(numpy.arange(100).reshape((10, 10)))
dt.configure()
summary = dt.summary_info()
assert summary['Type'] == 'SpatioTemporalPattern'
assert dt.space.shape == (10, 10)
assert isinstance(dt.spatial, equations.DoubleGaussian)
assert dt.spatial_pattern.shape == (10, 1)
assert isinstance(dt.temporal, equations.Gaussian)
assert dt.temporal_pattern is None
assert dt.time is None
def test_spatiotemporalpattern(self):
dt = patterns.SpatioTemporalPattern()
dt.spatial = equations.DoubleGaussian()
dt.temporal = equations.Gaussian()
dt.spatial_pattern = numpy.arange(100).reshape((10, 10))
dt.configure_space(numpy.arange(100).reshape((10, 10)))
dt.configure()
summary = dt.summary_info
self.assertEqual(summary['Type'], 'SpatioTemporalPattern')
self.assertEqual(dt.space.shape, (10, 10))
self.assertTrue(isinstance(dt.spatial, equations.DoubleGaussian))
self.assertEqual(dt.spatial_pattern.shape, (10, 1))
self.assertTrue(isinstance(dt.temporal, equations.Gaussian))
self.assertTrue(dt.temporal_pattern is None)
self.assertTrue(dt.time is None)
def test_stimuliregion(self):
conn = connectivity.Connectivity(load_default=True)
conn.configure()
dt = patterns.StimuliRegion()
dt.connectivity = conn
dt.spatial = equations.DiscreteEquation()
dt.temporal = equations.Gaussian()
dt.weight = [0 for _ in range(conn.number_of_regions)]
dt.configure_space()
assert dt.summary_info['Type'] == 'StimuliRegion'
assert dt.connectivity is not None
assert dt.space.shape == (76, 1)
assert dt.spatial_pattern.shape == (76, 1)
assert isinstance(dt.temporal, equations.Gaussian)
assert dt.temporal_pattern is None
assert dt.time is None
def test_stimuliregion(self):
conn = connectivity.Connectivity()
conn.configure()
dt = patterns.StimuliRegion()
dt.connectivity = conn
dt.spatial = equations.DiscreteEquation()
dt.temporal = equations.Gaussian()
dt.weight = [0 for _ in range(conn.number_of_regions)]
dt.configure_space()
self.assertEqual(dt.summary_info['Type'], 'StimuliRegion')
self.assertTrue(dt.connectivity is not None)
self.assertEqual(dt.space.shape, (74, 1))
self.assertEqual(dt.spatial_pattern.shape, (74, 1))
self.assertTrue(isinstance(dt.temporal, equations.Gaussian))
self.assertTrue(dt.temporal_pattern is None)
self.assertTrue(dt.time is None)
def test_stimulisurface(self):
srf = surfaces.CorticalSurface.from_file()
srf.configure()
dt = patterns.StimuliSurface()
dt.surface = srf
dt.spatial = equations.DiscreteEquation()
dt.temporal = equations.Gaussian()
dt.focal_points_triangles = numpy.array([0, 1, 2])
dt.configure()
dt.configure_space()
summary = dt.summary_info()
assert summary['Type'] == "StimuliSurface"
assert dt.space.shape == (16384, 3)
assert isinstance(dt.spatial, equations.DiscreteEquation)
assert dt.spatial_pattern.shape == (16384, 1)
assert dt.surface is not None
assert isinstance(dt.temporal, equations.Gaussian)
assert dt.temporal_pattern is None
assert dt.time is None
def test_stimulisurface(self):
srf = surfaces.CorticalSurface(load_default=True)
srf.configure()
dt = patterns.StimuliSurface()
dt.surface = srf
dt.spatial = equations.DiscreteEquation()
dt.temporal = equations.Gaussian()
dt.focal_points_surface = [0, 1, 2]
dt.focal_points_triangles = [0, 1, 2]
dt.configure()
dt.configure_space()
summary = dt.summary_info
self.assertEqual(summary['Type'], "StimuliSurface")
self.assertEqual(dt.space.shape, (16384, 3))
self.assertTrue(isinstance(dt.spatial, equations.DiscreteEquation))
self.assertEqual(dt.spatial_pattern.shape, (16384, 1))
self.assertTrue(dt.surface is not None)
self.assertTrue(isinstance(dt.temporal, equations.Gaussian))
self.assertTrue(dt.temporal_pattern is None)
self.assertTrue(dt.time is None)
class LocalConnectivity(HasTraits):
"""
A sparse matrix for representing the local connectivity within the Cortex.
"""
surface = Attr(field_type=surfaces.CorticalSurface, label="Surface")
matrix = Attr(field_type=scipy.sparse.spmatrix, required=False)
equation = Attr(
field_type=equations.FiniteSupportEquation,
label="Spatial",
required=False,
default=equations.Gaussian())
cutoff = Float(
label="Cutoff distance (mm)",
default=40.0,
doc="Distance at which to truncate the evaluation in mm.")
# Temporary obj
matrix_gdist = None
def compute(self):
"""
Compute current Matrix.
"""
self.log.info("Mapping geodesic distance through the LocalConnectivity.")
# Start with data being geodesic_distance_matrix, then map it through equation
# Then replace original data with result...
self.matrix_gdist.data = self.equation.evaluate(self.matrix_gdist.data)
# Homogenise spatial discretisation effects across the surface
nv = self.matrix_gdist.shape[0]
ind = numpy.arange(nv, dtype=int)
pos_mask = self.matrix_gdist.data > 0.0
neg_mask = self.matrix_gdist.data < 0.0
pos_con = self.matrix_gdist.copy()
neg_con = self.matrix_gdist.copy()
pos_con.data[neg_mask] = 0.0
neg_con.data[pos_mask] = 0.0
pos_contrib = pos_con.sum(axis=1)
pos_contrib = numpy.array(pos_contrib).squeeze()
neg_contrib = neg_con.sum(axis=1)
neg_contrib = numpy.array(neg_contrib).squeeze()
pos_mean = pos_contrib.mean()
neg_mean = neg_contrib.mean()
if ((pos_mean != 0.0 and any(pos_contrib == 0.0)) or
(neg_mean != 0.0 and any(neg_contrib == 0.0))):
msg = "Cortical mesh is too coarse for requested LocalConnectivity."
self.log.warning(msg)
bad_verts = ()
if pos_mean != 0.0:
bad_verts = bad_verts + numpy.nonzero(pos_contrib == 0.0)
if neg_mean != 0.0:
bad_verts = bad_verts + numpy.nonzero(neg_contrib == 0.0)
self.log.debug("Problem vertices are: %s" % str(bad_verts))
pos_hf = numpy.zeros(shape=pos_contrib.shape)
pos_hf[pos_contrib != 0] = pos_mean / pos_contrib[pos_contrib != 0]
neg_hf = numpy.zeros(shape=neg_contrib.shape)
neg_hf[neg_contrib != 0] = neg_mean / neg_contrib[neg_contrib != 0]
pos_hf_diag = scipy.sparse.csc_matrix((pos_hf, (ind, ind)), shape=(nv, nv))
neg_hf_diag = scipy.sparse.csc_matrix((neg_hf, (ind, ind)), shape=(nv, nv))
homogenious_conn = (pos_hf_diag * pos_con) + (neg_hf_diag * neg_con)
# Then replace unhomogenised result with the spatially homogeneous one...
if not homogenious_conn.has_sorted_indices:
homogenious_conn.sort_indices()
self.matrix = homogenious_conn
@staticmethod
def from_file(source_file="local_connectivity_16384.mat"):
result = LocalConnectivity()
source_full_path = try_get_absolute_path("tvb_data.local_connectivity", source_file)
reader = FileReader(source_full_path)
result.matrix = reader.read_array(matlab_data_name="LocalCoupling")
return result
def summary_info(self):
"""
Gather scientifically interesting summary information from an instance
of this datatype.
"""
_, _, v = scipy.sparse.find(self.matrix)
return narray_summary_info(v, ar_name='matrix-nonzero')
def compute_sparse_matrix(self):
"""
NOTE: Before calling this method, the surface field
should already be set on the local connectivity.
Computes the sparse matrix for this local connectivity.
"""
if self.surface is None:
raise AttributeError('Require surface to compute local connectivity.')
self.matrix_gdist = surfaces.gdist.local_gdist_matrix(
self.surface.vertices.astype(numpy.float64),
self.surface.triangles.astype(numpy.int32),
max_distance=self.cutoff)
self.compute()
# Avoid having a large data-set in memory.
self.matrix_gdist = None
#Initialise an Integrator
heunint = integrators.HeunDeterministic(dt=2**-4)
#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 = surfaces.LocalConnectivity(equation=equations.Gaussian(),
cutoff=60.0)
grey_matter.equation.parameters['sigma'] = 10.0
grey_matter.equation.parameters['amp'] = 0.0
default_cortex = surfaces.Cortex(local_connectivity=grey_matter,
coupling_strength=local_coupling_strength)
#Define the stimulus
eqn_t = equations.Gaussian()
eqn_t.parameters["amp"] = 0.0
eqn_t.parameters["midpoint"] = 8.0
eqn_x = equations.Gaussian()
eqn_x.parameters["amp"] = -0.0625
eqn_x.parameters["sigma"] = 28.0
#Initialise some Monitors with period in physical time
momo = monitors.TemporalAverage(period=1.0) #1000Hz
mama = monitors.Bold(period=500) #defaults to one data point every 2s
#Bundle them
what_to_watch = (momo, mama)
#Define the stimulus
#Specify a weighting for regions to receive stimuli...
white_matter.configure() # Because we want access to number_of_regions
nodes = [0, 7, 13, 33, 42]
weighting = numpy.zeros((white_matter.number_of_regions, )) #1
weighting[nodes] = numpy.array([2.0**-2, 2.0**-3, 2.0**-4, 2.0**-5,
2.0**-6]) # [:, numpy.newaxis]
eqn_t = equations.Gaussian()
eqn_t.parameters["midpoint"] = 15000.0
eqn_t.parameters["sigma"] = 4.0
stimulus = patterns.StimuliRegion(temporal=eqn_t,
connectivity=white_matter,
weight=weighting)
#Initialise Simulator -- Model, Connectivity, Integrator, Monitors, and stimulus.
sim = simulator.Simulator(model=oscilator,
connectivity=white_matter,
coupling=white_matter_coupling,
integrator=heunint,
monitors=what_to_watch,
stimulus=stimulus) # surface=default_cortex,
def test_gaussian(self):
t = np.linspace(0,10)
dt = equations.Gaussian()
assert dt.parameters == {'amp': 1.0, 'sigma': 1.0, 'midpoint': 0.0, 'offset': 0.0}
np.testing.assert_allclose( dt.evaluate(t)[10:], dt.evaluate(t[10:]))
