def test_connectivitymeasure(self):
conn = connectivity.Connectivity()
dt = graph.ConnectivityMeasure(connectivity=conn, array_data = numpy.array([]))
assert dt.array_data is not None
assert dt.connectivity is not None
summary = dt.summary_info()
assert summary['Graph type'] == 'ConnectivityMeasure'
def test_region_boundaries(self):
cortex = surfaces.Cortex()
white_matter = connectivity.Connectivity()
white_matter.configure()
rb = region_boundaries.RegionBoundaries(cortex)
self.assertEqual(len(rb.region_neighbours.keys()),
white_matter.number_of_regions)
def test_shape(self):
# try to avoid introspector picking up this model
Gen2D = copy.deepcopy(models.Generic2dOscillator)
class CouplingShapeTestModel(Gen2D):
def __init__(self, test_case=None, n_node=None, **kwds):
super(CouplingShapeTestModel, self).__init__(**kwds)
self.cvar = numpy.r_[0, 1]
self.n_node = n_node
self.test_case = test_case
def dfun(self, state, coupling, local_coupling):
if self.test_case is not None:
self.test_case.assert_equal((2, self.n_node, 1),
coupling.shape)
return state
surf = cortex.Cortex(region_mapping_data=region_mapping.RegionMapping(
load_file="regionMapping_16k_76.txt"),
load_file="cortex_16384.zip")
sim = simulator.Simulator(model=CouplingShapeTestModel(
self, surf.vertices.shape[0]),
connectivity=connectivity.Connectivity(
load_file="connectivity_76.zip"),
surface=surf)
sim.configure()
for _ in sim(simulation_length=sim.integrator.dt * 2):
pass
def test_connectivity_reload(self):
"""
Reload a connectivity and check that defaults changes accordingly.
"""
conn = connectivity.Connectivity()
conn.default.reload(conn,
folder_path=os.path.join("connectivity",
"o52r00_irp2008_hemisphere_both_subcortical_true_regions_190"))
self.assertEqual(conn.weights.shape, (190, 190))
self.assertEqual(conn.weights.max(), 3.0)
self.assertEqual(conn.weights.min(), 0.0)
self.assertEqual(conn.tract_lengths.shape, (190, 190))
self.assertEqual(conn.tract_lengths.max(), 142.1458)
self.assertEqual(conn.tract_lengths.min(), 0.0)
self.assertEqual(conn.centres.shape, (190, 3))
self.assertEqual(conn.orientations.shape, (190, 3))
self.assertEqual(conn.region_labels.shape, (190,))
self.assertEqual(conn.areas.shape, (190,))
self.assertEqual(conn.unidirectional, 0)
self.assertEqual(conn.speed, numpy.array([3.0]))
self.assertFalse(conn.cortical.all())
self.assertEqual(conn.hemispheres.shape, (0,))
self.assertEqual(conn.idelays.shape, (0,))
self.assertEqual(conn.delays.shape, (0,))
self.assertEqual(conn.number_of_regions, 0)
self.assertTrue(conn.parcellation_mask is None)
self.assertTrue(conn.nose_correction is None)
self.assertTrue(conn.saved_selection is None)
self.assertEqual(conn.parent_connectivity, '')
def _vep2tvb_connectivity(vep_conn, connectivity_matrix=None):
if connectivity_matrix is None:
connectivity_matrix = vep_conn.normalized_weights
return connectivity.Connectivity(use_storage=False, weights=connectivity_matrix,
tract_lengths=vep_conn.tract_lengths, region_labels=vep_conn.region_labels,
centres=vep_conn.centers, hemispheres=vep_conn.hemispheres,
orientations=vep_conn.orientations, areas=vep_conn.areas)
def test_connectivity_surrogates(self):
"""
Create a connectivity using generate_surrogate method and that fields get correctly populated
"""
conn = connectivity.Connectivity()
conn.generate_surrogate_connectivity(74)
conn.configure()
# Check for value from tvb_data/connectivity/o52r00_irp2008
assert conn.weights.shape, (74, 74)
assert conn.weights.max() == 1.0
assert conn.weights.min() == 0.0
assert conn.tract_lengths.shape == (74, 74)
assert conn.tract_lengths.max() == 42.0
assert conn.tract_lengths.min() == 0.0
assert conn.centres.shape == (74, 3)
assert conn.orientations.shape == (74, 3)
assert conn.region_labels.shape == (74, )
assert conn.areas is not None
assert conn.undirected == 0
assert conn.speed == numpy.array([3.0])
assert conn.cortical is not None
assert conn.hemispheres is not None
assert conn.idelays.shape == (0, )
assert conn.delays.shape == (
74,
74,
)
assert conn.number_of_regions == 74
assert conn.number_of_connections == 75
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_connectivity_surrogates(self):
"""
Create a connectivity using generate_surrogate method and that fields get correctly populated
"""
conn = connectivity.Connectivity()
conn.generate_surrogate_connectivity(74)
conn.configure()
# Check for value from tvb_data/connectivity/o52r00_irp2008
self.assertEqual(conn.weights.shape, (74, 74))
self.assertEqual(conn.weights.max(), 1.0)
self.assertEqual(conn.weights.min(), 0.0)
self.assertEqual(conn.tract_lengths.shape, (74, 74))
self.assertEqual(conn.tract_lengths.max(), 42.0)
self.assertEqual(conn.tract_lengths.min(), 0.0)
self.assertEqual(conn.centres.shape, (74, 3))
self.assertEqual(conn.orientations.shape, (74, 3))
self.assertEqual(conn.region_labels.shape, (74, ))
self.assertTrue(conn.areas is not None)
self.assertEqual(conn.unidirectional, 0)
self.assertEqual(conn.speed, numpy.array([3.0]))
self.assertTrue(conn.cortical is not None)
self.assertTrue(conn.hemispheres is not None)
self.assertEqual(conn.idelays.shape, (0, ))
self.assertEqual(conn.delays.shape, (
74,
74,
))
self.assertEqual(conn.number_of_regions, 74)
self.assertEqual(conn.number_of_connections, 75)
def test_connectivitymeasure(self):
conn = connectivity.Connectivity()
dt = graph.ConnectivityMeasure(connectivity=conn)
assert dt.shape == (0, )
assert dt.dimensions_labels is None
assert dt.connectivity is not None
summary = dt.summary_info
assert summary['Graph type'] == 'ConnectivityMeasure'
def test_connectivitymeasure(self):
conn = connectivity.Connectivity()
dt = graph.ConnectivityMeasure(connectivity=conn)
self.assertEqual(dt.shape, (0, ))
self.assertTrue(dt.dimensions_labels is None)
self.assertTrue(dt.connectivity is not None)
summary = dt.summary_info
self.assertEqual(summary['Graph type'], 'ConnectivityMeasure')
def setup_method(self):
self.sim = simulator.Simulator(
connectivity=connectivity.Connectivity(
load_file='connectivity_192.zip'),
monitors=(monitors.iEEG(
sensors=SensorsInternal(load_file="seeg_39.txt.bz2"),
region_mapping=RegionMapping(
load_file='regionMapping_16k_192.txt')))).configure()
def _vep2tvb_connectivity(vep_conn):
return connectivity.Connectivity(use_storage=False,
weights=vep_conn.normalized_weights,
tract_lengths=vep_conn.tract_lengths,
region_labels=vep_conn.region_labels,
centres=vep_conn.centers,
hemispheres=vep_conn.hemispheres,
orientations=vep_conn.orientations,
areas=vep_conn.areas)
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.Connectivity(load_default=True)
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_76.txt")
else:
white_matter = connectivity.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 _vep2tvb_connectivity(vep_conn, model_connectivity=None):
if model_connectivity is None:
model_connectivity = vep_conn.normalized_weights
return connectivity.Connectivity(use_storage=False,
weights=model_connectivity,
tract_lengths=TIME_DELAYS_FLAG *
vep_conn.tract_lengths,
region_labels=vep_conn.region_labels,
centres=vep_conn.centres,
hemispheres=vep_conn.hemispheres,
orientations=vep_conn.orientations,
areas=vep_conn.areas)
def _run_sim(self, length, model, *mons):
sim = simulator.Simulator(
model=model,
connectivity=connectivity.Connectivity(load_default=True),
coupling=coupling.Linear(),
integrator=integrators.EulerDeterministic(),
monitors=mons)
sim.configure()
ys = []
for (t, y), in sim(simulation_length=length):
ys.append(y)
return sim, numpy.array(ys)
def gen_sim(a):
dt = 0.1
conn = connectivity.Connectivity()
conn.weights = weights
conn.tract_lengths = idelays * dt
conn.speed = 1.0
sim = simulator.Simulator(
coupling=py_coupling.Kuramoto(a=a),
connectivity=conn,
model=models.Kuramoto(omega=100 * 2 * numpy.pi / 1e3),
monitors=monitors.Raw(),
integrator=integrators.EulerDeterministic(dt=dt))
sim.configure()
sim.history[:] = 0.1
return sim
class StimuliRegionData(SpatioTemporalPatternData):
"""
A class that bundles the temporal profile of the stimulus, together with the
list of scaling weights of the regions where it will applied.
"""
connectivity = connectivity_module.Connectivity(label="Connectivity",
order=1)
spatial = equations.DiscreteEquation(label="Spatial Equation",
default=equations.DiscreteEquation,
fixed_type=True,
order=-1)
weight = basic.List(label="scaling", locked=True, order=4)
def test_connectivity_default(self):
"""
Create a default connectivity and check that everything gets loaded
"""
conn = connectivity.Connectivity(load_default=True)
conn.configure()
# Check for value from tvb_data/connectivity/o52r00_irp2008
self.assertEqual(conn.weights.shape, (74, 74))
self.assertEqual(conn.weights.max(), 3.0)
self.assertEqual(conn.weights.min(), 0.0)
self.assertEqual(conn.tract_lengths.shape, (74, 74))
self.assertEqual(conn.tract_lengths.max(), 153.48574)
self.assertEqual(conn.tract_lengths.min(), 0.0)
self.assertEqual(conn.centres.shape, (74, 3))
self.assertEqual(conn.orientations.shape, (74, 3))
self.assertEqual(conn.region_labels.shape, (74, ))
self.assertEqual(conn.areas.shape, (74, ))
self.assertEqual(conn.unidirectional, 0)
self.assertEqual(conn.speed, numpy.array([3.0]))
self.assertTrue(conn.cortical.all())
self.assertEqual(conn.hemispheres.shape, (74, ))
self.assertEqual(conn.idelays.shape, (0, ))
self.assertEqual(conn.delays.shape, (
74,
74,
))
self.assertEqual(conn.number_of_regions, 74)
self.assertEqual(conn.number_of_connections, 1560)
self.assertTrue(conn.parcellation_mask is None)
self.assertTrue(conn.nose_correction is None)
self.assertTrue(conn.saved_selection is None)
self.assertEqual(conn.parent_connectivity, '')
summary = conn.summary_info
self.assertEqual(summary['Number of regions'], 74)
## Call connectivity methods and make sure no compilation or runtime erros
conn.compute_tract_lengths()
conn.compute_region_labels()
conn.try_compute_hemispheres()
self.assertEqual(conn.scaled_weights().shape, (74, 74))
for mode in ['none', 'tract', 'region']:
# Empirical seems to fail on some scipy installations. Error is not pinned down
# so far, it seems to only happen on some machines. Most relevant related to this:
#
# http://projects.scipy.org/scipy/ticket/1735
# http://comments.gmane.org/gmane.comp.python.scientific.devel/14816
# http://permalink.gmane.org/gmane.comp.python.numeric.general/42082
#conn.switch_distribution(mode=mode)
self.assertEqual(conn.scaled_weights(mode=mode).shape, (74, 74))
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_connectivity_default(self):
"""
Create a default connectivity and check that everything gets loaded
"""
conn = connectivity.Connectivity(load_file="connectivity_76.zip")
conn.configure()
n = 76
# Check for value from tvb_data/connectivity/o52r00_irp2008
assert conn.weights.shape == (n, n)
assert conn.weights.max() == 3.0
assert conn.weights.min() == 0.0
assert conn.tract_lengths.shape == (n, n)
assert conn.tract_lengths.max() == 153.48574
assert conn.tract_lengths.min() == 0.0
assert conn.centres.shape == (n, 3)
assert conn.orientations.shape == (n, 3)
assert conn.region_labels.shape == (n, )
assert conn.areas.shape == (n, )
assert conn.undirected == 0
assert conn.speed == numpy.array([3.0])
assert conn.cortical.all()
assert conn.hemispheres.shape == (n, )
assert conn.idelays.shape == (0, )
assert conn.delays.shape == (
n,
n,
)
assert conn.number_of_regions == n
assert conn.number_of_connections == 1560
assert conn.saved_selection is None
assert conn.parent_connectivity is None
summary = conn._find_summary_info()
assert summary['Number of regions'] == n
## Call connectivity methods and make sure no compilation or runtime erros
conn.compute_tract_lengths()
conn.compute_region_labels()
conn.try_compute_hemispheres()
assert conn.scaled_weights().shape == (n, n)
for mode in ['none', 'tract', 'region']:
# Empirical seems to fail on some scipy installations. Error is not pinned down
# so far, it seems to only happen on some machines. Most relevant related to this:
#
# http://projects.scipy.org/scipy/ticket/1735
# http://comments.gmane.org/gmane.comp.python.scientific.devel/14816
# http://permalink.gmane.org/gmane.comp.python.numeric.general/42082
# conn.switch_distribution(mode=mode)
assert conn.scaled_weights(mode=mode).shape == (n, n)
def test_connectivity_bzip_in_zip(self):
conn = connectivity.Connectivity(load_file="connectivity_68.zip")
conn.configure()
assert conn.weights.shape == (68, 68)
assert conn.weights.max() == 0.12053822
assert conn.weights.min() == 0.0
assert conn.tract_lengths.shape == (68, 68)
assert conn.tract_lengths.max() == 252.90276
assert conn.tract_lengths.min() == 0.0
assert conn.centres.shape == (68, 3)
assert conn.orientations.shape == (68, 3)
assert conn.region_labels.shape == (68, )
assert conn.areas.shape == (0, )
assert conn.undirected == 1
assert conn.speed == numpy.array([3.0])
assert conn.hemispheres.shape == (68, )
assert conn.idelays.shape == (0, )
assert conn.delays.shape == (68, 68)
assert conn.number_of_regions == 68
def test_connectivity_h5py_reload(self):
"""
Reload a connectivity and check that defaults changes accordingly.
"""
h5_full_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"Edited_Connectivity.h5")
conn = connectivity.Connectivity(load_file=h5_full_path)
assert conn.weights.shape == (74, 74)
assert conn.weights[0][0] == 9.0 # Edit set first weight to 9
assert conn.weights.max() == 9.0 # Edit has a weight of value 9
assert conn.weights.min() == 0.0
assert conn.undirected == 0
assert conn.speed == numpy.array([3.0])
assert conn.hemispheres.shape == (74, )
assert conn.idelays.shape == (0, )
assert conn.delays.shape == (0, )
assert conn.number_of_regions == 0
assert conn.saved_selection is None
assert conn.parent_connectivity is None
def __init__(self,
connectivity=None,
spatial=None,
weight=None,
*args,
**kwargs):
if connectivity is None:
connectivity = conn.Connectivity()
self.connectivity = connectivity
# lives in base class
if spatial is None:
spatial = equations.DiscreteEquation()
if weight is None:
weight = []
self.weight = weight
super(StimuliRegion, self).__init__(*args, spatial=spatial, **kwargs)
class StimuliRegion(SpatioTemporalPattern):
"""
A class that bundles the temporal profile of the stimulus, together with the
list of scaling weights of the regions where it will applied.
"""
connectivity = connectivity.Connectivity(label="Connectivity", order=1)
spatial = equations.DiscreteEquation(label="Spatial Equation",
default=equations.DiscreteEquation,
fixed_type=True,
order=-1)
weight = basic.List(label="scaling", locked=True, order=4)
@staticmethod
def get_default_weights(number_of_regions):
"""
Returns a list with a number of elements
equal to the given number of regions.
"""
return [0.0] * number_of_regions
@property
def weight_array(self):
"""
Wrap weight List into a Numpy array, as it is requested by the simulator.
"""
return numpy.array(self.weight)[:, numpy.newaxis]
def configure_space(self, region_mapping=None):
"""
Do necessary preparations in order to use this stimulus.
NOTE: this was previously done in simulator configure_stimuli() method.
It no needs to be used in stimulus viewer also.
"""
if region_mapping is not None:
#TODO: smooth at surface region boundaries
distance = self.weight_array[region_mapping, :]
else:
distance = self.weight_array
super(StimuliRegion, self).configure_space(distance)
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_connectivity_h5py_reload(self):
"""
Reload a connectivity and check that defaults changes accordingly.
"""
conn = connectivity.Connectivity()
conn.default.reload(conn,
folder_path=os.path.join(os.path.dirname(os.path.abspath(__file__))),
file_name="Edited_Connectivity.h5")
self.assertEqual(conn.weights.shape, (74, 74))
self.assertEqual(conn.weights[0][0], 9.0) # Edit set first weight to 9
self.assertEqual(conn.weights.max(), 9.0) # Edit has a weight of value 9
self.assertEqual(conn.weights.min(), 0.0)
self.assertEqual(conn.unidirectional, 0)
self.assertEqual(conn.speed, numpy.array([3.0]))
self.assertEqual(conn.hemispheres.shape, (0,))
self.assertEqual(conn.idelays.shape, (0,))
self.assertEqual(conn.delays.shape, (0,))
self.assertEqual(conn.number_of_regions, 0)
self.assertTrue(conn.parcellation_mask is None)
self.assertTrue(conn.nose_correction is None)
self.assertTrue(conn.saved_selection is None)
self.assertEqual(conn.parent_connectivity, '')
def test_default_attributes(self):
"""
Test that default_console attributes are populated.
"""
cortex = surfaces.CorticalSurface()
cortex.configure()
self.assertTrue(cortex.vertices is not None)
self.assertEqual(81924, cortex.number_of_vertices)
self.assertEqual((81924, 3), cortex.vertices.shape)
self.assertEqual((81924, 3), cortex.vertex_normals.shape)
self.assertEqual(163840, cortex.number_of_triangles)
self.assertEqual((163840, 3), cortex.triangles.shape)
conn = connectivity.Connectivity()
conn.configure()
self.assertTrue(conn.centres is not None)
self.assertEqual((74,), conn.region_labels.shape)
self.assertEqual('lA1', conn.region_labels[0])
self.assertEquals((74, 3), conn.centres.shape)
self.assertEquals((74, 74), conn.weights.shape)
self.assertEquals((74, 74), conn.tract_lengths.shape)
self.assertEquals(conn.delays.shape, conn.tract_lengths.shape)
self.assertEqual(74, conn.number_of_regions)
def test_connectivity_reload(self):
"""
Reload a connectivity and check that defaults changes accordingly.
"""
conn = connectivity.Connectivity(load_file="connectivity_192.zip")
n = 192
assert conn.weights.shape == (n, n)
assert conn.weights.max() == 3.0
assert conn.weights.min() == 0.0
assert conn.tract_lengths.shape == (n, n)
assert conn.tract_lengths.max() == 142.1458
assert conn.tract_lengths.min() == 0.0
assert conn.centres.shape == (n, 3)
assert conn.orientations.shape == (n, 3)
assert conn.region_labels.shape == (n, )
assert conn.areas.shape == (n, )
assert conn.undirected == 0
assert conn.speed == numpy.array([3.0])
assert conn.hemispheres.shape == (0, )
assert conn.idelays.shape == (0, )
assert conn.delays.shape == (0, )
assert conn.number_of_regions == 0
assert conn.saved_selection is None
assert conn.parent_connectivity is None
class Simulator(core.Type):
"""
The Simulator class coordinates classes from all other modules in the
simulator package in order to perform simulations.
In general, it is necessary to initialiaze a simulator with the desired
components and then call the simulator in a loop to obtain simulation
data:
>>> sim = Simulator(...)
>>> for output in sim(simulation_length=1000):
...
Please refer to the user guide and the demos for more detail.
.. #Currently there seems to be a clash betwen traits and autodoc, autodoc
.. #can't find the methods of the class, the class specific names below get
.. #us around this...
.. automethod:: Simulator.__init__
.. automethod:: Simulator.configure
.. automethod:: Simulator.__call__
.. automethod:: Simulator.configure_history
.. automethod:: Simulator.configure_integrator_noise
.. automethod:: Simulator.memory_requirement
.. automethod:: Simulator.runtime
.. automethod:: Simulator.storage_requirement
"""
connectivity = connectivity_dtype.Connectivity(
label="Long-range connectivity",
default=None,
order=1,
required=True,
filters_ui=[
UIFilter(linked_elem_name="projection_matrix_data",
linked_elem_field=FilterChain.datatype + "._sources",
linked_elem_parent_name="monitors",
linked_elem_parent_option="EEG"),
UIFilter(linked_elem_name="region_mapping_data",
linked_elem_field=FilterChain.datatype + "._connectivity",
linked_elem_parent_name="surface",
linked_elem_parent_option=None)
],
doc="""A tvb.datatypes.Connectivity object which contains the
structural long-range connectivity data (i.e., white-matter tracts). In
combination with the ``Long-range coupling function`` it defines the inter-regional
connections. These couplings undergo a time delay via signal propagation
with a propagation speed of ``Conduction Speed``""")
conduction_speed = basic.Float(
label="Conduction Speed",
default=3.0,
order=2,
required=False,
range=basic.Range(lo=0.01, hi=100.0, step=1.0),
doc="""Conduction speed for ``Long-range connectivity`` (mm/ms)""")
coupling = coupling_module.Coupling(
label="Long-range coupling function",
default=coupling_module.Linear(),
required=True,
order=2,
doc="""The coupling function is applied to the activity propagated
between regions by the ``Long-range connectivity`` before it enters the local
dynamic equations of the Model. Its primary purpose is to 'rescale' the
incoming activity to a level appropriate to Model.""")
surface = Cortex(
label="Cortical surface",
default=None,
order=3,
required=False,
filters_backend=FilterChain(
fields=[FilterChain.datatype + '._valid_for_simulations'],
operations=["=="],
values=[True]),
filters_ui=[
UIFilter(linked_elem_name="projection_matrix_data",
linked_elem_field=FilterChain.datatype + "._sources",
linked_elem_parent_name="monitors",
linked_elem_parent_option="EEG"),
UIFilter(linked_elem_name="local_connectivity",
linked_elem_field=FilterChain.datatype + "._surface",
linked_elem_parent_name="surface",
linked_elem_parent_option=None)
],
doc="""By default, a tvb.datatypes.Cortex object which represents the
cortical surface defined by points in the 3D physical space and their
neighborhood relationship. In the current TVB version, when setting up a
surface-based simulation, the option to configure the spatial spread of
the ``Local Connectivity`` is available.""")
stimulus = patterns_dtype.SpatioTemporalPattern(
label="Spatiotemporal stimulus",
default=None,
order=4,
required=False,
doc=
"""A ``Spatiotemporal stimulus`` can be defined at the region or surface level.
It's composed of spatial and temporal components. For region defined stimuli
the spatial component is just the strength with which the temporal
component is applied to each region. For surface defined stimuli, a
(spatial) function, with finite-support, is used to define the strength
of the stimuli on the surface centred around one or more focal points.
In the current version of TVB, stimuli are applied to the first state
variable of the ``Local dynamic model``.""")
model = models_module.Model(
label="Local dynamic model",
default=models_module.Generic2dOscillator,
required=True,
order=5,
doc="""A tvb.simulator.Model object which describe the local dynamic
equations, their parameters, and, to some extent, where connectivity
(local and long-range) enters and which state-variables the Monitors
monitor. By default the 'Generic2dOscillator' model is used. Read the
Scientific documentation to learn more about this model.""")
integrator = integrators_module.Integrator(
label="Integration scheme",
default=integrators_module.HeunDeterministic,
required=True,
order=6,
doc="""A tvb.simulator.Integrator object which is
an integration scheme with supporting attributes such as
integration step size and noise specification for stochastic
methods. It is used to compute the time courses of the model state
variables.""")
initial_conditions = arrays_dtype.FloatArray(
label="Initial Conditions",
default=None,
order=-1,
required=False,
doc="""Initial conditions from which the simulation will begin. By
default, random initial conditions are provided. Needs to be the same shape
as simulator 'history', ie, initial history function which defines the
minimal initial state of the network with time delays before time t=0.
If the number of time points in the provided array is insufficient the
array will be padded with random values based on the 'state_variables_range'
attribute.""")
monitors = monitors_module.Monitor(
label="Monitor(s)",
default=monitors_module.TemporalAverage,
required=True,
order=8,
select_multiple=True,
doc="""A tvb.simulator.Monitor or a list of tvb.simulator.Monitor
objects that 'know' how to record relevant data from the simulation. Two
main types exist: 1) simple, spatial and temporal, reductions (subsets
or averages); 2) physiological measurements, such as EEG, MEG and fMRI.
By default the Model's specified variables_of_interest are returned,
temporally downsampled from the raw integration rate to a sample rate of
1024Hz.""")
simulation_length = basic.Float(
label="Simulation Length (ms)",
default=1000.0, # ie 1 second
required=True,
order=9,
doc="""The length of a simulation in milliseconds (ms).""")
def __init__(self, **kwargs):
"""
Use the base class' mechanisms to initialise the traited attributes
declared above, overriding defaults with any provided keywords. Then
declare any non-traited attributes.
"""
super(Simulator, self).__init__(**kwargs)
LOG.debug(str(kwargs))
self.calls = 0
self.current_step = 0
self.number_of_nodes = None
self.horizon = None
self.good_history_shape = None
self.history = None
self._memory_requirement_guess = None
self._memory_requirement_census = None
self._storage_requirement = None
self._runtime = None
def __str__(self):
return "Simulator(**kwargs)"
def preconfigure(self):
"""
Configure just the basic fields, so that memory can be estimated
"""
self.connectivity.configure()
if self.surface:
self.surface.configure()
if self.stimulus:
self.stimulus.configure()
self.coupling.configure()
self.model.configure()
self.integrator.configure()
# monitors needs to be a list or tuple, even if there is only one...
if not isinstance(self.monitors, (list, tuple)):
self.monitors = [self.monitors]
# Configure monitors
for monitor in self.monitors:
monitor.configure()
##------------- Now the the interdependant configuration -------------##
#"Nodes" refers to either regions or vertices + non-cortical regions.
if self.surface is None:
self.number_of_nodes = self.connectivity.number_of_regions
else:
#try:
self.number_of_nodes = self.surface.region_mapping.shape[0]
#except AttributeError:
# msg = "%s: Surface needs region mapping defined... "
# LOG.error(msg % (repr(self)))
# Estimate of memory usage
self._guesstimate_memory_requirement()
def configure(self, full_configure=True):
"""
The first step of configuration is to run the configure methods of all
the Simulator's components, ie its traited attributes.
Configuration of a Simulator primarily consists of calculating the
attributes, etc, which depend on the combinations of the Simulator's
traited attributes (keyword args).
Converts delays from physical time units into integration steps
and updates attributes that depend on combinations of the 6 inputs.
"""
if full_configure:
# When run from GUI, preconfigure is run separately, and we want to avoid running that part twice
self.preconfigure()
#Make sure spatialised model parameters have the right shape (number_of_nodes, 1)
excluded_params = ("state_variable_range", "variables_of_interest",
"noise", "psi_table", "nerf_table")
for param in self.model.trait.keys():
if param in excluded_params:
continue
#If it's a surface sim and model parameters were provided at the region level
region_parameters = getattr(self.model, param)
if self.surface is not None:
if region_parameters.size == self.connectivity.number_of_regions:
new_parameters = region_parameters[
self.surface.region_mapping].reshape((-1, 1))
setattr(self.model, param, new_parameters)
region_parameters = getattr(self.model, param)
if region_parameters.size == self.number_of_nodes:
new_parameters = region_parameters.reshape((-1, 1))
setattr(self.model, param, new_parameters)
#Configure spatial component of any stimuli
self.configure_stimuli()
#Set delays, provided in physical units, in integration steps.
self.connectivity.set_idelays(self.integrator.dt)
self.horizon = numpy.max(self.connectivity.idelays) + 1
LOG.info("horizon is %d steps" % self.horizon)
# workspace -- minimal state of network with delays
self.good_history_shape = (self.horizon, self.model.nvar,
self.number_of_nodes,
self.model.number_of_modes)
msg = "%s: History shape will be: %s"
LOG.debug(msg % (repr(self), str(self.good_history_shape)))
#Reshape integrator.noise.nsig, if necessary.
if isinstance(self.integrator,
integrators_module.IntegratorStochastic):
self.configure_integrator_noise()
self.configure_history(self.initial_conditions)
#Configure Monitors to work with selected Model, etc...
self.configure_monitors()
#Estimate of memory usage.
self._census_memory_requirement()
def __call__(self, simulation_length=None, random_state=None):
"""
When a Simulator is called it returns an iterator.
kwargs:
``simulation_length``:
total time of simulation
``random_state``:
a state for the NumPy random number generator, saved from a previous
call to permit consistent continuation of a simulation.
"""
#The number of times this Simulator has been called.
self.calls += 1
#Update the simulator objects simulation_length attribute,
if simulation_length is None:
simulation_length = self.simulation_length
else:
self.simulation_length = simulation_length
#Estimate run time and storage requirements, with logging.
self._guesstimate_runtime()
self._calculate_storage_requirement()
if random_state is not None:
if isinstance(self.integrator,
integrators_module.IntegratorStochastic):
self.integrator.noise.random_stream.set_state(random_state)
msg = "%s: random_state supplied. Seed is: %s"
LOG.info(
msg %
(str(self),
str(self.integrator.noise.random_stream.get_state()[1][0])
))
else:
msg = "%s: random_state supplied for non-stochastic integration"
LOG.warn(msg % str(self))
#Determine the number of integration steps required to produce
#data of simulation_length
int_steps = int(simulation_length / self.integrator.dt)
LOG.info("%s: gonna do %d integration steps" % (str(self), int_steps))
# locals for cleaner code.
horizon = self.horizon
history = self.history
dfun = self.model.dfun
coupling = self.coupling
scheme = self.integrator.scheme
npsum = numpy.sum
npdot = numpy.dot
ncvar = len(self.model.cvar)
number_of_regions = self.connectivity.number_of_regions
nsn = (number_of_regions, 1, number_of_regions)
# Exact dtypes and alignment are required by c speedups. Once we have history objects these will be encapsulated
# cvar index array broadcastable to nodes, cvars, nodes
cvar = numpy.array(self.model.cvar[numpy.newaxis, :, numpy.newaxis],
dtype=numpy.intc)
LOG.debug("%s: cvar is: %s" % (str(self), str(cvar)))
# idelays array broadcastable to nodes, cvars, nodes
idelays = numpy.array(self.connectivity.idelays[:, numpy.newaxis, :],
dtype=numpy.intc,
order='c')
LOG.debug("%s: idelays shape is: %s" % (str(self), str(idelays.shape)))
# weights array broadcastable to nodes, cva, nodes, modes
weights = self.connectivity.weights[:, numpy.newaxis, :, numpy.newaxis]
LOG.debug("%s: weights shape is: %s" % (str(self), str(weights.shape)))
# node_ids broadcastable to nodes, cvars, nodes
node_ids = numpy.array(
numpy.arange(number_of_regions)[numpy.newaxis, numpy.newaxis, :],
dtype=numpy.intc)
LOG.debug("%s: node_ids shape is: %s" %
(str(self), str(node_ids.shape)))
if self.surface is None:
local_coupling = 0.0
else:
region_average = self.surface.region_average
region_history = npdot(
region_average, history
) # this may be very expensive ~60sec for epileptor (many states and modes ...)
region_history = region_history.transpose((1, 2, 0, 3))
region_history = numpy.ascontiguousarray(
region_history) # required by the c speedups
if self.surface.coupling_strength.size == 1:
local_coupling = (self.surface.coupling_strength[0] *
self.surface.local_connectivity.matrix)
elif self.surface.coupling_strength.size == self.surface.number_of_vertices:
ind = numpy.arange(self.number_of_nodes, dtype=int)
vec_cs = numpy.zeros((self.number_of_nodes, ))
vec_cs[:self.surface.
number_of_vertices] = self.surface.coupling_strength
sp_cs = sparse.csc_matrix(
(vec_cs, (ind, ind)),
shape=(self.number_of_nodes, self.number_of_nodes))
local_coupling = sp_cs * self.surface.local_connectivity.matrix
if self.stimulus is None:
stimulus = 0.0
else: # TODO: Consider changing to simulator absolute time... This is an open discussion, a matter of interpretation of the stimuli time axis.
time = numpy.arange(0, simulation_length, self.integrator.dt)
time = time[numpy.newaxis, :]
self.stimulus.configure_time(time)
stimulus = numpy.zeros((self.model.nvar, self.number_of_nodes, 1))
LOG.debug("%s: stimulus shape is: %s" %
(str(self), str(stimulus.shape)))
# initial state, history[timepoint[0], state_variables, nodes, modes]
state = history[self.current_step % horizon, :]
LOG.debug("%s: state shape is: %s" % (str(self), str(state.shape)))
if self.surface is not None:
# the vertex mapping array is huge but sparse.
# csr because I expect the row to have one value and I expect the dot to proceed row wise.
vertex_mapping = sparse.csr_matrix(self.surface.vertex_mapping)
# this is big a well. same shape as the vertex mapping.
region_average = sparse.csr_matrix(region_average)
node_coupling_shape = (vertex_mapping.shape[0], ncvar,
self.model.number_of_modes)
delayed_state = numpy.zeros(
(number_of_regions, ncvar, number_of_regions,
self.model.number_of_modes))
for step in xrange(self.current_step + 1,
self.current_step + int_steps + 1):
time_indices = (step - 1 - idelays) % horizon
if self.surface is None:
get_state(history,
time_indices,
cvar,
node_ids,
out=delayed_state)
node_coupling = coupling(weights, state[self.model.cvar],
delayed_state)
else:
get_state(region_history,
time_indices,
cvar,
node_ids,
out=delayed_state)
region_coupling = coupling(
weights, region_history[(step - 1) % horizon,
self.model.cvar], delayed_state)
node_coupling = numpy.empty(node_coupling_shape)
# sparse matrices cannot multiply with 3d arrays so we use a loop over the modes
for mi in xrange(self.model.number_of_modes):
node_coupling[...,
mi] = vertex_mapping * region_coupling[...,
mi].T
node_coupling = node_coupling.transpose((1, 0, 2))
if self.stimulus is not None:
stimulus[self.model.cvar, :, :] = numpy.reshape(
self.stimulus(step - (self.current_step + 1)), (1, -1, 1))
state = scheme(state, dfun, node_coupling, local_coupling,
stimulus)
history[step % horizon, :] = state
if self.surface is not None:
# this optimisation is similar to the one done for vertex_mapping above
step_avg = numpy.empty((number_of_regions, state.shape[0],
self.model.number_of_modes))
for mi in xrange(self.model.number_of_modes):
step_avg[..., mi] = region_average.dot(state[..., mi].T)
region_history[step % horizon, :] = step_avg.transpose(
(1, 0, 2))
# monitor.things e.g. raw, average, eeg, meg, fmri...
output = [monitor.record(step, state) for monitor in self.monitors]
if any(outputi is not None for outputi in output):
yield output
# This -1 is here for not repeating the point on resume
self.current_step = self.current_step + int_steps - 1
self.history = history
def configure_history(self, initial_conditions=None):
"""
Set initial conditions for the simulation using either the provided
initial_conditions or, if none are provided, the model's initial()
method. This method is called durin the Simulator's __init__().
Any initial_conditions that are provided as an argument are expected
to have dimensions 1, 2, and 3 with shapse corresponding to the number
of state_variables, nodes and modes, respectively. If the provided
inital_conditions are shorter in time (dim=0) than the required history
the model's initial() method is called to make up the difference.
"""
history = self.history
if initial_conditions is None:
msg = "%s: Setting default history using model's initial() method."
LOG.info(msg % str(self))
history = self.model.initial(self.integrator.dt,
self.good_history_shape)
else:
# history should be [timepoints, state_variables, nodes, modes]
LOG.info("%s: Received initial conditions as arg." % str(self))
ic_shape = initial_conditions.shape
if ic_shape[1:] != self.good_history_shape[1:]:
msg = "%s: bad initial_conditions[1:] shape %s, should be %s"
msg %= self, ic_shape[1:], self.good_history_shape[1:]
raise ValueError(msg)
else:
if ic_shape[0] >= self.horizon:
msg = "%s: Using last %s time-steps for history."
LOG.info(msg % (str(self), self.horizon))
history = initial_conditions[
-self.horizon:, :, :, :].copy()
else:
msg = "%s: initial_conditions shorter than required."
LOG.info(msg % str(self))
msg = "%s: Using model's initial() method for difference."
LOG.info(msg % str(self))
history = self.model.initial(self.integrator.dt,
self.good_history_shape)
csmh = self.current_step % self.horizon
history = numpy.roll(history, -csmh, axis=0)
history[:ic_shape[0], :, :, :] = initial_conditions
history = numpy.roll(history, csmh, axis=0)
self.current_step += ic_shape[0] - 1
msg = "%s: history shape is: %s"
LOG.debug(msg % (str(self), str(history.shape)))
self.history = history
def configure_integrator_noise(self):
"""
This enables having noise to be state variable specific and/or to enter
only via specific brain structures, for example it we only want to
consider noise as an external input entering the brain via appropriate
thalamic nuclei.
Support 3 possible shapes:
1) number_of_nodes;
2) number_of_state_variables; and
3) (number_of_state_variables, number_of_nodes).
"""
noise = self.integrator.noise
if self.integrator.noise.ntau > 0.0:
self.integrator.noise.configure_coloured(
self.integrator.dt, self.good_history_shape[1:])
else:
self.integrator.noise.configure_white(self.integrator.dt,
self.good_history_shape[1:])
if self.surface is not None:
if self.integrator.noise.nsig.size == self.connectivity.number_of_regions:
self.integrator.noise.nsig = self.integrator.noise.nsig[
self.surface.region_mapping]
elif self.integrator.noise.nsig.size == self.model.nvar * self.connectivity.number_of_regions:
self.integrator.noise.nsig = self.integrator.noise.nsig[:,
self.
surface
.
region_mapping]
good_nsig_shape = (self.model.nvar, self.number_of_nodes,
self.model.number_of_modes)
nsig = self.integrator.noise.nsig
LOG.debug("Simulator.integrator.noise.nsig shape: %s" %
str(nsig.shape))
if nsig.shape in (good_nsig_shape, (1, )):
return
elif nsig.shape == (self.model.nvar, ):
nsig = nsig.reshape((self.model.nvar, 1, 1))
elif nsig.shape == (self.number_of_nodes, ):
nsig = nsig.reshape((1, self.number_of_nodes, 1))
elif nsig.shape == (self.model.nvar, self.number_of_nodes):
nsig = nsig.reshape((self.model.nvar, self.number_of_nodes, 1))
else:
msg = "Bad Simulator.integrator.noise.nsig shape: %s"
LOG.error(msg % str(nsig.shape))
LOG.debug("Simulator.integrator.noise.nsig shape: %s" %
str(nsig.shape))
self.integrator.noise.nsig = nsig
def configure_monitors(self):
""" Configure the requested Monitors for this Simulator """
if not isinstance(self.monitors, (list, tuple)):
self.monitors = [self.monitors]
# Configure monitors
for monitor in self.monitors:
monitor.config_for_sim(self)
def configure_stimuli(self):
""" Configure the defined Stimuli for this Simulator """
if self.stimulus is not None:
if self.surface:
self.stimulus.configure_space(self.surface.region_mapping)
else:
self.stimulus.configure_space()
def memory_requirement(self):
"""
Return an estimated of the memory requirements (Bytes) for this
simulator's current configuration.
"""
self._guesstimate_memory_requirement()
return self._memory_requirement_guess
def runtime(self, simulation_length):
"""
Return an estimated run time (seconds) for the simulator's current
configuration and a specified simulation length.
"""
self.simulation_length = simulation_length
self._guesstimate_runtime()
return self._runtime
def storage_requirement(self, simulation_length):
"""
Return an estimated storage requirement (Bytes) for the simulator's
current configuration and a specified simulation length.
"""
self.simulation_length = simulation_length
self._calculate_storage_requirement()
return self._storage_requirement
def _guesstimate_memory_requirement(self):
"""
guesstimate the memory required for this simulator.
Guesstimate is based on the shape of the dominant arrays, and as such
can operate before configuration.
NOTE: Assumes returned/yeilded data is in some sense "taken care of" in
the world outside the simulator, and so doesn't consider it, making
the simulator's history, and surface if present, the dominant
memory pigs...
"""
if self.surface:
number_of_nodes = self.surface.number_of_vertices
else:
number_of_nodes = self.connectivity.number_of_regions
number_of_regions = self.connectivity.number_of_regions
magic_number = 2.42 # Current guesstimate is low by about a factor of 2, seems safer to over estimate...
bits_64 = 8.0 # Bytes
bits_32 = 4.0 # Bytes
#NOTE: The speed hack for getting the first element of hist shape should
# partially resolves calling of this method with a non-configured
# connectivity, there remains the less common issue if no tract_lengths...
hist_shape = (
self.connectivity.tract_lengths.max() /
(self.conduction_speed or self.connectivity.speed or 3.0) /
self.integrator.dt, self.model.nvar, number_of_nodes,
self.model.number_of_modes)
memreq = numpy.prod(hist_shape) * bits_64
if self.surface:
memreq += self.surface.number_of_triangles * 3 * bits_32 * 2 # normals
memreq += self.surface.number_of_vertices * 3 * bits_64 * 2 # normals
memreq += number_of_nodes * number_of_regions * bits_64 * 4 # vertex_mapping, region_average, region_sum
#???memreq += self.surface.local_connectivity.matrix.nnz * 8
if not isinstance(self.monitors, (list, tuple)):
monitors = [self.monitors]
else:
monitors = self.monitors
for monitor in monitors:
if not isinstance(monitor, monitors_module.Bold):
stock_shape = (monitor.period / self.integrator.dt,
self.model.variables_of_interest.shape[0],
number_of_nodes, self.model.number_of_modes)
memreq += numpy.prod(stock_shape) * bits_64
if hasattr(monitor, "sensors"):
try:
memreq += number_of_nodes * monitor.sensors.number_of_sensors * bits_64 # projection_matrix
except AttributeError:
LOG.debug(
"No sensors specified, guessing memory based on default EEG."
)
memreq += number_of_nodes * 62.0 * bits_64
else:
stock_shape = (monitor.hrf_length * monitor._stock_sample_rate,
self.model.variables_of_interest.shape[0],
number_of_nodes, self.model.number_of_modes)
interim_stock_shape = (
1.0 / (2.0**-2 * self.integrator.dt),
self.model.variables_of_interest.shape[0], number_of_nodes,
self.model.number_of_modes)
memreq += numpy.prod(stock_shape) * bits_64
memreq += numpy.prod(interim_stock_shape) * bits_64
if psutil and memreq > psutil.virtual_memory().total:
LOG.error("This is gonna get ugly...")
self._memory_requirement_guess = magic_number * memreq
msg = "Memory requirement guesstimate: simulation will need about %.1f MB"
LOG.info(msg % (self._memory_requirement_guess / 1048576.0))
def _census_memory_requirement(self):
"""
Guesstimate the memory required for this simulator.
Guesstimate is based on a census of the dominant arrays after the
simulator has been configured.
NOTE: Assumes returned/yeilded data is in some sense "taken care of" in
the world outside the simulator, and so doesn't consider it, making
the simulator's history, and surface if present, the dominant
memory pigs...
"""
magic_number = 2.42 # Current guesstimate is low by about a factor of 2, seems safer to over estimate...
memreq = self.history.nbytes
try:
memreq += self.surface.triangles.nbytes * 2
memreq += self.surface.vertices.nbytes * 2
memreq += self.surface.vertex_mapping.nbytes * 4 # vertex_mapping, region_average, region_sum
memreq += self.surface.eeg_projection.nbytes
memreq += self.surface.local_connectivity.matrix.nnz * 8
except AttributeError:
pass
for monitor in self.monitors:
memreq += monitor._stock.nbytes
if isinstance(monitor, monitors_module.Bold):
memreq += monitor._interim_stock.nbytes
if psutil and memreq > psutil.virtual_memory().total:
LOG.error("This is gonna get ugly...")
self._memory_requirement_census = magic_number * memreq
#import pdb; pdb.set_trace()
msg = "Memory requirement census: simulation will need about %.1f MB"
LOG.info(msg % (self._memory_requirement_census / 1048576.0))
def _guesstimate_runtime(self):
"""
Estimate the runtime for this simulator.
Spread in parallel executions of larger arrays means this will be an over-estimation,
or rather a single threaded estimation...
Different choice of integrators and monitors has an additional effect,
on the magic number though relatively minor
"""
magic_number = 6.57e-06 # seconds
self._runtime = (magic_number * self.number_of_nodes *
self.model.nvar * self.model.number_of_modes *
self.simulation_length / self.integrator.dt)
msg = "Simulation single-threaded runtime should be about %s seconds!"
LOG.info(msg % str(int(self._runtime)))
def _calculate_storage_requirement(self):
"""
Calculate the storage requirement for the simulator, configured with
models, monitors, etc being run for a particular simulation length.
While this is only approximate, it is far more reliable/accurate than
the memory and runtime guesstimates.
"""
LOG.info("Calculating storage requirement for ...")
strgreq = 0
for monitor in self.monitors:
# Avoid division by zero for monitor not yet configured
# (in framework this is executed, when only preconfigure has been called):
current_period = monitor.period or self.integrator.dt
strgreq += (TvbProfile.current.MAGIC_NUMBER *
self.simulation_length * self.number_of_nodes *
self.model.nvar * self.model.number_of_modes /
current_period)
LOG.info("Calculated storage requirement for simulation: %d " %
int(strgreq))
self._storage_requirement = int(strgreq)