CellMLToNektar.pycml.mathml_apply Class Reference

Inheritance diagram for CellMLToNektar.pycml.mathml_apply:

Classes
class	OPS

Public Member Functions
def	__init__ (self)
def	clear_dependency_info (self)
def	get_dependencies (self)
def	operator (self)
def	qualifiers (self)
def	operands (self)
def	evaluate (self)
def	tree_complexity (self, **kw)
def	get_units (self)
def	check_assigned_var (self)
def	classify_variables (self, root=False, dependencies_only=False, needs_special_treatment=lambda n:None)
def	is_top_level (self)
def	is_ode (self)
def	is_assignment (self)
def	assigned_variable (self)
Public Member Functions inherited from CellMLToNektar.utilities.Colourable
def	__init__ (self, *args, **kwargs)
def	set_colour (self, colour)
def	get_colour (self)
def	clear_colour (self)
def	__init__ (self)
Public Member Functions inherited from CellMLToNektar.pycml.mathml
def	__init__ (self)
def	__repr__ (self)
def	__deepcopy__ (self, memo)
def	clone_self (self, register=False)
def	get_original_of_clone (self)
def	get_component (self)
def	model (self)
def	eval (self, elt)
Public Member Functions inherited from CellMLToNektar.pycml.element_base
def	__init__ (self)
def	__delattr__ (self, key)
def	__setattr__ (self, key, value)
def	rootNode (self)
def	cmeta_id (self)
def	xml_remove_child_at (self, index=-1)
def	xml_doc (self)
def	xml_properties (self)

Static Public Member Functions
def	create_new (elt, operator, operands=[], qualifiers=[])
Static Public Member Functions inherited from CellMLToNektar.pycml.mathml
def	clone (expr)

Static Public Attributes
	QUALIFIERS

Private Member Functions
def	_is_qualifier (self, element)
def	_get_operand_units (self)
def	_set_in_units (self, units, no_act=False)
def	_get_binding_time (self, check_operator=True)
def	_reduce (self, check_operator=True)

Private Attributes
	_cml_units
	_cml_binding_time
	_cml_depends_on
	_cml_assigns_to
	_cml_ode_has_free_var_on_rhs

Additional Inherited Members
Public Attributes inherited from CellMLToNektar.pycml.element_base
	xml_attributes
Properties inherited from CellMLToNektar.pycml.mathml
	component = property(get_component)

Detailed Description

Definition at line 4372 of file pycml.py.

Constructor & Destructor Documentation

__init__()

def CellMLToNektar.pycml.mathml_apply.__init__

(

self

)

Reimplemented from CellMLToNektar.pycml.mathml_constructor.

Definition at line 4393 of file pycml.py.

    def __init__(self):
        super(mathml_apply, self).__init__()
        self._cml_units = None
        self.clear_dependency_info()
    

References CellMLToNektar.pycml.mathml_apply.__init__().

Referenced by CellMLToNektar.pycml.mathml_apply.__init__().

Member Function Documentation

_get_binding_time()

def CellMLToNektar.pycml.mathml_apply._get_binding_time (   self,   check_operator = True  )

private

Return the binding time of this expression.

The binding time will be computed recursively and cached.
It will also be made available as an attribute in the XML.

It is computed by taking the least upper bound of the binding
times of our operands, unless the operator possesses an
alternative method.

Definition at line 4934 of file pycml.py.

    def _get_binding_time(self, check_operator=True):
        """Return the binding time of this expression.
 
        The binding time will be computed recursively and cached.
        It will also be made available as an attribute in the XML.
 
        It is computed by taking the least upper bound of the binding
        times of our operands, unless the operator possesses an
        alternative method.
        """
        if self._cml_binding_time is not None:
            return self._cml_binding_time
 
        # Do we have an annotation?
        if hasattr(self, u'binding_time'):
            self._cml_binding_time = getattr(BINDING_TIMES, self.binding_time)
            return self._cml_binding_time
 
        # Does operator have a specialised method for this?
        op = self.operator()
        if check_operator and hasattr(op, '_get_binding_time'):
            self._cml_binding_time = op._get_binding_time()
        else:
            # Compute operand binding times
            bts = [BINDING_TIMES.static]
            for operand in self.operands():
                bts.append(self._get_element_binding_time(operand))
            # Take l.u.b.
            self._cml_binding_time = max(bts)
 
        # Annotate the element with the binding time
        self.xml_set_attribute((u'pe:binding_time', NSS[u'pe']), unicode(self._cml_binding_time))
        return self._cml_binding_time
 

References CellMLToNektar.pycml.cellml_variable._cml_binding_time, CellMLToNektar.pycml.mathml_apply._cml_binding_time, CellMLToNektar.pycml.mathml_piecewise._cml_binding_time, CellMLToNektar.pycml.mathml_constructor._get_element_binding_time(), CellMLToNektar.optimize.ExpressionMatcher.A.operands, CellMLToNektar.pycml.mathml_apply.operands(), CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

Referenced by CellMLToNektar.pycml.mathml_ci._reduce(), CellMLToNektar.pycml.mathml_apply._reduce(), CellMLToNektar.pycml.mathml_piecewise._reduce(), CellMLToNektar.pycml.cellml_variable.get_value(), and CellMLToNektar.pycml.cellml_variable.is_statically_const().

_get_operand_units()

def CellMLToNektar.pycml.mathml_apply._get_operand_units (   self )

private

Return an iterable containing a <units> element for each operand
of this expression.

Definition at line 4439 of file pycml.py.

    def _get_operand_units(self):
        """
        Return an iterable containing a <units> element for each operand
        of this expression.
        """
        for o in self.operands():
            yield self._get_element_units(o)
 

References CellMLToNektar.pycml.mathml_constructor._get_element_units(), CellMLToNektar.optimize.ExpressionMatcher.A.operands, and CellMLToNektar.pycml.mathml_apply.operands().

Referenced by CellMLToNektar.pycml.mathml_apply.get_units().

_is_qualifier()

def CellMLToNektar.pycml.mathml_apply._is_qualifier (   self,   element  )

private

Return True iff element is a qualifier element.

Definition at line 4416 of file pycml.py.

    def _is_qualifier(self, element):
        """Return True iff element is a qualifier element."""
        return element.localName in self.QUALIFIERS
 

References CellMLToNektar.pycml.mathml_apply.QUALIFIERS.

Referenced by CellMLToNektar.pycml.mathml_apply.operands(), and CellMLToNektar.pycml.mathml_apply.qualifiers().

_reduce()

def CellMLToNektar.pycml.mathml_apply._reduce (   self,   check_operator = True  )

private

Reduce this expression by evaluating its static parts.

Definition at line 4968 of file pycml.py.

    def _reduce(self, check_operator=True):
        """Reduce this expression by evaluating its static parts."""
        # Check to see if this operator requires a special
        # reduction strategy
        op = self.operator()
        DEBUG('partial-evaluator', "Reducing", op.localName, getattr(self, u'id', ''))
        if check_operator and hasattr(op, '_reduce'):
            op._reduce()
        else:
            bt = self._get_binding_time()
            if bt == BINDING_TIMES.static:
                # Evaluate self and replace by a <cn>, <true> or <false>
                new_elt = self._eval_self()
                self._xfer_complexity(new_elt)
                self.replace_child(self, new_elt, self.xml_parent)
                # Update usage counts
                self._update_usage_counts(self, remove=True)
            elif bt == BINDING_TIMES.dynamic:
                # Recurse into operands and reduce those
                for op in self.operands():
                    self._reduce_elt(op)
        return
 

References CellMLToNektar.pycml.mathml_constructor._eval_self(), CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.mathml_cn._get_binding_time(), CellMLToNektar.pycml.mathml_ci._get_binding_time(), CellMLToNektar.pycml.mathml_piecewise._get_binding_time(), CellMLToNektar.pycml.mathml_diff._get_binding_time(), CellMLToNektar.pycml.mathml_and._get_binding_time(), CellMLToNektar.pycml.mathml_or._get_binding_time(), CellMLToNektar.pycml.mathml_eq._get_binding_time(), CellMLToNektar.pycml.mathml_apply._get_binding_time(), CellMLToNektar.pycml.mathml_constructor._reduce_elt(), CellMLToNektar.pycml.mathml_constructor._update_usage_counts(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.optimize.ExpressionMatcher.A.operands, CellMLToNektar.pycml.mathml_apply.operands(), CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

_set_in_units()

def CellMLToNektar.pycml.mathml_apply._set_in_units (   self,   units,   no_act = False  )

private

Set the units this expression should be given in.

If these aren't our natural units (as given by an initial
get_units) then we need to add units conversion code.

Definition at line 4523 of file pycml.py.

    def _set_in_units(self, units, no_act=False):
        """Set the units this expression should be given in.
 
        If these aren't our natural units (as given by an initial
        get_units) then we need to add units conversion code.
        """
        # First check we have something to do
        current_units = self.get_units()
        if units is current_units:
            return
        # Next, check if the required units can be achieved by suitable choices for operand units
        done = False
        if units in current_units:
            # They can!
            if not no_act:
                self._cml_units = units
            for src_units_set, src_units in current_units._get_sources(units):
                expr = src_units_set.get_expression()
                self._set_element_in_units(expr, src_units, no_act)
                done = True
            if not done and not no_act:
                # Some operators need this to be a UnitsSet
                self._cml_units = UnitsSet([units], self)
        if not done:
            # The behaviour now depends on the operator
            op = self.operator()
            if hasattr(op, '_set_in_units') and callable(op._set_in_units):
                op._set_in_units(units, no_act)
            else:
                raise UnitsError(self, u' '.join([
                    "Don't know how to select units for operands of operator",
                    op.localName, "when its units are", units.description()]))
 

References CellMLToNektar.pycml.cellml_model._cml_units, CellMLToNektar.pycml.cellml_component._cml_units, CellMLToNektar.pycml.mathml_units_mixin_tokens._cml_units, CellMLToNektar.pycml.mathml_units_mixin_container._cml_units, CellMLToNektar.pycml.mathml_cn._cml_units, CellMLToNektar.pycml.mathml_ci._cml_units, CellMLToNektar.pycml.mathml_apply._cml_units, CellMLToNektar.pycml.mathml_piecewise._cml_units, CellMLToNektar.pycml.mathml_units_mixin._set_element_in_units(), CellMLToNektar.pycml.cellml_variable.get_units(), CellMLToNektar.pycml.mathml_apply.get_units(), CellMLToNektar.pycml.mathml_piecewise.get_units(), CellMLToNektar.pycml.mathml_cn.get_units(), CellMLToNektar.pycml.mathml_ci.get_units(), CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

assigned_variable()

def CellMLToNektar.pycml.mathml_apply.assigned_variable

(

self

)

Return the variable assigned to by this assignment.

Should only be called on a top-level assignment expression.

If it's a straightforward assignment (so self.is_assignment()
returns True) then return the cellml_variable object
representing the variable assigned to.

If it's an ODE, return a pair
(dependent variable, independent variable).

Definition at line 4917 of file pycml.py.

    def assigned_variable(self):
        """Return the variable assigned to by this assignment.
 
        Should only be called on a top-level assignment expression.
        
        If it's a straightforward assignment (so self.is_assignment()
        returns True) then return the cellml_variable object
        representing the variable assigned to.
 
        If it's an ODE, return a pair
        (dependent variable, independent variable).
        """
        if not self.is_top_level():
            raise TypeError("not a top-level apply element")
        else:
            return self._cml_assigns_to
 

References CellMLToNektar.pycml.mathml_apply._cml_assigns_to, and CellMLToNektar.pycml.mathml_apply.is_top_level().

check_assigned_var()

def CellMLToNektar.pycml.mathml_apply.check_assigned_var

(

self

)

Check the current component owns the variable being assigned to.

Should only be called if this object represents an assignment
expression.  Checks that the variable being assigned to doesn't
have an interface value of 'in'.  If this isn't a simple assignment
(i.e. the LHS isn't a plain ci element) then the check succeeds
automatically.

Adds to the model's error list if the check fails.  This method
always returns None.

Definition at line 4758 of file pycml.py.

    def check_assigned_var(self):
        """Check the current component owns the variable being assigned to.
        
        Should only be called if this object represents an assignment
        expression.  Checks that the variable being assigned to doesn't
        have an interface value of 'in'.  If this isn't a simple assignment
        (i.e. the LHS isn't a plain ci element) then the check succeeds
        automatically.
        
        Adds to the model's error list if the check fails.  This method
        always returns None.
        """
        # Check this is an application of eq
        if self.operator().localName != u'eq':
            raise MathsError(self, u'Top-level mathematics expressions should be assigment expressions.')
        first_operand = self.operands().next()
        if first_operand.localName == u'ci':
            # We've already checked that the variable exists
            var = first_operand.variable
            for iface in [u'public_interface', u'private_interface']:
                if getattr(var, iface, u'none') == u'in':
                    raise MathsError(self, u' '.join([
                        u'Variable', var.fullname(),
                        u'is assigned to in a math element, but has its',
                        iface, u'set to "in".']))
 

References CellMLToNektar.optimize.ExpressionMatcher.A.operands, CellMLToNektar.pycml.mathml_apply.operands(), CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

classify_variables()

def CellMLToNektar.pycml.mathml_apply.classify_variables	(		self,
			root = False,
			dependencies_only = False,
			needs_special_treatment = lambda n: None
	)

Classify variables in this expression according to how they are
used.

In the process, compute and return a set of variables on which
this expression depends.  If root is True, store this set as a
list, to represent edges of a dependency graph.
Also, if root is True then this node is the root of an expression
(so it will be an application of eq); treat the LHS differently.

If dependencies_only then the variable classification will not be
done, only dependencies will be analysed.  This is useful for doing
a 'light' re-analysis if the dependency set has been reduced; if the
set has increased then the topological sort of equations may need to
be redone.

The function needs_special_treatment may be supplied to override the
default recursion into sub-trees.  It takes a single sub-tree as
argument, and should either return the dependency set for that
sub-tree, or None to use the default recursion.  This is used when
re-analysing dependencies after applying lookup tables, since table
lookups only depend on the keying variable.

Definition at line 4784 of file pycml.py.

                           needs_special_treatment=lambda n: None):
        """
        Classify variables in this expression according to how they are
        used.
        
        In the process, compute and return a set of variables on which
        this expression depends.  If root is True, store this set as a
        list, to represent edges of a dependency graph.
        Also, if root is True then this node is the root of an expression
        (so it will be an application of eq); treat the LHS differently.
        
        If dependencies_only then the variable classification will not be
        done, only dependencies will be analysed.  This is useful for doing
        a 'light' re-analysis if the dependency set has been reduced; if the
        set has increased then the topological sort of equations may need to
        be redone.
        
        The function needs_special_treatment may be supplied to override the
        default recursion into sub-trees.  It takes a single sub-tree as
        argument, and should either return the dependency set for that
        sub-tree, or None to use the default recursion.  This is used when
        re-analysing dependencies after applying lookup tables, since table
        lookups only depend on the keying variable.
        """
        dependencies = set()
        ode_indep_var = None
        op = self.operator()
        if op.localName == u'diff':
            # This is a derivative dy/dx on the RHS of an assignment.
            # Store the dependency as a pair (y,x)
            dependencies.add((op.dependent_variable, op.independent_variable))
            if not dependencies_only:
                # Set variable types
                op._set_var_types()
        else:
            opers = self.operands()
            if root:
                # Treat the LHS of the assignment
                lhs = opers.next()
                if lhs.localName == u'ci':
                    # Direct assignment to variable
                    var = lhs.variable
                    var._add_dependency(self)
                    self._cml_assigns_to = var
                    if not dependencies_only:
                        # Check for possibly conflicting types
                        t = var.get_type()
                        if t == VarTypes.Constant or t == VarTypes.MaybeConstant:
                            self.model.validation_warning(
                                u' '.join([
                                u'Variable',var.fullname(),u'is assigned to',
                                u'and has an initial value set.']),
                                level=logging.WARNING_TRANSLATE_ERROR)
                        elif t == VarTypes.State or t == VarTypes.Free:
                            self.model.validation_warning(
                                u' '.join([
                                u'Variable',var.fullname(),u'is assigned to',
                                u'and appears on the LHS of an ODE.']),
                                level=logging.WARNING_TRANSLATE_ERROR)
                        var._set_type(VarTypes.Computed)
                elif lhs.localName == u'apply':
                    # This could be an ODE
                    diff = lhs.operator()
                    if diff.localName == u'diff':
                        # It is an ODE. TODO: Record it somewhere?
                        if not dependencies_only:
                            diff._set_var_types()
                        dep = diff.dependent_variable
                        indep = diff.independent_variable
                        dep._add_ode_dependency(indep, self)
                        # An ODE should depend on its independent variable
                        ode_indep_var = indep
                        if not dependencies_only:
                            indep._used()
                        # TODO: Hack; may remove.
                        self._cml_assigns_to = (dep, indep)
                    else:
                        raise MathsError(self, u'Assignment statements are expected to be an ODE or assign to a variable.',
                                         warn=True,
                                         level=logging.WARNING_TRANSLATE_ERROR)
                else:
                    raise MathsError(self, u'Assignment statements are expected to be an ODE or assign to a variable.',
                                     warn=True,
                                     level=logging.WARNING_TRANSLATE_ERROR)
 
            # Consider operands other than the LHS of an assignment
            for oper in opers:
                dependencies.update(self.classify_child_variables(oper, dependencies_only=dependencies_only,
                                                                  needs_special_treatment=needs_special_treatment))
 
        if ode_indep_var:
            # ODEs should depend on their independent variable.
            # However, for code generation we wish to distinguish
            # whether the independent variable appears on the RHS or
            # not.
            if ode_indep_var in dependencies:
                self._cml_ode_has_free_var_on_rhs = True
            else:
                self._cml_ode_has_free_var_on_rhs = False
                dependencies.add(ode_indep_var)
 
        if root:
            # Store dependencies
            self._cml_depends_on = list(dependencies)
        return dependencies
 

References CellMLToNektar.pycml.mathml_apply._cml_assigns_to, CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.optimize.ExpressionMatcher.A.operands, CellMLToNektar.pycml.mathml_apply.operands(), CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

clear_dependency_info()

def CellMLToNektar.pycml.mathml_apply.clear_dependency_info

(

self

)

Clear the type, dependency, etc. information for this equation.

This allows us to re-run the type & dependency analysis for the model.

Definition at line 4398 of file pycml.py.

    def clear_dependency_info(self):
        """Clear the type, dependency, etc. information for this equation.
        
        This allows us to re-run the type & dependency analysis for the model."""
        self._cml_binding_time = None
        # Dependency graph edges
        self._cml_depends_on = []
        self._cml_assigns_to = None
        self.clear_colour()
 

Referenced by CellMLToNektar.pycml.cellml_variable.__init__().

create_new()

def CellMLToNektar.pycml.mathml_apply.create_new (   elt,   operator,   operands = [],   qualifiers = []  )

static

Create a new MathML apply element, with given content.

elt should be any element in the document.

operator is used as the name of the first, empty, child.

operands is a list, possibly empty, of operand elements.  If
any member is a unicode object, it is considered to be the
name of a variable.  If a tuple, then it should be a pair of
unicode objects: (number, units).  (Although units can be an
attribute dictionary.)

qualifiers specifies a list of qualifier elements.

Definition at line 4992 of file pycml.py.

    def create_new(elt, operator, operands=[], qualifiers=[]):
        """Create a new MathML apply element, with given content.
 
        elt should be any element in the document.
 
        operator is used as the name of the first, empty, child.
        
        operands is a list, possibly empty, of operand elements.  If
        any member is a unicode object, it is considered to be the
        name of a variable.  If a tuple, then it should be a pair of
        unicode objects: (number, units).  (Although units can be an
        attribute dictionary.)
 
        qualifiers specifies a list of qualifier elements.
        """
        app = elt.xml_create_element(u'apply', NSS[u'm'])
        app.xml_append(app.xml_create_element(unicode(operator), NSS[u'm']))
        for qual in qualifiers:
            check_append_safety(qual)
            app.xml_append(qual)
        for op in operands:
            if isinstance(op, basestring):
                # Variable name
                op = app.xml_create_element(u'ci', NSS[u'm'],
                                            content=unicode(op))
            elif isinstance(op, tuple):
                # Constant with units
                if isinstance(op[1], dict):
                    attrs = op[1]
                else:
                    attrs = {(u'cml:units', NSS[u'cml']): unicode(op[1])}
                op = app.xml_create_element(u'cn', NSS[u'm'],
                                            attributes=attrs,
                                            content=unicode(op[0]))
            else:
                # Should already be an element
                check_append_safety(op)
            app.xml_append(op)
        return app
 

References CellMLToNektar.pycml.check_append_safety().

evaluate()

def CellMLToNektar.pycml.mathml_apply.evaluate

(

self

)

Evaluate this expression, and return its value, if possible.

Definition at line 4447 of file pycml.py.

    def evaluate(self):
        """
        Evaluate this expression, and return its value, if possible.
        """
        # Result depends on the operator
        op = self.operator()
        if hasattr(op, 'evaluate') and callable(op.evaluate):
            return op.evaluate()
        else:
            raise EvaluationError("Don't know how to evaluate the operator " + op.localName)
 

References CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

Referenced by CellMLToNektar.pycml.mathml_constructor._eval_self(), and CellMLToNektar.pycml.mathml_ci._reduce().

get_dependencies()

def CellMLToNektar.pycml.mathml_apply.get_dependencies

(

self

)

Return the list of variables this expression depends on.

Definition at line 4408 of file pycml.py.

    def get_dependencies(self):
        """Return the list of variables this expression depends on."""
        return self._cml_depends_on
 

References CellMLToNektar.pycml.cellml_variable._cml_depends_on, and CellMLToNektar.pycml.mathml_apply._cml_depends_on.

get_units()

def CellMLToNektar.pycml.mathml_apply.get_units

(

self

)

Recursively check this expression for dimensional consistency.

Checks that the operands have suitable units.
What constitutes 'suitable' depends on the operator; see appendix
C.3.2 of the CellML 1.0 spec.

If yes, returns a <units> element for the whole expression, based
on the rules in appendix C.3.3.

Throws a UnitsError if the units are inconsistent.

Definition at line 4556 of file pycml.py.

    def get_units(self):
        """Recursively check this expression for dimensional consistency.
 
        Checks that the operands have suitable units.
        What constitutes 'suitable' depends on the operator; see appendix
        C.3.2 of the CellML 1.0 spec.
 
        If yes, returns a <units> element for the whole expression, based
        on the rules in appendix C.3.3.
 
        Throws a UnitsError if the units are inconsistent.
        """
        if self._cml_units:
            return self._cml_units
        our_units = None
        op = self.operator().localName
        operand_units = self._get_operand_units()
        # Tuples where second item is an index
        operand_units_idx = itertools.izip(operand_units, itertools.count(1))
        # Standard units objects
        dimensionless = self.model.get_units_by_name(u'dimensionless')
        boolean = self.model.get_units_by_name(u'cellml:boolean')
 
        if op in self.OPS.relations | self.OPS.plusMinus:
            our_units = operand_units.next().copy()
            # Operands mustn't be booleans
            if boolean in our_units:
                raise UnitsError(self, u' '.join([
                    u'Operator',op,u'has boolean operands, which does not make sense.']))
            # Operand units must be 'equivalent' (perhaps dimensionally)
            for u in operand_units:
                if not hasattr(self.model, '_cml_special_units_converter') and not our_units.dimensionally_equivalent(u):
                    raise UnitsError(self, u' '.join([
                        u'Operator',op,u'requires its operands to have',
                        u'dimensionally equivalent units;',u.description(),
                        u'and',our_units.description(),u'differ']))
                our_units.update(u)
            if op in self.OPS.relations:
                # Result has cellml:boolean units
                our_units = UnitsSet([boolean])
        elif op in self.OPS.logical:
            # Operand units must be cellml:boolean
            for u, i in operand_units_idx:
                if not boolean in u:
                    raise UnitsError(self, u' '.join([
                        u'Operator',op,u'requires operands to be booleans;',
                        u'operand',str(i),u'has units',u.description()]))
            # Result has cellml:boolean units
            our_units = UnitsSet([boolean])
        elif op in self.OPS.elementary:
            # Operand units must be dimensionless
            for u, i in operand_units_idx:
                if not u.dimensionally_equivalent(dimensionless):
                    raise UnitsError(self, u' '.join([
                        u'Operator',op,u'requires operands to be dimensionless;',
                        u'operand',str(i),u'has units',u.description()]))
            if op == 'log':
                # <logbase> qualifier must have units dimensionless
                if hasattr(self, u'logbase'):
                    base = _child1(self.logbase)
                    u = self._get_element_units(base)
                    if not u.dimensionally_equivalent(dimensionless):
                        raise UnitsError(self, u' '.join([u'The logbase qualifier must have dimensionless',
                                                          u'units, not',u.description()]))
            # Result has units of dimensionless
            our_units = UnitsSet([dimensionless])
        elif op == 'power':
            # Arg1 : any, Arg2 : dimensionless
            arg_units = operand_units.next()
            if boolean in arg_units:
                raise UnitsError(self, u'The argument of <power> should not be boolean')
            exponent_units = operand_units.next()
            if not exponent_units.dimensionally_equivalent(dimensionless):
                raise UnitsError(self, u' '.join([u'The second operand to power must have dimensionless',
                                                  u'units, not',exponent_units.description()]))
            # Result has units that are the units on the (first)
            # operand raised to the power of the second operand.  If
            # units on the first operand are dimensionless, then so is
            # the result.
            # TODO: Check how we could allow equiv. to d'less, instead of equal.
            # Need to consider any multiplicative factor...
            if arg_units.equals(dimensionless):
                our_units = UnitsSet([dimensionless])
            else:
                opers = self.operands()
                opers.next()
                # Make sure exponent is static
                expt = opers.next()
                if self._get_element_binding_time(expt) != BINDING_TIMES.static:
                    raise UnitsError(self, 'Unable to units check power with an exponent that can vary at run-time',
                                     warn=True,
                                     level=logging.WARNING_TRANSLATE_ERROR)
                # Try to evaluate the exponent
                try:
                    expt = self.eval(expt)
                except EvaluationError, e:
                    raise UnitsError(self, u' '.join([u'Unable to evaluate the exponent of a power element:', unicode(e)]),
                                     warn=True,
                                     level=logging.WARNING_TRANSLATE_ERROR)
                our_units = dimensionless.simplify(arg_units, expt)
        elif op == 'root':
            # Arg : any, <degree> : dimensionless
            arg_units = operand_units.next()
            if boolean in arg_units:
                raise UnitsError(self, u'The argument of <root> should not be boolean')
            if hasattr(self, u'degree'):
                degree = _child1(self.degree)
                u = self._get_element_units(degree)
                if not u.dimensionally_equivalent(dimensionless):
                    raise UnitsError(self, u' '.join([
                        u'The degree qualifier must have dimensionless units, not',u.description()]))
            else:
                degree = 2.0 # Default is square root
            # Result has units that are the units on the (first) operand
            # raised to the power of the reciprocal of the value of the
            # degree qualifier.
            # TODO: If units on the first operand are dimensionless,
            # then so is the result.
            if not type(degree) is float:
                # Make sure degree is static
                if self._get_element_binding_time(degree) != BINDING_TIMES.static:
                    raise UnitsError(self, 'Unable to units check root with a degree that can vary at run-time',
                                     warn=True,
                                     level=logging.WARNING_TRANSLATE_ERROR)
                try:
                    degree = self.eval(degree)
                except EvaluationError, e:
                    raise UnitsError(self, u' '.join([u'Unable to evaluate the degree of a root element:', unicode(e)]),
                                     warn=True,
                                     level=logging.WARNING_TRANSLATE_ERROR)
            our_units = dimensionless.simplify(arg_units, 1/degree)
        elif op == 'diff':
            # Arg : any, <bvar> : any, <degree> : dimensionless
            arg_units = operand_units.next()
            if boolean in arg_units:
                raise UnitsError(self, u'The argument of <diff> should not be boolean')
            if hasattr(self, u'bvar'):
                if hasattr(self.bvar, u'degree'):
                    degree = _child1(self.bvar.degree)
                    u = self._get_element_units(degree)
                    if not u.dimensionally_equivalent(dimensionless):
                        raise UnitsError(self, u' '.join([
                            u'The degree qualifier must have dimensionless units, not',u.description()]))
                else:
                    degree = 1.0 # Default is first derivative
            else:
                raise UnitsError(self, u'A diff operator must have a bvar qualifier')
            # Result has units that are the quotient of the units of the
            # operand, over the units of the term in the bvar qualifier
            # raised to the value of the degree qualifier
            if not type(degree) is float:
                # Make sure exponent is static
                if self._get_element_binding_time(degree) != BINDING_TIMES.static:
                    raise UnitsError(self, 'Unable to units check derivative with a degree that can vary at run-time',
                                     warn=True,
                                     level=logging.WARNING_TRANSLATE_ERROR)
                try:
                    degree = self.eval(degree)
                except EvaluationError, e:
                    raise UnitsError(self, u' '.join([u'Unable to evaluate the degree of a diff element:', unicode(e)]),
                                     warn=True,
                                     level=logging.WARNING_TRANSLATE_ERROR)
            for e in self.xml_element_children(self.bvar):
                if not e.localName == u'degree':
                    bvar_units = self._get_element_units(e)
                    break
            else:
                raise UnitsError(self, u'diff element does not have a valid bvar')
            our_units = arg_units.simplify(bvar_units, -degree)
        elif op in self.OPS.absRound | self.OPS.timesDivide:
            # No restrictions on operand units, except that they shouldn't be boolean
            for u in self._get_operand_units():
                if boolean in u:
                    raise UnitsError(self, u' '.join([
                        u'Operator',op,u'has boolean operands, which does not make sense.']))
            if op == 'times':
                # Result has units that are the product of the operand units
                our_units = operand_units.next().copy()
                for u in operand_units:
                    our_units = our_units.simplify(other_units=u)
            elif op == 'divide':
                # Result has units that are the quotient of the units
                # on the first and second operands
                our_units = operand_units.next()
                our_units = our_units.simplify(other_units=operand_units.next(), other_exponent=-1)
            else:
                # Result has same units as operands
                our_units = operand_units.next().copy()
        else:
            # Warning: unsupported operator!
            raise UnitsError(self, u' '.join([u'Unsupported operator for units checking:', op]),
                             warn=True,
                             level=logging.WARNING_TRANSLATE_ERROR)
 
        # Cache & return result
        if isinstance(our_units, cellml_units):
            # Units conversion has been done, then PE
            our_units = UnitsSet([our_units])
        self._cml_units = our_units
        our_units.set_expression(self)
        return self._cml_units
 

References CellMLToNektar.pycml._child1(), CellMLToNektar.pycml.cellml_model._cml_units, CellMLToNektar.pycml.cellml_component._cml_units, CellMLToNektar.pycml.mathml_units_mixin_tokens._cml_units, CellMLToNektar.pycml.mathml_units_mixin_container._cml_units, CellMLToNektar.pycml.mathml_cn._cml_units, CellMLToNektar.pycml.mathml_ci._cml_units, CellMLToNektar.pycml.mathml_apply._cml_units, CellMLToNektar.pycml.mathml_piecewise._cml_units, CellMLToNektar.pycml.mathml_constructor._get_element_binding_time(), CellMLToNektar.pycml.mathml_constructor._get_element_units(), CellMLToNektar.pycml.mathml_apply._get_operand_units(), CellMLToNektar.pycml.copy(), CellMLToNektar.pycml.mathml.eval(), CellMLToNektar.pycml.get_units_by_name(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.optimize.ExpressionMatcher.A.operands, CellMLToNektar.pycml.mathml_apply.operands(), CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

Referenced by CellMLToNektar.pycml.mathml._ensure_units_exist(), CellMLToNektar.pycml.mathml_units_mixin_tokens._set_in_units(), and CellMLToNektar.pycml.mathml_apply._set_in_units().

is_assignment()

def CellMLToNektar.pycml.mathml_apply.is_assignment

(

self

)

Return True iff this is a straightforward assignment expression.

Only makes sense if called on a top-level assignment expression.
Checks that this is *not* an ODE, but assigns to a single variable.

Definition at line 4907 of file pycml.py.

    def is_assignment(self):
        """Return True iff this is a straightforward assignment expression.
 
        Only makes sense if called on a top-level assignment expression.
        Checks that this is *not* an ODE, but assigns to a single variable.
        """
        if not self.is_top_level():
            return False
        return isinstance(self._cml_assigns_to, cellml_variable)
 

References CellMLToNektar.pycml.mathml_apply._cml_assigns_to, and CellMLToNektar.pycml.mathml_apply.is_top_level().

is_ode()

def CellMLToNektar.pycml.mathml_apply.is_ode

(

self

)

Return True iff this is the assignment of an ODE.

Only makes sense if called on a top-level assignment
expression, and checks if it represents an ODE, i.e. if the
LHS is a derivative.

Definition at line 4896 of file pycml.py.

    def is_ode(self):
        """Return True iff this is the assignment of an ODE.
 
        Only makes sense if called on a top-level assignment
        expression, and checks if it represents an ODE, i.e. if the
        LHS is a derivative.
        """
        if not self.is_top_level():
            return False
        return type(self._cml_assigns_to) == types.TupleType
 

References CellMLToNektar.pycml.mathml_apply._cml_assigns_to, and CellMLToNektar.pycml.mathml_apply.is_top_level().

is_top_level()

def CellMLToNektar.pycml.mathml_apply.is_top_level

(

self

)

Test whether this is a top-level assignment expression.

Definition at line 4892 of file pycml.py.

    def is_top_level(self):
        """Test whether this is a top-level assignment expression."""
        return self._cml_assigns_to is not None
 

References CellMLToNektar.pycml.mathml_apply._cml_assigns_to.

Referenced by CellMLToNektar.pycml.mathml_apply.assigned_variable(), CellMLToNektar.pycml.mathml_apply.is_assignment(), and CellMLToNektar.pycml.mathml_apply.is_ode().

operands()

def CellMLToNektar.pycml.mathml_apply.operands

(

self

)

Return an iterable over the elements representing the operands for
this application.

Definition at line 4428 of file pycml.py.

    def operands(self):
        """
        Return an iterable over the elements representing the operands for
        this application.
        """
        # Get all element children and strip the first (the operator)
        operands = self.xml_element_children()
        operands.next()
        # Now strip qualifiers from the front
        return itertools.dropwhile(self._is_qualifier, operands)
 

References CellMLToNektar.pycml.mathml_apply._is_qualifier().

Referenced by CellMLToNektar.pycml.mathml_apply._get_binding_time(), CellMLToNektar.pycml.mathml_apply._get_operand_units(), CellMLToNektar.pycml.mathml_apply._reduce(), CellMLToNektar.pycml.mathml_apply.check_assigned_var(), CellMLToNektar.pycml.mathml_apply.classify_variables(), CellMLToNektar.pycml.mathml_apply.get_units(), CellMLToNektar.optimize.ExpressionMatcher.A.match(), and CellMLToNektar.pycml.mathml_apply.tree_complexity().

operator()

def CellMLToNektar.pycml.mathml_apply.operator

(

self

)

Return the element representing the operator being applied.

Definition at line 4412 of file pycml.py.

    def operator(self):
        """Return the element representing the operator being applied."""
        return _child1(self)
 

References CellMLToNektar.pycml._child1().

Referenced by CellMLToNektar.pycml.mathml_apply._get_binding_time(), CellMLToNektar.pycml.mathml_apply._reduce(), CellMLToNektar.pycml.mathml_apply._set_in_units(), CellMLToNektar.pycml.mathml_apply.check_assigned_var(), CellMLToNektar.pycml.mathml_apply.classify_variables(), CellMLToNektar.pycml.mathml_apply.evaluate(), CellMLToNektar.pycml.mathml_apply.get_units(), CellMLToNektar.optimize.ExpressionMatcher.A.match(), and CellMLToNektar.pycml.mathml_apply.tree_complexity().

qualifiers()

def CellMLToNektar.pycml.mathml_apply.qualifiers

(

self

)

Return an iterable over the elements representing the qualifiers for
this application.

Definition at line 4420 of file pycml.py.

    def qualifiers(self):
        """
        Return an iterable over the elements representing the qualifiers for
        this application.
        """
        quals = self.xml_element_children()
        return filter(self._is_qualifier, quals)
 

References CellMLToNektar.pycml.mathml_apply._is_qualifier().

tree_complexity()

def CellMLToNektar.pycml.mathml_apply.tree_complexity	(		self,
		**	kw
	)

Calculate a rough estimate of the computation time for
evaluating this <apply> element.

Operates recursively, so the complexity of a function call is
given by summing the complexity of the arguments and the time
for evaluating the function itself.

If lookup_tables is True, then assume we're using lookup tables
where possible.
If algebraic is True, the complexity is calculated as a dictionary,
mapping node types to the number of occurences of that type.

Definition at line 4458 of file pycml.py.

    def tree_complexity(self, **kw):
        """
        Calculate a rough estimate of the computation time for
        evaluating this <apply> element.
 
        Operates recursively, so the complexity of a function call is
        given by summing the complexity of the arguments and the time
        for evaluating the function itself.
        
        If lookup_tables is True, then assume we're using lookup tables
        where possible.
        If algebraic is True, the complexity is calculated as a dictionary,
        mapping node types to the number of occurences of that type.
        """
        kw['algebraic'] = kw.get('algebraic', False)
        if kw['algebraic']: ac = {}
        else: ac = 0
 
        # Complexity of this function
        op_name = self.operator().localName
        OPS = self.OPS
        if op_name in OPS.plusMinus or op_name in OPS.logical or op_name in OPS.relations:
            if kw['algebraic']: ac['op'] = (len(list(self.operands())) - 1)
            else: ac += 1 * (len(list(self.operands())) - 1)
        elif op_name in OPS.absRound:
            if op_name == 'abs':
                if kw['algebraic']: ac['abs'] = 1
                else: ac += 5
            else:
                if kw['algebraic']: ac['round'] = 1
                else: ac += 20
        elif op_name in OPS.elementary:
            if kw['algebraic']: ac['elementary'] = 1
            else: ac += 70
        elif op_name == 'times':
            if kw['algebraic']: ac['times'] = (len(list(self.operands())) - 1)
            else: ac += 1 * (len(list(self.operands())) - 1)
        elif op_name == 'divide':
            if kw['algebraic']: ac['divide'] = 1
            else: ac += 15
        elif op_name == 'power':
            # This will vary depending on the exponent - gcc can optimise for 2 and 3, it seems.
            exponent = list(self.operands())[1]
            if exponent.localName == u'cn' and unicode(exponent).strip() in [u'2', u'3']:
                if kw['algebraic']: ac['power2'] = 1
                else: ac += 5
            else:
                if kw['algebraic']: ac['power'] = 1
                else: ac += 30
        elif op_name == 'root':
            if kw['algebraic']: ac['root'] = 1
            else: ac += 30
        elif op_name == 'diff':
            if kw['algebraic']: ac['variable'] = 1
            else: ac += 0.7
        else:
            raise EvaluationError("Don't know complexity of operator " + op_name)
 
        # Complexity of operands
        for elt in self.operands():
            if kw['algebraic']:
                add_dicts(ac, self._tree_complexity(elt, **kw))
            else: ac += self._tree_complexity(elt, **kw)
        return ac
 

References CellMLToNektar.pycml.mathml_constructor._tree_complexity(), CellMLToNektar.utilities.add_dicts(), CellMLToNektar.optimize.ExpressionMatcher.A.operands, CellMLToNektar.pycml.mathml_apply.operands(), CellMLToNektar.optimize.ExpressionMatcher.A.operator, and CellMLToNektar.pycml.mathml_apply.operator().

Member Data Documentation

_cml_assigns_to

CellMLToNektar.pycml.mathml_apply._cml_assigns_to

private

Definition at line 4405 of file pycml.py.

Referenced by CellMLToNektar.pycml.mathml_apply.assigned_variable(), CellMLToNektar.pycml.mathml_apply.classify_variables(), CellMLToNektar.pycml.mathml_apply.is_assignment(), CellMLToNektar.pycml.mathml_apply.is_ode(), and CellMLToNektar.pycml.mathml_apply.is_top_level().

_cml_binding_time

CellMLToNektar.pycml.mathml_apply._cml_binding_time

private

Definition at line 4402 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.mathml_piecewise._get_binding_time(), CellMLToNektar.pycml.mathml_apply._get_binding_time(), and CellMLToNektar.pycml.cellml_variable._unset_binding_time().

_cml_depends_on

CellMLToNektar.pycml.mathml_apply._cml_depends_on

private

Definition at line 4404 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._add_dependency(), CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.cellml_variable.get_all_expr_dependencies(), CellMLToNektar.pycml.cellml_variable.get_dependencies(), CellMLToNektar.pycml.mathml_apply.get_dependencies(), and CellMLToNektar.pycml.cellml_variable.get_value().

_cml_ode_has_free_var_on_rhs

CellMLToNektar.pycml.mathml_apply._cml_ode_has_free_var_on_rhs

private

Definition at line 4882 of file pycml.py.

_cml_units

CellMLToNektar.pycml.mathml_apply._cml_units

private

Definition at line 4395 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model._build_units_dictionary(), CellMLToNektar.pycml.cellml_component._build_units_dictionary(), CellMLToNektar.pycml.mathml_apply._set_in_units(), CellMLToNektar.pycml.mathml_piecewise._set_in_units(), CellMLToNektar.pycml.cellml_model.add_units(), CellMLToNektar.pycml.cellml_component.add_units(), CellMLToNektar.pycml.cellml_model.get_all_units(), CellMLToNektar.pycml.cellml_component.get_all_units(), CellMLToNektar.pycml.mathml_apply.get_units(), CellMLToNektar.pycml.mathml_piecewise.get_units(), CellMLToNektar.pycml.mathml_cn.get_units(), CellMLToNektar.pycml.mathml_ci.get_units(), CellMLToNektar.pycml.cellml_model.get_units_by_name(), CellMLToNektar.pycml.cellml_component.get_units_by_name(), and CellMLToNektar.pycml.cellml_model.has_units().

QUALIFIERS

CellMLToNektar.pycml.mathml_apply.QUALIFIERS

static

Initial value:

=  frozenset(('degree', 'bvar', 'logbase',
                            'lowlimit', 'uplimit', 'interval', 'condition',
                            'domainofapplication', 'momentabout'))

Definition at line 4374 of file pycml.py.

Referenced by CellMLToNektar.pycml.mathml_apply._is_qualifier().