Nektar++: CellMLToNektar.pycml.cellml

def CellMLToNektar.pycml.cellml_model.__del__ ( self )

Definition at line 395 of file pycml.py.

References CellMLToNektar.pycml.cellml_model.clean_up().

 
     def __del__(self):
         self.clean_up()

CellMLToNektar.pycml.cellml_model.clean_up

def clean_up

Definition: pycml.py:398

CellMLToNektar.pycml.cellml_model.__del__

def __del__

Definition: pycml.py:395

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.

References CellMLToNektar.pycml.cellml_model._cml_components.

 
     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

CellMLToNektar.pycml.cellml_model._cml_components

_cml_components

Definition: pycml.py:388

CellMLToNektar.pycml.cellml_model._add_component

def _add_component

Definition: pycml.py:499

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.

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

 
     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)

CellMLToNektar.pycml.cellml_model._add_sorted_assignment

def _add_sorted_assignment

Definition: pycml.py:1095

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.

References CellMLToNektar.pycml.cellml_model._cml_units_map.

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

 
     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

CellMLToNektar.pycml.cellml_model._add_units_obj

def _add_units_obj

Definition: pycml.py:1331

CellMLToNektar.pycml.cellml_model._cml_units_map

_cml_units_map

Definition: pycml.py:391

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.

References CellMLToNektar.pycml.cellml_model._cml_variables.

 
     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

CellMLToNektar.pycml.cellml_model._cml_variables

_cml_variables

Definition: pycml.py:387

CellMLToNektar.pycml.cellml_model._add_variable

def _add_variable

Definition: pycml.py:490

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.

References CellMLToNektar.pycml.cellml_model._add_units_obj(), CellMLToNektar.pycml.cellml_model._cml_standard_units, CellMLToNektar.pycml.cellml_model._cml_units, and CellMLToNektar.pycml.cellml_model.validation_error().

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

 
     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)

CellMLToNektar.pycml.cellml_model._add_units_obj

def _add_units_obj

Definition: pycml.py:1331

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model._cml_units

_cml_units

Definition: pycml.py:389

CellMLToNektar.pycml.cellml_model._cml_standard_units

_cml_standard_units

Definition: pycml.py:390

CellMLToNektar.pycml.cellml_model._build_units_dictionary

def _build_units_dictionary

Definition: pycml.py:1210

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.

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

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

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

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model._check_assigned_vars

def _check_assigned_vars

Definition: pycml.py:842

CellMLToNektar.pycml.cellml_model._report_exception

def _report_exception

Definition: pycml.py:533

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.

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

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

CellMLToNektar.pycml.cellml_model._check_cellml_subset

def _check_cellml_subset

Definition: pycml.py:853

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model.validation_warning

def validation_warning

Definition: pycml.py:522

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.

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

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

 
     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)

CellMLToNektar.pycml.cellml_model.get_variable_by_name

def get_variable_by_name

Definition: pycml.py:418

CellMLToNektar.pycml.cellml_model.validation_warning

def validation_warning

Definition: pycml.py:522

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model.get_component_by_name

def get_component_by_name

Definition: pycml.py:414

CellMLToNektar.pycml.cellml_model._check_connection_units

def _check_connection_units

Definition: pycml.py:786

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 1154 of file pycml.py.

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

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

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model.validation_warning

def validation_warning

Definition: pycml.py:522

CellMLToNektar.pycml.cellml_model.get_units_by_name

def get_units_by_name

Definition: pycml.py:1309

CellMLToNektar.pycml.cellml_model._cml_conversions_needed

_cml_conversions_needed

Definition: pycml.py:1156

CellMLToNektar.pycml.cellml_model._report_exception

def _report_exception

Definition: pycml.py:533

CellMLToNektar.pycml.cellml_model._cml_validation_errors

_cml_validation_errors

Definition: pycml.py:385

CellMLToNektar.utilities.element_xpath

def element_xpath

Definition: utilities.py:225

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.

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

 
     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)

CellMLToNektar.pycml.MathsError

Definition: pycml.py:3343

CellMLToNektar.pycml.cellml_model._check_maths_name_references

def _check_maths_name_references

Definition: pycml.py:812

CellMLToNektar.pycml.cellml_model._report_exception

def _report_exception

Definition: pycml.py:533

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.

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

 
     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)

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model._check_unit_cycles

def _check_unit_cycles

Definition: pycml.py:1181

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.

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

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

CellMLToNektar.pycml.cellml_model._validate_connection

def _validate_connection

Definition: pycml.py:689

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model._check_variable_mappings

def _check_variable_mappings

Definition: pycml.py:663

CellMLToNektar.pycml.cellml_model.build_name_dictionaries

def build_name_dictionaries

Definition: pycml.py:932

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.

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

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

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

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model.get_all_variables

def get_all_variables

Definition: pycml.py:484

CellMLToNektar.pycml.cellml_model._check_variable_units_exist

def _check_variable_units_exist

Definition: pycml.py:774

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.

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

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

CellMLToNektar.pycml.cellml_model._classify_variables

def _classify_variables

Definition: pycml.py:866

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model.get_all_variables

def get_all_variables

Definition: pycml.py:484

CellMLToNektar.pycml.cellml_model._report_exception

def _report_exception

Definition: pycml.py:533

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.

References CellMLToNektar.pycml.cellml_model._cml_components.

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

CellMLToNektar.pycml.cellml_model._del_component

def _del_component

Definition: pycml.py:507

CellMLToNektar.pycml.cellml_model._cml_components

_cml_components

Definition: pycml.py:388

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.

References CellMLToNektar.pycml.cellml_model._cml_variables.

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

CellMLToNektar.pycml.cellml_model._del_variable

def _del_variable

Definition: pycml.py:495

CellMLToNektar.pycml.cellml_model._cml_variables

_cml_variables

Definition: pycml.py:387

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)

CellMLToNektar.pycml.cellml_model._get_units_obj

def _get_units_obj

Definition: pycml.py:1337

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.

References CellMLToNektar.pycml.cellml_model._cml_units_map.

 
     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

CellMLToNektar.pycml.cellml_model._cml_units_map

_cml_units_map

Definition: pycml.py:391

CellMLToNektar.pycml.cellml_model._is_new_units_obj

def _is_new_units_obj

Definition: pycml.py:1350

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.

References CellMLToNektar.pycml.cellml_model.clear_assignments().

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

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

CellMLToNektar.pycml.cellml_model.topological_sort

def topological_sort

Definition: pycml.py:1042

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model.clear_assignments

def clear_assignments

Definition: pycml.py:1120

CellMLToNektar.pycml.cellml_model.get_all_variables

def get_all_variables

Definition: pycml.py:484

CellMLToNektar.pycml.cellml_model._order_variables

def _order_variables

Definition: pycml.py:893

CellMLToNektar.pycml.cellml_model._cml_sorting_variables_stack

_cml_sorting_variables_stack

Definition: pycml.py:902

CellMLToNektar.pycml.cellml_model._report_exception

def _report_exception

Definition: pycml.py:533

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)

CellMLToNektar.pycml.cellml_model._remove_assignment

def _remove_assignment

Definition: pycml.py:1106

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.

References CellMLToNektar.pycml.cellml_model.validate(), 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().

 
     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)

CellMLToNektar.pycml.cellml_model.validation_warning

def validation_warning

Definition: pycml.py:522

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model._report_exception

def _report_exception

Definition: pycml.py:533

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.

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

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

CellMLToNektar.pycml.cellml_model._validate_component_hierarchies

def _validate_component_hierarchies

Definition: pycml.py:632

CellMLToNektar.pycml.cellml_model.build_component_hierarchy

def build_component_hierarchy

Definition: pycml.py:958

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

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.

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

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

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

CellMLToNektar.pycml.cellml_model._validate_connection

def _validate_connection

Definition: pycml.py:689

CellMLToNektar.pycml.cellml_model.get_variable_by_name

def get_variable_by_name

Definition: pycml.py:418

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model.get_component_by_name

def get_component_by_name

Definition: pycml.py:414

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.

References CellMLToNektar.pycml.cellml_model._add_units_obj(), CellMLToNektar.pycml.cellml_model._build_units_dictionary(), and CellMLToNektar.pycml.cellml_model._cml_units.

 
     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

CellMLToNektar.pycml.cellml_model._add_units_obj

def _add_units_obj

Definition: pycml.py:1331

CellMLToNektar.pycml.cellml_model.add_units

def add_units

Definition: pycml.py:1318

CellMLToNektar.pycml.cellml_model._cml_units

_cml_units

Definition: pycml.py:389

CellMLToNektar.pycml.cellml_model._build_units_dictionary

def _build_units_dictionary

Definition: pycml.py:1210

def CellMLToNektar.pycml.cellml_model.add_units_conversions ( self )

Add explicit units conversion mathematics where necessary.

Definition at line 1357 of file pycml.py.

References CellMLToNektar.pycml.import_processors().

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

CellMLToNektar.pycml.import_processors

def import_processors

Definition: pycml.py:84

CellMLToNektar.processors.UnitsConverter

Definition: processors.py:749

CellMLToNektar.pycml.cellml_model.add_units_conversions

def add_units_conversions

Definition: pycml.py:1357

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.

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

 
     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

CellMLToNektar.pycml.cellml_model.build_component_hierarchy

def build_component_hierarchy

Definition: pycml.py:958

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model.get_component_by_name

def get_component_by_name

Definition: pycml.py:414

CellMLToNektar.pycml.cellml_model.build_name_dictionaries

def build_name_dictionaries

Definition: pycml.py:932

CellMLToNektar.pycml.cellml_model._cml_validation_errors

_cml_validation_errors

Definition: pycml.py:385

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.

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

 
     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

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model._cml_variables

_cml_variables

Definition: pycml.py:387

CellMLToNektar.pycml.cellml_model._cml_components

_cml_components

Definition: pycml.py:388

CellMLToNektar.pycml.cellml_model.build_name_dictionaries

def build_name_dictionaries

Definition: pycml.py:932

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 1381 of file pycml.py.

References CellMLToNektar.pycml.cellml_model.calculate_extended_dependencies().

 
                                         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

CellMLToNektar.pycml.cellml_model.calculate_extended_dependencies

def calculate_extended_dependencies

Definition: pycml.py:1381

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.

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

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

CellMLToNektar.pycml.cellml_model.clean_up

def clean_up

Definition: pycml.py:398

def CellMLToNektar.pycml.cellml_model.clear_assignments ( self )

Clear the assignments list.

Definition at line 1120 of file pycml.py.

References CellMLToNektar.pycml.cellml_model._cml_assignments.

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

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

CellMLToNektar.pycml.cellml_model.clear_assignments

def clear_assignments

Definition: pycml.py:1120

CellMLToNektar.pycml.cellml_model._cml_assignments

_cml_assignments

Definition: pycml.py:393

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.

References CellMLToNektar.pycml.cellml_model._check_dimensional_consistency(), and CellMLToNektar.pycml.cellml_model.get_assignments().

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

CellMLToNektar.pycml.cellml_model.do_binding_time_analysis

def do_binding_time_analysis

Definition: pycml.py:1124

CellMLToNektar.pycml.cellml_model.get_assignments

def get_assignments

Definition: pycml.py:1111

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.

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

 
     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

CellMLToNektar.pycml.cellml_model.find_free_vars

def find_free_vars

Definition: pycml.py:1370

CellMLToNektar.pycml.cellml_model.get_all_variables

def get_all_variables

Definition: pycml.py:484

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.

References CellMLToNektar.pycml.cellml_model.get_all_variables().

 
     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

CellMLToNektar.pycml.cellml_model.get_all_variables

def get_all_variables

Definition: pycml.py:484

CellMLToNektar.pycml.cellml_model.find_state_vars

def find_state_vars

Definition: pycml.py:1362

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.

References CellMLToNektar.pycml.cellml_model._build_units_dictionary(), and CellMLToNektar.pycml.cellml_model._cml_units.

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

 
     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

CellMLToNektar.pycml.cellml_model._cml_units

_cml_units

Definition: pycml.py:389

CellMLToNektar.pycml.cellml_model.get_all_units

def get_all_units

Definition: pycml.py:1300

CellMLToNektar.pycml.cellml_model._build_units_dictionary

def _build_units_dictionary

Definition: pycml.py:1210

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.

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

 
     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

CellMLToNektar.pycml.cellml_model.get_all_variables

def get_all_variables

Definition: pycml.py:484

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.

References CellMLToNektar.pycml.cellml_model._cml_assignments.

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

 
     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

CellMLToNektar.pycml.cellml_model._cml_assignments

_cml_assignments

Definition: pycml.py:393

CellMLToNektar.pycml.cellml_model.get_assignments

def get_assignments

Definition: pycml.py:1111

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.

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

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

CellMLToNektar.pycml.cellml_model.get_component_by_name

def get_component_by_name

Definition: pycml.py:414

CellMLToNektar.pycml.cellml_model._cml_components

_cml_components

Definition: pycml.py:388

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

CellMLToNektar.pycml.cellml_model.get_config

def get_config

Definition: pycml.py:402

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)

CellMLToNektar.pycml.cellml_model.get_option

def get_option

Definition: pycml.py:409

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.

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

 
     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

CellMLToNektar.pycml.cellml_model._cml_standard_units

_cml_standard_units

Definition: pycml.py:390

CellMLToNektar.pycml.cellml_model._build_units_dictionary

def _build_units_dictionary

Definition: pycml.py:1210

CellMLToNektar.pycml.cellml_model.get_standard_units

def get_standard_units

Definition: pycml.py:1294

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.

References CellMLToNektar.pycml.cellml_model._build_units_dictionary(), and CellMLToNektar.pycml.cellml_model._cml_units.

 
     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)

CellMLToNektar.pycml.cellml_model.get_units_by_name

def get_units_by_name

Definition: pycml.py:1309

CellMLToNektar.pycml.cellml_model._cml_units

_cml_units

Definition: pycml.py:389

CellMLToNektar.pycml.cellml_model._build_units_dictionary

def _build_units_dictionary

Definition: pycml.py:1210

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.

References CellMLToNektar.pycml.cellml_model._cml_validation_errors.

519

520 def get_validation_errors(self):

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

return self._cml_validation_errors

CellMLToNektar.pycml.cellml_model.get_validation_errors

def get_validation_errors

Definition: pycml.py:519

CellMLToNektar.pycml.cellml_model._cml_validation_errors

_cml_validation_errors

Definition: pycml.py:385

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.

References CellMLToNektar.pycml.cellml_model._cml_validation_warnings.

529

530 def get_validation_warnings(self):

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

532 """

return self._cml_validation_warnings

CellMLToNektar.pycml.cellml_model._cml_validation_warnings

_cml_validation_warnings

Definition: pycml.py:386

CellMLToNektar.pycml.cellml_model.get_validation_warnings

def get_validation_warnings

Definition: pycml.py:529

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]

CellMLToNektar.pycml.cellml_model.get_variable_by_cmeta_id

def get_variable_by_cmeta_id

Definition: pycml.py:474

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.

References CellMLToNektar.pycml.cellml_model._cml_variables.

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

 
     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

CellMLToNektar.pycml.cellml_model.get_variable_by_name

def get_variable_by_name

Definition: pycml.py:418

CellMLToNektar.pycml.cellml_model._cml_variables

_cml_variables

Definition: pycml.py:387

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

CellMLToNektar.pycml.cellml_model.get_variable_by_oxmeta_name

def get_variable_by_oxmeta_name

Definition: pycml.py:439

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

CellMLToNektar.pycml.cellml_model.get_variables_by_ontology_term

def get_variables_by_ontology_term

Definition: pycml.py:459

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

CellMLToNektar.pycml.cellml_model.has_units

def has_units

Definition: pycml.py:1327

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.

References CellMLToNektar.pycml.element_base.cmeta_id().

 
     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'

CellMLToNektar.pycml.element_base.cmeta_id

def cmeta_id

Definition: pycml.py:244

CellMLToNektar.pycml.cellml_model.is_self_excitatory

def is_self_excitatory

Definition: pycml.py:1446

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.

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

 
     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)

CellMLToNektar.pycml.cellml_model.search_for_assignments

def search_for_assignments

Definition: pycml.py:918

CellMLToNektar.pycml.cellml_model.math_xpath_2

string math_xpath_2

Definition: pycml.py:914

CellMLToNektar.pycml.cellml_model.apply_xpath_2

string apply_xpath_2

Definition: pycml.py:916

CellMLToNektar.pycml.cellml_model.apply_xpath_1

string apply_xpath_1

Definition: pycml.py:915

CellMLToNektar.pycml.cellml_model.math_xpath_1

string math_xpath_1

Definition: pycml.py:913

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.

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

 
     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

CellMLToNektar.pycml.cellml_model.topological_sort

def topological_sort

Definition: pycml.py:1042

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

CellMLToNektar.pycml.cellml_model._add_sorted_assignment

def _add_sorted_assignment

Definition: pycml.py:1095

CellMLToNektar.pycml.cellml_model._cml_sorting_variables_stack

_cml_sorting_variables_stack

Definition: pycml.py:902

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 549 of file pycml.py.

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

 
                  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)

CellMLToNektar.pycml.cellml_model.search_for_assignments

def search_for_assignments

Definition: pycml.py:918

CellMLToNektar.pycml.cellml_model._check_cellml_subset

def _check_cellml_subset

Definition: pycml.py:853

CellMLToNektar.pycml.cellml_model.math_xpath_2

string math_xpath_2

Definition: pycml.py:914

CellMLToNektar.pycml.cellml_model._classify_variables

def _classify_variables

Definition: pycml.py:866

CellMLToNektar.pycml.cellml_model._validate_component_hierarchies

def _validate_component_hierarchies

Definition: pycml.py:632

CellMLToNektar.utilities.DEBUG

def DEBUG

Definition: utilities.py:95

CellMLToNektar.pycml.cellml_model.validation_warning

def validation_warning

Definition: pycml.py:522

CellMLToNektar.pycml.cellml_model._check_variable_mappings

def _check_variable_mappings

Definition: pycml.py:663

CellMLToNektar.pycml.cellml_model._cml_validation_warnings

_cml_validation_warnings

Definition: pycml.py:386

CellMLToNektar.pycml.cellml_model._check_unit_cycles

def _check_unit_cycles

Definition: pycml.py:1181

CellMLToNektar.pycml.cellml_model._check_assigned_vars

def _check_assigned_vars

Definition: pycml.py:842

CellMLToNektar.pycml.cellml_model._check_maths_name_references

def _check_maths_name_references

Definition: pycml.py:812

CellMLToNektar.pycml.cellml_model._order_variables

def _order_variables

Definition: pycml.py:893

CellMLToNektar.pycml.cellml_model.math_xpath_1

string math_xpath_1

Definition: pycml.py:913

CellMLToNektar.pycml.cellml_model._check_variable_units_exist

def _check_variable_units_exist

Definition: pycml.py:774

CellMLToNektar.pycml.cellml_model.get_all_units

def get_all_units

Definition: pycml.py:1300

CellMLToNektar.pycml.cellml_model._check_connection_units

def _check_connection_units

Definition: pycml.py:786

CellMLToNektar.pycml.cellml_model._check_dimensional_consistency

def _check_dimensional_consistency

Definition: pycml.py:1154

CellMLToNektar.pycml.cellml_model._cml_validation_errors

_cml_validation_errors

Definition: pycml.py:385

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.

512

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

514 """Log a validation error message.

515

516 Message should be a unicode string.

517 """

518 self._cml_validation_errors.append(errmsg)

logging.getLogger('validator').log(level, errmsg.encode('UTF-8'))

CellMLToNektar.pycml.cellml_model.validation_error

def validation_error

Definition: pycml.py:512

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.

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

522

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

524 """Log a validation warning message.

525

526 Message should be a unicode string.

527 """

528 self._cml_validation_warnings.append(errmsg)

logging.getLogger('validator').log(level, errmsg.encode('UTF-8'))

CellMLToNektar.pycml.cellml_model.validation_warning

def validation_warning

Definition: pycml.py:522

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.

References CellMLToNektar.pycml.element_base.xml_attributes.

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

CellMLToNektar.pycml.element_base.xml_attributes

xml_attributes

Definition: pycml.py:213

CellMLToNektar.pycml.cellml_model.xml

def xml

Definition: pycml.py:1457

CellMLToNektar.pycml.cellml_model._cml_assignments

private

Definition at line 393 of file pycml.py.

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

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

CellMLToNektar.pycml.cellml_model._cml_conversions_needed

private

Definition at line 1156 of file pycml.py.

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

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

CellMLToNektar.pycml.cellml_model._cml_units

private

Definition at line 389 of file pycml.py.

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(), and CellMLToNektar.pycml.cellml_model._is_new_units_obj().

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(), and CellMLToNektar.pycml.cellml_model.validate().

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(), and CellMLToNektar.pycml.cellml_model.validate().

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

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

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

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

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

Member Function Documentation

Member Data Documentation

Public Member Functions
def	__init__

def	__del__

def	clean_up

def	get_config

def	get_option

def	get_component_by_name

def	get_variable_by_name

def	get_variable_by_oxmeta_name

def	get_variables_by_ontology_term

def	get_variable_by_cmeta_id

def	get_all_variables

def	validation_error

def	get_validation_errors

def	validation_warning

def	get_validation_warnings

def	validate

def	search_for_assignments

def	build_name_dictionaries

def	build_component_hierarchy

def	topological_sort

def	get_assignments

def	clear_assignments

def	do_binding_time_analysis

def	get_standard_units

def	get_all_units

def	get_units_by_name

def	add_units

def	has_units

def	add_units_conversions

def	find_state_vars

def	find_free_vars

def	calculate_extended_dependencies

def	is_self_excitatory

def	xml

Public Member Functions inherited from CellMLToNektar.pycml.element_base
def	__init__

def	__delattr__

def	__setattr__

def	rootNode

def	cmeta_id

def	xml_remove_child_at

def	xml_doc

def	xml_properties

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

def	_del_variable

def	_add_component

def	_del_component

def	_report_exception

def	_validate_component_hierarchies

def	_check_variable_mappings

def	_validate_connection

def	_check_variable_units_exist

def	_check_connection_units

def	_check_maths_name_references

def	_check_assigned_vars

def	_check_cellml_subset

def	_classify_variables

def	_order_variables

def	_add_sorted_assignment

def	_remove_assignment

def	_check_dimensional_consistency

def	_check_unit_cycles

def	_build_units_dictionary

def	_add_units_obj

def	_get_units_obj

def	_is_new_units_obj

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