Classes
class	cellml_component

class	cellml_model

class	cellml_unit

class	cellml_units

class	cellml_variable

class	comment_base

class	element_base

class	EvaluationError

class	mathml

class	mathml_abs

class	mathml_and

class	mathml_apply

class	mathml_arccos

class	mathml_arcsin

class	mathml_arctan

class	mathml_ci

class	mathml_cn

class	mathml_constructor

class	mathml_cos

class	mathml_degree

class	mathml_diff

class	mathml_divide

class	mathml_eq

class	mathml_exp

class	mathml_geq

class	mathml_gt

class	mathml_lambda

class	mathml_leq

class	mathml_ln

class	mathml_log

class	mathml_logbase

class	mathml_lt

class	mathml_math

class	mathml_minus

class	mathml_neq

class	mathml_operator

class	mathml_or

class	mathml_otherwise

class	mathml_piece

class	mathml_piecewise

class	mathml_plus

class	mathml_power

class	mathml_rem

class	mathml_root

class	mathml_sin

class	mathml_tan

class	mathml_times

class	mathml_units_mixin
	MathML elements #. More...

class	mathml_units_mixin_choose_nearest

class	mathml_units_mixin_container

class	mathml_units_mixin_equalise_operands

class	mathml_units_mixin_set_operands

class	mathml_units_mixin_tokens

class	MathsError

class	reduce_commutative_nary

class	UnitsError

class	UnitsSet

Functions
def	import_processors ()

def	make_xml_binder ()
	Helpful utility functions #. More...

def	amara_parse_cellml (source, uri=None, prefixes=None)

def	check_append_safety (elt)

def	add_methods_to_amara ()

def	_rel_error_ok (self, value1, value2, tol)
	def eq(self, other): """Compare 2 units elements for equality. More...

def	equals (self, other)

def	model (self)

def	extract (self, check_equality=False)

def	copy (self)

def	description (self, force=False, cellml=False)

def	get_units_by_name (self, uname)

def	expand (self)

def	is_base_unit (self)

def	is_simple (self)

def	get_multiplicative_factor (self)

def	get_multiplier (self)

def	get_offset (self)

def	create_new (parent, name, bases, add_to_parent=False, standard=False)

def	_based_on (self, units=None, prefix=None, exponent=None, multiplier=None, offset=None)

def	simplify (self, other_units=None, other_exponent=1)

def	_best_parent (self, other_units)

def	quotient (self, other_units)

def	dimensionally_equivalent (self, other_units)

def	child_i (elt, i)

def	_child1 (elt)

def	varobj (self, ci_elt)

def	vars_in (self, expr)

def	same_tree (self, other, this=None)

def	_xfer_complexity (self, new_elt)

def	_adjust_complexity (self, old_elt, new_elt)

def	classify_child_variables (self, elt, **kwargs)

Variables
	processors = None

list	__version__ = "$Revision: 25949 $"[11:-2]

	level

	format

	stream

	WARNING_TRANSLATE_ERROR

dictionary	NSS

	VarTypes

	CELLML_SUBSET_ELTS

	BINDING_TIMES = Enum('static', 'dynamic')

list	units_name_counter = [0]

	new_units = dimensionless
	print "Keeping d'less ref with m =",m,"from", print self.description(), if other_units: print "and",other_units.description() else: print More...

	unit_elements = set(d.values())

string	uname = u'___units_' + str(self.units_name_counter[0])

	_cml_generated

	xml_parent

def	units = self.model._get_units_obj(units)
	_u = units More...

string	msg = "Adding units " + units.name + " as "

	name

	cellml

dictionary	attrs = {(u'cml:units', NSS[u'cml']): units.name}

	_cml_expanded

	base_units

Function Documentation

◆ _adjust_complexity()

def CellMLToNektar.pycml._adjust_complexity	(	self,
		old_elt,
		new_elt
	)

private

Adjust ancestor complexity because old_elt changed to new_elt.

The purpose of this method is to allow us to keep track of
what the complexity of each expression node *was* prior to PE
being performed.  Thus we cannot just re-compute complexities,
but must update values using the original complexities.  If a
variable definition is instantiated, then the complexity of
the expression containing the lookup must be adjusted to
reflect the additional expense of evaluating the defining
expression.

When this method is called, only new_elt is a child of self.

Definition at line 3923 of file pycml.py.

    def _adjust_complexity(self, old_elt, new_elt):
        """Adjust ancestor complexity because old_elt changed to new_elt.
 
        The purpose of this method is to allow us to keep track of
        what the complexity of each expression node *was* prior to PE
        being performed.  Thus we cannot just re-compute complexities,
        but must update values using the original complexities.  If a
        variable definition is instantiated, then the complexity of
        the expression containing the lookup must be adjusted to
        reflect the additional expense of evaluating the defining
        expression.
 
        When this method is called, only new_elt is a child of self.
        """
        #print "Adjusting", element_xpath(self), "due to", element_xpath(old_elt),
        #if isinstance(old_elt, mathml_ci):
        #    print unicode(old_elt)
        #else:
        #    print
        try:
            new = new_elt._cml_complexity
            old = old_elt._cml_complexity
        except AttributeError:
            return
        #print "  by", new-old
        elt = self
        while elt:
            if isinstance(elt, mathml_piecewise):
                # Piecewise is tricky to adjust!  So we 're-compute' instead.
                ac, piece_ac = 0, []
                for piece in getattr(elt, u'piece', []):
                    ac += child_i(piece, 2)._cml_complexity
                    piece_ac.append(child_i(piece, 1)._cml_complexity)
                if hasattr(elt, u'otherwise'):
                    piece_ac.append(child_i(elt.otherwise, 1)._cml_complexity)
                ac += max(piece_ac)
                elt._cml_complexity = ac
            elif hasattr(elt, '_cml_complexity'):
                elt._cml_complexity += (new - old)
            elt = getattr(elt, 'xml_parent', None)
        return
    

References CellMLToNektar.pycml.child_i().

◆ _based_on()

def CellMLToNektar.pycml._based_on	(	self,
		units = `None`,
		prefix = `None`,
		exponent = `None`,
		multiplier = `None`,
		offset = `None`
	)

private

Convenience function for defining new units.

Definition at line 2940 of file pycml.py.

                  multiplier=None, offset=None):
        """Convenience function for defining new units."""
        for v in ['units', 'prefix', 'exponent', 'multiplier', 'offset']:
            # Coerce from str to unicode
            exec "if type(%s) == str: %s = unicode(%s)" % (v,v,v)
            # Check type
            exec "assert(%s is None or type(%s) == unicode)" % (v,v)
        assert(not hasattr(self, 'base_units') or self.base_units == u'no')
        attrs = {u'units': units}
        if offset:
            # Simple units definition
            assert(not hasattr(self, 'unit'))
            attrs[u'offset'] = offset
            if not prefix is None: attrs[u'prefix'] = prefix
            if not exponent is None: attrs[u'exponent'] = exponent
        else:
            # Complex units definition
            if not prefix is None: attrs[u'prefix'] = prefix
            if not exponent is None: attrs[u'exponent'] = exponent
            if not multiplier is None: attrs[u'multiplier'] = multiplier
        self.xml_append(self.xml_create_element(u'unit', NSS[u'cml'],
                                                attributes=attrs))
        return
 

◆ _best_parent()

def CellMLToNektar.pycml._best_parent	(	self,
		other_units
	)

private

Return a suitable parent for units formed from self and other_units.

If either constituent is in a component, that component should be the
parent, otherwise the model should be.

Definition at line 3143 of file pycml.py.

    def _best_parent(self, other_units):
        """Return a suitable parent for units formed from self and other_units.
 
        If either constituent is in a component, that component should be the
        parent, otherwise the model should be.
        """
        p1, p2 = self.xml_parent, other_units and other_units.xml_parent
        if p2 and p1 != p2 and isinstance(p1, cellml_model):
            p1 = p2
        return p1
 

◆ _child1()

def CellMLToNektar.pycml._child1 ( elt )

private

Definition at line 3460 of file pycml.py.

def _child1(elt):
    "Get the first child element of elt."
    return child_i(elt, 1)
 
 

References CellMLToNektar.pycml.child_i().

Referenced by CellMLToNektar.pycml.mathml_root._set_in_units(), CellMLToNektar.pycml.mathml_piecewise.evaluate(), CellMLToNektar.pycml.mathml_logbase.evaluate(), CellMLToNektar.pycml.mathml_degree.evaluate(), CellMLToNektar.pycml.mathml_apply.get_units(), and CellMLToNektar.pycml.mathml_apply.operator().

◆ _rel_error_ok()

def CellMLToNektar.pycml._rel_error_ok	(	self,
		value1,
		value2,
		tol
	)

private

def eq(self, other): """Compare 2 units elements for equality.

return self.equals(other) def ne(self, other): """Inverse of self.__eq__(other).""" return not self.__eq__(other)

Test if the relative difference of 2 values is within tol.

Definition at line 2627 of file pycml.py.

    def _rel_error_ok(self, value1, value2, tol):
        """Test if the relative difference of 2 values is within tol."""
        if abs(value1) == 0.0:
            return abs(value2) < tol
        else:
            return (abs(value1-value2)/abs(value1)) < tol
 

References tinysimd.abs().

◆ _xfer_complexity()

def CellMLToNektar.pycml._xfer_complexity	(	self,
		new_elt
	)

private

Transfer our complexity to the new element.

PE is replacing us by a new element.  If we are annotated with
a complexity - the complexity of this expression prior to PE -
then transfer the annotation to the new element.

Definition at line 3911 of file pycml.py.

    def _xfer_complexity(self, new_elt):
        """Transfer our complexity to the new element.
        
        PE is replacing us by a new element.  If we are annotated with
        a complexity - the complexity of this expression prior to PE -
        then transfer the annotation to the new element.
        """
        try:
            new_elt._cml_complexity = self._cml_complexity
        except AttributeError:
            pass
        return

◆ add_methods_to_amara()

def CellMLToNektar.pycml.add_methods_to_amara ( )

Definition at line 323 of file pycml.py.

def add_methods_to_amara():
    def getAttributeNS(self, ns, local, default=u""):
        """
        Get the value of an attribute specified by namespace and localname.
    
        Optionally can also pass a default value if the attribute
        doesn't exist (defaults to the empty string).
        """
        attrs = getattr(self, 'xml_attributes', {})
        keys = [ (ns_, SplitQName(qname)[1]) 
                   for _, (qname, ns_) in attrs.items() ]
        values = [ unicode(getattr(self, attr))
                   for attr, (qname, ns_) in attrs.items() ]
        attr_dict = dict(zip(keys, values))
        return attr_dict.get((ns, local), default)
    
    def xml_element_children(self, elt=None):
        """Return an iterable over child elements of this element."""
        if elt is None:
            elt = self
        for child in elt.xml_children:
            if getattr(child, 'nodeType', None) == Node.ELEMENT_NODE:
                yield child
    
    def safe_remove_child(self, child, parent=None):
        """Remove a child element from parent in such a way that it can safely be added elsewhere."""
        if parent is None: parent = self
        parent.xml_remove_child(child)
        child.next_elem = None
        
    def replace_child(self, old, new, parent=None):
        """Replace child old of parent with new."""
        if parent is None: parent = self
        parent.xml_insert_after(old, new)
        self.safe_remove_child(old, parent)
    
    import new
    for method in ['getAttributeNS', 'xml_element_children', 'safe_remove_child', 'replace_child']:
        meth = new.instancemethod(locals()[method], None, amara.bindery.element_base)
        setattr(amara.bindery.element_base, method, meth)
 

References CellMLToNektar.pycml.add_methods_to_amara().

Referenced by CellMLToNektar.pycml.add_methods_to_amara().

◆ amara_parse_cellml()

def CellMLToNektar.pycml.amara_parse_cellml	(	source,
		uri = `None`,
		prefixes = `None`
	)

Parse a CellML source with default rules and bindings.

Definition at line 191 of file pycml.py.

def amara_parse_cellml(source, uri=None, prefixes=None):
    """Parse a CellML source with default rules and bindings."""
    binder = make_xml_binder()
    rules = [bt.ws_strip_element_rule(u'*')]
    return amara_parse(source, rules=rules, binderobj=binder)
 

References CellMLToNektar.utilities.amara_parse(), and CellMLToNektar.pycml.make_xml_binder().

Referenced by CellMLToNektar.processors.ModelModifier._get_units_object(), CellMLToNektar.translators.SolverInfo.add_jacobian_matrix(), and CellMLToNektar.validator.CellMLValidator.validate().

◆ check_append_safety()

def CellMLToNektar.pycml.check_append_safety ( elt )

Check whether elt is safe to make a child, i.e. that it isn't
already a child elsewhere.

Definition at line 197 of file pycml.py.

def check_append_safety(elt):
    """
    Check whether elt is safe to make a child, i.e. that it isn't
    already a child elsewhere.
    """
    assert getattr(elt, 'next_elem', None) is None
    parent = getattr(elt, 'xml_parent', None)
    if parent:
        assert elt not in parent.xml_children
 

Referenced by CellMLToNektar.pycml.mathml_lambda.create_new(), CellMLToNektar.pycml.mathml_apply.create_new(), and CellMLToNektar.pycml.mathml_piecewise.create_new().

◆ child_i()

def CellMLToNektar.pycml.child_i	(	elt,
		i
	)

Definition at line 3449 of file pycml.py.

def child_i(elt, i):
    "Return the i'th child element of elt.  Indexing starts at 1."
    j = 0
    for e in elt.xml_children:
        if getattr(e, 'nodeType', None) == Node.ELEMENT_NODE:
            j += 1
            if j == i: return e
    else:
        # Not found :(
        raise ValueError("<"+elt.localName+"> does not have "+str(i)+
                         " child element(s).")

◆ classify_child_variables()

def CellMLToNektar.pycml.classify_child_variables	(		self,
			elt,
		**	kwargs
	)

Classify variables in the given expression according to how they are used.

In the process, compute and return a set of variables on which that expression depends.

If dependencies_only then the variable classification will not be
done, only dependencies will be analysed.  This is useful for doing
a 'light' re-analysis if the dependency set has been reduced; if the
set has increased then the topological sort of equations may need to
be redone.

The function needs_special_treatment may be supplied to override the
default recursion into sub-trees.  It takes a single sub-tree as
argument, and should either return the dependency set for that
sub-tree, or None to use the default recursion.  This is used when
re-analysing dependencies after applying lookup tables, since table
lookups only depend on the keying variable.

Definition at line 3965 of file pycml.py.

    def classify_child_variables(self, elt, **kwargs):
        """Classify variables in the given expression according to how they are used.
        
        In the process, compute and return a set of variables on which that expression depends.
 
        If dependencies_only then the variable classification will not be
        done, only dependencies will be analysed.  This is useful for doing
        a 'light' re-analysis if the dependency set has been reduced; if the
        set has increased then the topological sort of equations may need to
        be redone.
        
        The function needs_special_treatment may be supplied to override the
        default recursion into sub-trees.  It takes a single sub-tree as
        argument, and should either return the dependency set for that
        sub-tree, or None to use the default recursion.  This is used when
        re-analysing dependencies after applying lookup tables, since table
        lookups only depend on the keying variable.
        """
        if hasattr(elt, 'classify_variables'):
            dependencies = elt.classify_variables(**kwargs)
        else:
            dependencies = set()
            needs_special_treatment = kwargs.get('needs_special_treatment', lambda e: None)
            for e in elt.xml_element_children():
                child_deps = needs_special_treatment(e)
                if child_deps is None:
                    child_deps = self.classify_child_variables(e, **kwargs)
                dependencies.update(child_deps)
        return dependencies
 

◆ copy()

def CellMLToNektar.pycml.copy ( self )

Return a new UnitsSet containing this cellml_units object.

Used for interface compatibility with UnitsSet, where the method performs a shallow copy.

Definition at line 2663 of file pycml.py.

    def copy(self):
        """Return a new UnitsSet containing this cellml_units object.
 
        Used for interface compatibility with UnitsSet, where the method performs a shallow copy.
        """
        return UnitsSet([self])
 

Referenced by Nektar::MetricFile.CalculateHash(), ConvertCommandLine(), Nektar.CopyArray(), Nektar.CopyArrayN(), Nektar::SolverUtils::DriverParareal.CopyConvergedCheckPoints(), Nektar::LinearSystem.FactorMatrix(), CellMLToNektar.pycml.mathml_apply.get_units(), CellMLToNektar.pycml.mathml_piecewise.get_units(), Nektar::ArrayInitializationPolicy< ObjectType, typename std::enable_if< std::is_fundamental< ObjectType >::value >::type >.Initialize(), Nektar::LibUtilities::SessionReader.LoadDoc(), Nektar::NekMatrix< DataType, StandardMatrixTag >.NekMatrix(), Nektar.NekMultiplyLowerTriangularMatrix(), Nektar.NekMultiplyUpperTriangularMatrix(), Nektar::NekMatrix< DataType, StandardMatrixTag >.operator=(), Nektar::StorageSmvBsr< T >.processBcoInput(), Nektar::NekMatrix< DataType, StandardMatrixTag >.ResizeDataArrayIfNeeded(), SessionReader_CreateInstance(), Nektar::LibUtilities::GaussPoints.v_CalculateDerivMatrix(), Nektar::FieldUtils::InputSemtex.v_Process(), Nektar::LibUtilities::FieldIOHdf5.v_Write(), and Nektar::FieldUtils::OutputTecplotBinary.WriteDoubleOrFloat().

◆ create_new()

def CellMLToNektar.pycml.create_new	(	parent,
		name,
		bases,
		add_to_parent = `False`,
		standard = `False`
	)

static

Create a new units definition element.

It requires either a cellml_model or cellml_component element
to be passed as the parent for the definition.  If
add_to_parent is set to true the new units element will be
appended to parent's children.

The bases parameter should be a list of dictionaries suitable
for use as the keyword arguments of cellml_units._based_on.
If the list is empty it will be defined as a base unit.

Definition at line 2912 of file pycml.py.

    def create_new(parent, name, bases, add_to_parent=False, standard=False):
        """Create a new units definition element.
 
        It requires either a cellml_model or cellml_component element
        to be passed as the parent for the definition.  If
        add_to_parent is set to true the new units element will be
        appended to parent's children.
 
        The bases parameter should be a list of dictionaries suitable
        for use as the keyword arguments of cellml_units._based_on.
        If the list is empty it will be defined as a base unit.
        """
        # Create the units element
        attrs = {u'name': unicode(name)}
        if not bases:
            attrs[u'base_units'] = u'yes'
        if standard:
            attrs[u'standard'] = u'yes'
        u = parent.xml_create_element(u'units', NSS[u'cml'], attributes=attrs)
        if add_to_parent:
            parent.xml_append(u)
        else:
            u.xml_parent = parent # Hack so units lookups work
        # Add references to units we're based on
        for basis in bases:
            u._based_on(**basis)
        return u
 

◆ description()

def CellMLToNektar.pycml.description	(	self,
		force = `False`,
		cellml = `False`
	)

Return a human-readable name for these units.

The name will be descriptive and based on the consituent <unit> elements, e.g. 'volt per second^2'

By default, if these are user-defined units, then return self.name.  Set force to True to override this behaviour.

Set cellml to True to get a description that is also a valid CellML identifier.

Definition at line 2670 of file pycml.py.

    def description(self, force=False, cellml=False):
        """Return a human-readable name for these units.
        
        The name will be descriptive and based on the consituent <unit> elements, e.g. 'volt per second^2'
 
        By default, if these are user-defined units, then return self.name.  Set force to True to override this behaviour.
 
        Set cellml to True to get a description that is also a valid CellML identifier.
        """
        if self.is_base_unit():
            desc = self.name
        elif not force and not self._cml_generated:
            desc = self.name
        else:
            descs, per_descs = [], []
            # Multiplier
            m = self.get_multiplier()
            if m != 1:
                descs.append(unicode(m))
            # Constituent units
            dimensionless = self.get_units_by_name('dimensionless')
            for unit in self.unit:
                if unit.get_units_element() is dimensionless:
                    continue
                desc = [getattr(unit, u'prefix_', u''), unit.get_units_element().name]
                e = unit.get_exponent()
                if int(e) == e:
                    # Cast to integer so name looks nicer.
                    e = int(e)
                if abs(e) != 1:
                    desc.extend(['^', str(abs(e))])
                desc = u''.join(desc)
                if e < 0:
                    per_descs.append(desc)
                else:
                    descs.append(desc)
            # Sort unit descriptions for readability
            descs.sort()
            descs = u' '.join(descs)
            per_descs.sort()
            desc = u' per '.join([descs] + per_descs)
            if not desc:
                desc = u'dimensionless'
            elif descs:
                desc = u"'" + desc + u"'"
            else:
                # Remove unwanted space from the start
                desc = u"'" + desc[1:] + u"'"
            # Convert to CellML identifier?
            if cellml:
                desc = desc.replace(u"'", u"").replace(u"^", u"")
                desc = desc.replace(u"*", u"").replace(u".", u"_")
                desc = desc.replace(u" ", u"_")
        return desc
 

References tinysimd.abs().

Referenced by main(), CellMLToNektar.translators.CellMLTranslator.output_assignment(), Nektar::LibUtilities::SessionReader.ParseCommandLineArguments(), and CellMLToNektar.pycml.cellml_units.uniquify_tuple().

◆ dimensionally_equivalent()

def CellMLToNektar.pycml.dimensionally_equivalent	(	self,
		other_units
	)

Return True iff other_units is dimensionally equivalent to self.

As per appendix C.2.2, two units definitions have dimensional
equivalence if, when each is recursively expanded and
simplified into a product of base units, each has the same set
of base units with the same exponent on corresponding base units.

Definition at line 3185 of file pycml.py.

    def dimensionally_equivalent(self, other_units):
        """Return True iff other_units is dimensionally equivalent to self.
        
        As per appendix C.2.2, two units definitions have dimensional
        equivalence if, when each is recursively expanded and
        simplified into a product of base units, each has the same set
        of base units with the same exponent on corresponding base units.
        """
        u1 = self.expand().simplify()
        if isinstance(other_units, UnitsSet):
            other_units = other_units.extract()
        u2 = other_units.expand().simplify()
        # Build dictionaries mapping base_unit_obj to exponent.
        d1, d2 = {}, {}
        if u1.is_base_unit():
            d1[u1] = 1
        else:
            for u in u1.unit:
                d1[u.get_units_element()] = u.get_exponent()
        if u2.is_base_unit():
            d2[u2] = 1
        else:
            for u in u2.unit:
                d2[u.get_units_element()] = u.get_exponent()
        # Compare keys: do u1 & u2 have the same set of base units?
        sym_diff = set(d1.keys()) ^ set(d2.keys())
        if sym_diff:
            dimensionless = self.get_units_by_name(u'dimensionless')
            if not sym_diff == set([dimensionless]):
                # Symmetric difference is non-empty, but not an ignorable
                # instance of dimensionless
                return False
        # Compare corresponding exponents
        for k in d1:
            try:
                if d1[k] != d2[k]: return False
            except KeyError:
                # One may have dimensionless as a key
                pass
        # We have a match!
        return True
 
 

References CellMLToNektar.pycml.simplify().

Referenced by CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.generate_interface().

◆ equals()

def CellMLToNektar.pycml.equals	(	self,
		other
	)

Compare 2 units elements for equality.

Two units are deemed equal if they are both dimensionally equivalent and have the same
multiplicative factor (to within a relative tolerance of 10^-6).

If both are simple units, they must also have the same offset.

Definition at line 2634 of file pycml.py.

    def equals(self, other):
        """Compare 2 units elements for equality.
 
        Two units are deemed equal if they are both dimensionally equivalent and have the same
        multiplicative factor (to within a relative tolerance of 10^-6).
        
        If both are simple units, they must also have the same offset.
        """
        equal = isinstance(other, cellml_units) and \
                self.dimensionally_equivalent(other) and \
                self._rel_error_ok(self.expand().get_multiplicative_factor(),
                                   other.expand().get_multiplicative_factor(),
                                   1e-6)
        if equal and self.is_simple():
            equal = self._rel_error_ok(self.unit.get_offset(),
                                       other.unit.get_offset(),
                                       1e-6)
        return equal
 

References CellMLToNektar.pycml.get_multiplicative_factor(), and CellMLToNektar.pycml.get_offset().

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

◆ expand()

def CellMLToNektar.pycml.expand ( self )

Expand to a product of powers of base units.

Expand this units definition according to the algorithm given in appendix C.3.4 of the CellML spec.

Caches and returns the resulting <units> object, which will be
newly created if there are any changes made, or this object if not.

Definition at line 2730 of file pycml.py.

    def expand(self):
        """Expand to a product of powers of base units.
        
        Expand this units definition according to the algorithm given in appendix C.3.4 of the CellML spec.
        
        Caches and returns the resulting <units> object, which will be
        newly created if there are any changes made, or this object if not.
        """
        if self._cml_expanded is None:
            # Do the expansion
            if self.is_base_unit():
                # We are a base unit, so stop the recursion; the result is us
                self._cml_expanded = self
            elif self.is_simple():
                # Simple units definition, i.e. only one <unit> element,
                # exponent=1, and referenced units are simple or base.
                # Expand the units referenced by our <unit> element
                expanded_child = self.unit.get_units_element().expand()
                # Get our multiplicative factor & offset as numbers
                m1p1 = self.unit.get_multiplicative_factor()
                o1 = self.unit.get_offset()
                if expanded_child.is_base_unit():
                    # New multiplier, etc. are just ours
                    m_new = m1p1
                    o_new = o1
                    # Referenced units are expanded_child
                    ref_obj_new = expanded_child
                else:
                    # Get the multiplier & offset of our expanded child
                    m2p2 = expanded_child.unit.get_multiplicative_factor()
                    o2 = expanded_child.unit.get_offset()
                    # Calculate new multiplier, etc. per Equation (11)
                    m_new = m1p1*m2p2
                    o_new = o1 + o2/m1p1
                    # Referenced units are those referenced by expanded_child
                    # These will be base units
                    ref_obj_new = expanded_child.unit.get_units_element()
                # Create the new units & unit elements
                attrs = {u'name': self.name}
                self._cml_expanded = self.xml_create_element(u'units',
                                                             NSS[u'cml'],
                                                             attributes=attrs)
                self._cml_expanded._cml_generated = True
                attrs = {u'units': ref_obj_new.name,
                         u'multiplier': unicode(m_new),
                         u'offset': unicode(o_new)}
                unit = self.xml_create_element(u'unit', NSS[u'cml'],
                                               attributes=attrs)
                # Manually set the reference object for unit, since we have
                # it handy
                unit._set_units_element(ref_obj_new)
                self._cml_expanded.xml_append(unit)
            else:
                # Complex units definition, i.e. multiple <unit> elements,
                # or non-unitary exponent, at some point within this defn.
                # Create the new units element so we can add children to it
                attrs = {u'name': self.name}
                exp_units = self.xml_create_element(u'units', NSS[u'cml'],
                                                    attributes=attrs)
                exp_units._cml_generated = True
                # Compute m_t (Equation (18)) expanding referenced
                # units as we go
                m_t = 1
                for unit in self.unit:
                    m_t *= unit.get_multiplicative_factor() # * is assoc. :)
                    # We'll need the exponent to modify units referenced
                    # by this reference
                    e = unit.get_exponent()
                    # Expand referenced units
                    exp_u = unit.get_units_element().expand()
                    if exp_u.is_base_unit():
                        # Create reference to exp_u
                        attrs = {u'units': exp_u.name,
                                 u'exponent': unicode(e)}
                        u = self.xml_create_element(u'unit', NSS[u'cml'],
                                                    attributes=attrs)
                        exp_units.xml_append(u)
                    else:
                        # Process units referenced by exp_u, which will be
                        # base units.
                        for u in exp_u.unit:
                            m_t *= u.get_multiplicative_factor() ** e
                            attrs = {u'units': u.units,
                                     u'exponent': unicode(
                                u.get_exponent() * e)}
                            u_new = u.xml_create_element(u'unit',
                                                         NSS[u'cml'],
                                                         attributes=attrs)
                            exp_units.xml_append(u_new)
                # Set the multiplier for the expanded units to m_t.
                # Since a <units> elements doesn't have a multiplier
                # attribute, we set it on the first <unit> element.
                # Note that all the <unit> elements have been newly created,
                # so have an implicit multiplier of 1 currently.
                # Note also that the fact that each <unit> has an exponent
                # doesn't matter, since the exponent doesn't affect the
                # multiplier.
                # Alan pointed out a bug: if the <unit> elements are
                # in non-canonical order then we can get identical
                # units (according to the intended canonical form)
                # comparing as non-equal, because expansion put the
                # multiplicative factor on different <unit> elements
                # in each case.  Hence we have to put the factor on
                # the first <unit> element according to a canonical
                # sorting order.
                # TODO: Be a bit cleverer about this?  In the base unit case
                # above we could do exp_units.xml_append(unit.clone()) and
                # not have its multiplicative factor contributing to m_t.
                # Would then need to multiply here, since first unit may
                # already have multiplier != 1.
                # Alternative idea from Alan: I have just noticed that
                # when expanding a complex units definition based on a
                # complex units definition, we can get away with not
                # sorting the unit elements. All that is required is
                # to create a new unit element which type is
                # dimensionless and value of its multiplier attribute
                # m*10^(p*e). This avoids having to sort things and
                # propagating the multiplier attribute...
                first_unit = sorted(exp_units.unit, key=lambda u: u.units)[0]
                first_unit.multiplier = unicode(m_t)
                # Cache result
                self._cml_expanded = exp_units
            # Set parent of the expanded units to be our parent
            self._cml_expanded.xml_parent = self.xml_parent
        # Returned the cached result
        return self._cml_expanded
 

◆ extract()

def CellMLToNektar.pycml.extract	(	self,
		check_equality = `False`
	)

Return these units.

Used for interface compatibility with UnitsSet.

Definition at line 2657 of file pycml.py.

    def extract(self, check_equality=False):
        """Return these units.
 
        Used for interface compatibility with UnitsSet."""
        return self
 

Referenced by CellMLToNektar.pycml.mathml_units_mixin._add_units_conversion(), CellMLToNektar.pycml.mathml._ensure_units_exist(), CellMLToNektar.pycml.mathml_eq._set_in_units(), CellMLToNektar.processors.InterfaceGenerator._split_ode(), Geometry_Init(), Geometry_Init_Curved(), CellMLToNektar.pycml.mathml_cn.get_units(), and CellMLToNektar.pycml.mathml_ci.get_units().

◆ get_multiplicative_factor()

def CellMLToNektar.pycml.get_multiplicative_factor ( self )

Return the multiplicative factor of this units definition.

The multiplicative factor of a units definition can be defined as
the product of the multiplicative factors of its unit children.

Definition at line 2876 of file pycml.py.

    def get_multiplicative_factor(self):
        """Return the multiplicative factor of this units definition.
 
        The multiplicative factor of a units definition can be defined as
        the product of the multiplicative factors of its unit children.
        """
        m = reduce(operator.mul,
                   map(lambda unit: unit.get_multiplicative_factor(),
                       getattr(self, u'unit', [])),
                   1)
        return m
 

Referenced by CellMLToNektar.pycml.mathml_units_mixin_choose_nearest._set_in_units(), CellMLToNektar.pycml.mathml_units_mixin_equalise_operands._set_in_units(), CellMLToNektar.pycml.equals(), and CellMLToNektar.pycml.UnitsSet.extract().

◆ get_multiplier()

def CellMLToNektar.pycml.get_multiplier ( self )

Return the multiplier of this units definition.

The multiplier of a units definition can be defined as the product
of the multipliers of its unit children.

Definition at line 2888 of file pycml.py.

    def get_multiplier(self):
        """Return the multiplier of this units definition.
 
        The multiplier of a units definition can be defined as the product
        of the multipliers of its unit children.
        """
        return reduce(operator.mul,
                      map(lambda unit: unit.get_multiplier(),
                          getattr(self, u'unit', [])),
                      1)
 

◆ get_offset()

def CellMLToNektar.pycml.get_offset ( self )

Return the offset associated with this units definition.

If these are simple units, return the offset on our unit child.
Otherwise, return 0.

Definition at line 2899 of file pycml.py.

    def get_offset(self):
        """Return the offset associated with this units definition.
 
        If these are simple units, return the offset on our unit child.
        Otherwise, return 0.
        """
        if self.is_simple():
            o = self.unit.get_offset()
        else:
            o = 0
        return o
    

References CellMLToNektar.pycml.get_offset().

Referenced by CellMLToNektar.pycml.equals(), CellMLToNektar.pycml.UnitsSet.extract(), CellMLToNektar.pycml.get_offset(), and CellMLToNektar.pycml.cellml_units.uniquify_tuple().

◆ get_units_by_name()

def CellMLToNektar.pycml.get_units_by_name	(	self,
		uname
	)

Return an object representing the element that defines the units named `uname'.

Definition at line 2725 of file pycml.py.

    def get_units_by_name(self, uname):
        """Return an object representing the element that defines the units named `uname'."""
        # Look up units in our parent model or component element instead
        return self.xml_parent.get_units_by_name(uname)
 

References CellMLToNektar.pycml.get_units_by_name().

◆ import_processors()

def CellMLToNektar.pycml.import_processors ( )

Lazy import.

Definition at line 84 of file pycml.py.

def import_processors():
    """Lazy import."""
    global processors
    if processors is None:
        import processors
 
 

Referenced by CellMLToNektar.pycml.cellml_model.add_units_conversions().

◆ is_base_unit()

def CellMLToNektar.pycml.is_base_unit ( self )

Return True iff this is a base units definition.

Definition at line 2857 of file pycml.py.

    def is_base_unit(self):
        """Return True iff this is a base units definition."""
        return getattr(self, u'base_units', u'no') == u'yes'

◆ is_simple()

def CellMLToNektar.pycml.is_simple ( self )

Return True iff this is a simple units definition.

Units are simple if:
  there is 1 <unit> element
  the exponent is omitted or has value 1.0
  the referenced units are simple or base units

Definition at line 2860 of file pycml.py.

    def is_simple(self):
        """Return True iff this is a simple units definition.
 
        Units are simple if:
          there is 1 <unit> element
          the exponent is omitted or has value 1.0
          the referenced units are simple or base units
        """
        simple = False
        if not self.is_base_unit() and len(self.unit) == 1:
            if self.unit.get_exponent() == 1.0:
                u = self.unit.get_units_element()
                if u.is_base_unit() or u.is_simple():
                    simple = True
        return simple
 

◆ make_xml_binder()

def CellMLToNektar.pycml.make_xml_binder ( )

Helpful utility functions #.

Create a specialised binder, given some mappings from element names
to python classes, and setting namespace prefixes.

Definition at line 168 of file pycml.py.

def make_xml_binder():
    """
    Create a specialised binder, given some mappings from element names
    to python classes, and setting namespace prefixes.
    """
    binder = amara.bindery.binder(prefixes=NSS)
    binder.set_binding_class(NSS[u'cml'], "model", cellml_model)
    binder.set_binding_class(NSS[u'cml'], "component", cellml_component)
    binder.set_binding_class(NSS[u'cml'], "variable", cellml_variable)
    binder.set_binding_class(NSS[u'cml'], "units", cellml_units)
    binder.set_binding_class(NSS[u'cml'], "unit", cellml_unit)
    for mathml_elt in ['math', 'degree', 'logbase', 'otherwise',
                       'diff', 'plus', 'minus', 'times', 'divide',
                       'exp', 'ln', 'log', 'abs', 'power', 'root',
                       'leq', 'geq', 'lt', 'gt', 'eq', 'neq',
                       'rem',
                       'ci', 'cn', 'apply', 'piecewise', 'piece',
                       'sin', 'cos', 'tan', 'arcsin', 'arccos', 'arctan']:
        exec "binder.set_binding_class(NSS[u'm'], '%s', mathml_%s)" % (mathml_elt, mathml_elt)
    binder.set_binding_class(NSS[u'm'], "and_", mathml_and)
    binder.set_binding_class(NSS[u'm'], "or_", mathml_or)
    return binder
 

Referenced by CellMLToNektar.pycml.amara_parse_cellml().

◆ model()

def CellMLToNektar.pycml.model ( self )

Definition at line 2654 of file pycml.py.

    def model(self):
        return self.rootNode.model
 

◆ quotient()

def CellMLToNektar.pycml.quotient	(	self,
		other_units
	)

Form the quotient of two units definitions.

This method does not simplify the resulting units.
Quotient units will be cached.

Definition at line 3154 of file pycml.py.

    def quotient(self, other_units):
        """Form the quotient of two units definitions.
 
        This method does not simplify the resulting units.
        Quotient units will be cached.
        """
        if not other_units in self._cml_quotients:
            # Create new <units> element
            self.units_name_counter[0] += 1
            uname = u'___units_' + str(self.units_name_counter[0])
            quotient_units = self.xml_create_element(
                u'units', NSS[u'cml'], attributes={u'name': uname})
            quotient_units._cml_generated = True
            quotient_units.xml_parent = self._best_parent(other_units)
            # Invent references to the constituent units
            u = self.xml_create_element(u'unit', NSS[u'cml'],
                                        attributes={u'units': self.name})
            u._set_units_element(self)
            quotient_units.xml_append(u)
            u = self.xml_create_element(u'unit', NSS[u'cml'],
                                        attributes={u'units': self.name,
                                                    u'exponent': u'-1'})
            u._set_units_element(other_units)
            quotient_units.xml_append(u)
            # Cache
            if self.model._is_new_units_obj(quotient_units):
                quotient_units.xml_parent.add_units(uname, quotient_units)
            quotient_units = self.model._get_units_obj(quotient_units)
            self._cml_quotients[other_units] = quotient_units
        return self._cml_quotients[other_units]
 

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

◆ same_tree()

def CellMLToNektar.pycml.same_tree	(	self,
		other,
		this = `None`
	)

Check whether this element represents the same tree as a given element.

Definition at line 3897 of file pycml.py.

    def same_tree(self, other, this=None):
        """Check whether this element represents the same tree as a given element."""
        if this is None: this = self
        equal = (this.localName == other.localName
                 and len(getattr(this, 'xml_children', [])) == len(getattr(other, 'xml_children', [])))
        if equal and this.localName in [u'cn', u'ci']:
            equal = unicode(this) == unicode(other)
        if equal and hasattr(this, 'xml_children'):
            for tc, oc in zip(self.xml_element_children(this), self.xml_element_children(other)):
                if not self.same_tree(oc, tc):
                    equal = False
                    break
        return equal
 

◆ simplify()

def CellMLToNektar.pycml.simplify	(	self,
		other_units = `None`,
		other_exponent = `1`
	)

Simplify these units.

Create a new <units> element representing a simplified version of
this element.  This implements the algorithm of appendix C.3.1.  It
is however slightly different, in order to allow for units
conversions rather than just preserving dimensional equivalence.

If other_units is not None, then produce a simplified version of
the product of these units and other_units.  other_units are
considered to be raised to the power of other_exponent (so a
quotient can be performed by passing other_exponent=-1).  Note that
other_exponent should have numeric type.

If other_units is a UnitsSet, then we construct a UnitsSet
containing self, and call the simplify method on that, thus
returning a UnitsSet instance.

Multiplicative factors on the original <unit> objects are
maintained on the generated references, by taking the product of
all factors from <unit> objects that contribute to the new <unit>
object.  Note that this means that we may need to retain a
reference to dimensionless with a multiplier, for example if the
quotient of centimetres by metres is taken.

Offsets are only permitted on simple units, so may not appear where
there are multiple <unit> elements.  Hence when a product of units
is taken, any offsets are discarded.

Definition at line 2967 of file pycml.py.

    def simplify(self, other_units=None, other_exponent=1):
        """Simplify these units.
        
        Create a new <units> element representing a simplified version of
        this element.  This implements the algorithm of appendix C.3.1.  It
        is however slightly different, in order to allow for units
        conversions rather than just preserving dimensional equivalence.
 
        If other_units is not None, then produce a simplified version of
        the product of these units and other_units.  other_units are
        considered to be raised to the power of other_exponent (so a
        quotient can be performed by passing other_exponent=-1).  Note that
        other_exponent should have numeric type.
 
        If other_units is a UnitsSet, then we construct a UnitsSet
        containing self, and call the simplify method on that, thus
        returning a UnitsSet instance.
 
        Multiplicative factors on the original <unit> objects are
        maintained on the generated references, by taking the product of
        all factors from <unit> objects that contribute to the new <unit>
        object.  Note that this means that we may need to retain a
        reference to dimensionless with a multiplier, for example if the
        quotient of centimetres by metres is taken.
 
        Offsets are only permitted on simple units, so may not appear where
        there are multiple <unit> elements.  Hence when a product of units
        is taken, any offsets are discarded.
        """
        if isinstance(other_units, UnitsSet):
            # Use the set version of simplify
            return UnitsSet([self]).simplify(other_units, other_exponent)
        
        # Check for result in cache (see #1714)
        if (other_units, other_exponent) in self._cml_simplified:
            return self._cml_simplified[(other_units, other_exponent)]
 
        # Make a list of all <unit> elements to be included
        units = []
        if self.is_base_unit():
            # We are a base unit, so invent a reference to ourselves
            u = self.xml_create_element(u'unit', NSS[u'cml'],
                                        attributes={u'units': self.name})
            u.xml_parent = self # Hack, but it might need a parent...
            u._set_units_element(self)
            units.append(u)
        else:
            units = list(self.unit)
        our_unit_elements = frozenset(units)
        other_unit_elements = None
        if not other_units is None:
            if other_units.is_base_unit():
                # other_units are base units, so invent a reference
                attrs = {u'units': other_units.name,
                         u'exponent': unicode(other_exponent)}
                u = self.xml_create_element(u'unit', NSS[u'cml'],
                                            attributes=attrs)
                u.xml_parent = other_units
                u._set_units_element(other_units)
                units.append(u)
                if other_exponent == 1:
                    other_unit_elements = frozenset([u])
            else:
                if other_exponent == 1:
                    units.extend(list(other_units.unit))
                    other_unit_elements = frozenset(other_units.unit)
                else:
                    for unit in other_units.unit:
                        # Need to create a new <unit> element with different
                        # exponent and multiplier
                        u = unit.clone()
                        u.exponent = unicode(other_exponent *
                                             u.get_exponent())
                        u.multiplier = unicode(u.get_multiplier() **
                                               other_exponent)
                        units.append(u)
        # Sort <unit> elements according to the <units> objects they
        # reference
        dimensionless = self.get_units_by_name(u'dimensionless')
        d = {dimensionless: []}
        for unit in units:
            obj = unit.get_units_element()
            if obj in d:
                d[obj].append(unit)
            else:
                d[obj] = [unit]
        # Collapse equivalent units references into a single reference.
        # That is, all references to the same object get collapsed into a new
        # reference to that object with different exponent, etc.
        for obj in d.keys():
            if obj != dimensionless and len(d[obj]) > 1:
                # Sum the exponents
                expt = sum(map(lambda u: u.get_exponent(), d[obj]))
                # If exponents cancel, replace with ref to dimensionless
                if expt == 0:
                    attrs = {u'units': u'dimensionless'}
                else:
                    attrs = {u'units': d[obj][0].units,
                             u'exponent': unicode(expt)}
                # Compute the multiplier for the new unit reference, as
                # the product of multiplicative factors on the originals
                m = reduce(operator.mul,
                           map(lambda u: u.get_multiplicative_factor(),
                               d[obj]))
                attrs[u'multiplier'] = unicode(m)
                # Create a new reference
                new = self.xml_create_element(u'unit', NSS[u'cml'],
                                              attributes=attrs)
                new.xml_parent = self
                if expt == 0:
                    # Note an extra reference to dimensionless...
                    d[dimensionless].append(new)
                    # ...and remove the references to obj from d
                    del d[obj]
                else:
                    d[obj] = new
            elif obj != dimensionless and d[obj]:
                # d[obj] is a singleton list.  Create a new reference and
                # store it instead (a new reference is needed to avoid
                # altering the linked list from self.unit).
                d[obj] = d[obj][0].clone()
        # Note d must have at least one key, namely dimensionless
        # If dimensionless is referenced in addition to other units,
        # remove the references to dimensionless.
        # But remember the multipliers!
        m = reduce(operator.mul,
                   map(lambda u: u.get_multiplicative_factor(),
                       d[dimensionless]),
                   1)
        if m == 1:
            del d[dimensionless]
        else:
            # Retain a single reference to dimensionless, with the
            # combined multiplier.
            d[dimensionless] = d[dimensionless][0].clone()
            d[dimensionless].multiplier = unicode(m)

References CellMLToNektar.pycml.simplify().

Referenced by CellMLToNektar.pycml.mathml_units_mixin._add_units_conversion(), CellMLToNektar.pycml.dimensionally_equivalent(), CellMLToNektar.CellMLToNektarTranslator.CellMLToNektarTranslator.generate_interface(), and CellMLToNektar.pycml.simplify().

◆ varobj()

def CellMLToNektar.pycml.varobj	(	self,
		ci_elt
	)

Return the variable object for the given ci element.

This method is more general than ci_elt.variable, working even
for ci elements outside of a component.  Such elements *must*
contain a fully qualified variable name, i.e. including the
name of the component the variable occurs in.  This method
handles a variety of encodings of variable names that contain
the component name.

Definition at line 3853 of file pycml.py.

    def varobj(self, ci_elt):
        """Return the variable object for the given ci element.
 
        This method is more general than ci_elt.variable, working even
        for ci elements outside of a component.  Such elements *must*
        contain a fully qualified variable name, i.e. including the
        name of the component the variable occurs in.  This method
        handles a variety of encodings of variable names that contain
        the component name.
        """
        try:
            var = ci_elt.variable
        except:
            varname = unicode(ci_elt).strip()
            var = cellml_variable.get_variable_object(self.model, varname)
        return var
 

◆ vars_in()

def CellMLToNektar.pycml.vars_in	(	self,
		expr
	)

Return a list of 'variable' objects used in the given expression.

This method doesn't make use of the dependency information
generated when validating the model, but parses the
mathematics afresh.  It is used to refresh the dependency
lists after partial evaluation, and to determine dependencies
in mathematics added outside the normal model structure
(e.g. Jacobian calculation).

If an ODE appears, includes the mathml_apply instance defining
the ODE.  Otherwise all returned objects will be
cellml_variable instances.

Definition at line 3870 of file pycml.py.

    def vars_in(self, expr):
        """Return a list of 'variable' objects used in the given expression.
 
        This method doesn't make use of the dependency information
        generated when validating the model, but parses the
        mathematics afresh.  It is used to refresh the dependency
        lists after partial evaluation, and to determine dependencies
        in mathematics added outside the normal model structure
        (e.g. Jacobian calculation).
 
        If an ODE appears, includes the mathml_apply instance defining
        the ODE.  Otherwise all returned objects will be
        cellml_variable instances.
        """
        res = set()
        if isinstance(expr, mathml_ci):
            res.add(self.varobj(expr))
        elif isinstance(expr, mathml_apply) and \
                 expr.operator().localName == u'diff':
            dep_var = self.varobj(expr.ci)
            indep_var = self.varobj(expr.bvar.ci)
            res.add(dep_var.get_ode_dependency(indep_var))
        elif hasattr(expr, 'xml_children'):
            for child in expr.xml_children:
                res.update(self.vars_in(child))
        return res
    

Variable Documentation

◆ version

list CellMLToNektar.pycml.__version__ = "$Revision: 25949 $"[11:-2]

private

Definition at line 91 of file pycml.py.

◆ _cml_expanded

CellMLToNektar.pycml._cml_expanded

private

Definition at line 2742 of file pycml.py.

◆ _cml_generated

CellMLToNektar.pycml._cml_generated

private

Definition at line 3128 of file pycml.py.

◆ attrs

dictionary CellMLToNektar.pycml.attrs = {(u'cml:units', NSS[u'cml']): units.name}

Definition at line 3847 of file pycml.py.

◆ base_units

CellMLToNektar.pycml.base_units

Definition at line 2948 of file pycml.py.

◆ BINDING_TIMES

CellMLToNektar.pycml.BINDING_TIMES = Enum('static', 'dynamic')

Definition at line 161 of file pycml.py.

◆ cellml

CellMLToNektar.pycml.cellml

Definition at line 3835 of file pycml.py.

◆ CELLML_SUBSET_ELTS

CellMLToNektar.pycml.CELLML_SUBSET_ELTS

Initial value:

=  frozenset(
    ['math', 'cn', 'sep', 'ci', 'apply', 'piecewise', 'piece', 'otherwise',
     'eq', 'neq', 'gt', 'lt', 'geq', 'leq',
     'plus', 'minus', 'times', 'divide', 'power', 'root', 'abs',
     'exp', 'ln', 'log', 'floor', 'ceiling', 'factorial',
     'and', 'or', 'not', 'xor',
     'diff', 'degree', 'bvar', 'logbase',
     'sin', 'cos', 'tan', 'sec', 'csc', 'cot',
     'sinh', 'cosh', 'tanh', 'sech', 'csch', 'coth',
     'arcsin', 'arccos', 'arctan', 'arcsec', 'arccsc', 'arccot',
     'arcsinh', 'arccosh', 'arctanh', 'arcsech', 'arccsch', 'arccoth',
     'true', 'false', 'notanumber', 'pi', 'infinity', 'exponentiale',
     'semantics', 'annotation', 'annotation-xml'])

Definition at line 146 of file pycml.py.

◆ format

CellMLToNektar.pycml.format

Definition at line 101 of file pycml.py.

◆ level

CellMLToNektar.pycml.level

Definition at line 100 of file pycml.py.

◆ msg

string CellMLToNektar.pycml.msg = "Adding units " + units.name + " as "

Definition at line 3834 of file pycml.py.

Referenced by Nektar::LibUtilities::Equation.Equation(), Nektar::ErrorUtil.Error(), Nektar::LibUtilities::Equation.Evaluate(), and Nektar::MultiRegions::ExpList.GetExpIndex().

◆ name

CellMLToNektar.pycml.name

Definition at line 3835 of file pycml.py.

◆ new_units

def CellMLToNektar.pycml.new_units = dimensionless

print "Keeping d'less ref with m =",m,"from", print self.description(), if other_units: print "and",other_units.description() else: print

print "Adding",uname,hash(new_units),new_units.description()

print ".simplify", uname

Definition at line 3113 of file pycml.py.

◆ NSS

dictionary CellMLToNektar.pycml.NSS

Initial value:

=  {u'm'  : u'http://www.w3.org/1998/Math/MathML',
       u'cml': u'http://www.cellml.org/cellml/1.0#',
       # Our extensions; URIs will probably change?
       u'pe': u'https://chaste.comlab.ox.ac.uk/cellml/ns/partial-evaluation#',
       u'lut': u'https://chaste.comlab.ox.ac.uk/cellml/ns/lookup-tables',
       u'solver': u'https://chaste.comlab.ox.ac.uk/cellml/ns/solver-info',
       u'oxmeta': u'https://chaste.comlab.ox.ac.uk/cellml/ns/oxford-metadata#',
       u'pycml': u'https://chaste.comlab.ox.ac.uk/cellml/ns/pycml#',
       u'proto': u'https://chaste.cs.ox.ac.uk/nss/protocol/0.1#',
       # Metadata-related
       u'cmeta'  : u"http://www.cellml.org/metadata/1.0#",
       u'rdf'    : u"http://www.w3.org/1999/02/22-rdf-syntax-ns#",
       u'dc'     : u"http://purl.org/dc/elements/1.1/",
       u'dcterms': u"http://purl.org/dc/terms/",
       u'bqs'    : u"http://www.cellml.org/bqs/1.0#",
       u'vCard'  : u"http://www.w3.org/2001/vcard-rdf/3.0#",
       u'cg'     : u"http://www.cellml.org/metadata/graphs/1.0#",
       u'cs'     : u"http://www.cellml.org/metadata/simulation/1.0#",
       u'csub'   : u"http://www.cellml.org/metadata/custom_subset/1.0#",
       u'bqbiol' : u"http://biomodels.net/biology-qualifiers/",
       # Temporary documentation namespace
       u'doc' : u"http://cellml.org/tmp-documentation"
       }

Definition at line 116 of file pycml.py.

◆ processors

CellMLToNektar.pycml.processors = None

Definition at line 83 of file pycml.py.

◆ stream

CellMLToNektar.pycml.stream

Definition at line 102 of file pycml.py.

◆ uname

string CellMLToNektar.pycml.uname = u'___units_' + str(self.units_name_counter[0])

Definition at line 3124 of file pycml.py.

◆ unit_elements

CellMLToNektar.pycml.unit_elements = set(d.values())

Definition at line 3116 of file pycml.py.

◆ units

CellMLToNektar.pycml.units = self.model._get_units_obj(units)

_u = units

print "Adding",units.name, hash(units), units.description(), print "(was",id(_u),"now",id(units),")" Ensure referenced units exist

Definition at line 3825 of file pycml.py.

◆ units_name_counter

list CellMLToNektar.pycml.units_name_counter = [0]

Definition at line 2966 of file pycml.py.

◆ VarTypes

CellMLToNektar.pycml.VarTypes

Initial value:

1= Enum('Unknown', 'Free', 'State', 'MaybeConstant', 'Constant',

2 'Computed', 'Mapped')

CellMLToNektar.enum.Enum

def Enum(*names)

Definition: enum.py:8

Definition at line 142 of file pycml.py.

◆ WARNING_TRANSLATE_ERROR

CellMLToNektar.pycml.WARNING_TRANSLATE_ERROR

Definition at line 108 of file pycml.py.

◆ xml_parent

CellMLToNektar.pycml.xml_parent

Definition at line 3130 of file pycml.py.

Classes

Functions

Variables

Function Documentation

◆ _adjust_complexity()

◆ _based_on()

◆ _best_parent()

◆ _child1()

◆ _rel_error_ok()

◆ _xfer_complexity()

◆ add_methods_to_amara()

◆ amara_parse_cellml()

◆ check_append_safety()

◆ child_i()

◆ classify_child_variables()

◆ copy()

◆ create_new()

◆ description()

◆ dimensionally_equivalent()

◆ equals()

◆ expand()

◆ extract()

◆ get_multiplicative_factor()

◆ get_multiplier()

◆ get_offset()

◆ get_units_by_name()

◆ import_processors()

◆ is_base_unit()

◆ is_simple()

◆ make_xml_binder()

◆ model()

◆ quotient()

◆ same_tree()

◆ simplify()

◆ varobj()

◆ vars_in()

Variable Documentation

◆ __version__

◆ _cml_expanded

◆ _cml_generated

◆ attrs

◆ base_units

◆ BINDING_TIMES

◆ cellml

◆ CELLML_SUBSET_ELTS

◆ format

◆ level

◆ msg

◆ name

◆ new_units

◆ NSS

◆ processors

◆ stream

◆ uname

◆ unit_elements

◆ units

◆ units_name_counter

◆ VarTypes

◆ WARNING_TRANSLATE_ERROR

◆ xml_parent

◆ version