Nektar++: CellMLToNektar.pycml.mathml

CellMLToNektar.pycml.mathml_apply._get_binding_time

def operator

Definition: pycml.py:4412

def _get_binding_time

Definition: pycml.py:4934

CellMLToNektar.pycml.mathml_apply._cml_binding_time

_cml_binding_time

Definition: pycml.py:4402

CellMLToNektar.pycml.mathml_apply._get_operand_units

def operands

Definition: pycml.py:4428

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)

def _get_operand_units

Definition: pycml.py:4439

CellMLToNektar.pycml.mathml_constructor._get_element_units

def operands

Definition: pycml.py:4428

def _get_element_units

Definition: pycml.py:4068

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

CellMLToNektar.pycml.mathml_apply.QUALIFIERS

tuple QUALIFIERS

Definition: pycml.py:4374

CellMLToNektar.pycml.mathml_apply._is_qualifier

def _is_qualifier

Definition: pycml.py:4416

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

CellMLToNektar.pycml.mathml_apply._reduce

def _reduce

Definition: pycml.py:4968

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.mathml_constructor._reduce_elt

def _reduce_elt

Definition: pycml.py:4095

CellMLToNektar.pycml.mathml_constructor._eval_self

def operator

Definition: pycml.py:4412

def _eval_self

Definition: pycml.py:4108

CellMLToNektar.pycml.mathml_apply._get_binding_time

def _get_binding_time

Definition: pycml.py:4934

CellMLToNektar.pycml.mathml_constructor._update_usage_counts

def _update_usage_counts

Definition: pycml.py:4123

CellMLToNektar.pycml.mathml_apply._set_in_units

def operands

Definition: pycml.py:4428

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

def _set_in_units

Definition: pycml.py:4523

CellMLToNektar.pycml.mathml_units_mixin._set_element_in_units

def _set_element_in_units

Definition: pycml.py:3534

CellMLToNektar.pycml.UnitsError

Definition: pycml.py:3429

CellMLToNektar.pycml.UnitsSet

def operator

Definition: pycml.py:4412

Definition: pycml.py:2349

CellMLToNektar.pycml.mathml_apply._cml_units

_cml_units

Definition: pycml.py:4395

CellMLToNektar.pycml.mathml_apply.get_units

def get_units

Definition: pycml.py:4556

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

_cml_assigns_to

Definition: pycml.py:4405

CellMLToNektar.pycml.mathml_apply.assigned_variable

def is_top_level

Definition: pycml.py:4892

def assigned_variable

Definition: pycml.py:4917

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

CellMLToNektar.pycml.mathml_apply.check_assigned_var

def check_assigned_var

Definition: pycml.py:4758

CellMLToNektar.pycml.MathsError

Definition: pycml.py:3343

def operator

Definition: pycml.py:4412

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

def operands

Definition: pycml.py:4428

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.

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

CellMLToNektar.pycml.MathsError

Definition: pycml.py:3343

_cml_assigns_to

Definition: pycml.py:4405

CellMLToNektar.pycml.mathml_apply._cml_depends_on

def operator

Definition: pycml.py:4412

_cml_depends_on

Definition: pycml.py:4404

CellMLToNektar.pycml.mathml_apply._cml_ode_has_free_var_on_rhs

_cml_ode_has_free_var_on_rhs

Definition: pycml.py:4882

CellMLToNektar.utilities.Colourable.clear_colour

def operands

Definition: pycml.py:4428

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

def clear_colour

Definition: utilities.py:138

CellMLToNektar.pycml.mathml_apply.clear_dependency_info

def clear_dependency_info

Definition: pycml.py:4398

CellMLToNektar.pycml.mathml_apply._cml_depends_on

_cml_assigns_to

Definition: pycml.py:4405

_cml_depends_on

Definition: pycml.py:4404

CellMLToNektar.pycml.mathml_apply._cml_binding_time

_cml_binding_time

Definition: pycml.py:4402

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

CellMLToNektar.pycml.check_append_safety

def check_append_safety

Definition: pycml.py:197

CellMLToNektar.pycml.mathml_apply.create_new

def create_new

Definition: pycml.py:4992

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)

CellMLToNektar.pycml.mathml_apply.evaluate

def evaluate

Definition: pycml.py:4447

CellMLToNektar.pycml.EvaluationError

Definition: pycml.py:3337

CellMLToNektar.pycml.mathml_apply.get_dependencies

def operator

Definition: pycml.py:4412

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

def get_dependencies

Definition: pycml.py:4408

CellMLToNektar.pycml.mathml_apply._cml_depends_on

_cml_depends_on

Definition: pycml.py:4404

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

CellMLToNektar.pycml._child1

def _child1

Definition: pycml.py:3460

CellMLToNektar.pycml.mathml.eval

def eval

Definition: pycml.py:3791

CellMLToNektar.pycml.mathml_constructor._get_element_binding_time

def _get_element_binding_time

Definition: pycml.py:4057

CellMLToNektar.pycml.UnitsError

Definition: pycml.py:3429

CellMLToNektar.pycml.copy

def copy

Definition: pycml.py:2663

CellMLToNektar.pycml.mathml_apply._get_operand_units

def operator

Definition: pycml.py:4412

def _get_operand_units

Definition: pycml.py:4439

CellMLToNektar.pycml.UnitsSet

Definition: pycml.py:2349

CellMLToNektar.pycml.mathml_apply._cml_units

_cml_units

Definition: pycml.py:4395

CellMLToNektar.pycml.mathml_apply.get_units

def get_units

Definition: pycml.py:4556

CellMLToNektar.pycml.mathml.model

def operands

Definition: pycml.py:4428

def model

Definition: pycml.py:3785

CellMLToNektar.pycml.mathml_constructor._get_element_units

def _get_element_units

Definition: pycml.py:4068

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)

CellMLToNektar.pycml.mathml_apply.is_assignment

_cml_assigns_to

Definition: pycml.py:4405

def is_assignment

Definition: pycml.py:4907

def is_top_level

Definition: pycml.py:4892

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

_cml_assigns_to

Definition: pycml.py:4405

CellMLToNektar.pycml.mathml_apply.is_ode

def is_top_level

Definition: pycml.py:4892

def is_ode

Definition: pycml.py:4896

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

_cml_assigns_to

Definition: pycml.py:4405

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 is_top_level

Definition: pycml.py:4892

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

 
     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)

CellMLToNektar.pycml.mathml_apply._is_qualifier

def _is_qualifier

Definition: pycml.py:4416

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 operands

Definition: pycml.py:4428

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

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

CellMLToNektar.pycml._child1

def _child1

Definition: pycml.py:3460

CellMLToNektar.pycml.mathml_apply._is_qualifier

def operator

Definition: pycml.py:4412

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)

def _is_qualifier

Definition: pycml.py:4416

CellMLToNektar.pycml.mathml_apply.qualifiers

def qualifiers

Definition: pycml.py:4420

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

CellMLToNektar.pycml.mathml_constructor._tree_complexity

def _tree_complexity

Definition: pycml.py:4008

CellMLToNektar.pycml.mathml_apply.OPS

Definition: pycml.py:4378

CellMLToNektar.pycml.EvaluationError

Definition: pycml.py:3337

def operator

Definition: pycml.py:4412