Source code for tvb.interfaces.web.entities.context_model_parameters

# -*- coding: utf-8 -*-
# TheVirtualBrain-Framework Package. This package holds all Data Management, and 
# Web-UI helpful to run brain-simulations. To use it, you also need to download
# TheVirtualBrain-Scientific Package (for simulators). See content of the
# documentation-folder for more details. See also
# (c) 2012-2023, Baycrest Centre for Geriatric Care ("Baycrest") and others
# This program is free software: you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the Free Software Foundation,
# either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.  See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License along with this
# program.  If not, see <>.
# When using The Virtual Brain for scientific publications, please cite it as explained here:

.. moduleauthor:: Ionel Ortelecan <>

from copy import deepcopy

from tvb.adapters.forms.surface_model_parameters_form import SurfaceModelParametersForm
from tvb.basic.logger.builder import get_logger
from tvb.core.neocom import h5
from tvb.core.neotraits.spatial_model import SpatialModel
from tvb.datatypes.surfaces import CorticalSurface

KEY_EQUATION = "equation"
KEY_FOCAL_POINTS = "focal_points"
KEY_FOCAL_POINTS_TRIANGLES = "focal_points_triangles"

[docs] class SurfaceContextModelParameters(SpatialModel): """ This class contains methods which allows you to edit the model parameters for each vertex of the given surface. """ def __init__(self, surface_index, default_model, current_equation, current_model_param): self.logger = get_logger(self.__class__.__module__) self.default_model = default_model self.surface_index = surface_index self.applied_equations = {} self.current_equation = current_equation self.current_model_param = current_model_param
[docs] def apply_equation(self, param_name, equation_instance): """ Applies an equation on the given model parameter. """ if param_name in self.applied_equations: param_data = self.applied_equations[param_name] param_data[KEY_EQUATION] = equation_instance else: self.applied_equations[param_name] = {KEY_EQUATION: equation_instance, KEY_FOCAL_POINTS: [], KEY_FOCAL_POINTS_TRIANGLES: []}
[docs] def apply_focal_point(self, model_param, triangle_index): """ NOTE: Expects a triangle index Adds a focal point in which should be applied the equation for the given model parameter. """ triangle_index = int(triangle_index) surface_h5 = h5.h5_file_for_index(self.surface_index) if model_param in self.applied_equations: if triangle_index >= 0: vertex_index = int(surface_h5.triangles[triangle_index][0]) model_equation = self.applied_equations[model_param] if vertex_index not in model_equation[KEY_FOCAL_POINTS]: model_equation[KEY_FOCAL_POINTS].append(vertex_index) model_equation[KEY_FOCAL_POINTS_TRIANGLES].append(triangle_index) surface_h5.close()
[docs] def remove_focal_point(self, model_param, triangle_index): """ NOTE: Expects a vertex index Removes a focal point from the list of focal points in which should be applied the equation for the given model parameter. """ triangle_index = int(triangle_index) if model_param in self.applied_equations: if triangle_index >= 0: model_equation = self.applied_equations[model_param] if triangle_index in model_equation[KEY_FOCAL_POINTS_TRIANGLES]: f_p_idx = model_equation[KEY_FOCAL_POINTS_TRIANGLES].index(triangle_index) model_equation[KEY_FOCAL_POINTS].remove(model_equation[KEY_FOCAL_POINTS][f_p_idx]) model_equation[KEY_FOCAL_POINTS_TRIANGLES].remove(triangle_index)
[docs] def reset_equations_for_all_parameters(self): """ Reset the equations for all the model parameters. """ self.applied_equations = {}
[docs] def reset_param_equation(self, model_param): """ Resets the equation for the specified model parameter. """ if model_param in self.applied_equations: self.applied_equations.pop(model_param)
[docs] def get_equation_for_parameter(self, parameter_name): """ :returns: the applied equation for the given model param OR None if there is no equation applied to this param. """ try: return self.applied_equations[parameter_name][KEY_EQUATION] except KeyError: return None
[docs] def get_focal_points_for_parameter(self, parameter_name): """ :returns: the list of focal points for the equation applied in the given model param. """ if parameter_name in self.applied_equations and KEY_FOCAL_POINTS in self.applied_equations[parameter_name]: return self.applied_equations[parameter_name][KEY_FOCAL_POINTS_TRIANGLES] return []
def _get_default_value_for_model_param(self, param_name): default_attr = deepcopy(getattr(type(self.default_model), param_name)) return default_attr.default
[docs] def get_data_for_model_param(self, param_name): """ Compute the equation configured for the current param_name. If no equation was set for param_name, return the default array. """ surface_dt = CorticalSurface() surface_h5 = h5.h5_file_for_index(self.surface_index) surface_h5.load_into(surface_dt) surface_h5.close() if param_name in self.applied_equations: temp = self.applied_equations[param_name] equation = temp[KEY_EQUATION] focal_points = temp[KEY_FOCAL_POINTS] # if focal points or the equation are missing do not update this model parameter if focal_points and equation: res = surface_dt.compute_equation(focal_points, equation) return res self.logger.warning('Focal points or Equation are missing for %s. Defaults will be used.', param_name) return self._get_default_value_for_model_param(param_name) else: return self._get_default_value_for_model_param(param_name)
[docs] def get_configure_info(self): """ :returns: a dictionary which contains information about the applied equations on the model parameters. """ result = {} for param in self.applied_equations: equation = self.applied_equations[param][KEY_EQUATION] keys = sorted(list(equation.parameters), key=lambda x: len(x)) keys.reverse() base_equation = equation.equation for eq_param in keys: while True: stripped_eq = "".join(base_equation.split()) param_idx = stripped_eq.find('\\' + eq_param) if param_idx < 0: break # If parameter is precedeed by an alfanumerical character replace with multiplicative sign if param_idx > 0 and stripped_eq[param_idx - 1].isalnum(): base_equation = base_equation.replace('\\' + eq_param, '*' + str(equation.parameters[eq_param])) else: base_equation = base_equation.replace('\\' + eq_param, str(equation.parameters[eq_param])) base_equation = base_equation.replace(eq_param, str(equation.parameters[eq_param])) focal_points = str(self.applied_equations[param][KEY_FOCAL_POINTS]) result[param] = {'equation_name': equation.__class__.__name__, 'equation_params': base_equation, 'focal_points': focal_points} return result
[docs] @staticmethod def get_equation_information(): return { SurfaceModelParametersForm.equation_field_label: 'current_equation' }