CellMLToNektar.pycml.mathml_units_mixin Class Reference

MathML elements #. More...

Inheritance diagram for CellMLToNektar.pycml.mathml_units_mixin:

Private Member Functions
def	_add_units_conversion (self, expr, defn_units, to_units, no_act=False)
def	_set_element_in_units (self, elt, units, no_act=False)

Detailed Description

MathML elements #.

Base class for units mixin classes.

Definition at line 3469 of file pycml.py.

Member Function Documentation

_add_units_conversion()

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
        

_set_element_in_units()

def CellMLToNektar.pycml.mathml_units_mixin._set_element_in_units (   self,   elt,   units,   no_act = False  )

private

Try to set the units of the given element.

Generates a debug message if this isn't possible.

Definition at line 3534 of file pycml.py.

References CellMLToNektar.pycml.mathml_units_mixin._add_units_conversion(), CellMLToNektar.pycml.cellml_variable.component, CellMLToNektar.pycml.mathml.component, CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.pycml.get_units_by_name().

Referenced by CellMLToNektar.pycml.mathml_units_mixin_set_operands._set_in_units(), CellMLToNektar.pycml.mathml_units_mixin_equalise_operands._set_in_units(), CellMLToNektar.pycml.mathml_units_mixin_choose_nearest._set_in_units(), CellMLToNektar.pycml.mathml_units_mixin_container._set_in_units(), CellMLToNektar.pycml.mathml_apply._set_in_units(), CellMLToNektar.pycml.mathml_piecewise._set_in_units(), CellMLToNektar.pycml.mathml_power._set_in_units(), CellMLToNektar.pycml.mathml_root._set_in_units(), and CellMLToNektar.pycml.mathml_eq._set_in_units().

    def _set_element_in_units(self, elt, units, no_act=False):
        """Try to set the units of the given element.

        Generates a debug message if this isn't possible.
        """
        if hasattr(elt, '_set_in_units') and callable(elt._set_in_units):
            elt._set_in_units(units, no_act)
        elif elt.localName in [u'false', u'true']:
            boolean = self.component.get_units_by_name('cellml:boolean')
            if boolean is not units:
                # TODO: *blink* this should never happen
                self._add_units_conversion(elt, boolean, units, no_act)
        elif elt.localName in [u'notanumber', u'pi', u'infinity', u'exponentiale']:
            dimensionless = self.component.get_units_by_name('dimensionless')
            if dimensionless is not units:
                # TODO: *blink* this should never happen
                self._add_units_conversion(elt, dimensionless, units, no_act)
        else:
            DEBUG('validator',
                  'Cannot set units (to', units.description(), ') for element', elt.localName)
        return