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.

References CellMLToNektar.pycml.child_i().

     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
     

◆ _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 2941 of file pycml.py.

Referenced by CellMLToNektar.pycml.create_new().

                   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.

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().

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

◆ _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
 

◆ _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)
 
 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.

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().

 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)
 

◆ 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.

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

 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
 

◆ 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.

Referenced by Nektar::LibUtilities::GaussPoints.CalculateDerivMatrix(), Nektar.CopyArray(), Nektar.CopyArrayN(), Nektar::LinearSystem.FactorMatrix(), CellMLToNektar.pycml.mathml_apply.get_units(), CellMLToNektar.pycml.mathml_piecewise.get_units(), Nektar::NekMeshUtils::Tetrahedron.GetCurvedNodes(), Nektar::NekMeshUtils::Prism.GetCurvedNodes(), Nektar::NekMeshUtils::Triangle.GetCurvedNodes(), 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::NekVector< NekDouble >.NekVector(), Nektar::NekVector< NekDouble >.operator=(), Nektar::NekMatrix< DataType, StandardMatrixTag >.operator=(), Nektar::FieldUtils::InputSemtex.Process(), Nektar::StorageSmvBsr< T >.processBcoInput(), Nektar::Utilities.quadTensorNodeOrdering(), Nektar::NekMatrix< DataType, StandardMatrixTag >.ResizeDataArrayIfNeeded(), SessionReader_CreateInstance(), Nektar::Utilities.triTensorNodeOrdering(), Nektar::LibUtilities::FieldIOHdf5.v_Write(), and Nektar::FieldUtils::OutputTecplotBinary.WriteDoubleOrFloat().

     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])
 

◆ 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.

References CellMLToNektar.pycml._based_on().

     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.

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

     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
 

◆ 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.

References CellMLToNektar.pycml.simplify().

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

     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
 
 

◆ 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.

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

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

     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
 

◆ 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.

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(), CellMLToNektar.pycml.mathml_ci.get_units(), Nektar::Utilities::ProcessOptiExtract.Process(), and Nektar::Utilities::ProcessJac.Process().

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

◆ 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.

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

     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
 

◆ 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.

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

     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
     

◆ 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)
 

◆ import_processors()

def CellMLToNektar.pycml.import_processors ( )

Lazy import.

Definition at line 84 of file pycml.py.

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

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

◆ 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.

Referenced by CellMLToNektar.pycml.amara_parse_cellml().

 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
 

◆ model()

def CellMLToNektar.pycml.model ( self )

Definition at line 2654 of file pycml.py.

Referenced by Nektar::NekMeshUtils::CADSystemCFI.GetBoundingBox(), and Nektar::NekMeshUtils::CADSystemCFI.LoadCAD().

     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.

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

     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]
 

◆ 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.

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

     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)

◆ 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.

Referenced by Nektar::SolverUtils.AddSummaryItem(), Nektar::SolverUtils::UnsteadySystem.CheckSteadyState(), Nektar::SolverUtils::CouplingCwipi.DumpRawFields(), Nektar::SolverUtils::SessionFunction.EvaluateFld(), Nektar::SolverUtils::SessionFunction.EvaluatePts(), Nektar::FieldUtils::OutputFld.GetFullOutName(), Nektar::FieldUtils::OutputVtk.GetFullOutName(), Nektar::LibUtilities::PtsIO.Import(), Nektar::LibUtilities::SessionReader.LoadDoc(), Nektar::SpatialDomains::MeshGraphXml.PartitionMesh(), Nektar::FieldUtils::OutputInfo.Process(), Nektar::LibUtilities::PtsIO.SetUpFieldMetaData(), Nektar::LibUtilities::FieldIOXml.SetUpFieldMetaData(), Nektar::LibUtilities::FieldIO.SetUpOutput(), Nektar::SolverUtils::FilterHistoryPoints.v_Initialise(), Nektar::SolverUtils::CouplingFile.v_Receive(), Nektar::SolverUtils::CouplingFile.v_Send(), Nektar::SolverUtils::FilterHistoryPoints.v_Update(), Nektar::IterativeElasticSystem.WriteGeometry(), Nektar::FieldUtils::OutputVtk.WritePVtu(), and Nektar::SpatialDomains::MeshGraphXml.WriteXMLGeometry().

◆ 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::LibUtilities::Equation.Evaluate(), Nektar::MultiRegions::ExpList.GetExpIndex(), and Nektar::Utilities::InputStar.SetupElements().

◆ 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