Inheritance diagram for CellMLToNektar.processors.UnitsConverter:

[legend]

Public Member Functions
def	__init__ (self, model, warn_only=None, show_xml_context_only=False)

def	__del__ (self)

def	try_convert (self, func, args, *kwargs)

def	add_special_conversion (self, from_units, to_units, converter)

def	modify_rhs (self, expr, operator, var)

def	times_rhs_by (self, expr, var)

def	divide_rhs_by (self, expr, var)

def	convert_assignments (self, exprs)

def	convert_constant (self, value, from_units, to_units, comp)

def	convert_mapping (self, mapping, comp1, comp2, var1, var2)

def	convert_connections (self, connections)

def	add_conversions_for_component (self, comp)

def	add_all_conversions (self)

Public Member Functions inherited from CellMLToNektar.processors.ModelModifier
def	__init__ (self, model)

def	finalize (self, error_handler, pre_units_check_hook=None, check_units=True)

def	create_new_component (self, cname)

def	connect_variables (self, source, target)

def	remove_connection (self, var1, var2)

def	remove_connections (self, var)

def	add_variable (self, comp, vname, units, **kwargs)

def	add_units (self, units)

def	add_expr_to_comp (self, comp, expr)

def	remove_expr (self, expr)

def	remove_definition (self, var, keep_initial_value=False)

def	del_attr (self, elt, localName, ns=None)

def	set_units_converter (self, converter)

def	get_units_converter (self)

Public Attributes
	warn_only

	show_xml_context_only

	special_conversions

Public Attributes inherited from CellMLToNektar.processors.ModelModifier
	model

	connections_made

Private Member Functions
def	_setup_logger (self)

def	_cleanup_logger (self)

def	_apply_special_conversion_for_nested_expr (self, expr, defn_units, desired_units)

def	_check_special_conversion (self, expr)

Private Attributes
	_converted_mappings

	_log_handler

Detailed Description

Top-level interface to the units conversion code in PyCml.

Definition at line 749 of file processors.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.processors.UnitsConverter.__init__	(	self,
		model,
		warn_only = `None`,
		show_xml_context_only = `False`
	)

Constructor.

Reimplemented from CellMLToNektar.processors.ModelModifier.

Definition at line 752 of file processors.py.

    def __init__(self, model, warn_only=None, show_xml_context_only=False):
        super(UnitsConverter, self).__init__(model)
        if warn_only is None:
            warn_only = model.get_option('warn_on_units_errors')
        self.warn_only = warn_only
        self.show_xml_context_only = show_xml_context_only
        self.special_conversions = {}
        self._setup_logger()
        self._converted_mappings = set()
    

References CellMLToNektar.processors.UnitsConverter.__init__().

Referenced by CellMLToNektar.processors.UnitsConverter.__init__().

◆ del()

def CellMLToNektar.processors.UnitsConverter.__del__ ( self )

Definition at line 762 of file processors.py.

    def __del__(self):
        self._cleanup_logger()
        

References CellMLToNektar.processors.UnitsConverter._cleanup_logger().

Member Function Documentation

◆ _apply_special_conversion_for_nested_expr()

def CellMLToNektar.processors.UnitsConverter._apply_special_conversion_for_nested_expr	(	self,
		expr,
		defn_units,
		desired_units
	)

private

Apply a special conversion to the given (sub-)expression.

This will get called by mathml_units_mixin._add_units_conversion if a special conversion is required by a nested sub-expression.

Definition at line 792 of file processors.py.

    def _apply_special_conversion_for_nested_expr(self, expr, defn_units, desired_units):
        """Apply a special conversion to the given (sub-)expression.
        
        This will get called by mathml_units_mixin._add_units_conversion if a special conversion is required by a nested sub-expression.
        """
        for from_units, to_units in self.special_conversions.iterkeys():
            if (from_units.dimensionally_equivalent(defn_units)
                and to_units.dimensionally_equivalent(desired_units)):
                # We can apply this conversion
                expr = self.special_conversions[(from_units, to_units)](expr)
                DEBUG('units-converter', "Used nested special conversion from", repr(from_units), "to", repr(to_units))#, "giving", expr.xml())
                break
#         else:
#             print "No on nested conv from", repr(from_units), "to", repr(to_units)
        return expr
 

References CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.processors.UnitsConverter.special_conversions.

Referenced by CellMLToNektar.processors.UnitsConverter.add_conversions_for_component().

◆ _check_special_conversion()

def CellMLToNektar.processors.UnitsConverter._check_special_conversion	(	self,
		expr
	)

private

Check whether a special conversion applies to the given assignment.

Special conversions allow us to do units conversion between dimensionally non-equivalent
quantities, by utilising biological knowledge.  Available special conversions are added
using the add_special_conversion method.

Definition at line 808 of file processors.py.

    def _check_special_conversion(self, expr):
        """Check whether a special conversion applies to the given assignment.
        
        Special conversions allow us to do units conversion between dimensionally non-equivalent
        quantities, by utilising biological knowledge.  Available special conversions are added
        using the add_special_conversion method.
        """
        lhs_units = expr.eq.lhs.get_units()
        rhs_units = expr.eq.rhs.get_units()
        if lhs_units.dimensionally_equivalent(rhs_units):
            return
        for from_units, to_units in self.special_conversions.iterkeys():
            if (from_units.dimensionally_equivalent(rhs_units)
                and to_units.dimensionally_equivalent(lhs_units)):
                # We can apply this conversion
                self.special_conversions[(from_units, to_units)](expr)
                DEBUG('units-converter', "Used special conversion from", repr(from_units), "to", repr(to_units))#, "giving", expr.xml())
                break
#         else:
#             print "No on conv from", repr(from_units), "to", repr(to_units)
 

References CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.processors.UnitsConverter.special_conversions.

Referenced by CellMLToNektar.processors.UnitsConverter.convert_assignments(), and CellMLToNektar.processors.UnitsConverter.convert_constant().

◆ _cleanup_logger()

def CellMLToNektar.processors.UnitsConverter._cleanup_logger ( self )

private

Flush logger & remove handler.

Definition at line 774 of file processors.py.

    def _cleanup_logger(self):
        """Flush logger & remove handler."""
        logger = logging.getLogger('units-converter')
        self._log_handler.flush()
        logger.removeHandler(self._log_handler)
 

References CellMLToNektar.processors.UnitsConverter._log_handler.

Referenced by CellMLToNektar.processors.UnitsConverter.__del__().

◆ _setup_logger()

def CellMLToNektar.processors.UnitsConverter._setup_logger ( self )

private

Definition at line 765 of file processors.py.

    def _setup_logger(self):
        logger = logging.getLogger('units-converter')
        logger.setLevel(logging.WARNING)
        formatter = logging.Formatter(fmt="%(name)s: %(message)s")
        handler = logging.StreamHandler(sys.stderr)
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        self._log_handler = handler
    

◆ add_all_conversions()

def CellMLToNektar.processors.UnitsConverter.add_all_conversions ( self )

Add all units conversions required in the given model.

Definition at line 1011 of file processors.py.

    def add_all_conversions(self):
        """Add all units conversions required in the given model."""
        model = self.model
        # Mathematical expressions
        self.convert_assignments(model.get_assignments())
        # Connections
        for conn in getattr(model, u'connection', []):
            comp1 = model.get_component_by_name(conn.map_components.component_1)
            comp2 = model.get_component_by_name(conn.map_components.component_2)
            for mapping in conn.map_variables:
                var1 = model.get_variable_by_name(comp1.name, mapping.variable_1)
                var2 = model.get_variable_by_name(comp2.name, mapping.variable_2)
                self.convert_mapping(mapping, comp1, comp2, var1, var2)
        return

References CellMLToNektar.processors.UnitsConverter.convert_assignments(), CellMLToNektar.processors.UnitsConverter.convert_mapping(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

◆ add_conversions_for_component()

def CellMLToNektar.processors.UnitsConverter.add_conversions_for_component	(	self,
		comp
	)

Add all units conversions required by the given component.

This allows us to only apply the conversions required by an interface component created
by an InterfaceGenerator.

Definition at line 987 of file processors.py.

    def add_conversions_for_component(self, comp):
        """Add all units conversions required by the given component.
        
        This allows us to only apply the conversions required by an interface component created
        by an InterfaceGenerator.
        """
        model = self.model
        if self.special_conversions:
            self.model._cml_special_units_converter = self._apply_special_conversion_for_nested_expr
        assignments = model.search_for_assignments(comp)
        self.convert_assignments(assignments)
        if self.special_conversions:
            del self.model._cml_special_units_converter
        for conn in getattr(model, u'connection', []):
            cname1 = conn.map_components.component_1
            cname2 = conn.map_components.component_2
            if comp.name in [cname1, cname2]:
                comp1 = model.get_component_by_name(cname1)
                comp2 = model.get_component_by_name(cname2)
                for mapping in conn.map_variables:
                    var1 = model.get_variable_by_name(cname1, mapping.variable_1)
                    var2 = model.get_variable_by_name(cname2, mapping.variable_2)
                    self.convert_mapping(mapping, comp1, comp2, var1, var2)
    

References CellMLToNektar.processors.UnitsConverter._apply_special_conversion_for_nested_expr(), CellMLToNektar.processors.UnitsConverter.convert_assignments(), CellMLToNektar.processors.UnitsConverter.convert_mapping(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.processors.UnitsConverter.special_conversions.

◆ add_special_conversion()

def CellMLToNektar.processors.UnitsConverter.add_special_conversion	(	self,
		from_units,
		to_units,
		converter
	)

Add a new special conversion to the list available.

Special conversions allow us to do units conversion between dimensionally non-equivalent
quantities, by utilising biological knowledge.  The function "converter" will be called with
an assignment (top-level mathml_apply instance) that has RHS units equivalent to from_units,
and LHS units equivalent to to_units.  It should alter the equation in-place (i.e. the
object passed to it must contain the final equation) to do an appropriate units conversion,
at least so that LHS and RHS dimensions match.

Definition at line 829 of file processors.py.

    def add_special_conversion(self, from_units, to_units, converter):
        """Add a new special conversion to the list available.
        
        Special conversions allow us to do units conversion between dimensionally non-equivalent
        quantities, by utilising biological knowledge.  The function "converter" will be called with
        an assignment (top-level mathml_apply instance) that has RHS units equivalent to from_units,
        and LHS units equivalent to to_units.  It should alter the equation in-place (i.e. the
        object passed to it must contain the final equation) to do an appropriate units conversion,
        at least so that LHS and RHS dimensions match.
        """
        self.special_conversions[(from_units, to_units)] = converter
    

References CellMLToNektar.processors.UnitsConverter.special_conversions.

◆ convert_assignments()

def CellMLToNektar.processors.UnitsConverter.convert_assignments	(	self,
		exprs
	)

Apply conversions to any assignments in the given iterable.

Definition at line 889 of file processors.py.

    def convert_assignments(self, exprs):
        """Apply conversions to any assignments in the given iterable."""
        boolean = self.model.get_units_by_name('cellml:boolean')
        for expr in exprs:
            if isinstance(expr, mathml_apply):
#                 print 'Converting? assignment', element_xpath(expr)
                if self.special_conversions:
                    self.try_convert(self._check_special_conversion, expr)
                self.try_convert(expr._set_in_units, boolean)
    

References CellMLToNektar.processors.UnitsConverter._check_special_conversion(), CellMLToNektar.pycml.get_units_by_name(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.processors.UnitsConverter.special_conversions, and CellMLToNektar.processors.UnitsConverter.try_convert().

Referenced by CellMLToNektar.processors.UnitsConverter.add_all_conversions(), CellMLToNektar.processors.UnitsConverter.add_conversions_for_component(), and CellMLToNektar.processors.UnitsConverter.convert_mapping().

◆ convert_connections()

def CellMLToNektar.processors.UnitsConverter.convert_connections	(	self,
		connections
	)

Add units conversions for all connections in the given set.

:param connections: a set of variable pairs representing connections.  For each pair of variables a units conversion
will be added if needed and not already performed.

Definition at line 971 of file processors.py.

    def convert_connections(self, connections):
        """Add units conversions for all connections in the given set.
        
        :param connections: a set of variable pairs representing connections.  For each pair of variables a units conversion
        will be added if needed and not already performed.
        """
        model = self.model
        for conn in getattr(model, u'connection', []):
            comp1 = model.get_component_by_name(conn.map_components.component_1)
            comp2 = model.get_component_by_name(conn.map_components.component_2)
            for mapping in conn.map_variables:
                var1 = model.get_variable_by_name(comp1.name, mapping.variable_1)
                var2 = model.get_variable_by_name(comp2.name, mapping.variable_2)
                if frozenset([var1, var2]) in connections:
                    self.convert_mapping(mapping, comp1, comp2, var1, var2)
    

References CellMLToNektar.processors.UnitsConverter.convert_mapping(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

◆ convert_constant()

def CellMLToNektar.processors.UnitsConverter.convert_constant	(	self,
		value,
		from_units,
		to_units,
		comp
	)

Convert a constant value into desired units.

Definition at line 899 of file processors.py.

    def convert_constant(self, value, from_units, to_units, comp):
        """Convert a constant value into desired units."""
        from_units = self.add_units(from_units)
        to_units = self.add_units(to_units)
        expr = mathml_apply.create_new(self.model, u'eq', [(u'0', to_units.name),
                                                           (unicode(value), from_units.name)])
        self.add_expr_to_comp(comp, expr)
        # Nasty hack to make expr.is_top_level return True
        expr._cml_assigns_to = expr.operands().next()
        if self.special_conversions:
            self.try_convert(self._check_special_conversion, expr)
        self.try_convert(expr.eq.rhs._set_in_units, to_units)
        self.remove_expr(expr)
        return expr.eq.rhs.evaluate()
 

References CellMLToNektar.processors.UnitsConverter._check_special_conversion(), CellMLToNektar.processors.ModelModifier.add_expr_to_comp(), CellMLToNektar.pycml.cellml_model.add_units(), CellMLToNektar.pycml.cellml_component.add_units(), CellMLToNektar.processors.ModelModifier.add_units(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.processors.ModelModifier.remove_expr(), CellMLToNektar.processors.UnitsConverter.special_conversions, and CellMLToNektar.processors.UnitsConverter.try_convert().

◆ convert_mapping()

def CellMLToNektar.processors.UnitsConverter.convert_mapping	(	self,
		mapping,
		comp1,
		comp2,
		var1,
		var2
	)

Apply conversions to a mapping between two variables.

Definition at line 914 of file processors.py.

    def convert_mapping(self, mapping, comp1, comp2, var1, var2):
        """Apply conversions to a mapping between two variables."""
        model = self.model
        # Check for being already converted
        var_pair = frozenset([var1, var2])
        if var_pair in self._converted_mappings:
            DEBUG('units-converter', 'Skipping already converted mapping', var1, '<->', var2)
            return
        else:
            self._converted_mappings.add(var_pair)
        # Ensure mapping is var1 := var2; swap vars if needed
        swapped = False
        try:
            if var2.get_source_variable() is var1:
                swapped = True
                var1, var2 = var2, var1
                comp1, comp2 = comp2, comp1
        except TypeError:
            pass
        # Get units
        u1 = var1.get_units()
        u2 = var2.get_units()
        DEBUG('units-converter', "Converting mapping of", var1, ":=", var2,
              "(units:", repr(u1), repr(u2), ")")
        if not u1.equals(u2):
            # We need a conversion
            # Add a copy of var1 to comp1, with units as var2
            if getattr(var1, u'public_interface', '') == u'in':
                in_interface = u'public'
            else:
                in_interface = u'private'
            var1_converter = self.add_variable(comp1, var1.name + u'_converter', u2, interfaces={in_interface: u'in'})
            var1._cml_var_type = VarTypes.Computed
            var1._cml_source_var = None
            delattr(var1, in_interface + u'_interface')
            var1_converter._set_source_variable(var2)
            # Add assignment maths for var1 := var1_converter
            app = mathml_apply.create_new(model, u'eq', [var1.name, var1_converter.name])
            self.add_expr_to_comp(comp1, app)
            var1._cml_depends_on = [app]
            app._cml_assigns_to = var1
            # Update mapping to var1_converter := var2
            if swapped:
                mapping.variable_2 = var1_converter.name
            else:
                mapping.variable_1 = var1_converter.name
            # Fix usage counts - var1_converter is only used by app, and so var2 usage decreases
            var1_converter._used()
            for _ in xrange(var1.get_usage_count()):
                var2._decrement_usage_count()
            # Apply units conversion to the assignment
            self.convert_assignments([app])
            # Add the assignment into the sorted list
            assignments = model.get_assignments()
            idx = assignments.index(var1)
            assignments[idx:idx+1] = [var1_converter, app]
    

References CellMLToNektar.processors.UnitsConverter._converted_mappings, CellMLToNektar.processors.ModelModifier.add_expr_to_comp(), CellMLToNektar.processors.ModelModifier.add_variable(), CellMLToNektar.processors.UnitsConverter.convert_assignments(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

Referenced by CellMLToNektar.processors.UnitsConverter.add_all_conversions(), CellMLToNektar.processors.UnitsConverter.add_conversions_for_component(), and CellMLToNektar.processors.UnitsConverter.convert_connections().

◆ divide_rhs_by()

def CellMLToNektar.processors.UnitsConverter.divide_rhs_by	(	self,
		expr,
		var
	)

Helper method of use to special units conversions.

Will modify the given expr in-place, post-dividing the RHS by a reference to the given variable
object.
Connections and variables will be added to ensure that the given variable is available in the
component in which expr appears.

Returns expr, for ease of chaining expressions.

Definition at line 877 of file processors.py.

    def divide_rhs_by(self, expr, var):
        """Helper method of use to special units conversions.
        
        Will modify the given expr in-place, post-dividing the RHS by a reference to the given variable
        object.
        Connections and variables will be added to ensure that the given variable is available in the
        component in which expr appears.
        
        Returns expr, for ease of chaining expressions.
        """
        return self.modify_rhs(expr, u'divide', var)
    

References CellMLToNektar.processors.UnitsConverter.modify_rhs().

◆ modify_rhs()

def CellMLToNektar.processors.UnitsConverter.modify_rhs	(	self,
		expr,
		operator,
		var
	)

Helper method of use to special units conversions.

Will modify the given expr in-place, replacing the RHS by an application of the given operator.
The operands will be the existing RHS and a ci element referencing the supplied variable object.
Connections and variables will be added to ensure that the given variable is available in the
component in which expr appears.

Returns expr, for ease of chaining expressions.

Definition at line 841 of file processors.py.

    def modify_rhs(self, expr, operator, var):
        """Helper method of use to special units conversions.
        
        Will modify the given expr in-place, replacing the RHS by an application of the given operator.
        The operands will be the existing RHS and a ci element referencing the supplied variable object.
        Connections and variables will be added to ensure that the given variable is available in the
        component in which expr appears.
        
        Returns expr, for ease of chaining expressions.
        """
        assert isinstance(var, cellml_variable)
        # Ensure var is available in expr's component
        local_var_name = var.name
        source_comp = var.component
        expr_comp = expr.component
        if source_comp != expr_comp:
            local_var = self.connect_variables(var, (expr_comp.name, var.fullname(cellml=True)))
            local_var_name = local_var.name
        # Change expr
        rhs = expr.eq.rhs
        expr.safe_remove_child(rhs)
        new_rhs = mathml_apply.create_new(var.model, operator, [rhs, local_var_name])
        expr.xml_append(new_rhs)
        return expr
    

References CellMLToNektar.processors.ModelModifier.connect_variables().

Referenced by CellMLToNektar.processors.UnitsConverter.divide_rhs_by(), and CellMLToNektar.processors.UnitsConverter.times_rhs_by().

◆ times_rhs_by()

def CellMLToNektar.processors.UnitsConverter.times_rhs_by	(	self,
		expr,
		var
	)

Helper method of use to special units conversions.

Will modify the given expr in-place, post-multiplying the RHS by a reference to the given variable object.
Connections and variables will be added to ensure that the given variable is available in the
component in which expr appears.

Returns expr, for ease of chaining expressions.

Definition at line 866 of file processors.py.

    def times_rhs_by(self, expr, var):
        """Helper method of use to special units conversions.
        
        Will modify the given expr in-place, post-multiplying the RHS by a reference to the given variable object.
        Connections and variables will be added to ensure that the given variable is available in the
        component in which expr appears.
        
        Returns expr, for ease of chaining expressions.
        """
        return self.modify_rhs(expr, u'times', var)
 

References CellMLToNektar.processors.UnitsConverter.modify_rhs().

◆ try_convert()

def CellMLToNektar.processors.UnitsConverter.try_convert	(		self,
			func,
		*	args,
		**	kwargs
	)

Call the given function, and log any units errors produced.

Definition at line 780 of file processors.py.

    def try_convert(self, func, *args, **kwargs):
        """Call the given function, and log any units errors produced."""
        try:
            func(*args, **kwargs)
        except UnitsError, e:
            if self.show_xml_context_only:
                e.show_xml_context_only()
            if self.warn_only:
                e.warn = True
                e.level = logging.WARNING
            logging.getLogger('units-converter').log(e.level, unicode(e).encode('UTF-8'))
 

References tinysimd.log(), CellMLToNektar.processors.UnitsConverter.show_xml_context_only, CellMLToNektar.pycml.MathsError.show_xml_context_only(), and CellMLToNektar.processors.UnitsConverter.warn_only.

Referenced by CellMLToNektar.processors.UnitsConverter.convert_assignments(), and CellMLToNektar.processors.UnitsConverter.convert_constant().

Member Data Documentation

◆ _converted_mappings

CellMLToNektar.processors.UnitsConverter._converted_mappings

private

Definition at line 760 of file processors.py.

Referenced by CellMLToNektar.processors.UnitsConverter.convert_mapping().

◆ _log_handler

CellMLToNektar.processors.UnitsConverter._log_handler

private

Definition at line 772 of file processors.py.

Referenced by CellMLToNektar.processors.UnitsConverter._cleanup_logger().

◆ show_xml_context_only

CellMLToNektar.processors.UnitsConverter.show_xml_context_only

Definition at line 757 of file processors.py.

Referenced by CellMLToNektar.processors.UnitsConverter.try_convert().

◆ special_conversions

CellMLToNektar.processors.UnitsConverter.special_conversions

Definition at line 758 of file processors.py.

Referenced by CellMLToNektar.processors.UnitsConverter._apply_special_conversion_for_nested_expr(), CellMLToNektar.processors.UnitsConverter._check_special_conversion(), CellMLToNektar.processors.UnitsConverter.add_conversions_for_component(), CellMLToNektar.processors.UnitsConverter.add_special_conversion(), CellMLToNektar.processors.UnitsConverter.convert_assignments(), and CellMLToNektar.processors.UnitsConverter.convert_constant().

◆ warn_only

CellMLToNektar.processors.UnitsConverter.warn_only

Definition at line 756 of file processors.py.

Referenced by CellMLToNektar.processors.UnitsConverter.try_convert().

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

◆ __del__()

Member Function Documentation

◆ _apply_special_conversion_for_nested_expr()

◆ _check_special_conversion()

◆ _cleanup_logger()

◆ _setup_logger()

◆ add_all_conversions()

◆ add_conversions_for_component()

◆ add_special_conversion()

◆ convert_assignments()

◆ convert_connections()

◆ convert_constant()

◆ convert_mapping()

◆ divide_rhs_by()

◆ modify_rhs()

◆ times_rhs_by()

◆ try_convert()

Member Data Documentation

◆ _converted_mappings

◆ _log_handler

◆ show_xml_context_only

◆ special_conversions

◆ warn_only

◆ init()

◆ del()