CellMLToNektar.translators.ConfigurationStore Class Reference

Inheritance diagram for CellMLToNektar.translators.ConfigurationStore:

Public Member Functions
def	__init__ (self, doc, options=None)
def	read_configuration_file (self, config_file)
def	finalize_config (self)
def	find_current_vars (self)
def	annotate_currents_for_pe (self)
def	expose_variables (self)
def	annotate_metadata_for_pe (self)
def	find_transmembrane_potential (self)
def	find_membrane_capacitance (self)
def	find_lookup_variables (self)
def	validate_metadata (self, assume_valid=False)

Public Attributes
	doc
	options
	unit_definitions
	V_definitions
	V_variable
	Cm_definitions
	Cm_variable
	lut_config
	i_stim_definitions
	i_stim_var
	i_ionic_definitions
	i_ionic_vars
	i_ionic_negated
	i_stim_negated
	dt_variable
	i_data_clamp_current
	i_data_clamp_conductance
	metadata_vars

Private Member Functions
def	_create_var_def (self, content, defn_type)
def	_check_var_def (self, var_elt, var_desc)
def	_parse_var (self, elt, name)
def	_parse_Vm (self, vm_elt)
def	_parse_Cm (self, cm_elt)
def	_parse_currents (self, currents)
def	_find_variable (self, defn, pe_done=False)
def	_process_ci_elts (self, elt, func, **kwargs)
def	_find_transmembrane_currents_from_voltage_ode (self)
def	_find_var (self, oxmeta_name, definitions)
def	_parse_lookup_tables (self, lookup_tables)
def	_set_lut_defaults (self, lut_dict)

Detailed Description

A container for configuration information, read in from XML
configuration files.  The file structure is described in the
read_configuration_file method.

Definition at line 1807 of file translators.py.

Constructor & Destructor Documentation

__init__()

def CellMLToNektar.translators.ConfigurationStore.__init__	(		self,
			doc,
			options = None
	)

Create a new store.

doc specifies a CellML document, the processing of which this configuration store will affect.

If given, options should be an optparse.Values instance containing command-line options.

Definition at line 1813 of file translators.py.

    def __init__(self, doc, options=None):
        """Create a new store.
 
        doc specifies a CellML document, the processing of which this configuration store will affect.
 
        If given, options should be an optparse.Values instance containing command-line options.
        """
        self.doc = doc
        doc._cml_config = self
        self.options = options
        self.unit_definitions = cellml_component.create_new(doc.model, '*lookup_table_units*')
        self.unit_definitions.xml_parent = doc.model # Needed for looking up standard units
        # Transmembrane potential
        self.V_definitions = [u'membrane,V']
        self.V_variable = None
        # Membrane capacitance
        self.Cm_definitions = []
        self.Cm_variable = None
        # Lookup table configuration
        self.lut_config = {}
        # Ionic currents configuration
        self.i_stim_definitions = [u'membrane,i_Stim']
        self.i_stim_var = None
        self.i_ionic_definitions = [u'membrane,i_.*']
        self.i_ionic_vars = []
        # Whether GetIIonic will need to negate the sum of i_ionic_vars
        self.i_ionic_negated = False
        # Whether the stimulus magnitude is positive, rather than negative
        self.i_stim_negated = False
        # Other variables that may be set by other code, for example an InterfaceGenerator
        self.dt_variable = None
        self.i_data_clamp_current = None
        self.i_data_clamp_conductance = None
        return
 

Member Function Documentation

_check_var_def()

def CellMLToNektar.translators.ConfigurationStore._check_var_def (   self,   var_elt,   var_desc  )

private

Check a variable definition is syntactically valid.

If type == 'name', it must have text content of the form "component_name,variable_name".
If type == 'oxmeta', it must have text content drawn from METADATA_NAMES.
If type == 'config-name', it must have text content either 'stimulus' or 'transmembrane_potential'.

Definition at line 1978 of file translators.py.

    def _check_var_def(self, var_elt, var_desc):
        """Check a variable definition is syntactically valid.
        
        If type == 'name', it must have text content of the form "component_name,variable_name".
        If type == 'oxmeta', it must have text content drawn from METADATA_NAMES.
        If type == 'config-name', it must have text content either 'stimulus' or 'transmembrane_potential'.
        """
        defn_type = getattr(var_elt, u'type', u'name')
        if defn_type == u'name':
            name_parts = unicode(var_elt).strip().split(',')
            if len(name_parts) != 2:
                raise ConfigurationError('Invalid definition of ' + var_desc + ': '
                                         + unicode(var_elt))
        elif defn_type == u'oxmeta':
            if unicode(var_elt) not in cellml_metadata.METADATA_NAMES:
                raise ConfigurationError('"' + unicode(var_elt) + '" is not a valid oxmeta name')
        elif defn_type == u'config-name':
            if unicode(var_elt) not in [u'stimulus', u'transmembrane_potential', u'membrane_capacitance']:
                raise ConfigurationError('"' + unicode(var_elt) + '" is not a name known to the config file')
        else:
            raise ConfigurationError('"' + defn_type + '" is not a valid variable definition type')
        return
 

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_var().

_create_var_def()

def CellMLToNektar.translators.ConfigurationStore._create_var_def (   self,   content,   defn_type  )

private

Create a variable definition object.

Definition at line 1973 of file translators.py.

    def _create_var_def(self, content, defn_type):
        """Create a variable definition object."""
        xml_fragment = '<var type="%s">%s</var>' % (defn_type, content)
        return amara.parse(str(xml_fragment)).var
 

Referenced by CellMLToNektar.translators.ConfigurationStore._find_var(), and CellMLToNektar.translators.ConfigurationStore.find_lookup_variables().

_find_transmembrane_currents_from_voltage_ode()

def CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode (   self )

private

Analyse the expression for dV/dt to determine the transmembrane currents.

Looks for an equation defining dV/d(something) and assumes the something is
time; this will be checked during code generation for Chaste.  It then finds
all variables on the RHS of this equation which have the same units as the
stimulus current (self.i_stim_var) and identifies these as transmembrane
currents.  Will automatically exclude the stimulus current.

If self.V_variable is not set, returns the empty list.

Definition at line 2074 of file translators.py.

    def _find_transmembrane_currents_from_voltage_ode(self):
        """Analyse the expression for dV/dt to determine the transmembrane currents.
        
        Looks for an equation defining dV/d(something) and assumes the something is
        time; this will be checked during code generation for Chaste.  It then finds
        all variables on the RHS of this equation which have the same units as the
        stimulus current (self.i_stim_var) and identifies these as transmembrane
        currents.  Will automatically exclude the stimulus current.
        
        If self.V_variable is not set, returns the empty list.
        """
        if not self.V_variable:
            DEBUG('config', "Transmembrane potential not configured, so can't determine currents from its ODE")
            return []
        if self.i_stim_var:
            current_units = [self.i_stim_var.component.get_units_by_name(self.i_stim_var.units)]
        else:
            from CellMLToNektarTranslator import CellMLToNektarTranslator
            current_units = CellMLToNektarTranslator.get_current_units_options(self.doc.model)
        ionic_vars = []
        
        def find_units_match(test_units, units_list, remove_match=False, keep_only_match=False):
            """Look for a units definition dimensionally equivalent to test_units within units_list.
            
            If remove_match is True, remove the first match from the list.
            If keep_only_match is True, remove all entries except the first match from the list.
            Return the matching units, or None if there are no matches.
            """
            for units in units_list:
                if test_units.dimensionally_equivalent(units):
                    match = units
                    break
            else:
                match = None
            if match and remove_match:
                units_list.remove(match)
            if match and keep_only_match:
                units_list[:] = [match]
            return match
 
        def clear_values(expr, process_definitions=False):
            """Recursively clear saved values for variables in this expression.
            
            If process_definitions is True, recursively treat expressions defining variables
            used in this expression, too.
            """
            def process_var(var):
                var.unset_values()
                var._unset_binding_time(only_temporary=True)
                if process_definitions:
                    defn = var.get_dependencies()
                    if defn:
                        if isinstance(defn[0], mathml_apply):
                            clear_values(defn[0].eq.rhs, process_definitions=True)
                        elif isinstance(defn[0], cellml_variable):
                            process_var(defn[0])
            def process_ci(ci_elt):
                process_var(ci_elt.variable)
            self._process_ci_elts(expr, process_ci)
        
        def check_if_current(ci_elt, vars_found):
            """Check if this is a transmembrane current."""
            v = ci_elt.variable
            if v.get_source_variable(recurse=True) is not self.i_stim_var:
                vars_found.append(v)
                # Check units
                u = v.component.get_units_by_name(v.units)
                if find_units_match(u, current_units, keep_only_match=True):
                    ionic_vars.append(v.get_source_variable(recurse=True))
                    ionic_vars[-1]._cml_ref_in_dvdt = ci_elt # Hack for data clamp support (#2708)
            # Fake this variable being 1 so we can check the sign of GetIIonic
            if not v.is_statically_const(ignore_annotations=True):
                v.set_value(1.0)
        
        def bfs(func, vars, *args, **kwargs):
            """Do a breadth first search of the definitions of variables in vars.
            
            func is the recursive function to call.  It will be given the list of defining expressions
            as its first argument, and args and kwargs as remaining arguments.
            """
            def get_defn(var):
                defn = var.get_dependencies()
                if defn:
                    var._set_binding_time(BINDING_TIMES.static, temporary=True)
                    if isinstance(defn[0], cellml_variable):
                        defn = get_defn(defn[0])
                    else:
                        assert isinstance(defn[0], mathml_apply)
                        var.unset_values()
                        defn = defn[0].eq.rhs
                return defn
            defns = []
            for var in vars:
                defn = get_defn(var)
                if defn:
                    defns.append(defn)
            if defns:
                func(defns, *args, **kwargs)
 
        def find_currents(exprs, depth=0, maxdepth=2):
            """Find ionic currents by searching the given expressions.
            
            On the initial call, exprs should contain just the definition of dV/dt (i.e. the RHS).
            
            Uses breadth-first search of the equation dependency tree to find variables that
            have units dimensionally equivalent to one of the current formulations that Chaste
            can handle, or equivalent to the stimulus current's units if one is defined.
            
            Initially, A_per_F is removed from the list, since the RHS of dV/dt should always
            have equivalent dimensions.  If another option can't be found within maxdepth levels,
            we restart the search with A_per_F included.  The depth limit is intended to guard against
            unexpectedly finding something that isn't a current; it's somewhat dodgy, but won't
            break on any model I know, and I haven't thought of a better approach yet.
            
            When one variable with suitable units is found, further ionic currents must have units
            equivalent to its to be found.  Also once one ionic current is found, only the remaining
            expressions at its depth will be processed.
            """
            if depth == 0 and maxdepth > 0:
                dvdt_units = exprs[0].xml_parent.eq.lhs.get_units()
                A_per_F = find_units_match(dvdt_units, current_units, remove_match=True)
#                 # We could do this check, but actually it doesn't catch much and later checks will pick up on the problem
#                 if A_per_F is None and not self.i_stim_var:
#                     raise ConfigurationError('Units ' + dvdt_units.description() + ' of dV/dt are not equivalent to V/s - unable to continue.')
            # Process all expressions at this depth
            vars_found = []
            for expr in exprs:
                self._process_ci_elts(expr, check_if_current, vars_found=vars_found)
            if not ionic_vars and depth != maxdepth:
                # Process the definitions of expressions at this depth
                bfs(find_currents, vars_found, depth+1, maxdepth)
            # If we reached maxdepth unsuccessfully, try again with A_per_F included (if it was an option)
            if not ionic_vars and depth == 0 and maxdepth > 0 and A_per_F:
                current_units.append(A_per_F)
                find_currents(exprs, depth, maxdepth=-1)
 
        def assign_values_for_stimulus_check(exprs, found_stim=Sentinel()):
            """Assign temporary values to variables in order to check the stimulus sign.
            
            This will process defining expressions in a breadth first search until the stimulus
            current is found.  Each variable that doesn't have its definitions processed will
            be given a value as follows:
             - stimulus current = 1
             - other currents = 0
             - other variables = 1
            The stimulus current is then negated from the sign expected by Chaste if evaluating
            dV/dt gives a positive value.
            """
            assert len(current_units) == 1 # We are using the stimulus units
            vars = []
            def f(ci_elt):
                v = ci_elt.variable
                if v.get_source_variable(recurse=True) is self.i_stim_var:
                    v.set_value(1.0)
                    found_stim.set()
                else:
                    u = v.component.get_units_by_name(v.units)
                    if u.dimensionally_equivalent(current_units[0]):
                        v.set_value(0.0)
                    elif not v.is_statically_const(ignore_annotations=True):
                        v.set_value(1.0)
                    vars.append(v)
            for expr in exprs:
                self._process_ci_elts(expr, f)
            if not found_stim:
                bfs(assign_values_for_stimulus_check, vars, found_stim=found_stim)
 
        # Iterate over all expressions in the model, to find the one for dV/d(something)
        for expr in (e for e in self.doc.model.get_assignments() if isinstance(e, mathml_apply) and e.is_ode()):
            # Assume the independent variable is time; if it isn't, we'll catch this later
            (dep_var, time_var) = expr.assigned_variable()
            if dep_var.get_source_variable(recurse=True) is self.V_variable:
                # Recursively search for ionic currents
                find_currents([expr.eq.rhs])
                if not ionic_vars:
                    # The sign checks below will be nonsense in this case. An error will be raised later.
                    break
                # Check the sign of the RHS
                self.i_ionic_negated = expr.eq.rhs.evaluate() > 0.0
                clear_values(expr.eq.rhs, process_definitions=True)
                if self.i_stim_var:
                    # Check the sign of the stimulus current
                    assign_values_for_stimulus_check([expr.eq.rhs])
                    self.i_stim_negated = expr.eq.rhs.evaluate() > 0.0
                    clear_values(expr.eq.rhs, process_definitions=True)
                # Found dV/d(something); don't check any more expressions
                break
        DEBUG('config', "Found ionic currents from dV/dt: ", ionic_vars)
        call_if(self.i_ionic_negated, DEBUG, 'config', "Ionic current is negated")
        call_if(self.i_stim_negated, DEBUG, 'config', "Stimulus current is negated")
        return ionic_vars
    

References CellMLToNektar.optimize.PartialEvaluator._process_ci_elts(), CellMLToNektar.translators.ConfigurationStore._process_ci_elts(), CellMLToNektar.utilities.call_if(), Nektar::UnitTests.d(), CellMLToNektar.utilities.DEBUG(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.ConfigurationStore.i_ionic_negated, CellMLToNektar.translators.ConfigurationStore.i_stim_negated, CellMLToNektar.translators.ConfigurationStore.i_stim_var, and CellMLToNektar.translators.ConfigurationStore.V_variable.

Referenced by CellMLToNektar.translators.ConfigurationStore.find_current_vars().

_find_var()

def CellMLToNektar.translators.ConfigurationStore._find_var (   self,   oxmeta_name,   definitions  )

private

Find the variable object in the model for a particular concept.

Will look for a variable annotated with the given oxmeta_name first, then
try the list of definitions from the configuration file in turn.

Definition at line 2266 of file translators.py.

    def _find_var(self, oxmeta_name, definitions):
        """Find the variable object in the model for a particular concept.
        
        Will look for a variable annotated with the given oxmeta_name first, then
        try the list of definitions from the configuration file in turn.
        """
        var = None
        # Prepend an oxmeta definition
        oxmeta_defn = self._create_var_def(oxmeta_name, 'oxmeta')
        for defn in [oxmeta_defn] + definitions:
            var = self._find_variable(defn)
            if var:
                break
        return var
 

References CellMLToNektar.translators.ConfigurationStore._create_var_def(), and CellMLToNektar.translators.ConfigurationStore._find_variable().

Referenced by CellMLToNektar.translators.ConfigurationStore.find_membrane_capacitance(), and CellMLToNektar.translators.ConfigurationStore.find_transmembrane_potential().

_find_variable()

def CellMLToNektar.translators.ConfigurationStore._find_variable (   self,   defn,   pe_done = False  )

private

Find a variable matching the given definition.

If pe_done is True, then partial evaluation has been performed
on the model, so looking for variables by name needs to look for
variables called compname__varname in the single component.

Definition at line 2031 of file translators.py.

    def _find_variable(self, defn, pe_done=False):
        """Find a variable matching the given definition.
 
        If pe_done is True, then partial evaluation has been performed
        on the model, so looking for variables by name needs to look for
        variables called compname__varname in the single component.
        """
        defn_type = getattr(defn, u'type', u'name')
        if defn_type == u'name':
            name_parts = unicode(defn).strip().split(',')
            if pe_done:
                try:
                    var = self.doc.model.component.get_variable_by_name(u'__'.join(name_parts))
                except KeyError:
                    var = None
            else:
                var = self.doc.model.xml_xpath(u'cml:component[@name="%s"]/cml:variable[@name="%s"]'
                                               % tuple(name_parts))
                if var:
                    var = var[0]
        elif defn_type == u'oxmeta':
            var = self.doc.model.get_variable_by_oxmeta_name(str(defn), throw=False)
        elif defn_type == u'config-name':
            if unicode(defn) == u'stimulus':
                var = self.i_stim_var
            elif unicode(defn) == u'transmembrane_potential':
                var = self.V_variable
            elif unicode(defn) == u'membrane_capacitance':
                var = self.Cm_variable
            else:
                raise ConfigurationError('"' + str(defn) + '" is not a valid configuration file variable name')
        else:
            raise ConfigurationError('"' + defn_type + '" is not a valid variable definition type')
        return var
    

References CellMLToNektar.translators.ConfigurationStore.Cm_variable, Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.ConfigurationStore.i_stim_var, and CellMLToNektar.translators.ConfigurationStore.V_variable.

Referenced by CellMLToNektar.translators.ConfigurationStore._find_var(), and CellMLToNektar.translators.ConfigurationStore.find_lookup_variables().

_parse_Cm()

def CellMLToNektar.translators.ConfigurationStore._parse_Cm (   self,   cm_elt  )

private

Parse definition of variable holding the cell membrane capacitance.

Definition at line 2019 of file translators.py.

    def _parse_Cm(self, cm_elt):
        """Parse definition of variable holding the cell membrane capacitance."""
        self.Cm_definitions = self._parse_var(cm_elt, 'membrane_capacitance')
 

References CellMLToNektar.translators.ConfigurationStore._parse_var(), and CellMLToNektar.translators.ConfigurationStore.Cm_definitions.

Referenced by CellMLToNektar.translators.ConfigurationStore.read_configuration_file().

_parse_currents()

def CellMLToNektar.translators.ConfigurationStore._parse_currents (   self,   currents  )

private

Parse definitions of ionic and stimulus currents.

Definition at line 2023 of file translators.py.

    def _parse_currents(self, currents):
        """Parse definitions of ionic and stimulus currents."""
        if hasattr(currents, u'stimulus'):
            self.i_stim_definitions = self._parse_var(currents.stimulus, 'stimulus current')
        if hasattr(currents, u'ionic_match'):
            self.i_ionic_definitions = self._parse_var(currents.ionic_match, 'ionic currents')
        return
    

References CellMLToNektar.translators.ConfigurationStore._parse_var(), CellMLToNektar.translators.ConfigurationStore.i_ionic_definitions, and CellMLToNektar.translators.ConfigurationStore.i_stim_definitions.

Referenced by CellMLToNektar.translators.ConfigurationStore.read_configuration_file().

_parse_lookup_tables()

def CellMLToNektar.translators.ConfigurationStore._parse_lookup_tables (   self,   lookup_tables  )

private

Parse a lookup_tables element.

Definition at line 2319 of file translators.py.

    def _parse_lookup_tables(self, lookup_tables):
        """Parse a lookup_tables element."""
        for lt in lookup_tables.lookup_table:
            var_type = getattr(lt.var, u'type', u'name')
            var_name = unicode(lt.var).strip()
            config_key = (var_type, var_name)
            if not config_key in self.lut_config:
                self.lut_config[config_key] = {}
                self._set_lut_defaults(self.lut_config[config_key])
            for elt in lt.xml_element_children():
                if elt.localName != u'var':
                    self.lut_config[config_key]['table_' + elt.localName] = unicode(elt).strip()
            if hasattr(lt, u'units'):
                try:
                    units = self.unit_definitions.get_units_by_name(lt.units)
                except KeyError:
                    raise ConfigurationError('The units "%s" referenced by the lookup table for "%s" do not exist'
                                             % (lt.units, var_name))
                self.lut_config[config_key]['table_units'] = units
        return
 

References CellMLToNektar.translators.ConfigurationStore._set_lut_defaults(), CellMLToNektar.pycml.get_units_by_name(), CellMLToNektar.translators.ConfigurationStore.lut_config, and CellMLToNektar.translators.ConfigurationStore.unit_definitions.

Referenced by CellMLToNektar.translators.ConfigurationStore.read_configuration_file().

_parse_var()

def CellMLToNektar.translators.ConfigurationStore._parse_var (   self,   elt,   name  )

private

Parse definition of a special variable.

Definition at line 2001 of file translators.py.

    def _parse_var(self, elt, name):
        """Parse definition of a special variable."""
        if hasattr(elt, 'var'):
            # List of possibilities
            defs = []
            for vardef in elt.var:
                self._check_var_def(vardef, name)
                defs.append(vardef)
        else:
            # Old style - single variable given by text content
            self._check_var_def(elt, name)
            defs = [elt]
        return defs
 

References CellMLToNektar.translators.ConfigurationStore._check_var_def().

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_Cm(), CellMLToNektar.translators.ConfigurationStore._parse_currents(), and CellMLToNektar.translators.ConfigurationStore._parse_Vm().

_parse_Vm()

def CellMLToNektar.translators.ConfigurationStore._parse_Vm (   self,   vm_elt  )

private

Parse definition of variable holding the transmembrane potential.

Definition at line 2015 of file translators.py.

    def _parse_Vm(self, vm_elt):
        """Parse definition of variable holding the transmembrane potential."""
        self.V_definitions = self._parse_var(vm_elt, 'transmembrane_potential')
    

References CellMLToNektar.translators.ConfigurationStore._parse_var(), and CellMLToNektar.translators.ConfigurationStore.V_definitions.

Referenced by CellMLToNektar.translators.ConfigurationStore.read_configuration_file().

_process_ci_elts()

def CellMLToNektar.translators.ConfigurationStore._process_ci_elts (   self,   elt,   func, **  kwargs  )

private

Recursively apply func to any ci elements in the tree rooted at elt.

Definition at line 2066 of file translators.py.

    def _process_ci_elts(self, elt, func, **kwargs):
        """Recursively apply func to any ci elements in the tree rooted at elt."""
        if isinstance(elt, mathml_ci):
            func(elt, **kwargs)
        else:
            for child in getattr(elt, 'xml_children', []):
                self._process_ci_elts(child, func, **kwargs)
    

References CellMLToNektar.optimize.PartialEvaluator._process_ci_elts(), and CellMLToNektar.translators.ConfigurationStore._process_ci_elts().

Referenced by CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode(), CellMLToNektar.optimize.PartialEvaluator._process_ci_elts(), CellMLToNektar.translators.ConfigurationStore._process_ci_elts(), and CellMLToNektar.optimize.PartialEvaluator.is_instantiable().

_set_lut_defaults()

def CellMLToNektar.translators.ConfigurationStore._set_lut_defaults (   self,   lut_dict  )

private

Set default configuration for a lookup table.

Definition at line 2340 of file translators.py.

    def _set_lut_defaults(self, lut_dict):
        """Set default configuration for a lookup table."""
        def_dict = optimize.LookupTableAnalyser._LT_DEFAULTS
        for k, v in def_dict.iteritems():
            if k != 'table_var':
                lut_dict[k] = v
        lut_dict['table_units'] = None
        return
 

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_lookup_tables(), and CellMLToNektar.translators.ConfigurationStore.finalize_config().

annotate_currents_for_pe()

def CellMLToNektar.translators.ConfigurationStore.annotate_currents_for_pe

(

self

)

Annotate ionic & stimulus current vars so PE doesn't remove them.
Also annotate the membrane capacitance, if defined.

Definition at line 2349 of file translators.py.

    def annotate_currents_for_pe(self):
        """Annotate ionic & stimulus current vars so PE doesn't remove them.
        Also annotate the membrane capacitance, if defined."""
        if self.i_stim_var:
            self.i_stim_var.set_pe_keep(True)
        for var in self.i_ionic_vars:
            var.set_pe_keep(True)
        if self.Cm_variable:
            self.Cm_variable.set_pe_keep(True)
        return
    

References CellMLToNektar.translators.ConfigurationStore.Cm_variable, CellMLToNektar.translators.ConfigurationStore.i_ionic_vars, and CellMLToNektar.translators.ConfigurationStore.i_stim_var.

annotate_metadata_for_pe()

def CellMLToNektar.translators.ConfigurationStore.annotate_metadata_for_pe

(

self

)

Definition at line 2379 of file translators.py.

    def annotate_metadata_for_pe(self):
        "Annotate all vars tagged with metadata so PE doesn't remove them."
        for var in self.metadata_vars:
            var.set_pe_keep(True)
        return
 

References CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.metadata_vars, and CellMLToNektar.translators.ConfigurationStore.metadata_vars.

expose_variables()

def CellMLToNektar.translators.ConfigurationStore.expose_variables

(

self

)

Expose variables for access with GetAnyVariable if desired.

Definition at line 2360 of file translators.py.

    def expose_variables(self):
        """Expose variables for access with GetAnyVariable if desired."""
        def annotate(var):
            t = var.get_type()
            if t == VarTypes.Constant:
                var.set_is_modifiable_parameter(True)
            elif t in [VarTypes.Computed, VarTypes.Free, VarTypes.Mapped]:
                var.set_is_derived_quantity(True)
        if self.options.expose_annotated_variables:
            for var in self.metadata_vars:
                if (not self.options.use_chaste_stimulus or
                    not var.oxmeta_name in cellml_metadata.STIMULUS_NAMES):
                    annotate(var)
            DEBUG('translate', "+++ Exposed annotated variables")
        if self.options.expose_all_variables:
            for var in self.doc.model.get_all_variables():
                annotate(var)
            DEBUG('translate', "+++ Exposed all variables")
    

References CellMLToNektar.utilities.DEBUG(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.metadata_vars, CellMLToNektar.translators.ConfigurationStore.metadata_vars, CellMLToNektar.translators.CellMLTranslator.options, and CellMLToNektar.translators.ConfigurationStore.options.

finalize_config()

def CellMLToNektar.translators.ConfigurationStore.finalize_config

(

self

)

Having read all the configuration files, apply to the model.

Definition at line 1960 of file translators.py.

    def finalize_config(self):
        """Having read all the configuration files, apply to the model."""
        # If no LT options given, add defaults
        if not self.lut_config:
            config_key = ('config-name', 'transmembrane_potential')
            self.lut_config[config_key] = {}
            self._set_lut_defaults(self.lut_config[config_key])
        # Identify the variables in the model
        self.find_transmembrane_potential()
        self.find_membrane_capacitance()
        if not self.options.protocol:
            self.find_current_vars()
 

References CellMLToNektar.translators.ConfigurationStore._set_lut_defaults(), CellMLToNektar.translators.ConfigurationStore.find_current_vars(), CellMLToNektar.translators.ConfigurationStore.find_membrane_capacitance(), CellMLToNektar.translators.ConfigurationStore.find_transmembrane_potential(), CellMLToNektar.translators.ConfigurationStore.lut_config, CellMLToNektar.translators.CellMLTranslator.options, and CellMLToNektar.translators.ConfigurationStore.options.

find_current_vars()

def CellMLToNektar.translators.ConfigurationStore.find_current_vars

(

self

)

Find the variables representing currents.

Definition at line 2281 of file translators.py.

    def find_current_vars(self):
        """Find the variables representing currents."""
        # Find the stimulus current, if it exists for this kind of model (some are self-excitatory)
        if not self.doc.model.is_self_excitatory():
            # self.i_stim_var = self._find_var('membrane_stimulus_current', self.i_stim_definitions)
            # DEBUG('config', 'Found stimulus', self.i_stim_var)
            if not self.i_stim_var:
                # No match :(
                msg = "No stimulus current found; you'll have trouble generating Nektar code"
                if self.options.fully_automatic:
                    raise ConfigurationError(msg)
                else:
                    print >>sys.stderr, msg
                    self.i_stim_var = None
        # For other ionic currents, try using the equation for dV/dt unless told otherwise
        if not self.options.use_i_ionic_regexp:
            self.i_ionic_vars = self._find_transmembrane_currents_from_voltage_ode()
        else:
            for defn in self.i_ionic_definitions:
                if getattr(defn, u'type', u'name') != u'name':
                    raise ConfigurationError('Ionic current definitions have to have type "name"')
                regexps = unicode(defn).strip().split(',')
                comp_re = re.compile(regexps[0] + '$')
                var_re = re.compile(regexps[1] + '$')
                for component in getattr(self.doc.model, u'component', []):
                    if comp_re.match(unicode(component.name).strip()):
                        for var in getattr(component, u'variable', []):
                            if (var is not self.i_stim_var and
                                var_re.match(unicode(var.name).strip())):
                                self.i_ionic_vars.append(var)
        if not self.i_ionic_vars:
            msg = "No ionic currents found; you'll have trouble generating Nektar code"
            if self.options.fully_automatic:
                raise ConfigurationError(msg)
            else:
                print >>sys.stderr, msg
        return
 

References CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.ConfigurationStore.i_ionic_definitions, CellMLToNektar.translators.ConfigurationStore.i_ionic_vars, CellMLToNektar.translators.ConfigurationStore.i_stim_var, CellMLToNektar.translators.CellMLTranslator.options, and CellMLToNektar.translators.ConfigurationStore.options.

Referenced by CellMLToNektar.translators.ConfigurationStore.finalize_config().

find_lookup_variables()

def CellMLToNektar.translators.ConfigurationStore.find_lookup_variables

(

self

)

Find the variable objects used as lookup table keys.

This method translates the variable names given in the configuration file into objects
in the document, and then uses those objects as keys in our lut_config dictionary.
The ultimate source variable for the variable specified is used, in order to avoid
complications caused by intermediaries being removed (e.g. by PE).

The table settings are also units-converted to match the units of the key variable.

Definition at line 2411 of file translators.py.

    def find_lookup_variables(self):
        """Find the variable objects used as lookup table keys.
 
        This method translates the variable names given in the configuration file into objects
        in the document, and then uses those objects as keys in our lut_config dictionary.
        The ultimate source variable for the variable specified is used, in order to avoid
        complications caused by intermediaries being removed (e.g. by PE).
 
        The table settings are also units-converted to match the units of the key variable.
        """
        new_config = {}
        for key in self.lut_config:
            defn_type, content = key
            defn = self._create_var_def(content, defn_type)
            var = self._find_variable(defn)
            if not var:
                # Variable doesn't exist, so we can't index on it
                LOG('lookup-tables', logging.WARNING, 'Variable', content, 'not found, so not using as table index.')
            else:
                var = var.get_source_variable(recurse=True)
                if not var in new_config:
                    new_config[var] = {}
                new_config[var].update(self.lut_config[key])
                # Apply units conversions to the table settings if required
                table_units = new_config[var]['table_units']
                if table_units:
                    var_units = var.get_units()
                    if not table_units.dimensionally_equivalent(var_units):
                        LOG('lookup-tables', logging.WARNING, 'Variable', content, 'is in units', var_units.description(),
                            'which are incompatible with', table_units.description(), 'so not using as table index.')
                    elif not table_units.equals(var_units):
                        # New setting[var_units] = m[var_units/table_units]*(setting-o1[table_units]) + o2[var_units]
                        # c.f. mathml_units_mixin._add_units_conversion
                        print 'LT conversion:', table_units.description(), 'to', var_units.description(), 'equal?', table_units.equals(var_units)
                        m = table_units.get_multiplicative_factor() / var_units.get_multiplicative_factor()
                        for setting in new_config[var]:
                            try:
                                old_value = float(new_config[var][setting])
                                new_value = m * (old_value - table_units.get_offset()) + var_units.get_offset()
                                new_config[var][setting] = unicode(new_value)
                                print 'LT conversion', setting, old_value, new_value
                            except (ValueError, TypeError):
                                pass
        self.lut_config = new_config
        DEBUG('config', 'Lookup tables configuration:', new_config)
        return
 

References CellMLToNektar.translators.ConfigurationStore._create_var_def(), CellMLToNektar.translators.ConfigurationStore._find_variable(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.utilities.LOG(), and CellMLToNektar.translators.ConfigurationStore.lut_config.

find_membrane_capacitance()

def CellMLToNektar.translators.ConfigurationStore.find_membrane_capacitance

(

self

)

Find and store the variable object representing the cell membrane capacitance.

Uses first metadata, if present, then the configuration file.

Definition at line 2404 of file translators.py.

    def find_membrane_capacitance(self):
        """Find and store the variable object representing the cell membrane capacitance.
        
        Uses first metadata, if present, then the configuration file."""
        self.Cm_variable = self._find_var('membrane_capacitance', self.Cm_definitions)
        DEBUG('config', 'Found capacitance', self.Cm_variable)
 

References CellMLToNektar.translators.ConfigurationStore._find_var(), CellMLToNektar.translators.ConfigurationStore.Cm_definitions, CellMLToNektar.translators.ConfigurationStore.Cm_variable, and CellMLToNektar.utilities.DEBUG().

Referenced by CellMLToNektar.translators.ConfigurationStore.finalize_config().

find_transmembrane_potential()

def CellMLToNektar.translators.ConfigurationStore.find_transmembrane_potential

(

self

)

Find and store the variable object representing V.

Tries metadata annotation first.  If that fails, uses the name given in
the command line options, if present.  If that fails, uses the config file.

Definition at line 2385 of file translators.py.

    def find_transmembrane_potential(self):
        """Find and store the variable object representing V.
 
        Tries metadata annotation first.  If that fails, uses the name given in
        the command line options, if present.  If that fails, uses the config file.
        """
        if not self.options:
            raise ValueError('No command line options given')
        # Check command line option before config file
        if self.options.transmembrane_potential:
            self.V_definitions[0:0] = [self.options.transmembrane_potential.strip().split(',')]
            if len(self.V_definitions[0]) != 2:
                raise ConfigurationError('The name of V must contain both component and variable name')
        self.V_variable = self._find_var('membrane_voltage', self.V_definitions)
        DEBUG('config', 'Found V', self.V_variable)
        if not self.V_variable and not self.options.protocol:
            raise ConfigurationError('No transmembrane potential found; check your configuration')
        return self.V_variable
    

References CellMLToNektar.translators.ConfigurationStore._find_var(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.translators.CellMLTranslator.options, CellMLToNektar.translators.ConfigurationStore.options, CellMLToNektar.translators.ConfigurationStore.V_definitions, and CellMLToNektar.translators.ConfigurationStore.V_variable.

Referenced by CellMLToNektar.translators.ConfigurationStore.finalize_config().

read_configuration_file()

def CellMLToNektar.translators.ConfigurationStore.read_configuration_file	(		self,
			config_file
	)

Read configuration stored in config_file.

The configuration file is expected to be XML, conforming to
the following structure.  Currently little checking is done on
the file format; incorrectly formatted files are unlikely to
give particularly helpful error messages.

The root element may contain a 'global' element, giving global
configuration options.  These include:

 * 'lookup_tables'
   Contains one or more 'lookup_table' elements, one for each
   type of lookup table available.  These contain (a selection of)
   the elements:
   * 'var' - the variable to key on.  The component name given
     should be that from which the variable is exported.  Must be
     present.
   * 'min', 'max', 'step' - table bounds parameters.  Optional.
   Default values are used for parameters that are not present.
 * 'currents'
   Defines which variables hold the ionic and stimulus currents,
   if any.  It contains 2 elements:
   * 'stimulus' - the full name of the stimulus current variable
   * 'ionic_match' - a regular expression matching full names of
     ionic current variables.  It may also match the stimulus
     current, but the stimulus will never be considered an ionic
     current.  The value is split on ','; the first part is then
     matched against component names, and the second against
     variables in matching components.
     
     This is mostly redundant now, because the equation for dV/dt
     is used first to determine the ionic currents (see documentation
     for _find_transmembrane_currents_from_voltage_ode), and only
     if this fails to find suitable currents will the ionic_match
     definition be used.
 * 'transmembrane_potential'
   Defines which variable holds the transmembrane potential.
   Defaults to 'membrane,V' if not present.
 * 'membrane_capacitance'
   Defines which variable holds the cell membrane capacitance.
   
The root element also contains 0 or more 'for_model' elements,
which contain settings for individual models.  These must have
at least one of an 'id' or 'name' attribute, which specify the
model in question.  They can also contain anything allowable as
global configuration options.  Options given here override those
specified globally.

Configuration which is identical for groups of models may be given
using the 'for_models' element.  This has an 'ids' element as its
first child, which contains 'id' elements holding either the name
or id of a model.  The remaining contents of the 'for_models'
element are as for 'for_model'.

There are 3 ways of specifying variables:
1. By name (var type='name')
   Variable names are given in full form, i.e. component_name,variable_name
2. By standardised name (var type='oxmeta')
   Use the name from the oxmeta annotations
3. By reference to a section of the config file (when defining lookup table keys)
   e.g. <var type='config-name'>transmembrane_potential</var>

Within any element that specifies a variable, a list of <var> elements can be
provided.  Each will be tried in turn to see if a match can be found in the model,
and the first match wins.

Some items are overridden if oxmeta annotations are present in the model, with
the annotated variable taking precedence over the config file specification.

Definition at line 1848 of file translators.py.

    def read_configuration_file(self, config_file):
        """Read configuration stored in config_file.
 
        The configuration file is expected to be XML, conforming to
        the following structure.  Currently little checking is done on
        the file format; incorrectly formatted files are unlikely to
        give particularly helpful error messages.
 
        The root element may contain a 'global' element, giving global
        configuration options.  These include:
 
         * 'lookup_tables'
           Contains one or more 'lookup_table' elements, one for each
           type of lookup table available.  These contain (a selection of)
           the elements:
           * 'var' - the variable to key on.  The component name given
             should be that from which the variable is exported.  Must be
             present.
           * 'min', 'max', 'step' - table bounds parameters.  Optional.
           Default values are used for parameters that are not present.
         * 'currents'
           Defines which variables hold the ionic and stimulus currents,
           if any.  It contains 2 elements:
           * 'stimulus' - the full name of the stimulus current variable
           * 'ionic_match' - a regular expression matching full names of
             ionic current variables.  It may also match the stimulus
             current, but the stimulus will never be considered an ionic
             current.  The value is split on ','; the first part is then
             matched against component names, and the second against
             variables in matching components.
             
             This is mostly redundant now, because the equation for dV/dt
             is used first to determine the ionic currents (see documentation
             for _find_transmembrane_currents_from_voltage_ode), and only
             if this fails to find suitable currents will the ionic_match
             definition be used.
         * 'transmembrane_potential'
           Defines which variable holds the transmembrane potential.
           Defaults to 'membrane,V' if not present.
         * 'membrane_capacitance'
           Defines which variable holds the cell membrane capacitance.
           
        The root element also contains 0 or more 'for_model' elements,
        which contain settings for individual models.  These must have
        at least one of an 'id' or 'name' attribute, which specify the
        model in question.  They can also contain anything allowable as
        global configuration options.  Options given here override those
        specified globally.
 
        Configuration which is identical for groups of models may be given
        using the 'for_models' element.  This has an 'ids' element as its
        first child, which contains 'id' elements holding either the name
        or id of a model.  The remaining contents of the 'for_models'
        element are as for 'for_model'.
 
        There are 3 ways of specifying variables:
        1. By name (var type='name')
           Variable names are given in full form, i.e. component_name,variable_name
        2. By standardised name (var type='oxmeta')
           Use the name from the oxmeta annotations
        3. By reference to a section of the config file (when defining lookup table keys)
           e.g. <var type='config-name'>transmembrane_potential</var>
 
        Within any element that specifies a variable, a list of <var> elements can be
        provided.  Each will be tried in turn to see if a match can be found in the model,
        and the first match wins.
 
        Some items are overridden if oxmeta annotations are present in the model, with
        the annotated variable taking precedence over the config file specification.
        """
        DEBUG('config', "Reading configuration from ", config_file)
        binder = amara.bindery.binder()
        binder.set_binding_class(None, "units", cellml_units)
        binder.set_binding_class(None, "unit", cellml_unit)
        rules = [bt.ws_strip_element_rule(u'*')]
        config_doc = amara_parse(config_file, rules=rules, binderobj=binder)
        # Store extra units definitions
        for defn in config_doc.xml_xpath(u'/*/units'):
            defn.xml_parent = self.unit_definitions # Needed for looking up the units this definition is derived from
            self.unit_definitions.add_units(defn.name, defn)
        # Overrides for command-line options
        if self.options and hasattr(config_doc.pycml_config, 'command_line_args'):
            args = map(str, config_doc.pycml_config.command_line_args.arg)
            args.append('dummy-file')
            get_options(args, self.options)
        # Sections to use in configuration; later sections take precedence
        sections = []
        # Use global configuration?
        glo = config_doc.xml_xpath(u'/*/global')
        if glo:
            sections.append(glo[0])
        # Get the config section(s) for our model.  Sections
        # specifically for this model come after sections covering
        # multiple models, so they take precedence.
        model_id = getattr(self.doc.model, u'id', self.doc.model.name)
        sections.extend(config_doc.xml_xpath(
            u'/*/for_models[ids/id="%s" or ids/id="%s"]'
            % (self.doc.model.name, model_id)))
        sections.extend(config_doc.xml_xpath(
            u'/*/for_model[@name="%s" or @id="%s"]'
            % (self.doc.model.name, model_id)))
        # Main items of configuration
        for section in sections:
            if hasattr(section, u'lookup_tables'):
                self._parse_lookup_tables(section.lookup_tables)
            if hasattr(section, u'currents'):
                self._parse_currents(section.currents)
            if hasattr(section, u'transmembrane_potential'):
                self._parse_Vm(section.transmembrane_potential)
            if hasattr(section, u'membrane_capacitance'):
                self._parse_Cm(section.membrane_capacitance)
    

References CellMLToNektar.translators.ConfigurationStore._parse_Cm(), CellMLToNektar.translators.ConfigurationStore._parse_currents(), CellMLToNektar.translators.ConfigurationStore._parse_lookup_tables(), CellMLToNektar.translators.ConfigurationStore._parse_Vm(), CellMLToNektar.utilities.amara_parse(), CellMLToNektar.utilities.DEBUG(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.get_options(), CellMLToNektar.translators.CellMLTranslator.options, CellMLToNektar.translators.ConfigurationStore.options, and CellMLToNektar.translators.ConfigurationStore.unit_definitions.

validate_metadata()

def CellMLToNektar.translators.ConfigurationStore.validate_metadata	(		self,
			assume_valid = False
	)

Check that the metadata annotations are 'sensible'.

Ensures that only names we know are used, and that the same name isn't used for multiple variables.

Definition at line 2459 of file translators.py.

    def validate_metadata(self, assume_valid=False):
        """Check that the metadata annotations are 'sensible'.
        
        Ensures that only names we know are used, and that the same name isn't used for multiple variables.
        """
        vars = cellml_metadata.find_variables(self.doc.model, ('bqbiol:is', NSS['bqbiol']))
        self.metadata_vars = filter(lambda v: v.oxmeta_name, vars)
        if assume_valid:
            return
        names_used = [var.oxmeta_name for var in self.metadata_vars]
        DEBUG('metadata', 'Names found: ', names_used)
        # Check all metadata is allowed
        unknown_names = frozenset(names_used) - cellml_metadata.METADATA_NAMES
        if unknown_names:
            msg = ['Unrecognised oxmeta variable names found (run with --assume-valid to ignore):']
            msg.extend(sorted(unknown_names))
            raise ConfigurationError('\n  '.join(msg))
        # Check for duplicates
        d = {}
        for name in names_used:
            if name in d:
                raise ConfigurationError(name + ' metadata attribute is duplicated in the cellml file.')
            else:
                d[name] = name
 
 

References Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, and CellMLToNektar.translators.ConfigurationStore.doc.

Member Data Documentation

Cm_definitions

CellMLToNektar.translators.ConfigurationStore.Cm_definitions

Definition at line 1829 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_Cm(), and CellMLToNektar.translators.ConfigurationStore.find_membrane_capacitance().

Cm_variable

CellMLToNektar.translators.ConfigurationStore.Cm_variable

Definition at line 1830 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._find_variable(), CellMLToNektar.translators.ConfigurationStore.annotate_currents_for_pe(), and CellMLToNektar.translators.ConfigurationStore.find_membrane_capacitance().

doc

CellMLToNektar.translators.ConfigurationStore.doc

Definition at line 1820 of file translators.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser._determine_duplicate_tables(), CellMLToNektar.optimize.LookupTableAnalyser._determine_unneeded_tables(), CellMLToNektar.optimize.PartialEvaluator._do_reduce_eval_loop(), CellMLToNektar.optimize.LookupTableAnalyser._find_tables(), CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode(), CellMLToNektar.translators.ConfigurationStore._find_variable(), CellMLToNektar.optimize.PartialEvaluator._get_assignment_exprs(), CellMLToNektar.optimize.LookupTableAnalyser.analyse_model(), CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable(), CellMLToNektar.optimize.LookupTableAnalyser.config(), CellMLToNektar.translators.CellMLTranslator.config(), CellMLToNektar.translators.ConfigurationStore.expose_variables(), CellMLToNektar.translators.ConfigurationStore.find_current_vars(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.get_stimulus_assignment(), CellMLToNektar.optimize.PartialEvaluator.is_instantiable(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.lut_parameters(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_backward_euler_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_derived_quantities(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_equations(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_get_i_ionic(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_intracellular_calcium(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), CellMLToNektar.translators.CellMLTranslator.output_lut_declarations(), CellMLToNektar.translators.CellMLTranslator.output_lut_deletion(), CellMLToNektar.translators.CellMLTranslator.output_lut_generation(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_indexing_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_indices(), CellMLToNektar.translators.CellMLTranslator.output_lut_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_memory(), CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_methods(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_rush_larsen_mathematics(), CellMLToNektar.translators.CellMLTranslator.output_table_index_generation(), CellMLToNektar.translators.ConfigurationStore.read_configuration_file(), CellMLToNektar.optimize.LookupTableAnalyser.remove_lut_annotations(), CellMLToNektar.translators.CellMLTranslator.scan_for_lookup_tables(), and CellMLToNektar.translators.ConfigurationStore.validate_metadata().

dt_variable

CellMLToNektar.translators.ConfigurationStore.dt_variable

Definition at line 1843 of file translators.py.

i_data_clamp_conductance

CellMLToNektar.translators.ConfigurationStore.i_data_clamp_conductance

Definition at line 1845 of file translators.py.

i_data_clamp_current

CellMLToNektar.translators.ConfigurationStore.i_data_clamp_current

Definition at line 1844 of file translators.py.

i_ionic_definitions

CellMLToNektar.translators.ConfigurationStore.i_ionic_definitions

Definition at line 1836 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_currents(), and CellMLToNektar.translators.ConfigurationStore.find_current_vars().

i_ionic_negated

CellMLToNektar.translators.ConfigurationStore.i_ionic_negated

Definition at line 1839 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode().

i_ionic_vars

CellMLToNektar.translators.ConfigurationStore.i_ionic_vars

Definition at line 1837 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore.annotate_currents_for_pe(), and CellMLToNektar.translators.ConfigurationStore.find_current_vars().

i_stim_definitions

CellMLToNektar.translators.ConfigurationStore.i_stim_definitions

Definition at line 1834 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_currents().

i_stim_negated

CellMLToNektar.translators.ConfigurationStore.i_stim_negated

Definition at line 1841 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode().

i_stim_var

CellMLToNektar.translators.ConfigurationStore.i_stim_var

Definition at line 1835 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode(), CellMLToNektar.translators.ConfigurationStore._find_variable(), CellMLToNektar.translators.ConfigurationStore.annotate_currents_for_pe(), and CellMLToNektar.translators.ConfigurationStore.find_current_vars().

lut_config

CellMLToNektar.translators.ConfigurationStore.lut_config

Definition at line 1832 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_lookup_tables(), CellMLToNektar.translators.ConfigurationStore.finalize_config(), and CellMLToNektar.translators.ConfigurationStore.find_lookup_variables().

metadata_vars

CellMLToNektar.translators.ConfigurationStore.metadata_vars

Definition at line 2465 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore.annotate_metadata_for_pe(), CellMLToNektar.translators.ConfigurationStore.expose_variables(), and CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_cell_parameters().

options

CellMLToNektar.translators.ConfigurationStore.options

Definition at line 1822 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore.expose_variables(), CellMLToNektar.translators.ConfigurationStore.finalize_config(), CellMLToNektar.translators.ConfigurationStore.find_current_vars(), CellMLToNektar.translators.ConfigurationStore.find_transmembrane_potential(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_state_assignments(), and CellMLToNektar.translators.ConfigurationStore.read_configuration_file().

unit_definitions

CellMLToNektar.translators.ConfigurationStore.unit_definitions

Definition at line 1823 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_lookup_tables(), and CellMLToNektar.translators.ConfigurationStore.read_configuration_file().

V_definitions

CellMLToNektar.translators.ConfigurationStore.V_definitions

Definition at line 1826 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._parse_Vm(), and CellMLToNektar.translators.ConfigurationStore.find_transmembrane_potential().

V_variable

CellMLToNektar.translators.ConfigurationStore.V_variable

Definition at line 1827 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore._find_transmembrane_currents_from_voltage_ode(), CellMLToNektar.translators.ConfigurationStore._find_variable(), and CellMLToNektar.translators.ConfigurationStore.find_transmembrane_potential().