CellMLToNektar.optimize.LookupTableAnalyser Class Reference

Inheritance diagram for CellMLToNektar.optimize.LookupTableAnalyser:

Classes
class	LUTState

Public Member Functions
def	__init__ (self)
def	config (self)
def	var_is_membrane_potential (self, var)
def	is_allowed_variable (self, var)
def	is_keying_var (self, var)
def	set_params (self, **kw)
def	get_param (self, param_name, table_var)
def	create_state_from_annotations (self, expr)
def	analyse_for_lut (self, expr, var_checker_fn)
def	check_divide_by_table (self, expr, operand_states)
def	check_commutative_tables (self, expr, operand_states)
def	annotate_as_suitable (self, expr, table_var)
def	remove_lut_annotations (self, expr, remove_reason=False)
def	analyse_model (self, doc, solver_info, annotate_failures=True, annotate_outermost_only=True)
def	calculate_dependencies (self, expr)

Static Public Member Functions
def	copy_lut_annotations (from_expr, to_expr)

Public Attributes
	doc
	solver_info
	annotate_failures
	annotate_outermost_only

Static Public Attributes
	lut_expensive_funcs

Private Member Functions
def	_find_tables (self, expr, table_dict)
def	_determine_unneeded_tables (self)
def	_determine_duplicate_tables (self)

Static Private Attributes
dictionary	_LT_DEFAULTS

Detailed Description

Analyses & annotates a CellML model to indicate where lookup
tables can be used.

Definition at line 384 of file optimize.py.

Constructor & Destructor Documentation

__init__()

def CellMLToNektar.optimize.LookupTableAnalyser.__init__

(

self

)

Create an analyser.

Definition at line 390 of file optimize.py.

    def __init__(self):
        """Create an analyser."""
        # No model to analyse yet
        self.doc = None
        # Set default parameter values
        self.set_params()
 

Member Function Documentation

_determine_duplicate_tables()

def CellMLToNektar.optimize.LookupTableAnalyser._determine_duplicate_tables (   self )

private

Determine whether we have multiple tables for the same expression.

Any expression that is identical to a previous table will be re-annotated to refer to the
previous table, instead of declaring a new one.

This is a temporary measure until we have proper sub-expression elimination for the Jacobian
and residual calculations.

Definition at line 860 of file optimize.py.

    def _determine_duplicate_tables(self):
        """Determine whether we have multiple tables for the same expression.
        
        Any expression that is identical to a previous table will be re-annotated to refer to the
        previous table, instead of declaring a new one.
        
        This is a temporary measure until we have proper sub-expression elimination for the Jacobian
        and residual calculations.
        """
        uniq_tables = []
        for expr in self.doc.lookup_tables:
            for table in uniq_tables:
                if expr.same_tree(table):
                    lt_name = table.getAttributeNS(NSS['lut'], u'table_name', u'')
                    # Need to remove old name before we can set a new one (grr amara)
                    del expr.table_name
                    expr.xml_set_attribute((u'lut:table_name', NSS['lut']), lt_name)
                    break
            else:
                uniq_tables.append(expr)
 

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

_determine_unneeded_tables()

def CellMLToNektar.optimize.LookupTableAnalyser._determine_unneeded_tables (   self )

private

Determine whether some expressions identified as lookup tables aren't actually used.

This occurs if some ODEs have been linearised, in which case the original definitions
will have been analysed for lookup tables, but aren't actually used.

TODO: The original definitions might be used for computing derived quantities...

Definition at line 834 of file optimize.py.

    def _determine_unneeded_tables(self):
        """Determine whether some expressions identified as lookup tables aren't actually used.
        
        This occurs if some ODEs have been linearised, in which case the original definitions
        will have been analysed for lookup tables, but aren't actually used.
        
        TODO: The original definitions might be used for computing derived quantities...
        """
        original_tables = {}
        new_tables = {}
        def f(exprs, table_dict):
            exprs = filter(lambda n: isinstance(n, (mathml_ci, mathml_apply, mathml_piecewise)), exprs)
            for node in self.doc.model.calculate_extended_dependencies(exprs):
                if isinstance(node, mathml_apply):
                    self._find_tables(node, table_dict)
        for u, t, eqns in self.solver_info.get_linearised_odes():
            original_defn = u.get_ode_dependency(t)
            f([original_defn], original_tables)
            f(eqns, new_tables)
        for id_ in set(original_tables.keys()) - set(new_tables.keys()):
            expr = original_tables[id_]
            self.remove_lut_annotations(expr)
            expr.xml_set_attribute((u'lut:reason', NSS['lut']),
                                   u'Expression will not be used in generated code.')
            DEBUG('lookup-tables', 'Not annotating probably unused expression', expr)
    

References CellMLToNektar.optimize.LookupTableAnalyser._find_tables(), CellMLToNektar.utilities.DEBUG(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.optimize.LookupTableAnalyser.remove_lut_annotations(), CellMLToNektar.optimize.PartialEvaluator.solver_info, and CellMLToNektar.optimize.LookupTableAnalyser.solver_info.

_find_tables()

def CellMLToNektar.optimize.LookupTableAnalyser._find_tables (   self,   expr,   table_dict  )

private

Helper method for _determine_unneeded_tables.

Definition at line 826 of file optimize.py.

    def _find_tables(self, expr, table_dict):
        """Helper method for _determine_unneeded_tables."""
        if expr.getAttributeNS(NSS['lut'], u'possible', '') == u'yes':
            table_dict[id(expr)] = expr
        else:
            for e in self.doc.model.xml_element_children(expr):
                self._find_tables(e, table_dict)
 

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

Referenced by CellMLToNektar.optimize.LookupTableAnalyser._determine_unneeded_tables(), and CellMLToNektar.optimize.LookupTableAnalyser._find_tables().

analyse_for_lut()

def CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut	(		self,
			expr,
			var_checker_fn
	)

Check if the given expression can be replaced by a lookup table.

The first argument is the expression to check; the second is a
function which takes a variable object and returns True iff this
variable is permitted within a lookup table expression.

If self.annotate_failures is True then annotate <apply> and
<piecewise> expressions which don't qualify with the reason
why they do not.
This can be:
 'no_var' - doesn't contain the table variable
 'bad_var <vname>' - contains a variable which isn't permitted
 'no_func' - doesn't contain an expensive function
or a comma separated combination of the above.
The annotation is stored as the lut:reason attribute.

If self.annotate_outermost_only is True then only annotate the
outermost qualifying expression, rather than also annotating
qualifying subexpressions.

Definition at line 556 of file optimize.py.

    def analyse_for_lut(self, expr, var_checker_fn):
        """Check if the given expression can be replaced by a lookup table.
 
        The first argument is the expression to check; the second is a
        function which takes a variable object and returns True iff this
        variable is permitted within a lookup table expression.
 
        If self.annotate_failures is True then annotate <apply> and
        <piecewise> expressions which don't qualify with the reason
        why they do not.
        This can be:
         'no_var' - doesn't contain the table variable
         'bad_var <vname>' - contains a variable which isn't permitted
         'no_func' - doesn't contain an expensive function
        or a comma separated combination of the above.
        The annotation is stored as the lut:reason attribute.
 
        If self.annotate_outermost_only is True then only annotate the
        outermost qualifying expression, rather than also annotating
        qualifying subexpressions.
        """
        # If this is a cloned expression, then just copy any annotations on the original.
        if isinstance(expr, mathml):
            source_expr = expr.get_original_of_clone()
        else:
            source_expr = None
        if source_expr and source_expr.getAttributeNS(NSS['lut'], u'possible', '') != '':
            LookupTableAnalyser.copy_lut_annotations(source_expr, expr)
            state = self.create_state_from_annotations(source_expr)
            DEBUG('lookup-tables', "No need to analyse clone", expr.xml(), state.suitable(), state.reason())
        else:
            # Initialise the indicators
            state = self.LUTState()
            # Process current node
            if isinstance(expr, mathml_ci):
                # Variable reference
                if var_checker_fn(expr.variable):
                    # Could be a permitted var that isn't a keying var
                    if self.is_keying_var(expr.variable):
                        assert state.table_var is None # Sanity check
                        state.has_var = True
                        state.table_var = expr.variable
                else:
                    state.bad_vars.add(expr.variable.name)
            elif isinstance(expr, mathml_piecewise):
                # Recurse into pieces & otherwise options
                if hasattr(expr, u'otherwise'):
                    r = self.analyse_for_lut(child_i(expr.otherwise, 1),
                                             var_checker_fn)
                    state.update(r)
                for piece in getattr(expr, u'piece', []):
                    r = self.analyse_for_lut(child_i(piece, 1), var_checker_fn)
                    state.update(r)
                    r = self.analyse_for_lut(child_i(piece, 2), var_checker_fn)
                    state.update(r)
            elif isinstance(expr, mathml_apply):
                # Check function
                if (not state.has_func and
                    expr.operator().localName in self.lut_expensive_funcs):
                    state.has_func = True
                # Check operands
                operand_states = {}
                for operand in expr.operands():
                    r = self.analyse_for_lut(operand, var_checker_fn)
                    state.update(r)
                    operand_states[id(operand)] = r
                # Check qualifiers
                for qual in expr.qualifiers():
                    r = self.analyse_for_lut(qual, var_checker_fn)
                    state.update(r)
                # Special case additional optimisations
                if self.config and self.config.options.combine_commutative_tables and not state.suitable():
                    if isinstance(expr.operator(), reduce_commutative_nary):
                        self.check_commutative_tables(expr, operand_states)
                    elif isinstance(expr.operator(), mathml_divide):
                        self.check_divide_by_table(expr, operand_states)
            else:
                # Just recurse into children
                for e in expr.xml_children:
                    if getattr(e, 'nodeType', None) == Node.ELEMENT_NODE:
                        r = self.analyse_for_lut(e, var_checker_fn)
                        state.update(r)
        # Annotate the expression if appropriate
        if isinstance(expr, (mathml_apply, mathml_piecewise)):
            if state.suitable():
                self.annotate_as_suitable(expr, state.table_var)
            else:
                if self.annotate_failures:
                    expr.xml_set_attribute((u'lut:reason', NSS['lut']), state.reason())
        return state
    

References CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut(), CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable(), CellMLToNektar.optimize.LookupTableAnalyser.annotate_failures, CellMLToNektar.optimize.LookupTableAnalyser.annotate_outermost_only, CellMLToNektar.optimize.LookupTableAnalyser.check_commutative_tables(), CellMLToNektar.optimize.LookupTableAnalyser.check_divide_by_table(), CellMLToNektar.pycml.child_i(), CellMLToNektar.optimize.LookupTableAnalyser.config(), CellMLToNektar.translators.CellMLTranslator.config(), CellMLToNektar.optimize.LookupTableAnalyser.create_state_from_annotations(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.optimize.LookupTableAnalyser.is_keying_var(), and CellMLToNektar.optimize.LookupTableAnalyser.lut_expensive_funcs.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut().

analyse_model()

def CellMLToNektar.optimize.LookupTableAnalyser.analyse_model	(		self,
			doc,
			solver_info,
			annotate_failures = True,
			annotate_outermost_only = True
	)

Analyse the given document.

This method checks all expressions (and subexpressions)
in the given document for whether they could be converted to
use a lookup table, and annotates them appropriately.

By default expressions which don't qualify will be annotated
to indicate why; set annotate_failures to False to suppress
this.

Also by default only the outermost suitable expression in any
given tree will be annotated; if you want to annotate suitable
subexpressions of a suitable expression then pass
annotate_outermost_only as False.

Definition at line 758 of file optimize.py.

                      annotate_outermost_only=True):
        """Analyse the given document.
 
        This method checks all expressions (and subexpressions)
        in the given document for whether they could be converted to
        use a lookup table, and annotates them appropriately.
 
        By default expressions which don't qualify will be annotated
        to indicate why; set annotate_failures to False to suppress
        this.
 
        Also by default only the outermost suitable expression in any
        given tree will be annotated; if you want to annotate suitable
        subexpressions of a suitable expression then pass
        annotate_outermost_only as False.
        """
        self.doc = doc
        self.solver_info = solver_info
        self.annotate_failures = annotate_failures
        self.annotate_outermost_only = annotate_outermost_only
        doc.lookup_tables = {}
        # How to check for allowed variables
        if hasattr(doc, '_cml_config'):
            checker_fn = self.is_allowed_variable
        else:
            checker_fn = self.var_is_membrane_potential
 
        # Check all expressions
        for expr in (e for e in doc.model.get_assignments()
                     if isinstance(e, mathml_apply)):
            ops = expr.operands()
            ops.next()
            e = ops.next()
            self.analyse_for_lut(e, checker_fn)
        for expr in solver_info.get_modifiable_mathematics():
            self.analyse_for_lut(expr, checker_fn)
 
        if solver_info.has_modifiable_mathematics():
            self._determine_unneeded_tables()
 
        # Assign names (numbers) to the lookup tables found.
        # Also work out which ones can share index variables into the table.
        doc.lookup_tables = doc.lookup_tables.keys()
        doc.lookup_tables.sort(cmp=element_path_cmp)
        doc.lookup_table_indexes, n = {}, 0
        for i, expr in enumerate(doc.lookup_tables):
            expr.xml_set_attribute((u'lut:table_name', NSS['lut']), unicode(i))
            comp = expr.get_component()
            var = comp.get_variable_by_name(expr.var).get_source_variable(recurse=True)
            key = (expr.min, expr.max, expr.step, var)
            if not key in doc.lookup_table_indexes:
                doc.lookup_table_indexes[key] = unicode(n)
                n += 1
            expr.xml_set_attribute((u'lut:table_index', NSS['lut']), doc.lookup_table_indexes[key])
        
        if solver_info.has_modifiable_mathematics():
            self._determine_duplicate_tables()
            
        # Re-do dependency analysis so that an expression using lookup
        # tables only depends on the keying variable.
        for expr in (e for e in doc.model.get_assignments()
                     if isinstance(e, mathml_apply)):
            expr.classify_variables(root=True,
                                    dependencies_only=True,
                                    needs_special_treatment=self.calculate_dependencies)
 

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

annotate_as_suitable()

def CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable	(		self,
			expr,
			table_var
	)

Annotate the given expression as being suitable for a lookup table.

Definition at line 714 of file optimize.py.

    def annotate_as_suitable(self, expr, table_var):
        """Annotate the given expression as being suitable for a lookup table."""
        if self.annotate_outermost_only:
            # Remove annotations from (expr and) child expressions
            self.remove_lut_annotations(expr)
        for param in ['min', 'max', 'step']:
            expr.xml_set_attribute((u'lut:' + param, NSS['lut']),
                                   self.get_param('table_' + param, table_var))
        expr.xml_set_attribute((u'lut:var', NSS['lut']), table_var.name)
        expr.xml_set_attribute((u'lut:possible', NSS['lut']), u'yes')
        self.doc.lookup_tables[expr] = True
    

References CellMLToNektar.optimize.LookupTableAnalyser.annotate_outermost_only, Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.optimize.LookupTableAnalyser.get_param(), and CellMLToNektar.optimize.LookupTableAnalyser.remove_lut_annotations().

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut(), CellMLToNektar.optimize.LookupTableAnalyser.check_commutative_tables(), and CellMLToNektar.optimize.LookupTableAnalyser.check_divide_by_table().

calculate_dependencies()

def CellMLToNektar.optimize.LookupTableAnalyser.calculate_dependencies	(		self,
			expr
	)

Determine the dependencies of an expression that might use a lookup table.

This method is suitable for use as the needs_special_treatment function in
mathml_apply.classify_variables.  It is used to override the default recursion
into sub-trees.  It takes a single sub-tree as argument, and returns either
the dependency set for that sub-tree, or None to use the default recursion.

Expressions that can use a lookup table only depend on the keying variable.

Definition at line 881 of file optimize.py.

    def calculate_dependencies(self, expr):
        """Determine the dependencies of an expression that might use a lookup table.
 
        This method is suitable for use as the needs_special_treatment function in
        mathml_apply.classify_variables.  It is used to override the default recursion
        into sub-trees.  It takes a single sub-tree as argument, and returns either
        the dependency set for that sub-tree, or None to use the default recursion.
        
        Expressions that can use a lookup table only depend on the keying variable.
        """
        if expr.getAttributeNS(NSS['lut'], u'possible', '') == u'yes':
            key_var_name = expr.getAttributeNS(NSS['lut'], u'var')
            key_var = expr.component.get_variable_by_name(key_var_name).get_source_variable(recurse=True)
            return set([key_var])
        # If not a table, use default behaviour
        return None
 
 

check_commutative_tables()

def CellMLToNektar.optimize.LookupTableAnalyser.check_commutative_tables	(		self,
			expr,
			operand_states
	)

Check whether we can combine suitable operands into a new expression.

If expr has a commutative (and associative) n-ary operator, but is not suitable as a
whole to become a lookup table (checked by caller) then we might still be able to
do slightly better than just analysing its operands.  If multiple operands can be
replaced by tables keyed on the same variable, these can be combined into a new
application of the same operator as expr, which can then be replaced as a whole
by a single lookup table, and made an operand of expr.

Alternatively, if at least one operand can be replaced by a table, and a subset of
other operands do not contain other variables, then they can be included in the single
table.

Definition at line 664 of file optimize.py.

    def check_commutative_tables(self, expr, operand_states):
        """Check whether we can combine suitable operands into a new expression.
        
        If expr has a commutative (and associative) n-ary operator, but is not suitable as a
        whole to become a lookup table (checked by caller) then we might still be able to
        do slightly better than just analysing its operands.  If multiple operands can be
        replaced by tables keyed on the same variable, these can be combined into a new
        application of the same operator as expr, which can then be replaced as a whole
        by a single lookup table, and made an operand of expr.
        
        Alternatively, if at least one operand can be replaced by a table, and a subset of
        other operands do not contain other variables, then they can be included in the single
        table.
        """
        # Operands that can be replaced by tables
        table_operands = filter(lambda op: operand_states[id(op)].suitable(), expr.operands())
        if not table_operands:
            return
        # Sort these suitable operands by table_var (map var id to var & operand list, respectively)
        table_vars, table_var_operands = {}, {}
        for oper in table_operands:
            table_var = operand_states[id(oper)].table_var
            table_var_id = id(table_var)
            if not table_var_id in table_vars:
                table_vars[table_var_id] = table_var
                table_var_operands[table_var_id] = []
            table_var_operands[table_var_id].append(oper)
        # Figure out if any operands aren't suitable by themselves but could be included in a table
        potential_operands = {id(None): []}
        for table_var_id in table_vars.keys():
            potential_operands[table_var_id] = []
        for op in expr.operands():
            state = operand_states[id(op)]
            if not state.suitable() and not state.bad_vars:
                if not state.table_var in potential_operands:
                    potential_operands[id(state.table_var)] = []
                potential_operands[id(state.table_var)].append(op)
        # Do any combining
        for table_var_id in table_vars.keys():
            suitable_opers = table_var_operands[table_var_id] + potential_operands[table_var_id] + potential_operands[id(None)]
            if len(suitable_opers) > 1:
                # Create new sub-expression with the suitable operands
                for oper in suitable_opers:
                    expr.safe_remove_child(oper)
                new_expr = mathml_apply.create_new(expr, expr.operator().localName, suitable_opers)
                expr.xml_append(new_expr)
                self.annotate_as_suitable(new_expr, table_vars[table_var_id])
                # Remove the operands with no table_var from consideration with other keying vars
                potential_operands[id(None)] = []
    

References CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable().

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut().

check_divide_by_table()

def CellMLToNektar.optimize.LookupTableAnalyser.check_divide_by_table	(		self,
			expr,
			operand_states
	)

Convert division by a table into multiplication.

This is called if expr, a division, cannot be replaced as a whole by a lookup table.
If the denominator can be replaced by a table, then convert expr into a multiplication
by the reciprocal, moving the division into the table.

Definition at line 647 of file optimize.py.

    def check_divide_by_table(self, expr, operand_states):
        """Convert division by a table into multiplication.
        
        This is called if expr, a division, cannot be replaced as a whole by a lookup table.
        If the denominator can be replaced by a table, then convert expr into a multiplication
        by the reciprocal, moving the division into the table.
        """
        numer, denom = list(expr.operands())
        state = operand_states[id(denom)]
        if state.suitable():
            expr.safe_remove_child(numer)
            expr.safe_remove_child(denom)
            recip = mathml_apply.create_new(expr, u'divide', [(u'1', u'dimensionless'), denom])
            times = mathml_apply.create_new(expr, u'times', [numer, recip])
            expr.replace_child(expr, times, expr.xml_parent)
            self.annotate_as_suitable(recip, state.table_var)
 

References CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable().

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut().

config()

def CellMLToNektar.optimize.LookupTableAnalyser.config

(

self

)

Get the current document's configuration store.

Definition at line 398 of file optimize.py.

    def config(self):
        """Get the current document's configuration store."""
        return getattr(self.doc, '_cml_config', None)
 

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

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut(), CellMLToNektar.optimize.LookupTableAnalyser.get_param(), CellMLToNektar.optimize.LookupTableAnalyser.is_allowed_variable(), CellMLToNektar.optimize.LookupTableAnalyser.is_keying_var(), CellMLToNektar.translators.CellMLTranslator.lut_factor(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_assignment(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_backward_euler_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_derivative_calculations(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_derived_quantities(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_indexing_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_methods(), CellMLToNektar.translators.CellMLTranslator.output_single_lookup(), CellMLToNektar.translators.CellMLTranslator.output_table_index_checking(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_table_index_checking(), CellMLToNektar.translators.CellMLTranslator.output_table_index_generation(), and CellMLToNektar.translators.CellMLTranslator.output_table_index_generation_code().

copy_lut_annotations()

def CellMLToNektar.optimize.LookupTableAnalyser.copy_lut_annotations (   from_expr,   to_expr  )

static

Copy any lookup table annotations from one expression to another.

Definition at line 727 of file optimize.py.

    def copy_lut_annotations(from_expr, to_expr):
        """Copy any lookup table annotations from one expression to another."""
        for pyname, fullname in from_expr.xml_attributes.iteritems():
            if fullname[1] == NSS['lut']:
                to_expr.xml_set_attribute(fullname, getattr(from_expr, pyname))
 

create_state_from_annotations()

def CellMLToNektar.optimize.LookupTableAnalyser.create_state_from_annotations	(		self,
			expr
	)

Create a LUTState instance from an already annotated expression.

Definition at line 537 of file optimize.py.

    def create_state_from_annotations(self, expr):
        """Create a LUTState instance from an already annotated expression."""
        state = self.LUTState()
        possible = expr.getAttributeNS(NSS['lut'], u'possible', '')
        if possible == u'yes':
            varname = expr.getAttributeNS(NSS['lut'], u'var')
            state.table_var = expr.component.get_variable_by_name(varname)
        elif possible == u'no':
            reason = expr.getAttributeNS(NSS['lut'], u'reason', '')
            reasons = reason.split(u',')
            for reason in reasons:
                if reason == u'no_var':
                    state.has_var = False
                elif reason == u'no_func':
                    state.has_func = False
                elif reason.startswith(u'bad_var '):
                    state.bad_vars.add(reason[8:])
        return state
 

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut().

get_param()

def CellMLToNektar.optimize.LookupTableAnalyser.get_param	(		self,
			param_name,
			table_var
	)

Get the value of the lookup table parameter.

table_var is the variable object being used to key this table.

If the document has a config store, lookup the value there.
If that doesn't give us a value, use that given using set_params.

Definition at line 453 of file optimize.py.

    def get_param(self, param_name, table_var):
        """Get the value of the lookup table parameter.
 
        table_var is the variable object being used to key this table.
 
        If the document has a config store, lookup the value there.
        If that doesn't give us a value, use that given using set_params.
        """
        try:
            val = self.config.lut_config[
                table_var.get_source_variable(recurse=True)][param_name]
        except AttributeError, KeyError:
            val = getattr(self, param_name)
        return val
 

References CellMLToNektar.optimize.LookupTableAnalyser.config(), and CellMLToNektar.translators.CellMLTranslator.config().

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable().

is_allowed_variable()

def CellMLToNektar.optimize.LookupTableAnalyser.is_allowed_variable	(		self,
			var
	)

Return True iff the given variable is allowed in a lookup table.

This method uses the config store in the document to check the variable object.

Definition at line 410 of file optimize.py.

    def is_allowed_variable(self, var):
        """Return True iff the given variable is allowed in a lookup table.
 
        This method uses the config store in the document to check the variable object.
        """
        var = var.get_source_variable(recurse=True)
        allowed = (var in self.config.lut_config or
                   (self.config.options.include_dt_in_tables and
                    var is self.solver_info.get_dt().get_source_variable(recurse=True)))
        return allowed
 

References CellMLToNektar.optimize.LookupTableAnalyser.config(), CellMLToNektar.translators.CellMLTranslator.config(), CellMLToNektar.optimize.PartialEvaluator.solver_info, and CellMLToNektar.optimize.LookupTableAnalyser.solver_info.

is_keying_var()

def CellMLToNektar.optimize.LookupTableAnalyser.is_keying_var	(		self,
			var
	)

Return True iff the given variable can be used as a table key.

Will check the config store if it exists.  If not, the variable name must match self.table_var.

Definition at line 421 of file optimize.py.

    def is_keying_var(self, var):
        """Return True iff the given variable can be used as a table key.
 
        Will check the config store if it exists.  If not, the variable name must match self.table_var.
        """
        if self.config:
            return var.get_source_variable(recurse=True) in self.config.lut_config
        else:
            return var.name == self.table_var
 

References CellMLToNektar.optimize.LookupTableAnalyser.config(), CellMLToNektar.translators.CellMLTranslator.config(), and CellMLToNektar.optimize.LookupTableAnalyser.LUTState.table_var.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut().

remove_lut_annotations()

def CellMLToNektar.optimize.LookupTableAnalyser.remove_lut_annotations	(		self,
			expr,
			remove_reason = False
	)

Remove lookup table annotations from the given expression.

By default this will only remove annotations from expressions
(and sub-expressions) that can be converted to use lookup tables.
If remove_reason is True, then the lut:reason attributes on
non-qualifying expressions will also be removed.

Definition at line 733 of file optimize.py.

    def remove_lut_annotations(self, expr, remove_reason=False):
        """Remove lookup table annotations from the given expression.
 
        By default this will only remove annotations from expressions
        (and sub-expressions) that can be converted to use lookup tables.
        If remove_reason is True, then the lut:reason attributes on
        non-qualifying expressions will also be removed.
        """
        # Remove from this expression
        delete_table = False
        for pyname in getattr(expr, 'xml_attributes', {}).keys():
            fullname = expr.xml_attributes[pyname]
            if fullname[1] == NSS['lut']:
                if remove_reason or fullname[0] != u'lut:reason':
                    expr.__delattr__(pyname)
                    if fullname[0] != u'lut:reason':
                        delete_table = True
        # Delete expr from list of lookup tables?
        if delete_table:
            del self.doc.lookup_tables[expr]
        # Recurse into children
        for e in expr.xml_children:
            if getattr(e, 'nodeType', None) == Node.ELEMENT_NODE:
                self.remove_lut_annotations(e, remove_reason)
 

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

Referenced by CellMLToNektar.optimize.LookupTableAnalyser._determine_unneeded_tables(), CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable(), and CellMLToNektar.optimize.LookupTableAnalyser.remove_lut_annotations().

set_params()

def CellMLToNektar.optimize.LookupTableAnalyser.set_params	(		self,
		**	kw
	)

Set parameters controlling lookup table generation.

Keyword parameters control the lookup table settings, which are
stored as attributes on suitable expressions.
table_min - minimum table entry (unicode) -> lut:min
table_max - maximum table entry (unicode) -> lut:max
table_step - table step size (unicode) -> lut:step
table_var - the name of the variable indexing the table (unicode) -> lut:var

Definition at line 435 of file optimize.py.

    def set_params(self, **kw):
        """Set parameters controlling lookup table generation.
 
        Keyword parameters control the lookup table settings, which are
        stored as attributes on suitable expressions.
        table_min - minimum table entry (unicode) -> lut:min
        table_max - maximum table entry (unicode) -> lut:max
        table_step - table step size (unicode) -> lut:step
        table_var - the name of the variable indexing the table (unicode) -> lut:var
        """
        defaults = self._LT_DEFAULTS
        for attr in defaults:
            if attr in kw:
                setattr(self, attr, kw[attr])
            else:
                setattr(self, attr, getattr(self, attr, defaults[attr]))
        return
 

References CellMLToNektar.optimize.LookupTableAnalyser._LT_DEFAULTS.

var_is_membrane_potential()

def CellMLToNektar.optimize.LookupTableAnalyser.var_is_membrane_potential	(		self,
			var
	)

Determine if the given variable represents the transmembrane potential.

This method takes an instance of cellml_variable and returns a boolean.

Definition at line 402 of file optimize.py.

    def var_is_membrane_potential(self, var):
        """Determine if the given variable represents the transmembrane potential.
 
        This method takes an instance of cellml_variable and returns a boolean.
        """
        return (var.name in [u'V', u'membrane__V'] and
                var.get_type(follow_maps=True) == VarTypes.State)
 

Member Data Documentation

_LT_DEFAULTS

dictionary CellMLToNektar.optimize.LookupTableAnalyser._LT_DEFAULTS

staticprivate

Initial value:

=  {'table_min': u'-100.0001',
                    'table_max': u'49.9999',
                    'table_step': u'0.01',
                    'table_var': u'V'}

Definition at line 431 of file optimize.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.set_params().

annotate_failures

CellMLToNektar.optimize.LookupTableAnalyser.annotate_failures

Definition at line 778 of file optimize.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut().

annotate_outermost_only

CellMLToNektar.optimize.LookupTableAnalyser.annotate_outermost_only

Definition at line 779 of file optimize.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut(), and CellMLToNektar.optimize.LookupTableAnalyser.annotate_as_suitable().

doc

CellMLToNektar.optimize.LookupTableAnalyser.doc

Definition at line 393 of file optimize.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().

lut_expensive_funcs

CellMLToNektar.optimize.LookupTableAnalyser.lut_expensive_funcs

static

Initial value:

=  frozenset(('exp', 'log', 'ln', 'root',
                                     'sin', 'cos', 'tan',
                                     'sec', 'csc', 'cot',
                                     'sinh', 'cosh', 'tanh',
                                     'sech', 'csch', 'coth',
                                     'arcsin', 'arccos', 'arctan',
                                     'arcsinh', 'arccosh', 'arctanh',
                                     'arcsec', 'arccsc', 'arccot',
                                     'arcsech', 'arccsch', 'arccoth'))

Definition at line 469 of file optimize.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser.analyse_for_lut().

solver_info

CellMLToNektar.optimize.LookupTableAnalyser.solver_info

Definition at line 777 of file optimize.py.

Referenced by CellMLToNektar.optimize.LookupTableAnalyser._determine_unneeded_tables(), CellMLToNektar.optimize.PartialEvaluator._get_assignment_exprs(), and CellMLToNektar.optimize.LookupTableAnalyser.is_allowed_variable().