Inheritance diagram for CellMLToNektar.translators.SolverInfo:

[legend]

Public Member Functions
def	__init__ (self, model, force=False)

def	add_all_info (self)

def	add_dt_reference (self)

def	add_transmembrane_potential_name (self)

def	add_linearised_odes (self)

def	add_jacobian_matrix (self)

def	use_canonical_variable_names (self)

def	add_membrane_ionic_current (self)

def	add_linear_ode_update_equations (self)

def	add_variable_links (self)

def	do_binding_time_analysis (self)

def	has_modifiable_mathematics (self)

def	get_modifiable_mathematics (self)

def	get_linearised_odes (self)

def	create_dt (self, modifier, comp, units)

def	get_dt (self)

Private Member Functions
def	_fix_jac_var_name (self, vname)

def	_check_state_var_units_conversions (self)

def	_process_mathematics (self, func)

def	_add_variable_links (self, elt)

def	_get_variable (self, varname)

def	_get_special_variable (self, varname, ptype=VarTypes.Unknown)

def	_get_special_component (self)

Private Attributes
	_model

	_solver_info

	_component

	_dt

Static Private Attributes
	_jac_temp_re = re.compile(r't[0-9]+')

Detailed Description

Add information for specialised translator classes into a model.

Definition at line 1359 of file translators.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.translators.SolverInfo.__init__	(	self,
		model,
		force = `False`
	)

Add information for the solvers as XML.

The Jacobian and linearity analyses store their results in
Python data structures as attributes of this object.
Transcribe these into XML in a child <solver_info> element.

If any of these elements exist in the model they will be left
unaltered, unless force is set to True.

This constructor just sets up the container element; call one
of the add_* methods to actually add the information to it.

Definition at line 1361 of file translators.py.

    def __init__(self, model, force=False):
        """Add information for the solvers as XML.
 
        The Jacobian and linearity analyses store their results in
        Python data structures as attributes of this object.
        Transcribe these into XML in a child <solver_info> element.
 
        If any of these elements exist in the model they will be left
        unaltered, unless force is set to True.
        
        This constructor just sets up the container element; call one
        of the add_* methods to actually add the information to it.
        """
        self._model = model
        if force and hasattr(model, u'solver_info'):
            model.xml_remove_child(model.solver_info)
        if hasattr(model, u'solver_info'):
            solver_info = model.solver_info
        else:
            solver_info = model.xml_create_element(u'solver_info', NSS[u'solver'])
            model.xml_append(solver_info)
        self._solver_info = solver_info
        self._component = None
        self._dt = None
    

Member Function Documentation

◆ _add_variable_links()

def CellMLToNektar.translators.SolverInfo._add_variable_links	(	self,
		elt
	)

private

Recursively link ci elements in the given XML tree to cellml_variable objects.

Also sets component links: for ci elements, to the component containing the linked
variable, and for cn elements, to the first component in the model.

Definition at line 1743 of file translators.py.

    def _add_variable_links(self, elt):
        """Recursively link ci elements in the given XML tree to cellml_variable objects.
        
        Also sets component links: for ci elements, to the component containing the linked
        variable, and for cn elements, to the first component in the model.
        """
        if isinstance(elt, mathml_ci):
            var = self._get_variable(unicode(elt))
            elt._cml_variable = var
            elt._cml_component = var.component
        elif isinstance(elt, mathml_cn):
            # Fake a component, since it doesn't really have one
            elt._cml_component = elt.model.component
        elif hasattr(elt, 'xml_children'):
            for child in elt.xml_children:
                self._add_variable_links(child)
 

References CellMLToNektar.translators.SolverInfo._add_variable_links(), and CellMLToNektar.translators.SolverInfo._get_variable().

Referenced by CellMLToNektar.translators.SolverInfo._add_variable_links(), CellMLToNektar.translators.SolverInfo.add_linear_ode_update_equations(), and CellMLToNektar.translators.SolverInfo.add_variable_links().

◆ _check_state_var_units_conversions()

def CellMLToNektar.translators.SolverInfo._check_state_var_units_conversions ( self )

private

Check if any Jacobian entries need to be altered because the units of state variables have changed.

If any variable considered a state variable by the Jacobian is now of type Computed then it has been
converted.  We figure out the conversion factor, update the Jacobian to reference the new state variable,
and units-convert the derivative.

Definition at line 1604 of file translators.py.

    def _check_state_var_units_conversions(self):
        """Check if any Jacobian entries need to be altered because the units of state variables have changed.
        
        If any variable considered a state variable by the Jacobian is now of type Computed then it has been
        converted.  We figure out the conversion factor, update the Jacobian to reference the new state variable,
        and units-convert the derivative.
        """
        if not hasattr(self._solver_info, u'jacobian'):
            return
        # Helper methods
        def set_var_values(elt, vars=None):
            """Fake all variables appearing in the given expression being set to 1.0, and return them."""
            if vars is None:
                vars = []
            if isinstance(elt, mathml_ci):
                elt.variable.set_value(1.0)
                vars.append(elt.variable)
            else:
                for child in getattr(elt, 'xml_children', []):
                    set_var_values(child, vars)
            return vars
        # Find any converted state variables
        converted_state_vars = set()
        for entry in getattr(self._solver_info.jacobian, u'entry', []):
            var = self._get_variable(entry.var_i)
            if var.get_type() == VarTypes.Computed:
                converted_state_vars.add(var)
        if not converted_state_vars:
            return
        # Figure out the conversion factor in each case
        state_var_map = {}
        for var in converted_state_vars:
            defn = var.get_dependencies()[0]
            defn_vars = set_var_values(defn.eq.rhs)
            assert len(defn_vars) == 1, "Unexpected form of units conversion expression found"
            factor = defn.eq.rhs.evaluate()
            state_var_map[var] = (defn_vars[0], factor)
            defn_vars[0].unset_values()
        # Apply the conversion to relevant Jacobian entries
        for entry in getattr(self._solver_info.jacobian, u'entry', []):
            factor = 1
            var_i = self._get_variable(entry.var_i)
            if var_i in converted_state_vars:
                var_i, factor_i = state_var_map[var_i]
                var_i = var_i.get_source_variable(recurse=True)
                entry.var_i = unicode(var_i.fullname())
                factor /= factor_i
            var_j = self._get_variable(entry.var_j)
            if var_j in converted_state_vars:
                var_j, factor_j = state_var_map[var_j]
                var_j = var_j.get_source_variable(recurse=True)
                entry.var_j = unicode(var_j.fullname())
                factor *= factor_j
            if factor != 1:
                # Replace rhs with rhs * factor
                rhs = list(entry.math.xml_element_children())[0]
                entry.math.safe_remove_child(rhs)
                new_rhs = mathml_apply.create_new(entry, 'times', [(factor, 'dimensionless'), rhs])
                entry.math.xml_append(new_rhs)
    

References CellMLToNektar.translators.SolverInfo._get_variable(), and CellMLToNektar.translators.SolverInfo._solver_info.

Referenced by CellMLToNektar.translators.SolverInfo.add_variable_links().

◆ _fix_jac_var_name()

def CellMLToNektar.translators.SolverInfo._fix_jac_var_name	(	self,
		vname
	)

private

If PE will be performed on a model with a single component, then we'll need full names in
the variable attributes.

Definition at line 1458 of file translators.py.

    def _fix_jac_var_name(self, vname):
        """
        If PE will be performed on a model with a single component, then we'll need full names in
        the variable attributes.
        """
        if vname[:4] == 'var_' and len(self._model.component) == 1 and not self._model.component.ignore_component_name:
            name = unicode('var_' + self._model.component.name + '__' + vname[4:])
        else:
            name = unicode(vname)
        return name
    

References CellMLToNektar.translators.SolverInfo._model.

Referenced by CellMLToNektar.translators.SolverInfo.add_jacobian_matrix().

◆ _get_special_component()

def CellMLToNektar.translators.SolverInfo._get_special_component ( self )

private

Get or create a special component for containing special variables.

Definition at line 1798 of file translators.py.

    def _get_special_component(self):
        """Get or create a special component for containing special variables."""
        if not self._component:
            self._component = cellml_component.create_new(self._model, u'')
            self._model._add_component(self._component, special=True)
        return self._component
 
 
 

References CellMLToNektar.translators.SolverInfo._component, and CellMLToNektar.translators.SolverInfo._model.

Referenced by CellMLToNektar.translators.SolverInfo._get_special_variable(), CellMLToNektar.translators.SolverInfo.add_jacobian_matrix(), and CellMLToNektar.translators.SolverInfo.add_linearised_odes().

◆ _get_special_variable()

def CellMLToNektar.translators.SolverInfo._get_special_variable	(	self,
		varname,
		ptype = `VarTypes.Unknown`
	)

private

Get or create a special variable object that doesn't really exist in the model.

Definition at line 1787 of file translators.py.

    def _get_special_variable(self, varname, ptype=VarTypes.Unknown):
        """Get or create a special variable object that doesn't really exist in the model."""
        comp = self._get_special_component()
        try:
            var = comp.get_variable_by_name(varname)
        except KeyError:
            var = cellml_variable.create_new(self._model, varname, u'dimensionless')
            comp._add_variable(var)
            var._set_type(ptype)
        return var
 

References CellMLToNektar.translators.SolverInfo._get_special_component(), and CellMLToNektar.translators.SolverInfo._model.

Referenced by CellMLToNektar.translators.SolverInfo._get_variable(), and CellMLToNektar.translators.SolverInfo.get_dt().

◆ _get_variable()

def CellMLToNektar.translators.SolverInfo._get_variable	(	self,
		varname
	)

private

Return the variable in the model with name varname.

Definition at line 1761 of file translators.py.

    def _get_variable(self, varname):
        """Return the variable in the model with name varname."""
        try:
            if varname == 'delta_t':
                # Special case for the timestep in ComputeJacobian and elsewhere
                var = self.get_dt()
            elif self._jac_temp_re.match(varname):
                var = self._get_special_variable(varname, VarTypes.Unknown)
            else:
                var = cellml_variable.get_variable_object(self._model, varname)
        except KeyError:
            raise ValueError("Cannot find variable '%s' referenced in SolverInfo" % varname)
        return var
    

References CellMLToNektar.translators.SolverInfo._get_special_variable(), CellMLToNektar.translators.SolverInfo._jac_temp_re, CellMLToNektar.translators.SolverInfo._model, and CellMLToNektar.translators.SolverInfo.get_dt().

Referenced by CellMLToNektar.translators.SolverInfo._add_variable_links(), CellMLToNektar.translators.SolverInfo._check_state_var_units_conversions(), and CellMLToNektar.translators.SolverInfo.use_canonical_variable_names().

◆ _process_mathematics()

def CellMLToNektar.translators.SolverInfo._process_mathematics	(	self,
		func
	)

private

Apply func to each top-level mathematical construct in the solver info blocks.

func must be able to accept mathml_piecewise, mathml_apply, mathml_ci and mathml_cn elements.

Definition at line 1671 of file translators.py.

    def _process_mathematics(self, func):
        """Apply func to each top-level mathematical construct in the solver info blocks.
        
        func must be able to accept mathml_piecewise, mathml_apply, mathml_ci and mathml_cn elements.
        """
        solver_info = self._solver_info
        # Jacobian
        if hasattr(solver_info, u'jacobian'):
            if hasattr(solver_info.jacobian, u'math'):
                for elt in solver_info.jacobian.math.apply:
                    func(elt)
            for entry in solver_info.jacobian.entry:
                for elt in entry.math.xml_element_children():
                    func(elt)
        # Linearised ODEs
        if hasattr(solver_info, u'linear_odes'):
            for math in solver_info.linear_odes.math:
                for elt in math.xml_element_children():
                    func(elt)
    

References CellMLToNektar.translators.SolverInfo._solver_info.

Referenced by CellMLToNektar.translators.SolverInfo.add_variable_links(), and CellMLToNektar.translators.SolverInfo.do_binding_time_analysis().

◆ add_all_info()

def CellMLToNektar.translators.SolverInfo.add_all_info ( self )

Actually add the info.

Definition at line 1386 of file translators.py.

    def add_all_info(self):
        """Actually add the info."""
        self.add_transmembrane_potential_name()
        self.add_membrane_ionic_current()
        self.add_linearised_odes()
        self.add_jacobian_matrix()
        self.add_dt_reference()
    

References CellMLToNektar.translators.SolverInfo.add_dt_reference(), CellMLToNektar.translators.SolverInfo.add_jacobian_matrix(), CellMLToNektar.translators.SolverInfo.add_linearised_odes(), CellMLToNektar.translators.SolverInfo.add_membrane_ionic_current(), and CellMLToNektar.translators.SolverInfo.add_transmembrane_potential_name().

◆ add_dt_reference()

def CellMLToNektar.translators.SolverInfo.add_dt_reference ( self )

Add a reference to the variable representing dt.

Definition at line 1394 of file translators.py.

    def add_dt_reference(self):
        """Add a reference to the variable representing dt."""
        solver_info = self._solver_info
        model = self._model
        if not hasattr(solver_info, u'dt'):
            dt = self.get_dt()
            elt = model.xml_create_element(u'dt', NSS[u'solver'], content=dt.fullname(cellml=True))
            solver_info.xml_append(elt)
            self._model._add_sorted_assignment(dt)
    

References CellMLToNektar.translators.SolverInfo._model, CellMLToNektar.translators.SolverInfo._solver_info, and CellMLToNektar.translators.SolverInfo.get_dt().

Referenced by CellMLToNektar.translators.SolverInfo.add_all_info().

◆ add_jacobian_matrix()

def CellMLToNektar.translators.SolverInfo.add_jacobian_matrix ( self )

Jacobian matrix elements.

Structure looks like:
<jacobian>
    [<math> assignments of common sub-terms </math>]
    <entry var_i='varname' var_j='varname'>
        <math> apply|cn|ci ...</math>
    </entry>
</jacobian>

Definition at line 1469 of file translators.py.

    def add_jacobian_matrix(self):
        """Jacobian matrix elements.
        
        Structure looks like:
        <jacobian>
            [<math> assignments of common sub-terms </math>]
            <entry var_i='varname' var_j='varname'>
                <math> apply|cn|ci ...</math>
            </entry>
        </jacobian>
        """
        solver_info = self._solver_info
        model = self._model
        if model._cml_jacobian and model._cml_jacobian_full:
            jac = model._cml_jacobian[1]
        else:
            # Old-style partial jacobian, or no jacobian
            jac = model._cml_jacobian
        if not hasattr(solver_info, u'jacobian') and jac:
            jac_elt = model.xml_create_element(u'jacobian', NSS[u'solver'])
            solver_info.xml_append(jac_elt)
            
            if model._cml_jacobian_full:
                # There may be temporaries
                temporaries = model._cml_jacobian[0]
                if temporaries:
                    jac_elt.xml_append(amara_parse_cellml(temporaries).math)
 
            jac_vars = jac.keys()
            jac_vars.sort() # Will sort by variable name
            for v_i, v_j in jac_vars:
                # Add (i,j)-th entry
                attrs = {u'var_i': self._fix_jac_var_name(v_i),
                         u'var_j': self._fix_jac_var_name(v_j)}
                entry = model.xml_create_element(u'entry', NSS[u'solver'], attributes=attrs)
                jac_elt.xml_append(entry)
                entry_doc = amara_parse_cellml(jac[(v_i, v_j)].xml())
                entry.xml_append(entry_doc.math)
            # Ensure that the model has a special component
            self._get_special_component()
        return
    

References CellMLToNektar.translators.SolverInfo._fix_jac_var_name(), CellMLToNektar.translators.SolverInfo._get_special_component(), CellMLToNektar.translators.SolverInfo._model, CellMLToNektar.translators.SolverInfo._solver_info, and CellMLToNektar.pycml.amara_parse_cellml().

Referenced by CellMLToNektar.translators.SolverInfo.add_all_info().

◆ add_linear_ode_update_equations()

def CellMLToNektar.translators.SolverInfo.add_linear_ode_update_equations ( self )

Add the update equations for the linear ODEs.

A linear ODE has the form du/dt = g+h.u where g & h are not functions of u.  The
update expression then looks like u = (u + g.dt)/(1 - h.dt).

This replaces the linear_odes block with the structure:
<linear_odes>
    <math>
        <ci>u</ci>
        <ci>t</ci>
        <apply> <!-- (u + g.dt)/(1 - h.dt) --> </apply>
    </math>
    .
    .
    .
</linear_odes>

Definition at line 1547 of file translators.py.

    def add_linear_ode_update_equations(self):
        """Add the update equations for the linear ODEs.
        
        A linear ODE has the form du/dt = g+h.u where g & h are not functions of u.  The
        update expression then looks like u = (u + g.dt)/(1 - h.dt).
        
        This replaces the linear_odes block with the structure:
        <linear_odes>
            <math>
                <ci>u</ci>
                <ci>t</ci>
                <apply> <!-- (u + g.dt)/(1 - h.dt) --> </apply>
            </math>
            .
            .
            .
        </linear_odes>
        """
        block = getattr(self._solver_info, u'linear_odes', None)
        dt = self._model.get_config().dt_variable.fullname() # was dt = u'delta_t'
        # Add the new equations
        for u, t, gh in self.get_linearised_odes():
            g, h = gh
            g.safe_remove_child(g, g.xml_parent)
            g_dt = mathml_apply.create_new(block, u'times', [g, dt])
            numer = mathml_apply.create_new(block, u'plus', [u.fullname(), g_dt])
            h.safe_remove_child(h, h.xml_parent)
            h_dt = mathml_apply.create_new(block, u'times', [h, dt])
            denom = mathml_apply.create_new(block, u'minus', [(u'1', u'dimensionless'), h_dt])
            eqn = mathml_apply.create_new(block, u'divide', [numer, denom])
            math = block.xml_create_element(u'math', NSS[u'm'])
            math.xml_append(mathml_ci.create_new(block, u.fullname()))
            math.xml_append(mathml_ci.create_new(block, t.fullname()))
            math.xml_append(eqn)
            block.xml_append(math)
            self._add_variable_links(math)
        # Remove the old equations (first math element)
        block.xml_remove_child(block.math)
    

References CellMLToNektar.translators.SolverInfo._add_variable_links(), CellMLToNektar.translators.SolverInfo._model, CellMLToNektar.translators.SolverInfo._solver_info, and CellMLToNektar.translators.SolverInfo.get_linearised_odes().

◆ add_linearised_odes()

def CellMLToNektar.translators.SolverInfo.add_linearised_odes ( self )

Linearised ODEs - where du/dt = g + hu (and g, h are not functions of u).

Structure looks like:
<linear_odes>
    <math>
        <apply><eq/>
            <apply><diff/>
                <bvar><ci>t</ci></bvar>
                <ci>u</ci>
            </apply>
            <apply><plus/>
                g
                <apply><times/>
                    h
                    <ci>u</ci>
                </apply>
            </apply>
        </apply>
        .
        .
        .
    </math>
</linear_odes>

Definition at line 1414 of file translators.py.

    def add_linearised_odes(self):
        """Linearised ODEs - where du/dt = g + hu (and g, h are not functions of u).
        
        Structure looks like:
        <linear_odes>
            <math>
                <apply><eq/>
                    <apply><diff/>
                        <bvar><ci>t</ci></bvar>
                        <ci>u</ci>
                    </apply>
                    <apply><plus/>
                        g
                        <apply><times/>
                            h
                            <ci>u</ci>
                        </apply>
                    </apply>
                </apply>
                .
                .
                .
            </math>
        </linear_odes>
        """
        solver_info = self._solver_info
        model = self._model
        if not hasattr(solver_info, u'linear_odes') and model._cml_linear_update_exprs:
            odes_elt = model.xml_create_element(u'linear_odes', NSS[u'solver'])
            solver_info.xml_append(odes_elt)
            odes_math = model.xml_create_element(u'math', NSS[u'm'])
            odes_elt.xml_append(odes_math)
            linear_vars = model._cml_linear_update_exprs.keys()
            linear_vars.sort(key=lambda v: v.fullname())
            free_var = model._cml_free_var
            for var in linear_vars:
                g, h = model._cml_linear_update_exprs[var]
                hu = mathml_apply.create_new(model, u'times', [h, var.fullname()])
                rhs = mathml_apply.create_new(model, u'plus', [g, hu])
                odes_math.xml_append(mathml_diff.create_new(
                    model, free_var.fullname(), var.fullname(), rhs))
            # Ensure that the model has a special component
            self._get_special_component()
    

References CellMLToNektar.translators.SolverInfo._get_special_component(), CellMLToNektar.translators.SolverInfo._model, and CellMLToNektar.translators.SolverInfo._solver_info.

Referenced by CellMLToNektar.translators.SolverInfo.add_all_info().

◆ add_membrane_ionic_current()

def CellMLToNektar.translators.SolverInfo.add_membrane_ionic_current ( self )

Add ionic current information as XML for solvers to use.

Definition at line 1530 of file translators.py.

    def add_membrane_ionic_current(self):
        """Add ionic current information as XML for solvers to use."""
        solver_info = self._solver_info
        model = self._model
        # The total ionic current.  This relies on having a configuration store.
        if hasattr(model.xml_parent, '_cml_config') and not hasattr(solver_info, u'ionic_current'):
            conf = model.xml_parent._cml_config
            if conf.i_ionic_vars:
                ionic_elt = model.xml_create_element(u'ionic_current', NSS[u'solver'])
                # Adds each ionic var to the xml doc from the config store
                for var in conf.i_ionic_vars:
                    varelt = model.xml_create_element(u'var', NSS[u'solver'],
                                                      content=var.fullname())
                    ionic_elt.xml_append(varelt)
                solver_info.xml_append(ionic_elt)
        return
    

References CellMLToNektar.translators.SolverInfo._model, and CellMLToNektar.translators.SolverInfo._solver_info.

Referenced by CellMLToNektar.translators.SolverInfo.add_all_info().

◆ add_transmembrane_potential_name()

def CellMLToNektar.translators.SolverInfo.add_transmembrane_potential_name ( self )

The name of the transmembrane potential.

Definition at line 1404 of file translators.py.

    def add_transmembrane_potential_name(self):
        """The name of the transmembrane potential."""
        solver_info = self._solver_info
        model = self._model
        if not hasattr(solver_info, u'transmembrane_potential'):
            v_elt = model.xml_create_element(
                u'transmembrane_potential', NSS[u'solver'],
                content=model._cml_transmembrane_potential.fullname())
            solver_info.xml_append(v_elt)
    

References CellMLToNektar.translators.SolverInfo._model, and CellMLToNektar.translators.SolverInfo._solver_info.

Referenced by CellMLToNektar.translators.SolverInfo.add_all_info().

◆ add_variable_links()

def CellMLToNektar.translators.SolverInfo.add_variable_links ( self )

Link ci elements in the added XML to cellml_variable objects.

This analyses the names in the ci elements to determine which variable in
the model they refer to.

Definition at line 1586 of file translators.py.

    def add_variable_links(self):
        """Link ci elements in the added XML to cellml_variable objects.
        
        This analyses the names in the ci elements to determine which variable in
        the model they refer to.
        """
        self._process_mathematics(self._add_variable_links)
        #1795 - classify temporary variables for the Jacobian matrix, and append
        # to the main list of assignments in the model
        solver_info = self._solver_info
        if hasattr(solver_info, u'jacobian') and hasattr(solver_info.jacobian, u'math'):
            for elt in solver_info.jacobian.math.apply:
                elt.classify_variables(root=True)
            for elt in solver_info.jacobian.math.apply:
                self._model.topological_sort(elt)
        #2418 - check if any state variables have been units-converted
        self._check_state_var_units_conversions()
    

References CellMLToNektar.translators.SolverInfo._add_variable_links(), CellMLToNektar.translators.SolverInfo._check_state_var_units_conversions(), CellMLToNektar.translators.SolverInfo._model, CellMLToNektar.translators.SolverInfo._process_mathematics(), and CellMLToNektar.translators.SolverInfo._solver_info.

Referenced by CellMLToNektar.translators.SolverInfo.do_binding_time_analysis().

◆ create_dt()

def CellMLToNektar.translators.SolverInfo.create_dt	(	self,
		modifier,
		comp,
		units
	)

Create the special 'dt' variable in the given component.

Definition at line 1775 of file translators.py.

    def create_dt(self, modifier, comp, units):
        """Create the special 'dt' variable in the given component."""
        self._dt = modifier.add_variable(comp, modifier._uniquify_var_name(u'dt', comp), units)
        self._dt._set_type(VarTypes.Free)
        return self._dt
    

References CellMLToNektar.translators.SolverInfo._dt.

◆ do_binding_time_analysis()

def CellMLToNektar.translators.SolverInfo.do_binding_time_analysis ( self )

Do a binding time analysis on the additional mathematics.

This requires self.add_variable_links to have been called already.

Definition at line 1664 of file translators.py.

    def do_binding_time_analysis(self):
        """Do a binding time analysis on the additional mathematics.
        
        This requires self.add_variable_links to have been called already.
        """
        self._process_mathematics(lambda elt: elt._get_binding_time())
        

References CellMLToNektar.translators.SolverInfo._process_mathematics(), and CellMLToNektar.translators.SolverInfo.add_variable_links().

◆ get_dt()

def CellMLToNektar.translators.SolverInfo.get_dt ( self )

Get or create a special 'dt' variable.

Definition at line 1781 of file translators.py.

    def get_dt(self):
        """Get or create a special 'dt' variable."""
        if not self._dt:
            self._dt = self._get_special_variable(u'dt', VarTypes.Free)
        return self._dt
 

References CellMLToNektar.translators.SolverInfo._dt, and CellMLToNektar.translators.SolverInfo._get_special_variable().

Referenced by CellMLToNektar.translators.SolverInfo._get_variable(), and CellMLToNektar.translators.SolverInfo.add_dt_reference().

◆ get_linearised_odes()

def CellMLToNektar.translators.SolverInfo.get_linearised_odes ( self )

Return an iterable over the linearised ODEs, i.e. ODEs of the form
du/dt = g + hu (with g, h not functions of u).

Yields tuples (u, t, eqns) where the form of eqns depends on whether
add_linear_ode_update_equations has been called.  If so, it is a 1-tuple
containing the update equation; if not, it is (g,h).

Definition at line 1719 of file translators.py.

    def get_linearised_odes(self):
        """Return an iterable over the linearised ODEs, i.e. ODEs of the form
        du/dt = g + hu (with g, h not functions of u).
        
        Yields tuples (u, t, eqns) where the form of eqns depends on whether
        add_linear_ode_update_equations has been called.  If so, it is a 1-tuple
        containing the update equation; if not, it is (g,h).
        """
        if hasattr(self._solver_info, u'linear_odes'):
            if hasattr(self._solver_info.linear_odes.math, u'ci'):
                for math in self._solver_info.linear_odes.math:
                    u, t, eqn = list(math.xml_element_children())
                    u = u.variable
                    t = t.variable
                    yield (u, t, (eqn,))
            else:
                for ode in self._solver_info.linear_odes.math.apply:
                    u = ode.apply.ci.variable
                    t = ode.apply.bvar.ci.variable
                    opers = ode.apply[1].operands()
                    g = opers.next()
                    h = opers.next().operands().next()
                    yield (u, t, (g,h))
    

References CellMLToNektar.translators.SolverInfo._solver_info.

Referenced by CellMLToNektar.translators.SolverInfo.add_linear_ode_update_equations(), and CellMLToNektar.translators.SolverInfo.get_modifiable_mathematics().

◆ get_modifiable_mathematics()

def CellMLToNektar.translators.SolverInfo.get_modifiable_mathematics ( self )

Get an iterable over mathematical constructs in the solver info blocks that can be changed.

Returned elements will be mathml_piecewise, mathml_apply, mathml_ci or mathml_cn instances.

Definition at line 1699 of file translators.py.

    def get_modifiable_mathematics(self):
        """Get an iterable over mathematical constructs in the solver info blocks that can be changed.
        
        Returned elements will be mathml_piecewise, mathml_apply, mathml_ci or mathml_cn instances.
        """
        solver_info = self._solver_info
        # Jacobian - entry definitions and temporaries can be changed
        if hasattr(solver_info, u'jacobian'):
            if hasattr(solver_info.jacobian, u'math'):
                for elt in solver_info.jacobian.math.apply:
                    yield elt
            for entry in solver_info.jacobian.entry:
                for elt in entry.math.xml_element_children():
                    yield elt
        # Linearised ODEs - only g & h can be changed
        if hasattr(solver_info, u'linear_odes'):
            for _, _, eqns in self.get_linearised_odes():
                for eqn in eqns:
                    yield eqn
 

References CellMLToNektar.translators.SolverInfo._solver_info, and CellMLToNektar.translators.SolverInfo.get_linearised_odes().

Referenced by CellMLToNektar.translators.SolverInfo.has_modifiable_mathematics().

◆ has_modifiable_mathematics()

def CellMLToNektar.translators.SolverInfo.has_modifiable_mathematics ( self )

Check if the solver info blocks contain any modifiable mathematics.

Definition at line 1691 of file translators.py.

    def has_modifiable_mathematics(self):
        """Check if the solver info blocks contain any modifiable mathematics."""
        try:
            self.get_modifiable_mathematics().next()
            return True
        except StopIteration:
            return False
    

References CellMLToNektar.translators.SolverInfo.get_modifiable_mathematics().

◆ use_canonical_variable_names()

def CellMLToNektar.translators.SolverInfo.use_canonical_variable_names ( self )

PE has just been performed, so we need to update variable names occurring outside
the modifiable mathematics sections.

Definition at line 1511 of file translators.py.

    def use_canonical_variable_names(self):
        """
        PE has just been performed, so we need to update variable names occurring outside
        the modifiable mathematics sections.
        """
        jac_elt = getattr(self._solver_info, u'jacobian', None)
        for entry in getattr(jac_elt, u'entry', []):
            for vlabel in ['var_i', 'var_j']:
                vname = getattr(entry, vlabel)
                var = self._get_variable(vname)
                new_name = var.get_source_variable(recurse=True).fullname()
                setattr(entry, vlabel, new_name)
        dt_elt = getattr(self._solver_info, u'dt', None)
        if dt_elt:
            var = self._get_variable(unicode(dt_elt))
            new_name = var.get_source_variable(recurse=True).fullname()
            dt_elt.xml_remove_child(unicode(dt_elt))
            dt_elt.xml_append(unicode(new_name))
 

References CellMLToNektar.translators.SolverInfo._get_variable(), and CellMLToNektar.translators.SolverInfo._solver_info.

Member Data Documentation

◆ _component

CellMLToNektar.translators.SolverInfo._component

private

Definition at line 1383 of file translators.py.

Referenced by CellMLToNektar.translators.SolverInfo._get_special_component().

◆ _dt

CellMLToNektar.translators.SolverInfo._dt

private

Definition at line 1384 of file translators.py.

Referenced by CellMLToNektar.translators.SolverInfo.create_dt(), and CellMLToNektar.translators.SolverInfo.get_dt().

◆ _jac_temp_re

CellMLToNektar.translators.SolverInfo._jac_temp_re = re.compile(r't[0-9]+')

staticprivate

Definition at line 1760 of file translators.py.

Referenced by CellMLToNektar.translators.SolverInfo._get_variable().

◆ _model

CellMLToNektar.translators.SolverInfo._model

private

Definition at line 1374 of file translators.py.

◆ _solver_info

CellMLToNektar.translators.SolverInfo._solver_info

private

Definition at line 1382 of file translators.py.

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _add_variable_links()

◆ _check_state_var_units_conversions()

◆ _fix_jac_var_name()

◆ _get_special_component()

◆ _get_special_variable()

◆ _get_variable()

◆ _process_mathematics()

◆ add_all_info()

◆ add_dt_reference()

◆ add_jacobian_matrix()

◆ add_linear_ode_update_equations()

◆ add_linearised_odes()

◆ add_membrane_ionic_current()

◆ add_transmembrane_potential_name()

◆ add_variable_links()

◆ create_dt()

◆ do_binding_time_analysis()

◆ get_dt()

◆ get_linearised_odes()

◆ get_modifiable_mathematics()

◆ has_modifiable_mathematics()

◆ use_canonical_variable_names()

Member Data Documentation

◆ _component

◆ _dt

◆ _jac_temp_re

◆ _model

◆ _solver_info

◆ init()