CellMLToNektar.pycml Namespace Reference

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
def	check_append_safety
def	add_methods_to_amara
def	_rel_error_ok
	def eq(self, other): """Compare 2 units elements for equality. More...
def	equals
def	model
def	extract
def	copy
def	description
def	get_units_by_name
def	expand
def	is_base_unit
def	is_simple
def	get_multiplicative_factor
def	get_multiplier
def	get_offset
def	create_new
def	_based_on
def	simplify
def	_best_parent
def	quotient
def	dimensionally_equivalent
def	child_i
def	_child1
def	varobj
def	vars_in
def	same_tree
def	_xfer_complexity
def	_adjust_complexity
def	classify_child_variables

Variables
	processors = None
string	__version__ = "$Revision: 25949 $"
string	format = "%(name)s: %(levelname)s: %(message)s"
	stream = sys.stderr)
dictionary	NSS
tuple	VarTypes
tuple	CELLML_SUBSET_ELTS
tuple	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...
tuple	unit_elements = set(d.values())
string	uname = u'___units_'
tuple	units = self.model._get_units_obj(units)
	_u = units More...
string	msg = "Adding units "
	print "Adding",units.name, hash(units), units.description(), print "(was",id(_u),"now",id(units),")" Ensure referenced units exist More...
dictionary	attrs = {(u'cml:units', NSS[u'cml']): units.name}
	_cml_expanded
	base_units

Function Documentation

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