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)

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 )

Reimplemented from CellMLToNektar.pycml.mathml_constructor.

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
 

References CellMLToNektar.pycml.mathml_piecewise.__init__().

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

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.

    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
 

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_ci._reduce(), CellMLToNektar.pycml.mathml_apply._reduce(), CellMLToNektar.pycml.mathml_piecewise._reduce(), CellMLToNektar.pycml.cellml_variable.get_value(), and CellMLToNektar.pycml.cellml_variable.is_statically_const().

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

                           needs_special_treatment=lambda n: None):
        """Classify variables in this expression according to how they are used.
        
        In the process, compute and return a set of variables on which
        this expression depends.
 
        If 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.

    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
 
 

References CellMLToNektar.pycml.check_append_safety().

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

    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
 

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

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

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

    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
 

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

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

    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
 

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

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

◆ _cml_units

CellMLToNektar.pycml.mathml_piecewise._cml_units

private

Definition at line 5035 of file pycml.py.

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