Inheritance diagram for CellMLToNektar.processors.ModelModifier:

[legend]

Public Member Functions
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
	model

	connections_made

Private Member Functions
def	_clear_model_caches (self)

def	_make_connection (self, src_var, target_comp, target_vname)

def	_find_connection_element (self, var1, var2)

def	_create_connection_element (self, var1, var2)

def	_update_connections (self, oldVar, newVar)

def	_find_common_tail (self, l1, l2)

def	_parent_path (self, comp)

def	_process_operator (self, expr, operator, func, args, *kwargs)

def	_find_or_create_variable (self, cname, vname, source)

def	_get_units_object (self, units)

def	_uniquify_var_name (self, varname, comp)

def	_uniquify_name (self, name, callable)

def	_convert_initial_value (self, var, units, do_conversion=True)

Private Attributes
	_units_converter

Detailed Description

Base class supporting common model modification functionality.

This class contains the logic to deal with adding/deleting variables, components, equations, etc.
and connecting things up.  It also handles re-analysing the model when modifications have been
completed to ensure that PyCml's internal data structures are up-to-date.

Instances should be created with the model to modify as a single parameter.  Once all
modifications have been completed, the finalize method must be called to ensure later
processing of the model (e.g. code generation) will succeed.

Definition at line 47 of file processors.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.processors.ModelModifier.__init__	(	self,
		model
	)

Constructor.

Reimplemented in CellMLToNektar.processors.InterfaceGenerator, and CellMLToNektar.processors.UnitsConverter.

Definition at line 58 of file processors.py.

    def __init__(self, model):
        """Constructor."""
        self.model = model
        self._units_converter = None
        self.connections_made = set()
        

Member Function Documentation

◆ _clear_model_caches()

def CellMLToNektar.processors.ModelModifier._clear_model_caches ( self )

private

Clear cached links in the model, since we'll need to recompute many of them
once we've finished modifying it.  Also clears dependency information.

Definition at line 100 of file processors.py.

    def _clear_model_caches(self):
        """
        Clear cached links in the model, since we'll need to recompute many of them
        once we've finished modifying it.  Also clears dependency information.
        """
        for comp in getattr(self.model, u'component', []):
            for math in getattr(comp, u'math', []):
                math._unset_cached_links()
        for var in self.model.get_all_variables():
            var.clear_dependency_info()
        assignment_exprs = self.model.search_for_assignments()
        for expr in assignment_exprs:
            expr.clear_dependency_info()
    

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

Referenced by CellMLToNektar.processors.ModelModifier.finalize().

◆ _convert_initial_value()

def CellMLToNektar.processors.ModelModifier._convert_initial_value	(	self,
		var,
		units,
		do_conversion = `True`
	)

private

Convert any initial value of the given variable into the given units.

If there is no initial value, returns None.
If there is no units converter, leaves the initial_value unchanged.

Definition at line 513 of file processors.py.

    def _convert_initial_value(self, var, units, do_conversion=True):
        """Convert any initial value of the given variable into the given units.
        
        If there is no initial value, returns None.
        If there is no units converter, leaves the initial_value unchanged.
        """
        if not hasattr(var, u'initial_value'):
            return None
        value = var.initial_value
        if value and self._units_converter and do_conversion:
            if not var.get_units().equals(units):
                try:
                    value = self._units_converter.convert_constant(value, var.get_units(), units, var.component)
                except EvaluationError, e:
                    raise ModelModificationError("Cannot units-convert initial value as requires run-time information:\n"
                                                 + str(e))
        return unicode(value)
 
 
 

References CellMLToNektar.processors.ModelModifier._units_converter, and CellMLToNektar.pycml.equals().

Referenced by CellMLToNektar.processors.InterfaceGenerator.add_input().

◆ _create_connection_element()

def CellMLToNektar.processors.ModelModifier._create_connection_element	(	self,
		var1,
		var2
	)

private

Create a connection element connecting the given variables and add to the model.

If there's already a connection element for the relevant pair of components,
we just add another map_variables element to that.

Definition at line 249 of file processors.py.

    def _create_connection_element(self, var1, var2):
        """Create a connection element connecting the given variables and add to the model.
        
        If there's already a connection element for the relevant pair of components,
        we just add another map_variables element to that.
        """
        conn, swap = self._find_connection_element(var1, var2)
        if conn:
            if swap:
                var1, var2 = var2, var1
        else:
            conn = var1.xml_create_element(u'connection', NSS[u'cml'])
            mapc = var1.xml_create_element(u'map_components', NSS[u'cml'],
                                           attributes={u'component_1': var1.component.name,
                                                       u'component_2': var2.component.name})
            conn.xml_append(mapc)
            self.model.xml_append(conn)
        mapv = var1.xml_create_element(u'map_variables', NSS[u'cml'],
                                       attributes={u'variable_1': var1.name,
                                                   u'variable_2': var2.name})
        conn.xml_append(mapv)
    

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

Referenced by CellMLToNektar.processors.ModelModifier._make_connection().

◆ _find_common_tail()

def CellMLToNektar.processors.ModelModifier._find_common_tail	(	self,
		l1,
		l2
	)

private

Find the first element at which both lists are identical from then on.

Definition at line 327 of file processors.py.

    def _find_common_tail(self, l1, l2):
        """Find the first element at which both lists are identical from then on."""
        i = -1
        try:
            while l1[i] == l2[i]:
                i -= 1
        except IndexError:
            # One list is the tail of the other
            pass
        # i now gives the last differing element
        assert i < -1
        return i+1
        

Referenced by CellMLToNektar.processors.ModelModifier.connect_variables().

◆ _find_connection_element()

def CellMLToNektar.processors.ModelModifier._find_connection_element	(	self,
		var1,
		var2
	)

private

Find any connection element containing a connection of the given variables.

Returns a pair, the first element of which is either the element or None, and the
second of which is a boolean indicating whether the variables need to be swapped
in order to match the order of the components in the connection.

Definition at line 228 of file processors.py.

    def _find_connection_element(self, var1, var2):
        """Find any connection element containing a connection of the given variables.
        
        Returns a pair, the first element of which is either the element or None, and the
        second of which is a boolean indicating whether the variables need to be swapped
        in order to match the order of the components in the connection.
        """
        cn1, cn2 = var1.component.name, var2.component.name
        cnames = set([cn1, cn2])
        for conn in getattr(self.model, u'connection', []):
            mc = conn.map_components
            if set([mc.component_1, mc.component_2]) == cnames:
                break
        else:
            conn = None
        if conn:
            swap = conn.map_components.component_1 == cn2
        else:
            swap = False
        return conn, swap
    

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

Referenced by CellMLToNektar.processors.ModelModifier._create_connection_element(), and CellMLToNektar.processors.ModelModifier.remove_connection().

◆ _find_or_create_variable()

def CellMLToNektar.processors.ModelModifier._find_or_create_variable	(	self,
		cname,
		vname,
		source
	)

private

Find a given variable in the model, creating it if necessary.

We look for a variable in the component named cname with the same name as the source.
If it doesn't exist, a variable named vname will be created in that component (unless
it already exists).
The variable will become a mapped variable with the given source.
Hence if it is created it will have the same units.

Definition at line 359 of file processors.py.

    def _find_or_create_variable(self, cname, vname, source):
        """Find a given variable in the model, creating it if necessary.
        
        We look for a variable in the component named cname with the same name as the source.
        If it doesn't exist, a variable named vname will be created in that component (unless
        it already exists).
        The variable will become a mapped variable with the given source.
        Hence if it is created it will have the same units.
        """
        try:
            var = self.model.get_variable_by_name(cname, source.name)
            raise KeyError()
        except KeyError:
            # Have we created it already?
            try:
                var = self.model.get_variable_by_name(cname, vname)
            except KeyError:
                # Create it and add to model
                units = source.component.get_units_by_name(source.units)
                var = self.add_variable(cname, vname, units)
        return var
    

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

Referenced by CellMLToNektar.processors.ModelModifier._make_connection().

◆ _get_units_object()

def CellMLToNektar.processors.ModelModifier._get_units_object	(	self,
		units
	)

private

Helper function to convert a units specification into a cellml_units object.

The input can be a cellml_units object, in which case we just return it.
However, it can also be a serialised CellML units definition, in which case it
will be parsed to create the object.

Definition at line 394 of file processors.py.

    def _get_units_object(self, units):
        """Helper function to convert a units specification into a cellml_units object.
        
        The input can be a cellml_units object, in which case we just return it.
        However, it can also be a serialised CellML units definition, in which case it
        will be parsed to create the object.
        """
        if isinstance(units, cellml_units):
            # We're done
            pass
        else:
            units = amara_parse_cellml(unicode(units))
        assert isinstance(units, cellml_units)
        return units
 

References CellMLToNektar.pycml.amara_parse_cellml().

Referenced by CellMLToNektar.processors.InterfaceGenerator.add_input(), CellMLToNektar.processors.InterfaceGenerator.add_output(), and CellMLToNektar.processors.InterfaceGenerator.add_output_function().

◆ _make_connection()

def CellMLToNektar.processors.ModelModifier._make_connection	(	self,
		src_var,
		target_comp,
		target_vname
	)

private

Make a connection from a source variable to a given component and suggested local name.

Note that in the case that both variables already exist and are connected, the existing
connection is allowed to flow in either direction.

Definition at line 180 of file processors.py.

    def _make_connection(self, src_var, target_comp, target_vname):
        """Make a connection from a source variable to a given component and suggested local name.
        
        Note that in the case that both variables already exist and are connected, the existing
        connection is allowed to flow in either direction.
        """
        src_comp = src_var.component
        target_var = self._find_or_create_variable(target_comp.name, target_vname, src_var)
        # Sanity check the target variable
        if (target_var.get_type() == VarTypes.Mapped
            and target_var.get_source_variable(recurse=True) is src_var.get_source_variable(recurse=True)):
#            print "Connection exists between", src_var, "and target", target_var
            return target_var
        elif target_var.get_type() == VarTypes.Unknown:
            # We've created this variable, so should be ok, but check for gotchas
            assert not(hasattr(target_var, u'initial_value'))
            if src_comp is target_comp.parent():
                src_if = u'private'
                target_if = u'public'
            elif src_comp.parent() is target_comp:
                src_if = u'public'
                target_if = u'private'
            else:
                assert src_comp.parent() is target_comp.parent()
                src_if = u'public'
                target_if = u'public'
                # One special case: if the src_var is actually obtained from a different
                # component at this level or above, in which case we should use the real
                # source, not that given.
                if getattr(src_var, src_if + u'_interface', u'none') == u'in':
                    src_var = src_var.get_source_variable()
            # Check and set the interface attributes
#            print "Connecting source", src_var, src_if, getattr(src_var, src_if + u'_interface', u'none'),
#            print "to", target_var, target_if, getattr(target_var, target_if + u'_interface', u'none')
            assert getattr(src_var, src_if + u'_interface', u'none') != u'in'
            assert getattr(target_var, target_if + u'_interface', u'none') != u'out'
            src_var.xml_set_attribute((src_if + u'_interface', None), u'out')
            target_var.xml_set_attribute((target_if + u'_interface', None), u'in')
            # Create the connection element
            self._create_connection_element(src_var, target_var)
            self.connections_made.add(frozenset([src_var, target_var]))
            # Ensure we handle a later connection attempt between these variables correctly
            target_var._set_source_variable(src_var)
        else:
            # Naming conflict; try again with a different target name
            return self._make_connection(src_var, target_comp, target_vname + u'_')
        return target_var
    

References CellMLToNektar.processors.ModelModifier._create_connection_element(), CellMLToNektar.processors.ModelModifier._find_or_create_variable(), CellMLToNektar.processors.ModelModifier._make_connection(), and CellMLToNektar.processors.ModelModifier.connections_made.

Referenced by CellMLToNektar.processors.ModelModifier._make_connection(), and CellMLToNektar.processors.ModelModifier.connect_variables().

◆ _parent_path()

def CellMLToNektar.processors.ModelModifier._parent_path	(	self,
		comp
	)

private

Return a path of components from that given to the encapsulation root.

The root is specified by None, since we're really dealing with a forest,
not a tree.

Definition at line 340 of file processors.py.

    def _parent_path(self, comp):
        """Return a path of components from that given to the encapsulation root.
        
        The root is specified by None, since we're really dealing with a forest,
        not a tree.
        """
        path = [comp]
        while comp:
            path.append(comp.parent())
            comp = comp.parent()
        return path
 

Referenced by CellMLToNektar.processors.ModelModifier.connect_variables().

◆ _process_operator()

def CellMLToNektar.processors.ModelModifier._process_operator	(		self,
			expr,
			operator,
			func,
		*	args,
		**	kwargs
	)

private

Apply func to any application of the given operator within the given tree.

Definition at line 352 of file processors.py.

    def _process_operator(self, expr, operator, func, *args, **kwargs):
        """Apply func to any application of the given operator within the given tree."""
        for elt in self.model.xml_element_children(expr):
            self._process_operator(elt, operator, func, *args, **kwargs)
        if isinstance(expr, mathml_apply) and expr.operator().localName == operator:
            func(expr, *args, **kwargs)
 

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

Referenced by CellMLToNektar.processors.ModelModifier._process_operator(), and CellMLToNektar.processors.InterfaceGenerator._transform_derivatives_on_rhs().

◆ _uniquify_name()

def CellMLToNektar.processors.ModelModifier._uniquify_name	(	self,
		name,
		callable
	)

private

Ensure the given name is unique within a particular context.

The context is determined by the given function: it will be passed candidate names to test
for existence, and is expected to throw iff the name is not already used.  Underscores will
be appended to the given name until callable throws, and the resulting unique name returned.

Definition at line 488 of file processors.py.

    def _uniquify_name(self, name, callable):
        """Ensure the given name is unique within a particular context.
        
        The context is determined by the given function: it will be passed candidate names to test
        for existence, and is expected to throw iff the name is not already used.  Underscores will
        be appended to the given name until callable throws, and the resulting unique name returned.
        """
        while True:
            try:
                callable(name)
                name += u'_'
            except:
                break
        return name
    

Referenced by CellMLToNektar.processors.ModelModifier._uniquify_var_name(), and CellMLToNektar.processors.ModelModifier.add_units().

◆ _uniquify_var_name()

def CellMLToNektar.processors.ModelModifier._uniquify_var_name	(	self,
		varname,
		comp
	)

private

Ensure varname is unique within the given component.

Underscores will be appended to the name until it is unique.  The unique name will be returned.

Definition at line 481 of file processors.py.

    def _uniquify_var_name(self, varname, comp):
        """Ensure varname is unique within the given component.
        
        Underscores will be appended to the name until it is unique.  The unique name will be returned.
        """
        return self._uniquify_name(varname, comp.get_variable_by_name)
    

References CellMLToNektar.processors.ModelModifier._uniquify_name().

Referenced by CellMLToNektar.processors.InterfaceGenerator._split_ode().

◆ _update_connections()

def CellMLToNektar.processors.ModelModifier._update_connections	(	self,
		oldVar,
		newVar
	)

private

Change all variables connected to oldVar to be mapped to newVar instead.

Definition at line 314 of file processors.py.

    def _update_connections(self, oldVar, newVar):
        """Change all variables connected to oldVar to be mapped to newVar instead."""
        vars = [v for v in self.model.get_all_variables() if v.get_source_variable(True) is oldVar]
        # Remove old connections, including interfaces and types so creating the new connection works
        for v in vars:
            self.remove_connections(v)
            self.del_attr(v, u'public_interface')
            self.del_attr(v, u'private_interface')
            v.clear_dependency_info()
        # Create new connections
        for v in vars:
            self.connect_variables(newVar, v)
    

References CellMLToNektar.processors.ModelModifier.connect_variables(), CellMLToNektar.processors.ModelModifier.del_attr(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.processors.ModelModifier.remove_connections().

Referenced by CellMLToNektar.processors.InterfaceGenerator.add_input().

◆ add_expr_to_comp()

def CellMLToNektar.processors.ModelModifier.add_expr_to_comp	(	self,
		comp,
		expr
	)

Add an expression to the mathematics in the given component.

comp may be a cellml_component instance or a component name.

Definition at line 434 of file processors.py.

    def add_expr_to_comp(self, comp, expr):
        """Add an expression to the mathematics in the given component.
        
        comp may be a cellml_component instance or a component name.
        """
        if not isinstance(comp, cellml_component):
            comp = self.model.get_component_by_name(comp)
        if not hasattr(comp, u'math'):
            # Create the math element
            math = comp.xml_create_element(u'math', NSS[u'm'])
            comp.xml_append(math)
        # Append this expression
        comp.math.xml_append(expr)
    

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

Referenced by CellMLToNektar.processors.InterfaceGenerator._split_ode(), CellMLToNektar.processors.InterfaceGenerator.add_output_function(), CellMLToNektar.processors.UnitsConverter.convert_constant(), CellMLToNektar.processors.UnitsConverter.convert_mapping(), and CellMLToNektar.processors.InterfaceGenerator.make_var_computed_constant().

◆ add_units()

def CellMLToNektar.processors.ModelModifier.add_units	(	self,
		units
	)

Add a units definition to the model, if it doesn't already exist.

If the definition isn't in the model, at whole-model level, it will be added.  If the same
definition is already available, however, that definition should be used by preference.
Will return the actual units object to use.

Definition at line 409 of file processors.py.

    def add_units(self, units):
        """Add a units definition to the model, if it doesn't already exist.
        
        If the definition isn't in the model, at whole-model level, it will be added.  If the same
        definition is already available, however, that definition should be used by preference.
        Will return the actual units object to use.
        """
        units = self.model._get_units_obj(units)
        try:
            model_units = self.model.get_units_by_name(units.name)
        except KeyError:
            model_units = None
        if model_units:
            assert units.uniquify_tuple == model_units.uniquify_tuple
            units = model_units
        else:
            units.name = self._uniquify_name(units.name, self.model.get_units_by_name)
            self.model.add_units(units.name, units)
            self.model.xml_append(units)
            # Ensure referenced units exist
            for unit in getattr(units, u'unit', []):
                unit._set_units_element(self.add_units(unit.get_units_element()), override=True)
                unit.units = unit.get_units_element().name
        return units
    

References CellMLToNektar.processors.ModelModifier._uniquify_name(), CellMLToNektar.pycml.cellml_model.add_units(), CellMLToNektar.pycml.cellml_component.add_units(), CellMLToNektar.processors.ModelModifier.add_units(), CellMLToNektar.pycml.get_units_by_name(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

Referenced by CellMLToNektar.processors.ModelModifier.add_units(), CellMLToNektar.processors.ModelModifier.add_variable(), and CellMLToNektar.processors.UnitsConverter.convert_constant().

◆ add_variable()

def CellMLToNektar.processors.ModelModifier.add_variable	(		self,
			comp,
			vname,
			units,
		**	kwargs
	)

Add a new variable to the given component.

Remaining arguments are as for cellml_variable.create_new.
Returns the new variable object.

Definition at line 381 of file processors.py.

    def add_variable(self, comp, vname, units, **kwargs):
        """Add a new variable to the given component.
        
        Remaining arguments are as for cellml_variable.create_new.
        Returns the new variable object.
        """
        if not isinstance(comp, cellml_component):
            comp = self.model.get_component_by_name(comp)
        units = self.add_units(units)
        var = cellml_variable.create_new(comp, vname, units.name, **kwargs)
        comp._add_variable(var)
        return var
        

References 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(), and CellMLToNektar.translators.CellMLTranslator.model.

Referenced by CellMLToNektar.processors.ModelModifier._find_or_create_variable(), CellMLToNektar.processors.InterfaceGenerator._split_ode(), CellMLToNektar.processors.InterfaceGenerator.add_input(), CellMLToNektar.processors.InterfaceGenerator.add_output(), CellMLToNektar.processors.InterfaceGenerator.add_output_function(), and CellMLToNektar.processors.UnitsConverter.convert_mapping().

◆ connect_variables()

def CellMLToNektar.processors.ModelModifier.connect_variables	(	self,
		source,
		target
	)

Create a connection between the given source and target variables.

The variables are both specified either by a pair (cname,vname), or as cellml_variable objects.
The source variable must exist within the model, whereas the target might not, in
which case it will be created.

Note that in the case that both source and target exist, it might NOT be the case that
target obtains its value from source.  They might already be connected, and source obtains
its value from target.  Or they might both obtain their value from a common source.

If the variable names are not identical, any variables created will have the same name as the
target, if possible.  If there's an existing variable with that name, not connected to the
source, then underscores will be appended to the name to avoid conflicts.  Note that we do
check for variables in intermediate components that have the same name as the source and are
connected to it, to avoid adding unnecessary variables.

Returns the target variable object.

Definition at line 132 of file processors.py.

    def connect_variables(self, source, target):
        """Create a connection between the given source and target variables.
        
        The variables are both specified either by a pair (cname,vname), or as cellml_variable objects.
        The source variable must exist within the model, whereas the target might not, in
        which case it will be created.
        
        Note that in the case that both source and target exist, it might NOT be the case that
        target obtains its value from source.  They might already be connected, and source obtains
        its value from target.  Or they might both obtain their value from a common source.
        
        If the variable names are not identical, any variables created will have the same name as the
        target, if possible.  If there's an existing variable with that name, not connected to the
        source, then underscores will be appended to the name to avoid conflicts.  Note that we do
        check for variables in intermediate components that have the same name as the source and are
        connected to it, to avoid adding unnecessary variables.
        
        Returns the target variable object.
        """
        if isinstance(source, cellml_variable):
            src_cname, src_vname = source.component.name, source.name
        else:
            src_cname, src_vname = source
        if isinstance(target, cellml_variable):
            target_cname, target_vname = target.component.name, target.name
        else:
            target_cname, target_vname = target
        src_comp = self.model.get_component_by_name(src_cname)
        target_comp = self.model.get_component_by_name(target_cname)
        if src_comp == target_comp:
            return target_comp.get_variable_by_name(target_vname)
        # Determine encapsulation paths from target & source to the root
        src_path = self._parent_path(src_comp)
        target_path = self._parent_path(target_comp)
        # At some point these will share a common path, even if it's just the root itself
        meeting_index = self._find_common_tail(src_path, target_path)
        # Construct path from source to target, leaving out the root (None)
        path = src_path[:meeting_index]
        if src_path[meeting_index]:
            path.append(src_path[meeting_index])
        path.extend(reversed(target_path[:meeting_index]))
        # Traverse this path, adding connections at each step
        next_src_var = src_comp.get_variable_by_name(src_vname)
        for i, src_comp in enumerate(path[:-1]):
            target_comp = path[i+1]
            next_src_var = self._make_connection(next_src_var, target_comp, target_vname)
        return next_src_var
    

References CellMLToNektar.processors.ModelModifier._find_common_tail(), CellMLToNektar.processors.ModelModifier._make_connection(), CellMLToNektar.processors.ModelModifier._parent_path(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

Referenced by CellMLToNektar.processors.InterfaceGenerator._transform_derivative_on_rhs(), CellMLToNektar.processors.ModelModifier._update_connections(), CellMLToNektar.processors.InterfaceGenerator.add_output(), and CellMLToNektar.processors.UnitsConverter.modify_rhs().

◆ create_new_component()

def CellMLToNektar.processors.ModelModifier.create_new_component	(	self,
		cname
	)

Create a new component in the model, ensuring the name is unique.

If a component with name cname already exists,
underscores will be added to the component name to make it unique.

Definition at line 114 of file processors.py.

    def create_new_component(self, cname):
        """Create a new component in the model, ensuring the name is unique.
        
        If a component with name cname already exists,
        underscores will be added to the component name to make it unique.
        """
        while True:
            try:
                self.model.get_component_by_name(cname)
                cname += u'_'
            except KeyError:
                # Component with this name doesn't exist
                break
        # Create the component
        comp = cellml_component.create_new(self.model, cname)
        self.model._add_component(comp)
        return comp
    

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

Referenced by CellMLToNektar.processors.InterfaceGenerator.get_interface_component().

◆ del_attr()

def CellMLToNektar.processors.ModelModifier.del_attr	(	self,
		elt,
		localName,
		ns = `None`
	)

Delete an XML attribute from an element, if it exists.

Definition at line 474 of file processors.py.

    def del_attr(self, elt, localName, ns=None):
        """Delete an XML attribute from an element, if it exists."""
        for (pyname, (qname, ns_)) in elt.xml_attributes.items():
            _, name = SplitQName(qname)
            if ns_ == ns and name == localName:
                delattr(elt, pyname)
 

Referenced by CellMLToNektar.processors.ModelModifier._update_connections(), CellMLToNektar.processors.InterfaceGenerator.add_input(), CellMLToNektar.processors.InterfaceGenerator.add_output(), and CellMLToNektar.processors.ModelModifier.remove_definition().

◆ finalize()

def CellMLToNektar.processors.ModelModifier.finalize	(	self,
		error_handler,
		pre_units_check_hook = `None`,
		check_units = `True`
	)

Re-do the model validation steps needed for further processing of the model.

Checks connections, etc. and builds up the dependency graph again, then performs
a topological sort.

If any errors are found during re-validation, the error_handler will be called with the
list.  Warnings are ignored.

TODO: figure out how to determine how much of this is actually needed - InterfaceGenerator
can probably get away with less work.

Reimplemented in CellMLToNektar.processors.InterfaceGenerator.

Definition at line 64 of file processors.py.

    def finalize(self, error_handler, pre_units_check_hook=None, check_units=True):
        """Re-do the model validation steps needed for further processing of the model.
        
        Checks connections, etc. and builds up the dependency graph again, then performs
        a topological sort.
        
        If any errors are found during re-validation, the error_handler will be called with the
        list.  Warnings are ignored.
        
        TODO: figure out how to determine how much of this is actually needed - InterfaceGenerator
        can probably get away with less work.
        """
        self._clear_model_caches()
        # We want to see any errors
        logging_info = validator.CellMLValidator.setup_logging(show_errors=True, show_warnings=False)
        # Re-run validation & analysis
        self.model._check_variable_mappings()
        if not self.model._cml_validation_errors:
            assignment_exprs = self.model.search_for_assignments()
            self.model._check_assigned_vars(assignment_exprs)
        if not self.model._cml_validation_errors:
            self.model._classify_variables(assignment_exprs)
            self.model._order_variables(assignment_exprs)
        if not self.model._cml_validation_errors and check_units:
            if callable(pre_units_check_hook):
                pre_units_check_hook()
            self.model._check_connection_units(check_for_units_conversions=False)
            self.model._check_dimensional_consistency(assignment_exprs,
                                                      xml_context=False,
                                                      warn_on_units_errors=self.model.get_option('warn_on_units_errors'),
                                                      check_for_units_conversions=False)
        if self.model._cml_validation_errors:
            error_handler(self.model._cml_validation_errors)
        # Clear up logging
        validator.CellMLValidator.cleanup_logging(logging_info)
 

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

◆ get_units_converter()

def CellMLToNektar.processors.ModelModifier.get_units_converter ( self )

Get the units converter object, if any has been set.

Definition at line 507 of file processors.py.

    def get_units_converter(self):
        """Get the units converter object, if any has been set."""
        if not self._units_converter:
            raise ModelModificationError("No units converter has been set.")
        return self._units_converter
 

References CellMLToNektar.processors.ModelModifier._units_converter.

◆ remove_connection()

def CellMLToNektar.processors.ModelModifier.remove_connection	(	self,
		var1,
		var2
	)

Remove a connection between two variables.

Removes the relevant map_variables element.
If this results in an empty connection element, removes that as well.

Definition at line 271 of file processors.py.

    def remove_connection(self, var1, var2):
        """Remove a connection between two variables.
        
        Removes the relevant map_variables element.
        If this results in an empty connection element, removes that as well.
        """
        conn, swap = self._find_connection_element(var1, var2)
        if not conn:
            raise ModelModificationError("Cannot remove non-existent connection.")
        if swap:
            var1, var2 = var2, var1
        # Find the relevant map_variables element
        mapv = conn.xml_xpath(u'cml:map_variables[@variable_1="%s" and @variable_2="%s"]'
                              % (var1.name, var2.name))
        if not mapv:
            raise ModelModificationError("Cannot remove non-existent connection.")
        conn.xml_remove_child(mapv[0])
        if not hasattr(conn, u'map_variables'):
            conn.xml_parent.xml_remove_child(conn)
    

References CellMLToNektar.processors.ModelModifier._find_connection_element().

◆ remove_connections()

def CellMLToNektar.processors.ModelModifier.remove_connections	(	self,
		var
	)

Remove all connection elements for the given variable.

Removes each relevant map_variables element.
If this results in an empty connection element, removes that as well.

Definition at line 291 of file processors.py.

    def remove_connections(self, var):
        """Remove all connection elements for the given variable.
        
        Removes each relevant map_variables element.
        If this results in an empty connection element, removes that as well.
        """
        cname, vname = var.component.name, var.name
        for conn in list(getattr(self.model, u'connection', [])):
            if cname == conn.map_components.component_1:
                vid = u'variable_1'
            elif cname == conn.map_components.component_2:
                vid = u'variable_2'
            else:
                continue
            for mapv in conn.map_variables:
                if vname == getattr(mapv, vid, ''):
                    # Found a connection
                    conn.xml_remove_child(mapv)
                    if not hasattr(conn, u'map_variables'):
                        conn.xml_parent.xml_remove_child(conn)
                    # There can't be any more matching map_variables in this connection
                    break
    

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

Referenced by CellMLToNektar.processors.ModelModifier._update_connections().

◆ remove_definition()

def CellMLToNektar.processors.ModelModifier.remove_definition	(	self,
		var,
		keep_initial_value = `False`
	)

Remove any existing definition (as an equation) of the given variable.

If keep_initial_value is False, then also remove any initial_value attribute.

If the variable is Mapped, throw a ModelModificationError.

Definition at line 456 of file processors.py.

    def remove_definition(self, var, keep_initial_value=False):
        """Remove any existing definition (as an equation) of the given variable.
        
        If keep_initial_value is False, then also remove any initial_value attribute.
        
        If the variable is Mapped, throw a ModelModificationError.
        """
        if var.get_type() == VarTypes.Mapped:
            raise ModelModificationError("Cannot remove the equation defining a mapped variable - remove the definition of its source instead")
        if not keep_initial_value:
            self.del_attr(var, u'initial_value')
        # Note: if this is a variable added by a protocol, then it shouldn't have
        # any dependencies set up yet, so this is a no-op.
        for dep in var.get_all_expr_dependencies():
            self.remove_expr(dep)
        # We know don't know how it will be defined
        var.clear_dependency_info()
 

References CellMLToNektar.processors.ModelModifier.del_attr(), and CellMLToNektar.processors.ModelModifier.remove_expr().

Referenced by CellMLToNektar.processors.InterfaceGenerator.make_var_computed_constant(), and CellMLToNektar.processors.InterfaceGenerator.make_var_constant().

◆ remove_expr()

def CellMLToNektar.processors.ModelModifier.remove_expr	(	self,
		expr
	)

Remove an expression (ODE or assignment) from its parent.

Definition at line 448 of file processors.py.

    def remove_expr(self, expr):
        """Remove an expression (ODE or assignment) from its parent."""
        assert isinstance(expr, mathml_apply)
        if expr.xml_parent:
            expr.xml_parent.safe_remove_child(expr)
            expr.xml_parent = None # Not done by Amara...
        return expr
    

Referenced by CellMLToNektar.processors.InterfaceGenerator._split_ode(), CellMLToNektar.processors.UnitsConverter.convert_constant(), and CellMLToNektar.processors.ModelModifier.remove_definition().

◆ set_units_converter()

def CellMLToNektar.processors.ModelModifier.set_units_converter	(	self,
		converter
	)

Set the object used to units-convert variable initial values.

Definition at line 503 of file processors.py.

    def set_units_converter(self, converter):
        """Set the object used to units-convert variable initial values."""
        self._units_converter = converter
    

References CellMLToNektar.processors.ModelModifier._units_converter.

Member Data Documentation

◆ _units_converter

CellMLToNektar.processors.ModelModifier._units_converter

private

Definition at line 61 of file processors.py.

Referenced by CellMLToNektar.processors.ModelModifier._convert_initial_value(), CellMLToNektar.processors.ModelModifier.get_units_converter(), and CellMLToNektar.processors.ModelModifier.set_units_converter().

◆ connections_made

CellMLToNektar.processors.ModelModifier.connections_made

Definition at line 62 of file processors.py.

Referenced by CellMLToNektar.processors.ModelModifier._make_connection().

◆ model

CellMLToNektar.processors.ModelModifier.model

Definition at line 60 of file processors.py.

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _clear_model_caches()

◆ _convert_initial_value()

◆ _create_connection_element()

◆ _find_common_tail()

◆ _find_connection_element()

◆ _find_or_create_variable()

◆ _get_units_object()

◆ _make_connection()

◆ _parent_path()

◆ _process_operator()

◆ _uniquify_name()

◆ _uniquify_var_name()

◆ _update_connections()

◆ add_expr_to_comp()

◆ add_units()

◆ add_variable()

◆ connect_variables()

◆ create_new_component()

◆ del_attr()

◆ finalize()

◆ get_units_converter()

◆ remove_connection()

◆ remove_connections()

◆ remove_definition()

◆ remove_expr()

◆ set_units_converter()

Member Data Documentation

◆ _units_converter

◆ connections_made

◆ model

◆ init()