Inheritance diagram for CellMLToNektar.processors.InterfaceGenerator:

[legend]

Public Member Functions
def	__init__ (self, model, name='interface', units_converter=None)

def	add_input (self, var, units, annotate=True, convert_initial_value=True)

def	add_output (self, var, units, annotate=True)

def	add_output_function (self, resultName, operator, argVars, units)

def	make_var_constant (self, var, value)

def	make_var_computed_constant (self, var, value)

def	finalize (self, args, *kwargs)

def	get_interface_component (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)

Private Member Functions
def	_transform_derivatives_on_rhs (self)

def	_transform_derivative_on_rhs (self, expr)

def	_split_ode (self, newVar, oldVar)

def	_add_all_odes_to_interface (self)

Private Attributes
	_interface_component

	_interface_component_name

Additional Inherited Members
Public Attributes inherited from CellMLToNektar.processors.ModelModifier
	model

	connections_made

Detailed Description

Class for generating an interface between a CellML model and external code.

This contains functionality for users to describe the interface desired by the external code, i.e.
which variables are inputs and/or outputs, and expected units.  It will then create a new component
within the CellML model containing these variables, and add units conversions where required.  The
external code then only needs to interact with this new component.

Definition at line 533 of file processors.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.processors.InterfaceGenerator.__init__	(	self,
		model,
		name = `'interface'`,
		units_converter = `None`
	)

Constructor.

Reimplemented from CellMLToNektar.processors.ModelModifier.

Definition at line 541 of file processors.py.

    def __init__(self, model, name='interface', units_converter=None):
        super(InterfaceGenerator, self).__init__(model)
        self._interface_component = None
        self._interface_component_name = name
        self.set_units_converter(units_converter)
    

References CellMLToNektar.processors.InterfaceGenerator.__init__().

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

Member Function Documentation

◆ _add_all_odes_to_interface()

def CellMLToNektar.processors.InterfaceGenerator._add_all_odes_to_interface ( self )

private

All the derivatives should be considered as model outputs, and state variables as model inputs.

For any that haven't been done explicitly, this method will add the corresponding state variable
as an input, with its original units, which has the desired effect.

Definition at line 725 of file processors.py.

    def _add_all_odes_to_interface(self):
        """All the derivatives should be considered as model outputs, and state variables as model inputs.
        
        For any that haven't been done explicitly, this method will add the corresponding state variable
        as an input, with its original units, which has the desired effect.
        """
        comp = self.get_interface_component()
        for var in self.model.find_state_vars():
            if var.component is not comp:
                self.add_input(var, var.get_units())
    

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

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

◆ _split_ode()

def CellMLToNektar.processors.InterfaceGenerator._split_ode	(	self,
		newVar,
		oldVar
	)

private

Split an ODE definition so the derivative goes into the interface component.

The RHS stays where it is, and is assigned to a new variable, which is connected to the interface
component and assigned to the new derivative.  newVar is the new state variable in the interface
component, and oldVar will soon be mapped to it by the caller.

Any other equations in the model which use the derivative are transformed to use the new variable
instead.

Definition at line 692 of file processors.py.

    def _split_ode(self, newVar, oldVar):
        """Split an ODE definition so the derivative goes into the interface component.
        
        The RHS stays where it is, and is assigned to a new variable, which is connected to the interface
        component and assigned to the new derivative.  newVar is the new state variable in the interface
        component, and oldVar will soon be mapped to it by the caller.
        
        Any other equations in the model which use the derivative are transformed to use the new variable
        instead.
        """
        # Get the free variable in the interface component
        free_var = self.model.find_free_vars()[0]
        if free_var.component is not newVar.component:
            free_var = self.add_input(free_var, free_var.get_units())
        # Add a new variable to assign the RHS to, with units of the original derivative
        deriv_name = self._uniquify_var_name(u'd_%s_d_%s' % (oldVar.name, free_var.name), oldVar.component)
        orig_ode = oldVar.get_all_expr_dependencies()[0]
        orig_rhs_var = self.add_variable(oldVar.component, deriv_name, orig_ode.eq.lhs.get_units().extract())
        # Add an output version of this in the interface, with desired units
        desired_units = newVar.get_units().quotient(free_var.get_units())
        mapped_rhs_var = self.add_output(orig_rhs_var, desired_units, annotate=False)
        # Replace the original ODE with an assignment
        orig_rhs = orig_ode.eq.rhs
        orig_ode.safe_remove_child(orig_rhs)
        self.remove_expr(orig_ode)
        self.add_expr_to_comp(oldVar.component,
                              mathml_apply.create_new(self.model, u'eq',
                                                      [orig_rhs_var.name, orig_rhs]))
        # Create a new ODE in the interface component
        new_ode = mathml_diff.create_new(self.model, free_var.name, newVar.name, mapped_rhs_var.name)
        self.add_expr_to_comp(newVar.component, new_ode)
        new_ode.classify_variables(root=True, dependencies_only=True)
    

References CellMLToNektar.processors.ModelModifier._uniquify_var_name(), CellMLToNektar.processors.ModelModifier.add_expr_to_comp(), CellMLToNektar.processors.InterfaceGenerator.add_input(), CellMLToNektar.processors.InterfaceGenerator.add_output(), CellMLToNektar.processors.ModelModifier.add_variable(), CellMLToNektar.pycml.extract(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.pycml.quotient(), and CellMLToNektar.processors.ModelModifier.remove_expr().

Referenced by CellMLToNektar.processors.InterfaceGenerator._transform_derivatives_on_rhs(), and CellMLToNektar.processors.InterfaceGenerator.add_input().

◆ _transform_derivative_on_rhs()

def CellMLToNektar.processors.InterfaceGenerator._transform_derivative_on_rhs	(	self,
		expr
	)

private

Transform a derivative on the RHS of an equation to refer to the defining variable.

Helper method used by self._transform_derivatives_on_rhs to do the actual transformation.

Definition at line 675 of file processors.py.

    def _transform_derivative_on_rhs(self, expr):
        """Transform a derivative on the RHS of an equation to refer to the defining variable.
        
        Helper method used by self._transform_derivatives_on_rhs to do the actual transformation.
        """
        # Find the variable to use
        dep_var = expr.diff.dependent_variable.get_source_variable(recurse=True)
        indep_var = expr.diff.independent_variable.get_source_variable(recurse=True)
        ode = dep_var.get_ode_dependency(indep_var)
        rhs_var = ode.eq.rhs.variable.get_source_variable(recurse=True)
        # Ensure there's something mapped to it in this component
        rhs_var = self.connect_variables(rhs_var, (expr.component.name, rhs_var.name))
        # Update this expression
        parent = expr.xml_parent
        parent.xml_insert_after(expr, mathml_ci.create_new(parent, rhs_var.name))
        parent.safe_remove_child(expr)
    

References CellMLToNektar.processors.InterfaceGenerator._transform_derivatives_on_rhs(), and CellMLToNektar.processors.ModelModifier.connect_variables().

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

◆ _transform_derivatives_on_rhs()

def CellMLToNektar.processors.InterfaceGenerator._transform_derivatives_on_rhs ( self )

private

Transform any equations with derivatives on the RHS to use the variable defining it instead.

self._split_ode must have been used for all derivatives before calling this method.  This means
that each ODE now has a variable to which the RHS is assigned.  Rather than using the derivative
directly, which could break the dependency chain if units conversions are used for time, equations
should refer to this new variable instead.

Definition at line 664 of file processors.py.

    def _transform_derivatives_on_rhs(self):
        """Transform any equations with derivatives on the RHS to use the variable defining it instead.
        
        self._split_ode must have been used for all derivatives before calling this method.  This means
        that each ODE now has a variable to which the RHS is assigned.  Rather than using the derivative
        directly, which could break the dependency chain if units conversions are used for time, equations
        should refer to this new variable instead.
        """
        for expr in self.model.search_for_assignments():
            self._process_operator(list(expr.operands())[1], u'diff', self._transform_derivative_on_rhs)
 

References CellMLToNektar.processors.ModelModifier._process_operator(), CellMLToNektar.processors.InterfaceGenerator._split_ode(), CellMLToNektar.processors.InterfaceGenerator._transform_derivative_on_rhs(), 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(), and CellMLToNektar.processors.InterfaceGenerator.finalize().

◆ add_input()

def CellMLToNektar.processors.InterfaceGenerator.add_input	(	self,
		var,
		units,
		annotate = `True`,
		convert_initial_value = `True`
	)

Specify a variable as an input to the model.

var should be a cellml_variable object already existing in the model.
units should be a suitable input to self._get_units_object.

If adding both State and Free variables as inputs, make sure to add the Free variable first,
otherwise you will not be able to specify units for it.

Set annotate to False if you do not wish a Constant variable to be annotated as a modifiable
parameter.

If a units converter has been supplied, we will also try to units-convert initial values.
This may not be possible if special conversions are used, since they may involve variables
whose values are not known at this time.  If this is the case, set convert_initial_value to
False to avoid applying the conversion.  A proper solution requires CellML 1.1 features.

The new variable added to the interface component is returned.

Definition at line 547 of file processors.py.

    def add_input(self, var, units, annotate=True, convert_initial_value=True):
        """Specify a variable as an input to the model.
        
        var should be a cellml_variable object already existing in the model.
        units should be a suitable input to self._get_units_object.
        
        If adding both State and Free variables as inputs, make sure to add the Free variable first,
        otherwise you will not be able to specify units for it.
        
        Set annotate to False if you do not wish a Constant variable to be annotated as a modifiable
        parameter.
        
        If a units converter has been supplied, we will also try to units-convert initial values.
        This may not be possible if special conversions are used, since they may involve variables
        whose values are not known at this time.  If this is the case, set convert_initial_value to
        False to avoid applying the conversion.  A proper solution requires CellML 1.1 features.
        
        The new variable added to the interface component is returned.
        """
        assert isinstance(var, cellml_variable)
        units = self._get_units_object(units)
        var = var.get_source_variable(recurse=True) # Ensure we work with source variables only
        var_name = var.fullname(cellml=True)
        # Check that the variable has a suitable type to be an input
        t = var.get_type()
        if t == VarTypes.Computed:
            raise ModelModificationError("Cannot specify computed variable " + var.fullname() + " as an input")
        elif t not in [VarTypes.Constant, VarTypes.Free, VarTypes.State]:
            raise ModelModificationError("Variable " + var.fullname() + " has unexpected type " + str(t))
        # Add a new variable with desired units to the interface component
        comp = self.get_interface_component()
        newvar = self.add_variable(comp, var_name, units, id=var.cmeta_id,
                                   initial_value=self._convert_initial_value(var, units, convert_initial_value),
                                   interfaces={u'public': u'out'})
        newvar._set_type(t)
        # Remove initial value and id from the original, if they exist
        self.del_attr(var, u'initial_value')
        self.del_attr(var, u'id', NSS['cmeta'])
        # If the original variable was a state variable, split the defining equation
        if t == VarTypes.State:
            self._split_ode(newvar, var)
        # Annotate the new variable as a parameter if the original was a constant
        if t == VarTypes.Constant and annotate:
            newvar.set_is_modifiable_parameter(True)
 
        self._update_connections(var, newvar)
        return newvar
    

References CellMLToNektar.processors.ModelModifier._convert_initial_value(), CellMLToNektar.processors.ModelModifier._get_units_object(), CellMLToNektar.processors.InterfaceGenerator._split_ode(), CellMLToNektar.processors.ModelModifier._update_connections(), CellMLToNektar.processors.ModelModifier.add_variable(), CellMLToNektar.processors.ModelModifier.del_attr(), and CellMLToNektar.processors.InterfaceGenerator.get_interface_component().

Referenced by CellMLToNektar.processors.InterfaceGenerator._add_all_odes_to_interface(), and CellMLToNektar.processors.InterfaceGenerator._split_ode().

◆ add_output()

def CellMLToNektar.processors.InterfaceGenerator.add_output	(	self,
		var,
		units,
		annotate = `True`
	)

Specify a variable as an output of the model.

var should be a cellml_variable object already existing in the model.
units should be a suitable input to self._get_units_object.
The new variable will take the cmeta:id of the original, and hence existing metadata
annotations will refer to the new variable.
If annotate is set to True, the new variable will also be annotated as a derived quantity.

The new variable added to the interface component is returned.

Definition at line 595 of file processors.py.

    def add_output(self, var, units, annotate=True):
        """Specify a variable as an output of the model.
        
        var should be a cellml_variable object already existing in the model.
        units should be a suitable input to self._get_units_object.
        The new variable will take the cmeta:id of the original, and hence existing metadata
        annotations will refer to the new variable.
        If annotate is set to True, the new variable will also be annotated as a derived quantity.
        
        The new variable added to the interface component is returned.
        """
        assert isinstance(var, cellml_variable)
        units = self._get_units_object(units)
        var = var.get_source_variable(recurse=True)
        var_name = var.fullname(cellml=True)
        comp = self.get_interface_component()
        newvar = self.add_variable(comp, var_name, units, id=var.cmeta_id)
        self.del_attr(var, u'id', NSS['cmeta'])
        self.connect_variables(var, newvar)
        if annotate:
            newvar.set_is_derived_quantity(True)
        return newvar
    

References CellMLToNektar.processors.ModelModifier._get_units_object(), CellMLToNektar.processors.ModelModifier.add_variable(), CellMLToNektar.processors.ModelModifier.connect_variables(), CellMLToNektar.processors.ModelModifier.del_attr(), and CellMLToNektar.processors.InterfaceGenerator.get_interface_component().

Referenced by CellMLToNektar.processors.InterfaceGenerator._split_ode(), and CellMLToNektar.processors.InterfaceGenerator.add_output_function().

◆ add_output_function()

def CellMLToNektar.processors.InterfaceGenerator.add_output_function	(	self,
		resultName,
		operator,
		argVars,
		units
	)

Add an output that's defined as a (MathML) function of existing model variables.

The desired units are those of the function's result.  The function arguments will be
imported with their units as given by the model, and the function calculated.  This result
will then be units-converted if necessary.

The new variable added to the interface component is returned.

Definition at line 618 of file processors.py.

    def add_output_function(self, resultName, operator, argVars, units):
        """Add an output that's defined as a (MathML) function of existing model variables.
        
        The desired units are those of the function's result.  The function arguments will be
        imported with their units as given by the model, and the function calculated.  This result
        will then be units-converted if necessary.
        
        The new variable added to the interface component is returned.
        """
        # Add the result variable
        comp = self.get_interface_component()
        units = self._get_units_object(units)
        result_var = self.add_variable(comp, resultName, units)
        result_var.set_pe_keep(True)
        # Map the argument variables
        operands = []
        for var in argVars:
            operands.append(self.add_output(var, var.get_units(), annotate=False).name)
        # Create the new function and assign it to result_var
        expr = mathml_apply.create_new(self.model, operator, operands)
        assign = mathml_apply.create_new(self.model, u'eq', [result_var.name, expr])
        self.add_expr_to_comp(comp, assign)
        return result_var
    

References CellMLToNektar.processors.ModelModifier._get_units_object(), CellMLToNektar.processors.ModelModifier.add_expr_to_comp(), CellMLToNektar.processors.InterfaceGenerator.add_output(), CellMLToNektar.processors.ModelModifier.add_variable(), CellMLToNektar.processors.InterfaceGenerator.get_interface_component(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

◆ finalize()

def CellMLToNektar.processors.InterfaceGenerator.finalize	(		self,
		*	args,
		**	kwargs
	)

Override finalize to also set up standard interface elements not defined individually.

Reimplemented from CellMLToNektar.processors.ModelModifier.

Definition at line 658 of file processors.py.

    def finalize(self, *args, **kwargs):
        """Override finalize to also set up standard interface elements not defined individually."""
        self._add_all_odes_to_interface()
        self._transform_derivatives_on_rhs()
        super(InterfaceGenerator, self).finalize(*args, **kwargs)
 

References CellMLToNektar.processors.InterfaceGenerator._add_all_odes_to_interface(), CellMLToNektar.processors.InterfaceGenerator._transform_derivatives_on_rhs(), and CellMLToNektar.processors.InterfaceGenerator.finalize().

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

◆ get_interface_component()

def CellMLToNektar.processors.InterfaceGenerator.get_interface_component ( self )

Get the new component that will contain the interface.

The name will be self._interface_component_name, unless a component with that name already exists,
in which case underscores will be added to the component name to make it unique.

Definition at line 736 of file processors.py.

    def get_interface_component(self):
        """Get the new component that will contain the interface.
        
        The name will be self._interface_component_name, unless a component with that name already exists,
        in which case underscores will be added to the component name to make it unique.
        """
        if self._interface_component is None:
            self._interface_component = self.create_new_component(unicode(self._interface_component_name))
            self.model.interface_component_name = unicode(self._interface_component_name)
            assert not self._interface_component.ignore_component_name
        return self._interface_component
 
 

References CellMLToNektar.processors.InterfaceGenerator._interface_component, CellMLToNektar.processors.InterfaceGenerator._interface_component_name, CellMLToNektar.processors.ModelModifier.create_new_component(), CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), and CellMLToNektar.translators.CellMLTranslator.model.

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

◆ make_var_computed_constant()

def CellMLToNektar.processors.InterfaceGenerator.make_var_computed_constant	(	self,
		var,
		value
	)

Turn a variable into a Computed variable with constant value definition.

Definition at line 649 of file processors.py.

    def make_var_computed_constant(self, var, value):
        """Turn a variable into a Computed variable with constant value definition."""
        self.remove_definition(var)
        var.clear_dependency_info()
        defn = mathml_apply.create_new(self.model, u'eq', 
                                       [var.name, (unicode(str(value)), var.get_units().name)])
        self.add_expr_to_comp(var.component, defn)
        var._set_type(VarTypes.Computed)
 

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

◆ make_var_constant()

def CellMLToNektar.processors.InterfaceGenerator.make_var_constant	(	self,
		var,
		value
	)

Turn a variable into a constant.

Definition at line 642 of file processors.py.

    def make_var_constant(self, var, value):
        """Turn a variable into a constant."""
        self.remove_definition(var)
        var.clear_dependency_info()
        var.initial_value = unicode(str(value))
        var._set_type(VarTypes.Constant)
    

References CellMLToNektar.processors.ModelModifier.remove_definition().

Member Data Documentation

◆ _interface_component

CellMLToNektar.processors.InterfaceGenerator._interface_component

private

Definition at line 543 of file processors.py.

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

◆ _interface_component_name

CellMLToNektar.processors.InterfaceGenerator._interface_component_name

private

Definition at line 544 of file processors.py.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _add_all_odes_to_interface()

◆ _split_ode()

◆ _transform_derivative_on_rhs()

◆ _transform_derivatives_on_rhs()

◆ add_input()

◆ add_output()

◆ add_output_function()

◆ finalize()

◆ get_interface_component()

◆ make_var_computed_constant()

◆ make_var_constant()

Member Data Documentation

◆ _interface_component

◆ _interface_component_name

◆ init()