CellMLToNektar.pycml.mathml_units_mixin_choose_nearest Class Reference

Inheritance diagram for CellMLToNektar.pycml.mathml_units_mixin_choose_nearest:

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

Detailed Description

Definition at line 3618 of file pycml.py.

Member Function Documentation

_set_in_units()

def CellMLToNektar.pycml.mathml_units_mixin_choose_nearest._set_in_units (   self,   desired_units,   no_act = False  )

private

Set the units of the application of this operator.

This mixin is used for the <times> and <divide> operators.
There are 2 possible strategies here.  One is to pick one of the
operands and convert it so that the overall units match those
required.  The other is to pick units from the set of those
possible for this application, and convert the result to the
desired units.  We go with the latter option, picking the units
that are least in the sense that they have the least multipicative
factor, but where possible that factor is no less than that on the
desired units.

Definition at line 3619 of file pycml.py.

    def _set_in_units(self, desired_units, no_act=False):
        """Set the units of the application of this operator.
 
        This mixin is used for the <times> and <divide> operators.
        There are 2 possible strategies here.  One is to pick one of the
        operands and convert it so that the overall units match those
        required.  The other is to pick units from the set of those
        possible for this application, and convert the result to the
        desired units.  We go with the latter option, picking the units
        that are least in the sense that they have the least multipicative
        factor, but where possible that factor is no less than that on the
        desired units.
        """
        app = self.xml_parent
        min_factor, best_factor = None, None
        least_units, best_units = None, None
        desired_factor = desired_units.expand().get_multiplicative_factor()
        DEBUG('validator', '>',self.localName,':',desired_factor,
              desired_units.description())
        units_set = app.get_units().get_consistent_set(desired_units)
        for possible_units in units_set:
            f = possible_units.expand().get_multiplicative_factor()
            if min_factor is None or f<min_factor:
                least_units, min_factor = possible_units, f
            if f >= desired_factor and (best_factor is None or f < best_factor):
                best_units, best_factor = possible_units, f
        if best_units is None:
            # All factors were less than that desired, so just go with the least
            units = least_units
        else:
            units = best_units
        DEBUG('validator', '\t<-',
              units.expand().get_multiplicative_factor(),
              units.description())
        # Add units conversion code
        app._add_units_conversion(app, units, desired_units, no_act)
        # Set the operand units
        for src_units_set, src_units in app.get_units()._get_sources(units):
            expr = src_units_set.get_expression()
            DEBUG('validator', '#',self.localName,':',
                  src_units.description(),expr.localName)
            self._set_element_in_units(expr, src_units, no_act)
        # Record which units we used
        if not no_act:
            app._cml_units = units
        return

References CellMLToNektar.pycml.mathml_units_mixin._set_element_in_units(), CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.pycml.get_multiplicative_factor().