Inheritance diagram for CellMLToNektar.pycml.mathml_apply:

[legend]

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)

Public Member Functions inherited from CellMLToNektar.pycml.mathml_constructor
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 )

Definition at line 4393 of file pycml.py.

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

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.

References CellMLToNektar.pycml.cellml_variable._cml_binding_time, CellMLToNektar.pycml.mathml_apply._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_apply._reduce(), and CellMLToNektar.pycml.mathml_piecewise._reduce().

     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
 

◆ _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.

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().

     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)
 

◆ _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.

References CellMLToNektar.pycml.mathml_apply.QUALIFIERS.

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

     def _is_qualifier(self, element):
         """Return True iff element is a qualifier element."""
         return element.localName in self.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.

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_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().

     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
 

◆ _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()]))
 

◆ 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.

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

     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
 

◆ 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.

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

     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".']))
 

◆ 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 4786 of file pycml.py.

References CellMLToNektar.pycml.mathml_apply._cml_assigns_to, CellMLToNektar.processors.ModelModifier.model, Nektar::NekMeshUtils::CADSystemCFI.model, CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.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_apply.check_assigned_var().

                            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
 

◆ 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()
 

◆ 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.

References CellMLToNektar.pycml.check_append_safety().

     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
 

◆ 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.

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

Referenced by CellMLToNektar.pycml.mathml_constructor._eval_self().

     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)
 

◆ 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.

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

     def get_dependencies(self):
         """Return the list of variables this expression depends on."""
         return self._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.

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().

     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
 

◆ 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.

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

     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)
 

◆ 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.

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

     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
 

◆ 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.

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().

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

◆ 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.

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(), and CellMLToNektar.pycml.mathml_apply.tree_complexity().

     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)
 

◆ operator()

def CellMLToNektar.pycml.mathml_apply.operator ( self )

Return the element representing the operator being applied.

Definition at line 4412 of file pycml.py.

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(), and CellMLToNektar.pycml.mathml_apply.tree_complexity().

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

◆ 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.

References CellMLToNektar.pycml.mathml_apply._is_qualifier().

     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)
 

◆ 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.

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().

     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
 

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.mathml_apply._get_binding_time(), and CellMLToNektar.pycml.mathml_piecewise._get_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.mathml_apply.get_dependencies().

◆ _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.mathml_apply._set_in_units(), CellMLToNektar.pycml.mathml_piecewise._set_in_units(), CellMLToNektar.pycml.mathml_apply.get_units(), and CellMLToNektar.pycml.mathml_piecewise.get_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().

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _get_binding_time()

◆ _get_operand_units()

◆ _is_qualifier()

◆ _reduce()

◆ _set_in_units()

◆ assigned_variable()

◆ check_assigned_var()

◆ classify_variables()

◆ clear_dependency_info()

◆ create_new()

◆ evaluate()

◆ get_dependencies()

◆ get_units()

◆ is_assignment()

◆ is_ode()

◆ is_top_level()

◆ operands()

◆ operator()

◆ qualifiers()

◆ tree_complexity()

Member Data Documentation

◆ _cml_assigns_to

◆ _cml_binding_time

◆ _cml_depends_on

◆ _cml_ode_has_free_var_on_rhs

◆ _cml_units

◆ QUALIFIERS

◆ init()