atomArray[el.atomArray]
A container for a list of atoms
A child of molecule and contains atom information. There are two strategies:
  • Create individual atom elements under atomArray (in any order). This gives the greatest flexibility but is the most verbose.
  • Create *Array attributes (e.g. of elementTypeArrayType under atomArray. This requires all arrays to be of identical lengths with explicit values for all atoms in every array. This is NOT suitable for complexType atom children such as atomParity or composite types such as xy2. It also cannot be checked as easily by schema- and schematron validation. The atomIDArray attribute is mandatory. It is allowed (though not yet recommended) to add *Array children such as floatArray

The attributes are directly related to the scalar attributes under atom which should be consulted for more info.

example

Example - these are exactly equivalent representations

<stm:list xmlns:stm="http://www.xml-cml.org/schema/stmml">
  <atomArray>
    <atom id="a1" elementType="O" hydrogenCount="1"/>
     <atom id="a2" elementType="N" hydrogenCount="1"/>
    <atom id="a3" elementType="C" hydrogenCount="3"/>
  </atomArray>
<!-- is equivalent to -->
  <atomArray
    atomID="a1 a2 a3"
    elementType="O N C"
    hydrogenCount="1 1 3"/>
</stm:list>
Content Model
(atom+|(stm:array)*)
id[att.id]
A unique ID for an element

This is not formally of type ID (an XML NAME which must start with a letter and contain only letters, digits and .-_:). It is recommended that IDs start with a letter, and contain no punctuation or whitespace. The function generate-id() in XSLT will generate semantically void unique IDs.

It is difficult to ensure uniqueness when documents are merged. We suggest namespacing IDs, perhaps using the containing elements as the base. Thus mol3:a1 could be a useful unique ID. However this is still experimental.

[xsd:string]
Pattern: [A-Za-z0-9_-]+(:[A-Za-z0-9_-]+)?
An attribute providing a unique ID for an element
title[att.title]
A title on an element.
No controlled value.

example

<action title="turn on heat" start="T09:00:00" convention="xsd"/>
convention[att.convention]
A string referencing a dictionary, units, convention or other metadata.

The namespace is optional but recommended where possible

Note: this convention is only used within STMML and related languages; it is NOT a generic URI.

example

<list>
<!-- dictRef is of namespaceRefType -->
  <scalar dictRef="chem:mpt">123</scalar>  
<!-- error -->
  <scalar dictRef="mpt23">123</scalar>  
</list>
[xsd:string]
Pattern: [A-Za-z][A-Za-z0-9_]*(:[A-Za-z][A-Za-z0-9_]*)?
A reference to a convention

There is no controlled vocabulary for conventions, but the author must ensure that the semantics are openly available and that there are mechanisms for implementation. The convention is inherited by all the subelements, so that a convention for molecule would by default extend to its bond and atom children. This can be overwritten if necessary by an explicit convention.

It may be useful to create conventions with namespaces (e.g. iupac:name). Use of convention will normally require non-STMML semantics, and should be used with caution. We would expect that conventions prefixed with "ISO" would be useful, such as ISO8601 for dateTimes.

There is no default, but the conventions of STMML or the related language (e.g. CML) will be assumed.

example

<bond convention="fooChem" order="-5"
   xmlns:fooChem="http://www.fooChem/conventions"/>
dictRef[att.dictRef]
A string referencing a dictionary, units, convention or other metadata.

The namespace is optional but recommended where possible

Note: this convention is only used within STMML and related languages; it is NOT a generic URI.

example

<list>
<!-- dictRef is of namespaceRefType -->
  <scalar dictRef="chem:mpt">123</scalar>  
<!-- error -->
  <scalar dictRef="mpt23">123</scalar>  
</list>
[xsd:string]
Pattern: [A-Za-z][A-Za-z0-9_]*(:[A-Za-z][A-Za-z0-9_]*)?

A reference to a dictionary entry.

Elements in data instances such as scalar may have a dictRef attribute to point to an entry in a dictionary. To avoid excessive use of (mutable) filenames and URIs we recommend a namespace prefix, mapped to a namespace URI in the normal manner. In this case, of course, the namespace URI must point to a real XML document containing entry elements and validated against STMML Schema.

Where there is concern about the dictionary becoming separated from the document the dictionary entries can be physically included as part of the data instance and the normal XPointer addressing mechanism can be used.

This attribute can also be used on dictionary elements to define the namespace prefix

example

<scalar dataType="xsd:float" title="surfaceArea" 
  dictRef="cmlPhys:surfArea" 
  xmlns:cmlPhys="http://www.xml-cml.org/dict/physical"
  units="units:cm2">50</scalar>

example

<stm:list xmlns:stm="http://www.xml-cml.org/schema/stmml">
  <stm:observation>
    <p>We observed <object count="3" dictRef="#p1"/> 
      constructing dwellings of different material</p>
  </stm:observation>
  <stm:entry id="p1" term="pig">
    <stm:definition>A domesticated animal.</stm:definition>
    <stm:description>Predators include wolves</stm:description>
    <stm:description class="scientificName">Sus scrofa</stm:description>
  </stm:entry>
</stm:list>
elementType[]
An array of elementTypes

Instances of this type will be used in array-style representation of atoms.

example

<atomArray elementType="O N S Pb"/>
XSD:LIST of elementTypeType
Allowed elementType values

The periodic table (up to element number 118. In addition the following strings are allowed:

  • Dummy. This does not correspond to a "real" atom and can support a point in space or within a chemical graph.

example

<atomArray>
  <atom id="a1" elementType="C"/>
  <atom id="a2" elementType="N"/>
  <atom id="a3" elementType="Pb"/>
  <atom id="a4" elementType="Dummy"/>
</atomArray>
UNION OF

Allowed values

  • Ac
  • Al
  • Ag
  • Am
  • Ar
  • As
  • At
  • Au
  • B
  • Ba
  • Bh
  • Bi
  • Be
  • Bk
  • Br
  • C
  • Ca
  • Cd
  • Ce
  • Cf
  • Cl
  • Cm
  • Co
  • Cr
  • Cs
  • Cu
  • Db
  • Dy
  • Er
  • Es
  • Eu
  • F
  • Fe
  • Fm
  • Fr
  • Ga
  • Gd
  • Ge
  • H
  • He
  • Hf
  • Hg
  • Ho
  • Hs
  • I
  • In
  • Ir
  • K
  • Kr
  • La
  • Li
  • Lr
  • Lu
  • Md
  • Mg
  • Mn
  • Mo
  • Mt
  • N
  • Na
  • Nb
  • Nd
  • Ne
  • Ni
  • No
  • Np
  • O
  • Os
  • P
  • Pa
  • Pb
  • Pd
  • Pm
  • Po
  • Pr
  • Pt
  • Pu
  • Ra
  • Rb
  • Re
  • Rf
  • Rh
  • Rn
  • Ru
  • S
  • Sb
  • Sc
  • Se
  • Sg
  • Si
  • Sm
  • Sn
  • Sr
  • Ta
  • Tb
  • Tc
  • Te
  • Th
  • Ti
  • Tl
  • Tm
  • U
  • Uun
  • Uuu
  • Uub
  • Uut
  • Uuq
  • Uup
  • Uuh
  • Uus
  • Uuo
  • V
  • W
  • Xe
  • Y
  • Yb
  • Zn
  • Zr
  • Dummy
[xsd:string]
Pattern: [A-Za-z]+:[A-Za-z][A-Za-z0-9\-]+
Almost mandatory. see elementType
count[]
An array of integers

An array of integers; for re-use by other schemas

Not machine-validatable

example

<atomArray xmlns="http://www.xml-cml.org/schema/cml2/core"
  hydrogenCount="3 1 0 2"/>
XSD:LIST of xsd:integer
See count
formalCharge[]
An array of integers

An array of integers; for re-use by other schemas

Not machine-validatable

example

<atomArray xmlns="http://www.xml-cml.org/schema/cml2/core"
  hydrogenCount="3 1 0 2"/>
XSD:LIST of xsd:integer
See formalCharge
hydrogenCount[]
An array of integers

An array of integers; for re-use by other schemas

Not machine-validatable

example

<atomArray xmlns="http://www.xml-cml.org/schema/cml2/core"
  hydrogenCount="3 1 0 2"/>
XSD:LIST of xsd:integer
See hydrogenCount
nonHydrogenCount[]
An array of integers

An array of integers; for re-use by other schemas

Not machine-validatable

example

<atomArray xmlns="http://www.xml-cml.org/schema/cml2/core"
  hydrogenCount="3 1 0 2"/>
XSD:LIST of xsd:integer
See nonHydrogenCount
isotope[]
An array of floats

An array of floats or other real numbers. Not used in STM Schema, but re-used by CML and other languages.

example

<atomArray xmlns="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 3.4 5.6"/>
XSD:LIST of xsd:decimal
See isotope
occupancy[]
An array of floats

An array of floats or other real numbers. Not used in STM Schema, but re-used by CML and other languages.

example

<atomArray xmlns="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 3.4 5.6"/>
XSD:LIST of xsd:decimal
See occupancy
x2[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See x2
x3[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See x3
xFract[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See xFract
y2[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See y2
y3[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See y3
yFract[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See yFract
z3[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See z3
zFract[]
An array of coordinateComponents for a single coordinate.

An array of coordinateComponents for a single coordinate where these all refer to an X-coordinate (NOT x,y,z) Instances of this type will be used in array-style representation of 2-D or 3-D coordinates.

Currently no machine validation

Currently not used in STMML, but re-used by CML (see example)

example

<cml:atomArray 
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
XSD:LIST of xsd:decimal
See zFract
atomID[]
An array of atomRefs

The atomRefs cannot be schema- or schematron-validated. Instances of this type will be used in array-style representation of bonds and atomParitys. It can also be used for arrays of atomIDTypes such as in complex setereochemistry, geometrical definitions, atom groupings, etc.

example

<molecule id="m1">
  <atomArray atomID="a2 a4 a6"  
      elementType="O N S"/>
</molecule>
XSD:LIST of atomRefType
A reference to an existing atom

example

<molecule id="m1">
  <atomArray>
    <atom id="a1"/>
  </atomArray>
  <electron id="e1" atomRef="a1"/>
</molecule>
[xsd:string]
Pattern: *[A-Za-z_][A-Za-z0-9\-:_]*\s*
See atomID
ref[att.ref]
A reference to an existing element

A reference to an existing element in the document. The target of the ref attribute must exist. The test for validity will normally occur in the element's appinfo

Any DOM Node created from this element will normally be a reference to another Node, so that if the target node is modified a the dereferenced content is modified. At present there are no deep copy semantics hardcoded into the schema.

BASE: idType
A unique ID for an element

This is not formally of type ID (an XML NAME which must start with a letter and contain only letters, digits and .-_:). It is recommended that IDs start with a letter, and contain no punctuation or whitespace. The function generate-id() in XSLT will generate semantically void unique IDs.

It is difficult to ensure uniqueness when documents are merged. We suggest namespacing IDs, perhaps using the containing elements as the base. Thus mol3:a1 could be a useful unique ID. However this is still experimental.

[xsd:string]
Pattern: [A-Za-z0-9_-]+(:[A-Za-z0-9_-]+)?
A reference to an element of given type

ref modifies an element into a reference to an existing element of that type within the document. This is similar to a pointer and it can be thought of a strongly typed hyperlink. It may also be used for "subclassing" or "overriding" elements.

example

<cml>
  <molecule id="m1">
    <atomArray>
      <atom elementType="N"/>
      <atom elementType="O"/>
    </atomArray>
  </molecule>
  <html:p>The action of <molecule ref="#m1"/> on cardiac muscle ...</html:p>
</cml>