def edit_noise_parameters(self):
"""
Main method, to initialize Model-Parameter visual-set.
"""
model, integrator, connectivity, _ = self.get_data_from_burst_configuration(
)
connectivity_viewer_params = self.get_connectivity_parameters(
connectivity)
context_noise_config = ContextNoiseParameters(connectivity, model,
integrator)
param_names, param_data = self.get_data_for_param_sliders(
'0', context_noise_config)
base.add2session(KEY_CONTEXT_NC, context_noise_config)
template_specification = dict(title="Simulation - Noise configuration")
template_specification[
'submit_parameters_url'] = '/spatial/noiseconfiguration/submit_noise_configuration'
template_specification['parametersNames'] = param_names
template_specification['paramSlidersData'] = param_data
template_specification['isSingleMode'] = True
template_specification.update(connectivity_viewer_params)
template_specification[
'mainContent'] = 'spatial/noise_configuration_main'
template_specification['displayDefaultSubmitBtn'] = True
return self.fill_default_attributes(template_specification)
def submit_model_parameters(self):
"""
Collects the model parameters values from all the models used for the surface vertices.
"""
context_model_parameters = base.get_from_session(KEY_CONTEXT_MPS)
burst_configuration = base.get_from_session(base.KEY_BURST_CONFIG)
for original_param, modified_param in context_model_parameters.prepared_model_parameter_names.items(
):
full_name = PARAMS_MODEL_PATTERN % (
context_model_parameters.model_name, original_param)
param_data = context_model_parameters.get_data_for_model_param(
original_param, modified_param)
if isinstance(param_data, dict):
equation = param_data[KEY_EQUATION]
param_data[KEY_EQUATION] = equation.to_json(equation)
param_data[KEY_FOCAL_POINTS] = json.dumps(
param_data[KEY_FOCAL_POINTS])
param_data = json.dumps(param_data)
burst_configuration.update_simulation_parameter(
full_name, param_data)
### Clean from session drawing context
base.remove_from_session(KEY_CONTEXT_MPS)
### Update in session BURST configuration for burst-page.
base.add2session(base.KEY_BURST_CONFIG, burst_configuration.clone())
raise cherrypy.HTTPRedirect("/burst/")
def reset_burst(self):
"""
Called when click on "New Burst" entry happens from UI.
This will generate an empty new Burst Configuration.
"""
new_burst = self.burst_service.new_burst_configuration(base.get_current_project().id)
base.add2session(base.KEY_BURST_CONFIG, new_burst)
def index(self, **data):
"""
Login page (with or without messages).
"""
template_specification = dict(mainContent="login",
title="Login",
data=data)
if cherrypy.request.method == 'POST':
form = LoginForm()
try:
data = form.to_python(data)
username = data[KEY_USERNAME]
password = data[KEY_PASSWORD]
user = self.user_service.check_login(username, password)
if user is not None:
basecontroller.add2session(basecontroller.KEY_USER, user)
basecontroller.set_info_message('Welcome ' + username)
self.logger.debug("User " + username +
" has just logged in!")
if user.selected_project is not None:
prj = user.selected_project
prj = ProjectService().find_project(prj)
self._mark_selected(prj)
raise cherrypy.HTTPRedirect('/user/profile')
else:
basecontroller.set_error_message(
'Wrong username/password, or user not yet validated...'
)
self.logger.debug("Wrong username " + username + " !!!")
except formencode.Invalid, excep:
template_specification[
basecontroller.KEY_ERRORS] = excep.unpack_errors()
def edit_model_parameters(self):
"""
Main method, to initialize Model-Parameter visual-set.
"""
model, integrator, connectivity, _ = self.get_data_from_burst_configuration(
)
connectivity_viewer_params = self.get_connectivity_parameters(
connectivity)
context_model_parameters = ContextModelParameters(
connectivity, model, integrator)
data_for_param_sliders = self.get_data_for_param_sliders(
'0', context_model_parameters)
base.add2session(KEY_CONTEXT_MPR, context_model_parameters)
template_specification = dict(
title="Spatio temporal - Model parameters")
template_specification[
'submit_parameters_url'] = '/spatial/modelparameters/regions/submit_model_parameters'
template_specification[
'parametersNames'] = context_model_parameters.model_parameter_names
template_specification['isSingleMode'] = True
template_specification['paramSlidersData'] = json.dumps(
data_for_param_sliders)
template_specification.update(connectivity_viewer_params)
template_specification[
'mainContent'] = 'spatial/model_param_region_main'
template_specification['displayDefaultSubmitBtn'] = True
template_specification.update(
context_model_parameters.phase_plane_params)
return self.fill_default_attributes(template_specification)
def settings(self, save_settings=False, **data):
"""Main settings page submit and get"""
template_specification = dict(
mainContent="../settings/system_settings", title="System Settings")
if save_settings:
try:
form = SettingsForm()
data = form.to_python(data)
isrestart, isreset = self.settingsservice.save_settings(**data)
if isrestart:
thread = threading.Thread(target=self._restart_services,
kwargs={'should_reset': isreset})
thread.start()
bc.add2session(bc.KEY_IS_RESTART, True)
bc.set_info_message(
'Please wait until TVB is restarted properly!')
raise cherrypy.HTTPRedirect('/tvb')
# Here we will leave the same settings page to be displayed.
# It will continue reloading when CherryPy restarts.
except formencode.Invalid, excep:
template_specification[bc.KEY_ERRORS] = excep.unpack_errors()
except InvalidSettingsException, excep:
self.logger.error(
'Invalid settings! Exception %s was raised' %
(str(excep)))
bc.set_error_message(excep.message)
def save_parameters(self, index_in_tab, **data):
"""
Save parameters
:param tab_nr: the index of the selected tab
:param index_in_tab: the index of the configured portlet in the selected tab
:param data: the {name:value} dictionary configuration of the current portlet
Having these inputs, update the configuration of the portletin the
corresponding tab position form the burst configuration .
"""
burst_config = base.get_from_session(base.KEY_BURST_CONFIG)
tab_nr = burst_config.selected_tab
old_portlet_config = burst_config.tabs[int(tab_nr)].portlets[int(
index_in_tab)]
# Replace all void entries with 'None'
for entry in data:
if data[entry] == '':
data[entry] = None
need_relaunch = self.burst_service.update_portlet_configuration(
old_portlet_config, data)
if need_relaunch:
#### Reset Burst Configuration into an entity not persisted (id = None for all)
base.add2session(base.KEY_BURST_CONFIG, burst_config.clone())
return "relaunchView"
else:
self.workflow_service.store_workflow_step(
old_portlet_config.visualizer)
return "noRelaunch"
def add_adapter_to_session(self,
algo_group,
input_tree,
default_data=None):
"""
Put in session information about currently selected adapter.
Will be used by filters and efficiency load.
"""
previous_algo = self.get_current_substep()
current_algo = algo_group.id if algo_group is not None else (
default_data[base.KEY_ADAPTER]
if default_data is not None else None)
if current_algo is None or str(current_algo) != str(previous_algo):
self.clean_from_session()
adapter_info = {}
else:
adapter_info = base.get_from_session(self.KEY_CURRENT_ADAPTER_INFO)
if default_data is not None:
adapter_info[self._KEY_SELECTED_DATA] = default_data
if input_tree is not None:
adapter_info[self._KEY_INPUT_TREE] = input_tree
if algo_group is not None:
adapter_info[self._KEY_CURRENT_STEP] = algo_group.fk_category
adapter_info[self._KEY_CURRENT_SUBSTEP] = algo_group.id
base.add2session(self.KEY_CURRENT_ADAPTER_INFO, adapter_info)
def edit_model_parameters(self):
"""
Main method, to initialize Model-Parameter visual-set.
"""
model, integrator, connectivity, surface = self.get_data_from_burst_configuration(
)
context_model_parameters = SurfaceContextModelParameters(
surface, connectivity, model, integrator)
base.add2session(KEY_CONTEXT_MPS, context_model_parameters)
template_specification = dict(
title="Spatio temporal - Model parameters")
template_specification.update(self.display_surface(surface.gid))
model_params_data = self.get_surface_model_parameters_data()
model_params_data = self._add_entra_equation_entries(model_params_data)
template_specification.update(model_params_data)
template_specification[
'submit_parameters_url'] = '/spatial/modelparameters/surface/submit_model_parameters'
template_specification[
'mainContent'] = 'spatial/model_param_surface_main'
template_specification[
'equationViewerUrl'] = '/spatial/modelparameters/surface/get_equation_chart'
template_specification['equationsPrefixes'] = json.dumps(
self.plotted_equations_prefixes)
template_specification['submitSurfaceParametersBtn'] = True
return self.fill_default_attributes(template_specification)
def copy_configuration(self, from_node, to_nodes):
from_node = int(from_node)
to_nodes = json.loads(to_nodes)
if from_node < 0 or not len(to_nodes):
return
context_model_parameters = base.get_from_session(KEY_CONTEXT_NC)
context_model_parameters.set_noise_connectivity_nodes(
from_node, to_nodes)
base.add2session(KEY_CONTEXT_NC, context_model_parameters)
def copy_burst(self, burst_id):
"""
When currently selected entry is a valid Burst, create a clone of that Burst.
"""
base_burst = self.burst_service.load_burst(burst_id)[0]
if (base_burst is None) or (base_burst.id is None):
return self.reset_burst()
base.add2session(base.KEY_BURST_CONFIG, base_burst.clone())
return base_burst.name
def index(self):
"""Get on burst main page"""
template_specification = dict(
mainContent="burst/main_burst",
title="Simulation Cockpit",
baseUrl=cfg.BASE_URL,
includedResources='project/included_resources')
portlets_list = self.burst_service.get_available_portlets()
session_stored_burst = base.get_from_session(base.KEY_BURST_CONFIG)
if session_stored_burst is None or session_stored_burst.id is None:
if session_stored_burst is None:
session_stored_burst = self.burst_service.new_burst_configuration(
base.get_current_project().id)
base.add2session(base.KEY_BURST_CONFIG, session_stored_burst)
adapter_interface = self.cached_simulator_input_tree
if session_stored_burst is not None:
current_data = session_stored_burst.get_all_simulator_values(
)[0]
adapter_interface = ABCAdapter.fill_defaults(
adapter_interface, current_data, True)
### Add simulator tree to session to be available in filters
self.context.add_adapter_to_session(
self.cached_simulator_algo_group, adapter_interface,
current_data)
template_specification['inputList'] = adapter_interface
selected_portlets = session_stored_burst.update_selected_portlets()
template_specification[
'burst_list'] = self.burst_service.get_available_bursts(
base.get_current_project().id)
template_specification['portletList'] = portlets_list
template_specification['selectedPortlets'] = json.dumps(
selected_portlets)
template_specification['draw_hidden_ranges'] = True
template_specification['burstConfig'] = session_stored_burst
### Prepare PSE available metrics
### We put here all available algorithms, because the metrics select area is a generic one,
### and not loaded with every Burst Group change in history.
algo_group = self.flow_service.get_algorithm_by_module_and_class(
MEASURE_METRICS_MODULE, MEASURE_METRICS_CLASS)[1]
adapter_instance = ABCAdapter.build_adapter(algo_group)
if adapter_instance is not None and hasattr(adapter_instance,
'available_algorithms'):
template_specification['available_metrics'] = [
metric_name for metric_name in
adapter_instance.available_algorithms.keys()
]
else:
template_specification['available_metrics'] = []
template_specification[base.KEY_PARAMETERS_CONFIG] = False
template_specification[base.KEY_SECTION] = 'burst'
return self.fill_default_attributes(template_specification)
def load_local_connectivity(self, local_connectivity_gid, from_step=None):
"""
Loads the interface for an existing local connectivity.
"""
context = base.get_from_session(KEY_LCONN_CONTEXT)
context.selected_entity = local_connectivity_gid
base.add2session(
base.KEY_MESSAGE, "Successfully loaded existent entity gid=%s" %
(local_connectivity_gid, ))
if int(from_step) == 1:
return self.step_1()
if int(from_step) == 2:
return self.step_2()
def step_1_submit(self, next_step, do_reset=0, **kwargs):
"""
Any submit from the first step should be handled here. Update the context then
go to the next step as required. In case a reset is needed create a clear context.
"""
if int(do_reset) == 1:
new_context = SurfaceStimulusContext()
base.add2session(KEY_SURFACE_CONTEXT, new_context)
context = base.get_from_session(KEY_SURFACE_CONTEXT)
if kwargs.get(SURFACE_PARAMETER) != context.get_session_surface():
context.set_focal_points('[]')
context.update_eq_kwargs(kwargs)
return self.do_step(next_step)
def step_1_submit(self, next_step, do_reset=0, **kwargs):
"""
Any submit from the first step should be handled here. Update the context then
go to the next step as required. In case a reset is needed create a clear context.
"""
if int(do_reset) == 1:
new_context = RegionStimulusContext()
base.add2session(KEY_REGION_CONTEXT, new_context)
context = base.get_from_session(KEY_REGION_CONTEXT)
if kwargs.get(
CONNECTIVITY_PARAMETER) != context.get_session_connectivity():
context.set_weights([])
context.equation_kwargs = kwargs
return self.do_step(next_step)
def copy_model(self, from_node, to_nodes):
"""
Replace the model of the nodes 'to_nodes' with the model of the node 'from_node'.
``from_node``: the index of the node from where will be copied the model
``to_nodes``: a list with the nodes indexes for which will be replaced the model
"""
from_node = int(from_node)
to_nodes = json.loads(to_nodes)
if from_node < 0 or not len(to_nodes):
return
context_model_parameters = base.get_from_session(KEY_CONTEXT_MPR)
context_model_parameters.set_model_for_connectivity_nodes(from_node, to_nodes)
base.add2session(KEY_CONTEXT_MPR, context_model_parameters)
def submit_model_parameters(self):
"""
Collects the model parameters values from all the models used for the connectivity nodes.
"""
context_model_parameters = base.get_from_session(KEY_CONTEXT_MPR)
burst_configuration = base.get_from_session(base.KEY_BURST_CONFIG)
for param_name in context_model_parameters.model_parameter_names:
full_name = PARAMS_MODEL_PATTERN % (context_model_parameters.model_name, param_name)
full_values = context_model_parameters.get_values_for_parameter(param_name)
burst_configuration.update_simulation_parameter(full_name, full_values)
### Clean from session drawing context
base.remove_from_session(KEY_CONTEXT_MPR)
### Update in session BURST configuration for burst-page.
base.add2session(base.KEY_BURST_CONFIG, burst_configuration.clone())
raise cherrypy.HTTPRedirect("/burst/")
def cached_simulator_input_tree(self):
"""
Cache Simulator's input tree, for performance issues.
Anyway, without restart, the introspected tree will not be different on multiple executions.
:returns: Simulator's Input Tree (copy from cache or just loaded)
"""
cached_simulator_tree = base.get_from_session(
base.KEY_CACHED_SIMULATOR_TREE)
if cached_simulator_tree is None:
cached_simulator_tree = self.flow_service.prepare_adapter(
base.get_current_project().id,
self.cached_simulator_algo_group)[1]
base.add2session(base.KEY_CACHED_SIMULATOR_TREE,
cached_simulator_tree)
return copy.deepcopy(cached_simulator_tree)
def reload_burst_operation(self, operation_id, is_group, **_):
"""
Find out from which burst was this operation launched. Set that burst as the selected one and
redirect to the burst page.
"""
is_group = int(is_group)
if not is_group:
operation = self.flow_service.load_operation(int(operation_id))
else:
op_group = ProjectService.get_operation_group_by_id(operation_id)
first_op = ProjectService.get_operations_in_group(op_group)[0]
operation = self.flow_service.load_operation(int(first_op.id))
operation.burst.prepare_after_load()
base.add2session(base.KEY_BURST_CONFIG, operation.burst)
raise cherrypy.HTTPRedirect("/burst/")
def get_visualizers_for_operation_id(self, op_id, width, height):
"""
Method called from parameters exploration page in case a burst with a range of parameters
for the simulator was launched.
:param op_id: the selected operation id from the parameter space exploration.
:param width: the width of the right side display
:param height: the height of the right side display
Given these parameters first get the workflow to which op_id belongs, then load the portlets
from that workflow as the current burst configuration. Width and height are used to get the
proper sizes for the visualization iFrames.
"""
burst_config = base.get_from_session(base.KEY_BURST_CONFIG)
burst_config = self.burst_service.load_tab_configuration(burst_config, op_id)
base.add2session(base.KEY_BURST_CONFIG, burst_config)
return self.load_configured_visualizers(width, height)
def __get_operations_filters(self):
"""
Filters for VIEW_ALL_OPERATIONS page.
Get from session currently selected filters, or build a new set of filters.
"""
session_filtes = bc.get_from_session(self.KEY_OPERATION_FILTERS)
if session_filtes:
return session_filtes
else:
sim_group = self.flow_service.get_algorithm_by_module_and_class(
SIMULATOR_MODULE, SIMULATOR_CLASS)[1]
new_filters = StaticFiltersFactory.build_operations_filters(
sim_group,
bc.get_logged_user().id)
bc.add2session(self.KEY_OPERATION_FILTERS, new_filters)
return new_filters
def update_model_parameter_for_nodes(self, param_name, new_param_value, connectivity_node_indexes):
"""
Updates the specified model parameter for the first node from the 'connectivity_node_indexes'
list and after that replace the model of each node from the 'connectivity_node_indexes' list
with the model of the first node from the list.
"""
connectivity_node_indexes = json.loads(connectivity_node_indexes)
if not len(connectivity_node_indexes):
return
context_model_parameters = base.get_from_session(KEY_CONTEXT_MPR)
first_node_index = connectivity_node_indexes[0]
context_model_parameters.update_model_parameter(first_node_index, param_name, new_param_value)
if len(connectivity_node_indexes) > 1:
#eliminate the first node
connectivity_node_indexes = connectivity_node_indexes[1: len(connectivity_node_indexes)]
context_model_parameters.set_model_for_connectivity_nodes(first_node_index, connectivity_node_indexes)
base.add2session(KEY_CONTEXT_MPR, context_model_parameters)
def submit_noise_configuration(self):
"""
Collects the model parameters values from all the models used for the connectivity nodes.
"""
context_noise_config = base.get_from_session(KEY_CONTEXT_NC)
burst_configuration = base.get_from_session(base.KEY_BURST_CONFIG)
_, simulator_group = FlowService().get_algorithm_by_module_and_class(
SIMULATOR_MODULE, SIMULATOR_CLASS)
simulator_adapter = ABCAdapter.build_adapter(simulator_group)
for param_name in simulator_adapter.noise_configurable_parameters():
burst_configuration.update_simulation_parameter(
param_name, str(context_noise_config.noise_values))
### Clean from session drawing context
base.remove_from_session(KEY_CONTEXT_NC)
### Update in session BURST configuration for burst-page.
base.add2session(base.KEY_BURST_CONFIG, burst_configuration.clone())
raise cherrypy.HTTPRedirect("/burst/")
def reset_model_parameters_for_nodes(self, connectivity_node_indexes):
"""
Resets the model parameters, of the specified connectivity nodes, to their default values.
"""
connectivity_node_indexes = json.loads(connectivity_node_indexes)
if not len(connectivity_node_indexes):
return
context_model_parameters = base.get_from_session(KEY_CONTEXT_MPR)
context_model_parameters.reset_model_parameters_for_nodes(connectivity_node_indexes)
context_model_parameters.load_model_for_connectivity_node(connectivity_node_indexes[0])
data_for_param_sliders = self.get_data_for_param_sliders(connectivity_node_indexes[0], context_model_parameters)
base.add2session(KEY_CONTEXT_MPR, context_model_parameters)
template_specification = dict()
template_specification['paramSlidersData'] = json.dumps(data_for_param_sliders)
template_specification['parametersNames'] = data_for_param_sliders['all_param_names']
return template_specification
def load_burst(self, burst_id):
"""
Given a clicked burst from the history and the selected tab, load all
the required data from that burst. Return a value specifying if it was a result
of a range launch (OperationGroup) or not.
"""
try:
old_burst = base.get_from_session(base.KEY_BURST_CONFIG)
burst, group_gid = self.burst_service.load_burst(burst_id)
burst.selected_tab = old_burst.selected_tab
base.add2session(base.KEY_BURST_CONFIG, burst)
return {'status': burst.status, 'group_gid': group_gid, 'selected_tab': burst.selected_tab}
except Exception, excep:
### Most probably Burst was removed. Delete it from session, so that client
### has a good chance to get a good response on refresh
self.logger.error(excep)
base.remove_from_session(base.KEY_BURST_CONFIG)
raise excep
def apply_equation(self, **kwargs):
"""
Applies an equations for computing a model parameter.
"""
submitted_data = ABCAdapter.collapse_arrays(kwargs, ['model_param'])
model_param, equation = self._compute_equation(submitted_data)
context_model_parameters = base.get_from_session(KEY_CONTEXT_MPS)
context_model_parameters.apply_equation(model_param, equation)
base.add2session(KEY_CONTEXT_MPS, context_model_parameters)
template_specification = self.get_surface_model_parameters_data(
model_param)
template_specification = self._add_entra_equation_entries(
template_specification, kwargs['min_x'], kwargs['max_x'])
template_specification[
'equationViewerUrl'] = '/spatial/modelparameters/surface/get_equation_chart'
template_specification['equationsPrefixes'] = json.dumps(
self.plotted_equations_prefixes)
return self.fill_default_attributes(template_specification)
def display_surface(surface_gid):
"""
Generates the HTML for displaying the surface with the given ID.
"""
surface = ABCAdapter.load_entity_by_gid(surface_gid)
base.add2session(PARAM_SURFACE, surface_gid)
url_vertices_pick, url_normals_pick, url_triangles_pick = surface.get_urls_for_pick_rendering()
url_vertices, url_normals, url_triangles, alphas, alphas_indices = surface.get_urls_for_rendering(True, None)
template_specification = dict()
template_specification['urlVerticesPick'] = json.dumps(url_vertices_pick)
template_specification['urlTrianglesPick'] = json.dumps(url_triangles_pick)
template_specification['urlNormalsPick'] = json.dumps(url_normals_pick)
template_specification['urlVertices'] = json.dumps(url_vertices)
template_specification['urlTriangles'] = json.dumps(url_triangles)
template_specification['urlNormals'] = json.dumps(url_normals)
template_specification['alphas'] = json.dumps(alphas)
template_specification['alphas_indices'] = json.dumps(alphas_indices)
template_specification['brainCenter'] = json.dumps(surface.center())
return template_specification
def profile(self, logout=False, save=False, **data):
"""
Display current user's profile page.
On POST: logout, or save password/email.
"""
if cherrypy.request.method == 'POST' and logout:
raise cherrypy.HTTPRedirect('/user/logout')
template_specification = dict(mainContent="profile",
title="User Profile")
if cherrypy.request.method == 'POST' and save:
try:
form = EditUserForm()
data = form.to_python(data)
user = basecontroller.get_logged_user()
if KEY_PASSWORD in data and data[KEY_PASSWORD]:
user.password = md5(data[KEY_PASSWORD]).hexdigest()
if KEY_EMAIL in data and data[KEY_EMAIL]:
user.email = data[KEY_EMAIL]
old_password = None
if 'old_password' in data and data['old_password']:
old_password = md5(data['old_password']).hexdigest()
self.user_service.edit_user(user, old_password)
if old_password:
basecontroller.set_info_message("Changes Submitted!")
else:
basecontroller.set_info_message(
"Submitted! No password changed.")
except formencode.Invalid, excep:
template_specification[
basecontroller.KEY_ERRORS] = excep.unpack_errors()
except UsernameException, excep:
self.logger.exception(excep)
user = basecontroller.get_logged_user()
basecontroller.add2session(
basecontroller.KEY_USER,
self.user_service.get_user_by_id(user.id))
basecontroller.set_error_message(
"Could not save changes. Probably wrong old password!!")
def step_1(self, do_reset=0, **kwargs):
"""
Generate the html for the first step of the local connectivity page.
:param kwargs: not actually used, but parameters are still submitted from UI since we just
use the same js function for this. TODO: do this in a smarter way
"""
if int(do_reset) == 1:
new_context = ContextLocalConnectivity()
base.add2session(KEY_LCONN_CONTEXT, new_context)
context = base.get_from_session(KEY_LCONN_CONTEXT)
right_side_interface = self._get_lconn_interface()
left_side_interface = self.get_select_existent_entities(
'Load Local Connectivity', LocalConnectivity,
context.selected_entity)
#add interface to session, needed for filters
self.add_interface_to_session(left_side_interface,
right_side_interface['inputList'])
template_specification = dict(title="Surface - Local Connectivity")
template_specification[
'mainContent'] = 'spatial/local_connectivity_step1_main'
template_specification.update(right_side_interface)
template_specification['displayCreateLocalConnectivityBtn'] = True
template_specification['loadExistentEntityUrl'] = LOAD_EXISTING_URL
template_specification['resetToDefaultUrl'] = RELOAD_DEFAULT_PAGE_URL
template_specification[
'existentEntitiesInputList'] = left_side_interface
template_specification[
'submit_parameters_url'] = '/spatial/localconnectivity/create_local_connectivity'
template_specification[
'equationViewerUrl'] = '/spatial/localconnectivity/get_equation_chart'
template_specification['equationsPrefixes'] = json.dumps(
self.plotted_equations_prefixes)
template_specification[
'next_step_url'] = '/spatial/localconnectivity/step_2'
template_specification['displayedMessage'] = base.get_from_session(
base.KEY_MESSAGE)
return self.fill_default_attributes(template_specification)
def view_stimulus(self, focal_points):
"""
Just create the stimulus to view the actual data, don't store to db.
Hold the entity in session without the surface, so the next time you need
data just get from that one.
"""
try:
context = base.get_from_session(KEY_SURFACE_CONTEXT)
context.set_focal_points(focal_points)
kwargs = copy.deepcopy(context.equation_kwargs)
surface_stimulus_creator = self.get_creator_and_interface(SURFACE_STIMULUS_CREATOR_MODULE,
SURFACE_STIMULUS_CREATOR_CLASS, StimuliSurface())[0]
min_time = float(kwargs.get('min_tmp_x', 0))
max_time = float(kwargs.get('max_tmp_x', 100))
kwargs = surface_stimulus_creator.prepare_ui_inputs(kwargs)
stimulus = surface_stimulus_creator.launch(**kwargs)
surface_gid = base.get_from_session(PARAM_SURFACE)
surface = ABCAdapter.load_entity_by_gid(surface_gid)
stimulus.surface = surface
stimulus.configure_space()
time = numpy.arange(min_time, max_time, 1)
time = time[numpy.newaxis, :]
stimulus.configure_time(time)
data = []
max_value = numpy.max(stimulus())
for i in range(min(CHUNK_SIZE, stimulus.temporal_pattern.shape[1])):
step_data = stimulus(i).tolist()
data.append(step_data)
stimulus.surface = surface.gid
base.add2session(KEY_STIMULUS, stimulus)
result = {'status': 'ok', 'max': max_value, 'data': data, "time_min": min_time, "time_max": max_time,
"chunk_size": CHUNK_SIZE}
return result
except (NameError, ValueError, SyntaxError), ex:
return {'status': 'error',
'errorMsg': "Could not generate stimulus data. Some of the parameters hold invalid characters."}
