Inheritance diagram for CellMLToNektar.pycml.mathml_piecewise:

[legend]

Public Member Functions
def	__init__ (self)

def	tree_complexity (self, kw)

def	get_units (self)

def	classify_variables (self, dependencies_only=False, needs_special_treatment=lambda n:None)

def	evaluate (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, pieces, otherwise=None)

Static Public Member Functions inherited from CellMLToNektar.pycml.mathml
def	clone (expr)

Private Member Functions
def	_set_in_units (self, units, no_act=False)

def	_get_binding_time (self)

def	_reduce (self, check_operator=True)

Private Attributes
	_cml_units

	_cml_binding_time

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

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.pycml.mathml_piecewise.__init__ ( self )

Definition at line 5033 of file pycml.py.

     def __init__(self):
         super(mathml_piecewise, self).__init__()
         self._cml_units = None
         self._cml_binding_time = None
 

Member Function Documentation

◆ _get_binding_time()

def CellMLToNektar.pycml.mathml_piecewise._get_binding_time ( self )

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 (some of) the conditions and cases.

Condition & case binding times are computed in the order given
in the file.  If a condition is static with value False, its
associated case is not considered.  If a condition is static
with value True, subsequent conditions & cases and the
otherwise (if present) will not be considered.

Definition at line 5228 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_binding_time, CellMLToNektar.pycml.mathml_apply._cml_binding_time, CellMLToNektar.pycml.mathml_piecewise._cml_binding_time, CellMLToNektar.pycml.mathml_constructor._get_element_binding_time(), CellMLToNektar.pycml.child_i(), and CellMLToNektar.pycml.mathml.eval().

Referenced by CellMLToNektar.pycml.mathml_piecewise._reduce().

     def _get_binding_time(self):
         """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 (some of) the conditions and cases.
         
         Condition & case binding times are computed in the order given
         in the file.  If a condition is static with value False, its
         associated case is not considered.  If a condition is static
         with value True, subsequent conditions & cases and the
         otherwise (if present) will not be considered.
         """
         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
 
         # Compute condition binding times
         bts = [BINDING_TIMES.static]
         for piece in getattr(self, u'piece', []):
             condition = child_i(piece, 2)
             bt = self._get_element_binding_time(condition)
             if bt is BINDING_TIMES.static:
                 cond_value = self.eval(condition)
                 if cond_value is True:
                     # Compute BT for associated case
                     bts.append(self._get_element_binding_time(
                         child_i(piece, 1)))
                     # Skip remaining conditions & otherwise
                     break
             else:
                 # Don't need to append extra statics, since bts
                 # contains at least one member that is static
                 bts.append(bt)
                 # Compute BT for associated case
                 bts.append(self._get_element_binding_time(
                     child_i(piece, 1)))
         else:
             # Consider the <otherwise> element
             if hasattr(self, u'otherwise'):
                 bts.append(self._get_element_binding_time(
                     child_i(self.otherwise, 1)))
         # Take least upper bound of appropriate binding times
         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
 

◆ _reduce()

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

private

Reduce this expression by evaluating its static parts.

Even in a dynamic conditional, where a condition is static and
evaluates to False, the associated case is discarded.

Definition at line 5285 of file pycml.py.

     def _reduce(self, check_operator=True):
         """Reduce this expression by evaluating its static parts.
 
         Even in a dynamic conditional, where a condition is static and
         evaluates to False, the associated case is discarded.
         """
         # Element to replace this <piecewise> with, if any
         new_elt = None
         if self._get_binding_time() == BINDING_TIMES.static:
             # Evaluate self and replace by a <cn>, <true> or <false>
             new_elt = self._eval_self()
         elif self._get_binding_time() == BINDING_TIMES.dynamic:
             # Go through pieces and reduce where appropriate
             deletable_pieces = []
             found_dynamic_piece = False
             for piece in getattr(self, u'piece', []):
                 condition = child_i(piece, 2)
                 bt = self._get_element_binding_time(condition)
                 if bt is BINDING_TIMES.static:
                     cond_value = self.eval(condition)
                     if cond_value is True:
                         if not found_dynamic_piece:
                             # Replace the entire piecewise element by our case
                             # We don't replace if a previous piece had a
                             # dynamic condition, since this would change
                             # execution order, which could alter the semantics.
                             new_elt = child_i(piece, 1)
                             break
                     else:
                         # Discard this condition & case
                         deletable_pieces.append(piece)
                 elif bt is BINDING_TIMES.dynamic:
                     found_dynamic_piece = True
                     # Reduce the condition & case
                     self._reduce_elt(condition)
                     self._reduce_elt(child_i(piece, 1))
             else:
                 # Didn't replace entire conditional
                 # Remove pieces with False conditions
                 for piece in deletable_pieces:
                     self._update_usage_counts(piece, remove=True)
                     self.xml_remove_child(piece)
                 # Consider the <otherwise> element
                 if hasattr(self, u'otherwise'):
                     if not found_dynamic_piece:
                         # All the <piece> elements were removed, so replace
                         # the entire conditional by this <otherwise>
                         new_elt = child_i(self.otherwise, 1)
                     else:
                         # Just reduce the <otherwise>
                         self._reduce_elt(child_i(self.otherwise, 1))
         # Replace this element, if required
         if new_elt is not None:
             # Update usage counts for removed expressions
             for piece in getattr(self, u'piece', []):
                 if not new_elt is child_i(piece, 1):
                     self._update_usage_counts(piece, remove=True)
                 else:
                     # Condition is being removed
                     self._update_usage_counts(child_i(piece, 2), remove=True)
                     piece.xml_remove_child(child_i(piece, 2))
                     piece.xml_remove_child(new_elt)
             if hasattr(self, u'otherwise') and \
                not new_elt is child_i(self.otherwise, 1):
                 self._update_usage_counts(child_i(self.otherwise, 1),
                                           remove=True)
             # Do the replace
             self._xfer_complexity(new_elt)
             self.replace_child(self, new_elt, self.xml_parent)
             # May need to reduce our replacement
             self._reduce_elt(new_elt)
 

◆ _set_in_units()

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

private

Set the units this expression should be given in.

This is done recursively by setting the units for each option.

We also set the units on each condition to be boolean, since
subexpressions of the conditions may need units conversions added.

Definition at line 5106 of file pycml.py.

     def _set_in_units(self, units, no_act=False):
         """Set the units this expression should be given in.
 
         This is done recursively by setting the units for each option.
         
         We also set the units on each condition to be boolean, since
         subexpressions of the conditions may need units conversions added.
         """
         # First, record our units
         if not no_act:
             self._cml_units = units
         # Now process our children
         boolean = self.model.get_units_by_name(u'cellml:boolean')
         for piece in getattr(self, u'piece', []):
             self._set_element_in_units(child_i(piece, 1), units, no_act)
             self._set_element_in_units(child_i(piece, 2), boolean, no_act)
         if hasattr(self, u'otherwise'):
             self._set_element_in_units(child_i(self.otherwise, 1), units, no_act)
 

◆ classify_variables()

def CellMLToNektar.pycml.mathml_piecewise.classify_variables	(	self,
		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 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 5177 of file pycml.py.

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

                            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 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()
         pieces = list(getattr(self, u'piece', []))
         if hasattr(self, u'otherwise'):
             pieces.append(self.otherwise)
         for piece in pieces:
             dependencies.update(self.classify_child_variables(piece, dependencies_only=dependencies_only,
                                                               needs_special_treatment=needs_special_treatment))
         return dependencies
 

◆ create_new()

def CellMLToNektar.pycml.mathml_piecewise.create_new	(	elt,
		pieces,
		otherwise = `None`
	)

static

Create a new piecewise element.

elt is any element in the current document.

pieces is a list of pairs of expressions: (case, condition).

otherwise, if given, is the default case.

Definition at line 5358 of file pycml.py.

References CellMLToNektar.pycml.check_append_safety().

     def create_new(elt, pieces, otherwise=None):
         """Create a new piecewise element.
 
         elt is any element in the current document.
 
         pieces is a list of pairs of expressions: (case, condition).
 
         otherwise, if given, is the default case.
         """
         piecewise = elt.xml_create_element(u'piecewise', NSS[u'm'])
         for piece in pieces:
             case, cond = piece
             check_append_safety(case)
             check_append_safety(cond)
             piece_elt = elt.xml_create_element(u'piece', NSS[u'm'])
             piece_elt.xml_append(case)
             piece_elt.xml_append(cond)
             piecewise.xml_append(piece_elt)
         if otherwise:
             check_append_safety(otherwise)
             otherwise_elt = elt.xml_create_element(u'otherwise', NSS[u'm'])
             otherwise_elt.xml_append(otherwise)
             piecewise.xml_append(otherwise_elt)
         return piecewise
 
 

◆ evaluate()

def CellMLToNektar.pycml.mathml_piecewise.evaluate ( self )

Evaluate this piecewise expression.

Tests choices in the order they occur in the file.
Only evaluates a choice if its condition evaluates to True.

Definition at line 5205 of file pycml.py.

References CellMLToNektar.pycml._child1(), CellMLToNektar.pycml.child_i(), and CellMLToNektar.pycml.mathml.eval().

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

     def evaluate(self):
         """Evaluate this piecewise expression.
 
         Tests choices in the order they occur in the file.
         Only evaluates a choice if its condition evaluates to True.
         """
         for piece in getattr(self, u'piece', []):
             condition = child_i(piece, 2)
             cond_value = self.eval(condition)
             if cond_value is True:
                 # This is the option to take
                 value = self.eval(child_i(piece, 1))
                 break
         else:
             # Evaluate the <otherwise>
             if hasattr(self, u'otherwise'):
                 value = self.eval(_child1(self.otherwise))
             else:
                 raise EvaluationError(u' '.join([
                     "A piecewise element where the pieces aren't mutually",
                     "exhaustive requires an otherwise element."]))
         return value
 

◆ get_units()

def CellMLToNektar.pycml.mathml_piecewise.get_units ( self )

Recursively check this expression for dimensional consistency.

The first child elements of each <piece> and <otherwise> element
should have dimensionally equivalent units (the resulting <units>
element will be dimensionally equivalent to these).  The second child
elements of each <piece> should have units of cellml:boolean.

If consistent, returns a <units> element for the whole expression.
Throws a UnitsError if the units are inconsistent.

Definition at line 5125 of file pycml.py.

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

     def get_units(self):
         """Recursively check this expression for dimensional consistency.
 
         The first child elements of each <piece> and <otherwise> element
         should have dimensionally equivalent units (the resulting <units>
         element will be dimensionally equivalent to these).  The second child
         elements of each <piece> should have units of cellml:boolean.
 
         If consistent, returns a <units> element for the whole expression.
         Throws a UnitsError if the units are inconsistent.
         """
         if self._cml_units:
             return self._cml_units
         # Check the second child of each <piece> element
         boolean = self.model.get_units_by_name(u'cellml:boolean')
         for piece in getattr(self, u'piece', []):
             cond_elt = child_i(piece, 2)
             units = self._get_element_units(cond_elt)
             if not boolean in units:
                 raise UnitsError(self, u' '.join([
                     u'The second child element of a <piece> element must have'
                     u'units of cellml:boolean, not',units.description()]))
         # Compare the first child element of each <piece> and the <otherwise>,
         # if present.
         our_units = None
         if hasattr(self, u'otherwise'):
             value_elt = child_i(self.otherwise, 1)
             our_units = self._get_element_units(value_elt).copy()
         for piece in getattr(self, u'piece', []):
             value_elt = child_i(piece, 1)
             if our_units is None:
                 our_units = self._get_element_units(value_elt).copy()
             else:
                 units = self._get_element_units(value_elt)
                 if not our_units.dimensionally_equivalent(units):
                     raise UnitsError(self, u' '.join([
                         u'The first child elements of children of a piecewise',
                         u'element must have dimensionally equivalent units;',
                         units.description(),'and',our_units.description(),
                         u'differ']))
                 our_units.update(units)
         # Check that we have some units for this element
         if our_units is None:
             raise UnitsError(self, u' '.join([
                 u'A piecewise element must have at least one piece or',
                 u'otherwise child in order to have defined units.']))
         # Cache & return units
         self._cml_units = our_units
         our_units.set_expression(self)
         return self._cml_units
 

◆ tree_complexity()

def CellMLToNektar.pycml.mathml_piecewise.tree_complexity	(	self,
		kw
	)

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

The real evaluation time will generally depend on run time
data, which makes things tricky.  Here we estimate by taking
the sum of the complexities of the conditions and the maximum
of the complexity of the cases, in order to obtain an upper
bound.

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.

If self.rootNode.num_lookup_tables exists, this method will
update the count of lookup tables based on this expression,
unless the argument 'count_tables' is False or algebraic is True.

Definition at line 5038 of file pycml.py.

References CellMLToNektar.pycml.mathml_constructor._tree_complexity(), CellMLToNektar.utilities.add_dicts(), CellMLToNektar.pycml.child_i(), CellMLToNektar.utilities.max_i(), and CellMLToNektar.pycml.element_base.rootNode().

     def tree_complexity(self, **kw):
         """
         Calculate a rough estimate of the computation time for
         evaluating this <piecewise> element.
 
         The real evaluation time will generally depend on run time
         data, which makes things tricky.  Here we estimate by taking
         the sum of the complexities of the conditions and the maximum
         of the complexity of the cases, in order to obtain an upper
         bound.
         
         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.
 
         If self.rootNode.num_lookup_tables exists, this method will
         update the count of lookup tables based on this expression,
         unless the argument 'count_tables' is False or algebraic is True.
         """
         kw['algebraic'] = kw.get('algebraic', False)
         alg = kw['algebraic']
         if alg: ac, piece_dicts = {}, []
         else: ac = 0
         piece_acs = []
         count_lts = hasattr(self.rootNode, 'num_lookup_tables') and kw.get('count_tables', True) and not alg
         if count_lts:
             # Alternative method of counting number of lookup tables;
             # handles the Zhang model better!
             num_lts = self.rootNode.num_lookup_tables
             piece_num_lts = []
 
         for piece in getattr(self, u'piece', []):
             test_ac = self._tree_complexity(child_i(piece, 2), **kw)
             if alg: add_dicts(ac, test_ac)
             else: ac += test_ac
             if count_lts:
                 nlts = self.rootNode.num_lookup_tables
             piece_ac = self._tree_complexity(child_i(piece, 1), **kw)
             if alg:
                 piece_dicts.append(piece_ac)
                 piece_acs.append(self._tree_complexity(child_i(piece, 1), count_tables=False))
             else:
                 piece_acs.append(piece_ac)
             if count_lts:
                 piece_num_lts.append(self.rootNode.num_lookup_tables - nlts)
         if hasattr(self, u'otherwise'):
             if count_lts:
                 nlts = self.rootNode.num_lookup_tables
             ow_ac = self._tree_complexity(child_i(self.otherwise, 1), **kw)
             if alg:
                 piece_dicts.append(ow_ac)
                 piece_acs.append(
                     self._tree_complexity(child_i(self.otherwise, 1), count_tables=False))
             else:
                 piece_acs.append(ow_ac)
             if count_lts:
                 piece_num_lts.append(self.rootNode.num_lookup_tables - nlts)
         max_idx, max_piece_ac = max_i(piece_acs)
         if alg:
             add_dicts(ac, piece_dicts[max_idx])
         else:
             ac += max_piece_ac
         if count_lts:
             self.rootNode.num_lookup_tables -= sum(piece_num_lts)
             self.rootNode.num_lookup_tables += piece_num_lts[max_idx]
         return ac
 

Member Data Documentation

◆ _cml_binding_time

CellMLToNektar.pycml.mathml_piecewise._cml_binding_time

private

Definition at line 5036 of file pycml.py.

Referenced by CellMLToNektar.pycml.mathml_piecewise._get_binding_time().

◆ _cml_units

CellMLToNektar.pycml.mathml_piecewise._cml_units

private

Definition at line 5035 of file pycml.py.

Referenced by CellMLToNektar.pycml.mathml_piecewise._set_in_units(), and CellMLToNektar.pycml.mathml_piecewise.get_units().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _get_binding_time()

◆ _reduce()

◆ _set_in_units()

◆ classify_variables()

◆ create_new()

◆ evaluate()

◆ get_units()

◆ tree_complexity()

Member Data Documentation

◆ _cml_binding_time

◆ _cml_units

◆ init()