Inheritance diagram for CellMLToNektar.pycml.cellml_model:

[legend]

Public Member Functions
def	__init__ (self)

def	__del__ (self)

def	clean_up (self)

def	get_config (self, config_attr=None)

def	get_option (self, option_name)

def	get_component_by_name (self, compname)

def	get_variable_by_name (self, compname, varname)

def	get_variable_by_oxmeta_name (self, name, throw=True)

def	get_variables_by_ontology_term (self, term)

def	get_variable_by_cmeta_id (self, cmeta_id)

def	get_all_variables (self)

def	validation_error (self, errmsg, level=logging.ERROR)

def	get_validation_errors (self)

def	validation_warning (self, errmsg, level=logging.WARNING)

def	get_validation_warnings (self)

def	validate (self, xml_context=False, invalid_if_warnings=False, warn_on_units_errors=False, check_for_units_conversions=False, assume_valid=False, **ignored_kwargs)

def	search_for_assignments (self, comp=None)

def	build_name_dictionaries (self, rebuild=False)

def	build_component_hierarchy (self, relationship, namespace=None, name=None, rels=None)

def	topological_sort (self, node)

def	get_assignments (self)

def	clear_assignments (self)

def	do_binding_time_analysis (self)

def	get_standard_units (self)

def	get_all_units (self)

def	get_units_by_name (self, uname)

def	add_units (self, name, units)

def	has_units (self, units)

def	add_units_conversions (self)

def	find_state_vars (self)

def	find_free_vars (self)

def	calculate_extended_dependencies (self, nodes, prune=[], prune_deps=[], state_vars_depend_on_odes=False, state_vars_examined=set())

def	is_self_excitatory (self)

def	xml (self, stream=None, writer=None, **wargs)

Public Member Functions inherited from CellMLToNektar.pycml.element_base
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 Attributes
string	math_xpath_1 = u'cml:component/m:math'

string	math_xpath_2 = u'cml:component/cml:reaction/cml:variable_ref/cml:role/m:math'

string	apply_xpath_1 = u'/m:apply[m:eq]'

string	apply_xpath_2 = u'/m:semantics/m:apply[m:eq]'

Private Member Functions
def	_add_variable (self, var, varname, compname)

def	_del_variable (self, varname, compname)

def	_add_component (self, comp, special=False)

def	_del_component (self, comp)

def	_report_exception (self, e, show_xml_context)

def	_validate_component_hierarchies (self)

def	_check_variable_mappings (self)

def	_validate_connection (self, conn)

def	_check_variable_units_exist (self)

def	_check_connection_units (self, check_for_units_conversions=False)

def	_check_maths_name_references (self, expr, xml_context=False)

def	_check_assigned_vars (self, assignments, xml_context=False)

def	_check_cellml_subset (self, math_elts, root=True)

def	_classify_variables (self, assignment_exprs, xml_context=False)

def	_order_variables (self, assignment_exprs, xml_context=False)

def	_add_sorted_assignment (self, a)

def	_remove_assignment (self, a)

def	_check_dimensional_consistency (self, assignment_exprs, xml_context=False, warn_on_units_errors=False, check_for_units_conversions=False)

def	_check_unit_cycles (self, unit)

def	_build_units_dictionary (self)

def	_add_units_obj (self, units)

def	_get_units_obj (self, units)

def	_is_new_units_obj (self, units)

Private Attributes
	_cml_validation_errors

	_cml_validation_warnings

	_cml_variables

	_cml_components

	_cml_units

	_cml_standard_units

	_cml_units_map

	_cml_assignments

	_cml_sorting_variables_stack

	_cml_conversions_needed

Additional Inherited Members
Public Attributes inherited from CellMLToNektar.pycml.element_base
	xml_attributes

Detailed Description

Specialised class for the model element of a CellML document.
Adds methods for collecting and reporting validation errors, etc.

Definition at line 377 of file pycml.py.

Constructor & Destructor Documentation

◆ init()

def CellMLToNektar.pycml.cellml_model.__init__ ( self )

Reimplemented from CellMLToNektar.pycml.element_base.

Definition at line 383 of file pycml.py.

     def __init__(self):
         element_base.__init__(self)
         self._cml_validation_errors = []
         self._cml_validation_warnings = []
         self._cml_variables = {}
         self._cml_components = {}
         self._cml_units = {}
         self._cml_standard_units = {}
         self._cml_units_map = {}
         # Topologically sorted assignments list
         self._cml_assignments = []
     

◆ del()

def CellMLToNektar.pycml.cellml_model.__del__ ( self )

Definition at line 395 of file pycml.py.

     def __del__(self):
         self.clean_up()
         

References CellMLToNektar.pycml.cellml_model.clean_up().

Member Function Documentation

◆ _add_component()

def CellMLToNektar.pycml.cellml_model._add_component	(	self,
		comp,
		special = `False`
	)

private

Add a new component to the model.

Definition at line 499 of file pycml.py.

     def _add_component(self, comp, special=False):
         """Add a new component to the model."""
         if special:
             comp.xml_parent = self
         else:
             self.xml_append(comp)
         self._cml_components[comp.name] = comp
  

References CellMLToNektar.pycml.cellml_model._cml_components.

◆ _add_sorted_assignment()

def CellMLToNektar.pycml.cellml_model._add_sorted_assignment	(	self,
		a
	)

private

During the topological sort, add a finished assignment to the
list.  This list can then be executed in order to simulate the
model.

The element added can either be a MathML expression
representing an assignment, or a CellML variable element,
indicating an assignment due to a variable mapping.

Definition at line 1095 of file pycml.py.

     def _add_sorted_assignment(self, a):
         """
         During the topological sort, add a finished assignment to the
         list.  This list can then be executed in order to simulate the
         model.
  
         The element added can either be a MathML expression
         representing an assignment, or a CellML variable element,
         indicating an assignment due to a variable mapping.
         """
         self._cml_assignments.append(a)

References CellMLToNektar.pycml.cellml_model._cml_assignments.

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

◆ _add_units_obj()

def CellMLToNektar.pycml.cellml_model._add_units_obj	(	self,
		units
	)

private

Add a units object into the global hashmap.

Definition at line 1331 of file pycml.py.

     def _add_units_obj(self, units):
         """Add a units object into the global hashmap."""
         if not units.uniquify_tuple in self._cml_units_map:
             self._cml_units_map[units.uniquify_tuple] = units
         return
     

References CellMLToNektar.pycml.cellml_model._cml_units_map.

Referenced by CellMLToNektar.pycml.cellml_model._build_units_dictionary(), and CellMLToNektar.pycml.cellml_model.add_units().

◆ _add_variable()

def CellMLToNektar.pycml.cellml_model._add_variable	(	self,
		var,
		varname,
		compname
	)

private

Add a new variable to the model.

Definition at line 490 of file pycml.py.

     def _add_variable(self, var, varname, compname):
         """Add a new variable to the model."""
         assert (compname, varname) not in self._cml_variables
         self._cml_variables[(compname, varname)] = var
  

References CellMLToNektar.pycml.cellml_model._cml_variables.

◆ _build_units_dictionary()

def CellMLToNektar.pycml.cellml_model._build_units_dictionary ( self )

private

Create a dictionary mapping units names to objects, for all units definitions in this element.

Definition at line 1210 of file pycml.py.

     def _build_units_dictionary(self):
         """Create a dictionary mapping units names to objects, for all units definitions in this element."""
         # Standard units
         std_units = self._cml_standard_units
         def make(name, bases):
             return cellml_units.create_new(self, name, bases, standard=True)
         # SI base units & dimensionless
         base_units = [u'ampere', u'candela',  u'dimensionless', u'kelvin',
                       u'kilogram', u'metre', u'mole', u'second']
         base_units.append(u'#FUDGE#') # Used for PE of naughty models
         for units in base_units:
             std_units[units] = make(units, [])
         # Special cellml:boolean units
         boolean = make(u'cellml:boolean', [])
         std_units[u'cellml:boolean'] = boolean
         # Convenience derived units
         gram = make('gram', [{'units': 'kilogram', 'multiplier': '0.001'}])
         litre = make('litre', [{'multiplier': '1000', 'prefix': 'centi',
                                 'units': 'metre', 'exponent': '3'}])
         # SI derived units
         radian = make('radian', [{'units': 'metre'},
                                  {'units': 'metre', 'exponent': '-1'}])
         steradian = make('steradian', [{'units': 'metre', 'exponent': '2'},
                                        {'units': 'metre', 'exponent': '-2'}])
         hertz = make('hertz', [{'units': 'second', 'exponent': '-1'}])
         newton = make('newton', [{'units': 'metre'},
                                  {'units': 'kilogram'},
                                  {'units': 'second', 'exponent': '-2'}])
         pascal = make('pascal', [{'units': 'newton'},
                                  {'units': 'metre', 'exponent': '-2'}])
         joule = make('joule', [{'units': 'newton'},
                                {'units': 'metre'}])
         watt = make('watt', [{'units': 'joule'},
                              {'units': 'second', 'exponent': '-1'}])
         coulomb = make('coulomb', [{'units': 'second'},
                                    {'units': 'ampere'}])
         volt = make('volt', [{'units': 'watt'},
                              {'units': 'ampere', 'exponent': '-1'}])
         farad = make('farad', [{'units': 'coulomb'},
                                {'units': 'volt', 'exponent': '-1'}])
         ohm = make('ohm', [{'units': 'volt'},
                            {'units': 'ampere', 'exponent': '-1'}])
         siemens = make('siemens', [{'units': 'ampere'},
                                    {'units': 'volt', 'exponent': '-1'}])
         weber = make('weber', [{'units': 'volt'},
                                {'units': 'second'}])
         tesla = make('tesla', [{'units': 'weber'},
                                {'units': 'metre', 'exponent': '-2'}])
         henry = make('henry', [{'units': 'weber'},
                                {'units': 'ampere', 'exponent': '-1'}])
         celsius = make('celsius', [{'units': 'kelvin', 'offset': '-273.15'}])
         lumen = make('lumen', [{'units': 'candela'},
                                {'units': 'steradian'}])
         lux = make('lux', [{'units': 'lumen'},
                            {'units': 'metre', 'exponent': '-2'}])
         becquerel = make('becquerel', [{'units': 'second', 'exponent': '-1'}])
         gray = make('gray', [{'units': 'joule'},
                              {'units': 'kilogram', 'exponent': '-1'}])
         sievert = make('sievert', [{'units': 'joule'},
                                    {'units': 'kilogram', 'exponent': '-1'}])
         katal = make('katal', [{'units': 'second', 'exponent': '-1'},
                                {'units': 'mole'}])
         for units in [becquerel, celsius, coulomb, farad, gram, gray, henry,
                       hertz, joule, katal, litre, lumen, lux, newton, ohm,
                       pascal, radian, siemens, sievert, steradian, tesla,
                       volt, watt, weber]:
             std_units[units.name] = units
         # American spellings
         std_units[u'meter'] = std_units[u'metre']
         std_units[u'liter'] = std_units[u'litre']
         # User-defined units
         model_units = self._cml_units
         model_units.update(std_units)
         if hasattr(self, u'units'):
             for units in self.units:
                 if units.name in model_units:
                     self.validation_error("Units names must be unique within the parent component or model,"
                                           " and must not redefine the standard units (5.4.1.2)."
                                           " The units definition named '%s' in the model is a duplicate." % units.name)
                 model_units[units.name] = units
         # Update units hashmap
         for u in model_units.itervalues():
             self._add_units_obj(u)
     

Referenced by CellMLToNektar.pycml.cellml_model.add_units(), CellMLToNektar.pycml.cellml_component.add_units(), CellMLToNektar.pycml.cellml_model.get_all_units(), CellMLToNektar.pycml.cellml_component.get_all_units(), CellMLToNektar.pycml.cellml_model.get_standard_units(), CellMLToNektar.pycml.cellml_model.get_units_by_name(), and CellMLToNektar.pycml.cellml_component.get_units_by_name().

◆ _check_assigned_vars()

def CellMLToNektar.pycml.cellml_model._check_assigned_vars	(	self,
		assignments,
		xml_context = `False`
	)

private

Check Rule 4.4.4: mathematical expressions may only modify
variables belonging to the current component.

Definition at line 842 of file pycml.py.

     def _check_assigned_vars(self, assignments, xml_context=False):
         """Check Rule 4.4.4: mathematical expressions may only modify
         variables belonging to the current component.
         """
         for expr in assignments:
             try:
                 expr.check_assigned_var()
             except MathsError, e:
                 self._report_exception(e, xml_context)
         DEBUG('validator', 'Checked variable assignments')
  

References CellMLToNektar.pycml.cellml_model._report_exception(), and CellMLToNektar.utilities.DEBUG().

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

◆ _check_cellml_subset()

def CellMLToNektar.pycml.cellml_model._check_cellml_subset	(	self,
		math_elts,
		root = `True`
	)

private

Warn if MathML outside the CellML subset is used.

Definition at line 853 of file pycml.py.

     def _check_cellml_subset(self, math_elts, root=True):
         """Warn if MathML outside the CellML subset is used."""
         for elt in math_elts:
             if not elt.localName in CELLML_SUBSET_ELTS and \
                    elt.namespaceURI == NSS[u'm']:
                 self.validation_warning(u' '.join([
                     u'MathML element', elt.localName,
                     u'is not in the CellML subset.',
                     u'Some tools may not be able to process it.']))
             self._check_cellml_subset(self.xml_element_children(elt), False)
         if root:
             DEBUG('validator', 'Checked for CellML subset')
  

References CellMLToNektar.pycml.cellml_model._check_cellml_subset(), CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.pycml.cellml_model.validation_warning().

Referenced by CellMLToNektar.pycml.cellml_model._check_cellml_subset(), and CellMLToNektar.pycml.cellml_model.validate().

◆ _check_connection_units()

def CellMLToNektar.pycml.cellml_model._check_connection_units	(	self,
		check_for_units_conversions = `False`
	)

private

Check that the units of mapped variables are dimensionally consistent.

If check_for_units_conversions is True we also warn if they are not equivalent,
since much processing software may not be able to handle that case.

Definition at line 786 of file pycml.py.

     def _check_connection_units(self, check_for_units_conversions=False):
         """Check that the units of mapped variables are dimensionally consistent.
         
         If check_for_units_conversions is True we also warn if they are not equivalent,
         since much processing software may not be able to handle that case.
         """
         for conn in getattr(self, u'connection', []):
             comp1 = self.get_component_by_name(conn.map_components.component_1)
             comp2 = self.get_component_by_name(conn.map_components.component_2)
             for mapping in conn.map_variables:
                 var1 = self.get_variable_by_name(comp1.name, mapping.variable_1)
                 var2 = self.get_variable_by_name(comp2.name, mapping.variable_2)
                 # Check the units
                 u1 = var1.get_units()
                 u2 = var2.get_units()
                 if not u1 == u2:
                     if not u1.dimensionally_equivalent(u2):
                         self.validation_error(u' '.join([
                             var1.fullname(), 'and', var2.fullname(),
                             'are mapped, but have dimensionally inconsistent units.']))
                     elif check_for_units_conversions:
                         self.validation_warning(
                             u' '.join(['Warning: mapping between', var1.fullname(), 'and',
                                        var2.fullname(), 'will require a units conversion.']),
                             level=logging.WARNING_TRANSLATE_ERROR)
  

References CellMLToNektar.pycml.cellml_model.get_component_by_name(), CellMLToNektar.pycml.cellml_model.get_variable_by_name(), CellMLToNektar.pycml.cellml_component.get_variable_by_name(), CellMLToNektar.pycml.cellml_model.validation_error(), and CellMLToNektar.pycml.cellml_model.validation_warning().

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

◆ _check_dimensional_consistency()

def CellMLToNektar.pycml.cellml_model._check_dimensional_consistency	(	self,
		assignment_exprs,
		xml_context = `False`,
		warn_on_units_errors = `False`,
		check_for_units_conversions = `False`
	)

private

Appendix C.3.6: Equation dimension checking.

Definition at line 1151 of file pycml.py.

                                        check_for_units_conversions=False):
         """Appendix C.3.6: Equation dimension checking."""
         self._cml_conversions_needed = False
         # Check dimensions
         for expr in assignment_exprs:
             try:
                 expr.get_units()
             except UnitsError, e:
                 if warn_on_units_errors:
                     e.warn = True
                     e.level = logging.WARNING
                 self._report_exception(e, xml_context)
         # Check if units conversions will be needed
         if check_for_units_conversions and not self._cml_validation_errors:
             boolean = self.get_units_by_name('cellml:boolean')
             for expr in assignment_exprs:
                 try:
                     DEBUG('validator', "Checking units in", element_xpath(expr), expr.component.name)
                     expr._set_in_units(boolean, no_act=True)
                 except UnitsError:
                     pass
             # Warn if conversions used
             if self._cml_conversions_needed:
                 self.validation_warning('The mathematics in this model require units conversions.',
                                         level=logging.WARNING)
         DEBUG('validator', 'Checked units')
  

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

◆ _check_maths_name_references()

def CellMLToNektar.pycml.cellml_model._check_maths_name_references	(	self,
		expr,
		xml_context = `False`
	)

private

Check rules 4.4.2.1 and 4.4.3.2: name references in mathematics.

Definition at line 812 of file pycml.py.

     def _check_maths_name_references(self, expr, xml_context=False):
         """Check rules 4.4.2.1 and 4.4.3.2: name references in mathematics."""
         if isinstance(expr, mathml_ci):
             # Check variable exists
             try:
                 _ = expr.variable
             except KeyError:
                 self._report_exception(
                         MathsError(expr,
                                    "The content of a MathML ci element must match the name of a variable "
                                    "in the enclosing component, once whitespace normalisation has been "
                                    "performed (4.4.2.1). Variable '%s' does not exist in component '%s'."
                                    % (unicode(expr).strip(), expr.component.name)),
                         xml_context)
         elif isinstance(expr, mathml_cn):
             # Check units exist
             try:
                 expr.get_units()
             except KeyError:
                 self._report_exception(
                         MathsError(expr,
                                    "Units on a cn element must be standard or defined in the current "
                                    "component or model (4.4.3.2). Units '%s' are not defined in "
                                    "component '%s'." % (expr.units, expr.component.name)),
                         xml_context)
         else:
             # Recurse
             for child in expr.xml_element_children():
                 self._check_maths_name_references(child, xml_context)
  

References CellMLToNektar.pycml.cellml_model._check_maths_name_references(), and CellMLToNektar.pycml.cellml_model._report_exception().

Referenced by CellMLToNektar.pycml.cellml_model._check_maths_name_references(), and CellMLToNektar.pycml.cellml_model.validate().

◆ _check_unit_cycles()

def CellMLToNektar.pycml.cellml_model._check_unit_cycles	(	self,
		unit
	)

private

Check for cyclic units definitions.

We do this by doing a depth-first search from unit.

Definition at line 1181 of file pycml.py.

     def _check_unit_cycles(self, unit):
         """Check for cyclic units definitions.
  
         We do this by doing a depth-first search from unit.
         """
         if unit.get_colour() != DFS.White:
             # Allow self.validate to call us without colour check
             return
         unit.set_colour(DFS.Gray)
         # Get the object unit is defined in
         parent = unit.xml_parent or self
         for u in getattr(unit, u'unit', []):
             # Explore units that this unit is defined in terms of
             try:
                 v = parent.get_units_by_name(u.units)
             except KeyError:
                 self.validation_error("The value of the units attribute on a unit element must be taken"
                                       " from the dictionary of standard units or be the name of a"
                                       " user-defined unit in the current component or model (5.4.2.2)."
                                       " Units '%s' are not defined." % u.units)
                 continue
             if v.get_colour() == DFS.White:
                 self._check_unit_cycles(v)
             elif v.get_colour() == DFS.Gray:
                 # We have a cycle
                 self.validation_error("Units %s and %s are in a cyclic units definition"
                                       % (unit.name, v.name))
         unit.set_colour(DFS.Black)
  

References CellMLToNektar.pycml.cellml_model._check_unit_cycles(), and CellMLToNektar.pycml.cellml_model.validation_error().

Referenced by CellMLToNektar.pycml.cellml_model._check_unit_cycles(), and CellMLToNektar.pycml.cellml_model.validate().

◆ _check_variable_mappings()

def CellMLToNektar.pycml.cellml_model._check_variable_mappings ( self )

private

Check Rules 3.4.{5,6}: check variable mappings and interfaces are sane.

Definition at line 663 of file pycml.py.

     def _check_variable_mappings(self):
         """Check Rules 3.4.{5,6}: check variable mappings and interfaces are sane."""
         # First check connection elements and build mappings dict
         self.build_name_dictionaries()
         connected_components = set()
         for connection in getattr(self, u'connection', []):
             comps = frozenset([connection.map_components.component_1, connection.map_components.component_2])
             if comps in connected_components:
                 self.validation_error("Each map_components element must map a unique pair of components "
                                       "(3.4.5.4). The pair ('%s', '%s') is repeated." % tuple(comps))
             connected_components.add(comps)
             self._validate_connection(connection)
         # Now check for variables that should receive a value but don't
         for comp in getattr(self, u'component', []):
             for var in getattr(comp, u'variable', []):
                 for iface in [u'private_interface', u'public_interface']:
                     if getattr(var, iface, u'none') == u'in':
                         try:
                             var.get_source_variable()
                         except TypeError:
                             # No source variable found
                             self.validation_error("Variable '%s' has a %s attribute with value 'in', "
                                                   "but no component exports a value to that variable."
                                                   % (var.fullname(), iface))
         DEBUG('validator', 'Checked variable mappings')
     

References CellMLToNektar.pycml.cellml_model._validate_connection(), CellMLToNektar.pycml.cellml_model.build_name_dictionaries(), CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.pycml.cellml_model.validation_error().

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

◆ _check_variable_units_exist()

def CellMLToNektar.pycml.cellml_model._check_variable_units_exist ( self )

private

Check rule 3.4.3.3: that the units declared for variables exist.

Definition at line 774 of file pycml.py.

     def _check_variable_units_exist(self):
         """Check rule 3.4.3.3: that the units declared for variables exist."""
         for var in self.get_all_variables():
             try:
                 var.get_units()
             except KeyError:
                 self.validation_error("The value of the units attribute on a variable must be either "
                                       "one of the standard units or the name of a unit defined in the "
                                       "current component or model (3.4.3.3). The units '%s' on the "
                                       "variable '%s' in component '%s' do not exist."
                                       % (var.units, var.name, var.component.name))
  

References CellMLToNektar.pycml.cellml_model.get_all_variables(), and CellMLToNektar.pycml.cellml_model.validation_error().

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

◆ _classify_variables()

def CellMLToNektar.pycml.cellml_model._classify_variables	(	self,
		assignment_exprs,
		xml_context = `False`
	)

private

Determine the type of each variable.

Note that mapped vars must have already been classified by
self._check_variable_mappings, and the RELAX NG schema ensures
that a variable cannot be both Mapped and MaybeConstant.

Builds the equation dependency graph in the process.

Definition at line 866 of file pycml.py.

     def _classify_variables(self, assignment_exprs, xml_context=False):
         """Determine the type of each variable.
         
         Note that mapped vars must have already been classified by
         self._check_variable_mappings, and the RELAX NG schema ensures
         that a variable cannot be both Mapped and MaybeConstant.
         
         Builds the equation dependency graph in the process.
         """
         # Classify those vars that might be constants,
         # i.e. have an initial value assigned.
         for var in self.get_all_variables():
             if hasattr(var, u'initial_value'):
                 var._set_type(VarTypes.MaybeConstant)
         # Now classify by checking usage in mathematics, building
         # an equation dependency graph in the process.
         for expr in assignment_exprs:
             try:
                 expr.classify_variables(root=True)
             except MathsError, e:
                 self._report_exception(e, xml_context)
         # Unused vars still classified as MaybeConstant are constants
         for var in self.get_all_variables():
             if var.get_type() == VarTypes.MaybeConstant:
                 var._set_type(VarTypes.Constant)
         DEBUG('validator', 'Classified variables')
             

References CellMLToNektar.pycml.cellml_model._report_exception(), CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.pycml.cellml_model.get_all_variables().

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

◆ _del_component()

def CellMLToNektar.pycml.cellml_model._del_component	(	self,
		comp
	)

private

Remove the given component from the model.

Definition at line 507 of file pycml.py.

     def _del_component(self, comp):
         """Remove the given component from the model."""
         self.xml_remove_child(comp)
         del self._cml_components[comp.name]
  

References CellMLToNektar.pycml.cellml_model._cml_components.

◆ _del_variable()

def CellMLToNektar.pycml.cellml_model._del_variable	(	self,
		varname,
		compname
	)

private

Remove a variable from the model.

Definition at line 495 of file pycml.py.

     def _del_variable(self, varname, compname):
         """Remove a variable from the model."""
         del self._cml_variables[(compname, varname)]
  

References CellMLToNektar.pycml.cellml_model._cml_variables.

◆ _get_units_obj()

def CellMLToNektar.pycml.cellml_model._get_units_obj	(	self,
		units
	)

private

Unique-ify this units object.

If an object with the same definition already exists, return that.
Otherwise return the given units object.

'Same definition' is based on the cellml_units.uniquify_tuple
property, which in turn is based partly on the generated name
which would be given to these units, since that really *must*
be unique in generated models.

Definition at line 1337 of file pycml.py.

     def _get_units_obj(self, units):
         """Unique-ify this units object.
  
         If an object with the same definition already exists, return that.
         Otherwise return the given units object.
  
         'Same definition' is based on the cellml_units.uniquify_tuple
         property, which in turn is based partly on the generated name
         which would be given to these units, since that really *must*
         be unique in generated models.
         """
         return self._cml_units_map.get(units.uniquify_tuple, units)
     

References CellMLToNektar.pycml.cellml_model._cml_units_map.

◆ _is_new_units_obj()

def CellMLToNektar.pycml.cellml_model._is_new_units_obj	(	self,
		units
	)

private

Have these units been generated already?

i.e. is a units object with this definition in our map?

Definition at line 1350 of file pycml.py.

     def _is_new_units_obj(self, units):
         """Have these units been generated already?
  
         i.e. is a units object with this definition in our map?
         """
         return units.uniquify_tuple not in self._cml_units_map
  

References CellMLToNektar.pycml.cellml_model._cml_units_map.

◆ _order_variables()

def CellMLToNektar.pycml.cellml_model._order_variables	(	self,
		assignment_exprs,
		xml_context = `False`
	)

private

Topologically sort the equation dependency graph.

This orders all the assignment expressions in the model, to
allow procedural code generation.  It also checks that equations
are not cyclic (we don't support DAEs).

Definition at line 893 of file pycml.py.

     def _order_variables(self, assignment_exprs, xml_context=False):
         """Topologically sort the equation dependency graph.
         
         This orders all the assignment expressions in the model, to
         allow procedural code generation.  It also checks that equations
         are not cyclic (we don't support DAEs).
         """
         self.clear_assignments() # Ensure we start from a clean slate
         try:
             self._cml_sorting_variables_stack = []
             for var in self.get_all_variables():
                 if var.get_colour() == DFS.White:
                     self.topological_sort(var)
             for expr in assignment_exprs:
                 if expr.get_colour() == DFS.White:
                     self.topological_sort(expr)
         except MathsError, e:
             self._report_exception(e, xml_context)
         DEBUG('validator', 'Topologically sorted variables')
  

References CellMLToNektar.pycml.cellml_model.clear_assignments().

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

◆ _remove_assignment()

def CellMLToNektar.pycml.cellml_model._remove_assignment	(	self,
		a
	)

private

Remove the given assignment from our list.

This method is used by the partial evaluator.

Definition at line 1106 of file pycml.py.

     def _remove_assignment(self, a):
         """Remove the given assignment from our list.
  
         This method is used by the partial evaluator."""
         self._cml_assignments.remove(a)

References CellMLToNektar.pycml.cellml_model._cml_assignments.

◆ _report_exception()

def CellMLToNektar.pycml.cellml_model._report_exception	(	self,
		e,
		show_xml_context
	)

private

Report an exception e as a validation error or warning.

If show_xml_context is True, display the XML of the context
of the exception as well.

Definition at line 533 of file pycml.py.

     def _report_exception(self, e, show_xml_context):
         """Report an exception e as a validation error or warning.
         
         If show_xml_context is True, display the XML of the context
         of the exception as well.
         """
         e.show_xml_context = show_xml_context
         if e.warn:
             self.validation_warning(unicode(e), level=e.level)
         else:
             self.validation_error(unicode(e), level=e.level)
  

References CellMLToNektar.pycml.cellml_model.validation_error(), and CellMLToNektar.pycml.cellml_model.validation_warning().

Referenced by CellMLToNektar.pycml.cellml_model._check_assigned_vars(), CellMLToNektar.pycml.cellml_model._check_maths_name_references(), and CellMLToNektar.pycml.cellml_model._classify_variables().

◆ _validate_component_hierarchies()

def CellMLToNektar.pycml.cellml_model._validate_component_hierarchies ( self )

private

Check Rule 6.4.3.2 (4): hierarchies must not be circular.

Builds all the hierarchies, and checks for cycles.
In the process, we also check the other rules in 6.4.3, and 6.4.2.5.

Definition at line 632 of file pycml.py.

     def _validate_component_hierarchies(self):
         """Check Rule 6.4.3.2 (4): hierarchies must not be circular.
         
         Builds all the hierarchies, and checks for cycles.
         In the process, we also check the other rules in 6.4.3, and 6.4.2.5.
         """
         # First, we find the hierarchies that are defined.
         hiers = set()
         rels = []
         for group in getattr(self, u'group', []):
             local_hiers = set()
             for rel in getattr(group, u'relationship_ref', []):
                 rels.append(rel)
                 reln = rel.relationship
                 ns = rel.xml_attributes[u'relationship'][1]
                 name = getattr(rel, u'name', None)
                 hier = (reln, ns, name)
                 if hier in local_hiers:
                     self.validation_error("A group element must not contain two or more relationship_ref"
                                           " elements that define a relationship attribute in a common"
                                           " namespace with the same value and that have the same name"
                                           " attribute value (which may be non-existent) (6.4.2.5)."
                                           " Relationship '%s' name '%s' in namespace '%s' is repeated."
                                           % (reln, name or '', ns))
                 local_hiers.add(hier)
                 hiers.add(hier)
         # Now build & check each hierarchy
         for hier in hiers:
             self.build_component_hierarchy(hier[0], hier[1], hier[2], rels=rels)
         DEBUG('validator', 'Checked component hierachies')
     

References CellMLToNektar.pycml.cellml_model.build_component_hierarchy(), CellMLToNektar.utilities.DEBUG(), and CellMLToNektar.pycml.cellml_model.validation_error().

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

◆ _validate_connection()

def CellMLToNektar.pycml.cellml_model._validate_connection	(	self,
		conn
	)

private

Validate the given connection element.

Check that the given connection object defines valid mappings
between variables, according to rules 3.4.5 and 3.4.6.

Definition at line 689 of file pycml.py.

     def _validate_connection(self, conn):
         """Validate the given connection element.
         
         Check that the given connection object defines valid mappings
         between variables, according to rules 3.4.5 and 3.4.6.
         """
         # Check we are allowed to connect these components
         try:
             comp1 = self.get_component_by_name(conn.map_components.component_1)
         except KeyError:
             self.validation_error("Connections must be between components defined in the current model "
                                   "(3.4.5.2). There is no component '%s'." % conn.map_components.component_1)
             return
         try:
             comp2 = self.get_component_by_name(conn.map_components.component_2)
         except KeyError:
             self.validation_error("Connections must be between components defined in the current model "
                                   "(3.4.5.3). There is no component '%s'." % conn.map_components.component_2)
             return
         if comp1 is comp2:
             self.validation_error("A connection must link two different components (3.4.5.4). "
                                   "The component '%s' is being connected to itself." % comp1.name)
             return
         # Get the parent of each component in the encapsulation hierarchy
         par1, par2 = comp1.parent(), comp2.parent()
         # The two components must either be siblings (maybe top-level) or parent & child.
         if not (par1 == comp2 or par2 == comp1 or par1 == par2):
             self.validation_error(u' '.join([
                 'Connections are only permissible between sibling',
                 'components, or where one is the parent of the other.\n',
                 comp1.name,'and',comp2.name,'are unrelated.']))
             return
         # Now check each variable mapping
         for mapping in conn.map_variables:
             try:
                 var1 = self.get_variable_by_name(comp1.name, mapping.variable_1)
             except KeyError:
                 self.validation_error("A variable mapping must be between existing variables (3.4.6.2). "
                                       "Variable '%s' doesn't exist in component '%s'."
                                        % (mapping.variable_1, comp1.name))
                 continue
             try:
                 var2 = self.get_variable_by_name(comp2.name, mapping.variable_2)
             except KeyError:
                 self.validation_error("A variable mapping must be between existing variables (3.4.6.2). "
                                       "Variable '%s' doesn't exist in component '%s'."
                                        % (mapping.variable_2, comp2.name))
                 continue
             errm, e = ['Interface mismatch mapping',var1.fullname(),'and',var2.fullname(),':\n'], None
             if par1 == par2:
                 # Siblings, so should have differing public interfaces
                 if not hasattr(var1, 'public_interface'):
                     e = 'missing public_interface attribute on ' + \
                         var1.fullname() + '.'
                 elif not hasattr(var2, 'public_interface'):
                     e = 'missing public_interface attribute on ' + \
                         var2.fullname() + '.'
                 elif var1.public_interface == var2.public_interface:
                     e = 'public_interface attributes are identical.'
                 else:
                     if var1.public_interface == 'in':
                         var1._set_source_variable(var2)
                     else:
                         var2._set_source_variable(var1)
             else:
                 if par2 == comp1:
                     # Component 1 is the parent of component 2
                     var1, var2 = var2, var1
                 # Now var2 is in the parent component, and var1 in the child
                 if not hasattr(var1, 'public_interface'):
                     e = var1.fullname()+' missing public_interface.'
                 elif not hasattr(var2, 'private_interface'):
                     e = var2.fullname()+' missing private_interface.'
                 elif var1.public_interface == var2.private_interface:
                     e = 'relevant interfaces have identical values.'
                 else:
                     if var1.public_interface == 'in':
                         var1._set_source_variable(var2)
                     else:
                         var2._set_source_variable(var1)
             # If there was an error, log it
             if e:
                 errm.append(e)
                 self.validation_error(u' '.join(errm))
     

References CellMLToNektar.pycml.cellml_model.get_component_by_name(), CellMLToNektar.pycml.cellml_model.get_variable_by_name(), CellMLToNektar.pycml.cellml_component.get_variable_by_name(), and CellMLToNektar.pycml.cellml_model.validation_error().

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

◆ add_units()

def CellMLToNektar.pycml.cellml_model.add_units	(	self,
		name,
		units
	)

Add an entry in our units dictionary for units named `name' with element object `units'.

Definition at line 1318 of file pycml.py.

     def add_units(self, name, units):
         """Add an entry in our units dictionary for units named `name' with element object `units'."""
         if not self._cml_units:
             self._build_units_dictionary()
         assert name not in self._cml_units
         self._cml_units[name] = units
         self._add_units_obj(units)
         return
  

Referenced by CellMLToNektar.processors.ModelModifier.add_units(), CellMLToNektar.processors.ModelModifier.add_variable(), and CellMLToNektar.processors.UnitsConverter.convert_constant().

◆ add_units_conversions()

def CellMLToNektar.pycml.cellml_model.add_units_conversions ( self )

Add explicit units conversion mathematics where necessary.

Definition at line 1357 of file pycml.py.

     def add_units_conversions(self):
         """Add explicit units conversion mathematics where necessary."""
         import_processors()
         processors.UnitsConverter(self).add_all_conversions()
  

References CellMLToNektar.pycml.import_processors().

◆ build_component_hierarchy()

def CellMLToNektar.pycml.cellml_model.build_component_hierarchy	(	self,
		relationship,
		namespace = `None`,
		name = `None`,
		rels = `None`
	)

Create all the parent-child links for the given component hierarchy.

relationship gives the type of the hierarchy. If it is not one of the
CellML types (i.e. encapsulation or containment) then the namespace URI
must be specified.  Multiple non-encapsulation hierarchies of the same
type can be specified by giving the name argument.

Definition at line 958 of file pycml.py.

     def build_component_hierarchy(self, relationship, namespace=None, name=None, rels=None):
         """
         Create all the parent-child links for the given component hierarchy.
  
         relationship gives the type of the hierarchy. If it is not one of the
         CellML types (i.e. encapsulation or containment) then the namespace URI
         must be specified.  Multiple non-encapsulation hierarchies of the same
         type can be specified by giving the name argument.
         """
         key = (relationship, namespace, name)
         # Set all components to have no parent or children, under this hierarchy
         for comp in getattr(self, u'component', []):
             comp._clear_hierarchy(key)
         self.build_name_dictionaries()
         # Find nodes defining this hierarchy
         if rels is None:
             rels = self.xml_xpath(u'cml:group/cml:relationship_ref')
         groups = []
         for rel in rels:
             # NB: The first test below relies on there only being one
             # attr with localname of 'relationship' on each rel.
             # So let's check this...
             if hasattr(rel, u'relationship_'):
                 self.validation_error(u' '.join([
                     'relationship_ref element has multiple relationship',
                     'attributes in different namespaces:\n'] + 
                         map(lambda qn,ns: '('+qn+','+ns+')',
                             rel.xml_attributes.values())))
                 return
             if rel.relationship == relationship and \
                rel.xml_attributes[u'relationship'][1] == namespace and \
                getattr(rel, u'name', None) == name:
                 # It's in the hierarchy
                 groups.append(rel.xml_parent)
         # Now build all the parent links for this hierarchy
         def set_parent(p, crefs):
             for cref in crefs:
                 # Find component cref refers to
                 try:
                     c = self.get_component_by_name(cref.component)
                 except KeyError:
                     self.validation_error("A component_ref element must reference a component in the current"
                                           " model (6.4.3.3). Component '%s' does not exist." % cref.component)
                     return
                 # Set c's parent to p
                 c._set_parent_component(key, p)
                 if hasattr(cref, 'component_ref'):
                     # If we already have children under this hierarchy it's a validation error
                     if c._has_child_components(key):
                         self.validation_error("In a given hierarchy, only one component_ref element "
                                               "referencing a given component may contain children (6.4.3.2)."
                                               " Component '%s' has children in multiple locations." % c.name)
                     # Set parent of c's children to c
                     set_parent(c, cref.component_ref)
                 elif p is None and namespace is None:
                     self.validation_error("Containment and encapsulation relationships must be hierarchical"
                                           " (6.4.3.2). Potentially top-level component '%s' has not been"
                                           " given children." % cref.component)
         for group in groups:
             set_parent(None, group.component_ref)
         if self._cml_validation_errors:
             return
         # Check for a cycle in the hierarchy (rule 6.4.3.2 (4)).
         # Note that since we have already ensured that no component is a parent in more than one location,
         # nor is any component a child more than once, so the only possibility for a cycle is if one of
         # the components referenced as a child of a group element is also referenced as a (leaf) descendent
         # of one of its children.  We check for this by following parent links backwards.
         def has_cycle(root_comp, cur_comp):
             if cur_comp is None:
                 return False
             elif cur_comp is root_comp:
                 return True
             else:
                 return has_cycle(root_comp, cur_comp.parent(reln_key=key))
         for group in groups:
             for cref in group.component_ref:
                 # Find component cref refers to
                 c = self.get_component_by_name(cref.component)
                 if has_cycle(c, c.parent(reln_key = key)):
                     n, ns = name or "", namespace or ""
                     self.validation_error("The '%s' relationship hierarchy with name '%s' and namespace"
                                           " '%s' has a cycle" % (relationship, n, ns))
         return
  

References CellMLToNektar.pycml.cellml_model._cml_validation_errors, CellMLToNektar.pycml.cellml_model.build_name_dictionaries(), CellMLToNektar.pycml.cellml_model.get_component_by_name(), and CellMLToNektar.pycml.cellml_model.validation_error().

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

◆ build_name_dictionaries()

def CellMLToNektar.pycml.cellml_model.build_name_dictionaries	(	self,
		rebuild = `False`
	)

Create dictionaries mapping names of variables and components to
the objects representing them.
Dictionary keys for variables will be
  (component_name, variable_name).

If rebuild is True, clear the dictionaries first.

Definition at line 932 of file pycml.py.

     def build_name_dictionaries(self, rebuild=False):
         """
         Create dictionaries mapping names of variables and components to
         the objects representing them.
         Dictionary keys for variables will be
           (component_name, variable_name).
         
         If rebuild is True, clear the dictionaries first.
         """
         if rebuild:
             self._cml_variables = {}
             self._cml_components = {}
         if not self._cml_components:
             for comp in getattr(self, u'component', []):
                 if comp.name in self._cml_components:
                     self.validation_error("Component names must be unique within a model (3.4.2.2)."
                                           " The name '%s' is repeated." % comp.name)
                 self._cml_components[comp.name] = comp
                 for var in getattr(comp, u'variable', []):
                     key = (comp.name, var.name)
                     if key in self._cml_variables:
                         self.validation_error("Variable names must be unique within a component (3.4.3.2)."
                                               " The name '%s' is repeated in component '%s'."
                                               % (var.name, comp.name))
                     self._cml_variables[key] = var
  

References CellMLToNektar.pycml.cellml_model._cml_components, CellMLToNektar.pycml.cellml_model._cml_variables, and CellMLToNektar.pycml.cellml_model.validation_error().

Referenced by CellMLToNektar.pycml.cellml_model._check_variable_mappings(), and CellMLToNektar.pycml.cellml_model.build_component_hierarchy().

◆ calculate_extended_dependencies()

def CellMLToNektar.pycml.cellml_model.calculate_extended_dependencies	(	self,
		nodes,
		prune = `[]`,
		prune_deps = `[]`,
		state_vars_depend_on_odes = `False`,
		state_vars_examined = `set()`
	)

Calculate the extended dependencies of the given nodes.

Recurse into the dependency graph, in order to construct a
set, for each node in nodes, of all the nodes on which it
depends, either directly or indirectly.

Each node IS included in its own dependency set.

If prune is specified, it should be a set of nodes for which
we won't include their dependencies or the nodes themselves.
This is useful e.g. for pruning variables required for calculating
a stimulus if the stimulus is being provided by another method.
prune_deps is similar: dependencies of these nodes will be excluded,
but the nodes themselves will be included if asked for.

If state_vars_depend_on_odes is True, then considers state variables
to depend on the ODE defining them.

Requires the dependency graph to be acyclic.

Return the union of all the dependency sets.

Definition at line 1378 of file pycml.py.

                                         state_vars_examined=set()):
         """Calculate the extended dependencies of the given nodes.
  
         Recurse into the dependency graph, in order to construct a
         set, for each node in nodes, of all the nodes on which it
         depends, either directly or indirectly.
  
         Each node IS included in its own dependency set.
  
         If prune is specified, it should be a set of nodes for which
         we won't include their dependencies or the nodes themselves.
         This is useful e.g. for pruning variables required for calculating
         a stimulus if the stimulus is being provided by another method.
         prune_deps is similar: dependencies of these nodes will be excluded,
         but the nodes themselves will be included if asked for.
         
         If state_vars_depend_on_odes is True, then considers state variables
         to depend on the ODE defining them.
  
         Requires the dependency graph to be acyclic.
  
         Return the union of all the dependency sets.
         """
         deps = set()
         for node in nodes:
             if node in prune or (isinstance(node, mathml_apply) and
                                  isinstance(node.operator(), mathml_eq) and
                                  isinstance(node.eq.lhs, mathml_ci) and
                                  node.eq.lhs.variable in prune):
                 continue
             if type(node) == tuple:
                 # This is an ODE dependency, so get the defining expression instead.
                 ode = True
                 orig_node = node
                 node = node[0].get_ode_dependency(node[1])
                 if orig_node in prune_deps:
                     # Include the defining expression, but skip its dependencies
                     deps.add(node)
                     continue
                 free_var = node.eq.lhs.diff.independent_variable
             else:
                 ode = False
             deps.add(node)
             if node in prune_deps:
                 # Skip dependencies of this node
                 continue
             nodedeps = set(node.get_dependencies())
             if ode and not node._cml_ode_has_free_var_on_rhs:
                 # ODEs depend on their independent variable.  However,
                 # when writing out code we don't want to pull the free
                 # variable in just for this, as the compiler then
                 # gives us unused variable warnings.
                 nodedeps.remove(free_var)
             if (state_vars_depend_on_odes and isinstance(node, cellml_variable)
                 and node.get_type() == VarTypes.State
                 and node not in state_vars_examined):
                 nodedeps.update(node.get_all_expr_dependencies())
                 state_vars_examined.add(node)
             deps.update(self.calculate_extended_dependencies(nodedeps,
                                                              prune=prune,
                                                              prune_deps=prune_deps,
                                                              state_vars_depend_on_odes=state_vars_depend_on_odes,
                                                              state_vars_examined=state_vars_examined))
         return deps
  

References CellMLToNektar.translators.CellMLTranslator.calculate_extended_dependencies(), and CellMLToNektar.pycml.cellml_model.calculate_extended_dependencies().

◆ clean_up()

def CellMLToNektar.pycml.cellml_model.clean_up ( self )

Try to get the RDF library to clean up nicely.

Definition at line 398 of file pycml.py.

     def clean_up(self):
         """Try to get the RDF library to clean up nicely."""
         cellml_metadata.remove_model(self)
         

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

◆ clear_assignments()

def CellMLToNektar.pycml.cellml_model.clear_assignments ( self )

Clear the assignments list.

Definition at line 1120 of file pycml.py.

     def clear_assignments(self):
         """Clear the assignments list."""
         self._cml_assignments = []
  

References CellMLToNektar.pycml.cellml_model._cml_assignments.

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

◆ do_binding_time_analysis()

def CellMLToNektar.pycml.cellml_model.do_binding_time_analysis ( self )

Perform a binding time analysis on the model's mathematics.

This requires variables to have been classified and a
topological sort of the mathematics to have been performed.

Variables and top-level expressions are processed in the order
given by the topological sort, hence only a single pass is
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

Expressions are dealt with by recursively annotating
subexpressions.  See code in the MathML classes for details.

Definition at line 1124 of file pycml.py.

     def do_binding_time_analysis(self):
         """Perform a binding time analysis on the model's mathematics.
  
         This requires variables to have been classified and a
         topological sort of the mathematics to have been performed.
  
         Variables and top-level expressions are processed in the order
         given by the topological sort, hence only a single pass is
         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
  
         Expressions are dealt with by recursively annotating
         subexpressions.  See code in the MathML classes for details.
         """
         for item in self.get_assignments():
             if isinstance(item, cellml_variable):
                 # Set binding time based on type
                 item._get_binding_time()
             else:
                 # Compute binding time recursively
                 item._get_binding_time()
  

References CellMLToNektar.pycml.cellml_model.get_assignments().

◆ find_free_vars()

def CellMLToNektar.pycml.cellml_model.find_free_vars ( self )

Return a list of the free variable elements in this model.

Definition at line 1370 of file pycml.py.

     def find_free_vars(self):
         """Return a list of the free variable elements in this model."""
         free_vars = []
         for var in self.get_all_variables():
             if var.get_type() == VarTypes.Free:
                 free_vars.append(var)
         return free_vars
     

References CellMLToNektar.pycml.cellml_model.get_all_variables().

◆ find_state_vars()

def CellMLToNektar.pycml.cellml_model.find_state_vars ( self )

Return a list of the state variable elements in this model.

Definition at line 1362 of file pycml.py.

     def find_state_vars(self):
         """Return a list of the state variable elements in this model."""
         state_vars = []
         for var in self.get_all_variables():
             if var.get_type() == VarTypes.State:
                 state_vars.append(var)
         return state_vars
  

References CellMLToNektar.pycml.cellml_model.get_all_variables().

◆ get_all_units()

def CellMLToNektar.pycml.cellml_model.get_all_units ( self )

Get a list of all units objects, including the standard units.

Definition at line 1300 of file pycml.py.

     def get_all_units(self):
         """Get a list of all units objects, including the standard units."""
         if not self._cml_units:
             self._build_units_dictionary()
         units = self._cml_units.values()
         for comp in getattr(self, u'component', []):
             units.extend(comp.get_all_units())
         return units
  

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

◆ get_all_variables()

def CellMLToNektar.pycml.cellml_model.get_all_variables ( self )

Return an iterator over the variables in the model.

Definition at line 484 of file pycml.py.

     def get_all_variables(self):
         """Return an iterator over the variables in the model."""
         for comp in getattr(self, u'component', []):
             for var in getattr(comp, u'variable', []):
                 yield var
  

Referenced by CellMLToNektar.pycml.cellml_model._check_variable_units_exist(), CellMLToNektar.pycml.cellml_model._classify_variables(), CellMLToNektar.pycml.cellml_model.find_free_vars(), and CellMLToNektar.pycml.cellml_model.find_state_vars().

◆ get_assignments()

def CellMLToNektar.pycml.cellml_model.get_assignments ( self )

Return a sorted list of all the assignments in the model.

Assignments can either be instances of cellml_variable, in
which case they represent a variable mapping, or instances of
mathml_apply, representing top-level assignment expressions.

Definition at line 1111 of file pycml.py.

     def get_assignments(self):
         """
         Return a sorted list of all the assignments in the model.
  
         Assignments can either be instances of cellml_variable, in
         which case they represent a variable mapping, or instances of
         mathml_apply, representing top-level assignment expressions.
         """
         return self._cml_assignments

References CellMLToNektar.pycml.cellml_model._cml_assignments.

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

◆ get_component_by_name()

def CellMLToNektar.pycml.cellml_model.get_component_by_name	(	self,
		compname
	)

Return the component object that has name `compname'.

Definition at line 414 of file pycml.py.

     def get_component_by_name(self, compname):
         """Return the component object that has name `compname'."""
         return self._cml_components[compname]
     

References CellMLToNektar.pycml.cellml_model._cml_components.

Referenced by CellMLToNektar.pycml.cellml_model._check_connection_units(), CellMLToNektar.pycml.cellml_model._validate_connection(), and CellMLToNektar.pycml.cellml_model.build_component_hierarchy().

◆ get_config()

def CellMLToNektar.pycml.cellml_model.get_config	(	self,
		config_attr = `None`
	)

Get the configuration store if it exists, or an attribute thereof.

Definition at line 402 of file pycml.py.

     def get_config(self, config_attr=None):
         """Get the configuration store if it exists, or an attribute thereof."""
         config = getattr(self.xml_parent, '_cml_config', None)
         if config_attr:
             config = getattr(config, config_attr, None)
         return config
     

◆ get_option()

def CellMLToNektar.pycml.cellml_model.get_option	(	self,
		option_name
	)

Get the value of a command-line option.

Definition at line 409 of file pycml.py.

     def get_option(self, option_name):
         """Get the value of a command-line option."""
         config = getattr(self.xml_parent, '_cml_config', None)
         return config and getattr(config.options, option_name)
  

◆ get_standard_units()

def CellMLToNektar.pycml.cellml_model.get_standard_units ( self )

Get a dictionary mapping the names of the standard CellML units to their definitions.

Definition at line 1294 of file pycml.py.

     def get_standard_units(self):
         """Get a dictionary mapping the names of the standard CellML units to their definitions."""
         if not self._cml_standard_units:
             self._build_units_dictionary()
         return self._cml_standard_units
  

References CellMLToNektar.pycml.cellml_model._build_units_dictionary(), CellMLToNektar.pycml.cellml_component._build_units_dictionary(), and CellMLToNektar.pycml.cellml_model._cml_standard_units.

◆ get_units_by_name()

def CellMLToNektar.pycml.cellml_model.get_units_by_name	(	self,
		uname
	)

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

Definition at line 1309 of file pycml.py.

     def get_units_by_name(self, uname):
         """Return an object representing the element that defines the units named `uname'."""
         if not self._cml_units:
             self._build_units_dictionary()
         try:
             return self._cml_units[uname]
         except KeyError:
             raise KeyError("Units '%s' are not defined in the current component or model." % uname)
  

◆ get_validation_errors()

def CellMLToNektar.pycml.cellml_model.get_validation_errors ( self )

Return the list of all errors found (so far) while validating this model.

Definition at line 519 of file pycml.py.

     def get_validation_errors(self):
         """Return the list of all errors found (so far) while validating this model."""
         return self._cml_validation_errors

References CellMLToNektar.pycml.cellml_model._cml_validation_errors.

◆ get_validation_warnings()

def CellMLToNektar.pycml.cellml_model.get_validation_warnings ( self )

Return the list of all warnings found (so far) while validating this model.

Definition at line 529 of file pycml.py.

     def get_validation_warnings(self):
         """Return the list of all warnings found (so far) while validating this model.
         """
         return self._cml_validation_warnings

References CellMLToNektar.pycml.cellml_model._cml_validation_warnings.

◆ get_variable_by_cmeta_id()

def CellMLToNektar.pycml.cellml_model.get_variable_by_cmeta_id	(	self,
		cmeta_id
	)

Get the unique variable in this model with the given cmeta:id attribute value.

Definition at line 474 of file pycml.py.

     def get_variable_by_cmeta_id(self, cmeta_id):
         """
         Get the unique variable in this model with the given cmeta:id attribute value.
         """
         vars = self.xml_xpath(u'cml:component/cml:variable[@cmeta:id="%s"]' % cmeta_id)
         if len(vars) != 1:
             raise ValueError('"%s" does not ID a unique variable (matches: %s)'
                              % (cmeta_id, str(vars)))
         return vars[0]
     

◆ get_variable_by_name()

def CellMLToNektar.pycml.cellml_model.get_variable_by_name	(	self,
		compname,
		varname
	)

Return the variable object with name `varname' in component
`compname'.

Definition at line 418 of file pycml.py.

     def get_variable_by_name(self, compname, varname):
         """
         Return the variable object with name `varname' in component
         `compname'.
         """
         try:
             var = self._cml_variables[(compname, varname)]
         except KeyError, e:
             if compname == u'':
                 if self.component.ignore_component_name:
                     compname = self.component.name
                 else:
                     try:
                         compname, varname = cellml_variable.split_name(varname)
                     except ValueError:
                         raise e
                 var = self._cml_variables[(compname, varname)]
             else:
                 raise e
         return var
     

References CellMLToNektar.pycml.cellml_model._cml_variables, CellMLToNektar.pycml.cellml_variable.component, and CellMLToNektar.pycml.mathml.component.

Referenced by CellMLToNektar.pycml.cellml_model._check_connection_units(), and CellMLToNektar.pycml.cellml_model._validate_connection().

◆ get_variable_by_oxmeta_name()

def CellMLToNektar.pycml.cellml_model.get_variable_by_oxmeta_name	(	self,
		name,
		throw = `True`
	)

Get the unique variable in this model with the given Oxford metadata
name annotation.

If throw is True, will raise ValueError if there is no such variable,
or more than 1 match.  If throw is False, returns None in these cases.

Definition at line 439 of file pycml.py.

     def get_variable_by_oxmeta_name(self, name, throw=True):
         """
         Get the unique variable in this model with the given Oxford metadata
         name annotation.
         
         If throw is True, will raise ValueError if there is no such variable,
         or more than 1 match.  If throw is False, returns None in these cases.
         """
         vars = cellml_metadata.find_variables(self,
                                              ('bqbiol:is', NSS['bqbiol']),
                                              ('oxmeta:'+str(name), NSS['oxmeta']))
         if len(vars) == 1:
             var = vars[0]
         elif throw:
             raise ValueError('"%s" does not name a unique variable (matches: %s)'
                              % (name, str(vars)))
         else:
             var = None
         return var
     

◆ get_variables_by_ontology_term()

def CellMLToNektar.pycml.cellml_model.get_variables_by_ontology_term	(	self,
		term
	)

Return a list of variables annotated with the given ontology term.

The annotations have the same form as for oxmeta name annotations (see
get_variable_by_oxmeta_name).  However, here we are not restricted to
namespace, and no check is done on the number of results returned.

The given term must be a (prefixed_name, nsuri) tuple.

Definition at line 459 of file pycml.py.

     def get_variables_by_ontology_term(self, term):
         """Return a list of variables annotated with the given ontology term.
         
         The annotations have the same form as for oxmeta name annotations (see
         get_variable_by_oxmeta_name).  However, here we are not restricted to
         namespace, and no check is done on the number of results returned.
         
         The given term must be a (prefixed_name, nsuri) tuple.
         """
         assert isinstance(term, tuple)
         assert len(term) == 2
         named_vars = cellml_metadata.find_variables(self, ('bqbiol:is', NSS['bqbiol']), term)
         category_vars = cellml_metadata.find_variables(self, ('bqbiol:isVersionOf', NSS['bqbiol']), term)
         return named_vars + category_vars
     

◆ has_units()

def CellMLToNektar.pycml.cellml_model.has_units	(	self,
		units
	)

Test whether a given units definition appears in the model.

Definition at line 1327 of file pycml.py.

     def has_units(self, units):
         """Test whether a given units definition appears in the model."""
         return units in self._cml_units.itervalues()
  

References CellMLToNektar.pycml.cellml_model._cml_units, CellMLToNektar.pycml.cellml_component._cml_units, CellMLToNektar.pycml.mathml_units_mixin_tokens._cml_units, CellMLToNektar.pycml.mathml_units_mixin_container._cml_units, CellMLToNektar.pycml.mathml_cn._cml_units, CellMLToNektar.pycml.mathml_ci._cml_units, CellMLToNektar.pycml.mathml_apply._cml_units, and CellMLToNektar.pycml.mathml_piecewise._cml_units.

◆ is_self_excitatory()

def CellMLToNektar.pycml.cellml_model.is_self_excitatory ( self )

Determine whether this model is self-excitatory,
i.e. does not require an external stimulus.

Definition at line 1446 of file pycml.py.

     def is_self_excitatory(self):
         """Determine whether this model is self-excitatory,
         i.e. does not require an external stimulus.
         """
         meta_id = self.cmeta_id
         if not meta_id:
             return False
         property = cellml_metadata.create_rdf_node(('pycml:is-self-excitatory', NSS['pycml']))
         source = cellml_metadata.create_rdf_node(fragment_id=meta_id)
         return cellml_metadata.get_target(self, source, property) == 'yes'
  

References CellMLToNektar.pycml.element_base.cmeta_id().

◆ search_for_assignments()

def CellMLToNektar.pycml.cellml_model.search_for_assignments	(	self,
		comp = `None`
	)

Search for assignment expressions in the model's mathematics.

If comp is supplied, will only return assignments in that component.

Definition at line 918 of file pycml.py.

     def search_for_assignments(self, comp=None):
         """Search for assignment expressions in the model's mathematics.
         
         If comp is supplied, will only return assignments in that component.
         """
         assignments_xpath = u' | '.join([self.math_xpath_1 + self.apply_xpath_1,
                                          self.math_xpath_1 + self.apply_xpath_2,
                                          self.math_xpath_2 + self.apply_xpath_1,
                                          self.math_xpath_2 + self.apply_xpath_2])
         if comp:
             assignments_xpath = assignments_xpath.replace(u'component',
                                                           u'component[@name="%s"]' % comp.name)
         return self.xml_xpath(assignments_xpath)
     

References CellMLToNektar.pycml.cellml_model.apply_xpath_1, CellMLToNektar.pycml.cellml_model.apply_xpath_2, CellMLToNektar.pycml.cellml_model.math_xpath_1, and CellMLToNektar.pycml.cellml_model.math_xpath_2.

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

◆ topological_sort()

def CellMLToNektar.pycml.cellml_model.topological_sort	(	self,
		node
	)

Do a topological sort of all assignment expressions and variables
in the model.

node should be an expression or variable object that inherits from
Colourable and has methods get_dependencies, get_component

Definition at line 1042 of file pycml.py.

     def topological_sort(self, node):
         """
         Do a topological sort of all assignment expressions and variables
         in the model.
  
         node should be an expression or variable object that inherits from
         Colourable and has methods get_dependencies, get_component
         """
         node.set_colour(DFS.Gray)
         # Keep track of gray variables, for reporting cycles
         if isinstance(node, cellml_variable):
             self._cml_sorting_variables_stack.append(node.fullname())
         elif node.is_ode():
             # This is an expression defining an ODE; the name on the
             # stack will look something like d(V)/d(t)
             n1, n2 = map(lambda v: v.fullname(), node.assigned_variable())
             self._cml_sorting_variables_stack.append(u'd'+n1+u'/d'+n2)
         # Visit children in the dependency graph
         for dep in node.get_dependencies():
             if type(dep) == types.TupleType:
                 # This is an ODE dependency, so get the defining expression
                 dep = dep[0].get_ode_dependency(dep[1], node)
             if dep.get_colour() == DFS.White:
                 self.topological_sort(dep)
             elif dep.get_colour() == DFS.Gray:
                 # We have a cyclic dependency
                 if isinstance(dep, cellml_variable):
                     i = self._cml_sorting_variables_stack.index(dep.fullname())
                 elif node.is_ode():
                     n1, n2 = map(lambda v: v.fullname(),
                                  dep.assigned_variable())
                     i = self._cml_sorting_variables_stack.index(
                         u'd'+n1+u'/d'+n2)
                 else:
                     # Since any variable always depends on a mathematical
                     # expression defining it, the only case where the
                     # expression is gray before the corresponding variable
                     # (apart from an ODE, dealt with above) is if a tree
                     # started at an expression.  Hence the whole stack
                     # is in the cycle.
                     i = 0
                 varnames = self._cml_sorting_variables_stack[i:]
                 self.validation_error(u' '.join([
                     u'There is a cyclic dependency involving the following',
                     u'variables:', u','.join(varnames)]))
         # Finish this node, and add it to the appropriate sorted list
         node.set_colour(DFS.Black)
         self._add_sorted_assignment(node)
         # Pop the gray variables stack
         if (isinstance(node, cellml_variable) or node.is_ode()):
             self._cml_sorting_variables_stack.pop()
         return
     

References CellMLToNektar.pycml.cellml_model._add_sorted_assignment(), CellMLToNektar.pycml.cellml_model._cml_sorting_variables_stack, CellMLToNektar.pycml.cellml_model.topological_sort(), and CellMLToNektar.pycml.cellml_model.validation_error().

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

◆ validate()

def CellMLToNektar.pycml.cellml_model.validate	(		self,
			xml_context = `False`,
			invalid_if_warnings = `False`,
			warn_on_units_errors = `False`,
			check_for_units_conversions = `False`,
			assume_valid = `False`,
		**	ignored_kwargs
	)

Validate this model.

Assumes that RELAX NG validation has been done.  Checks rules
3.4.2.2, 3.4.3.2, 3.4.3.3, 3.4.5.2, 3.4.5.3, 3.4.5.4, 3.4.6.2, 3.4.6.3, 3.4.6.4,
4.4.2.1, 4.4.3.2, 4.4.4, 5.4.1.2, 5.4.2.2, 6.4.2.5, 6.4.3.2, and 6.4.3.3
in the CellML 1.0 spec, and performs units checking.

Note that if some checks fail, most of the remaining checks
will not be performed.  Hence when testing a model validate
repeatedly until it passes.

If xml_context is True, then the failing MathML tree will be
displayed with every units error.

If check_for_units_conversions is True, then generate a warning if
units conversions will be needed.

If assume_valid is True then fewer checks will be done - only
what is required to set up the data structures needed for model
transformation.

Returns True iff the model validates.
When invalid_if_warnings is True the model will fail to validate
if there are any warnings, as well as if there are any errors.

Definition at line 545 of file pycml.py.

                  assume_valid=False, **ignored_kwargs):
         """Validate this model.
  
         Assumes that RELAX NG validation has been done.  Checks rules
         3.4.2.2, 3.4.3.2, 3.4.3.3, 3.4.5.2, 3.4.5.3, 3.4.5.4, 3.4.6.2, 3.4.6.3, 3.4.6.4,
         4.4.2.1, 4.4.3.2, 4.4.4, 5.4.1.2, 5.4.2.2, 6.4.2.5, 6.4.3.2, and 6.4.3.3
         in the CellML 1.0 spec, and performs units checking.
  
         Note that if some checks fail, most of the remaining checks
         will not be performed.  Hence when testing a model validate
         repeatedly until it passes.
  
         If xml_context is True, then the failing MathML tree will be
         displayed with every units error.
  
         If check_for_units_conversions is True, then generate a warning if
         units conversions will be needed.
         
         If assume_valid is True then fewer checks will be done - only
         what is required to set up the data structures needed for model
         transformation.
  
         Returns True iff the model validates.
         When invalid_if_warnings is True the model will fail to validate
         if there are any warnings, as well as if there are any errors.
         """
         self._validate_component_hierarchies()
  
         # Rule 5.4.2.2: units definitions may not be circular.
         # Also checks 5.4.1.2: no duplicate units names.
         if not assume_valid:
             for unit in self.get_all_units():
                 self._check_unit_cycles(unit)
             DEBUG('validator', 'Checked for units cycles')
             # Check rule 3.4.3.3 too.
             self._check_variable_units_exist()
  
         if not self._cml_validation_errors:
             self._check_variable_mappings() # This sets up source variable links
         if not self._cml_validation_errors and not assume_valid:
             self._check_connection_units(check_for_units_conversions)
  
         # Rules 4.4.2.1 and 4.4.3.2: check name references in mathematics
         if not self._cml_validation_errors:
             assignment_exprs = self.search_for_assignments()
             if not assume_valid:
                 for expr in assignment_exprs:
                     self._check_maths_name_references(expr, xml_context)
  
         # Rule 4.4.4: mathematical expressions may only modify
         # variables belonging to the current component.
         if not self._cml_validation_errors and not assume_valid:
             self._check_assigned_vars(assignment_exprs, xml_context)
  
         # Warn if mathematics outside the CellML subset is used.
         if not self._cml_validation_errors and not assume_valid:
             math_elts = self.xml_xpath(self.math_xpath_1 + u' | ' + self.math_xpath_2)
             self._check_cellml_subset(math_elts)
  
         # Classify variables and check for circular equations.
         # Does a topological sort of all equations in the process.
         # TODO: Handle reactions properly.
         if not self._cml_validation_errors:
             self._classify_variables(assignment_exprs, xml_context)
             self._order_variables(assignment_exprs, xml_context)
  
         # Appendix C.3.6: Equation dimension checking.
         if not self._cml_validation_errors and (not assume_valid or check_for_units_conversions):
             self._check_dimensional_consistency(assignment_exprs,
                                                 xml_context,
                                                 warn_on_units_errors,
                                                 check_for_units_conversions)
         
         # Warn if unknown namespaces are used, just in case.
         unknown_nss = set(self.rootNode.xml_namespaces.keys()).difference(set(NSS.values()))
         if unknown_nss:
             self.validation_warning(u'Unrecognised namespaces used:\n  ' +
                                     u'\n  '.join(list(unknown_nss)))
  
         # Return validation result
         return not self._cml_validation_errors and \
                (not invalid_if_warnings or not self._cml_validation_warnings)
  

◆ validation_error()

def CellMLToNektar.pycml.cellml_model.validation_error	(	self,
		errmsg,
		level = `logging.ERROR`
	)

Log a validation error message.

Message should be a unicode string.

Definition at line 512 of file pycml.py.

     def validation_error(self, errmsg, level=logging.ERROR):
         """Log a validation error message.
         
         Message should be a unicode string.
         """
         self._cml_validation_errors.append(errmsg)
         logging.getLogger('validator').log(level, errmsg.encode('UTF-8'))

References CellMLToNektar.pycml.cellml_model._cml_validation_errors, and tinysimd.log().

◆ validation_warning()

def CellMLToNektar.pycml.cellml_model.validation_warning	(	self,
		errmsg,
		level = `logging.WARNING`
	)

Log a validation warning message.

Message should be a unicode string.

Definition at line 522 of file pycml.py.

     def validation_warning(self, errmsg, level=logging.WARNING):
         """Log a validation warning message.
         
         Message should be a unicode string.
         """
         self._cml_validation_warnings.append(errmsg)
         logging.getLogger('validator').log(level, errmsg.encode('UTF-8'))

References CellMLToNektar.pycml.cellml_model._cml_validation_warnings, and tinysimd.log().

Referenced by CellMLToNektar.pycml.cellml_model._check_cellml_subset(), CellMLToNektar.pycml.cellml_model._check_connection_units(), CellMLToNektar.pycml.cellml_model._report_exception(), and CellMLToNektar.pycml.cellml_model.validate().

◆ xml()

def CellMLToNektar.pycml.cellml_model.xml	(		self,
			stream = `None`,
			writer = `None`,
		**	wargs
	)

Serialize back to XML.
If stream is given, output to stream.
If writer is given, use it directly.
If neither a stream nor a writer is given, return the output text
as a Python string (not Unicode) encoded as UTF-8.

This overrides Amara's method, in order to force declaration of
various namespaces with prefixes on this element, and to ensure
the RDF annotations are up-to-date.

See base class docs for possible keyword arguments.

Definition at line 1457 of file pycml.py.

     def xml(self, stream=None, writer=None, **wargs):
         """Serialize back to XML.
         If stream is given, output to stream.
         If writer is given, use it directly.
         If neither a stream nor a writer is given, return the output text
         as a Python string (not Unicode) encoded as UTF-8.
  
         This overrides Amara's method, in order to force declaration of
         various namespaces with prefixes on this element, and to ensure
         the RDF annotations are up-to-date.
  
         See base class docs for possible keyword arguments.
         """
         extra_namespaces = {u'cellml': NSS[u'cml'],
                             u'pe': NSS[u'pe'],
                             u'lut': NSS[u'lut']}
         
         # Update RDF block if necessary
         cellml_metadata.update_serialized_rdf(self)
         
         temp_stream = None
         close_document = 0
         if not writer:
             #Change the default to *not* generating an XML decl
             if not wargs.get('omitXmlDeclaration'):
                 wargs['omitXmlDeclaration'] = u'yes'
             if stream:
                 writer = amara.bindery.create_writer(stream, wargs)
             else:
                 temp_stream = StringIO()
                 writer = amara.bindery.create_writer(temp_stream, wargs)
  
             writer.startDocument()
             close_document = 1
         writer.startElement(self.nodeName, self.namespaceURI,
                             extraNss=extra_namespaces)
         if hasattr(self, 'xml_attributes'):
             for apyname in self.xml_attributes:
                 aqname, ans = self.xml_attributes[apyname]
                 val = self.__dict__[apyname]
                 writer.attribute(aqname, val, ans)
         for child in self.xml_children:
             if isinstance(child, unicode):
                 writer.text(child)
             else:
                 child.xml(writer=writer)
         writer.endElement(self.nodeName, self.namespaceURI)
         if close_document:
             writer.endDocument()
         return temp_stream and temp_stream.getvalue()
     
  

References CellMLToNektar.pycml.element_base.xml_attributes.

Member Data Documentation

◆ _cml_assignments

CellMLToNektar.pycml.cellml_model._cml_assignments

private

Definition at line 393 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model._add_sorted_assignment(), CellMLToNektar.pycml.cellml_model._remove_assignment(), CellMLToNektar.pycml.cellml_model.clear_assignments(), and CellMLToNektar.pycml.cellml_model.get_assignments().

◆ _cml_components

CellMLToNektar.pycml.cellml_model._cml_components

private

Definition at line 388 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model._add_component(), CellMLToNektar.pycml.cellml_model._del_component(), CellMLToNektar.pycml.cellml_model.build_name_dictionaries(), and CellMLToNektar.pycml.cellml_model.get_component_by_name().

◆ _cml_conversions_needed

CellMLToNektar.pycml.cellml_model._cml_conversions_needed

private

Definition at line 1156 of file pycml.py.

◆ _cml_sorting_variables_stack

CellMLToNektar.pycml.cellml_model._cml_sorting_variables_stack

private

Definition at line 902 of file pycml.py.

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

◆ _cml_standard_units

CellMLToNektar.pycml.cellml_model._cml_standard_units

private

Definition at line 390 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model._build_units_dictionary(), and CellMLToNektar.pycml.cellml_model.get_standard_units().

◆ _cml_units

CellMLToNektar.pycml.cellml_model._cml_units

private

Definition at line 389 of file pycml.py.

◆ _cml_units_map

CellMLToNektar.pycml.cellml_model._cml_units_map

private

Definition at line 391 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model._add_units_obj(), CellMLToNektar.pycml.cellml_model._get_units_obj(), and CellMLToNektar.pycml.cellml_model._is_new_units_obj().

◆ _cml_validation_errors

CellMLToNektar.pycml.cellml_model._cml_validation_errors

private

Definition at line 385 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model.build_component_hierarchy(), CellMLToNektar.pycml.cellml_model.get_validation_errors(), CellMLToNektar.pycml.cellml_model.validate(), and CellMLToNektar.pycml.cellml_model.validation_error().

◆ _cml_validation_warnings

CellMLToNektar.pycml.cellml_model._cml_validation_warnings

private

Definition at line 386 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model.get_validation_warnings(), CellMLToNektar.pycml.cellml_model.validate(), and CellMLToNektar.pycml.cellml_model.validation_warning().

◆ _cml_variables

CellMLToNektar.pycml.cellml_model._cml_variables

private

Definition at line 387 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model._add_variable(), CellMLToNektar.pycml.cellml_model._del_variable(), CellMLToNektar.pycml.cellml_model.build_name_dictionaries(), and CellMLToNektar.pycml.cellml_model.get_variable_by_name().

◆ apply_xpath_1

string CellMLToNektar.pycml.cellml_model.apply_xpath_1 = u'/m:apply[m:eq]'

static

Definition at line 915 of file pycml.py.

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

◆ apply_xpath_2

string CellMLToNektar.pycml.cellml_model.apply_xpath_2 = u'/m:semantics/m:apply[m:eq]'

static

Definition at line 916 of file pycml.py.

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

◆ math_xpath_1

string CellMLToNektar.pycml.cellml_model.math_xpath_1 = u'cml:component/m:math'

static

Definition at line 913 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model.search_for_assignments(), and CellMLToNektar.pycml.cellml_model.validate().

◆ math_xpath_2

string CellMLToNektar.pycml.cellml_model.math_xpath_2 = u'cml:component/cml:reaction/cml:variable_ref/cml:role/m:math'

static

Definition at line 914 of file pycml.py.

Referenced by CellMLToNektar.pycml.cellml_model.search_for_assignments(), and CellMLToNektar.pycml.cellml_model.validate().

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

◆ __del__()

Member Function Documentation

◆ _add_component()

◆ _add_sorted_assignment()

◆ _add_units_obj()

◆ _add_variable()

◆ _build_units_dictionary()

◆ _check_assigned_vars()

◆ _check_cellml_subset()

◆ _check_connection_units()

◆ _check_dimensional_consistency()

◆ _check_maths_name_references()

◆ _check_unit_cycles()

◆ _check_variable_mappings()

◆ _check_variable_units_exist()

◆ _classify_variables()

◆ _del_component()

◆ _del_variable()

◆ _get_units_obj()

◆ _is_new_units_obj()

◆ _order_variables()

◆ _remove_assignment()

◆ _report_exception()

◆ _validate_component_hierarchies()

◆ _validate_connection()

◆ add_units()

◆ add_units_conversions()

◆ build_component_hierarchy()

◆ build_name_dictionaries()

◆ calculate_extended_dependencies()

◆ clean_up()

◆ clear_assignments()

◆ do_binding_time_analysis()

◆ find_free_vars()

◆ find_state_vars()

◆ get_all_units()

◆ get_all_variables()

◆ get_assignments()

◆ get_component_by_name()

◆ get_config()

◆ get_option()

◆ get_standard_units()

◆ get_units_by_name()

◆ get_validation_errors()

◆ get_validation_warnings()

◆ get_variable_by_cmeta_id()

◆ get_variable_by_name()

◆ get_variable_by_oxmeta_name()

◆ get_variables_by_ontology_term()

◆ has_units()

◆ is_self_excitatory()

◆ search_for_assignments()

◆ topological_sort()

◆ validate()

◆ validation_error()

◆ validation_warning()

◆ xml()

Member Data Documentation

◆ _cml_assignments

◆ _cml_components

◆ _cml_conversions_needed

◆ _cml_sorting_variables_stack

◆ _cml_standard_units

◆ _cml_units

◆ _cml_units_map

◆ _cml_validation_errors

◆ _cml_validation_warnings

◆ _cml_variables

◆ apply_xpath_1

◆ apply_xpath_2

◆ math_xpath_1

◆ math_xpath_2

◆ init()

◆ del()