Inheritance diagram for CellMLToNektar.pycml.cellml_variable:

[legend]

Public Member Functions
def	__init__ (self)

def	clear_dependency_info (self)

def	__hash__ (self)

def	fullname (self, cellml=False, debug=False)

def	__str__ (self)

def	__repr__ (self)

def	get_component (self)

def	model (self)

def	get_units (self)

def	get_dependencies (self)

def	get_ode_dependency (self, independent_var, context=None)

def	get_all_expr_dependencies (self)

def	get_source_variable (self, recurse=False)

def	get_type (self, follow_maps=False)

def	get_usage_count (self)

def	add_rdf_annotation (self, property, target, allow_dup=False)

def	get_rdf_annotation (self, property)

def	get_rdf_annotations (self, property)

def	remove_rdf_annotations (self, property=None)

def	set_rdf_annotation_from_boolean (self, property, is_yes)

def	is_statically_const (self, ignore_annotations=False)

def	set_value (self, value, ode=None, follow_maps=True)

def	unset_values (self)

def	get_value (self, ode=None)

def	is_modifiable_parameter (self)

def	set_is_modifiable_parameter (self, is_param)

def	is_derived_quantity (self)

def	set_is_derived_quantity (self, is_dq)

def	is_output_variable (self)

def	set_is_output_variable (self, is_ov)

def	pe_keep (self)

def	set_pe_keep (self, keep)

def	oxmeta_name (self)

def	set_oxmeta_name (self, name)

Public Member Functions inherited from CellMLToNektar.utilities.Colourable
def	__init__ (self, args, kwargs)

def	set_colour (self, colour)

def	get_colour (self)

def	clear_colour (self)

Public Member Functions inherited from CellMLToNektar.pycml.element_base
def	__init__ (self)

def	__delattr__ (self, key)

def	__setattr__ (self, key, value)

def	rootNode (self)

def	cmeta_id (self)

def	xml_remove_child_at (self, index=-1)

def	xml_doc (self)

def	xml_properties (self)

Static Public Member Functions
def	split_name (varname)

def	get_variable_object (model, varname)

def	create_new (elt, name, units, id=None, initial_value=None, interfaces={})

Public Attributes
	initial_value

Public Attributes inherited from CellMLToNektar.pycml.element_base
	xml_attributes

Properties
	component = property(get_component)

Private Member Functions
def	_add_dependency (self, dep)

def	_add_ode_dependency (self, independent_var, expr)

def	_update_ode_dependency (self, free_var, defn)

def	_set_source_variable (self, src_var)

def	_set_type (self, var_type, _orig=None)

def	_used (self)

def	_decrement_usage_count (self, follow_maps=True)

def	_set_binding_time (self, bt, temporary=False)

def	_unset_binding_time (self, only_temporary=False)

def	_get_binding_time (self)

def	_reduce (self, update_usage=False)

Private Attributes
	_cml_var_type

	_cml_source_var

	_cml_value

	_cml_binding_time

	_cml_depends_on
	Move the definition to this component defn._unset_cached_links() defn.xml_parent.xml_remove_child(defn) self.component.math.xml_append(defn) Schedule the LHS of the defining expression for update. More...

	_cml_depends_on_ode

	_cml_usage_count

	_cml_saved_bt

Detailed Description

Class representing CellML <variable> elements.

Definition at line 1648 of file pycml.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.pycml.cellml_variable.__init__ ( self )

Definition at line 1652 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.clear_dependency_info().

     def __init__(self):
         super(cellml_variable, self).__init__()
         self.clear_dependency_info()
         return
     

Member Function Documentation

◆ hash()

def CellMLToNektar.pycml.cellml_variable.__hash__ ( self )

Hashing function for variables.

Hash is based on hashing the full name of the variable, as
this must be unique within a model.  Unfortunately, when we do
partial evaluation, the full name changes!

TODO: do we need a hash function?

Definition at line 1673 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.fullname().

     def __hash__(self):
         """Hashing function for variables.
 
         Hash is based on hashing the full name of the variable, as
         this must be unique within a model.  Unfortunately, when we do
         partial evaluation, the full name changes!
         
         TODO: do we need a hash function?
         """
         return hash(self.fullname(cellml=True))
 

◆ repr()

def CellMLToNektar.pycml.cellml_variable.__repr__ ( self )

Definition at line 1758 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.fullname().

     def __repr__(self):
         return '<cellml_variable %s @ 0x%x>' % (self.fullname(), id(self))
 

◆ str()

def CellMLToNektar.pycml.cellml_variable.__str__ ( self )

Definition at line 1755 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.fullname().

     def __str__(self):
         return 'cellml_variable' + self.fullname()
     

◆ _add_dependency()

def CellMLToNektar.pycml.cellml_variable._add_dependency	(	self,
		dep
	)

private

Add a dependency of this variable.

This could be an expression defining it, or a variable it's mapped from.
Triggers a validation error if we already have another dependency,
since a variable can't be defined in more than one way.

Definition at line 1773 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_depends_on, and CellMLToNektar.pycml.cellml_variable.fullname().

Referenced by CellMLToNektar.pycml.cellml_variable._set_source_variable().

     def _add_dependency(self, dep):
         """Add a dependency of this variable.
         
         This could be an expression defining it, or a variable it's mapped from.
         Triggers a validation error if we already have another dependency,
         since a variable can't be defined in more than one way.
         """
         if self._cml_depends_on:
             if not dep in self._cml_depends_on:
                 # Multiple dependencies. TODO: Give more info.
                 raise MathsError(dep, u' '.join([
                     u'The variable',self.fullname(),
                     u'gets its value from multiple locations.']))
         else:
             self._cml_depends_on.append(dep)
         return
     

◆ _add_ode_dependency()

def CellMLToNektar.pycml.cellml_variable._add_ode_dependency	(	self,
		independent_var,
		expr
	)

private

Add a dependency of this variable as the dependent variable in an ODE.

independent_var is the corresponding independent variable, and expr is the
expression defining the ODE.
Triggers a validation error if the same ODE is defined by multiple expressions.

Definition at line 1796 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_depends_on_ode, and CellMLToNektar.pycml.cellml_variable.fullname().

     def _add_ode_dependency(self, independent_var, expr):
         """Add a dependency of this variable as the dependent variable in an ODE.
         
         independent_var is the corresponding independent variable, and expr is the
         expression defining the ODE.
         Triggers a validation error if the same ODE is defined by multiple expressions.
         """
         if independent_var in self._cml_depends_on_ode:
             if self._cml_depends_on_ode[independent_var] != expr:
                 # Multiple definitions.  TODO: Give more info.
                 raise MathsError(expr, u''.join([
                     u'There are multiple definitions of the ODE d',self.fullname(),
                     u'/d',independent_var.fullname()]))
         else:
             self._cml_depends_on_ode[independent_var] = expr
         return
     

◆ _decrement_usage_count()

def CellMLToNektar.pycml.cellml_variable._decrement_usage_count	(	self,
		follow_maps = `True`
	)

private

Decrement our usage count.

Definition at line 1947 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_usage_count, CellMLToNektar.pycml.cellml_variable._cml_var_type, CellMLToNektar.utilities.DEBUG(), CellMLToNektar.pycml.cellml_variable.fullname(), and CellMLToNektar.pycml.cellml_variable.get_source_variable().

     def _decrement_usage_count(self, follow_maps=True):
         """Decrement our usage count."""
         DEBUG('partial-evaluator', "Dec usage for", self.fullname())
         assert self._cml_usage_count > 0
         self._cml_usage_count -= 1
         if follow_maps and self._cml_var_type == VarTypes.Mapped:
             self.get_source_variable()._decrement_usage_count()
         # Note in the model if a usage count has decreased to 1, in
         # order to repeat the partial evaluation loop.
         if self._cml_usage_count == 1:
             model = self.xml_parent.xml_parent
             model._pe_repeat = u'yes'
         return
 

◆ _get_binding_time()

def CellMLToNektar.pycml.cellml_variable._get_binding_time ( self )

private

Return the binding time of this variable, as a member of
the BINDING_TIMES Enum.

This method will (try to) compute & cache the binding time if
necessary.

Variables are classified based on their type:
  State, Free -> dynamic
  Constant -> static
  Mapped -> binding time of source variable
  Computed -> binding time of defining expression

Definition at line 2074 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_binding_time, CellMLToNektar.pycml.cellml_variable._cml_depends_on, CellMLToNektar.pycml.cellml_variable._set_binding_time(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.pycml.cellml_variable.fullname(), CellMLToNektar.pycml.cellml_variable.get_rdf_annotation(), CellMLToNektar.pycml.cellml_variable.get_source_variable(), CellMLToNektar.pycml.cellml_variable.get_type(), and CellMLToNektar.pycml.cellml_variable.pe_keep().

Referenced by CellMLToNektar.pycml.mathml_ci._reduce(), CellMLToNektar.pycml.mathml_apply._reduce(), CellMLToNektar.pycml.mathml_piecewise._reduce(), CellMLToNektar.pycml.cellml_variable.get_value(), and CellMLToNektar.pycml.cellml_variable.is_statically_const().

     def _get_binding_time(self):
         """Return the binding time of this variable, as a member of
         the BINDING_TIMES Enum.
 
         This method will (try to) compute & cache the binding time if
         necessary.
 
         Variables are classified based on their type:
           State, Free -> dynamic
           Constant -> static
           Mapped -> binding time of source variable
           Computed -> binding time of defining expression
         """
         if self._cml_binding_time is None:
             # Check for an annotation setting the BT
             bt_annotation = self.get_rdf_annotation(('pe:binding_time', NSS[u'pe']))
             if bt_annotation:
                 bt = getattr(BINDING_TIMES, bt_annotation)
                 DEBUG('partial-evaluator', "BT var", self.fullname(), "is annotated as", bt)
             elif self.pe_keep:
                 # This variable must appear in the specialised model
                 bt = BINDING_TIMES.dynamic
                 DEBUG('partial-evaluator', "BT var", self.fullname(), "is kept")
             else:
                 # Compute BT based on our type
                 t = self.get_type()
                 DEBUG('partial-evaluator', "BT var", self.fullname(), "type", str(t))
                 if t in [VarTypes.State, VarTypes.Free, VarTypes.Unknown]:
                     bt = BINDING_TIMES.dynamic
                 elif t == VarTypes.Constant:
                     bt = BINDING_TIMES.static
                 elif t == VarTypes.Mapped:
                     bt = self.get_source_variable()._get_binding_time()
                 elif t == VarTypes.Computed:
                     bt = self._cml_depends_on[0]._get_binding_time()
                 else:
                     raise TypeError("Unexpected variable type " + str(t) +
                                     " of variable " + self.fullname() +
                                     " in BTA.")
                 DEBUG('partial-evaluator', "BT var", self.fullname(), "is", bt)
             self._set_binding_time(bt)
         else:
             bt = self._cml_binding_time
         return bt
     

◆ _reduce()

def CellMLToNektar.pycml.cellml_variable._reduce	(	self,
		update_usage = `False`
	)

private

Reduce this dynamic variable that is being kept.

If it has a static source, then turn it into a constant.
Otherwise make it depend directly on an appropriate source:
either one of its source variables that is also being kept,
or the ultimate defining expression.

If update_usage is True then this variable is used in an equation,
so reduce the usage of any source variables it no longer depends on.

Definition at line 2272 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_var_type, CellMLToNektar.pycml.cellml_variable.get_source_variable(), and CellMLToNektar.pycml.cellml_variable.pe_keep().

     def _reduce(self, update_usage=False):
         """Reduce this dynamic variable that is being kept.
 
         If it has a static source, then turn it into a constant.
         Otherwise make it depend directly on an appropriate source:
         either one of its source variables that is also being kept,
         or the ultimate defining expression.
 
         If update_usage is True then this variable is used in an equation,
         so reduce the usage of any source variables it no longer depends on.
         """
         assert self.pe_keep
         src = self.get_source_variable(recurse=True)
         if src._get_binding_time() is BINDING_TIMES.static:
             # Become a constant
             self._cml_var_type = VarTypes.Constant
             # Set our value
             value = unicode(src.get_value())
             self.initial_value = value
             # Fix up usage counts
             if update_usage:
                 self.get_source_variable()._decrement_usage_count()
             # We now have no dependencies
             self._cml_depends_on = []
             self._cml_source_var = None
         elif self.get_type() == VarTypes.Mapped:
             # Manually recurse down maps to find a suitable source
             src = self.get_source_variable()
             while not src.pe_keep and src.get_type() == VarTypes.Mapped and src.get_usage_count() == 1:
                 src = src.get_source_variable()
             if src.pe_keep or src.get_usage_count() > 1:
                 # Depend directly on src
                 self._cml_depends_on = [src]
                 self._cml_source_var = src
                 # Fix up usage counts
                 if update_usage:
                     src._used()
                     self.get_source_variable()._decrement_usage_count()
             else: # src.get_type() != VarTypes.Mapped
                 # This variable is the only reference to the ultimate defining
                 # expression, so become computed.
                 self._cml_var_type = VarTypes.Computed
                 defn = src.get_dependencies()[0]
                 assert isinstance(defn, mathml_apply)
                 ## Move the definition to this component
                 #defn._unset_cached_links()
                 #defn.xml_parent.xml_remove_child(defn)
                 #self.component.math.xml_append(defn)
                 # Schedule the LHS of the defining expression for update
                 defn._cml_assigns_to = self
                 defn._pe_process = u'retarget'
                 # Fix up usage counts
                 if update_usage:
                     self.get_source_variable()._decrement_usage_count()
                 # Depend directly on the assignment expression
                 self._cml_depends_on = [defn]
                 self._cml_source_var = None
     

◆ _set_binding_time()

def CellMLToNektar.pycml.cellml_variable._set_binding_time	(	self,
		bt,
		temporary = `False`
	)

private

Set the binding time of this variable.

Options are members of the BINDING_TIMES Enum.

If temporary is True, then we're temporarily overriding the normal setting,
so save any existing annotation for later replacement.

Definition at line 2042 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._get_binding_time(), and CellMLToNektar.pycml.cellml_variable._unset_binding_time().

     def _set_binding_time(self, bt, temporary=False):
         """Set the binding time of this variable.
         
         Options are members of the BINDING_TIMES Enum.
         
         If temporary is True, then we're temporarily overriding the normal setting,
         so save any existing annotation for later replacement.
         """
         #print "set bt", self, bt, temporary
         assert bt in BINDING_TIMES
         if temporary and not hasattr(self, '_cml_saved_bt'):
             self._cml_saved_bt = self.get_rdf_annotation(('pe:binding_time', NSS[u'pe']))
         self.add_rdf_annotation(('pe:binding_time', NSS[u'pe']), str(bt))
         self._cml_binding_time = bt
         return
     

◆ _set_source_variable()

def CellMLToNektar.pycml.cellml_variable._set_source_variable	(	self,
		src_var
	)

private

Set this to be a mapped variable which imports its value from src_var.
A validation error is generated if we are already mapped.

Definition at line 1851 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._add_dependency(), CellMLToNektar.pycml.cellml_variable._cml_source_var, CellMLToNektar.pycml.cellml_variable._set_type(), CellMLToNektar.pycml.cellml_variable.fullname(), CellMLToNektar.processors.ModelModifier.model, Nektar::NekMeshUtils::CADSystemCFI.model, CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.pycml.cellml_variable.model().

     def _set_source_variable(self, src_var):
         """Set this to be a mapped variable which imports its value from src_var.
         A validation error is generated if we are already mapped.
         """
         if not self._cml_source_var is None:
             # Mapping already exists
             model = self.model
             debug = model.get_option('debug')
             model.validation_error(u' '.join([
                 'A variable with interface "in" may only obtain its',
                 'value from one location.\nBoth',
                 self._cml_source_var.fullname(debug=debug), 'and',
                 src_var.fullname(debug=debug), 'are exported to', self.fullname(debug=debug)]))
         else:
             self._cml_source_var = src_var
             self._set_type(VarTypes.Mapped)
             self._add_dependency(src_var)
         return
 

◆ _set_type()

def CellMLToNektar.pycml.cellml_variable._set_type	(	self,
		var_type,
		_orig = `None`
	)

private

Update the type of this variable.

The caller should check that the update makes sense.

If this variable already has type Mapped, then update the type of
our source variable, instead.

Definition at line 1894 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_usage_count, CellMLToNektar.pycml.cellml_variable._cml_var_type, and CellMLToNektar.pycml.cellml_variable.get_source_variable().

Referenced by CellMLToNektar.pycml.cellml_variable._set_source_variable().

     def _set_type(self, var_type, _orig=None):
         """Update the type of this variable.
         
         The caller should check that the update makes sense.
         
         If this variable already has type Mapped, then update the type of
         our source variable, instead.
         """
         # If this is becoming a state variable, increment its usage count
         if var_type is VarTypes.State and not self._cml_var_type is VarTypes.State:
             self._cml_usage_count += 1
         if self._cml_var_type == VarTypes.Mapped and not _orig is self:
             # Guard against infinite loops, since we haven't done a cyclic dependency check yet
             if _orig is None: _orig = self
             self.get_source_variable()._set_type(var_type, _orig=_orig)
         else:
             self._cml_var_type = var_type
         return
 

◆ _unset_binding_time()

def CellMLToNektar.pycml.cellml_variable._unset_binding_time	(	self,
		only_temporary = `False`
	)

private

Unset any stored binding time.

If the stored BT was a temporary setting, replace it with the original value.

Definition at line 2058 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_binding_time, CellMLToNektar.pycml.cellml_variable._cml_saved_bt, CellMLToNektar.pycml.cellml_variable._set_binding_time(), and CellMLToNektar.pycml.cellml_variable.remove_rdf_annotations().

     def _unset_binding_time(self, only_temporary=False):
         """Unset any stored binding time.
         
         If the stored BT was a temporary setting, replace it with the original value.
         """
         #print "unset bt", self, only_temporary
         self._cml_binding_time = None
         if hasattr(self, '_cml_saved_bt'):
             if self._cml_saved_bt:
                 self._set_binding_time(getattr(BINDING_TIMES, self._cml_saved_bt))
             else:
                 self.remove_rdf_annotations(('pe:binding_time', NSS[u'pe']))
             del self._cml_saved_bt
         elif not only_temporary:
             self.remove_rdf_annotations(('pe:binding_time', NSS[u'pe']))
         

◆ _update_ode_dependency()

def CellMLToNektar.pycml.cellml_variable._update_ode_dependency	(	self,
		free_var,
		defn
	)

private

Update an ODE dependency due to partial evaluation.

When the PE processes the LHS of a derivative equation, it alters the independent
variable to reference its source directly.  If this new source wasn't originally
our independent variable's source (e.g. due to a units conversion expression) then
this will break lookups of the ODE via _get_ode_dependency, so we need to update
the reference.

Definition at line 1813 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_depends_on_ode, CellMLToNektar.pycml.cellml_variable.get_source_variable(), and CellMLToNektar.pycml.cellml_variable.get_type().

     def _update_ode_dependency(self, free_var, defn):
         """Update an ODE dependency due to partial evaluation.
         
         When the PE processes the LHS of a derivative equation, it alters the independent
         variable to reference its source directly.  If this new source wasn't originally
         our independent variable's source (e.g. due to a units conversion expression) then
         this will break lookups of the ODE via _get_ode_dependency, so we need to update
         the reference.
         """
         if self.get_type() == VarTypes.Mapped:
             return self.get_source_variable()._update_ode_dependency(free_var, defn)
         self._cml_depends_on_ode.clear()
         self._cml_depends_on_ode[free_var] = defn
     

◆ _used()

def CellMLToNektar.pycml.cellml_variable._used ( self )

private

Note this variable as being used in an expression.

Keep track of the usage count.
If this is a mapped variable, note its source as being used,
as well.

Note that if a variable is used in 2 branches of a conditional
then this counts as 2 uses.

Definition at line 1924 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_usage_count, CellMLToNektar.pycml.cellml_variable._cml_var_type, and CellMLToNektar.pycml.cellml_variable.get_source_variable().

     def _used(self):
         """Note this variable as being used in an expression.
         
         Keep track of the usage count.
         If this is a mapped variable, note its source as being used,
         as well.
 
         Note that if a variable is used in 2 branches of a conditional
         then this counts as 2 uses.
         """
         self._cml_usage_count += 1
         if self._cml_var_type == VarTypes.MaybeConstant:
             self._cml_var_type = VarTypes.Constant
         elif self._cml_var_type == VarTypes.Mapped:
             self.get_source_variable()._used()
         return
 

◆ add_rdf_annotation()

def CellMLToNektar.pycml.cellml_variable.add_rdf_annotation	(	self,
		property,
		target,
		allow_dup = `False`
	)

Add an RDF annotation about this variable.

property must be a tuple (qname, namespace_uri).
target may either be a tuple as above, or a unicode string, in which
case it is interpreted as a literal RDF node.

If the variable does not already have a cmeta:id, one will be created
for it with value self.fullname(cellml=True).

The actual RDF will be added to the main RDF block in the model, which
will be created if it does not exist.  Any existing annotations of this
variable with the same property will be removed, unless allow_dup=True.

Definition at line 1961 of file pycml.py.

References CellMLToNektar.pycml.element_base.cmeta_id(), CellMLToNektar.pycml.cellml_variable.fullname(), CellMLToNektar.processors.ModelModifier.model, Nektar::NekMeshUtils::CADSystemCFI.model, CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.pycml.cellml_variable.model().

Referenced by CellMLToNektar.pycml.cellml_variable.set_oxmeta_name(), and CellMLToNektar.pycml.cellml_variable.set_rdf_annotation_from_boolean().

     def add_rdf_annotation(self, property, target, allow_dup=False):
         """Add an RDF annotation about this variable.
         
         property must be a tuple (qname, namespace_uri).
         target may either be a tuple as above, or a unicode string, in which
         case it is interpreted as a literal RDF node.
         
         If the variable does not already have a cmeta:id, one will be created
         for it with value self.fullname(cellml=True).
 
         The actual RDF will be added to the main RDF block in the model, which
         will be created if it does not exist.  Any existing annotations of this
         variable with the same property will be removed, unless allow_dup=True.
         """
         meta_id = self.cmeta_id
         if not meta_id:
             # Create ID for this variable, so we can refer to it in RDF
             meta_id = cellml_metadata.create_unique_id(self.model, unicode(self.fullname(cellml=True)))
             self.xml_set_attribute((u'cmeta:id', NSS['cmeta']), meta_id)
         property = cellml_metadata.create_rdf_node(property)
         target = cellml_metadata.create_rdf_node(target)
         source = cellml_metadata.create_rdf_node(fragment_id=meta_id)
         if allow_dup:
             cellml_metadata.add_statement(self.model, source, property, target)
         else:
             cellml_metadata.replace_statement(self.model, source, property, target)
 

◆ clear_dependency_info()

def CellMLToNektar.pycml.cellml_variable.clear_dependency_info ( self )

Clear the type, dependency, etc. information for this variable.

This allows us to re-run the type & dependency analysis for the model.

Definition at line 1657 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable.__init__().

     def clear_dependency_info(self):
         """Clear the type, dependency, etc. information for this variable.
         
         This allows us to re-run the type & dependency analysis for the model.
         """
         # The type of this variable is not yet known
         self._cml_var_type = VarTypes.Unknown
         self._cml_source_var = None
         self._cml_value = {}
         self._cml_binding_time = None
         # Dependency graph edges
         self._cml_depends_on = []
         self._cml_depends_on_ode = {}
         self._cml_usage_count = 0
         self.clear_colour()
 

◆ create_new()

def CellMLToNektar.pycml.cellml_variable.create_new	(	elt,
		name,
		units,
		id = `None`,
		initial_value = `None`,
		interfaces = `{}`
	)

static

Create a new <variable> element with the given name and units.

Optionally id, initial_value, and interfaces may also be given.

elt may be any existing XML element.

Definition at line 2331 of file pycml.py.

     def create_new(elt, name, units, id=None, initial_value=None, interfaces={}):
         """Create a new <variable> element with the given name and units.
         
         Optionally id, initial_value, and interfaces may also be given.
         
         elt may be any existing XML element.
         """
         attrs = {(u'units', None): unicode(units),
                  (u'name', None): unicode(name)}
         if id:
             attrs[(u'cmeta:id', NSS[u'cmeta'])] = unicode(id)
         if initial_value is not None and initial_value != u'':
             attrs[(u'initial_value', None)] = unicode(initial_value)
         for iface, val in interfaces.items():
             attrs[(iface + u'_interface', None)] = unicode(val)
         new_elt = elt.xml_create_element(u'variable', NSS[u'cml'], attributes=attrs)
         return new_elt
 

◆ fullname()

def CellMLToNektar.pycml.cellml_variable.fullname	(	self,
		cellml = `False`,
		debug = `False`
	)

Return the full name of this variable, i.e.
'(component_name,variable_name)'.

If cellml is given as True, return the name in a form compatible with
the CellML spec instead, i.e. component_name__variable_name, unless
the component has its ignore_component_name property set, in which case
just use variable_name.

If debug is True, also give information about the variable object.

Definition at line 1684 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.component, and CellMLToNektar.pycml.cellml_component.name.

     def fullname(self, cellml=False, debug=False):
         """
         Return the full name of this variable, i.e.
         '(component_name,variable_name)'.
 
         If cellml is given as True, return the name in a form compatible with
         the CellML spec instead, i.e. component_name__variable_name, unless
         the component has its ignore_component_name property set, in which case
         just use variable_name.
         
         If debug is True, also give information about the variable object.
         """
         if hasattr(self, 'xml_parent'):
             parent_name = self.xml_parent.name
             ignore_component = self.component.ignore_component_name
         else:
             parent_name = '*orphan*'
             ignore_component = True
         if cellml:
             if ignore_component:
                 vn = self.name
             else:
                 vn = parent_name + u'__' + self.name
         else:
             vn = u'(' + parent_name + u',' + self.name + u')'
         if debug:
             vn = '%s@0x%x' % (vn, id(self))
         return vn
 

◆ get_all_expr_dependencies()

def CellMLToNektar.pycml.cellml_variable.get_all_expr_dependencies ( self )

Return all expressions this variable depends on, either directly or as an ODE.

Definition at line 1845 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_depends_on, and CellMLToNektar.pycml.cellml_variable._cml_depends_on_ode.

     def get_all_expr_dependencies(self):
         """Return all expressions this variable depends on, either directly or as an ODE."""
         deps = filter(lambda d: isinstance(d, mathml_apply), self._cml_depends_on)
         deps.extend(self._cml_depends_on_ode.values())
         return deps
 

◆ get_component()

def CellMLToNektar.pycml.cellml_variable.get_component ( self )

Definition at line 1761 of file pycml.py.

1761 def get_component(self):

1762 return self.xml_parent

◆ get_dependencies()

def CellMLToNektar.pycml.cellml_variable.get_dependencies ( self )

Return the list of things this variable depends on.

Definition at line 1790 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_depends_on.

     def get_dependencies(self):
         """
         Return the list of things this variable depends on.
         """
         return self._cml_depends_on
     

◆ get_ode_dependency()

def CellMLToNektar.pycml.cellml_variable.get_ode_dependency	(	self,
		independent_var,
		context = `None`
	)

Return the expression defining the ODE giving the derivative of this
variable w.r.t. independent_var.
Triggers a validation error if the ODE has not been defined.

Definition at line 1827 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_depends_on_ode, CellMLToNektar.pycml.cellml_variable.fullname(), CellMLToNektar.pycml.cellml_variable.get_source_variable(), and CellMLToNektar.pycml.cellml_variable.get_type().

     def get_ode_dependency(self, independent_var, context=None):
         """
         Return the expression defining the ODE giving the derivative of this
         variable w.r.t. independent_var.
         Triggers a validation error if the ODE has not been defined.
         """
         if self.get_type() == VarTypes.Mapped:
             return self.get_source_variable().get_ode_dependency(independent_var, context=context)
         free_vars = self._cml_depends_on_ode.keys()
         free_vars = dict(zip(map(lambda v: v.get_source_variable(recurse=True), free_vars),
                              free_vars))
         independent_src = independent_var.get_source_variable(recurse=True)
         if not independent_src in free_vars:
             raise MathsError(context or self, u''.join([
                 u'The ODE d',self.fullname(),u'/d',independent_var.fullname(),
                 u'is used but not defined.']))
         return self._cml_depends_on_ode[free_vars[independent_src]]
     

◆ get_rdf_annotation()

def CellMLToNektar.pycml.cellml_variable.get_rdf_annotation	(	self,
		property
	)

Get an RDF annotation about this variable.

property must be a tuple (qname, namespace_uri).

Will return the unique annotation found with source being this variable's id,
and the given property.  If no annotation is found (or if the variable does
not have a cmeta:id), returns None.  Throws an error if more than one
annotation is found.

Definition at line 1988 of file pycml.py.

References CellMLToNektar.pycml.element_base.cmeta_id(), CellMLToNektar.processors.ModelModifier.model, Nektar::NekMeshUtils::CADSystemCFI.model, CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.pycml.cellml_variable.model().

Referenced by CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.cellml_variable.is_derived_quantity(), CellMLToNektar.pycml.cellml_variable.is_modifiable_parameter(), CellMLToNektar.pycml.cellml_variable.is_output_variable(), and CellMLToNektar.pycml.cellml_variable.pe_keep().

     def get_rdf_annotation(self, property):
         """Get an RDF annotation about this variable.
         
         property must be a tuple (qname, namespace_uri).
         
         Will return the unique annotation found with source being this variable's id,
         and the given property.  If no annotation is found (or if the variable does
         not have a cmeta:id), returns None.  Throws an error if more than one
         annotation is found.
         """
         meta_id = self.cmeta_id
         if not meta_id:
             return None
         property = cellml_metadata.create_rdf_node(property)
         source = cellml_metadata.create_rdf_node(fragment_id=meta_id)
         return cellml_metadata.get_target(self.model, source, property)
     

◆ get_rdf_annotations()

def CellMLToNektar.pycml.cellml_variable.get_rdf_annotations	(	self,
		property
	)

Get all RDF annotations about this variable that use the given property.

property must be a tuple (qname, namespace_uri).

Will return all annotations found with source being this variable's id,
and the given property.  If no annotation is found (or if the variable does
not have a cmeta:id), returns the empty list

Definition at line 2005 of file pycml.py.

References CellMLToNektar.pycml.element_base.cmeta_id(), CellMLToNektar.processors.ModelModifier.model, Nektar::NekMeshUtils::CADSystemCFI.model, CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.pycml.cellml_variable.model().

Referenced by CellMLToNektar.pycml.cellml_variable.oxmeta_name().

     def get_rdf_annotations(self, property):
         """Get all RDF annotations about this variable that use the given property.
         
         property must be a tuple (qname, namespace_uri).
         
         Will return all annotations found with source being this variable's id,
         and the given property.  If no annotation is found (or if the variable does
         not have a cmeta:id), returns the empty list
         """
         meta_id = self.cmeta_id
         if not meta_id:
             return []
         property = cellml_metadata.create_rdf_node(property)
         source = cellml_metadata.create_rdf_node(fragment_id=meta_id)
         return cellml_metadata.get_targets(self.model, source, property)
 

◆ get_source_variable()

def CellMLToNektar.pycml.cellml_variable.get_source_variable	(	self,
		recurse = `False`
	)

Assuming this variable imports its value, return the variable
from which we obtain our value.
If our value is determined within this component, raise a
TypeError.

If recurse is set to True, recursively follow mappings until
a non-mapped variable is found.

Definition at line 1870 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_source_var, and CellMLToNektar.pycml.cellml_variable.fullname().

     def get_source_variable(self, recurse=False):
         """
         Assuming this variable imports its value, return the variable
         from which we obtain our value.
         If our value is determined within this component, raise a
         TypeError.
 
         If recurse is set to True, recursively follow mappings until
         a non-mapped variable is found.
         """
         if self._cml_source_var is None:
             if recurse:
                 src = self
             else:
                 raise TypeError(u' '.join([
                     'Variable', self.fullname(), u'is not a mapped variable',
                     '(i.e. does not obtain its value from another component).'
                     ]))
         else:
             src = self._cml_source_var
             if recurse:
                 src = src.get_source_variable(recurse=True)
         return src
     

◆ get_type()

def CellMLToNektar.pycml.cellml_variable.get_type	(	self,
		follow_maps = `False`
	)

Return the type of this variable.

If follow_maps is True and the value of this variable is imported
from another component, then return the type of the variable we
get our value from instead.

Definition at line 1913 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_var_type, and CellMLToNektar.pycml.cellml_variable.get_source_variable().

     def get_type(self, follow_maps=False):
         """Return the type of this variable.
         
         If follow_maps is True and the value of this variable is imported
         from another component, then return the type of the variable we
         get our value from instead.
         """
         if follow_maps and self._cml_var_type == VarTypes.Mapped:
             return self.get_source_variable().get_type(follow_maps=True)
         return self._cml_var_type
 

◆ get_units()

def CellMLToNektar.pycml.cellml_variable.get_units ( self )

Get the cellml_units object giving this variable's units.

Definition at line 1769 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.component, and CellMLToNektar.pycml.get_units_by_name().

Referenced by CellMLToNektar.pycml.mathml._ensure_units_exist(), CellMLToNektar.pycml.mathml_units_mixin_tokens._set_in_units(), and CellMLToNektar.pycml.mathml_apply._set_in_units().

     def get_units(self):
         """Get the cellml_units object giving this variable's units."""
         return self.component.get_units_by_name(self.units)
 

◆ get_usage_count()

def CellMLToNektar.pycml.cellml_variable.get_usage_count ( self )

Return the number of times this variable is used in an expression.

Definition at line 1941 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_usage_count.

     def get_usage_count(self):
         """
         Return the number of times this variable is used in an expression.
         """
         return self._cml_usage_count
 

◆ get_value()

def CellMLToNektar.pycml.cellml_variable.get_value	(	self,
		ode = `None`
	)

Return the value of this variable.

If a value has been set with set_value(), return that.
Otherwise, the behaviour depends on the type of this variable.
If it is Mapped, return the value of the source variable.
If it is Constant or State, return its initial value.
Otherwise, raise an EvaluationError.

If ode is given, it should be an instance of cellml_variable.
In this case, we're getting the value of d(self)/d(ode).

Definition at line 2171 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_depends_on, CellMLToNektar.pycml.cellml_variable._cml_value, CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.cellml_variable.fullname(), CellMLToNektar.pycml.cellml_variable.get_source_variable(), CellMLToNektar.pycml.cellml_variable.get_type(), and CellMLToNektar.pycml.cellml_variable.initial_value.

     def get_value(self, ode=None):
         """Return the value of this variable.
 
         If a value has been set with set_value(), return that.
         Otherwise, the behaviour depends on the type of this variable.
         If it is Mapped, return the value of the source variable.
         If it is Constant or State, return its initial value.
         Otherwise, raise an EvaluationError.
 
         If ode is given, it should be an instance of cellml_variable.
         In this case, we're getting the value of d(self)/d(ode).
         """
         # TODO: Might want to alter the handling of initial value for an ODE?
         if ode in self._cml_value:
             val = self._cml_value[ode]
         elif self.get_type() == VarTypes.Mapped:
             val = self.get_source_variable().get_value(ode=ode)
         elif ode is None and self.get_type() in [VarTypes.Unknown,
                                                  VarTypes.State, VarTypes.Constant]:
             if hasattr(self, 'initial_value'):
                 val = float(self.initial_value)
             else:
                 raise EvaluationError("Variable " + self.fullname() + " has no initial value set.")
         elif self.get_type() == VarTypes.Computed and self._get_binding_time() == BINDING_TIMES.static:
             # Evaluate the defining expression
             val = self._cml_depends_on[0].evaluate()
         else:
             raise EvaluationError("Unable to find a suitable value for variable " + self.fullname())
         return val
 

◆ get_variable_object()

def CellMLToNektar.pycml.cellml_variable.get_variable_object	(	model,
		varname
	)

static

Return the variable object that has name varname.

This method tries to handle various forms of fully qualified variable name, i.e. names which
include the name of the component the variable occurs in, including those created by
CellMLTranslator.code_name.

Definition at line 1730 of file pycml.py.

     def get_variable_object(model, varname):
         """Return the variable object that has name varname.
         
         This method tries to handle various forms of fully qualified variable name, i.e. names which
         include the name of the component the variable occurs in, including those created by
         CellMLTranslator.code_name.
         """
         varname = unicode(varname)
         if varname[:4] == 'var_':
             varname = varname[4:]
         cname, vname = cellml_variable.split_name(varname)
         if len(model.component) == 1 and cname == model.component.name:
             var = model.component.get_variable_by_name(vname)
         else:
             try:
                 var = model.get_variable_by_name(cname, vname)
             except KeyError, e:
                 try:
                     if cname:
                         vname = cname + u'__' + vname
                     var = model.component.get_variable_by_name(vname)
                 except KeyError:
                     raise e
         return var
     

◆ is_derived_quantity()

def CellMLToNektar.pycml.cellml_variable.is_derived_quantity ( self )

Whether this variable should be included in reports of derived quantities.

Definition at line 2216 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.get_rdf_annotation().

Referenced by CellMLToNektar.pycml.cellml_variable.pe_keep().

     def is_derived_quantity(self):
         """Whether this variable should be included in reports of derived quantities."""
         return self.get_rdf_annotation(('pycml:derived-quantity', NSS['pycml'])) == 'yes'

◆ is_modifiable_parameter()

def CellMLToNektar.pycml.cellml_variable.is_modifiable_parameter ( self )

Whether this variable is a parameter that should be modifiable at run-time.

Definition at line 2202 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.get_rdf_annotation(), and CellMLToNektar.pycml.cellml_variable.get_type().

Referenced by CellMLToNektar.pycml.cellml_variable.pe_keep().

     def is_modifiable_parameter(self):
         """Whether this variable is a parameter that should be modifiable at run-time."""
         return (self.get_type() == VarTypes.Constant and
                 self.get_rdf_annotation(('pycml:modifiable-parameter', NSS['pycml'])) == 'yes')

◆ is_output_variable()

def CellMLToNektar.pycml.cellml_variable.is_output_variable ( self )

Whether a protocol has requested this variable as a model output.

Definition at line 2227 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.get_rdf_annotation().

Referenced by CellMLToNektar.pycml.cellml_variable.pe_keep().

     def is_output_variable(self):
         """Whether a protocol has requested this variable as a model output."""
         return self.get_rdf_annotation(('pycml:output-variable', NSS['pycml'])) == 'yes'

◆ is_statically_const()

def CellMLToNektar.pycml.cellml_variable.is_statically_const	(	self,
		ignore_annotations = `False`
	)

Determine loosely if this variable is considered constant.

Checks if we're Constant, or Computed with a static binding time (or
of unknown type).

If ignore_annotations is True, will ignore cached binding time values and
pe:keep annotations.  It instead finds all variables we depend on, directly or
indirectly, and gives a dynamic result iff any is a state or free variable.

Definition at line 2119 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.cellml_variable.get_source_variable(), CellMLToNektar.pycml.cellml_variable.get_type(), CellMLToNektar.processors.ModelModifier.model, Nektar::NekMeshUtils::CADSystemCFI.model, CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.pycml.cellml_variable.model().

     def is_statically_const(self, ignore_annotations=False):
         """Determine loosely if this variable is considered constant.
         
         Checks if we're Constant, or Computed with a static binding time (or
         of unknown type).
         
         If ignore_annotations is True, will ignore cached binding time values and
         pe:keep annotations.  It instead finds all variables we depend on, directly or
         indirectly, and gives a dynamic result iff any is a state or free variable.
         """
         result = False
         t = self.get_type()
         if t in [VarTypes.Constant, VarTypes.Unknown]:
             result = True
         elif t == VarTypes.Computed:
             if ignore_annotations:
                 dependencies = self.model.calculate_extended_dependencies([self])
                 result = True
                 for node in dependencies:
                     if isinstance(node, cellml_variable) and node.get_type() in [VarTypes.State, VarTypes.Free]:
                         result = False
                         break
             else:
                 result = self._get_binding_time() == BINDING_TIMES.static
         elif t == VarTypes.Mapped:
             result = self.get_source_variable().is_statically_const(ignore_annotations)
         return result
 

◆ model()

def CellMLToNektar.pycml.cellml_variable.model ( self )

Definition at line 1766 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.component.

     def model(self):
         return self.component.xml_parent
     

◆ oxmeta_name()

def CellMLToNektar.pycml.cellml_variable.oxmeta_name ( self )

The canonical name of this variable, as given by Oxford metadata.

Returns the empty string if no annotation is given.

Definition at line 2252 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.get_rdf_annotations().

     def oxmeta_name(self):
         """The canonical name of this variable, as given by Oxford metadata.
 
         Returns the empty string if no annotation is given.
         """
         for annotation in self.get_rdf_annotations(('bqbiol:is', NSS['bqbiol'])):
             name = cellml_metadata.namespace_member(annotation, NSS['oxmeta'], wrong_ns_ok=True)
             if name:
                 return name
         # No suitable annotation found
         return ""

◆ pe_keep()

def CellMLToNektar.pycml.cellml_variable.pe_keep ( self )

Whether PE should retain this variable in the specialised model.

Definition at line 2238 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.get_rdf_annotation(), CellMLToNektar.pycml.cellml_variable.is_derived_quantity(), CellMLToNektar.pycml.cellml_variable.is_modifiable_parameter(), and CellMLToNektar.pycml.cellml_variable.is_output_variable().

Referenced by CellMLToNektar.pycml.cellml_variable._get_binding_time(), and CellMLToNektar.pycml.cellml_variable._reduce().

     def pe_keep(self):
         """Whether PE should retain this variable in the specialised model."""
         return (self.get_rdf_annotation(('pe:keep', NSS[u'pe'])) == 'yes' or
                 self.is_modifiable_parameter or
                 self.is_derived_quantity or
                 self.is_output_variable)

◆ remove_rdf_annotations()

def CellMLToNektar.pycml.cellml_variable.remove_rdf_annotations	(	self,
		property = `None`
	)

Remove all RDF annotations about this variable.

If property is given, only remove annotations with the given property.

Definition at line 2021 of file pycml.py.

References CellMLToNektar.pycml.element_base.cmeta_id(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.processors.ModelModifier.model, Nektar::NekMeshUtils::CADSystemCFI.model, CellMLToNektar.translators.CellMLTranslator.model, and CellMLToNektar.pycml.cellml_variable.model().

Referenced by CellMLToNektar.pycml.cellml_variable._unset_binding_time().

     def remove_rdf_annotations(self, property=None):
         """Remove all RDF annotations about this variable.
         
         If property is given, only remove annotations with the given property.
         """
         meta_id = self.cmeta_id
         if meta_id:
             DEBUG('cellml-metadata', "Removing RDF annotations for", self, "with id", meta_id)
             source = cellml_metadata.create_rdf_node(fragment_id=meta_id)
             if property:
                 property = cellml_metadata.create_rdf_node(property)
             cellml_metadata.remove_statements(self.model, source, property, None)
 

◆ set_is_derived_quantity()

def CellMLToNektar.pycml.cellml_variable.set_is_derived_quantity	(	self,
		is_dq
	)

Set method for the is_derived_quantity property.

We need a separate method for this to bypass Amara's property setting checks.

Definition at line 2219 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.set_rdf_annotation_from_boolean().

     def set_is_derived_quantity(self, is_dq):
         """Set method for the is_derived_quantity property.
         
         We need a separate method for this to bypass Amara's property setting checks.
         """
         self.set_rdf_annotation_from_boolean(('pycml:derived-quantity', NSS[u'pycml']), is_dq)
 

◆ set_is_modifiable_parameter()

def CellMLToNektar.pycml.cellml_variable.set_is_modifiable_parameter	(	self,
		is_param
	)

Set method for the is_modifiable_parameter property.

We need a separate method for this to bypass Amara's property setting checks.

Definition at line 2206 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.fullname(), CellMLToNektar.pycml.cellml_variable.get_type(), and CellMLToNektar.pycml.cellml_variable.set_rdf_annotation_from_boolean().

     def set_is_modifiable_parameter(self, is_param):
         """Set method for the is_modifiable_parameter property.
         
         We need a separate method for this to bypass Amara's property setting checks.
         """
         if is_param and self.get_type() != VarTypes.Constant:
             raise ValueError("A non-constant variable (%s) cannot be set as a parameter" % (self.fullname(),))
         self.set_rdf_annotation_from_boolean(('pycml:modifiable-parameter', NSS[u'pycml']), is_param)
 

◆ set_is_output_variable()

def CellMLToNektar.pycml.cellml_variable.set_is_output_variable	(	self,
		is_ov
	)

Set method for the is_output_variable property.

We need a separate method for this to bypass Amara's property setting checks.

Definition at line 2230 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.set_rdf_annotation_from_boolean().

     def set_is_output_variable(self, is_ov):
         """Set method for the is_output_variable property.
         
         We need a separate method for this to bypass Amara's property setting checks.
         """
         self.set_rdf_annotation_from_boolean(('pycml:output-variable', NSS[u'pycml']), is_ov)
 

◆ set_oxmeta_name()

def CellMLToNektar.pycml.cellml_variable.set_oxmeta_name	(	self,
		name
	)

Set method for the oxmeta_name property.

Sets a bqbiol:is RDF annotation with the name.

We need a separate method for this to bypass Amara's property setting checks.

Definition at line 2263 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.add_rdf_annotation().

     def set_oxmeta_name(self, name):
         """Set method for the oxmeta_name property.
         
         Sets a bqbiol:is RDF annotation with the name.
         
         We need a separate method for this to bypass Amara's property setting checks.
         """
         self.add_rdf_annotation(('bqbiol:is', NSS['bqbiol']), ('oxmeta:'+name, NSS['oxmeta']))
 

◆ set_pe_keep()

def CellMLToNektar.pycml.cellml_variable.set_pe_keep	(	self,
		keep
	)

Set method for the pe_keep property.

We need a separate method for this to bypass Amara's property setting checks.

Definition at line 2244 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.set_rdf_annotation_from_boolean().

     def set_pe_keep(self, keep):
         """Set method for the pe_keep property.
         
         We need a separate method for this to bypass Amara's property setting checks.
         """
         self.set_rdf_annotation_from_boolean(('pe:keep', NSS[u'pe']), keep)
 

◆ set_rdf_annotation_from_boolean()

def CellMLToNektar.pycml.cellml_variable.set_rdf_annotation_from_boolean	(	self,
		property,
		is_yes
	)

Set an RDF annotation as 'yes' or 'no' depending on a boolean value.

Definition at line 2034 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable.add_rdf_annotation().

Referenced by CellMLToNektar.pycml.cellml_variable.set_is_derived_quantity(), CellMLToNektar.pycml.cellml_variable.set_is_modifiable_parameter(), CellMLToNektar.pycml.cellml_variable.set_is_output_variable(), and CellMLToNektar.pycml.cellml_variable.set_pe_keep().

     def set_rdf_annotation_from_boolean(self, property, is_yes):
         """Set an RDF annotation as 'yes' or 'no' depending on a boolean value."""
         if is_yes:
             val = 'yes'
         else:
             val = 'no'
         self.add_rdf_annotation(property, val)
 

◆ set_value()

def CellMLToNektar.pycml.cellml_variable.set_value	(	self,
		value,
		ode = `None`,
		follow_maps = `True`
	)

Set the value of this variable.

Expects a floating point or boolean value.

If ode is given, it should be an instance of cellml_variable.
In this case, we're setting the value of d(self)/d(ode).

If this is a mapped variable, assign the value to its source
variable instead, unless follow_maps is set to False

Definition at line 2147 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_value, CellMLToNektar.pycml.cellml_variable.get_source_variable(), and CellMLToNektar.pycml.cellml_variable.get_type().

     def set_value(self, value, ode=None, follow_maps=True):
         """Set the value of this variable.
 
         Expects a floating point or boolean value.
 
         If ode is given, it should be an instance of cellml_variable.
         In this case, we're setting the value of d(self)/d(ode).
 
         If this is a mapped variable, assign the value to its source
         variable instead, unless follow_maps is set to False
         """
         #print "set_value", self, ode, value
         if follow_maps and self.get_type() == VarTypes.Mapped:
             self.get_source_variable().set_value(value, ode=ode)
         else:
             assert type(value) in [types.FloatType, types.BooleanType]
             self._cml_value[ode] = float(value)
         return

◆ split_name()

def CellMLToNektar.pycml.cellml_variable.split_name ( varname )

static

Split a variable name as given by cellml_variable.fullname into constituent parts.

Returns a tuple (component name, local variable name).  If the component name cannot
be identified, it will be returned as the empty string.

Definition at line 1714 of file pycml.py.

     def split_name(varname):
         """Split a variable name as given by cellml_variable.fullname into constituent parts.
         
         Returns a tuple (component name, local variable name).  If the component name cannot
         be identified, it will be returned as the empty string.
         """
         try:
             if varname[0] == u'(':
                 cname, vname = varname[1:-1].split(u',')
             else:
                 cname, vname = varname.split(u'__', 1)
         except ValueError:
             cname, vname = u'', varname
         return cname, vname
 

◆ unset_values()

def CellMLToNektar.pycml.cellml_variable.unset_values ( self )

Unset all values for this variable set with set_value.

Definition at line 2165 of file pycml.py.

References CellMLToNektar.pycml.cellml_variable._cml_value, CellMLToNektar.pycml.cellml_variable.get_source_variable(), and CellMLToNektar.pycml.cellml_variable.get_type().

     def unset_values(self):
         """Unset all values for this variable set with set_value."""
         #print "unset_values", self
         if self.get_type() == VarTypes.Mapped:
             self.get_source_variable().unset_values()
         self._cml_value.clear()

Member Data Documentation

◆ _cml_binding_time

CellMLToNektar.pycml.cellml_variable._cml_binding_time

private

Definition at line 1666 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.mathml_apply._get_binding_time(), CellMLToNektar.pycml.mathml_piecewise._get_binding_time(), and CellMLToNektar.pycml.cellml_variable._unset_binding_time().

◆ _cml_depends_on

CellMLToNektar.pycml.cellml_variable._cml_depends_on

private

Move the definition to this component defn._unset_cached_links() defn.xml_parent.xml_remove_child(defn) self.component.math.xml_append(defn) Schedule the LHS of the defining expression for update.

Definition at line 1668 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._add_dependency(), CellMLToNektar.pycml.cellml_variable._get_binding_time(), CellMLToNektar.pycml.cellml_variable.get_all_expr_dependencies(), CellMLToNektar.pycml.cellml_variable.get_dependencies(), CellMLToNektar.pycml.mathml_apply.get_dependencies(), and CellMLToNektar.pycml.cellml_variable.get_value().

◆ _cml_depends_on_ode

CellMLToNektar.pycml.cellml_variable._cml_depends_on_ode

private

Definition at line 1669 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._add_ode_dependency(), CellMLToNektar.pycml.cellml_variable._update_ode_dependency(), CellMLToNektar.pycml.cellml_variable.get_all_expr_dependencies(), and CellMLToNektar.pycml.cellml_variable.get_ode_dependency().

◆ _cml_saved_bt

CellMLToNektar.pycml.cellml_variable._cml_saved_bt

private

Definition at line 2053 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._unset_binding_time().

◆ _cml_source_var

CellMLToNektar.pycml.cellml_variable._cml_source_var

private

Definition at line 1664 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._set_source_variable(), and CellMLToNektar.pycml.cellml_variable.get_source_variable().

◆ _cml_usage_count

CellMLToNektar.pycml.cellml_variable._cml_usage_count

private

Definition at line 1670 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._decrement_usage_count(), CellMLToNektar.pycml.cellml_variable._set_type(), CellMLToNektar.pycml.cellml_variable._used(), and CellMLToNektar.pycml.cellml_variable.get_usage_count().

◆ _cml_value

CellMLToNektar.pycml.cellml_variable._cml_value

private

Definition at line 1665 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable.get_value(), CellMLToNektar.pycml.cellml_variable.set_value(), and CellMLToNektar.pycml.cellml_variable.unset_values().

◆ _cml_var_type

CellMLToNektar.pycml.cellml_variable._cml_var_type

private

Definition at line 1663 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable._decrement_usage_count(), CellMLToNektar.pycml.cellml_variable._reduce(), CellMLToNektar.pycml.cellml_variable._set_type(), CellMLToNektar.pycml.cellml_variable._used(), and CellMLToNektar.pycml.cellml_variable.get_type().

◆ initial_value

CellMLToNektar.pycml.cellml_variable.initial_value

Definition at line 2290 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_variable.get_value().

Property Documentation

◆ component

CellMLToNektar.pycml.cellml_variable.component = property(get_component)

static

Definition at line 1763 of file pycml.py.

Referenced by CellMLToNektar.pycml.mathml_constructor._get_element_units(), CellMLToNektar.pycml.mathml_units_mixin._set_element_in_units(), CellMLToNektar.pycml.cellml_variable.fullname(), CellMLToNektar.pycml.cellml_variable.get_units(), CellMLToNektar.pycml.mathml_ci.get_units(), CellMLToNektar.pycml.cellml_model.get_variable_by_name(), CellMLToNektar.pycml.cellml_variable.model(), and CellMLToNektar.pycml.mathml_ci.variable().

Public Member Functions

Static Public Member Functions

Public Attributes

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __hash__()

◆ __repr__()

◆ __str__()

◆ _add_dependency()

◆ _add_ode_dependency()

◆ _decrement_usage_count()

◆ _get_binding_time()

◆ _reduce()

◆ _set_binding_time()

◆ _set_source_variable()

◆ _set_type()

◆ _unset_binding_time()

◆ _update_ode_dependency()

◆ _used()

◆ add_rdf_annotation()

◆ clear_dependency_info()

◆ create_new()

◆ fullname()

◆ get_all_expr_dependencies()

◆ get_component()

◆ get_dependencies()

◆ get_ode_dependency()

◆ get_rdf_annotation()

◆ get_rdf_annotations()

◆ get_source_variable()

◆ get_type()

◆ get_units()

◆ get_usage_count()

◆ get_value()

◆ get_variable_object()

◆ is_derived_quantity()

◆ is_modifiable_parameter()

◆ is_output_variable()

◆ is_statically_const()

◆ model()

◆ oxmeta_name()

◆ pe_keep()

◆ remove_rdf_annotations()

◆ set_is_derived_quantity()

◆ set_is_modifiable_parameter()

◆ set_is_output_variable()

◆ set_oxmeta_name()

◆ set_pe_keep()

◆ set_rdf_annotation_from_boolean()

◆ set_value()

◆ split_name()

◆ unset_values()

Member Data Documentation

◆ _cml_binding_time

◆ _cml_depends_on

◆ _cml_depends_on_ode

◆ _cml_saved_bt

◆ _cml_source_var

◆ _cml_usage_count

◆ _cml_value

◆ _cml_var_type

◆ initial_value

Property Documentation

◆ component

◆ init()

◆ hash()

◆ repr()

◆ str()