Inheritance diagram for CellMLToNektar.translators.CellMLTranslator:

[legend]

Classes
class	NameAlreadyRegistered

Public Member Functions
def	register (cls, subclass, name)

def	__init__ (self, add_timestamp=True, options=None)

def	error (self, lines, xml=None)

def	config (self)

def	translate (self, doc, model_filename, output_filename=None, subsidiary_file_name=None, class_name=None, v_variable=None, continuation=None, lookup_method_prefix='', row_lookup_method=False, lt_index_uses_floor=True, constrain_table_indices=False)

def	final_configuration_hook (self)

def	output_file_name (self, model_filename)

def	subsidiary_file_name (self, output_filename)

def	send_main_output_to_subsidiary (self, to_subsidiary=True)

def	writeln (self, args, *kwargs)

def	write (self, *args)

def	capture_output (self)

def	get_captured_output (self)

def	output_comment (self, args, *kwargs)

def	output_doxygen (self, args, *kwargs)

def	set_indent (self, level=None, offset=None)

def	code_name (self, var, ode=False, prefix=None)

def	varobj (self, varname)

def	var_display_name (self, var)

def	include_guard (self)

def	output_top_boilerplate (self)

def	output_mathematics (self)

def	output_bottom_boilerplate (self)

def	output_assignment (self, expr)

def	output_lhs (self, expr)

def	output_variable (self, ci_elt, ode=False)

def	output_expr (self, expr, paren)

def	output_number (self, expr)

def	eval_number (self, expr)

def	output_apply (self, expr, paren)

def	output_function (self, func_name, args, paren, reciprocal=False)

def	output_nary_operator (self, operator, operands, paren)

def	output_unary_operator (self, operator, operand, paren)

def	output_binary_operator (self, operator, operands, paren, expr)

def	output_root (self, expr, paren)

def	output_log (self, expr, paren)

def	output_minus (self, expr, paren)

def	output_piecewise (self, expr, paren)

def	open_paren (self, paren)

def	close_paren (self, paren)

def	open_block (self, **kwargs)

def	close_block (self, blank_line=True, **kwargs)

def	calculate_extended_dependencies (self, nodes, prune=[], prune_deps=[])
	Dependency related methods #. More...

def	output_equations (self, nodeset)

def	scan_for_lookup_tables (self)
	Lookup table methods #. More...

def	lut_access_code (self, table_index, table_name, i)

def	lut_parameters (self, key)

def	lut_size_calculation (self, min, max, step)

def	output_lut_generation (self, only_index=None)

def	output_lut_deletion (self, only_index=None)

def	output_lut_declarations (self)

def	output_lut_index_declarations (self, idx)

def	output_lut_indices (self)

def	output_lut_methods (self)

def	output_single_lookup (self, tidx, tname, result)

def	output_lut_row_lookup_methods (self)

def	output_lut_row_lookup_memory (self)

def	is_lookup_table (self, expr)

def	contained_table_indices (self, node)

def	lut_factor (self, idx, include_comma=False, include_type=False)

def	output_table_lookup (self, expr, paren)

def	output_table_index_generation (self, time_name, nodeset=set())

def	output_table_index_checking (self, key, idx)

def	output_table_index_generation_code (self, key, idx)

Static Public Member Functions
def	generate_interface (doc, solver_info)

Static Public Attributes
dictionary	translators = {}

string	STMT_END = ';'
	Various language tokens #. More...

string	EQ_ASSIGN = ' = '

string	COMMENT_START = '// '

string	DOXYGEN_COMMENT_START = '//! '

string	TYPE_DOUBLE = 'NekDouble '

string	TYPE_VOID = 'void '

string	TYPE_CONST_DOUBLE = 'const NekDouble '

string	TYPE_CONST_UNSIGNED = 'const unsigned '

string	TRUE = 'true'

string	FALSE = 'false'

string	PI = 'M_PI'

string	E = 'M_E'

string	NOT_A_NUMBER = 'NAN'

bool	USES_SUBSIDIARY_FILE = False

dictionary	FILE_EXTENSIONS

dictionary	function_map

dictionary	recip_trig

dictionary	nary_ops

dictionary	binary_ops

dictionary	special_roots = {2: 'sqrt', 3: 'cbrt'}

Private Member Functions
def	_vars_in (self, expr)

Private Attributes
	_main_output_to_subsidiary

	_original_out

Detailed Description

Base class for translators from CellML to programming languages.

Provides various methods & attributes that can be overridden to
achieve the desired output language and style.

Also contains a registration system for subclasses, so the
command-line client can know what translators are available.  See
the register method for more information.

Definition at line 98 of file translators.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.translators.CellMLTranslator.__init__	(	self,
		add_timestamp = `True`,
		options = `None`
	)

Create a translator.

Definition at line 167 of file translators.py.

    def __init__(self, add_timestamp=True, options=None):
        """Create a translator."""
        self.options = options
        # Initially output should not be indented
        self.indent_level = 0
        # Character to indent with
        self.indent_char = ' '
        # No. of occurrences of indent_char per indent_level
        self.indent_factor = 4
        # Whether to use lookup tables where possible
        self.use_lookup_tables = True
        # Whether to add a timestamp comment to generated files
        self.add_timestamp = add_timestamp
        # Main output goes to the main file by default
        self._main_output_to_subsidiary = False
 

Member Function Documentation

◆ _vars_in()

def CellMLToNektar.translators.CellMLTranslator._vars_in	(	self,
		expr
	)

private

Return a set of variable objects used in the given expression.

Will include state variables.  If the expression includes a derivative, the defining equation
for that derivative will be included in the set.  Also if an expression is being
replaced by a lookup table, this will only include the table key variable.

Definition at line 928 of file translators.py.

    def _vars_in(self, expr):
        """Return a set of variable objects used in the given expression.
 
        Will include state variables.  If the expression includes a derivative, the defining equation
        for that derivative will be included in the set.  Also if an expression is being
        replaced by a lookup table, this will only include the table key variable.
        """
        res = set()
        if self.use_lookup_tables and isinstance(expr, mathml) and self.is_lookup_table(expr):
            key_var = self.varobj(expr.getAttributeNS(NSS['lut'], u'var'))
            key_var = key_var.get_source_variable(recurse=True)
            res.add(key_var)
        elif isinstance(expr, mathml_ci):
            varobj = getattr(expr, '_cml_variable', None)
            if not varobj:
                varname = unicode(expr)
                varobj = self.varobj(varname.strip())
            if varobj:
                res.add(varobj)
        elif isinstance(expr, mathml_apply) and expr.operator().localName == u'diff':
            dep_varname = unicode(expr.ci)
            varobj = self.varobj(dep_varname.strip())
            res.add(varobj.get_ode_dependency(self.free_vars[0]))
        elif hasattr(expr, 'xml_children'):
            for child in expr.xml_children:
                res.update(self._vars_in(child))
        return res
 
 

References CellMLToNektar.translators.CellMLTranslator._vars_in(), CellMLToNektar.translators.CellMLTranslator.free_vars, CellMLToNektar.translators.CellMLTranslator.is_lookup_table(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.use_lookup_tables, CellMLToNektar.translators.CellMLTranslator.use_lookup_tables, and CellMLToNektar.translators.CellMLTranslator.varobj().

Referenced by CellMLToNektar.translators.CellMLTranslator._vars_in(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_backward_euler_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_grl_compute_partial(), and CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_rush_larsen_mathematics().

◆ calculate_extended_dependencies()

def CellMLToNektar.translators.CellMLTranslator.calculate_extended_dependencies	(	self,
		nodes,
		prune = `[]`,
		prune_deps = `[]`
	)

Dependency related methods #.

Method moved to cellml_model.

Definition at line 899 of file translators.py.

    def calculate_extended_dependencies(self, nodes, prune=[], prune_deps=[]):
        """Method moved to cellml_model."""
        
        # for var in nodes:
        #     self.writeln(var)
        # self.writeln()        
 
        # for var in self.model.calculate_extended_dependencies(nodes, prune, prune_deps):
        #     self.writeln(var)
        # self.writeln()
 
 
        return self.model.calculate_extended_dependencies(nodes, prune, prune_deps)
 

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

◆ capture_output()

def CellMLToNektar.translators.CellMLTranslator.capture_output ( self )

Make subsequent output operations write to a string buffer.

Definition at line 405 of file translators.py.

    def capture_output(self):
        """Make subsequent output operations write to a string buffer."""
        self._original_out = self.out
        self.out = StringIO()
    

◆ close_block()

def CellMLToNektar.translators.CellMLTranslator.close_block	(		self,
			blank_line = `True`,
		**	kwargs
	)

Close a code block and decrease indent.

Definition at line 885 of file translators.py.

    def close_block(self, blank_line=True, **kwargs):
        """Close a code block and decrease indent."""
        self.set_indent(offset=-1)
        self.writeln('}', **kwargs)
        if blank_line:
            self.writeln(**kwargs)
        return
 

References CellMLToNektar.translators.CellMLTranslator.set_indent(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ close_paren()

def CellMLToNektar.translators.CellMLTranslator.close_paren	(	self,
		paren
	)

Definition at line 878 of file translators.py.

    def close_paren(self, paren):
        if paren: self.write(')')
 

References CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_log(), CellMLToNektar.translators.CellMLTranslator.output_nary_operator(), CellMLToNektar.translators.CellMLTranslator.output_piecewise(), and CellMLToNektar.translators.CellMLTranslator.output_unary_operator().

◆ code_name()

def CellMLToNektar.translators.CellMLTranslator.code_name	(	self,
		var,
		ode = `False`,
		prefix = `None`
	)

Return the full name of var in a form suitable for inclusion in a
source file.

If ode is True then return the name of the derivative of var
instead.  We go directly to the source variable in this case,
rather than including intermediate assignment statements as is
done for connections.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 442 of file translators.py.

    def code_name(self, var, ode=False, prefix=None):
        """
        Return the full name of var in a form suitable for inclusion in a
        source file.
        
        If ode is True then return the name of the derivative of var
        instead.  We go directly to the source variable in this case,
        rather than including intermediate assignment statements as is
        done for connections.
        """
        if prefix is None:
            prefix = ['var_', 'd_dt_'][ode]
        if ode:
            var = var.get_source_variable(recurse=True)
        name = prefix + var.fullname(cellml=True)
        return name
    

◆ config()

def CellMLToNektar.translators.CellMLTranslator.config ( self )

Get the current document's configuration store.

Definition at line 198 of file translators.py.

    def config(self):
        """Get the current document's configuration store."""
        return getattr(self.doc, '_cml_config', None)
 

References Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, and CellMLToNektar.translators.ConfigurationStore.doc.

◆ contained_table_indices()

def CellMLToNektar.translators.CellMLTranslator.contained_table_indices	(	self,
		node
	)

Return all lookup tables used directly in computing this node.

If this is an expression node, checks all its children for table
lookups, and returns the set of table indices used.

Definition at line 1220 of file translators.py.

    def contained_table_indices(self, node):
        """Return all lookup tables used directly in computing this node.
 
        If this is an expression node, checks all its children for table
        lookups, and returns the set of table indices used.
        """
        result = set()
        if isinstance(node, amara.bindery.element_base):
            if self.is_lookup_table(node):
                result.add(node.table_index)
            else:
                for child in node.xml_children:
                    result.update(self.contained_table_indices(child))
        return result
    

References CellMLToNektar.translators.CellMLTranslator.contained_table_indices(), and CellMLToNektar.translators.CellMLTranslator.is_lookup_table().

Referenced by CellMLToNektar.translators.CellMLTranslator.contained_table_indices(), and CellMLToNektar.translators.CellMLTranslator.output_table_index_generation().

◆ error()

def CellMLToNektar.translators.CellMLTranslator.error	(	self,
		lines,
		xml = `None`
	)

Raise a translation error.

lines is a list of strings describing what went wrong.
A TranslationError with that message will be raised.

If xml is given, it should be an element, which will be
pretty-printed and included in the error.

Definition at line 183 of file translators.py.

    def error(self, lines, xml=None):
        """Raise a translation error.
 
        lines is a list of strings describing what went wrong.
        A TranslationError with that message will be raised.
 
        If xml is given, it should be an element, which will be
        pretty-printed and included in the error.
        """
        if xml is not None:
            lines.extend(xml.xml(indent = u'yes',
                                 omitXmlDeclaration = u'yes').split('\n'))
        raise TranslationError('\n'.join(lines))
 

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply(), CellMLToNektar.translators.CellMLTranslator.output_binary_operator(), CellMLToNektar.translators.CellMLTranslator.output_expr(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ eval_number()

def CellMLToNektar.translators.CellMLTranslator.eval_number	(	self,
		expr
	)

Evaluate a number.

If a (unicode) string, convert to float.
If a cn element, call its evaluate method.

Definition at line 697 of file translators.py.

    def eval_number(self, expr):
        """Evaluate a number.
 
        If a (unicode) string, convert to float.
        If a cn element, call its evaluate method.
        """
        if isinstance(expr, mathml_cn):
            return expr.evaluate()
        else:
            return float(unicode(expr))
 

Referenced by CellMLToNektar.translators.CellMLTranslator.output_number().

◆ final_configuration_hook()

def CellMLToNektar.translators.CellMLTranslator.final_configuration_hook ( self )

A hook for subclasses to do some final configuration.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 320 of file translators.py.

    def final_configuration_hook(self):
        """A hook for subclasses to do some final configuration."""
        return
 

◆ generate_interface()

def CellMLToNektar.translators.CellMLTranslator.generate_interface	(	doc,
		solver_info
	)

static

Generate an interface component connecting the model to whatever will use it.

Stub method that subclasses can override to implement this functionality.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 131 of file translators.py.

    def generate_interface(doc, solver_info):
        """Generate an interface component connecting the model to whatever will use it.
        
        Stub method that subclasses can override to implement this functionality.
        """
        pass
 

◆ get_captured_output()

def CellMLToNektar.translators.CellMLTranslator.get_captured_output ( self )

Stop capturing output, and return what was captured as a string.

Definition at line 410 of file translators.py.

    def get_captured_output(self):
        """Stop capturing output, and return what was captured as a string."""
        output = self.out.getvalue()
        self.out = self._original_out
        return output
 

References CellMLToNektar.translators.CellMLTranslator._original_out, and CellMLToNektar.translators.CellMLTranslator.out.

◆ include_guard()

def CellMLToNektar.translators.CellMLTranslator.include_guard ( self )

Get the include guard (for C/C++ output) for this cell model,
based on the class name.

Definition at line 488 of file translators.py.

    def include_guard(self):
        """
        Get the include guard (for C/C++ output) for this cell model,
        based on the class name.
        """
        return self.class_name.upper() + '_HPP_'
    

References CellMLToNektar.translators.CellMLTranslator.class_name.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ is_lookup_table()

def CellMLToNektar.translators.CellMLTranslator.is_lookup_table	(	self,
		expr
	)

Return True iff expr can be replaced by a lookup table.

Uses annotations from a previous analysis.

Definition at line 1214 of file translators.py.

    def is_lookup_table(self, expr):
        """Return True iff expr can be replaced by a lookup table.
 
        Uses annotations from a previous analysis."""
        return expr.getAttributeNS(NSS['lut'], u'possible', '') == u'yes'
    

Referenced by CellMLToNektar.translators.CellMLTranslator._vars_in(), CellMLToNektar.translators.CellMLTranslator.contained_table_indices(), and CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ lut_access_code()

def CellMLToNektar.translators.CellMLTranslator.lut_access_code	(	self,
		table_index,
		table_name,
		i
	)

Get the code for accessing the i'th element of the given table.

Definition at line 1062 of file translators.py.

    def lut_access_code(self, table_index, table_name, i):
        """Get the code for accessing the i'th element of the given table.
        """
        return '_lookup_table_%s[%s][%s]' % (table_index, i, table_name)
    

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_generation(), and CellMLToNektar.translators.CellMLTranslator.output_single_lookup().

◆ lut_factor()

def CellMLToNektar.translators.CellMLTranslator.lut_factor	(	self,
		idx,
		include_comma = `False`,
		include_type = `False`
	)

Return code for any extra factor needed to do a table lookup.

Will return the empty string unless linear interpolation is being used.

Definition at line 1235 of file translators.py.

    def lut_factor(self, idx, include_comma=False, include_type=False):
        """Return code for any extra factor needed to do a table lookup.
        
        Will return the empty string unless linear interpolation is being used.
        """
        if self.config.options.lookup_type == 'linear-interpolation':
            factor = '_factor_' + str(idx)
            if include_type: factor = self.TYPE_DOUBLE + factor
            if include_comma: factor = ', ' + factor
        else:
            factor = ''
        return factor
 

References CellMLToNektar.optimize.LookupTableAnalyser.config(), CellMLToNektar.translators.CellMLTranslator.config(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.TYPE_DOUBLE, and CellMLToNektar.translators.CellMLTranslator.TYPE_DOUBLE.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_index_declarations(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_indexing_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_methods(), CellMLToNektar.translators.CellMLTranslator.output_single_lookup(), CellMLToNektar.translators.CellMLTranslator.output_table_index_generation_code(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_table_index_generation_code(), and CellMLToNektar.translators.CellMLTranslator.output_table_lookup().

◆ lut_parameters()

def CellMLToNektar.translators.CellMLTranslator.lut_parameters	(	self,
		key
	)

Get the bounds and step size for a particular table.

key should be a key into self.lookup_table_indices.
Returns (min, max, step, step_inverse) suitable for putting in generated code.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 1067 of file translators.py.

    def lut_parameters(self, key):
        """Get the bounds and step size for a particular table.
        
        key should be a key into self.lookup_table_indices.
        Returns (min, max, step, step_inverse) suitable for putting in generated code.
        """
        return key[0:3] + [unicode(1 / float(key[2]))]
    

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_generation(), CellMLToNektar.translators.CellMLTranslator.output_table_index_checking(), and CellMLToNektar.translators.CellMLTranslator.output_table_index_generation_code().

◆ lut_size_calculation()

def CellMLToNektar.translators.CellMLTranslator.lut_size_calculation	(	self,
		min,
		max,
		step
	)

Return the equivalent of '1 + (unsigned)((max-min)/step+0.5)'.

Definition at line 1075 of file translators.py.

    def lut_size_calculation(self, min, max, step):
        """Return the equivalent of '1 + (unsigned)((max-min)/step+0.5)'."""
        return '1 + (unsigned)((%s-%s)/%s+0.5)' % (max, min, step)
 

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_generation().

◆ open_block()

def CellMLToNektar.translators.CellMLTranslator.open_block	(		self,
		**	kwargs
	)

Open a new code block and increase indent.

Definition at line 881 of file translators.py.

    def open_block(self, **kwargs):
        """Open a new code block and increase indent."""
        self.writeln('{', **kwargs)
        self.set_indent(offset=1)

References CellMLToNektar.translators.CellMLTranslator.set_indent(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ open_paren()

def CellMLToNektar.translators.CellMLTranslator.open_paren	(	self,
		paren
	)

Definition at line 876 of file translators.py.

876 def open_paren(self, paren):

877 if paren: self.write('(')

References CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_log(), CellMLToNektar.translators.CellMLTranslator.output_nary_operator(), CellMLToNektar.translators.CellMLTranslator.output_piecewise(), and CellMLToNektar.translators.CellMLTranslator.output_unary_operator().

◆ output_apply()

def CellMLToNektar.translators.CellMLTranslator.output_apply	(	self,
		expr,
		paren
	)

Output an <apply> expression.

paren is True if the context has requested parentheses.

Definition at line 731 of file translators.py.

    def output_apply(self, expr, paren):
        """Output an <apply> expression.
        
        paren is True if the context has requested parentheses.
        """
        op = expr.operator()
        if op.localName in self.function_map:
            self.output_function(self.function_map[op.localName],
                                 expr.operands(), paren)
        elif op.localName in self.recip_trig:
            self.output_function(self.function_map[self.recip_trig[op.localName]],
                                 expr.operands(), paren, reciprocal=True)
        elif op.localName == u'root':
            self.output_root(expr, paren)
        elif op.localName == u'log':
            self.output_log(expr, paren)
        elif op.localName in self.nary_ops:
            self.output_nary_operator(self.nary_ops[op.localName],
                                      expr.operands(), paren)
        elif op.localName in self.binary_ops:
            self.output_binary_operator(self.binary_ops[op.localName],
                                        expr.operands(), paren, expr)
        elif op.localName == u'minus':
            self.output_minus(expr, paren)
        elif op.localName == u'diff':
            # ODE occuring on the RHS
            self.write(self.code_name(op.dependent_variable, ode=True))
        else:
            # Unrecognised operator
            self.error(["Unsupported operator element " + str(op.localName)], xml=expr)
 

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ output_assignment()

def CellMLToNektar.translators.CellMLTranslator.output_assignment	(	self,
		expr
	)

Output an assignment expression.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 592 of file translators.py.

    def output_assignment(self, expr):
        """Output an assignment expression."""
        if isinstance(expr, cellml_variable):
            # self.writeln('Test')
            # This may be the assignment of a mapped variable, or a constant
            t = expr.get_type()
            if t == VarTypes.Mapped:
                # self.writeln(self.code_name(expr))
                self.writeln(self.TYPE_CONST_DOUBLE, self.code_name(expr),
                             self.EQ_ASSIGN,
                             self.code_name(expr.get_source_variable()),
                             self.STMT_END, nl=False)
                self.output_comment(expr.units, indent=False, pad=True)
            elif t == VarTypes.Constant:
                # self.writeln('Test')
                # self.writeln(self.code_name(expr))
 
 
                # setting various stim-parameters to zero, since Nektar uses its own stimulus
                if 'stim_amplitude' in str(self.code_name(expr)):
                    self.writeln(self.TYPE_CONST_DOUBLE, self.code_name(expr),
                                 self.EQ_ASSIGN, nl=False)
                    self.output_number(0)
                    self.writeln(self.STMT_END, indent=False, nl=False)
                    self.output_comment(expr.units, indent=False, pad=True)
                else:
                    self.writeln(self.TYPE_CONST_DOUBLE, self.code_name(expr),
                                 self.EQ_ASSIGN, nl=False)
                    self.output_number(expr.initial_value)
                    self.writeln(self.STMT_END, indent=False, nl=False)
                    self.output_comment(expr.units, indent=False, pad=True)
        else:
            # This is a mathematical expression
            self.writeln(self.TYPE_CONST_DOUBLE, nl=False)
            opers = expr.operands()
            self.output_lhs(opers.next())
            self.write(self.EQ_ASSIGN)
            self.output_expr(opers.next(), False)
            self.writeln(self.STMT_END, indent=False, nl=False)
            #1365: add a comment with the LHS units
            self.output_comment(expr._get_element_units(expr.eq.lhs, return_set=False).description(),
                                indent=False, pad=True)
 

Referenced by CellMLToNektar.translators.CellMLTranslator.output_equations(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_equations(), and CellMLToNektar.translators.CellMLTranslator.output_mathematics().

◆ output_binary_operator()

def CellMLToNektar.translators.CellMLTranslator.output_binary_operator	(	self,
		operator,
		operands,
		paren,
		expr
	)

Output a binary operator.

As output_nary_operator, but checks that len(list(operands)) == 2.

Definition at line 802 of file translators.py.

    def output_binary_operator(self, operator, operands, paren, expr):
        """Output a binary operator.
        
        As output_nary_operator, but checks that len(list(operands)) == 2.
        """
        operands = list(operands)
        if len(operands) != 2:
            self.error(["Binary operator" + operator +
                        "does not have 2 operands."], xml=expr)
        self.output_nary_operator(operator, operands, paren)
 

References CellMLToNektar.translators.CellMLTranslator.error(), and CellMLToNektar.translators.CellMLTranslator.output_nary_operator().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply(), and CellMLToNektar.translators.CellMLTranslator.output_minus().

◆ output_bottom_boilerplate()

def CellMLToNektar.translators.CellMLTranslator.output_bottom_boilerplate ( self )

Output bottom boilerplate

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 580 of file translators.py.

    def output_bottom_boilerplate(self):
        """Output bottom boilerplate"""
        self.writeln('\n')
        for i, var in enumerate(self.state_vars):
            self.writeln('rDY[', str(i), '] = ', self.code_name(var, True),
                         ';')
        self.close_block()
        self.set_indent(offset=-1)
        self.writeln('};\n')
        self.writeln('#endif')
        return
 

References CellMLToNektar.translators.CellMLTranslator.close_block(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.code_name(), CellMLToNektar.translators.CellMLTranslator.code_name(), CellMLToNektar.translators.CellMLTranslator.set_indent(), CellMLToNektar.translators.CellMLTranslator.state_vars, and CellMLToNektar.translators.CellMLTranslator.writeln().

Referenced by CellMLToNektar.translators.CellMLTranslator.translate().

◆ output_comment()

def CellMLToNektar.translators.CellMLTranslator.output_comment	(		self,
		*	args,
		**	kwargs
	)

Output a (multi-line) string as a comment.

Definition at line 416 of file translators.py.

    def output_comment(self, *args, **kwargs):
        """Output a (multi-line) string as a comment."""
        start = kwargs.get('start', self.COMMENT_START)
        if kwargs.get('pad', False):
            start = ' ' + start
        comment = ''.join(map(str, args))
        lines = comment.split('\n')
        for line in lines:
            self.writeln(start, line, **kwargs)
 

References CellMLToNektar.translators.CellMLTranslator.COMMENT_START, and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ output_doxygen()

def CellMLToNektar.translators.CellMLTranslator.output_doxygen	(		self,
		*	args,
		**	kwargs
	)

Output a (multi-line) string as a Doxygen comment.

Definition at line 426 of file translators.py.

    def output_doxygen(self, *args, **kwargs):
        """Output a (multi-line) string as a Doxygen comment."""
        kwargs['start'] = self.DOXYGEN_COMMENT_START
        self.output_comment(*args, **kwargs)
 

References CellMLToNektar.translators.CellMLTranslator.DOXYGEN_COMMENT_START, and CellMLToNektar.translators.CellMLTranslator.output_comment().

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_includes().

◆ output_equations()

def CellMLToNektar.translators.CellMLTranslator.output_equations	(	self,
		nodeset
	)

Output the mathematics described by nodeset.

nodeset represents a subset of the assignments in the model.
Output assignments in the order given by a topological sort,
but only include those in nodeset.

Since a set of assignments is given, this method does not
check whether variables are used - it is assumed that only
assignments that are actually wanted are given in nodeset.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 913 of file translators.py.

    def output_equations(self, nodeset):
        """Output the mathematics described by nodeset.
 
        nodeset represents a subset of the assignments in the model.
        Output assignments in the order given by a topological sort,
        but only include those in nodeset.
 
        Since a set of assignments is given, this method does not
        check whether variables are used - it is assumed that only
        assignments that are actually wanted are given in nodeset.
        """
        for expr in (e for e in self.model.get_assignments() if e in nodeset):
            self.output_assignment(expr)
        return
 

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

◆ output_expr()

def CellMLToNektar.translators.CellMLTranslator.output_expr	(	self,
		expr,
		paren
	)

Output the expression expr.

If paren is True then the context has requested parentheses around the
output; if expr requires them then they will be added.

Definition at line 646 of file translators.py.

    def output_expr(self, expr, paren):
        """Output the expression expr.
        
        If paren is True then the context has requested parentheses around the
        output; if expr requires them then they will be added.
        """
        if self.use_lookup_tables and self.is_lookup_table(expr):
            self.output_table_lookup(expr, paren)
        elif isinstance(expr, mathml_apply):
            self.output_apply(expr, paren)
        elif isinstance(expr, mathml_piecewise):
            self.output_piecewise(expr, paren)
        elif isinstance(expr, mathml_ci):
            self.output_variable(expr)
        elif expr.localName == u'cn':
            self.output_number(expr)
        elif expr.localName == u'degree':
            # <degree> is just a wrapper around an expression
            self.output_expr(child_i(expr, 1), paren)
        elif expr.localName == u'logbase':
            # <logbase> is just a wrapper around an expression
            self.output_expr(child_i(expr, 1), paren)
        elif expr.localName == u'true':
            self.write(self.TRUE)
        elif expr.localName == u'false':
            self.write(self.FALSE)
        elif expr.localName == u'pi':
            self.write(self.PI)
        elif expr.localName == u'exponentiale':
            self.write(self.E)
        else:
            self.error(["Unsupported expression element " + expr.localName],
                       xml=expr)
 

◆ output_file_name()

def CellMLToNektar.translators.CellMLTranslator.output_file_name	(	self,
		model_filename
	)

Generate a name for our output file, based on the input file.

Definition at line 324 of file translators.py.

    def output_file_name(self, model_filename):
        """Generate a name for our output file, based on the input file."""
        return os.path.splitext(model_filename)[0] + '.cpp'
    

◆ output_function()

def CellMLToNektar.translators.CellMLTranslator.output_function	(	self,
		func_name,
		args,
		paren,
		reciprocal = `False`
	)

Output a function call with name func_name and arguments args.

Parentheses are not required so paren is ignored.
If reciprocal is True then pass the reciprocal of each arg to
func_name.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 762 of file translators.py.

    def output_function(self, func_name, args, paren, reciprocal=False):
        """Output a function call with name func_name and arguments args.
        
        Parentheses are not required so paren is ignored.
        If reciprocal is True then pass the reciprocal of each arg to
        func_name.
        """
        self.write(func_name + '(')
        comma = False
        for arg in args:
            if comma: self.write(', ')
            else: comma = True
            if reciprocal:
                self.write('1/')
                self.output_expr(arg, True)
            else:
                self.output_expr(arg, False)
        self.write(')')
 

References CellMLToNektar.translators.CellMLTranslator.output_expr(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply(), CellMLToNektar.translators.CellMLTranslator.output_log(), and CellMLToNektar.translators.CellMLTranslator.output_root().

◆ output_lhs()

def CellMLToNektar.translators.CellMLTranslator.output_lhs	(	self,
		expr
	)

Output the left hand side of an assignment expression.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 635 of file translators.py.

    def output_lhs(self, expr):
        """Output the left hand side of an assignment expression."""
        if expr.localName == 'ci':
            self.output_variable(expr)
        elif expr.operator().localName == 'diff':
            self.write(self.code_name(expr.operator().dependent_variable, ode=True))
 

References CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.code_name(), CellMLToNektar.translators.CellMLTranslator.code_name(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_variable(), CellMLToNektar.translators.CellMLTranslator.output_variable(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_assignment().

◆ output_log()

def CellMLToNektar.translators.CellMLTranslator.output_log	(	self,
		expr,
		paren
	)

Output a logarithm to the given base, which defaults to base 10.

Definition at line 833 of file translators.py.

    def output_log(self, expr, paren):
        """Output a logarithm to the given base, which defaults to base 10."""
        if hasattr(expr, u'logbase'):
            # A base is provided.  Use the identity log_b(x) = log(x)/log(b)
            # TODO: Optimise for log2(x)
            self.open_paren(paren)
            self.output_function('log', expr.operands(), paren)
            self.write('/log(')
            self.output_expr(expr.logbase, False)
            self.write(')')
            self.close_paren(paren)
        else:
            # Use base 10
            self.output_function('log10', expr.operands(), paren)
 

References CellMLToNektar.translators.CellMLTranslator.close_paren(), CellMLToNektar.translators.CellMLTranslator.open_paren(), CellMLToNektar.translators.CellMLTranslator.output_expr(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_function(), CellMLToNektar.translators.CellMLTranslator.output_function(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply().

◆ output_lut_declarations()

def CellMLToNektar.translators.CellMLTranslator.output_lut_declarations ( self )

Output declarations for the lookup tables.

Definition at line 1126 of file translators.py.

    def output_lut_declarations(self):
        """Output declarations for the lookup tables."""
        self.output_comment('Lookup tables')
        # Allocate memory, per index variable for cache efficiency
        for idx in self.doc.lookup_table_indexes.itervalues():
            num_tables = unicode(self.doc.lookup_tables_num_per_index[idx])
            self.writeln(self.TYPE_DOUBLE, '(*_lookup_table_', idx, ')[', num_tables, ']', self.STMT_END)
        self.writeln()
 

References Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.CellMLTranslator.output_comment(), CellMLToNektar.translators.CellMLTranslator.STMT_END, CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.TYPE_DOUBLE, CellMLToNektar.translators.CellMLTranslator.TYPE_DOUBLE, and CellMLToNektar.translators.CellMLTranslator.writeln().

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ output_lut_deletion()

def CellMLToNektar.translators.CellMLTranslator.output_lut_deletion	(	self,
		only_index = `None`
	)

Output code to delete memory allocated for lookup tables.

Definition at line 1116 of file translators.py.

    def output_lut_deletion(self, only_index=None):
        """Output code to delete memory allocated for lookup tables."""
        for idx in self.doc.lookup_table_indexes.itervalues():
            if only_index is None or only_index == idx:
                self.writeln('if (_lookup_table_', idx, ')')
                self.open_block()
                self.writeln('delete[] _lookup_table_', idx, self.STMT_END)
                self.writeln('_lookup_table_', idx, self.EQ_ASSIGN, 'NULL', self.STMT_END)
                self.close_block(blank_line=False)
 

References CellMLToNektar.translators.CellMLTranslator.close_block(), Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.CellMLTranslator.EQ_ASSIGN, CellMLToNektar.translators.CellMLTranslator.open_block(), CellMLToNektar.translators.CellMLTranslator.STMT_END, and CellMLToNektar.translators.CellMLTranslator.writeln().

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ output_lut_generation()

def CellMLToNektar.translators.CellMLTranslator.output_lut_generation	(	self,
		only_index = `None`
	)

Output code to generate lookup tables.

There should be a list of suitable expressions available as self.doc.lookup_tables,
to save having to search the whole model.

If only_index is given, only generate tables using the given table index key.

Definition at line 1079 of file translators.py.

    def output_lut_generation(self, only_index=None):
        """Output code to generate lookup tables.
 
        There should be a list of suitable expressions available as self.doc.lookup_tables,
        to save having to search the whole model.
        
        If only_index is given, only generate tables using the given table index key.
        """
        # Don't use table lookups to generate the tables!
        self.use_lookup_tables = False
        # Allocate memory for tables
        for key, idx in self.doc.lookup_table_indexes.iteritems():
            if only_index is None or only_index == idx:
                min, max, step, _ = self.lut_parameters(key)
                self.writeln(self.TYPE_CONST_UNSIGNED, '_table_size_', idx, self.EQ_ASSIGN,
                             self.lut_size_calculation(min, max, step), self.STMT_END)
                self.writeln('_lookup_table_', idx, self.EQ_ASSIGN, 'new double[_table_size_', idx,
                             '][', self.doc.lookup_tables_num_per_index[idx], ']', self.STMT_END)
        # Generate each table in a separate loop
        for expr in self.doc.lookup_tables:
            var = expr.component.get_variable_by_name(expr.var)
            key = (expr.min, expr.max, expr.step, var.get_source_variable(recurse=True))
            idx = self.doc.lookup_table_indexes[key]
            if only_index is not None and only_index != idx:
                continue
            min, max, step, _ = self.lut_parameters(key)
            j = expr.table_name
            self.writeln('for (unsigned i=0 ; i<_table_size_', idx, '; i++)')
            self.open_block()
            self.writeln(self.TYPE_CONST_DOUBLE, self.code_name(var), self.EQ_ASSIGN, min,
                         ' + i*', step, self.STMT_END)
            self.writeln(self.lut_access_code(idx, j, 'i'), self.EQ_ASSIGN, nl=False)
            self.output_expr(expr, False)
            self.writeln(self.STMT_END, indent=False)
            self.close_block()
        self.use_lookup_tables = True
 

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ output_lut_index_declarations()

def CellMLToNektar.translators.CellMLTranslator.output_lut_index_declarations	(	self,
		idx
	)

Output declarations the variables used to index this table.

Definition at line 1135 of file translators.py.

    def output_lut_index_declarations(self, idx):
        """Output declarations the variables used to index this table."""
        self.writeln('unsigned _table_index_', idx, self.STMT_END)
        factor = self.lut_factor(idx, include_type=True)
        if factor:
            self.writeln(factor, self.STMT_END)
        if self.row_lookup_method:
            self.writeln('double* _lt_', idx, '_row', self.STMT_END)
 

References CellMLToNektar.translators.CellMLTranslator.lut_factor(), CellMLToNektar.translators.CellMLTranslator.row_lookup_method, CellMLToNektar.translators.CellMLTranslator.STMT_END, and CellMLToNektar.translators.CellMLTranslator.writeln().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_indices().

◆ output_lut_indices()

def CellMLToNektar.translators.CellMLTranslator.output_lut_indices ( self )

Output declarations for the lookup table indices.

Definition at line 1144 of file translators.py.

    def output_lut_indices(self):
        """Output declarations for the lookup table indices."""
        self.output_comment('Lookup table indices')
        for idx in self.doc.lookup_table_indexes.itervalues():
            self.output_lut_index_declarations(idx)
        self.writeln()
    

References Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.CellMLTranslator.output_comment(), CellMLToNektar.translators.CellMLTranslator.output_lut_index_declarations(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ output_lut_methods()

def CellMLToNektar.translators.CellMLTranslator.output_lut_methods ( self )

Output the methods which look up values from lookup tables.

Definition at line 1151 of file translators.py.

    def output_lut_methods(self):
        """Output the methods which look up values from lookup tables."""
        if self.row_lookup_method:
            self.output_lut_row_lookup_methods()
            return
        self.output_comment('Methods to look up values from lookup tables')
        self.output_comment('using ', self.config.options.lookup_type)
        for expr in self.doc.lookup_tables:
            j = expr.table_name
            idx = expr.table_index
            self.writeln('inline double _lookup_', j, '(unsigned i',
                         self.lut_factor('', include_type=True, include_comma=True), ')')
            self.open_block()
            self.output_single_lookup(idx, j, 'return ')
            self.close_block()
        self.writeln()
        return
 

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ output_lut_row_lookup_memory()

def CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_memory ( self )

Output declarations for the memory used by the row lookup methods.

Definition at line 1204 of file translators.py.

    def output_lut_row_lookup_memory(self):
        """Output declarations for the memory used by the row lookup methods."""
        self.output_comment('Row lookup methods memory')
        for key, idx in self.doc.lookup_table_indexes.iteritems():
            min, max, step, var = key
            num_tables = unicode(self.doc.lookup_tables_num_per_index[idx])
            self.writeln('double _lookup_table_', idx, '_row[', num_tables, '];')
        self.writeln()
        return
 

References Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, CellMLToNektar.translators.ConfigurationStore.doc, CellMLToNektar.translators.CellMLTranslator.output_comment(), and CellMLToNektar.translators.CellMLTranslator.writeln().

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class().

◆ output_lut_row_lookup_methods()

def CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_methods ( self )

Write methods that return a whole row of a lookup table.

Note: assumes that table names are numbered sequentially from 0.

Definition at line 1183 of file translators.py.

    def output_lut_row_lookup_methods(self):
        """Write methods that return a whole row of a lookup table.
 
        Note: assumes that table names are numbered sequentially from 0.
        """
        self.output_comment('Row lookup methods')
        self.output_comment('using ', self.config.options.lookup_type)
        for key, idx in self.doc.lookup_table_indexes.iteritems():
            num_tables = unicode(self.doc.lookup_tables_num_per_index[idx])
            self.writeln('double* _lookup_', idx, '_row(unsigned i',
                         self.lut_factor('', include_type=True, include_comma=True), ')')
            self.open_block()
            self.writeln('for (unsigned j=0; j<', num_tables, '; j++)')
            self.open_block()
            self.output_single_lookup(idx, 'j', '_lookup_table_%s_row[j] = ' % idx)
            self.close_block(False)
            self.writeln('return _lookup_table_', idx, '_row;')
            self.close_block()
        self.writeln()
        return
    

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_methods().

◆ output_mathematics()

def CellMLToNektar.translators.CellMLTranslator.output_mathematics ( self )

Output the mathematics in this model.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 566 of file translators.py.

    def output_mathematics(self):
        """Output the mathematics in this model."""
        self.writeln(self.COMMENT_START, 'Mathematics')
        for expr in self.model.get_assignments():
            # Check this expression is actually used; don't output if not
            var = None
            if isinstance(expr, mathml_apply) and expr.is_assignment():
                var = expr.assigned_variable()
            elif isinstance(expr, cellml_variable):
                var = expr
            if not (var and var.get_usage_count() == 0):
                self.output_assignment(expr)
        return
 

References CellMLToNektar.translators.CellMLTranslator.COMMENT_START, CellMLToNektar.processors.ModelModifier.model, CellMLToNektar.pycml.cellml_variable.model(), CellMLToNektar.pycml.mathml.model(), CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_assignment(), CellMLToNektar.translators.CellMLTranslator.output_assignment(), and CellMLToNektar.translators.CellMLTranslator.writeln().

Referenced by CellMLToNektar.translators.CellMLTranslator.translate().

◆ output_minus()

def CellMLToNektar.translators.CellMLTranslator.output_minus	(	self,
		expr,
		paren
	)

Output either a unary or binary minus.

Which is chosen depends on the number of operands.

Definition at line 848 of file translators.py.

    def output_minus(self, expr, paren):
        """Output either a unary or binary minus.
 
        Which is chosen depends on the number of operands.
        """
        operands = list(expr.operands())
        if len(operands) == 1:
            self.output_unary_operator('-', operands[0], paren)
        else:
            self.output_binary_operator('-', operands, paren, expr)
 

References CellMLToNektar.translators.CellMLTranslator.output_binary_operator(), and CellMLToNektar.translators.CellMLTranslator.output_unary_operator().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply().

◆ output_nary_operator()

def CellMLToNektar.translators.CellMLTranslator.output_nary_operator	(	self,
		operator,
		operands,
		paren
	)

Output an n-ary operator (using infix notation).

If paren is True, enclose the output in parentheses.

Definition at line 781 of file translators.py.

    def output_nary_operator(self, operator, operands, paren):
        """Output an n-ary operator (using infix notation).
        
        If paren is True, enclose the output in parentheses.
        """
        # TODO: Optimise - to use expm1(x) for computing exp(x)-1
        self.open_paren(paren)
        op = False
        for operand in operands:
            if op: self.write(' ' + operator + ' ')
            else: op = True
            self.output_expr(operand, True)
        self.close_paren(paren)
 

References CellMLToNektar.translators.CellMLTranslator.close_paren(), CellMLToNektar.translators.CellMLTranslator.open_paren(), CellMLToNektar.translators.CellMLTranslator.output_expr(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply(), and CellMLToNektar.translators.CellMLTranslator.output_binary_operator().

◆ output_number()

def CellMLToNektar.translators.CellMLTranslator.output_number	(	self,
		expr
	)

Output the plain number expr.

We make all constants parse as doubles to avoid problems with
integer division or numbers too large for the int type.

Negative numbers will be prefixed by a space to avoid unwanted
decrement operations.

Definition at line 680 of file translators.py.

    def output_number(self, expr):
        """Output the plain number expr.
        
        We make all constants parse as doubles to avoid problems with
        integer division or numbers too large for the int type.
        
        Negative numbers will be prefixed by a space to avoid unwanted
        decrement operations.
        """
        n = self.eval_number(expr)
        num = "%.17g" % n
        if num[0] == '-':
            num = ' ' + num
        if not '.' in num and not 'e' in num:
            num = num + '.0'
        self.write(num)
 

References CellMLToNektar.translators.CellMLTranslator.eval_number(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_assignment(), and CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ output_piecewise()

def CellMLToNektar.translators.CellMLTranslator.output_piecewise	(	self,
		expr,
		paren
	)

Output the piecewise expression expr.

We use a cascading ternary if expression for simplicity.

Definition at line 859 of file translators.py.

    def output_piecewise(self, expr, paren):
        """Output the piecewise expression expr.
 
        We use a cascading ternary if expression for simplicity.
        """
        self.open_paren(paren)
        for piece in getattr(expr, u'piece', []):
            self.output_expr(child_i(piece, 2), True) # Condition
            self.write(' ? ')
            self.output_expr(child_i(piece, 1), True) # Result
            self.write(' : ')
        if hasattr(expr, u'otherwise'):
            self.output_expr(child_i(expr.otherwise, 1), True) # Default case
        else:
            self.write(self.NOT_A_NUMBER)
        self.close_paren(paren)
 

References CellMLToNektar.pycml.child_i(), CellMLToNektar.translators.CellMLTranslator.close_paren(), CellMLToNektar.translators.CellMLTranslator.NOT_A_NUMBER, CellMLToNektar.translators.CellMLTranslator.open_paren(), CellMLToNektar.translators.CellMLTranslator.output_expr(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ output_root()

def CellMLToNektar.translators.CellMLTranslator.output_root	(	self,
		expr,
		paren
	)

Output a root taken to some degree.

If a degree qualifier element is not provided, uses default 2.

Definition at line 814 of file translators.py.

    def output_root(self, expr, paren):
        """Output a root taken to some degree.
 
        If a degree qualifier element is not provided, uses default 2.
        """
        if hasattr(expr, u'degree'):
            # A degree is given.  Compute x^(1/b)
            # TODO: Optimise for when b==2 (sqrt) or b==3 (cbrt)
            # Try to evaluate expr.degree, and if the result is a key
            # of self.special_roots, use the value as the function to call.
            self.write('pow(')
            self.output_expr(expr.operands().next(), False)
            self.write(', 1/')
            self.output_expr(expr.degree, True)
            self.write(')')
        else:
            # Compute square root
            self.output_function('sqrt', expr.operands(), paren)
 

References CellMLToNektar.translators.CellMLTranslator.output_expr(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_function(), CellMLToNektar.translators.CellMLTranslator.output_function(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply().

◆ output_single_lookup()

def CellMLToNektar.translators.CellMLTranslator.output_single_lookup	(	self,
		tidx,
		tname,
		result
	)

Write the lookup calculation for a single entry.

Used by output_lut_row_lookup_methods and output_lut_methods.

Definition at line 1169 of file translators.py.

    def output_single_lookup(self, tidx, tname, result):
        """Write the lookup calculation for a single entry.
        
        Used by output_lut_row_lookup_methods and output_lut_methods.
        """
        self.writeln(self.TYPE_CONST_DOUBLE, 'y1', self.EQ_ASSIGN,
                     self.lut_access_code(tidx, tname, 'i'), self.STMT_END)
        if self.config.options.lookup_type == 'linear-interpolation':
            self.writeln(self.TYPE_CONST_DOUBLE, 'y2', self.EQ_ASSIGN,
                         self.lut_access_code(tidx, tname, 'i+1'), self.STMT_END)
            self.writeln(result, 'y1 + (y2-y1)*', self.lut_factor(''), self.STMT_END)
        else:
            self.writeln(result, 'y1', self.STMT_END)
 

References CellMLToNektar.optimize.LookupTableAnalyser.config(), CellMLToNektar.translators.CellMLTranslator.config(), CellMLToNektar.translators.CellMLTranslator.EQ_ASSIGN, CellMLToNektar.translators.CellMLTranslator.lut_access_code(), CellMLToNektar.translators.CellMLTranslator.lut_factor(), CellMLToNektar.translators.CellMLTranslator.STMT_END, CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.TYPE_CONST_DOUBLE, CellMLToNektar.translators.CellMLTranslator.TYPE_CONST_DOUBLE, and CellMLToNektar.translators.CellMLTranslator.writeln().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_methods(), and CellMLToNektar.translators.CellMLTranslator.output_lut_row_lookup_methods().

◆ output_table_index_checking()

def CellMLToNektar.translators.CellMLTranslator.output_table_index_checking	(	self,
		key,
		idx
	)

Check whether a table index is out of bounds.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 1302 of file translators.py.

    def output_table_index_checking(self, key, idx):
        """Check whether a table index is out of bounds."""
        if self.config.options.check_lt_bounds:
            var = key[-1]
            min, max, _, _ = self.lut_parameters(key)
            varname = self.code_name(var)
            self.writeln('bool _oob_', idx, self.EQ_ASSIGN, 'false', self.STMT_END)
            self.writeln('if (', varname, '>', max, ' || ', varname, '<', min, ')')
            self.open_block()
            self.writeln('#define COVERAGE_IGNORE', indent=False)
            if self.constrain_table_indices:
                self.writeln('if (', varname, '>', max, ') ', varname, self.EQ_ASSIGN, max, self.STMT_END)
                self.writeln('else ', varname, self.EQ_ASSIGN, min, self.STMT_END)
            else:
                self.writeln('_oob_', idx, self.EQ_ASSIGN, 'true', self.STMT_END)
            self.writeln('#undef COVERAGE_IGNORE', indent=False)
            self.close_block(blank_line=False)
    

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_indexing_methods(), and CellMLToNektar.translators.CellMLTranslator.output_table_index_generation().

◆ output_table_index_generation()

def CellMLToNektar.translators.CellMLTranslator.output_table_index_generation	(	self,
		time_name,
		nodeset = `set()`
	)

Output code to calculate indexes into any lookup tables.

If time_name is given and table bounds are being checked, the time value will be included in the
error message.  Note that we need to pass it in, since in some contexts the free variable is not
defined.

If nodeset is given, then filter the table indices calculated so
that only those needed to compute the nodes in nodeset are defined.

A nodeset is required if any table indices are computed variables rather than state variables.
In this case, we use the equations within nodeset to calculate the values of the indices, and
return a set containing just those nodes used, so we can avoid recalculating them later.

Definition at line 1258 of file translators.py.

    def output_table_index_generation(self, time_name, nodeset=set()):
        """Output code to calculate indexes into any lookup tables.
        
        If time_name is given and table bounds are being checked, the time value will be included in the
        error message.  Note that we need to pass it in, since in some contexts the free variable is not
        defined.
        
        If nodeset is given, then filter the table indices calculated so
        that only those needed to compute the nodes in nodeset are defined.
        
        A nodeset is required if any table indices are computed variables rather than state variables.
        In this case, we use the equations within nodeset to calculate the values of the indices, and
        return a set containing just those nodes used, so we can avoid recalculating them later.
        """
        tables_to_index = set()
        nodes_used = set()
        for node in nodeset:
            tables_to_index.update(self.contained_table_indices(node))
        if tables_to_index or not nodeset:
            self.output_comment('Lookup table indexing')
        for key, idx in self.doc.lookup_table_indexes.iteritems():
            if not nodeset or idx in tables_to_index:
                var = key[-1]
                if var.get_type() is VarTypes.Computed:
                    if not nodeset:
                        raise TranslationError('Unable to generate lookup table indexed on', var, 'as it is a computed variable')
                    var_nodes = self.calculate_extended_dependencies([var]) & nodeset
                    self.output_equations(var_nodes)
                    nodes_used.update(var_nodes)
                self.output_table_index_checking(key, idx)
                if self.config.options.check_lt_bounds:
                    self.writeln('#define COVERAGE_IGNORE', indent=False)
                    self.writeln('if (_oob_', idx, ')')
                    if time_name is None:
                        dump_state_args = 'rY'
                    else:
                        dump_state_args = 'rY, ' + time_name
                    self.writeln('EXCEPTION(DumpState("', self.var_display_name(key[-1]),
                                 ' outside lookup table range", ', dump_state_args,'));', indent_offset=1)
                    self.writeln('#undef COVERAGE_IGNORE', indent=False)
                self.output_table_index_generation_code(key, idx)
        self.writeln()
        return nodes_used
        

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.calculate_lookup_table_indices(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ output_table_index_generation_code()

def CellMLToNektar.translators.CellMLTranslator.output_table_index_generation_code	(	self,
		key,
		idx
	)

Method called by output_table_index_generation to output the code for a single table.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 1320 of file translators.py.

    def output_table_index_generation_code(self, key, idx):
        """Method called by output_table_index_generation to output the code for a single table."""
        index_type = 'const unsigned '
        factor_type = 'const double '
        row_type = 'const double* const '
        var = key[-1]
        min, max, _, step_inverse = self.lut_parameters(key)
        offset = '_offset_' + idx
        offset_over_step = offset + '_over_table_step'
        varname = self.code_name(var)
        self.writeln(self.TYPE_CONST_DOUBLE, offset, self.EQ_ASSIGN, varname, ' - ', min, self.STMT_END)
        self.writeln(self.TYPE_CONST_DOUBLE, offset_over_step, self.EQ_ASSIGN,
                     offset, ' * ', step_inverse, self.STMT_END)
        idx_var = '_table_index_' + str(idx)
        if self.config.options.lookup_type == 'nearest-neighbour':
            if self.lt_index_uses_floor:
                self.writeln(index_type, idx_var, ' = (unsigned) round(', offset_over_step, ');')
            else:
                self.writeln(index_type, idx_var, ' = (unsigned) (', offset_over_step, '+0.5);')
        else:
            if self.lt_index_uses_floor:
                self.writeln(index_type, idx_var, ' = (unsigned) floor(', offset_over_step, ');')
            else:
                self.writeln(index_type, idx_var, ' = (unsigned)(', offset_over_step, ');')
            factor = self.lut_factor(idx)
            if factor:
                self.writeln(factor_type, factor, ' = ', offset_over_step, ' - ', idx_var, self.STMT_END)
        if self.row_lookup_method:
            self.writeln(row_type, '_lt_', idx, '_row = ', self.lookup_method_prefix, '_lookup_', idx,
                         '_row(', idx_var, self.lut_factor(idx, include_comma=True), ');')
 
 
 
 

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_indexing_methods(), and CellMLToNektar.translators.CellMLTranslator.output_table_index_generation().

◆ output_table_lookup()

def CellMLToNektar.translators.CellMLTranslator.output_table_lookup	(	self,
		expr,
		paren
	)

Output code to look up expr in the appropriate table.

Definition at line 1248 of file translators.py.

    def output_table_lookup(self, expr, paren):
        """Output code to look up expr in the appropriate table."""
        i = expr.table_index
        if self.row_lookup_method:
            self.write('_lt_', i, '_row[', expr.table_name, ']')
        else:
            self.write(self.lookup_method_prefix, '_lookup_', expr.table_name,
                       '(_table_index_', i, self.lut_factor(i, include_comma=True), ')')
        return
 

References CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.lookup_method_prefix, CellMLToNektar.translators.CellMLTranslator.lookup_method_prefix, CellMLToNektar.translators.CellMLTranslator.lut_factor(), CellMLToNektar.translators.CellMLTranslator.row_lookup_method, and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ output_top_boilerplate()

def CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate ( self )

Output top boilerplate.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 495 of file translators.py.

    def output_top_boilerplate(self):
        """Output top boilerplate."""
        self.writeln('#ifndef _', self.include_guard, '_')
        self.writeln('#define _', self.include_guard, '_\n')
        self.output_comment('Model: ', self.model.name)
        self.output_comment(version_comment(self.add_timestamp))
        self.writeln()
        self.writeln('#include <cmath>')
        self.writeln('#include "AbstractOdeSystem.hpp"')
        self.writeln('#include "Exception.hpp"')
        self.writeln('#include "AbstractStimulusFunction.hpp"\n')
        self.writeln('class ', self.class_name, ' : public AbstractOdeSystem')
        self.writeln('{')
        self.writeln('private:')
        self.writeln('AbstractStimulusFunction *mpStimulus;\n',
                     indent_offset=1)
        self.writeln('public:')
        self.set_indent(1)
        self.writeln('const static unsigned _NB_OF_STATE_VARIABLES_ = ',
                   str(len(self.state_vars)), ';\n')
        self.writeln('//', ('-'*66))
        self.writeln('// Methods')
        self.writeln('//', ('-'*66), '\n')
        # Constructor
        self.writeln('', self.class_name,
                   '(AbstractStimulusFunction *stim)')
        self.writeln('    : AbstractOdeSystem(_NB_OF_STATE_VARIABLES_, ',
                     self.v_index, ')')
        self.open_block()
        self.writeln('mpStimulus = stim;\n')
        for var in self.state_vars:
            self.writeln('mVariableNames.push_back("', var.name, '");')
            self.writeln('mVariableUnits.push_back("', var.units, '");')
            init_val = getattr(var, u'initial_value', None)
            if init_val is None:
                init_comm = ' // Value not given in model'
                # Don't want compiler error, but shouldn't be a real number
                init_val = self.NOT_A_NUMBER
            else:
                init_comm = ''
            self.writeln('mInitialConditions.push_back(', init_val, ');',
                       init_comm, '\n')
        if self.use_lookup_tables: self.output_lut_generation()
        self.close_block()
        # Destructor
        self.writeln('~', self.class_name, '(void)')
        self.open_block()
        if self.use_lookup_tables: self.output_lut_deletion()
        self.close_block()
        # Lookup table declarations & methods
        if self.use_lookup_tables:
            self.output_lut_declarations()
            self.output_lut_methods()
        # Evaluation function
        self.writeln('void EvaluateYDerivatives (')
        self.writeln('        double ', self.code_name(self.free_vars[0]), ',')
        self.writeln('        const std::vector<double> &rY,')
        self.writeln('        std::vector<double> &rDY)')
        self.open_block()
        self.writeln('// Inputs:')
        self.writeln('// Time units: ', self.free_vars[0].units)
        for i, var in enumerate(self.state_vars):
            self.writeln('double ', self.code_name(var),
                         ' = rY[', str(i), '];')
            self.writeln('// Units: ', var.units, '; Initial value: ',
                         getattr(var, u'initial_value', 'Unknown'))
        self.writeln()
        if self.use_lookup_tables:
            self.output_table_index_generation()
        return
 

Referenced by CellMLToNektar.translators.CellMLTranslator.translate().

◆ output_unary_operator()

def CellMLToNektar.translators.CellMLTranslator.output_unary_operator	(	self,
		operator,
		operand,
		paren
	)

Output a unary operator (using prefix notation).

Definition at line 795 of file translators.py.

    def output_unary_operator(self, operator, operand, paren):
        """Output a unary operator (using prefix notation)."""
        self.open_paren(paren)
        self.write(operator)
        self.output_expr(operand, True)
        self.close_paren(paren)
 

References CellMLToNektar.translators.CellMLTranslator.close_paren(), CellMLToNektar.translators.CellMLTranslator.open_paren(), CellMLToNektar.translators.CellMLTranslator.output_expr(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_minus().

◆ output_variable()

def CellMLToNektar.translators.CellMLTranslator.output_variable	(	self,
		ci_elt,
		ode = `False`
	)

Output a ci element, i.e. a variable lookup.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 642 of file translators.py.

    def output_variable(self, ci_elt, ode=False):
        """Output a ci element, i.e. a variable lookup."""
        self.write(self.code_name(ci_elt.variable, ode=ode))
 

References CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.code_name(), CellMLToNektar.translators.CellMLTranslator.code_name(), and CellMLToNektar.translators.CellMLTranslator.write().

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_get_i_ionic(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lhs(), and CellMLToNektar.translators.CellMLTranslator.output_lhs().

◆ register()

def CellMLToNektar.translators.CellMLTranslator.register	(	cls,
		subclass,
		name
	)

Register a new translator subclass.

Registers the subclass `subclass' with name `name' in the
translators class attribute of CellMLTranslator.  If the name
given is already in use, raises NameAlreadyRegistered.

Definition at line 117 of file translators.py.

    def register(cls, subclass, name):
        """Register a new translator subclass.
 
        Registers the subclass `subclass' with name `name' in the
        translators class attribute of CellMLTranslator.  If the name
        given is already in use, raises NameAlreadyRegistered.
        """
        if name in cls.translators:
            raise cls.NameAlreadyRegistered(name)
        cls.translators[name] = subclass
        return
    
 

References CellMLToNektar.translators.CellMLTranslator.translators.

◆ scan_for_lookup_tables()

def CellMLToNektar.translators.CellMLTranslator.scan_for_lookup_tables ( self )

Lookup table methods #.

Search for lookup tables used in this document.

Store a list of suitable expressions on the document root.
Generate a dictionary mapping tables to their index variables.

Definition at line 980 of file translators.py.

    def scan_for_lookup_tables(self):
        """Search for lookup tables used in this document.
 
        Store a list of suitable expressions on the document root.
        Generate a dictionary mapping tables to their index variables.
        """
        doc = self.doc
        # Get list of suitable expressions
        doc.lookup_tables = doc.xml_xpath(u"//*[@lut:possible='yes']")
        doc.lookup_tables.sort(cmp=element_path_cmp)
        # Map table keys (min, max, step, var) to an index variable
        doc.lookup_table_indexes = {}
        # Count the no. of lookup tables with each index variable
        doc.lookup_tables_num_per_index = {}
        if not doc.lookup_tables:
            # If no suitable expressions, we're done
            return
        # Search for table index variables already assigned
        table_indexes = [int(getattr(expr, u'table_index', -1))
                         for expr in doc.lookup_tables]
        tidx = max(table_indexes) + 1
        # Search for table names already assigned
        table_numbers = {}
        for expr in doc.lookup_tables:
            if hasattr(expr, u'table_name'):
                idx = expr.table_index
                table_numbers[idx] = max(table_numbers.get(idx, 0), 1 + int(expr.table_name))
        # Now assign new names, and construct mapping from tables to index variables
        for expr in doc.lookup_tables:
            # Get a suitable table index variable
            comp = expr.get_component()
            var = comp.get_variable_by_name(expr.var)
            var = var.get_source_variable(recurse=True)
            key = (expr.min, expr.max, expr.step, var)
            if not key in doc.lookup_table_indexes:
                var._cml_modifiable = True # Table index variables shouldn't be const, in case we constrain to table bounds
                if hasattr(expr, u'table_index'):
                    doc.lookup_table_indexes[key] = expr.table_index
                else:
                    doc.lookup_table_indexes[key] = unicode(tidx)
                    tidx += 1
                    expr.xml_set_attribute((u'lut:table_index', NSS['lut']),
                                           doc.lookup_table_indexes[key])
            # Get a table name, unique over all tables with this index variable
            if not hasattr(expr, u'table_name'):
                tnum = table_numbers.get(doc.lookup_table_indexes[key], 0)
                expr.xml_set_attribute((u'lut:table_name', NSS['lut']), unicode(tnum))
                table_numbers[doc.lookup_table_indexes[key]] = tnum + 1
        # Re-number table indices so they are contiguous starting from 0.
        table_index_map = {}
        table_name_map = {}
        tidx = 0
        for key in sorted(doc.lookup_table_indexes.keys()):
            idx = unicode(tidx)
            table_index_map[doc.lookup_table_indexes[key]] = idx
            table_name_map[idx] = {}
            doc.lookup_table_indexes[key] = idx
            doc.lookup_tables_num_per_index[idx] = 0
            tidx += 1
        # Make sure each lookup table is only listed once in doc.lookup_tables,
        # so we don't get 2 tables for the same expression!
        # Also re-number table names so they are contiguous starting from 0 for each table index.
        candidates = doc.lookup_tables[:]
        doc.lookup_tables = []
        listed = set()
        for expr in candidates:
            tid = (expr.table_index, expr.table_name)
            if not tid in listed:
                listed.add(tid)
                doc.lookup_tables.append(expr)
                # Renumber
                expr.table_index = table_index_map[expr.table_index]
                table_name_map[expr.table_index][expr.table_name] = unicode(doc.lookup_tables_num_per_index[expr.table_index])
                expr.table_name = table_name_map[expr.table_index][expr.table_name]
                # Increment count for this index variable
                doc.lookup_tables_num_per_index[expr.table_index] += 1
            else:
                # Just renumber to match the new id for this expression
                expr.table_index = table_index_map[expr.table_index]
                expr.table_name = table_name_map[expr.table_index][expr.table_name]
        return
 

References Nektar::LibUtilities::H5DataSource.doc, CellMLToNektar.optimize.PartialEvaluator.doc, CellMLToNektar.optimize.LookupTableAnalyser.doc, CellMLToNektar.translators.CellMLTranslator.doc, and CellMLToNektar.translators.ConfigurationStore.doc.

◆ send_main_output_to_subsidiary()

def CellMLToNektar.translators.CellMLTranslator.send_main_output_to_subsidiary	(	self,
		to_subsidiary = `True`
	)

Set subsequent main-file writes to go to the subsidiary file instead.

Supplying a False argument reverts this setting.

Has no effect if not using a subsidiary file.

Definition at line 355 of file translators.py.

    def send_main_output_to_subsidiary(self, to_subsidiary=True):
        """Set subsequent main-file writes to go to the subsidiary file instead.
        
        Supplying a False argument reverts this setting.
        
        Has no effect if not using a subsidiary file.
        """
        self._main_output_to_subsidiary = to_subsidiary
 

References CellMLToNektar.translators.CellMLTranslator._main_output_to_subsidiary.

◆ set_indent()

def CellMLToNektar.translators.CellMLTranslator.set_indent	(	self,
		level = `None`,
		offset = `None`
	)

Set the indentation level for subsequent writes.

If offset is given, adjust the level by that amount, otherwise
set it to an absolute value.

Definition at line 431 of file translators.py.

    def set_indent(self, level=None, offset=None):
        """Set the indentation level for subsequent writes.
 
        If offset is given, adjust the level by that amount, otherwise
        set it to an absolute value.
        """
        if offset is not None:
            self.indent_level += offset
        else:
            self.indent_level = level
 

References CellMLToNektar.translators.CellMLTranslator.indent_level.

Referenced by CellMLToNektar.translators.CellMLTranslator.close_block(), CellMLToNektar.translators.CellMLTranslator.open_block(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_bottom_boilerplate(), CellMLToNektar.translators.CellMLTranslator.output_bottom_boilerplate(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ subsidiary_file_name()

def CellMLToNektar.translators.CellMLTranslator.subsidiary_file_name	(	self,
		output_filename
	)

Generate a name for the subsidiary output file, based on the main one.

Returns a pair (main_output_file_name, subsidiary_file_name).  This is in
case the user specifies (e.g.) a .hpp file as the main output - we consider
the main output to be the .cpp file.

Definition at line 328 of file translators.py.

    def subsidiary_file_name(self, output_filename):
        """Generate a name for the subsidiary output file, based on the main one.
        
        Returns a pair (main_output_file_name, subsidiary_file_name).  This is in
        case the user specifies (e.g.) a .hpp file as the main output - we consider
        the main output to be the .cpp file.
        """
        base, ext = os.path.splitext(output_filename)
        ext = ext[1:] # Remove the '.'
        try:
            new_ext = self.FILE_EXTENSIONS[ext]
            swap = False
        except KeyError:
            swap = True
            for key, val in self.FILE_EXTENSIONS.iteritems():
                if val == ext:
                    new_ext = key
                    break
            else:
                # Turn off usage of subsidiary file
                self.USES_SUBSIDIARY_FILE = False
                return output_filename, None
        subsidiary_filename = base + '.' + new_ext
        if swap:
            output_filename, subsidiary_filename = subsidiary_filename, output_filename
        return output_filename, subsidiary_filename
 

References CellMLToNektar.translators.CellMLTranslator.FILE_EXTENSIONS.

◆ translate()

def CellMLToNektar.translators.CellMLTranslator.translate	(	self,
		doc,
		model_filename,
		output_filename = `None`,
		subsidiary_file_name = `None`,
		class_name = `None`,
		v_variable = `None`,
		continuation = `None`,
		lookup_method_prefix = `''`,
		row_lookup_method = `False`,
		lt_index_uses_floor = `True`,
		constrain_table_indices = `False`
	)

Generate code for the given model.

doc should be an instance of cellml_model representing a
valid CellML model, such as might be produced from a call
to
>>> valid, doc = validator.CellMLValidator().validate(
...     model_filename, True)

model_filename is the filename of the input model.
The output program will by default be generated in the same
folder, but with a different extension.  This can be
overridden by supplying the output_filename keyword argument.

By default the name of the class representing the model will
be derived from the model name.  This can be overridden by
passing an alternative as the class_name argument.

The variable representing the transmembrane potential should
be passed in using the v_variable argument.

By default this method will perform some setup and then call
    self.output_top_boilerplate()
    self.output_mathematics()
    self.output_bottom_boilerplate()
To alter this, pass a callable as the continuation parameter;
this will then be called instead.

lookup_method_prefix and row_lookup_method can be used to
customise some aspects of lookup table usage.  The former is
used by the Chaste translator to place lookup tables within a
singleton class, while the latter can improve cache
performance by looking up all tables in a single call, and
returning an array of the results.

lt_index_uses_floor specifies whether to use the floor()
function to calculate the index into the lookup tables, or
just cast to unsigned.

constrain_table_indices specifies whether to throw an
exception if lookup table index variables go outside the
bounds specified (default), or just to cap them at the bounds.

Reimplemented in CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.

Definition at line 202 of file translators.py.

                  lt_index_uses_floor=True, constrain_table_indices=False):
        """Generate code for the given model.
 
        doc should be an instance of cellml_model representing a
        valid CellML model, such as might be produced from a call
        to
        >>> valid, doc = validator.CellMLValidator().validate(
        ...     model_filename, True)
 
        model_filename is the filename of the input model.
        The output program will by default be generated in the same
        folder, but with a different extension.  This can be
        overridden by supplying the output_filename keyword argument.
 
        By default the name of the class representing the model will
        be derived from the model name.  This can be overridden by
        passing an alternative as the class_name argument.
 
        The variable representing the transmembrane potential should
        be passed in using the v_variable argument.
 
        By default this method will perform some setup and then call
            self.output_top_boilerplate()
            self.output_mathematics()
            self.output_bottom_boilerplate()
        To alter this, pass a callable as the continuation parameter;
        this will then be called instead.
 
        lookup_method_prefix and row_lookup_method can be used to
        customise some aspects of lookup table usage.  The former is
        used by the Chaste translator to place lookup tables within a
        singleton class, while the latter can improve cache
        performance by looking up all tables in a single call, and
        returning an array of the results.
        
        lt_index_uses_floor specifies whether to use the floor()
        function to calculate the index into the lookup tables, or
        just cast to unsigned.
 
        constrain_table_indices specifies whether to throw an
        exception if lookup table index variables go outside the
        bounds specified (default), or just to cap them at the bounds.
        """
        self.doc = doc
        self.model = doc.model
        # Name of the class that will represent this model
        if class_name is None:
            self.class_name = u'CML_' + doc.model.name.replace('-', '_')
        else:
            self.class_name = class_name
        # Figure out the free & state vars in this model
        self.free_vars = doc.model.find_free_vars()
        self.state_vars = doc.model.find_state_vars()
        if len(self.free_vars) > 1:
            self.error(["Model has more than one free variable; exiting.",
                        "Free vars:" + str(self.free_vars)])
        if len(self.free_vars) == 0:
            if self.model.get_option('protocol'):
                # We may be dealing with an algebraic model; check for an Unknown variable
                for var in self.model.get_all_variables():
                    if var.get_type() == VarTypes.Unknown:
                        self.free_vars.append(var)
            if len(self.free_vars) != 1:
                self.error(["Model has no free variable; exiting."])
        # If only a single component, don't add it to variable names
        self.single_component = (len(getattr(self.model, u'component', [])) == 1)
        # Find the (index of the) transmembrane potential
        self.v_variable = v_variable
        if self.v_variable:
            self.v_variable_name = (v_variable.component.name, v_variable.name)
        else:
            self.v_variable = None
        for i, var in enumerate(self.state_vars):
            if var is v_variable:
                self.v_index = i
                break
        else:
            self.v_index = -1
        # Check to see if we're using lookup tables
        self.lookup_method_prefix = lookup_method_prefix
        self.row_lookup_method = row_lookup_method
        self.lt_index_uses_floor = lt_index_uses_floor
        self.constrain_table_indices = constrain_table_indices
        self.scan_for_lookup_tables()
        if not doc.lookup_tables:
            # No tables found
            self.use_lookup_tables = False
 
        # Extra configuration hook
        self.final_configuration_hook()
 
        # Open the output file(s)
        if output_filename is None:
            output_filename = self.output_file_name(model_filename)
        if self.USES_SUBSIDIARY_FILE:
            output_filename, self.subsidiary_filename = self.subsidiary_file_name(output_filename)
        self.output_filename = output_filename
        self.out = open_output_stream(output_filename)
        if self.USES_SUBSIDIARY_FILE:
            self.out2 = open_output_stream(self.subsidiary_filename)
 
        # Translate
        if continuation:
            continuation()
        else:
            self.output_top_boilerplate()
            self.output_mathematics()
            self.output_bottom_boilerplate()
        close_output_stream(self.out)
        if self.USES_SUBSIDIARY_FILE:
            close_output_stream(self.out2)
        return
 

References CellMLToNektar.translators.CellMLTranslator.model, CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_bottom_boilerplate(), CellMLToNektar.translators.CellMLTranslator.output_bottom_boilerplate(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_mathematics(), CellMLToNektar.translators.CellMLTranslator.output_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_top_boilerplate(), CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate(), and CellMLToNektar.validator.validate().

◆ var_display_name()

def CellMLToNektar.translators.CellMLTranslator.var_display_name	(	self,
		var
	)

Return a display name for the given variable.

If it has an oxmeta name, uses that.  Otherwise, looks first for a bqbiol:is annotation,
or uses the cmeta:id if present, or the name attribute if not.  If there is an interface
component, strip the name of it out of the display name.

Definition at line 463 of file translators.py.

    def var_display_name(self, var):
        """Return a display name for the given variable.
        
        If it has an oxmeta name, uses that.  Otherwise, looks first for a bqbiol:is annotation,
        or uses the cmeta:id if present, or the name attribute if not.  If there is an interface
        component, strip the name of it out of the display name.
        """
        if var.oxmeta_name:
            name = var.oxmeta_name
        else:
            for uri in var.get_rdf_annotations(('bqbiol:is', NSS['bqbiol'])):
                if '#' in uri:
                    name = uri[1 + uri.rfind('#'):]
                    break
            else:
                if hasattr(var, u'id') and var.id:
                    name = var.id
                else:
                    name = var.name
        iface = getattr(self.model, 'interface_component_name', '#N/A#')
        if name.startswith(iface):
            name = name[len(iface)+2:]
        return name
 

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

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_bottom_boilerplate(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), and CellMLToNektar.translators.CellMLTranslator.output_table_index_generation().

◆ varobj()

def CellMLToNektar.translators.CellMLTranslator.varobj	(	self,
		varname
	)

Return the variable object that has code_name varname.

Definition at line 459 of file translators.py.

    def varobj(self, varname):
        """Return the variable object that has code_name varname."""
        return cellml_variable.get_variable_object(self.model, varname)
 

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

Referenced by CellMLToNektar.translators.CellMLTranslator._vars_in(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_backward_euler_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_get_i_ionic(), and CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_variable().

◆ write()

def CellMLToNektar.translators.CellMLTranslator.write	(		self,
		*	args
	)

Write to our output file.

This variant does not indent the output, or add a newline.

Definition at line 398 of file translators.py.

    def write(self, *args):
        """Write to our output file.
 
        This variant does not indent the output, or add a newline.
        """
        self.writeln(indent=False, nl=False, *args)
    

References CellMLToNektar.translators.CellMLTranslator.writeln().

◆ writeln()

def CellMLToNektar.translators.CellMLTranslator.writeln	(		self,
		*	args,
		**	kwargs
	)

Write a line to our output file.

Takes any number of strings as input, and writes them out to file.

Unless the keyword argument indent is given as False, then the
output will be indented to the level set by self.set_indent().
Setting indent_level will override this value.
Setting indent_offset will adjust the current level temporarily.

If nl is set to False then a newline character will not be
appended to the output.

If subsidiary=True, then the line will be written to the subsidiary
output file instead of the main one.  An error will be raised if
there is no subsidiary output file.

Definition at line 364 of file translators.py.

    def writeln(self, *args, **kwargs):
        """Write a line to our output file.
 
        Takes any number of strings as input, and writes them out to file.
 
        Unless the keyword argument indent is given as False, then the
        output will be indented to the level set by self.set_indent().
        Setting indent_level will override this value.
        Setting indent_offset will adjust the current level temporarily.
 
        If nl is set to False then a newline character will not be
        appended to the output.
        
        If subsidiary=True, then the line will be written to the subsidiary
        output file instead of the main one.  An error will be raised if
        there is no subsidiary output file.
        """
        if kwargs.get('subsidiary', False) or self._main_output_to_subsidiary:
            if not self.USES_SUBSIDIARY_FILE:
                self.error('Tried to write to non-existent subsidiary file')
            else:
                target = self.out2
        else:
            target = self.out
        indent = kwargs.get('indent', True)
        nl = kwargs.get('nl', True)
        if indent:
            level = kwargs.get('indent_level', self.indent_level)
            level += kwargs.get('indent_offset', 0)
            target.write(self.indent_char * self.indent_factor * level)
        target.write(''.join(map(str, args)))
        if nl:
            target.write('\n')
 

Member Data Documentation

◆ _main_output_to_subsidiary

CellMLToNektar.translators.CellMLTranslator._main_output_to_subsidiary

private

Definition at line 181 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.send_main_output_to_subsidiary(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ _original_out

CellMLToNektar.translators.CellMLTranslator._original_out

private

Definition at line 407 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.get_captured_output().

◆ add_timestamp

CellMLToNektar.translators.CellMLTranslator.add_timestamp

Definition at line 179 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_includes(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ binary_ops

dictionary CellMLToNektar.translators.CellMLTranslator.binary_ops

static

Initial value:

=  {'divide': '/',
                  'xor': '!=', 'eq': '==', 'neq': '!=',
                  'geq': '>=','leq': '<=','gt': '>','lt': '<'}

Definition at line 727 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply().

◆ class_name

CellMLToNektar.translators.CellMLTranslator.class_name

Definition at line 254 of file translators.py.

◆ COMMENT_START

string CellMLToNektar.translators.CellMLTranslator.COMMENT_START = '// '

static

Definition at line 143 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_backward_euler_mathematics(), CellMLToNektar.translators.CellMLTranslator.output_comment(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.translators.CellMLTranslator.output_mathematics(), and CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_state_assignments().

◆ constrain_table_indices

CellMLToNektar.translators.CellMLTranslator.constrain_table_indices

Definition at line 289 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_table_index_checking().

◆ doc

CellMLToNektar.translators.CellMLTranslator.doc

Definition at line 250 of file translators.py.

◆ DOXYGEN_COMMENT_START

string CellMLToNektar.translators.CellMLTranslator.DOXYGEN_COMMENT_START = '//! '

static

Definition at line 144 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_doxygen().

◆ E

string CellMLToNektar.translators.CellMLTranslator.E = 'M_E'

static

Definition at line 156 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ EQ_ASSIGN

string CellMLToNektar.translators.CellMLTranslator.EQ_ASSIGN = ' = '

static

Definition at line 142 of file translators.py.

◆ FALSE

string CellMLToNektar.translators.CellMLTranslator.FALSE = 'false'

static

Definition at line 154 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ FILE_EXTENSIONS

dictionary CellMLToNektar.translators.CellMLTranslator.FILE_EXTENSIONS

static

Initial value:

=  {'cpp': 'h',
                       'c': 'h',
                       'cxx': 'hxx'}

Definition at line 163 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.subsidiary_file_name().

◆ free_vars

CellMLToNektar.translators.CellMLTranslator.free_vars

Definition at line 258 of file translators.py.

◆ function_map

dictionary CellMLToNektar.translators.CellMLTranslator.function_map

static

Initial value:

=  {'power': 'pow', 'abs': 'fabs', 'ln': 'log', 'exp': 'exp',
                    'floor': 'floor', 'ceiling': 'ceil',
                    'factorial': 'factorial', # Needs external definition
                    'not': '!', 'rem': 'fmod',
                    'sin': 'sin', 'cos': 'cos', 'tan': 'tan',
                    'sec': '1/cos', 'csc': '1/sin', 'cot': '1/tan',
                    'sinh': 'sinh', 'cosh': 'cosh', 'tanh': 'tanh',
                    'sech': '1/cosh', 'csch': '1/sinh', 'coth': '1/tanh',
                    'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan',
                    'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'}

Definition at line 710 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply().

◆ indent_char

CellMLToNektar.translators.CellMLTranslator.indent_char

Definition at line 173 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.writeln().

◆ indent_factor

CellMLToNektar.translators.CellMLTranslator.indent_factor

Definition at line 175 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.writeln().

◆ indent_level

CellMLToNektar.translators.CellMLTranslator.indent_level

Definition at line 171 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.set_indent(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ lookup_method_prefix

CellMLToNektar.translators.CellMLTranslator.lookup_method_prefix

Definition at line 286 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_table_index_generation_code(), and CellMLToNektar.translators.CellMLTranslator.output_table_lookup().

◆ lt_index_uses_floor

CellMLToNektar.translators.CellMLTranslator.lt_index_uses_floor

Definition at line 288 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_table_index_generation_code().

◆ model

CellMLToNektar.translators.CellMLTranslator.model

Definition at line 251 of file translators.py.

◆ nary_ops

dictionary CellMLToNektar.translators.CellMLTranslator.nary_ops

static

Initial value:

= {'plus': '+', 'times': '*',

'and': '&&', 'or': '||'}

Definition at line 725 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply().

◆ NOT_A_NUMBER

string CellMLToNektar.translators.CellMLTranslator.NOT_A_NUMBER = 'NAN'

static

Definition at line 157 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_bottom_boilerplate(), CellMLToNektar.translators.CellMLTranslator.output_piecewise(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ options

CellMLToNektar.translators.CellMLTranslator.options

Definition at line 169 of file translators.py.

Referenced by CellMLToNektar.translators.ConfigurationStore.expose_variables(), CellMLToNektar.translators.ConfigurationStore.finalize_config(), CellMLToNektar.translators.ConfigurationStore.find_current_vars(), CellMLToNektar.translators.ConfigurationStore.find_transmembrane_potential(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_state_assignments(), and CellMLToNektar.translators.ConfigurationStore.read_configuration_file().

◆ out

CellMLToNektar.translators.CellMLTranslator.out

Definition at line 304 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.get_captured_output(), and CellMLToNektar.translators.CellMLTranslator.writeln().

◆ out2

CellMLToNektar.translators.CellMLTranslator.out2

Definition at line 306 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.writeln().

◆ output_filename

CellMLToNektar.translators.CellMLTranslator.output_filename

Definition at line 303 of file translators.py.

◆ PI

string CellMLToNektar.translators.CellMLTranslator.PI = 'M_PI'

static

Definition at line 155 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ recip_trig

dictionary CellMLToNektar.translators.CellMLTranslator.recip_trig

static

Initial value:

= {'arcsec': 'arccos', 'arccsc': 'arcsin', 'arccot': 'arctan',

'arcsech': 'arccosh', 'arccsch': 'arcsinh', 'arccoth': 'arctanh'}

Definition at line 722 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_apply().

◆ row_lookup_method

CellMLToNektar.translators.CellMLTranslator.row_lookup_method

Definition at line 287 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_class(), CellMLToNektar.translators.CellMLTranslator.output_lut_index_declarations(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_lut_indexing_methods(), CellMLToNektar.translators.CellMLTranslator.output_lut_methods(), CellMLToNektar.translators.CellMLTranslator.output_table_index_generation_code(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_table_index_generation_code(), and CellMLToNektar.translators.CellMLTranslator.output_table_lookup().

◆ single_component

CellMLToNektar.translators.CellMLTranslator.single_component

Definition at line 272 of file translators.py.

◆ special_roots

dictionary CellMLToNektar.translators.CellMLTranslator.special_roots = {2: 'sqrt', 3: 'cbrt'}

static

Definition at line 813 of file translators.py.

◆ state_vars

CellMLToNektar.translators.CellMLTranslator.state_vars

Definition at line 259 of file translators.py.

◆ STMT_END

string CellMLToNektar.translators.CellMLTranslator.STMT_END = ';'

static

Various language tokens #.

Definition at line 141 of file translators.py.

◆ subsidiary_filename

CellMLToNektar.translators.CellMLTranslator.subsidiary_filename

Definition at line 302 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_includes().

◆ translators

dictionary CellMLToNektar.translators.CellMLTranslator.translators = {}

static

Definition at line 110 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.register().

◆ TRUE

string CellMLToNektar.translators.CellMLTranslator.TRUE = 'true'

static

Definition at line 153 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_expr().

◆ TYPE_CONST_DOUBLE

string CellMLToNektar.translators.CellMLTranslator.TYPE_CONST_DOUBLE = 'const NekDouble '

static

Definition at line 149 of file translators.py.

◆ TYPE_CONST_UNSIGNED

string CellMLToNektar.translators.CellMLTranslator.TYPE_CONST_UNSIGNED = 'const unsigned '

static

Definition at line 150 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.output_lut_generation().

◆ TYPE_DOUBLE

string CellMLToNektar.translators.CellMLTranslator.TYPE_DOUBLE = 'NekDouble '

static

Definition at line 147 of file translators.py.

◆ TYPE_VOID

string CellMLToNektar.translators.CellMLTranslator.TYPE_VOID = 'void '

static

Definition at line 148 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_bottom_boilerplate(), and CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_evaluate_y_derivatives().

◆ use_lookup_tables

CellMLToNektar.translators.CellMLTranslator.use_lookup_tables

Definition at line 177 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator._vars_in(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.calculate_lookup_table_indices(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_constructor(), CellMLToNektar.translators.CellMLTranslator.output_expr(), CellMLToNektar.translators.CellMLTranslator.output_lut_generation(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ USES_SUBSIDIARY_FILE [1/2]

bool CellMLToNektar.translators.CellMLTranslator.USES_SUBSIDIARY_FILE = False

static

Definition at line 161 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.writeln().

◆ USES_SUBSIDIARY_FILE [2/2]

CellMLToNektar.translators.CellMLTranslator.USES_SUBSIDIARY_FILE

Definition at line 348 of file translators.py.

Referenced by CellMLToNektar.translators.CellMLTranslator.writeln().

◆ v_index

CellMLToNektar.translators.CellMLTranslator.v_index

Definition at line 281 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_backward_euler_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_grl1_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_grl2_mathematics(), and CellMLToNektar.translators.CellMLTranslator.output_top_boilerplate().

◆ v_variable

CellMLToNektar.translators.CellMLTranslator.v_variable

Definition at line 274 of file translators.py.

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_assignment(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_derivative_calculations(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_grl1_mathematics(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_grl2_mathematics(), and CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.output_rush_larsen_mathematics().

◆ v_variable_name

CellMLToNektar.translators.CellMLTranslator.v_variable_name

Definition at line 276 of file translators.py.

Public Attributes
	options

	indent_level

	indent_char

	indent_factor

	use_lookup_tables

	add_timestamp

	doc

	model

	class_name

	free_vars

	state_vars

	single_component

	v_variable

	v_variable_name

	v_index

	lookup_method_prefix

	row_lookup_method

	lt_index_uses_floor

	constrain_table_indices

	subsidiary_filename

	output_filename

	out

	out2

	USES_SUBSIDIARY_FILE

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _vars_in()

◆ calculate_extended_dependencies()

◆ capture_output()

◆ close_block()

◆ close_paren()

◆ code_name()

◆ config()

◆ contained_table_indices()

◆ error()

◆ eval_number()

◆ final_configuration_hook()

◆ generate_interface()

◆ get_captured_output()

◆ include_guard()

◆ is_lookup_table()

◆ lut_access_code()

◆ lut_factor()

◆ lut_parameters()

◆ lut_size_calculation()

◆ open_block()

◆ open_paren()

◆ output_apply()

◆ output_assignment()

◆ output_binary_operator()

◆ output_bottom_boilerplate()

◆ output_comment()

◆ output_doxygen()

◆ output_equations()

◆ output_expr()

◆ output_file_name()

◆ output_function()

◆ output_lhs()

◆ output_log()

◆ output_lut_declarations()

◆ output_lut_deletion()

◆ output_lut_generation()

◆ output_lut_index_declarations()

◆ output_lut_indices()

◆ output_lut_methods()

◆ output_lut_row_lookup_memory()

◆ output_lut_row_lookup_methods()

◆ output_mathematics()

◆ output_minus()

◆ output_nary_operator()

◆ output_number()

◆ output_piecewise()

◆ output_root()

◆ output_single_lookup()

◆ output_table_index_checking()

◆ output_table_index_generation()

◆ output_table_index_generation_code()

◆ output_table_lookup()

◆ output_top_boilerplate()

◆ output_unary_operator()

◆ output_variable()

◆ register()

◆ scan_for_lookup_tables()

◆ send_main_output_to_subsidiary()

◆ set_indent()

◆ subsidiary_file_name()

◆ translate()

◆ var_display_name()

◆ varobj()

◆ write()

◆ writeln()

Member Data Documentation

◆ _main_output_to_subsidiary

◆ _original_out

◆ add_timestamp

◆ init()