SBML.org — the global portal for all things SBML

Definition of filters to select states and topologies

A selector is a mask describing the rules that an entity has to pass in order to be used or rejected. This selector is built of different components, carrying state features. The components can be bound together or not. In a population based model, the selector, when applied to a pool of entities, permits to filter it, and to obtain a further, more refined, entity pool.

The above selector accepts everything containing a blue crystal, but rejects the red face and the isolated green crystal.
The above selector accepts everything containing a blue crystal, but rejects the red face and the isolated green crystal.

A selector can be reused in various places of a model, to restrict the application of a procedure to a certain set of topologies and states. Selectors can be used to refine the initial conditions of a species, for instance to specify the initial distribution of different states and topologies. They can also be used in a reaction to decide if a this reaction happens, or to modulate its velocity, in function of the state or topology of a reactant.

A selector defines the list of components composing the mask, that are species type existing under a given state (that can be an ensemble of elementary states). In addition to the components, the selector lists the possible or mandatory bonds, as well as the components that must not be bound. It is to be noted that a selector must not necessarily be the most parsimonious. One can use the selectors to describe the fine-grained topology of complexes, even if this topology is not used to decide upon particular reactions. The general structure of the selector is provided in Figure 2.7 on the next page and the general structure of the species type state is provided in Figure 2.8 on the following page.

Selector and all the associated classes.
Selector and all the associated classes.
SpeciesTypeState and all the associated classes.
SpeciesTypeState and all the associated classes.

A graphical represenation of how to build a selector to encode a complex entity is represented in Figure 2.9 on the next page.

This figure illustrates the procedure by which a selector builds the representation of a multi-state, multi-component complex. To encode the left part, representing the complex following the conventions used in this document, we write part represented on the right, listing the different components and their relationships.
This figure illustrates the procedure by which a selector builds the representation of a multi-state, multi-component complex. To encode the left part, representing the complex following the conventions used in this document, we write part represented on the right, listing the different components and their relationships.


Contents

Selector

A Selector is identified by an id and an optional name. As all elements derived from SBase, it can link to Notes and Annotation, and carry a metaid , and an sboTerm . In addition, a Selector is linked to a list of SpeciesTypeStates, a list of Bonds and a list of BindingSiteReferences.

Definition of Selector and its relation to SBase.
Definition of Selector and its relation to SBase.
<multi:selector 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
       multi:id="selector1"
       multi:name="unbound_receptor">
  <multi:listOfSpeciesTypeStates>
    <!-- some species type state -->
  </multi:listOfSpeciesTypeStates>
  <multi:listOfBonds>
    <!-- some bonds -->
  </multi:listOfBonds>
  <multi:listOfUnboundBindingSites>
    <!-- some unbound binding sites -->
  </multi:listOfUnboundBindingSites>
</multi:selector>

SpeciesTypeState

A species type state describes an ensemble of instances of a species type can be into, in order to fulfill the requirements of the selector. In order to build complex multi-component species, an instance of a species type can contain other instances of species types, that have to be declared in the selector also, with their allowed states. A species type state is then defined by the values of the different state features carried by the species type, the list of species type states it "contains", and their topology. A SpeciesTypeState is identifiļæ½ed by an id and an optional name plus an attribute speciesType , pointing to the SpeciesType it instantiates. As all elements derived from SBase, it can link to Notes and Annotation, and carry a metaid , and an sboTerm . In addition, a SpeciesTypeState can be linked to a list of StateFeatureInstances and a list of ContainedSpeciesTypes. A SpeciesTypeState can be instantiated several times in a selector, using the attributes minOccur and maxOccur . The attribute connex precises that all those instances must be part of a continuous network through bonds formed by the ContainedSpeciesTypes. The attribute saturated precises that all ContainedSpeciesTypes that are instances of SpeciesType with their attribute bindingSite set to true must be involved in bonds.

Definition of SpeciesTypeState and its relation to SBase.
Definition of SpeciesTypeState and its relation to SBase.

<multi:speciesTypeState 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
       multi:id="speciesTypeState1" 
       multi:name="open_receptor"
       multi:speciesType="speciesType1"
       multi:minOccur="2" multi:maxOccur="4"
       multi:connex="true" multi:saturated="true" >
  <multi:listOfStateFeatureInstances>
    <!-- some state feature instances -->
  </multi:listOfStateFeatureInstances>
  <multi:listOfContainedSpeciesTypes>
    <!-- some contained species types -->
  </multi:listOfContainedSpeciesTypes>
</multi:speciesTypeState>

StateFeatureInstance

The possible states of an instance of species type are described using the state features of that species type. Only the meaningful state features, that are used to specified the state, must be listed. The other are assumed to take any value, to be wildcards. A StateFeatureInstance is identified by an attribute StateFeature, pointing to the StateFeature it instantiates. As all elements derived from SBase, it can link to Notes and Annotation, and carry a metaid , and an sboTerm . In addition, a StateFeatureInstance can be linked to a list of StateFeatureValues.

Definition of StateFeatureInstance and its relation to SBase.
Definition of StateFeatureInstance and its relation to SBase.
<multi:stateFeatureInstance 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
       multi:stateFeature="stateFeature1">
  <!-- some state feature values -->
</multi:stateFeatureInstance>

StateFeatureValue

The selector specifies the values that a state feature of an instance of species type can take. A StateFeatureValue points to the relevant PossibleValues defined in the instantiated SpeciesTypes using an attribute possibleValue . As all elements derived from SBase, StateFeatureValue can link to Notes and Annotation, and carry a metaid , and an sboTerm .

Definition of StateFeatureValue and its relation to SBase.
Definition of StateFeatureValue and its relation to SBase.
<multi:stateFeatureValue 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
       multi:possibleValue="possibleValue1" />

ContainedSpeciesType

In order to build complex nested multi-component species, an instance of a species type can contain other instances of species types, that have to be declared in the same selector. As all elements derived from SBase, ContainedSpeciesType can link to Notes and Annotation, and carry a metaid , and an sboTerm . In addition, a ContainedSpeciesType points to the relevant SpeciesTypeState using an attribute speciesTypeState .

Definition of ContainedSpeciesType and its relation to SBase.
Definition of ContainedSpeciesType and its relation to SBase.
<multi:containedSpeciesType 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
       multi:speciesTypeState="speciesType1" />

Bond

The connectivity between the components of a selector is described by listing the bonds that are possible, mandatory or forbidden. As all elements derived from SBase, Bond can link to Notes and Annotation, and carry a metaid , and an sboTerm . An attribute occurrence specifies if a bond is required, allowed or prohibited. In addition, a Bond can be linked to a one or two BindingReferences.

Definition of ContainedSpeciesType and its relation to SBase.
Definition of ContainedSpeciesType and its relation to SBase.
<multi:bond 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
       multi:occurrence="required" />
  <!-- some binding site references -->
</multi:bond>

BindingSiteReference

A component involved in a bond is specified by a BindingSiteReference. As all elements derived from SBase, it can link to Notes and Annotation, and carry a metaid , and an sboTerm . In addition, a BindingSiteReference refers to the component involved in the bond through the attribute speciesTypeState , that points to the value of the id attribute of the relevant SpeciesTypeState.

Definition of BindingSiteReference and its relation to SBase.
Definition of BindingSiteReference and its relation to SBase.
<multi:bindingSiteReference 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
       multi:speciesTypeState="speciesTypeState1" />

Defining the components and the states allowed by the selector

The following code contains a portion of selector describing two species type states, speciesTypeState1 and speciesTypeState2. SpeciesTypeState1 has a feature stateFeature1 that can take the values possibleValue1 or possibleValue2 to pass the selection. In addition speciesTypeState2 contains 4 instances of speciesType2 (more exactly, it can contain between 4 and 4 instances of speciesType2 ... ). The boolean attributes connex and saturated are of no use in this particular example, but are to be interpreted in conjunction with the bond definitions.

Generation of a nested selector from the definition of the two species type states, and the containment of one by the other.
Generation of a nested selector from the definition of the two species type states, and the containment of one by the other.
<multi:listOfSpeciesTypeStates 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
  <multi:speciesTypeState 
         multi:id="speciesTypeState1"  
         multi:speciesType="speciesType1"
         multi:minOccur="4" multi:maxOccur="4"
         multi:connex="true" multi:saturated="true">
    <multi:listOfStateFeatureInstances>
      <multi:stateFeatureInstance multi:stateFeature="stateFeature1">
        <multi:listOfStateFeatureValues>
          <multi:stateFeatureValue multi:possibleValue="possibleValue1" />
          <multi:stateFeatureValue multi:possibleValue="possibleValue2" />
        </multi:listOfStateFeatureValues>
      </multi:stateFeatureInstance>
    </multi:listOfStateFeatureInstances>
  </multi:speciesTypeState>
  <multi:speciesTypeState 
         multi:id="speciesTypeState2"  
         multi:speciesType="speciesType2"
         multi:minOccur="1" multi:maxOccur="1">
    <multi:listOfContainedSpeciesTypes>
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeState1" />
    </multi:listOfContainedSpeciesTypes>
  </multi:speciesTypeState>
</multi:listOfSpeciesTypeStates>


Image:Warning.gif It is up to the model designer to avoid impossible structures, such as a species type state 1 that contains a species type 2, 2 itself containing 1. The following example is forbidden.

<multi:listOfSpeciesTypeStates
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
  
  <multi:speciesTypeState 
         multi:id="speciesTypeState1"
         multi:speciesType="speciesType1"
         multi:minOccur="1" multi:maxOccur="1" >
    <multi:listOfContainedSpeciesTypes>
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeState2" />
    </multi:listOfContainedSpeciesTypes>
  </multi:speciesTypeState>

  <multi:speciesTypeState 
         multi:id="speciesTypeState2" 
         multi:speciesType="speciesType2"
         multi:minOccur="1" 
         multi:maxOccur="1" >
    <multi:listOfContainedSpeciesTypes>
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeState1" />
    </multi:listOfContainedSpeciesTypes>
  </multi:speciesTypeState>

</multi:listOfSpeciesTypeStates>


If a species type is used in two different contexts, requiring for instance different numbers of occurences, two different species type states must be defined. For instance, if a species type A is used on its own in a species type C, or as contained twice in another species type B itself in C, we need one A with min/maxOccur=1 and one A with min/maxOccur=2.

Nested selector where a given species type is used in two different contexts.
Nested selector where a given species type is used in two different contexts.
<multi:listOfSpeciesTypeStates 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
  <multi:speciesTypeState 
         multi:id="speciesTypeStateA1" 
         multi:speciesType="speciesTypeA"
         multi:minOccur="1" multi:maxOccur="1" />
  <multi:speciesTypeState 
         multi:id="speciesTypeStateA2" 
         multi:speciesType="speciesTypeA"
         multi:minOccur="2" multi:maxOccur="2" />
  <multi:speciesTypeState 
         multi:id="speciesTypeStateB" 
         multi:speciesType="speciesTypeB"
         multi:minOccur="1" multi:maxOccur="1" />
    <multi:listOfContainedSpeciesTypes>
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeStateA2" />
    </multi:listOfContainedSpeciesTypes>
  </multi:speciesTypeState>
  <multi:speciesTypeState 
         multi:id="speciesTypeStateC" 
         multi:speciesType="speciesTypeC"
         multi:minOccur="1" multi:maxOccur="1" >
    <multi:listOfContainedSpeciesTypes>
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeStateA1" />
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeStateB" />
    </multi:listOfContainedSpeciesTypes>
  </multi:speciesTypeState>
</multi:listOfSpeciesTypeStates>


The same species type can also be declared several time with different state feature values. The following example depicts a species type B containing two intances of species type A with a state feature displaying alternative values. Although in both case, the species type states refer to the same species type, we need to declare them separately.

Nested selector where a given species type is used with two different state feature values.
Nested selector where a given species type is used with two different state feature values.
<multi:listOfSpeciesTypeStates 
       xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
  <multi:speciesTypeState 
         multi:id="speciesTypeStateA1" 
         multi:speciesType="speciesTypeA"
         multi:minOccur="1" multi:maxOccur="1"
    <multi:listOfStateFeatureInstances>
      <multi:stateFeatureInstance multi:stateFeature="stateFeature1">
        <multi:listOfStateFeatureValues>
          <multi:stateFeatureValue multi:possibleValue="possibleValue1" />
        </multi:listOfStateFeatureValues>
      </multi:stateFeatureInstance>
    </multi:listOfStateFeatureInstances>
  </multi:speciesTypeState>
  <multi:speciesTypeState 
         multi:id="speciesTypeStateA2" 
         multi:speciesType="speciesTypeA"
         multi:minOccur="1" multi:maxOccur="1"
    <multi:listOfStateFeatureInstances>
      <multi:stateFeatureInstance multi:stateFeature="stateFeature1">
        <multi:listOfStateFeatureValues>
          <multi:stateFeatureValue multi:possibleValue="possibleValue2" />
        </multi:listOfStateFeatureValues>
      </multi:stateFeatureInstance>
    </multi:listOfStateFeatureInstances>
  </multi:speciesTypeState>
  <multi:speciesTypeState 
         multi:id="speciesTypeStateB" 
         multi:speciesType="speciesTypeB"
         multi:minOccur="1" multi:maxOccur="1">
    <multi:listOfContainedSpeciesTypes>
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeStateA1" />
      <multi:containedSpeciesType multi:speciesTypeState="speciesTypeStateA2" />
    </multi:listOfContainedSpeciesTypes>
  </multi:speciesTypeState>
</multi:listOfSpeciesTypeStates>

Defining the connectivities allowed by the selector

In a selector, instances of species types possessing an attribute bindingSite set to true can be referred to when they are involved in bonds, or explicitly listed as unbound. As a result such a species type can be used in four different contexts:

  • In a declared explicit bond, with another specific instance of a species type (represented by a bond linking two black entities in the example graphs).
<multi:bond 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:occurrence="required" >
  <multi:bindingSiteReference multi:speciesTypeState="speciesTypeState1" />
  <multi:bindingSiteReference multi:speciesTypeState="speciesTypeState2" />
</multi:bond>
  • In a declared generic bond without another specific instance of a species type (represented by an unlinked black entity in the example graphs).
<multi:bond 
              xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
              multi:occurrence="required" >
  <multi:bindingSiteReference multi:speciesTypeState="speciesTypeState1" />
</multi:bond>
  • Declared as explicitly unbound (represented by a white entity in the example graphs).
<multi:listOfUnboundBindingSites
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1" />
  <multi:bindingSiteReference multi:speciesTypeState="speciesTypeState1" />
</multi:listOfUnboundBindingSites>
  • Undeclared, meaning that one does not care if it is bound or not (represented by a grey entity in the example graphs).


Image:Warning.gif A given binding site can only be bound to another binding site. If three instances of species types are bound together, they have to be bound through different contained binding sites. Those binding sites can be different instances of the same species type ("identical" binding sites) or instances of different species types (different binding sites). The following example is forbidden:

<multi:listOfBonds 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
  <multi:bond multi:occurrence="required" >
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateA" />
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateB" />
  </multi:bond>
  <multi:bond multi:occurrence="required" >
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateA" />
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateC" />
  </multi:bond>
</multi:listOfBonds>

Instead the following code should be used, where speciesTypeStateA1 and speciesTypeStateA2 are two different species type states of the same species type.

<multi:listOfBonds 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
  <multi:bond multi:occurrence="required" >
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateA1" />
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateB" />
  </multi:bond>
  <multi:bond multi:occurrence="required" >
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateA2" />
    <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateC" />
  </multi:bond>
</multi:listOfBonds>


The connectivity on the left is forbidden, and the connectivity on the right should be used instead.
The connectivity on the left is forbidden, and the connectivity on the right should be used instead.


The description of the connectivity through the list of bonds and the list of unbound binding sites is greedy. In other words, the possible connectivity is the sum of all the different listed possibilities. If in a selector, an instance of a species type is involved in at least one allowed bond, then it must be bound to something. It cannot be unbound. Furthermore, if an instance of a species type is involved in listed bonds, only the listed bonds can fulfill the selection.

The attribute occurence , in combination with explicit, generic and undeclared bonds, provides for a complete boolean logic to select the context of binding sites. Note that occurence is only present on Bond. In order to forbid a binding site to be unbound, we create a generic bond with occurence set to required (to say that X cannot be free is equivalent to say that X had to be bound to something, whatever it is).

To exemplify this boolean logic, let's take the example of an instance of a species type X interacting with instances of species type A, B or C.

In the following code, X is not declared at all, therefore X can be bound to A, B, C or be unbound:

<multi:selector 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:id="selector1" />
  <multi:listOfSpeciesTypeStates>
    <multi:speciesTypeState 
                 id="speciesTypeStateA" 
                 speciesType="speciesTypeA"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateB" 
                 speciesType="speciesTypeB"
                 multi:minOccur="1" multi:maxOccur="1" />
  </multi:listOfSpeciesTypeStates>
</multi:selector>

With the following code, X can only be bound to A, or unbound:

<multi:selector 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:id="selector1" />
  <multi:listOfSpeciesTypeStates>
    <multi:speciesTypeState 
                 id="speciesTypeStateX" 
                 speciesType="speciesTypeX"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateA" 
                 speciesType="speciesTypeA"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateB" 
                 speciesType="speciesTypeB"
                 multi:minOccur="1" multi:maxOccur="1" />
  </multi:listOfSpeciesTypeStates>
  <multi:listOfBonds 
               xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
    <multi:bond multi:occurrence="allowed" >
      <multi:bindingSiteReference 
                   multi:speciesTypeState="speciesTypeStateX" />
      <multi:bindingSiteReference 
                   multi:speciesTypeState="speciesTypeStateA" />
    </multi:bond>
    <multi:bond multi:occurrence="allowed" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateB" />
    </multi:bond>
  </multi:listOfBonds>
</multi:selector>

The following code defines a generic bond with X, which mean that X can be bound to A, B or C, but has to be bound to something:

<multi:selector 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:id="selector1" />
  <multi:listOfSpeciesTypeStates>
    <multi:speciesTypeState 
                 id="speciesTypeStateX" 
                 speciesType="speciesTypeX"
                 multi:minOccur="1" multi:maxOccur="1" />
  </multi:listOfSpeciesTypeStates>
  <multi:listOfBonds xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1" >
    <multi:bond multi:occurrence="allowed" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
    </multi:bond>
  </multi:listOfBonds>
</multi:selector>

The following code says that X cannot be bound to C (The bond X-C is prohibited), and therefore has to be bound to A or B or unbound.

<multi:selector 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:id="selector1" />
  <multi:listOfSpeciesTypeStates>
    <multi:speciesTypeState 
                 id="speciesTypeStateX" 
                 speciesType="speciesTypeX"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateC" 
                 speciesType="speciesTypeC"
                 multi:minOccur="1" multi:maxOccur="1" />
  </multi:listOfSpeciesTypeStates>
  <multi:listOfBonds 
               xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
    <multi:bond multi:occurrence="prohibited" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateC" />
    </multi:bond>
  </multi:listOfBonds>
</multi:selector>


The following code says that X cannot be bound to C (The bond X-C is prohibited), however a generic bond specifies that X has to bound to something, therefore effectively to A or B. In this particular example, occurence on the generic bond can be set indifferently to allowed or required.

<multi:selector 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:id="selector1" />
  <multi:listOfSpeciesTypeStates>
    <multi:speciesTypeState 
                 id="speciesTypeStateX" 
                 speciesType="speciesTypeX"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateC" 
                 speciesType="speciesTypeC"
                 multi:minOccur="1" multi:maxOccur="1" />
  </multi:listOfSpeciesTypeStates>
  <multi:listOfBonds 
               xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1" >
    <multi:bond multi:occurrence="prohibited" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateC" />
    </multi:bond>
    <multi:bond multi:occurrence="allowed" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
    </multi:bond>
  </multi:listOfBonds>
</multi:selector>


The following case is overdetermined, since the impossibility for X to bind C is implicit in the restriction of its binding to A or B.

<multi:selector 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:id="selector1" />
  <multi:listOfSpeciesTypeStates>
    <multi:speciesTypeState 
                 id="speciesTypeStateX" 
                 speciesType="speciesTypeX"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateA" 
                 speciesType="speciesTypeA"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateB" 
                 speciesType="speciesTypeB"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateC" 
                 speciesType="speciesTypeC"
                 multi:minOccur="1" multi:maxOccur="1" />
  </multi:listOfSpeciesTypeStates>
  <multi:listOfBonds 
               xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
    <multi:bond multi:occurrence="allowed" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateA" />
    </multi:bond>
    <multi:bond multi:occurrence="allowed" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateB" />
    </multi:bond>
    <multi:bond multi:occurrence="prohibited" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateX" />
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateC" />
    </multi:bond>
  </multi:listOfBonds>
</multi:selector>

The boolean attributes connex and saturated precises the topology of a multimeric assembly of the same component (same species type state, that is same species type with the same values allowed for all their state features). One can then declare the component only once, and each of the bond types or unbound binding sites only once. Attribute saturated set to true means that all the contained species types which bindingSite is set to true have to be bound. Attribute connex means that all the instances of the species type state have to be connected within the same complex. The following example presents a tetramer of identical subunits.

<multi:selector 
             xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1"
             multi:id="selector1" />
  <multi:listOfSpeciesTypeStates>
    <multi:speciesTypeState 
                 id="speciesTypeStateA" 
                 speciesType="speciesTypeA"
                 multi:minOccur="4" multi:maxOccur="4">
      <multi:listOfContainedSpeciesTypes>
        <multi:containedSpeciesType multi:speciesTypeState="speciesTypeStateB" />
        <multi:containedSpeciesType multi:speciesTypeState="speciesTypeStateC" />
      </multi:listOfContainedSpeciesTypes>
    </multi:speciesTypeState>
    <multi:speciesTypeState 
                 id="speciesTypeStateB" 
                 speciesType="speciesTypeB"
                 multi:minOccur="1" multi:maxOccur="1" />
    <multi:speciesTypeState 
                 id="speciesTypeStateC" 
                 speciesType="speciesTypeC"
                 multi:minOccur="1" multi:maxOccur="1" />
  </multi:listOfSpeciesTypeStates>
  <multi:listOfBonds 
               xmlns:multi="http://www.sbml.org/sbml/level3/version1/multi/version1">
    <multi:bond multi:occurrence="allowed" >
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateB" />
      <multi:bindingSiteReference multi:speciesTypeState="speciesTypeStateC" />
    </multi:bond>
  </multi:listOfBonds>
</multi:selector>

The following graphs are examples of the various combinations possible of connex and saturated attributes.

connex="true" saturated="true"
connex="true" saturated="true"
connex="false" saturated="true"
connex="false" saturated="true"
connex="true" saturated="false"
connex="true" saturated="false"
connex="false" saturated="false"
connex="false" saturated="false"


Back to start page



Please use our issue tracking system for any questions or suggestions about this website. This page was last modified 14:34, 29 November 2010.