NineML Types

Relationship to specification

There is a near one-to-one mapping between NineML types as defined in the NineML specification and classes in the nineml Python package.

The most significant exceptions are classes in the nineml package that are modelled on proposed changes to the NineML specification (see http://github.com/INCF/nineml-spec/issues), e.g. ComponentClass -> Dynamics/ConnectionRule, Projection, Quantity.

There are also cases where a type in the specification is just a thin wrapper around a body element (e.g. Delay, Size), which are “flattened” to be attributes in the NineML Python Library.

Mathematical expressions

All expressions in the NineML Python Library are represented using Sympy objects. Whereas in the NineML Specification mathematical expressions are specified to be enclosed within MathInline elements (with a subset of MathML planned as an alternative in future versions), in the NineML Python Library the Sympy object representing is accessed via the rhs property of the relevant objects.

Common properties/methods

All types

All NineML types in the NineML Python Library derive from BaseNineMLObject, which adds some common methods.

Document-level types

There are 12 types that are permitted in the root of a NineML document

  • Dynamics
  • DynamicsProperties
  • ConnectionRule
  • ConnectionRuleProperties
  • RandomDistribution
  • RandomDistribution
  • Population
  • Projection
  • Selection
  • Network
  • Unit
  • Dimension

Each instance of these types has a document property to access the document it belongs to and a url property to access the url of the document. If the instance has not been added to a document then they will return None.

Container types

NineML types that can have multiple child elements of one or more types, i.e.:

  • Dynamics
  • ConnectionRule
  • RandomDistribution
  • DynamicsProperties
  • ConnectionRuleProperties
  • RandomDistributionProperties
  • Regime
  • OnEvent
  • OnCondition
  • Network
  • Selection

derive from the ContainerObject class, which defines several methods to accessing, adding and removing their children. Internally, each child is stored in a dictionary according to its type. However, access to children is provided through four standardised accessor methods for each child type the container can hold:

<child-type-plural>:
Property that returns an iterator over child elements of the given type (e.g. aliases, parameters, on_conditions)
<child-type>_names/keys:
Property that returns an iterator over the keys of child elements that are used to store the child in the internal dictionary. If the child type has a name, then the access will be <child-type>_names, otherwise it will be <child-type>_keys (e.g. alias_names, parameter_names, on_condition_keys)
num_<child-type-plural>:
Property that returns the number child elements in the container
<child-type>:
Accessor method that takes the name/key of the child type and returns the corresponding element in the container.

There are a number of standard methods for container types

Annotations

All NineML elements can be annotated (except Annotations themselves) via their annotations property. The annotations property returns an Annotations element, with several convenient methods for setting attributes of nested elements.