def test_export(self):
op = TestFactory.create_operation(test_user=self.test_user,
test_project=self.test_project)
burst_config = BurstConfiguration(self.test_project.id)
burst_config.fk_simulation = op.id
burst_config.simulator_gid = self.session_stored_simulator.gid.hex
burst_config = dao.store_entity(burst_config)
storage_path = FilesHelper().get_project_folder(
self.test_project, str(op.id))
h5_path = h5.path_for(storage_path, SimulatorH5,
self.session_stored_simulator.gid)
with SimulatorH5(h5_path) as h5_file:
h5_file.store(self.session_stored_simulator)
burst = dao.get_bursts_for_project(self.test_project.id)
self.sess_mock['burst_id'] = str(burst[0].id)
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_BURST_CONFIG,
self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG, burst_config)
result = self.simulator_controller.export(str(burst[0].id))
assert path.exists(result.input.name), "Simulation was not exported!"
def build(project):
range_1 = ["row1", [1, 2, 10]]
range_2 = ["row2", [0.1, 0.3, 0.5]]
group = OperationGroup(
project.id, ranges=[json.dumps(range_1),
json.dumps(range_2)])
group = dao.store_entity(group)
group_ms = OperationGroup(
project.id, ranges=[json.dumps(range_1),
json.dumps(range_2)])
group_ms = dao.store_entity(group_ms)
datatype_group = DataTypeGroup(group)
datatype_group.no_of_ranges = 2
datatype_group.count_results = 10
dao.store_entity(datatype_group)
dt_group_ms = DataTypeGroup(group_ms)
dao.store_entity(dt_group_ms)
burst = BurstConfiguration(project.id, name='test_burst')
burst.simulator_gid = uuid.uuid4().hex
burst.fk_operation_group = group.id
burst.fk_metric_operation_group = group_ms.id
burst = dao.store_entity(burst)
return burst
def test_load_burst_only(self):
zip_path = path.join(path.dirname(tvb_data.__file__), 'connectivity', 'connectivity_66.zip')
connectivity = TestFactory.import_zip_connectivity(self.test_user, self.test_project, zip_path, "John")
op = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project)
burst_config = BurstConfiguration(self.test_project.id)
burst_config.fk_simulation = op.id
burst_config.simulator_gid = self.session_stored_simulator.gid.hex
burst_config.name = 'Test_Burst'
burst_config = dao.store_entity(burst_config)
self.sess_mock['burst_id'] = str(burst_config.id)
self.sess_mock['connectivity'] = connectivity.gid
self.sess_mock['conduction_speed'] = "3.0"
self.sess_mock['coupling'] = "Sigmoidal"
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_SIMULATOR_CONFIG, self.session_stored_simulator)
self.simulator_controller.set_connectivity(**self.sess_mock._data)
self.simulator_controller.set_stimulus(**self.sess_mock._data)
storage_path = FilesHelper().get_project_folder(self.test_project, str(op.id))
SimulatorSerializer().serialize_simulator(self.session_stored_simulator, None, storage_path)
with patch('cherrypy.session', self.sess_mock, create=True):
self.simulator_controller.load_burst_read_only(str(burst_config.id))
is_simulator_load = common.get_from_session(KEY_IS_SIMULATOR_LOAD)
is_simulator_copy = common.get_from_session(KEY_IS_SIMULATOR_COPY)
last_loaded_form_url = common.get_from_session(KEY_LAST_LOADED_FORM_URL)
assert is_simulator_load, "Simulator Load Flag should be True!"
assert not is_simulator_copy, "Simulator Copy Flag should be False!"
assert last_loaded_form_url == '/burst/setup_pse', "Incorrect last form URL!"
def test_export_simulator_configuration(self, operation_factory,
connectivity_index_factory):
"""
Test export of a simulator configuration
"""
conn_gid = uuid.UUID(connectivity_index_factory().gid)
operation = operation_factory(is_simulation=True,
store_vm=True,
test_project=self.test_project,
conn_gid=conn_gid)
burst_configuration = BurstConfiguration(self.test_project.id)
burst_configuration.fk_simulation = operation.id
burst_configuration.simulator_gid = operation.view_model_gid
burst_configuration.name = "Test_burst"
burst_configuration = dao.store_entity(burst_configuration)
op_folder = StorageInterface().get_project_folder(
self.test_project.name, str(operation.id))
BurstService().store_burst_configuration(burst_configuration,
op_folder)
export_file = self.export_manager.export_simulator_configuration(
burst_configuration.id)
assert export_file is not None, "Export process should return path to export file"
assert os.path.exists(
export_file
), "Could not find export file: %s on disk." % export_file
assert zipfile.is_zipfile(
export_file), "Generated file is not a valid ZIP file"
def test_export_simulator_configuration(self, operation_factory,
connectivity_factory):
"""
Test export of a simulator configuration
"""
operation = operation_factory()
simulator = SimulatorAdapterModel()
simulator.connectivity = connectivity_factory(4).gid
burst_configuration = BurstConfiguration(self.test_project.id)
burst_configuration.fk_simulation_id = operation.id
burst_configuration.simulator_gid = simulator.gid.hex
burst_configuration = dao.store_entity(burst_configuration)
storage_path = FilesHelper().get_project_folder(
self.test_project, str(operation.id))
h5_path = h5.path_for(storage_path, SimulatorH5, simulator.gid)
with SimulatorH5(h5_path) as h5_file:
h5_file.store(simulator)
export_file = self.export_manager.export_simulator_configuration(
burst_configuration.id)
assert export_file is not None, "Export process should return path to export file"
assert os.path.exists(
export_file
), "Could not find export file: %s on disk." % export_file
assert zipfile.is_zipfile(
export_file), "Generated file is not a valid ZIP file"
def store_burst(project_id, simulator_config=None):
"""
Build and persist BurstConfiguration entity.
"""
burst = BurstConfiguration(project_id)
if simulator_config is not None:
burst.simulator_configuration = simulator_config
return dao.store_entity(burst)
def _store_burst(self, proj_id, status, sim_config, name):
"""
Create and store a burst entity, for the project given project_id, having the
given status and simulator parames config, under the given name.
"""
burst = BurstConfiguration(proj_id, status, sim_config, name)
burst.prepare_before_save()
return dao.store_entity(burst)
def _store_burst(self, proj_id, status, sim_config, name):
"""
Create and store a burst entity, for the project given project_id, having the
given status and simulator parames config, under the given name.
"""
burst = BurstConfiguration(proj_id, status, sim_config, name)
burst.prepare_before_save()
return dao.store_entity(burst)
def test_set_simulation_length_with_burst_config_name(self):
burst_config = BurstConfiguration(self.test_project.id)
burst_config.name = "Test Burst Config"
self.sess_mock['simulation_length'] = '1000.0'
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_SIMULATOR_CONFIG, self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG, burst_config)
self.simulator_controller.set_simulation_length(**self.sess_mock._data)
assert self.session_stored_simulator.simulation_length == 1000.0, "simulation_length was not set correctly."
def load_burst_entity(self, json_burst, project_id):
"""
Load BurstConfiguration from JSON (possibly exported from a different machine).
Nothing gets persisted in DB or on disk.
:param json_burst: Burst JSON export
:param project_id: Current project ID (it will be used if the user later starts this simulation)
:return: BurstConfiguration filled from JSON
"""
burst_information = BurstInformation.load_from_dict(json_burst)
burst_entity = BurstConfiguration(project_id)
burst_entity.from_dict(burst_information.data)
burst_entity.prepare_after_load()
burst_entity.reset_tabs()
workflow_info = burst_information.get_workflows()[0]
workflow_entity = Workflow(project_id, None)
workflow_entity.from_dict(workflow_info.data)
view_steps = workflow_info.get_view_steps()
analyze_steps = workflow_info.get_workflow_steps()
for view_step in view_steps:
try:
algorithm = view_step.get_algorithm()
portlet = view_step.get_portlet()
view_step_entity = WorkflowStepView(algorithm.id, portlet_id=portlet.id)
view_step_entity.from_dict(view_step.data)
view_step_entity.workflow = workflow_entity
# For each visualize step, also load all of the analyze steps.
analyzers = []
for an_step in analyze_steps:
if (an_step.data["tab_index"] != view_step_entity.tab_index
or an_step.data["index_in_tab"] != view_step_entity.index_in_tab):
continue
algorithm = an_step.get_algorithm()
wf_step_entity = WorkflowStep(algorithm.id)
wf_step_entity.from_dict(an_step.data)
wf_step_entity.workflow = workflow_entity
analyzers.append(wf_step_entity)
portlet = PortletConfiguration(portlet.id)
portlet.set_visualizer(view_step_entity)
portlet.set_analyzers(analyzers)
burst_entity.set_portlet(view_step_entity.tab_index, view_step_entity.index_in_tab, portlet)
except Exception:
# only log exception and ignore this step from loading
self.logger.exception("Could not restore Workflow Step " + view_step.get_algorithm().name)
return burst_entity
def test_load_burst_history(self):
burst_config1 = BurstConfiguration(self.test_project.id)
burst_config2 = BurstConfiguration(self.test_project.id)
burst_config3 = BurstConfiguration(self.test_project.id)
dao.store_entity(burst_config1)
dao.store_entity(burst_config2)
dao.store_entity(burst_config3)
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_BURST_CONFIG, burst_config1)
burst_parameters = self.simulator_controller.load_burst_history()
assert len(burst_parameters['burst_list']) == 3, "The burst configurations where not stored."
def test_set_monitor_equation(self):
self.sess_mock['tau_s'] = '0.8'
self.sess_mock['tau_f'] = '0.4'
self.sess_mock['k_1'] = '5.6'
self.sess_mock['V_0'] = '0.02'
self.session_stored_simulator.monitors = [Bold()]
self.session_stored_simulator.monitors[
0].equation = FirstOrderVolterra()
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_SIMULATOR_CONFIG,
self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG,
BurstConfiguration(self.test_project.id))
self.simulator_controller.set_monitor_equation(
'Bold', **self.sess_mock._data)
assert self.session_stored_simulator.monitors[0].equation.parameters[
'tau_s'] == 0.8, "tau_s value was not set correctly."
assert self.session_stored_simulator.monitors[0].equation.parameters[
'tau_f'] == 0.4, "tau_f value was not set correctly."
assert self.session_stored_simulator.monitors[0].equation.parameters[
'k_1'] == 5.6, "k_1 value was not set correctly."
assert self.session_stored_simulator.monitors[0].equation.parameters[
'V_0'] == 0.02, "V_0 value was not set correctly."
def _import_bursts(project_entity, bursts_dict):
"""
Re-create old bursts, but keep a mapping between the id it has here and the old-id it had
in the project where they were exported, so we can re-add the datatypes to them.
"""
burst_ids_mapping = {}
for old_burst_id in bursts_dict:
burst_information = BurstInformation.load_from_dict(bursts_dict[old_burst_id])
burst_entity = BurstConfiguration(project_entity.id)
burst_entity.from_dict(burst_information.data)
burst_entity = dao.store_entity(burst_entity)
burst_ids_mapping[int(old_burst_id)] = burst_entity.id
# We don't need the data in dictionary form anymore, so update it with new BurstInformation object
bursts_dict[old_burst_id] = burst_information
return burst_ids_mapping
def test_export(self):
op = TestFactory.create_operation()
simulator_index = SimulatorIndex()
simulator_index.fill_from_has_traits(self.session_stored_simulator)
burst_config = BurstConfiguration(self.test_project.id,
simulator_index.id)
burst_config = dao.store_entity(burst_config)
simulator_index.fk_from_operation = op.id
simulator_index = dao.store_entity(simulator_index)
simulator_index.fk_parent_burst = burst_config.id
simulator_index = dao.store_entity(simulator_index)
simulator_h5 = h5.path_for_stored_index(simulator_index)
with SimulatorH5(simulator_h5) as h5_file:
h5_file.store(self.session_stored_simulator)
burst = dao.get_bursts_for_project(self.test_project.id)
self.sess_mock['burst_id'] = str(burst[0].id)
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_BURST_CONFIG,
self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG, burst_config)
result = self.simulator_controller.export(str(burst[0].id))
assert path.exists(result.input.name), "Simulation was not exported!"
def test_export_simulator_configuration(self, operation_factory):
"""
Test export of a simulator configuration
"""
operation = operation_factory()
simulator = Simulator()
simulator_index = SimulatorIndex()
simulator_index.fill_from_has_traits(simulator)
simulator_index.fk_from_operation = operation.id
simulator_index = dao.store_entity(simulator_index)
burst_configuration = BurstConfiguration(self.test_project.id,
simulator_index.id)
burst_configuration = dao.store_entity(burst_configuration)
simulator_index.fk_parent_burst = burst_configuration.id
simulator_index = dao.store_entity(simulator_index)
simulator_h5 = h5.path_for_stored_index(simulator_index)
with SimulatorH5(simulator_h5) as h5_file:
h5_file.store(simulator)
export_file = self.export_manager.export_simulator_configuration(
burst_configuration.id)
assert export_file is not None, "Export process should return path to export file"
assert os.path.exists(
export_file
), "Could not find export file: %s on disk." % export_file
assert zipfile.is_zipfile(
export_file), "Generated file is not a valid ZIP file"
def test_get_history_status(self):
burst_config = BurstConfiguration(self.test_project.id)
burst_config.start_time = datetime.now()
dao.store_entity(burst_config)
burst = dao.get_bursts_for_project(self.test_project.id)
self.sess_mock['burst_ids'] = '["' + str(burst[0].id) + '"]'
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_BURST_CONFIG, self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG, burst_config)
result = self.simulator_controller.get_history_status(**self.sess_mock._data).split(',')
assert int(result[0][2:]) == burst[0].id, "Incorrect burst was used."
assert result[1] == ' "running"', "Status should be set to running."
assert result[2] == ' false', "Burst shouldn't be group."
assert result[3] == ' ""', "Message should be empty, which means that there shouldn't be any errors."
assert int(result[4][2:-4]) >= 0, "Running time should be greater than or equal to 0."
def test_rename_burst(self):
burst_config = BurstConfiguration(self.test_project.id)
burst_config.name = 'Test Burst Configuration'
new_name = "Test Burst Configuration 2"
dao.store_entity(burst_config)
burst = dao.get_bursts_for_project(self.test_project.id)
self.sess_mock['burst_id'] = str(burst[0].id)
self.sess_mock['burst_name'] = new_name
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_BURST_CONFIG, self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG, burst_config)
result = self.simulator_controller.rename_burst(str(burst[0].id), new_name)
assert result == '{"success": "Simulation successfully renamed!"}', \
"Some error happened at renaming, probably because of invalid new name."
assert dao.get_bursts_for_project(self.test_project.id)[0].name == new_name, "Name wasn't actually changed."
def load_datatype_from_file(self,
current_file,
op_id,
datatype_group=None,
current_project_id=None):
# type: (str, int, DataTypeGroup, int) -> HasTraitsIndex
"""
Creates an instance of datatype from storage / H5 file
:returns: DatatypeIndex
"""
self.logger.debug("Loading DataType from file: %s" % current_file)
h5_class = H5File.h5_class_from_file(current_file)
if h5_class is BurstConfigurationH5:
if current_project_id is None:
op_entity = dao.get_operationgroup_by_id(op_id)
current_project_id = op_entity.fk_launched_in
h5_file = BurstConfigurationH5(current_file)
burst = BurstConfiguration(current_project_id)
burst.fk_simulation = op_id
h5_file.load_into(burst)
result = burst
else:
datatype, generic_attributes = h5.load_with_links(current_file)
index_class = h5.REGISTRY.get_index_for_datatype(
datatype.__class__)
datatype_index = index_class()
datatype_index.fill_from_has_traits(datatype)
datatype_index.fill_from_generic_attributes(generic_attributes)
# Add all the required attributes
if datatype_group:
datatype_index.fk_datatype_group = datatype_group.id
if len(datatype_group.subject) == 0:
datatype_group.subject = datatype_index.subject
dao.store_entity(datatype_group)
datatype_index.fk_from_operation = op_id
associated_file = h5.path_for_stored_index(datatype_index)
if os.path.exists(associated_file):
datatype_index.disk_size = FilesHelper.compute_size_on_disk(
associated_file)
result = datatype_index
return result
def set_burst_config(self, burst_config=None):
# type: (BurstConfiguration) -> None
"""
Create a new burst instance only if one does not exist in the context.
"""
if not burst_config and not self.burst_config:
burst_config = BurstConfiguration(self.project.id)
if burst_config:
common.add2session(self.KEY_BURST_CONFIG, burst_config)
def load_burst_configuration_from_folder(simulator_folder, project):
bc_h5_filename = DirLoader(
simulator_folder,
None).find_file_for_has_traits_type(BurstConfiguration)
burst_config = BurstConfiguration(project.id)
with BurstConfigurationH5(
os.path.join(simulator_folder, bc_h5_filename)) as bc_h5:
bc_h5.load_into(burst_config)
return burst_config
def reset_simulator_configuration(self):
burst_config = BurstConfiguration(self.context.project.id)
self.context.init_session_at_sim_reset(burst_config, SimulatorWizzardURLs.SET_CONNECTIVITY_URL)
self.monitors_handler.clear_next_monitors_dict()
form = self.prepare_first_fragment()
rendering_rules = SimulatorFragmentRenderingRules(form, SimulatorWizzardURLs.SET_CONNECTIVITY_URL,
is_first_fragment=True)
return rendering_rules.to_dict()
def build(test_user, test_project, simulation_length=10, is_group=False):
model = SimulatorAdapterModel()
model.connectivity = connectivity_index_factory().gid
model.simulation_length = simulation_length
burst = BurstConfiguration(test_project.id, name="Sim " + str(datetime.now()))
burst.start_time = datetime.now()
algorithm = dao.get_algorithm_by_module(SIMULATOR_MODULE, SIMULATOR_CLASS)
service = SimulatorService()
if is_group:
range_param = RangeParameter("conduction_speed", float, Range(lo=50.0, hi=100.0, step=20.0))
burst.range1 = range_param.to_json()
burst = BurstService().prepare_burst_for_pse(burst)
op = service.async_launch_and_prepare_pse(burst, test_user, test_project, algorithm,
range_param, None, model)
else:
dao.store_entity(burst)
op = service.async_launch_and_prepare_simulation(burst, test_user, test_project, algorithm, model)
return op
def store_burst(project_id, operation=None):
"""
Build and persist BurstConfiguration entity.
"""
burst = BurstConfiguration(project_id)
if operation is not None:
burst.name = 'dummy_burst'
burst.status = BurstConfiguration.BURST_FINISHED
burst.start_time = datetime.now()
burst.range1 = '["conduction_speed", {"lo": 50, "step": 1.0, "hi": 100.0}]'
burst.range2 = '["connectivity", null]'
burst.fk_simulation = operation.id
burst.simulator_gid = uuid.uuid4().hex
BurstService().store_burst_configuration(burst)
return dao.store_entity(burst)
def test_launch_simulation_with_default_parameters(self):
self.sess_mock['input-simulation-name-id'] = 'HappySimulation'
launch_mode = 'new'
burst_config = BurstConfiguration(self.test_project.id)
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_BURST_CONFIG, burst_config)
common.add2session(common.KEY_SIMULATOR_CONFIG, self.session_stored_simulator)
self.simulator_controller.launch_simulation(launch_mode, **self.sess_mock._data)
def test_load_burst_only(self):
zip_path = path.join(path.dirname(tvb_data.__file__), 'connectivity',
'connectivity_66.zip')
TestFactory.import_zip_connectivity(self.test_user, self.test_project,
zip_path, "John")
connectivity = TestFactory.get_entity(self.test_project,
ConnectivityIndex)
simulator_index = SimulatorIndex()
simulator_index.fill_from_has_traits(self.session_stored_simulator)
burst_config = BurstConfiguration(self.test_project.id,
simulator_index.id)
burst_config = dao.store_entity(burst_config)
simulator_index.fk_from_operation = burst_config.id
simulator_index = dao.store_entity(simulator_index)
simulator_index.fk_parent_burst = burst_config.id
simulator_index = dao.store_entity(simulator_index)
burst = dao.get_bursts_for_project(self.test_project.id)
self.sess_mock['burst_id'] = str(burst[0].id)
self.sess_mock['_connectivity'] = connectivity.gid
self.sess_mock['_conduction_speed'] = "3.0"
self.sess_mock['_coupling'] = "Sigmoidal"
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_SIMULATOR_CONFIG,
self.session_stored_simulator)
self.simulator_controller.set_connectivity(**self.sess_mock._data)
self.simulator_controller.set_stimulus(**self.sess_mock._data)
storage_path = FilesHelper().get_project_folder(
self.test_project, str(simulator_index.fk_from_operation))
simulator_service = SimulatorService()
SimulatorSerializer().serialize_simulator(
self.session_stored_simulator, simulator_index.gid, None,
storage_path)
with patch('cherrypy.session', self.sess_mock, create=True):
self.simulator_controller.load_burst_read_only(str(burst[0].id))
is_simulator_load = common.get_from_session(KEY_IS_SIMULATOR_LOAD)
is_simulator_copy = common.get_from_session(KEY_IS_SIMULATOR_COPY)
last_loaded_form_url = common.get_from_session(
KEY_LAST_LOADED_FORM_URL)
database_simulator = dao.get_generic_entity(SimulatorIndex,
burst_config.id,
'fk_parent_burst')[0]
assert simulator_index.gid == database_simulator.gid, "Simulator was not added correctly!"
assert is_simulator_load, "Simulator Load Flag should be True!"
assert not is_simulator_copy, "Simulator Copy Flag should be False!"
assert last_loaded_form_url == '/burst/setup_pse', "Incorrect last form URL!"
def fire_simulation(project_id, simulator):
project = dao.get_project_by_id(project_id)
assert isinstance(simulator, Simulator)
# Load the SimulatorAdapter algorithm from DB
cached_simulator_algorithm = FlowService(
).get_algorithm_by_module_and_class(IntrospectionRegistry.SIMULATOR_MODULE,
IntrospectionRegistry.SIMULATOR_CLASS)
# Instantiate a SimulatorService and launch the configured simulation
simulator_service = SimulatorService()
burst = BurstConfiguration(project.id)
burst.name = "Sim " + str(datetime.now())
burst.start_time = datetime.now()
dao.store_entity(burst)
launched_operation = simulator_service.async_launch_and_prepare_simulation(
burst, project.administrator, project, cached_simulator_algorithm,
simulator, None)
LOG.info("Operation launched ....")
return launched_operation
def test_export_simulator_configuration(self, operation_factory):
"""
Test export of a simulator configuration
"""
operation = operation_factory(is_simulation=True, store_vm=True)
burst_configuration = BurstConfiguration(self.test_project.id)
burst_configuration.fk_simulation = operation.id
burst_configuration.simulator_gid = operation.view_model_gid
burst_configuration = dao.store_entity(burst_configuration)
export_file = self.export_manager.export_simulator_configuration(
burst_configuration.id)
assert export_file is not None, "Export process should return path to export file"
assert os.path.exists(
export_file
), "Could not find export file: %s on disk." % export_file
assert zipfile.is_zipfile(
export_file), "Generated file is not a valid ZIP file"
def test_set_monitors(self):
self.sess_mock['monitors'] = ['Temporal average']
self.session_stored_simulator.monitors[0].variables_of_interest = numpy.array([0])
self.session_stored_simulator.model.variables_of_interest = ['V', 'W']
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_SIMULATOR_CONFIG, self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG, BurstConfiguration(self.test_project.id))
self.simulator_controller.set_monitors(**self.sess_mock._data)
assert isinstance(self.session_stored_simulator.monitors[0], TemporalAverage), 'Monitor class is incorrect.'
def load_burst_entity(self, json_burst, project_id):
"""
Load BurstConfiguration from JSON (possibly exported from a different machine).
Nothing gets persisted in DB or on disk.
:param json_burst: Burst JSON export
:param project_id: Current project ID (it will be used if the user later starts this simulation)
:return: BurstConfiguration filled from JSON
"""
burst_entity = BurstConfiguration(project_id)
return burst_entity
def test_set_seeg_monitor_params(self):
region_mapping = self.set_region_mapping()
seeg_sensors_file = path.join(path.dirname(tvb_data.sensors.__file__),
'seeg_588.txt')
seeg_sensors = TestFactory.import_sensors(
self.test_user, self.test_project, seeg_sensors_file,
SensorsImporterModel.OPTIONS['Internal Sensors'])
surface_file = path.join(path.dirname(tvb_data.surfaceData.__file__),
'cortex_16384.zip')
surface = TestFactory.import_surface_zip(self.test_user,
self.test_project,
surface_file, CORTICAL, True)
seeg_projection_file = path.join(
path.dirname(tvb_data.projectionMatrix.__file__),
'projection_seeg_588_surface_16k.npy')
seeg_projections = TestFactory.import_projection_matrix(
self.test_user, self.test_project, seeg_projection_file,
seeg_sensors.gid, surface.gid)
self.session_stored_simulator.model.variables_of_interest = ('V', 'W',
'V - W')
variable_of_interest_indexes = {'W': 1, 'V - W': 2}
self.sess_mock['variables_of_interest'] = list(
variable_of_interest_indexes.keys())
self.sess_mock['period'] = '0.75'
self.sess_mock['region_mapping'] = region_mapping.gid
self.sess_mock['projection'] = seeg_projections.gid
self.sess_mock['sigma'] = "1.0"
self.sess_mock['sensors'] = seeg_sensors.gid
self.session_stored_simulator.monitors = [iEEG()]
with patch('cherrypy.session', self.sess_mock, create=True):
common.add2session(common.KEY_SIMULATOR_CONFIG,
self.session_stored_simulator)
common.add2session(common.KEY_BURST_CONFIG,
BurstConfiguration(self.test_project.id))
self.simulator_controller.set_monitor_params(
'iEEG', **self.sess_mock._data)
assert self.session_stored_simulator.monitors[
0].period == 0.75, "Period was not set correctly."
assert list(self.session_stored_simulator.monitors[0].variables_of_interest) == \
list(variable_of_interest_indexes.values()), "Variables of interest were not set correctly."
assert self.session_stored_simulator.monitors[0].region_mapping.gid.hex == region_mapping.gid, \
"Region Mapping wasn't set and stored correctly."
assert self.session_stored_simulator.monitors[0].sensors.gid.hex == seeg_sensors.gid, \
"Region Mapping wasn't set and stored correctly."
assert self.session_stored_simulator.monitors[0].projection.gid is not None, \
"Projection wasn't stored correctly."
def test_get_selected_burst(self):
"""
Create burst, add it to session, then check that get_selected_burst
return the same burst. Also check that for an unstored entity we get
back 'None'
"""
burst_entity = BurstConfiguration(self.test_project.id, 'started', {}, 'burst1')
cherrypy.session[b_c.KEY_BURST_CONFIG] = burst_entity
stored_id = self.burst_c.get_selected_burst()
self.assertEqual(stored_id, 'None')
burst_entity = dao.store_entity(burst_entity)
cherrypy.session[b_c.KEY_BURST_CONFIG] = burst_entity
stored_id = self.burst_c.get_selected_burst()
self.assertEqual(str(stored_id), str(burst_entity.id))
