CellMLToNektar.pycml.mathml_units_mixin Class Reference

MathML elements #. More...

Inheritance diagram for CellMLToNektar.pycml.mathml_units_mixin:

Collaboration diagram for CellMLToNektar.pycml.mathml_units_mixin:

Private Member Functions
def	_add_units_conversion
def	_set_element_in_units

Detailed Description

MathML elements #.

Base class for units mixin classes.

Definition at line 3469 of file pycml.py.

Member Function Documentation

def CellMLToNektar.pycml.mathml_units_mixin._add_units_conversion (   self,   expr,   defn_units,   to_units,   no_act = False  )

private

Add mathematics for an explicit units conversion.

Wraps expr in the expression
m[to_units/defn_units]*(expr-o1[defn_units]) + o2[to_units].

Definition at line 3471 of file pycml.py.

References CellMLToNektar.pycml.extract(), and CellMLToNektar.pycml.simplify().

Referenced by CellMLToNektar.pycml.mathml_units_mixin._set_element_in_units(), and CellMLToNektar.pycml.mathml_units_mixin_tokens._set_in_units().

    def _add_units_conversion(self, expr, defn_units, to_units, no_act=False):
        """Add mathematics for an explicit units conversion.

        Wraps expr in the expression
        m[to_units/defn_units]*(expr-o1[defn_units]) + o2[to_units].
        """
#         print '_add_units_conv for', element_xpath(expr), 'from', defn_units.description(), 'to', to_units.description()
        if hasattr(expr.model, '_cml_special_units_converter') and not defn_units.dimensionally_equivalent(to_units):
            # This may be a special conversion case defined by a functional curation protocol
            if no_act:
                model._cml_conversions_needed = True
                return
            else:
                expr = expr.model._cml_special_units_converter(expr, defn_units, to_units)
#             print 'post special, expr units=', expr.get_units().description(), 'm=', expr.get_units().extract().expand().simplify().get_multiplicative_factor()
#             print 'orig defn_units=', defn_units.description(), 'm=', defn_units.expand().simplify().get_multiplicative_factor()
#             print 'orig to_units=', to_units.description(), 'm=', to_units.expand().simplify().get_multiplicative_factor()
            try:
                defn_units = expr.get_units().extract(check_equality=True)
            except:
                print 'ouch', expr.xml()
                for u in expr.get_units():
                    print u.description(), u.get_multiplier(), expr.get_units()._get_sources(u)
                raise
        defn_units_exp = defn_units.expand().simplify()
        to_units_exp = to_units.expand().simplify()
        # Conversion factor
        m = (defn_units_exp.get_multiplicative_factor() / to_units_exp.get_multiplicative_factor())
        # Replace expr by  m[to_units/defn_units]*(expr-o1[defn_units]) + o2[to_units]
        orig_expr, parent = expr, expr.xml_parent
        dummy = expr.xml_create_element(u'dummy', NSS[u'm'])
        model = expr.model # So we still have a reference after the next line
        parent.replace_child(expr, dummy) # Mark where to put the new elt
        if defn_units_exp.get_offset() != 0:
            # Create expr-o1 expression
            uattr = orig_expr._ensure_units_exist(defn_units, no_act=no_act)
            new_expr = mathml_apply.create_new(expr, u'minus',
                                               [expr, (unicode(defn_units_exp.get_offset()), uattr)])
            new_expr._cml_units = defn_units
            expr = new_expr
        if m != 1:
            quotient_units = to_units.quotient(defn_units)
            # Add units element to model if needed
            uattr = orig_expr._ensure_units_exist(quotient_units, no_act=no_act)
            # Create m*expr expression
            new_expr = mathml_apply.create_new(expr, u'times', [(unicode(m), uattr), expr])
            new_expr._cml_units = to_units
            expr = new_expr
        if to_units_exp.get_offset() != 0:
            # Create expr+o2 expression
            uattr = orig_expr._ensure_units_exist(to_units, no_act=no_act)
            new_expr = mathml_apply.create_new(expr, u'plus',
                                               [expr, (unicode(to_units_exp.get_offset()), uattr)])
            new_expr._cml_units = to_units
            expr = new_expr
        # Note that the model needed conversions
        if expr is not orig_expr:
            model._cml_conversions_needed = True
        if no_act:
            expr = orig_expr
        parent.replace_child(dummy, expr)
        return