Internet Magazine 2003 October/INTERNET108.ISO/pc/software/windows/building/xmlspy/xmlspyentcomplete5.exe/Data1.cab/_6DD88140F1B045EE95C893779462ABCE

Extensible Markup Language | 2003-02-13 | 198.5 KB | 5,014 lines

<?xml version="1.0" encoding="utf-8"?><xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.xml-cml.org/schema/cml2/core" xmlns:stm="http://www.xml-cml.org/schema/stmml" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:val="http://www.w3.org/1999/XSL/TransformX" targetNamespace="http://www.xml-cml.org/schema/cml2/core" elementFormDefault="qualified">

<!-- cannot always get this to work; it seems to be relative
to instance directory rather than schema directory.
(This was a known Xerces bug - requires entityResolver ...)

   <xsd:include schemaLocation="cmlCore0.xsd"/>

   <xsd:include schemaLocation="angleUnitsType.xsd"/>
   <xsd:include schemaLocation="atomRefs2.xsd"/>
   <xsd:include schemaLocation="atomRefs3.xsd"/>
   <xsd:include schemaLocation="atomRefs4.xsd"/>
   <xsd:include schemaLocation="atomRefArrayType.xsd"/>
   <xsd:include schemaLocation="atomIDType.xsd"/>
   <xsd:include schemaLocation="countType.xsd"/>
   <xsd:include schemaLocation="elementTypeType.xsd"/>
   <xsd:include schemaLocation="elementTypeArrayType.xsd"/>
   <xsd:include schemaLocation="formalChargeType.xsd"/>
   <xsd:include schemaLocation="hydrogenCountType.xsd"/>
   <xsd:include schemaLocation="isotopeType.xsd"/>
   <xsd:include schemaLocation="lengthType.xsd"/>
   <xsd:include schemaLocation="nonHydrogenCountType.xsd"/>
   <xsd:include schemaLocation="nonNegativeAngleType.xsd"/>
   <xsd:include schemaLocation="nonNegativeNumber.xsd"/>
   <xsd:include schemaLocation="occupancyType.xsd"/>
   <xsd:include schemaLocation="orderType.xsd"/>
   <xsd:include schemaLocation="orderArrayType.xsd"/>
   <xsd:include schemaLocation="spacegroupType.xsd"/>
   <xsd:include schemaLocation="stereoType.xsd"/>
   <xsd:include schemaLocation="stringBuiltinType.xsd"/>
   <xsd:include schemaLocation="torsionAngleType.xsd"/>


   <xsd:include schemaLocation="angle.xsd"/>
   <xsd:include schemaLocation="atom.xsd"/>
   <xsd:include schemaLocation="atomArray.xsd"/>
   <xsd:include schemaLocation="atomParity.xsd"/>
   <xsd:include schemaLocation="bond.xsd"/>
   <xsd:include schemaLocation="bondArray.xsd"/>
   <xsd:include schemaLocation="cml.xsd"/>
   <xsd:include schemaLocation="crystal.xsd"/>
   <xsd:include schemaLocation="electron.xsd"/>
   <xsd:include schemaLocation="formula.xsd"/>
   <xsd:include schemaLocation="length.xsd"/>
   <xsd:include schemaLocation="molecule.xsd"/>
   <xsd:include schemaLocation="name.xsd"/>
   <xsd:include schemaLocation="reaction.xsd"/>
   <xsd:include schemaLocation="sequence.xsd"/>
   <xsd:include schemaLocation="bondStereo.xsd"/>
   <xsd:include schemaLocation="symmetry.xsd"/>
   <xsd:include schemaLocation="torsion.xsd"/>
-->
  <!-- the head of the schema -->
<xsd:annotation>
  <xsd:documentation xml:lang="en">
    <div class="heading">WARNING</div>
    <div class="curation">
    <p>This document has been automatically generated from the XSD Schema, using XSLT stylesheets. Schemas are complex and it is
    not easy to produce the "best" view. It is possible that some information is included twice and (possibly)
    some is omitted. <b>The Schema itself should always be taken as definitive</b></p>
    </div>
  </xsd:documentation>
</xsd:annotation>
<xsd:annotation>
  <xsd:documentation xml:lang="en">
    <div class="heading">Curation</div>
    <div class="curation">
      <ul>
        <li> Created by hand starting from output of dtd2xsd.
      editing to enhance datatypes and content models, etc.
      2001-09-21</li>
        <li>First draft 2001-10-02</li>
        <li>Next draft 2002-09-20 (sic)</li>
        <li>Next draft 2002-11-20 (CML 2.0, on website)</li>
        <li>Submitted to JCICS 2002-12-01</li>
        <li>changed #REQUIRED to #IMPLIED on various id attributes 2002-12-21</li>
        <li>added property and propertyList 2002-12-29</li>
        <li>added identifier Element 2002-12-29</li>
        <li>added name Element 2002-12-29</li>
        <li>revision submitted to JCICS 2003-01-31 (CML V2.1)</li>
      </ul>
      <p>This schema represents a fundamental core for future CML. Some of the earlier
      elements may be obsolete, and some will be moved into new CML schemaspaces. The
      vocabulary is essentially unaltered but the syntax is simpler and the validation
      is more powerful.</p>
    </div>
  </xsd:documentation>
</xsd:annotation>
<xsd:annotation>
  <xsd:documentation xml:lang="en">
    <div class="heading">XSL validation</div>
    <div class="curation">
      <p>There is a prototypic validation procedure based on XSLT stylesheets with namespace prefix <tt>val</tt>.
      The syntax is XSL. The only example occurs in <tt>bond</tt> at present. Some global <tt>val</tt> resources will be defined
      in this section.</p>
    </div>
    <pre>

    </pre>
  </xsd:documentation>
  <xsd:appinfo>
    <val:key names="atoms" match="atom" use="@id"/>
    <val:key names="bonds" match="bond" use="@id"/>
    <val:key names="molecules" match="molecule" use="@id"/>

    <val:template name="error">
      <val:param name="error"/>
      <val:message>XSLT validation error: <val:value-of select="$error"/></val:message>
      <val:element name="error">
XSLT validation error: <val:value-of select="$error"/>
      </val:element>
    </val:template>
  </xsd:appinfo>
</xsd:annotation>


 <!-- attributes from STMML -->
  <!-- stmml attributes in CML -->
  <xsd:attributeGroup name="convention" id="attGp.convention">
  <xsd:attribute id="att.convention" name="convention" type="namespaceRefType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A reference to a convention</div>
        <div class="description">
          <p>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 <tt>molecule</tt> would by default extend to its <tt>bond</tt> and <tt>atom</tt> children. This can be overwritten
    if necessary by an explicit <tt>convention</tt>.</p>
    <p>It may be useful to create conventions with namespaces (e.g. <tt>iupac:name</tt>).
    Use of <tt>convention</tt> 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.</p>
    <p>There is no default, but the conventions of STMML or the related language (e.g. CML) will be assumed.</p>
        </div>

        <div class="example">
          <pre/>
        </div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>

  <xsd:attributeGroup id="attGp.delimiter" name="delimiter">
  <xsd:attribute id="att.delimiter" name="delimiter" type="delimiterType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A delimiter character for arrays and matrices</div>
        <div class="description">By default array components ('elements' in the non-XML sense) are whitespace-separated.
        This fails for components with embedded whitespace or missing completely:
        <pre>
        Example:
        In the protein database ' CA' and 'CA' are different atom types, and and array could be:
        <array delimiter="/" dictRef="pdb:atomTypes">/ N/ CA/CA/ N/</array>
        </pre>
        Note that the array starts and ends with the delimiter, which must be chosen to avoid accidental use. There is currently no syntax for escaping delimiters.
        </div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


  <xsd:attributeGroup id="attGp.dataType" name="dataType">
  <xsd:attribute id="att.dataType" name="dataType" type="dataTypeType" default="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">The dataType of an (simple) element or attribute</div>
        <div class="description"/>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


  <xsd:attributeGroup name="dictRef" id="attGp.dictRef">
  <xsd:attribute id="att.dictRef" name="dictRef" type="namespaceRefType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">
          <p>A reference to a dictionary entry.</p>
        </div>

        <div class="description">
          <p>Elements in data instances such as <a href="el.scalar">scalar</a> may have a
 <tt>dictRef</tt> 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
 <a href="el.entry">entry</a> elements and validated against STMML Schema.</p>
 <p>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.</p>
 <p>This attribute can also be used on <a href="el.dictionary">dictionary</a>
 elements to define the namespace prefix</p>
        </div>

        <div class="example">
         <pre><stmml title="dictRef example">

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

        <div class="example">
   <pre><stmml title="dictRef example 2">
<stm:list xmlns:stm="http://www.xml-cml.org/schema/stmml">
  <stm:observation>
    <p>We observed <object count="3" dictRef="foo: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>
</stmml>
</pre>
        </div>
       </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>
  <xsd:attributeGroup id="attGp.errorBasis" name="errorBasis">
  <xsd:attribute id="att.errorBasis" name="errorBasis" type="errorBasisType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary"/>
        <div class="description"/>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


  <xsd:attributeGroup id="attGp.errorValue" name="errorValue">
  <xsd:attribute id="att.errorValue" name="errorValue" type="errorValueType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary"/>
        <div class="description"/>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


  <xsd:attributeGroup id="attGp.id" name="id">
  <xsd:attribute id="att.id" name="id" type="idType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">An attribute providing a unique ID for an element</div>
        <div class="description">
        </div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


  <xsd:attributeGroup id="attGp.mandatoryId" name="mandatoryId">
  <xsd:attribute id="att.mandatoryId" name="id" type="idType" use="required">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">An attribute providing a mandatory unique ID for an element</div>
        <div class="description">This is a horrible hack. It should be possible to add 'required' to
    the attributeGroup where used... (Maybe it is and I am still fighting Schema Wars)
        </div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


  <xsd:attributeGroup id="attGp.max" name="max">
  <xsd:attribute id="att.max" name="max" type="maxType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary"/>
        <div class="description"/>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>

  <xsd:attributeGroup id="attGp.min" name="min">
  <xsd:attribute id="att.min" name="min" type="minType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary"/>
        <div class="description"/>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>

  <xsd:attributeGroup id="attGp.ref" name="ref">
<xsd:attribute id="att.ref" name="ref" type="refType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A reference to an element of given type</div>
      <div class="description">
       <p><tt>ref</tt> 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.
       </p>
   </div>

   <div class="example">
     <pre>
<stmml title="ref 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>
</stmml>

     </pre>
   </div>
   </xsd:documentation>
  </xsd:annotation>
</xsd:attribute>
</xsd:attributeGroup>

  <xsd:attributeGroup id="attGp.size" name="size">
  <xsd:attribute id="att.size" name="size" type="sizeType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">The size of an array, matrix, list, etc.</div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


  <xsd:attributeGroup id="attGp.title" name="title">
  <xsd:attribute id="att.title" name="title" type="xsd:string">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A title on an element.</div>
        <div class="description">No controlled value.</div>
        <div class="example">
          <pre><stmml title="title example">
<action title="turn on heat" start="T09:00:00" convention="xsd"/>
</stmml>
</pre>
        </div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>

  <xsd:attributeGroup id="attGp.units" name="units">
  <xsd:attribute id="att.units" name="units" type="unitsType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">Scientific units on an element.</div>
        <div class="description">These must be taken from a dictionary of units. There should be some mechanism for validating the type of the units against the possible values of the element.</div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>



  <xsd:attributeGroup name="tit_id_convGroup" id="attGp.tit_id_convGroup">
  <xsd:annotation>
    <xsd:documentation>
<!--
        <div class="summary">An group of attribute applicable to most STMML elements</div>
        <div class="description"><p>A group of attributes applicable to most STMML elements. It is
        recommended that IDs are used widely. Titles have no semantics but
        are useful for humans (e.g. a bond angle could be labelled "ortho"
        or "gamma". Coventions are inherited by subelements; the default is the
        current schema.</p>
         </div>
-->
    </xsd:documentation>
  </xsd:annotation>

  <xsd:attributeGroup ref="title"/>
  <xsd:attributeGroup ref="id"/>
  <xsd:attributeGroup ref="convention"/>

</xsd:attributeGroup>

  <xsd:attributeGroup name="tit_id_conv_dictGroup" id="attGp.tit_id_conv_dictGroup">
  <xsd:annotation>
    <xsd:documentation>
<!--      <div class="summary">Addition of the <tt>dictRef</tt> attribute to the <tt>tit_id_conv</tt> group.</div>-->
    </xsd:documentation>
  </xsd:annotation>
  <xsd:attributeGroup ref="tit_id_convGroup"/>
  <xsd:attributeGroup ref="dictRef"/>
</xsd:attributeGroup>



 <!-- types from STMML -->
  <!-- stmml types in CML -->

<xsd:simpleType name="coordinateComponentArrayType" id="st.coordinateComponentArrayType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">An array of coordinateComponents for a single coordinate.</div>
      <div class="description">
        <p>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.</p>
      <p>Currently no machine validation</p>
      <p>Currently not used in STMML, but re-used by CML (see example)</p>
      </div>
      <div class="example">
        <pre>
<stmml title="coordinateComponentArrayType">

<cml:atomArray
  xmlns:cml="http://www.xml-cml.org/schema/cml2/core"
  x2="1.2 2.3 4.5 6.7"/>
  </stmml>


        </pre>
      </div>
     </xsd:documentation>
   </xsd:annotation>
   <xsd:list itemType="xsd:float"/>
</xsd:simpleType>

  <xsd:simpleType name="coordinate2Type" id="st.coordinate2Type">
   <xsd:annotation>
     <xsd:documentation>
        <div class="summary">An x/y coordinate pair</div>
         <div class="description">
         <p>An x/y coordinate pair consisting of
         two real numbers, separated by whitespace or a comma.
         In arrays and matrices, it may be useful to set a separate delimiter</p>
      </div>
      <div class="example">
        <pre>
<stmml title="coordinate2Type example">
<list>
  <array dataType="xsd:decimal"
      >1.2,3.4   3.2,4.5   6.7,23.1 </array>
  <array delimiter="/" dataType="xsd:decimal"
      >/1.2 3.4/3.2 4.5/6.7 23.1/</array>
</list>
</stmml>

        </pre>
       </div>
     </xsd:documentation>
   </xsd:annotation>
   <xsd:restriction base="xsd:string">
      <xsd:pattern value="\s*([-]|[+])?\d*\.?\d*(\s+|[,])([-]|[+])?\d*\.?\d*\s*"/>
   </xsd:restriction>
</xsd:simpleType>


   <xsd:simpleType name="coordinate3Type" id="st.coordinate3Type">
      <xsd:annotation>
        <xsd:documentation>
          <div class="summary">An x/y/z coordinate triple</div>

          <div class="description">
            <p>An x/y/z coordinate triple consisting of
            three real numbers, separated by whitespace or commas.
            In arrays and matrices, it may be useful to set a separate delimiter</p>
         </div>

         <div class="example">
           <pre>
<stmml title="coordinate3Type example">
<list>
  <array dataType="xsd:decimal">1.2,3.4,1.2
    3.2,4.5,7.3   6.7,23.1,5.6 </array>
  <array delimiter="/" dataType="xsd:decimal"
  >/1.2 3.4 3.3/3.2 4.5 4.5/6.7 23.1 5.6/</array>
</list>
</stmml>


           </pre>
         </div>
        </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:string">
         <xsd:pattern value="\s*([-]|[+])?\d*\.?\d*(\s+|[,])([-]|[+])?\d*\.?\d*(\s+|[,])([-]|[+])?\d*\.?\d*\s*"/>
<!--         <xsd:pattern value="\s*([-]|[+])?\d*\.?\d*  (\s*[,|\s+]\s*([-]|[+])?\d*\.?\d*){2}\s*"/>-->
      </xsd:restriction>
   </xsd:simpleType>

     <xsd:simpleType name="countType" id="st.countType">
      <xsd:annotation>
        <xsd:documentation>
           <div class="summary">
            <p>A count multiplier for an element</p>
         </div>

          <div class="description">
            <p>Many elements represent objects which can occur an arbitrary number of times in a scientific context.
            Examples are
            <tt>action</tt>, <tt>object</tt> or <tt>molecule</tt>s.</p>
         </div>

         <div class="example">
           <pre>
<stmml title="countType example">

<list>
<object title="frog" count="10"/>
<action title="step3" count="3">
  <p>Add 10 ml reagent</p>
</action>
</list>
</stmml>

           </pre>
         </div>
        </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:nonNegativeInteger">
      </xsd:restriction>
   </xsd:simpleType>



   <xsd:simpleType name="dataTypeType" id="st.dataTypeType">
      <xsd:annotation>
        <xsd:documentation>
          <div class="summary">
           <p>an enumerated type for all builtin allowed dataTypes in STM</p>
         </div>

         <div class="description">
            <p>
               <tt>dataTypeType</tt> represents an enumeration of allowed dataTypes
               (at present identical with those in XML-Schemas (Part2- datatypes).
               This means that implementers should be able to use standard XMLSchema-based
               tools for validation without major implementation problems.
            </p>
            <p>It will often be used an an attribute on
            <a href="el.scalar">scalar</a>,
            <a href="el.array">array</a> or
            <a href="el.matrix">matrix</a>
            elements.</p>
         </div>

         <div class="example">
           <pre>
<stmml title="dataType example">

<list xmlns="http://www.xml-cml.org/schema/cml2/core">
  <scalar dataType="xsd:boolean" title="she loves me">true</scalar>
  <scalar dataType="xsd:float" title="x">23.2</scalar>
  <scalar dataType="xsd:duration" title="egg timer">PM4</scalar>
  <scalar dataType="xsd:dateTime" title="current data and time">2001-02-01:00:30</scalar>
  <scalar dataType="xsd:time" title="wake up">06:00</scalar>
  <scalar dataType="xsd:date" title="where is it">1752-09-10</scalar>
  <scalar dataType="xsd:anyURI" title="CML site">http://www.xml-cml.org/</scalar>
  <scalar dataType="xsd:QName" title="CML atom">cml:atom</scalar>
  <scalar dataType="xsd:normalizedString" title="song">the mouse ran up the clock</scalar>
  <scalar dataType="xsd:language" title="UK English">en-GB</scalar>
  <scalar dataType="xsd:Name" title="atom">atom</scalar>
  <scalar dataType="xsd:ID" title="XML ID">_123</scalar>
  <scalar dataType="xsd:integer" title="the answer">42</scalar>
  <scalar dataType="xsd:nonPositiveInteger" title="zero">0</scalar>
</list>
</stmml>

           </pre>
         </div>
        </xsd:documentation>
      </xsd:annotation>
  <xsd:union>
    <xsd:simpleType>
      <xsd:restriction base="xsd:string">
        <xsd:enumeration value="xsd:string"/>
       <xsd:enumeration value="xsd:boolean"/>
       <xsd:enumeration value="xsd:float"/>
       <xsd:enumeration value="xsd:double"/>
       <xsd:enumeration value="xsd:decimal"/>
       <xsd:enumeration value="xsd:duration"/>
       <xsd:enumeration value="xsd:dateTime"/>
       <xsd:enumeration value="xsd:time"/>
       <xsd:enumeration value="xsd:date"/>
       <xsd:enumeration value="xsd:gYearMonth"/>
       <xsd:enumeration value="xsd:gYear"/>
       <xsd:enumeration value="xsd:gMonthDay"/>
       <xsd:enumeration value="xsd:gDay"/>
       <xsd:enumeration value="xsd:gMonth"/>
       <xsd:enumeration value="xsd:hexBinary"/>
       <xsd:enumeration value="xsd:base64Binary"/>
       <xsd:enumeration value="xsd:anyURI"/>
       <xsd:enumeration value="xsd:QName"/>
       <xsd:enumeration value="xsd:NOTATION"/>
       <xsd:enumeration value="xsd:normalizedString"/>
       <xsd:enumeration value="xsd:token"/>
       <xsd:enumeration value="xsd:language"/>
       <xsd:enumeration value="xsd:IDREFS"/>
       <xsd:enumeration value="xsd:ENTITIES"/>
       <xsd:enumeration value="xsd:NMTOKEN"/>
       <xsd:enumeration value="xsd:NMTOKENS"/>
       <xsd:enumeration value="xsd:Name"/>
       <xsd:enumeration value="xsd:NCName"/>
       <xsd:enumeration value="xsd:ID"/>
       <xsd:enumeration value="xsd:IDREF"/>
       <xsd:enumeration value="xsd:ENTITY"/>
       <xsd:enumeration value="xsd:integer"/>
       <xsd:enumeration value="xsd:nonPositiveInteger"/>
       <xsd:enumeration value="xsd:negativeInteger"/>
       <xsd:enumeration value="xsd:long"/>
       <xsd:enumeration value="xsd:int"/>
       <xsd:enumeration value="xsd:short"/>
       <xsd:enumeration value="xsd:byte"/>
       <xsd:enumeration value="xsd:nonNegativeInteger"/>
       <xsd:enumeration value="xsd:unsignedLong"/>
       <xsd:enumeration value="xsd:unsignedInt"/>
       <xsd:enumeration value="xsd:unsignedShort"/>
       <xsd:enumeration value="xsd:unsignedByte"/>
       <xsd:enumeration value="xsd:positiveInteger"/>
     </xsd:restriction>
   </xsd:simpleType>
   <xsd:simpleType>
     <xsd:restriction base="xsd:QName">
     </xsd:restriction>
    </xsd:simpleType>
  </xsd:union>
</xsd:simpleType>


<xsd:simpleType name="delimiterType" id="st.delimiterType">
   <xsd:annotation>
     <xsd:documentation>
       <div class="summary">A non-whitespace character used in arrays to separate components</div>
      <div class="description">
        <p>Some STMML elements (such as <a href="el.array">array</a>) have
        content representing concatenated values. The default separator is
        whitespace (which can be normalised) and this should be used whenever
        possible. However in some cases the values are empty, or contain whitespace or other
        problematic punctuation, and a delimiter is required.</p>
        <p>Note that the content string MUST start and end with the delimiter so
        there is no ambiguity as to what the components are. Only printable
        characters from the ASCII character set should be used, and character
        entities should be avoided.</p>
        <p>When delimiters are used to separate precise whitespace this should always
        consist of spaces and not the other allowed whitespace characters
        (newline, tabs, etc.). If the latter are important it is probably best to redesign
        the application.</p>
      </div>
      <div class="example">
        <pre>
<stmml title="delimiter example">

<array size="4"  dataType="xsd:string" delimiter="|">|A|B12||D and   E|</array>
</stmml>


 <em>The values in the array are</em>
  "A", "B12", "" (empty string) and "D and   E"
 <em>note the spaces</em>
        </pre>
      </div>
     </xsd:documentation>
   </xsd:annotation>
   <xsd:restriction base="xsd:string">
   </xsd:restriction>
</xsd:simpleType>

  <xsd:simpleType name="errorBasisType" id="st.errorBasisType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">The basis of an error value</div>
      <div class="description">
        <p>Errors in values can be of several types and this simpleType
         provides a small controlled vocabulary</p>
      </div>

      <div class="example">
         <pre><stmml title="scalar example">
<scalar
    dataType="xsd:decimal"
    errorValue="1.0"
    errorBasis="observedStandardDeviation"
    title="body weight"
    dictRef="zoo:bodywt"
    units="units:g">34.3</scalar>
    </stmml>
</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:string">
    <xsd:enumeration value="observedRange"/>
    <xsd:enumeration value="observedStandardDeviation"/>
    <xsd:enumeration value="observedStandardError"/>
    <xsd:enumeration value="estimatedStandardDeviation"/>
    <xsd:enumeration value="estimatedStandardError"/>
  </xsd:restriction>
</xsd:simpleType>

  <xsd:simpleType name="errorValueType" id="st.errorValueType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">An observed or calculated estimate of the error in the value of a numeric quantity</div>
      <div class="description">
        <p>An observed or calculated estimate of the error in the value of a numeric quantity.
.        It should be ignored for dataTypes such as URL, date or string.
         The statistical basis of the <tt>errorValueType</tt> is not defined - it could be a range,
         an estimated standard deviation, an observed standard error, etc. This information can
         be added through <a href="at.errorBasisType">errorBasisType</a>.</p>
      </div>
      <div class="example">
        <pre><stmml title="scalar example">
<scalar
    dataType="xsd:decimal"
    errorValue="1.0"
    errorBasis="observedStandardDeviation"
    title="body weight"
    dictRef="zoo:bodywt"
    units="units:g">34.3</scalar>
    </stmml>
</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:float"/>
</xsd:simpleType>

  <xsd:simpleType name="idType" id="st.idType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A unique ID for an element</div>
      <div class="description">
      <p>This is not formally
          of type ID (an XML NAME which must start with a letter and contain only letters,
          digits and <tt>.-_:</tt>). It is recommended that IDs start with a letter,
          and contain no punctuation or whitespace. The function <tt>generate-id()</tt>
          in XSLT will generate semantically void unique IDs.</p>
          <p>It is difficult to ensure uniqueness when documents are merged. We suggest
          namespacing IDs, perhaps using the containing elements as the base.
          Thus <tt>mol3:a1</tt> could be a useful unique ID.
          However this is still experimental.</p>
         </div>
      </xsd:documentation>
     </xsd:annotation>
   <xsd:restriction base="xsd:string">
     <xsd:pattern value="([A-Za-z][A-Za-z0-9_-]*:)?[A-Za-z][A-Za-z0-9_\-\.]*"/>
   </xsd:restriction>
</xsd:simpleType>

   <xsd:simpleType name="floatArrayType" id="st.floatArrayType">
     <xsd:annotation>
       <xsd:documentation>
         <div class="summary">An array of floats</div>

         <div class="description">
            <p>An array of floats or other real numbers.
            Not used in STM Schema, but re-used by CML and other languages.
            </p>
         </div>

        <div class="example">
           <pre/>
         </div>
        </xsd:documentation>
      </xsd:annotation>
      <xsd:list itemType="xsd:float"/>
   </xsd:simpleType>

  <xsd:simpleType name="integerArrayType" id="st.integerArrayType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">An array of integers</div>
      <div class="description">
        <p>An array of integers; for re-use by other schemas</p>
        <p>Not machine-validatable</p>
      </div>
      <div class="example">
        <pre>
<stmml title="integerArray type">

<atomArray xmlns="http://www.xml-cml.org/schema/cml2/core"
  hydrogenCount="3 1 0 2"/>
  </stmml>

        </pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:list itemType="xsd:integer"/>
</xsd:simpleType>

   <xsd:simpleType name="maxType" id="st.maxType">
    <xsd:annotation>
       <xsd:documentation>
          <div class="summary">The maximum INCLUSIVE value of a quantity</div>
          <div class="description"><p>The maximum INCLUSIVE value of a sortable quantity such as
          numeric, date or string. It should be ignored for dataTypes such as URL.
          The use of <tt>min</tt> and
        <tt>max</tt> attributes can be used to give a range for the quantity.
       The statistical basis of this range is not defined. The value of <tt>max</tt>
       is usually an observed
       quantity (or calculated from observations). To restrict a value, the <tt>
       maxExclusive</tt> type in a dictionary should be used.</p>
       <p>The type of the maximum is the same as the quantity to which it refers - numeric,
       date and string are currently allowed</p>
       </div>
       <div class="example"><pre><stmml title="maxType example">

<scalar dataType="xsd:float" max="20" min="12">15</scalar>
</stmml>
</pre></div>
      </xsd:documentation>
    </xsd:annotation>
    <xsd:restriction base="xsd:string">
    </xsd:restriction>
 </xsd:simpleType>

 <xsd:attribute name="maxValue" type="maxType"/>

  <xsd:simpleType name="matrixType" id="st.matrixType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">Allowed <a href="el.matrix">matrix</a> types</div>
       <div class="description"><p>Allowed <tt>matrix</tt> types.
       These are mainly square matrices</p></div>
      <div class="example">
      <pre>
<stmml title="matrix example">

<matrix id="m1" title="mattrix-1" dictRef="foo:bar"
  rows="3" columns="3" dataType="xsd:decimal"
  delimiter="|" matrixType="squareSymmetric" units="unit:m"
  >|1.1|1.2|1.3|1.2|2.2|2.3|1.3|2.3|3.3|</matrix>
  </stmml>

      </pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:union>
  <xsd:simpleType>
  <xsd:restriction base="xsd:string">
      <xsd:enumeration value="rectangular"/>
      <xsd:enumeration value="square"/>
      <xsd:enumeration value="squareSymmetric"/>
      <xsd:enumeration value="squareAntisymmetric"/>
      <xsd:enumeration value="diagonal">
        <xsd:annotation>
          <xsd:documentation>
            <div class="description">Symmetric. Elements are zero except on the diagonal</div>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>
      <xsd:enumeration value="upperTriangular">
        <xsd:annotation>
          <xsd:documentation>
            <div class="description">Square. Elements are zero below the diagonal
            <pre>
1 2 3 4
0 3 5 6
0 0 4 8
0 0 0 2
      </pre>
            </div>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>
      <xsd:enumeration value="lowerTriangular">
        <xsd:annotation>
          <xsd:documentation>
            <div class="description">Symmetric. Elements are zero except on the diagonal</div>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>
      <xsd:enumeration value="unitary"/>
      <xsd:enumeration value="rowEigenvectors"/>
      <xsd:enumeration value="rotation22"/>
      <xsd:enumeration value="rotationTranslation32"/>
      <xsd:enumeration value="homogeneous33"/>
      <xsd:enumeration value="rotation33"/>
      <xsd:enumeration value="rotationTranslation43"/>
      <xsd:enumeration value="homogeneous44"/>
      <xsd:enumeration value="square"/>
   </xsd:restriction>
  </xsd:simpleType>
  <xsd:simpleType>
    <xsd:restriction base="namespaceRefType">
      <xsd:annotation>
        <xsd:documentation>
          <div class="summary">User-defined matrix-type</div>
          <div class="description">This definition must be by reference to a namespaced dictionary entry.</div>
        </xsd:documentation>
     </xsd:annotation>
    </xsd:restriction>
  </xsd:simpleType>
  </xsd:union>
</xsd:simpleType>

    <xsd:simpleType name="metadataType" id="md.metadataType">
        <xsd:annotation>
          <xsd:documentation>
            <div class="summary">The name of the metadata</div>
            <div class="description">Metadata consists of name-value pairs (value is in the "content" attribute). The names are from a semi-restricted vocabulary, mainly Dublin Core. The content is unrestricted. The order of metadata has no implied semantics at present.
            </div>
          </xsd:documentation>
        </xsd:annotation>
      <xsd:restriction base="xsd:string">
      <xsd:enumeration value="dc:coverage">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">The extent or scope of the
            content of the resource.</div>

            <div class="description">Coverage will typically include
            spatial location (a place name or geographic
            coordinates), temporal period (a period label, date, or
            date range) or jurisdiction (such as a named
            administrative entity). Recommended best practice is to
            select a value from a controlled vocabulary (for
            example, the Thesaurus of Geographic Names [TGN]) and
            that, where appropriate, named places or time periods
            be used in preference to numeric identifiers such as
            sets of coordinates or date ranges.
            </div>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:description">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">An account of the content of the
            resource.</div>

            <div class="description">Description may include but is not
            limited to: an abstract, table of contents, reference
            to a graphical representation of content or a free-text
            account of the content.
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:identifier">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">An unambiguous reference to the
            resource within a given context.</div>

            <div class="description">Recommended best practice is to
            identify the resource by means of a string or number
            conforming to a formal identification system. Example
            formal identification systems include the Uniform
            Resource Identifier (URI) (including the Uniform
            Resource Locator (URL)), the Digital Object Identifier
            (DOI) and the International Standard Book Number
            (ISBN).
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:format">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">The physical or digital
            manifestation of the resource.</div>

            <div class="description">Typically, Format may include the
            media-type or dimensions of the resource. Format may be
            used to determine the software, hardware or other
            equipment needed to display or operate the resource.
            Examples of dimensions include size and duration.
            Recommended best practice is to select a value from a
            controlled vocabulary (for example, the list of
            Internet Media Types [MIME] defining computer media
            formats).
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:relation">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">A reference to a related
            resource.</div>

            <div class="description">Recommended best practice is to
            reference the resource by means of a string or number
            conforming to a formal identification system.
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:rights">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">Information about rights held in
            and over the resource.</div>

            <div class="description">Typically, a Rights element will
            contain a rights management statement for the resource,
            or reference a service providing such information.
            Rights information often encompasses Intellectual
            Property Rights (IPR), Copyright, and various Property
            Rights. If the Rights element is absent, no assumptions
            can be made about the status of these and other rights
            with respect to the resource.
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:subject">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">The topic of the content of the
            resource.</div>

            <div class="description">Typically, a Subject will be
            expressed as keywords, key phrases or classification
            codes that describe a topic of the resource.
            Recommended best practice is to select a value from a
            controlled vocabulary or formal classification
            scheme.
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:title">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">A name given to the resource.</div>

            <div class="description">Typically, a Title will be a name by
            which the resource is formally known.
          </div>
         </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:type">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">The nature or genre of the
            content of the resource.</div>

            <div class="description">Type includes terms describing
            general categories, functions, genres, or aggregation
            levels for content. Recommended best practice is to
            select a value from a controlled vocabulary (for
            example, the working draft list of Dublin Core Types
            [DCT1]). To describe the physical or digital
            manifestation of the resource, use the FORMAT
            element.
          </div>
         </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:contributor">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">An entity responsible for making
            contributions to the content of the resource.</div>

            <div class="description">Examples of a Contributor include a
            person, an organisation, or a service. Typically, the
            name of a Contributor should be used to indicate the
            entity.
          </div>
         </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:creator">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">An entity primarily responsible
            for making the content of the resource.</div>

            <div class="description">Examples of a Creator include a
            person, an organisation, or a service. Typically, the
            name of a Creator should be used to indicate the
            entity.
          </div>
          </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:publisher">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">An entity responsible for making
            the resource available</div>

            <div class="description">Examples of a Publisher include a
            person, an organisation, or a service. Typically, the
            name of a Publisher should be used to indicate the
            entity.
          </div>
         </xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:source">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">A Reference to a resource from
            which the present resource is derived.</div>

            <div class="description">The present resource may be derived
            from the Source resource in whole or in part.
            Recommended best practice is to reference the resource
            by means of a string or number conforming to a formal
            identification system.
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:language">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">A language of the intellectual
            content of the resource.</div>

            <div class="description">Recommended best practice for the
            values of the Language element is defined by RFC 1766
            [RFC1766] which includes a two-letter Language Code
            (taken from the ISO 639 standard [ISO639]), followed
            optionally, by a two-letter Country Code (taken from
            the ISO 3166 standard [ISO3166]). For example, 'en' for
            English, 'fr' for French, or 'en-uk' for English used
            in the United Kingdom.
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="dc:date">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">A date associated with an event
            in the life cycle of the resource.</div>

            <div class="description">Typically, Date will be associated
            with the creation or availability of the resource.
            Recommended best practice for encoding the date value
            is defined in a profile of ISO 8601 [W3CDTF] and
            follows the YYYY-MM-DD format.
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="cmlm:safety">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">Entry contains information
            relating to chemical safety</div>

            <div class="description">Typically the content will be a
            reference to a handbook, MSDS, threshhold or other
            human-readable string
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="cmlm:insilico">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">Part or whole of the information
            was computer-generated</div>
            <div class="description">Typically the content will be the
            name of a method or a program
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="cmlm:structure">
        <xsd:annotation>
          <xsd:documentation>
            <div class="definition">3D structure included</div>
            <div class="description">details included
          </div>
</xsd:documentation>
        </xsd:annotation>
      </xsd:enumeration>

      <xsd:enumeration value="cmlm:reaction">
      </xsd:enumeration>

      <xsd:enumeration value="cmlm:identifier">
      </xsd:enumeration>

      <xsd:enumeration value="other">
      </xsd:enumeration>
    </xsd:restriction>
  </xsd:simpleType>

     <xsd:simpleType name="minType" id="st.minType">
      <xsd:annotation>
         <xsd:documentation>
            <div class="summary">The minimum INCLUSIVE value of a quantity</div>
            <div class="description"><p>The minimum INCLUSIVE value of a sortable quantity such as
            numeric, date or string. It should be ignored for dataTypes such as URL.
            The use of <tt>min</tt> and
          <tt>min</tt> attributes can be used to give a range for the quantity.
         The statistical basis of this range is not defined. The value of <tt>min</tt>
         is usually an observed
         quantity (or calculated from observations). To restrict a value, the <tt>
         minExclusive</tt> type in a dictionary should be used.</p>
         <p>The type of the minimum is the same as the quantity to which it refers - numeric,
         date and string are currently allowed</p>
         </div>
          <div class="example"><pre><stmml title="maxType example">

<scalar dataType="xsd:float" max="20" min="12">15</scalar>
</stmml>
</pre></div>
        </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:string">
      </xsd:restriction>
   </xsd:simpleType>

   <xsd:attribute name="minValue" type="minType"/>

  <xsd:simpleType name="namespaceRefType" id="st.namespaceRefType">
   <xsd:annotation>
      <xsd:documentation>
        <div class="summary">
         A string referencing a dictionary, units, convention or other metadata.
      </div>
        <div class="description">
         <p>The namespace is optional but recommended where possible</p>
      <p>Note: this convention is only used within STMML and related languages;
      it is NOT a generic URI.</p>
      </div>
        <div class="example">
        <pre>
<stmml title="namespace example">

<list>
<!-- dictRef is of namespaceRefType -->
  <scalar dictRef="chem:mpt">123</scalar>
<!-- error -->
  <scalar dictRef="mpt23">123</scalar>
</list>
</stmml>

        </pre>
      </div>
     </xsd:documentation>
   </xsd:annotation>
   <xsd:restriction base="xsd:string">
     <xsd:annotation>
       <xsd:documentation>
         <div class="description">
         <p>The namespace prefix must start with an alpha character and can only contain alphanumeric and '_'. The suffix can have characters from the XML ID specification (alphanumeric, '_', '.' and '-'</p>
      </div>
     </xsd:documentation>
   </xsd:annotation>
      <xsd:pattern value="([A-Za-z][A-Za-z0-9_]*:)?[A-Za-z][A-Za-z0-9_\.\-]*"/>
   </xsd:restriction>
</xsd:simpleType>

  <xsd:simpleType name="positiveNumberType" id="st.positiveNumberType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="description">A positive number. Note that we also provide nonNegativeNumber
      with inclusive zero. The maximum number is (quite large) since 'unbounded' is more difficult
      to implement.  This is greater than Eddington's estimate of the number of particles in the
      universe so it should work for most people.</div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:double">
    <xsd:minExclusive value="0.0"/>
    <xsd:maxInclusive value="1.0E+99"/>
  </xsd:restriction>
</xsd:simpleType>

  <xsd:simpleType name="refType" id="st.refType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A reference to an existing element</div>
      <div class="description">
        <p>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 <tt>appinfo</tt>
        </p>
        <p>Any DOM Node created from this element will normally be a <i>reference</i>
           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.
        </p>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="idType"/>
</xsd:simpleType>

     <xsd:simpleType name="sizeType" id="st.sizeType">
      <xsd:annotation>
         <xsd:documentation>
           <div class="summary">The size of an array</div>
           <div class="description">
            <p>The size of an array. Redundant, but serves as a check
         for processing software (useful if delimiters are used)</p>
         </div>
       </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:positiveInteger"/>
   </xsd:simpleType>

     <xsd:simpleType name="unitsType" id="st.unitsType">
      <xsd:annotation>
         <xsd:documentation>
           <div class="summary">Scientific units</div>
           <div class="description"><p>These will be linked to dictionaries of units with
         conversion information, using namespaced references (e.g. <tt>si:m</tt>)
          </p>
          <p>Distinguish carefully from <a href="st.unitType">unitType</a>
          which is an element describing a type of a unit in a <a href="el.unitList">unitList</a>
          </p></div>
           <div class="example"><pre><stmml title="unitList example">
<stm:unitList xmlns:stm="http://www.xml-cml.org/schema/stmml">

<!-- ======================================================================= -->
<!-- ========================= fundamental types =========================== -->
<!-- ======================================================================= -->

<stm:unitType id="length" name="length">
  <stm:dimension name="length" power="1"/>
</stm:unitType>

<stm:unitType id="time" name="time">
  <stm:dimension name="time" power="1"/>
</stm:unitType>

<!-- ... -->

<stm:unitType id="dimensionless" name="dimensionless">
  <stm:dimension name="dimensionless" power="1"/>
</stm:unitType>

<!-- ======================================================================= -->
<!-- ========================== derived types ============================== -->
<!-- ======================================================================= -->

<stm:unitType id="acceleration" name="acceleration">
  <stm:dimension name="length" power="1"/>
  <stm:dimension name="time" power="-2"/>
</stm:unitType>

<!-- ... -->

<!-- ======================================================================= -->
<!-- ====================== fundamental SI units =========================== -->
<!-- ======================================================================= -->

<stm:unit id="second" name="second" unitType="time">
  <stm:description>The SI unit of time</stm:description>
</stm:unit>

<stm:unit id="meter" name="meter" unitType="length"
  abbreviation="m">
  <stm:description>The SI unit of length</stm:description>
</stm:unit>

<!-- ... -->

<stm:unit id="kg" name="nameless" unitType="dimensionless"
  abbreviation="nodim">
  <stm:description>A fictitious parent for dimensionless units</stm:description>
</stm:unit>

<!-- ======================================================================= -->
<!-- ===================== derived SI units ================================ -->
<!-- ======================================================================= -->

<stm:unit id="newton" name="newton" unitType="force">
  <stm:description>The SI unit of force</stm:description>
</stm:unit>

<!-- ... -->

<!-- multiples of fundamental SI units -->

<stm:unit id="g" name="gram" unitType="mass"
  parentSI="kg"
  multiplierToSI="0.001"
  abbreviation="g">
  <stm:description>0.001 kg. </stm:description>
</stm:unit>

<stm:unit id="celsius" name="Celsius" parentSI="k"
  multiplierToSI="1"
  constantToSI="273.18">
  <stm:description><p>A common unit of temperature</p></stm:description>
</stm:unit>

<!-- fundamental non-SI units -->

<stm:unit id="inch" name="inch" parentSI="meter"
   abbreviation="in"
  multiplierToSI="0.0254" >
  <stm:description>An imperial measure of length</stm:description>
</stm:unit>

<!-- derived non-SI units -->

<stm:unit id="l" name="litre" unitType="volume"
   parentSI="meterCubed"
   abbreviation="l"
   multiplierToSI="0.001">
  <stm:description>Nearly 1 dm**3 This is not quite exact</stm:description>
</stm:unit>

<!-- ... -->

<stm:unit id="fahr" name="fahrenheit" parentSI="k"
   abbreviation="F"
  multiplierToSI="0.55555555555555555"
  constantToSI="-17.777777777777777777">
  <stm:description>An obsolescent unit of temperature still used in popular
  meteorology</stm:description>
</stm:unit>

</stm:unitList>
</stmml>

</pre></div>
        </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:string"/>
   </xsd:simpleType>





 <!-- elements from STMML -->
  <!-- stmml types in CML -->
<!-- these elements will adopt the CML namespace -->
  <xsd:element name="array" id="el.array">
   <xsd:annotation>
     <xsd:documentation>
       <div class="summary">
            A homogenous 1-dimensional array of similar objects.</div>
         <div class="description">
         <p>
            <tt>array</tt> manages a homogenous 1-dimensional array of similar objects. These
            can be encoded as strings (i.e. XSD-like datatypes) and are concatenated as
            string content. The size of the array should always be >= 1.
         </p>
         <p>The default delimiter is whitespace. The <tt>normalize-space()</tt> function of
         XSLT could be used to normalize all whitespace to single spaces and this would not affect
         the value of the array elements. To extract the elements <tt>java.lang.StringTokenizer</tt>
         could be used. If the elements themselves contain whitespace then a different delimiter
         must be used and is identified through the <tt>delimiter</tt> attribute. This method is
         mandatory if it is required to represent empty strings. If a delimiter is used it MUST
         start and end the array - leading and trailing whitespace is ignored. Thus <tt>size+1</tt>
         occurrences of the delimiter character are required. If non-normalized whitespace is to be
         encoded (e.g. newlines, tabs, etc) you are recommended to translate it character-wise
         to XML character entities.
         </p>
         <p>Note that normal Schema validation tools cannot validate the elements
         of <b>array</b> (they are defined as <tt>string</tt>) However if the string is
         split, a temporary schema
         can be constructed from the type and used for validation. Also the type
         can be contained in a dictionary and software could decide to retrieve this
         and use it for validation.</p>
         <p>When the elements of the <tt>array</tt> are not simple scalars
         (e.g. <a href="el.scalar">scalar</a>s with a value and an error, the
         <tt>scalar</tt>s should be used as the elements. Although this is
         verbose, it is simple to understand. If there is a demand for
         more compact representations, it will be possible to define the
         syntax in a later version.</p>
        </div>
<div class="example">
<pre><stmml title="array example 1">

<array size="5" title="value"
  dataType="xsd:decimal">  1.23 2.34 3.45 4.56 5.67</array>
  </stmml>
</pre>
         <p>the <tt>size</tt> attribute is not mandatory but provides a useful validity
         check): </p>
        </div>
<div class="example">
<pre><stmml title="array example 2">

<array size="5" title="initials" dataType="xsd:string"
  delimiter="/">/A B//C/D-E/F/</array>
  </stmml>
</pre>
<p>Note that the second array-element is the empty string ''.</p>
        </div>
<div class="example">
<pre><stmml title="array example 3">

<array title="mass" size="4"
  units="unit:g"
  errorBasis="observedStandardDeviation"
  minValues="10 11 10 9"
  maxValues="12 14 12 11"
  errorValues="1 2 1 1"
  dataType="xsd:float">11 12.5 10.9 10.2
</array>
</stmml>
</pre>
      </div>
       </xsd:documentation>
   </xsd:annotation>
   <xsd:complexType>
     <xsd:simpleContent>
       <xsd:extension base="xsd:string">
          <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
          <xsd:attribute name="dataType" type="dataTypeType" use="required">
             <xsd:annotation>
                  <xsd:documentation>
                   <div class="summary">The mandatory data type.</div>
                   <div class="summary">All elements of the array must have the same dataType</div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="errorValues" type="floatArrayType">
               <xsd:annotation>
                  <xsd:documentation>
                   <div class="summary">an optional array of error values for numeric arrays</div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:attribute>
            <xsd:attributeGroup ref="errorBasis"/>
            <xsd:attribute name="minValues" type="floatArrayType">
               <xsd:annotation>
                  <xsd:documentation>
                   <div class="summary">an optional array of minimum values for numeric arrays</div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="maxValues" type="floatArrayType">
               <xsd:annotation>
                  <xsd:documentation>
                   <div class="summary">an optional array of maximum values for numeric arrays</div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:attribute>
            <xsd:attributeGroup ref="units"/>
            <xsd:attributeGroup ref="delimiter"/>
            <xsd:attributeGroup ref="size"/>
            <xsd:attributeGroup ref="ref"/>
       </xsd:extension>
     </xsd:simpleContent>
   </xsd:complexType>
</xsd:element>


  <xsd:element name="list" id="el.list">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A generic container with no implied semantics</div>
      <div class="description"><p>
       A generic container with no implied semantics. It just contains
      things and can have attributes which bind conventions to it. It could often
      act as the root element in an STM document.</p>
      </div>
      <div class="example">
      <pre><stmml title="list example">

<list>
  <array title="animals" dataType="xsd:string">frog bear toad</array>
  <scalar title="weight" dataType="xsd:float">3.456</scalar>
</list>
</stmml>
</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:sequence>
      <xsd:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
    </xsd:sequence>
    <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
    <xsd:attribute name="type" type="xsd:string" id="att.list.type">
      <xsd:annotation>
        <xsd:documentation>
          <div class="summary">Type of the list</div>
          <div class="description">Semeantics undefined.</div>
          <div class="example">
            <pre><stmml title="list example">

<list>
  <array title="animals" dataType="xsd:string">frog bear toad</array>
  <scalar title="weight" dataType="xsd:float">3.456</scalar>
</list>
</stmml>
</pre>
          </div>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
  </xsd:complexType>
</xsd:element>

  <xsd:element name="matrix" id="el.matrix">
   <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A rectangular matrix of any quantities</div>
        <div class="description"><p>By default <tt>matrix</tt> represents
        a rectangular matrix of any quantities
            representable as XSD or STMML dataTypes. It consists of
            <tt>rows*columns</tt> elements, where <tt>columns</tt> is the
     fasting moving index. Assuming the elements are counted from 1 they are
     ordered <tt>V[1,1],V[1,2],...V[1,columns],V[2,1],V[2,2],...V[2,columns],
     ...V[rows,1],V[rows,2],...V[rows,columns]</tt></p>
     <p>By default whitespace is used to separate matrix elements; see
     <a href="el.array">array</a> for details. There are NO characters or markup
     delimiting the end of rows; authors must be careful!. The <tt>columns</tt>
     and <tt>rows</tt> attributes have no default values; a row vector requires
     a <tt>rows</tt> attribute of 1.</p>
     <p><tt>matrix</tt> also supports many types of square matrix, but at present we
     require all elements to be given, even if the matrix is symmetric, antisymmetric
     or banded diagonal. The <tt>matrixType</tt> attribute allows software to
     validate and process the type of matrix.</p>
      </div>
        <div class="example">
        <pre>
<stmml title="matrix example">

<matrix id="m1" title="mattrix-1" dictRef="foo:bar"
  rows="3" columns="3" dataType="xsd:decimal"
  delimiter="|" matrixType="squareSymmetric" units="unit:m"
  >|1.1|1.2|1.3|1.2|2.2|2.3|1.3|2.3|3.3|</matrix>
  </stmml>

        </pre>
        </div>
     </xsd:documentation>
   </xsd:annotation>

   <xsd:complexType>
      <xsd:simpleContent>
         <xsd:extension base="xsd:string">
            <xsd:attribute name="dataType" type="dataTypeType" use="required" id="att.matrix.dataType"/>
            <xsd:attribute name="delimiter" type="delimiterType" id="att.matrix.delimiter"/>
            <xsd:attribute name="rows" type="sizeType" use="required">
               <xsd:annotation>
                  <xsd:documentation>
                     <div class="summary"><p>Number of rows</p>
                  </div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="columns" type="sizeType" use="required" id="att.matrix.columns">
               <xsd:annotation>
                  <xsd:documentation>
                    <div class="summary"><p>Number of columns</p>
                  </div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:attribute>
            <xsd:attribute name="units" type="unitsType" id="att.matrix.units">
               <xsd:annotation>
                  <xsd:documentation>
                    <div class="summary"><p>units (recommended for numeric quantities!!)</p>
                  </div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:attribute>
            <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
            <xsd:attribute name="matrixType" type="matrixType" id="att.matrix.matrixType">
              <xsd:annotation>
                 <xsd:documentation>
                  <div class="summary">Type of matrix</div>
                  <div class="description">Mainly square, but extensible through the <tt>xsd:union</tt> mechanism.
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
           <xsd:attribute name="errorValues" type="floatArrayType" id="att.matrix.errorValues">
              <xsd:annotation>
                 <xsd:documentation>
                  <div class="summary">an optional array of error values for numeric matrices</div>
                 </xsd:documentation>
              </xsd:annotation>
           </xsd:attribute>
           <xsd:attributeGroup ref="errorBasis"/>
           <xsd:attribute name="minValues" type="floatArrayType" id="att.matrix.minValues">
              <xsd:annotation>
                 <xsd:documentation>
                  <div class="summary">an optional array of minimum values for numeric matrices</div>
                 </xsd:documentation>
              </xsd:annotation>
           </xsd:attribute>
           <xsd:attribute name="maxValues" type="floatArrayType" id="att.matrix.maxValues">
              <xsd:annotation>
                 <xsd:documentation>
                  <div class="summary">an optional array of maximum values for numeric matrices</div>
                 </xsd:documentation>
              </xsd:annotation>
           </xsd:attribute>

         </xsd:extension>
      </xsd:simpleContent>
   </xsd:complexType>
</xsd:element>

  <xsd:element name="metadata" id="el.metadata">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A general container for metadata</div>
      <div class="description"><p>A general container for metadata, including at least
      Dublin Core (DC) and CML-specific metadata</p>
      <p>In its simple form each element provides a name and content in a similar
      fashion to the <tt>meta</tt> element in HTML. <tt>metadata</tt> may have simpleContent
      (i.e. a string for adding further information - this is not controlled).</p>
    </div>
      <div class="example">
      <pre><stmml title="metadata example">

<list>
  <metadataList>
    <metadata name="dc:coverage" content="Europe"/>
    <metadata name="dc:description" content="Ornithological chemistry"/>
    <metadata name="dc:identifier"  content="ISBN:1234-5678"/>
    <metadata name="dc:format" content="printed"/>
    <metadata name="dc:relation" content="abc:def123"/>
    <metadata name="dc:rights" content="licence:GPL"/>
    <metadata name="dc:subject" content="Informatics"/>
    <metadata name="dc:title" content="birds"/>
    <metadata name="dc:type" content="bird books on chemistry"/>
    <metadata name="dc:contributor" content="Tux Penguin"/>
    <metadata name="dc:creator" content="author"/>
    <metadata name="dc:publisher" content="Penguinone publishing"/>
    <metadata name="dc:source" content="penguinPub"/>
    <metadata name="dc:language" content="en-GB"/>
    <metadata name="dc:date" content="1752-09-10"/>
  </metadataList>
  <metadataList>
    <metadata name="cmlm:safety" content="mostly harmless"/>
    <metadata name="cmlm:insilico" content="electronically produced"/>
    <metadata name="cmlm:structure" content="penguinone"/>
    <metadata name="cmlm:reaction" content="synthesis of penguinone"/>
    <metadata name="cmlm:identifier" content="smiles:O=C1C=C(C)C(C)(C)C(C)=C1"/>
  </metadataList>
</list>
</stmml>
</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:string">
        <xsd:attribute name="name" type="metadataType" id="att.metadata.name">
          <xsd:annotation>
            <xsd:documentation>
              <div class="summary">The metadata type</div>
            </xsd:documentation>
          </xsd:annotation>
        </xsd:attribute>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attribute name="content" type="xsd:string" id="att.metadata.content">
          <xsd:annotation>
            <xsd:documentation>
              <div class="summary">The metadata</div>
             </xsd:documentation>
          </xsd:annotation>
        </xsd:attribute>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

    <xsd:element name="metadataList" id="el.metadataList">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A general container for metadata elements</div>
        <div class="example"><pre><stmml title="metadata example">

<list>
  <metadataList>
    <metadata name="dc:coverage" content="Europe"/>
    <metadata name="dc:description" content="Ornithological chemistry"/>
    <metadata name="dc:identifier"  content="ISBN:1234-5678"/>
    <metadata name="dc:format" content="printed"/>
    <metadata name="dc:relation" content="abc:def123"/>
    <metadata name="dc:rights" content="licence:GPL"/>
    <metadata name="dc:subject" content="Informatics"/>
    <metadata name="dc:title" content="birds"/>
    <metadata name="dc:type" content="bird books on chemistry"/>
    <metadata name="dc:contributor" content="Tux Penguin"/>
    <metadata name="dc:creator" content="author"/>
    <metadata name="dc:publisher" content="Penguinone publishing"/>
    <metadata name="dc:source" content="penguinPub"/>
    <metadata name="dc:language" content="en-GB"/>
    <metadata name="dc:date" content="1752-09-10"/>
  </metadataList>
  <metadataList>
    <metadata name="cmlm:safety" content="mostly harmless"/>
    <metadata name="cmlm:insilico" content="electronically produced"/>
    <metadata name="cmlm:structure" content="penguinone"/>
    <metadata name="cmlm:reaction" content="synthesis of penguinone"/>
    <metadata name="cmlm:identifier" content="smiles:O=C1C=C(C)C(C)(C)C(C)=C1"/>
  </metadataList>
</list>
</stmml>
</pre></div>
      </xsd:documentation>
    </xsd:annotation>

    <xsd:complexType>
      <xsd:sequence>
        <xsd:element ref="metadata" maxOccurs="unbounded"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>


    <xsd:element name="observation" id="el.observation">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">An observation or occurrence</div>
        <div class="description"><p>A container for any events that
        need to be recorded, whether planned or not. They can include notes,
        measurements, conditions that may be referenced elsewhere, etc. There are
        no controlled semantics </p>
        <div class="example"><pre><stmml title="observation example">
<observation type="ornithology">
  <object title="sparrow" count="3"/>
  <observ/>
</observation>
</stmml>
</pre></div>
      </div>
     </xsd:documentation>
   </xsd:annotation>
    <xsd:complexType mixed="true">
      <xsd:sequence minOccurs="0" maxOccurs="unbounded">
        <xsd:any processContents="lax"/>
      </xsd:sequence>
      <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
      <xsd:attribute name="type" type="xsd:string" id="att.observation.type">
        <xsd:annotation>
          <xsd:documentation>
            <div class="summary">Type of observation (uncontrolled vocabulary)</div>
         </xsd:documentation>
       </xsd:annotation>
      </xsd:attribute>
      <xsd:attribute name="count" type="countType" id="att.observation.count"/>
    </xsd:complexType>

  </xsd:element>


  <xsd:element name="scalar" id="el.scalar">
   <xsd:annotation>
     <xsd:documentation>
       <div class="summary">An element to hold scalar data.</div>
         <div class="description">
           <p><tt>scalar</tt> holds scalar data under a single
            generic container. The semantics are usually resolved by
            linking to a dictionary.
             <b>scalar</b> defaults to a scalar string but
             has attributes which affect the type.
         </p>
         <p><tt>scalar</tt> does not necessarily reflect a physical object (for which
         <a href="el.object">object</a> should be used). It may reflect a property of an object
         such as temperature, size, etc. </p>
         <p>Note that normal Schema validation tools cannot validate the data type
         of <b>scalar</b> (it is defined as <tt>string</tt>), but that a temporary schema
         can be constructed from the type and used for validation. Also the type
         can be contained in a dictionary and software could decide to retrieve this
         and use it for validation.</p>
      </div>

      <div class="example">
        <pre>
<stmml title="scalar example">
<scalar
    dataType="xsd:decimal"
    errorValue="1.0"
    errorBasis="observedStandardDeviation"
    title="body weight"
    dictRef="zoo:bodywt"
    units="units:g">34.3</scalar>
    </stmml>

        </pre>
      </div>
     </xsd:documentation>
   </xsd:annotation>
   <xsd:complexType>
      <xsd:simpleContent>
         <xsd:extension base="xsd:string">
            <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
            <xsd:attributeGroup ref="dataType"/>
            <xsd:attributeGroup ref="errorValue"/>
            <xsd:attributeGroup ref="errorBasis"/>
            <xsd:attributeGroup ref="min"/>
            <xsd:attributeGroup ref="max"/>
            <xsd:attributeGroup ref="units"/>
         </xsd:extension>
      </xsd:simpleContent>
   </xsd:complexType>
</xsd:element>






   <!-- cml types -->
   <!-- CML types -->
   <xsd:simpleType name="angleUnitsType" id="st.angleUnitsType">
   <xsd:annotation>
     <xsd:documentation>
       <div class="summary">an enumeration of allowed angle units</div>
      <div class="description">
      </div>
      <div class="example">
        <pre>
        </pre>
      </div>
     </xsd:documentation>
   </xsd:annotation>
   <xsd:restriction base="xsd:string">
     <xsd:enumeration value="degrees"/>
     <xsd:enumeration value="radians"/>
   </xsd:restriction>
 </xsd:simpleType>

   <xsd:simpleType name="atomRefType" id="st.atomRefType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A reference to an existing atom</div>
      <div class="example">
         <pre><cml title="atomRef example">
  <molecule id="m1">
    <atomArray>
      <atom id="a1"/>
    </atomArray>
    <electron id="e1" atomRef="a1"/>
  </molecule>
</cml>
</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:string">
    <xsd:pattern value="\s*[A-Za-z_][A-Za-z0-9\-:_]*\s*"/>
  </xsd:restriction>
</xsd:simpleType>

   <xsd:simpleType name="atomRefs2Type" id="st.atomRefs2Type">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A reference to two distinct existing atoms in order</div>
      <div class="example">
        <pre><cml title="atomRefs2 example">
  <molecule id="m1">
    <atomArray>
      <atom id="a1"/>
      <atom id="a2"/>
    </atomArray>
    <bondArray>
      <bond atomRefs2="a1 a2"/>
    </bondArray>
  </molecule>
</cml>

</pre>
      </div>
    </xsd:documentation>
      </xsd:annotation>

      <xsd:restriction base="xsd:string">
         <xsd:pattern value="\s*\S+\s+\S+\s*"/>
      </xsd:restriction>
   </xsd:simpleType>

      <xsd:simpleType name="atomRefs3Type" id="st.atomRefs3Type">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">A reference to three distinct existing atoms in order</div>
      <div class="example">
       <pre><cml title="atomRefs3 example">
  <molecule id="m1">
    <atomArray>
      <atom id="a1"/>
      <atom id="a2"/>
      <atom id="a3"/>
    </atomArray>
    <angle atomRefs3="a1 a2 a3" units="degrees">123.4</angle>
  </molecule>
</cml>


       </pre>
      </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:string">
         <xsd:pattern value="\s*(\S+\s+){2}\S+\s*"/>
      </xsd:restriction>
   </xsd:simpleType>


   <xsd:simpleType name="atomRefs4Type" id="st.atomRefs4Type">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">A reference to four distinct existing atoms in order</div>
      <div class="example">
       <pre><cml title="atomRefs4 example">
  <molecule id="m1">
    <atomArray>
      <atom id="a1"/>
      <atom id="a2"/>
      <atom id="a3"/>
     <atom id="a4"/>
    </atomArray>
    <torsion atomRefs4="a1 a2 a3 a4" units="degrees">123.4</torsion>
  </molecule>
</cml>


       </pre>
      </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:string">
         <xsd:pattern value="\s*(\S+\s+){3}\S+\s*"/>
      </xsd:restriction>
   </xsd:simpleType>


   <xsd:simpleType name="atomRefArrayType" id="st.atomRefArrayType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">An array of atomRefs</div>
      <div class="description">
            <p>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.</p> </div>
      <div class="example">
       <pre>
<cml title="atomArray example">
  <molecule id="m1">
    <atomArray atomID="a2 a4 a6"
      elementType="O N S"/>
  </molecule>
</cml>

       </pre>
      </div>
         </xsd:documentation>
         <xsd:appinfo>
         </xsd:appinfo>
      </xsd:annotation>
      <xsd:list itemType="atomRefType"/>
   </xsd:simpleType>

   <xsd:simpleType name="atomIDType" id="st.atomIDType">
   <xsd:annotation>
      <xsd:documentation>
   <div class="summary">An identifier for an atom</div>
   <div class="description">
         <p>Of the form prefix:suffix where prefix and suffix
         are purely alphanumeric (with _ and -) and prefix
         is optional. This is similar to XML IDs (and we promote
         this as good practice for atomIDs. Other punctuation and
         whitespace is forbidden, so IDs from (say) PDB files are
         not satisfactory.</p>
         <p>The prefix is intended to form a pseudo-namespace so that
         atom IDs in different molecules may have identical suffixes.
         It is also useful if the prefix is the ID for the molecule
         (though this clearly has its limitation). Atom IDs should not
         be typed as XML IDs since they may not validate.</p>
         </div>
   <div class="example">
   <pre><cml title="example of IDs on atoms">
  <molecule id="m1">
    <atomArray>
<!-- this atom might be referenced as m1:a2. This is not formally
     part of CML yet -->
      <atom id="a2" elementType="O"/>
    </atomArray>
  </molecule>
  <molecule id="m2">
    <atomArray>
<!-- this atom might be referenced as m2:a2. This is not formally
     part of CML yet -->
      <atom id="a2" elementType="O"/>
    </atomArray>
  </molecule>
</cml>


</pre>
         </div>
      </xsd:documentation>
      <xsd:appinfo>
      </xsd:appinfo>
   </xsd:annotation>
   <xsd:restriction base="xsd:string">
      <xsd:pattern value="[A-Za-z0-9_-]+(:[A-Za-z0-9_-]+)?"/>
   </xsd:restriction>
</xsd:simpleType>

   <xsd:simpleType name="bondRefType" id="st.bondRefType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A reference to an existing bond</div>
           <div class="general"><p>A reference to a bond may be made by atoms (e.g. for multicentre or pi-bonds), electrons (for annotating reactions or describing electronic properties) or possibly other bonds
           (no examples yet). The semantics are relatively flexible.</p>
           </div>

      <div class="example">
       <pre>
<cml title="bondArray example">
  <bondArray>
    <bond id="b1" atomRefs2="a3 a8" order="D">
      <electron bondRef="b1"/>
      <bondStereo>C</bondStereo>
    </bond>
    <bond id="b2" atomRefs2="a3 a8" order="S">
      <bondStereo convention="MDL" conventionValue="6"/>
    </bond>
  </bondArray>
</cml>

       </pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:string">
    <xsd:pattern value="\s*\S+\s*"/>
  </xsd:restriction>
</xsd:simpleType>


   <xsd:simpleType name="bondRefArrayType" id="st.bondRefArrayType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">An array of references to bonds</div>
      <div class="description">
            <p>The references cannot (yet)
         cannot be schema- or schematron-validated. Instances of this type will
         be used in array-style representation of electron counts, etc.
         It can also be used for arrays of bondIDTypes such as in complex stereochemistry,
         geometrical definitions, bond groupings, etc.</p> </div>
      <div class="example">
       <pre>
       </pre>
      </div>
         </xsd:documentation>
         <xsd:appinfo>
         </xsd:appinfo>
      </xsd:annotation>
      <xsd:list itemType="bondRefType"/>
   </xsd:simpleType>

   <xsd:simpleType name="elementTypeType" id="st.elementTypeType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">Allowed <tt>elementType</tt> values</div>
      <div class="description">
        <p>The periodic table (up to
         element number 118. In addition the following strings are allowed:
         <ul>
            <li><tt>Du</tt>. ("dummy") This does not correspond to a "real" atom and can
         support a point in space or within a chemical graph.</li>
            <li><tt>R</tt>. ("R-group") This indicates that an atom or group of atoms could be attached at this point. </li>
         </ul>
         </p>
      </div>
      <div class="example">
        <pre><cml title="elementType example">
  <atomArray>
    <atom id="a1" elementType="C"/>
    <atom id="a2" elementType="N"/>
    <atom id="a3" elementType="Pb"/>
    <atom id="a4" elementType="Dummy"/>
  </atomArray>
</cml>

</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:union>
        <xsd:simpleType>
          <xsd:restriction base="xsd:string">
            <xsd:enumeration value="Ac"/>
            <xsd:enumeration value="Al"/>
            <xsd:enumeration value="Ag"/>
            <xsd:enumeration value="Am"/>
            <xsd:enumeration value="Ar"/>
            <xsd:enumeration value="As"/>
            <xsd:enumeration value="At"/>
            <xsd:enumeration value="Au"/>
            <xsd:enumeration value="B"/>
            <xsd:enumeration value="Ba"/>
            <xsd:enumeration value="Bh"/>
            <xsd:enumeration value="Bi"/>
            <xsd:enumeration value="Be"/>
            <xsd:enumeration value="Bk"/>
            <xsd:enumeration value="Br"/>
            <xsd:enumeration value="C"/>
            <xsd:enumeration value="Ca"/>
            <xsd:enumeration value="Cd"/>
            <xsd:enumeration value="Ce"/>
            <xsd:enumeration value="Cf"/>
            <xsd:enumeration value="Cl"/>
            <xsd:enumeration value="Cm"/>
            <xsd:enumeration value="Co"/>
            <xsd:enumeration value="Cr"/>
            <xsd:enumeration value="Cs"/>
            <xsd:enumeration value="Cu"/>
            <xsd:enumeration value="Db"/>
            <xsd:enumeration value="Dy"/>
            <xsd:enumeration value="Er"/>
            <xsd:enumeration value="Es"/>
            <xsd:enumeration value="Eu"/>
            <xsd:enumeration value="F"/>
            <xsd:enumeration value="Fe"/>
            <xsd:enumeration value="Fm"/>
            <xsd:enumeration value="Fr"/>
            <xsd:enumeration value="Ga"/>
            <xsd:enumeration value="Gd"/>
            <xsd:enumeration value="Ge"/>
            <xsd:enumeration value="H">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">Any isotope of hydrogen.</div>
            <div class="description">
<p>There are no special element symbols for D and T which should use the <tt>isotope</tt> attribute. </p></div>
    </xsd:documentation>
  </xsd:annotation>
            </xsd:enumeration>
            <xsd:enumeration value="He"/>
            <xsd:enumeration value="Hf"/>
            <xsd:enumeration value="Hg"/>
            <xsd:enumeration value="Ho"/>
            <xsd:enumeration value="Hs"/>
            <xsd:enumeration value="I"/>
            <xsd:enumeration value="In"/>
            <xsd:enumeration value="Ir"/>
            <xsd:enumeration value="K"/>
            <xsd:enumeration value="Kr"/>
            <xsd:enumeration value="La"/>
            <xsd:enumeration value="Li"/>
            <xsd:enumeration value="Lr"/>
            <xsd:enumeration value="Lu"/>
            <xsd:enumeration value="Md"/>
            <xsd:enumeration value="Mg"/>
            <xsd:enumeration value="Mn"/>
            <xsd:enumeration value="Mo"/>
            <xsd:enumeration value="Mt"/>
            <xsd:enumeration value="N"/>
            <xsd:enumeration value="Na"/>
            <xsd:enumeration value="Nb"/>
            <xsd:enumeration value="Nd"/>
            <xsd:enumeration value="Ne"/>
            <xsd:enumeration value="Ni"/>
            <xsd:enumeration value="No"/>
            <xsd:enumeration value="Np"/>
            <xsd:enumeration value="O"/>
            <xsd:enumeration value="Os"/>
            <xsd:enumeration value="P"/>
            <xsd:enumeration value="Pa"/>
            <xsd:enumeration value="Pb"/>
            <xsd:enumeration value="Pd"/>
            <xsd:enumeration value="Pm"/>
            <xsd:enumeration value="Po"/>
            <xsd:enumeration value="Pr"/>
            <xsd:enumeration value="Pt"/>
            <xsd:enumeration value="Pu"/>
            <xsd:enumeration value="Ra"/>
            <xsd:enumeration value="Rb"/>
            <xsd:enumeration value="Re"/>
            <xsd:enumeration value="Rf"/>
            <xsd:enumeration value="Rh"/>
            <xsd:enumeration value="Rn"/>
            <xsd:enumeration value="Ru"/>
            <xsd:enumeration value="S"/>
            <xsd:enumeration value="Sb"/>
            <xsd:enumeration value="Sc"/>
            <xsd:enumeration value="Se"/>
            <xsd:enumeration value="Sg"/>
            <xsd:enumeration value="Si"/>
            <xsd:enumeration value="Sm"/>
            <xsd:enumeration value="Sn"/>
            <xsd:enumeration value="Sr"/>
            <xsd:enumeration value="Ta"/>
            <xsd:enumeration value="Tb"/>
            <xsd:enumeration value="Tc"/>
            <xsd:enumeration value="Te"/>
            <xsd:enumeration value="Th"/>
            <xsd:enumeration value="Ti"/>
            <xsd:enumeration value="Tl"/>
            <xsd:enumeration value="Tm"/>
            <xsd:enumeration value="U"/>
            <xsd:enumeration value="Uun"/>
            <xsd:enumeration value="Uuu"/>
            <xsd:enumeration value="Uub"/>
            <xsd:enumeration value="Uut"/>
            <xsd:enumeration value="Uuq"/>
            <xsd:enumeration value="Uup"/>
            <xsd:enumeration value="Uuh"/>
            <xsd:enumeration value="Uus"/>
            <xsd:enumeration value="Uuo"/>
            <xsd:enumeration value="V"/>
            <xsd:enumeration value="W"/>
            <xsd:enumeration value="Xe"/>
            <xsd:enumeration value="Y"/>
            <xsd:enumeration value="Yb"/>
            <xsd:enumeration value="Zn"/>
            <xsd:enumeration value="Zr"/>

            <xsd:enumeration value="Dummy">
            </xsd:enumeration>
            <xsd:enumeration value="Du">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A point or object with no chemical semantics.</div>
            <div class="description">
<p>Examples can be centroids, bond-midpoints, orienting "atoms" in small z-matrices. </p>
<p>Note "Dummy" has the same semantics but is now deprecated.</p></div>
    </xsd:documentation>
  </xsd:annotation>
            </xsd:enumeration>

            <xsd:enumeration value="R">
  <xsd:annotation>
    <xsd:documentation>

      <div class="summary">A point at which an atom or group might be attached</div>
            <div class="description">
<p>Examples are abbreviated organic functional groups, Markush representations, polymers, unknown atoms, etc. Semantics may be determined by the <tt>role</tt> attribute on the atom. </p></div>
    </xsd:documentation>
  </xsd:annotation>
            </xsd:enumeration>

          </xsd:restriction>
        </xsd:simpleType>
        <xsd:simpleType>
          <xsd:restriction base="xsd:string">
            <xsd:pattern value="[A-Za-z]+:[A-Za-z][A-Za-z0-9\-]+"/>
          </xsd:restriction>
        </xsd:simpleType>
      </xsd:union>
   </xsd:simpleType>

      <xsd:simpleType name="elementTypeArrayType" id="st.elementTypeArrayType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">An array of elementTypes</div>
      <div class="description">
            <p>Instances of this type will
         be used in array-style representation of atoms.</p> </div>
      <div class="example">
       <pre><cml title="atomArray with elementTypes">
  <atomArray elementType="O N S Pb"/>
</cml>
</pre>
      </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:list itemType="elementTypeType"/>
   </xsd:simpleType>

      <xsd:simpleType name="formalChargeType" id="st.formalChargeType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">The formal charge on an atom</div>
      <div class="description">
            <p>Used for electron-bookeeping.
         This has no relation to its
         calculated (fractional) charge.</p> </div>
      <div class="example">
       <pre>
<cml title="formalCharge example">
  <atomArray>
    <atom id="a1" elementType="N" formalCharge="+1"/>
    <atom id="a2" elementType="O" formalCharge="-1"/>
  </atomArray>
</cml>

       </pre>
      </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:integer"/>
   </xsd:simpleType>

      <xsd:simpleType name="formulaType" id="st.formulaType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">A concise representation for a molecular formula</div>
      <div class="description">
            <p>This MUST adhere to a whitespaced syntax so that it is trivially machine-parsable.
            Each element is followed by its count, and the string is optionally ended
            by a formal charge. NO brackets or other nesting is allowed.</p>
      </div>
      <div class="example">
       <pre>
<cml title="formulaType example (concise)">
  <list>
    <formula id="methane" concise="C 1 H 4"/>
    <formula id="chloroacetate" concise="Cl 1 H 2 C 2 O 2 -1"/>
    <formula id="sodiumSulfate">
      <formula concise="H 2 O 1" count="10"/>
      <formula concise="Na 1 +1" count="2"/>
      <formula concise="S 1 O 4 -2"/>
    </formula>
  </list>
</cml>

       </pre>
      </div>
         </xsd:documentation>
         <xsd:appinfo>
         </xsd:appinfo>
      </xsd:annotation>
      <xsd:restriction base="xsd:string">
         <xsd:pattern value="\s*([A-Z][a-z]?\s+[1-9][0-9]*)(\s+[A-Z][a-z]?\s+[1-9][0-9]*)*(\s+[-|+]?[0-9]+)?\s*"/>
      </xsd:restriction>
   </xsd:simpleType>

   <xsd:simpleType name="hydrogenCountType" id="st.hydrogenCountType">
   <xsd:annotation>
      <xsd:documentation>
      <div class="summary">The total number of hydrogen atoms bonded to an atom</div>
      <div class="description">
         <p>The total number of hydrogen atoms bonded to an atom, whether
      explicitly included as atoms or not. It is an error to have hydrogen count
      less than the explicit hydrogen count. There is no default value and no assumptions
      about hydrogen Count can be made if it is not given. </p>
         <p>If hydrogenCount is given on every atom, then the values can be summed to give
      the total hydrogenCount for the (sub)molecule. Because of this hydrogenCount
      should not be used where hydrogen atoms bridge 2 or more atoms.</p>
      </div>
      <div class="example">
       <pre>
<cml title="single atom example">
<atom id="a1" title="O3'" elementType="O"
  formalCharge="1" hydrogenCount="1"
  isotope="17" occupancy="0.7"
  x2="1.2" y2="2.3"
  x3="3.4" y3="4.5" z3="5.6"
  convention="ABC" dictRef="chem:atom"
>
  <scalar title="dipole" dictRef="d:dip"
    units="units:debye">0.2</scalar>
  <atomParity atomRefs4="a3 a7 a2 a4">1</atomParity>
  <electron id="e1" atomRef="a1" count="2"/>
</atom>
</cml>

       </pre>
      </div>
      </xsd:documentation>
   </xsd:annotation>
   <xsd:restriction base="xsd:nonNegativeInteger"/>
</xsd:simpleType>


   <xsd:simpleType name="isotopeType" id="st.isotopeType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">The numeric representation of an isotope</div>
      <div class="description">
            <p>In core CML this represents a single number; either the
         combined proton/neutron count or a more accurate estimate of the
         nuclear mass. This is admittedly fuzzy, and requires a more complex
         object (which can manage conventions, lists of isotopic masses, etc.)
         See <a href="el.isotope">isotope</a>.</p>
         <p>The default is "natural abundance" - whatever that can be interpreted
         as.</p>
            <p>Delta values (i.e. deviations from the most abundant istopic mass)
         are never allowed.</p>
         </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:float">
         <xsd:minInclusive value="0.0"/>
         <xsd:maxInclusive value="99999999999.0"/>
      </xsd:restriction>
   </xsd:simpleType>

   <xsd:simpleType name="nonNegativeAngleType" id="st.nonNegativeAngleType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A non-signed angle, such as a bond angle.
      Note that we also provide positiveAngleType (e.g. for cell angles) and
      torsionAngleType for - guess what - <a href="el.torsion">torsion</a>.</div>
      <div class="description">
        <p>Re-used by <a href="el.angle">angle</a></p>
      </div>
      <div class="example">
       <pre><stmml title="nonNegativeAngle type">

<scalar dataType="nonNegativeAngleType">123</scalar>
</stmml>
</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:float">
    <xsd:minInclusive value="0.0"/>
    <xsd:maxInclusive value="180.0"/>
  </xsd:restriction>
</xsd:simpleType>

      <xsd:simpleType name="nonHydrogenCountType" id="st.nonHydrogenCountType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">The number of non-hydrogen atoms attached to an atom</div>
      <div class="description">
            <p>Obsolete in core CML. Only useful in CML queries</p>
            </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:nonNegativeInteger"/>
   </xsd:simpleType>

   <xsd:simpleType name="positiveAngleType" id="st.positiveAngleType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A non-signed angle, such as a cell angle.
      Note that we also provide nonNegativeAngleType (e.g. for bond angles)</div>
      <div class="description">
        <p>Re-used by <a href="el.crystal">crystal</a></p>
      </div>
      <div class="example">
       <pre><cml title="positiveAngleType example">
  <list>
    <scalar title="alpha" units="units:degree">70.123</scalar>
    <scalar title="beta" units="units:degree">80.456</scalar>
    <scalar title="gamma" units="units:degree">90.789</scalar>
  </list>
</cml>

</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:float">
    <xsd:minExclusive value="0.0"/>
    <xsd:maxInclusive value="180.0"/>
  </xsd:restriction>
</xsd:simpleType>


   <xsd:simpleType name="occupancyType" id="st.occupancyType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">Occupancy of an atomic site</div>
      <div class="description">
            <p> Primarily for crystallography. Values
         outside 0-1 are not allowed.</p>
         </div>
      <div class="example">See <a href="el.atom">atom</a>.
      </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:float">
         <xsd:minInclusive value="0"/>
         <xsd:maxInclusive value="1"/>
      </xsd:restriction>
   </xsd:simpleType>

   <xsd:simpleType name="orderArrayType" id="st.orderArrayType">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">An array of bond orders</div>
      <div class="description">
      <p> (seeAlso <a href="st.orderType">orderType</a>)</p> </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:list itemType="orderType"/>
</xsd:simpleType>

      <xsd:simpleType name="orderType" id="st.orderType">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">Bond order (as a string)</div>
      <div class="description">
            <p>This is purely conventional and used
       for bond/electron counting. There is no default value.
         The emptyString attribute can be used to indicate a bond of
         unknown or unspecified type. The interpretation of this is outside
         the scope of CML-based algorithms. It may be accompanied by a <tt>convention</tt>
         attribute on the <tt>bond</tt> which links to a dictionary.
         Example: <tt><bond convention="ccdc:9" atomRefs2="a1 a2"/></tt> could
         represent a delocalised bond in the CCDC convention.</p>
          </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:string">
        <xsd:enumeration value="S">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Single bond</div>
             </xsd:documentation>
           </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="1">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Single bond</div>
             </xsd:documentation>
           </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="D">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Double bond</div>
             </xsd:documentation>
           </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="2">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Double bond</div>
             </xsd:documentation>
           </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="T">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Triple bond</div>
             </xsd:documentation>
           </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="3">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Triple bond</div>
             </xsd:documentation>
           </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="A">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Aromatic bond</div>
             </xsd:documentation>
           </xsd:annotation>
        </xsd:enumeration>
      </xsd:restriction>
   </xsd:simpleType>


   <xsd:simpleType name="stateType" id="st.stateType">
      <xsd:annotation>
         <xsd:documentation>
           <div class="summary">State of a substance or property</div>
           <div class="description">
            <p>The state(s) of matter appropriate to a substance or property. It follows a partially controlled vocabulary. It can be extended through namespace codes to dictionaries</p>
           </div>
           <div class="example">
           </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:restriction base="xsd:string">
        <xsd:enumeration value="aqueous">
          <xsd:annotation>
            <xsd:documentation>
            An aqueous solution
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="gas">
          <xsd:annotation>
            <xsd:documentation>
              Gas or vapor. The default state for computation on isolated molecules
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="glass">
          <xsd:annotation>
            <xsd:documentation>
            A glassy state
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="liquid">
          <xsd:annotation>
            <xsd:documentation>
            Normally pure liquid (use solution where appropriate)
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="nematic">
          <xsd:annotation>
            <xsd:documentation>
           The nematic phase
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="smectic">
          <xsd:annotation>
            <xsd:documentation>
           The smectic phase
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="solid">
          <xsd:annotation>
            <xsd:documentation>
            A solid
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="solidSolution">
          <xsd:annotation>
            <xsd:documentation>
            A solid solution
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
        <xsd:enumeration value="solution">
          <xsd:annotation>
            <xsd:documentation>
            A (liquid) solution
            </xsd:documentation>
          </xsd:annotation>
        </xsd:enumeration>
      </xsd:restriction>
   </xsd:simpleType>

   <xsd:simpleType name="stereoType" id="st.stereoType">
   <xsd:annotation>
      <xsd:documentation>
         <div class="summary">(Bond) stereochemistry (as a string)</div>
         <div class="description">
         <p>. This is purely conventional;
               . There is no default value.
      The emptyString attribute can be used to indicate a bond of
      unknown or unspecified type. The interpretation of this is outside
      the scope of CML-based algorithms. It may be accompanied by a <tt>convention</tt>
      attribute  which links to a dictionary
         </p> </div>
         <div class="example">
         <pre><cml title="bondArray example">
  <bondArray>
    <bond id="b1" atomRefs2="a3 a8" order="D">
      <electron bondRef="b1"/>
      <bondStereo>C</bondStereo>
    </bond>
    <bond id="b2" atomRefs2="a3 a8" order="S">
      <bondStereo convention="MDL" conventionValue="6"/>
    </bond>
  </bondArray>
</cml>
</pre>
         </div>
      </xsd:documentation>
   </xsd:annotation>
   <xsd:restriction base="xsd:string">
               <xsd:enumeration value="C">
   <xsd:annotation>
      <xsd:documentation>
         <div class="summary">A cis bond</div>
      </xsd:documentation>
   </xsd:annotation>
                </xsd:enumeration>
               <xsd:enumeration value="T">
   <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A trans bond</div>
      </xsd:documentation>
   </xsd:annotation>
                </xsd:enumeration>
               <xsd:enumeration value="W">
   <xsd:annotation>
      <xsd:documentation>
         <div class="summary">A wedge bond</div>
      </xsd:documentation>
   </xsd:annotation>
                </xsd:enumeration>
               <xsd:enumeration value="H">
   <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A hatch bond</div>
      </xsd:documentation>
   </xsd:annotation>
                </xsd:enumeration>
               <xsd:enumeration value="">
   <xsd:annotation>
      <xsd:documentation>
        <div class="summary">empty or missing</div>
      </xsd:documentation>
   </xsd:annotation>
                </xsd:enumeration>
   </xsd:restriction>
</xsd:simpleType>

   <xsd:simpleType name="torsionAngleType" id="st.torsionAngleType">
   <xsd:annotation>
      <xsd:documentation>
        <div class="summary">The type of a torsion angle</div>
      </xsd:documentation>
   </xsd:annotation>
   <xsd:restriction base="xsd:float">
      <xsd:minInclusive value="-360.0"/>
      <xsd:maxInclusive value="360.0"/>
   </xsd:restriction>
</xsd:simpleType>




   <!-- cml attribute groups -->
   <!-- CML attribute Groups -->
   <xsd:attributeGroup id="attGp.atomRef" name="atomRef">
  <xsd:attribute id="att.atomRef" name="atomRef" type="atomRefType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A reference to an atom.</div>
        <div class="description">Typical use would be a bond with only one atom
    (e.g. the other end is to a bond or electrons)</div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


   <xsd:attributeGroup id="attGp.atomRefArray" name="atomRefArray">
  <xsd:attribute id="att.atomRefArray" name="atomRefArray" type="atomRefArrayType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">An array of references to atoms.</div>
        <div class="description">Typical use would be to atoms defining a plane</div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


   <xsd:attributeGroup id="attGp.atomRefs2" name="atomRefs2">
  <xsd:attribute id="att.atomRefs2" name="atomRefs2" type="atomRefs2Type">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A list of two references to atoms.</div>
        <div class="description">Typically used for defining bonds</div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


   <xsd:attributeGroup id="attGp.atomRefs3" name="atomRefs3">
  <xsd:attribute id="att.atomRefs3" name="atomRefs3" type="atomRefs3Type">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A list of three references to atoms.</div>
        <div class="description">Typically used for defining angles,
        but could also be used to define a three-centre bond.</div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


   <xsd:attributeGroup id="attGroup.atomRefs4" name="atomRefs4">
  <xsd:attribute id="att.atomRefs4" name="atomRefs4" type="atomRefs4Type">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">A list of 4 references to atoms.</div>
        <div class="description">Typically used for defining torsions and atomParities,
        but could also be used to define a four-centre bond.</div>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>


   <xsd:attributeGroup id="attGp.angleUnits" name="angleUnits">
  <xsd:attribute id="att.angleUnits" name="units" type="angleUnitsType">
    <xsd:annotation>
      <xsd:documentation>
        <div class="summary">Restricts units to radians or degrees</div>
        <div class="description"/>
      </xsd:documentation>
    </xsd:annotation>
  </xsd:attribute>
</xsd:attributeGroup>





  <!-- cml elements -->
      <xsd:element name="amount" id="el.amount">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">The amount of a <a href="el.substance">substance</a></div>
      <div class="description">
        <p>
        The <tt>units</tt> attribute is mandatory and can be customised to support
        mass, volumes, moles, percentages, or rations (e.g. ppm). </p>
      </div>
      <div class="example">
        <pre><cml title="substanceList example">
  <substanceList id="s1">
    <amount units="units:ml">100</amount>
    <substance id="s1">
      <amount units="units:l">1</amount>
      <molecule id="h2o" ref="mols:water"/>
    </substance>
    <substance id="s2">
      <amount units="units:mole">0.1</amount>
      <molecule id="nacl" formula="Na 1 O 1 H 1"/>
    </substance>
  </substanceList>
</cml>

</pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:float">
        <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
        <xsd:attributeGroup ref="units" id="att.amount.units"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

   <xsd:element name="angle" id="el.angle">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A "bond" angle between three atoms</div>
      <div class="description">
        <p>It can be used for:</p>
        <ul>
           <li>Recording experimentally determined bond angles (e.g. in
        a crystallographic paper).</li>
           <li>Providing the angle component for internal coordinates (e.g.
        z-matrix).</li>
        </ul>
      </div>
      <div class="example"><pre><molecule id="m1" title="angle example">
  <atomArray>
    <atom id="a1"/>
    <atom id="a2"/>
    <atom id="a3"/>
  </atomArray>
  <angle units="degrees" atomRefs3="a1 a2 a3">123.4</angle>
</molecule>
</pre></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="nonNegativeAngleType">
        <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
        <xsd:attributeGroup ref="atomRefs3"/>
        <xsd:attributeGroup ref="angleUnits"/>
        <xsd:attributeGroup ref="errorValue"/>
        <xsd:attributeGroup ref="errorBasis"/>
        <xsd:attributeGroup ref="min"/>
        <xsd:attributeGroup ref="max"/>
        <xsd:attributeGroup ref="ref"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

      <xsd:element name="atom" id="el.atom">
      <xsd:annotation>
         <xsd:documentation>
          <div class="summary">An atom</div>
           <div documentation="general">
            <p>
               Usually within a <tt>molecule</tt>.
        It is almost always contained within <tt>atomArray</tt>.
        </p>
         </div>
          <div class="example"><pre><cml title="single atom example">
<atom id="a1" title="O3'" elementType="O"
  formalCharge="1" hydrogenCount="1"
  isotope="17" occupancy="0.7"
  x2="1.2" y2="2.3"
  x3="3.4" y3="4.5" z3="5.6"
  convention="ABC" dictRef="chem:atom"
>
  <scalar title="dipole" dictRef="d:dip"
    units="units:debye">0.2</scalar>
  <atomParity atomRefs4="a3 a7 a2 a4">1</atomParity>
  <electron id="e1" atomRef="a1" count="2"/>
</atom>
</cml>
</pre></div>
         </xsd:documentation>
         <xsd:appinfo>
         </xsd:appinfo>
      </xsd:annotation>
      <xsd:complexType>

     <xsd:choice>
         <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element ref="name"/>
            <xsd:element ref="array"/>
            <xsd:element ref="matrix"/>
            <xsd:element ref="scalar"/>
            <xsd:element ref="atomParity"/>
            <xsd:element ref="electron">
               <xsd:annotation>
                  <xsd:documentation>
                     <div class="general"><p>
                     One or more electrons associated with the atom. The <a href="st.atomRefType">atomRef</a> on the <tt>electron</tt> should
                     point to the id on the atom. We may relax this later and allow
                     reference by context.</p>
                    </div>
                  </xsd:documentation>
               </xsd:annotation>
            </xsd:element>
         </xsd:choice>
<!-- CML-1 (deprecated) -->
         <xsd:choice minOccurs="0" maxOccurs="unbounded">
       <xsd:element ref="float" minOccurs="0" maxOccurs="unbounded"/>
       <xsd:element ref="integer" minOccurs="0" maxOccurs="unbounded"/>
       <xsd:element ref="string" minOccurs="0" maxOccurs="unbounded"/>
     </xsd:choice>
     </xsd:choice>

         <xsd:attributeGroup ref="id"/>
<!-- do not understand this; error in Xerces -->
         <xsd:attribute id="el.atom.count" name="count" type="countType">
<!--         <xsd:attribute id="el.atom.count" name="count" type="xsd:float" default="1">-->
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">The occurrence count of the atom.
               </div>
                  <div class="description">Most useful in <tt>formula</tt>
                  but possibly useful in <tt>atomArray</tt> where coordinates and
                  connectivity is not defined. No formal default, but assumed to be 1.
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.elementType" name="elementType" type="elementTypeType">
            <xsd:annotation>
               <xsd:documentation>
               <div class="general"><p>The elementType. Almost mandatory</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.formalCharge" name="formalCharge" type="formalChargeType">
            <xsd:annotation>
               <xsd:documentation>
                 <div class="summary">The formalCharge on the atom</div>
               <div class="description">NOT the calculated charge or oxidation state. No formal default, but its absence implies 0. It may be good practice to include it explicitly.
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.hydrogenCount" name="hydrogenCount" type="hydrogenCountType">
            <xsd:annotation>
               <xsd:documentation>
               <div class="general"><p>The explicit hydrogen count</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.nonHydrogenCount" name="nonHydrogenCount" type="nonHydrogenCountType">
            <xsd:annotation>
               <xsd:documentation>
               <div class="general"><p>The non-hydrogen count (obsolete - moved to CML Query)</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.isotope" name="isotope" type="isotopeType">
            <xsd:annotation>
               <xsd:documentation>
                <div class="general"><p>The isotopic mass. Default implies "natural abundance"</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.occupancy" name="occupancy" type="occupancyType">
            <xsd:annotation>
               <xsd:documentation>
                <div class="general"><p>The occupancy (mainly from crystallography)</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.x2" name="x2" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The x coordinate of a 2-D representation (unrelated to 3-D structure).
             Note that x- and y- 2D coordinates are required for graphical stereochemistry
             such as wedge/hatch. x- and y- coordinates must be both present or both absent.</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.x3" name="x3" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The x coordinate of a 3-D cartesian representation.
              x3 y3 and z3 coordinates must be both present or both absent.</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.xFract" name="xFract" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The fractional x coordinate in a crystal structure.
              xFract, yFract and zFract coordinates must be all present or all absent.
              A <tt>crystal</tt> element is required</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.xy2" name="xy2" type="coordinate2Type">
            <xsd:annotation>
               <xsd:documentation>
               <div class="general"><p>The combined x and y coordinates of a 2-D representation (unrelated to 3-D structure).
             Note that x- and y- 2D coordinates are required for graphical stereochemistry
             such as wedge/hatch.</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.xyz3" name="xyz3" type="coordinate3Type">
            <xsd:annotation>
               <xsd:documentation>
               <div class="general"><p>The combined x, y, z coordinates of a 3-D cartesian representation.</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.xyzFract" name="xyzFract" type="coordinate3Type">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The combined x, y, z fractional coordinates in a crystal structure.
              A <tt>crystal</tt> element is required</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.y2" name="y2" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The y coordinate of a 2-D representation (unrelated to 3-D structure).
             Note that x2 and y2 coordinates are required for graphical stereochemistry
             such as wedge/hatch. x2 and y2 coordinates must be both present or both absent.</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.y3" name="y3" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The y coordinate of a 3-D cartesian representation.
              x3 y3 and z3 coordinates must be both present or both absent.</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.yFract" name="yFract" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The fractional x coordinate in a crystal structure.
              xFract, yFract and zFract coordinates must be all present or all absent.
              A <tt>crystal</tt> element is required</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.z3" name="z3" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
              <div class="general"><p>The z coordinate of a 3-D cartesian representation.
              x3 y3 and z3 coordinates must be both present or both absent.</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.zFract" name="zFract" type="xsd:float">
            <xsd:annotation>
               <xsd:documentation>
             <div class="general"><p>The fractional x coordinate in a crystal structure.
              xFract, yFract and zFract coordinates must be all present or all absent.
              A <tt>crystal</tt> element is required</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attributeGroup ref="title"/>
         <xsd:attributeGroup ref="convention"/>
         <xsd:attributeGroup ref="dictRef"/>
         <xsd:attributeGroup ref="ref"/>
         <xsd:attribute name="role">
           <xsd:annotation>
              <xsd:documentation>
            <div class="general"><p>This can be used to describe the purpose of atoms whose <tt>elementType</tt>s are <tt>dummy</tt> or <tt>locant</tt>. </p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>

<!-- attribute extensions to core CML -->
<!-- atom.atts.extensions -->
<!-- this is reserved for extending core CML through attributes to atoms -->


      </xsd:complexType>
   </xsd:element>

      <xsd:element name="atomArray" id="el.atomArray">
      <xsd:annotation>
         <xsd:documentation>
          <div class="summary">A container for a list of atoms</div>
          <div class="description">A child of <a href="el.molecule">molecule</a> and contains
        <tt>atom</tt> information. There are two strategies:
        <ul>
                  <li>Create individual <a href="el.atom">atom</a> elements under
                  <a href="el.atomArray">atomArray</a>
        (in any order). This gives the greatest flexibility but is the most verbose.</li>
                  <li>Create <tt>*Array</tt> attributes (e.g. of
                  <a href="st.elementTypeArrayType">elementTypeArrayType</a> under
        <a href="el.atomArray">atomArray</a>. 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 <a href="el.atomParity">atomParity</a>
        or composite types such as <tt>xy2</tt>.
        It also cannot be checked as easily by schema- and schematron validation. The
        <tt>atomIDArray</tt> attribute is mandatory. It is allowed (though not yet recommended) to
        add <tt>*Array</tt> children such as <a href="el.floatArray">floatArray</a>
                  </li>
               </ul>
               <p>The attributes are directly related to the scalar attributes under
        <a href="el.atom">atom</a> which should be consulted for more info.</p>
    <p>NOTE: The CML-1 specifications are also supported but are deprecated</p>
    </div>
    <div class="example">
      <p>Example - these are exactly equivalent representations</p>
       <pre>
<cml title="atomArray CML1">
<list>
  <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"/>
</list>
</cml>

       </pre>
    </div>
    </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:choice>
            <xsd:element ref="atom" maxOccurs="unbounded"/>
            <xsd:element ref="array" minOccurs="0" maxOccurs="unbounded"/>
<!-- CML-1 (deprecated) -->
        <xsd:choice minOccurs="0" maxOccurs="unbounded">
          <xsd:element ref="floatArray" minOccurs="0" maxOccurs="unbounded"/>
          <xsd:element ref="integerArray" minOccurs="0" maxOccurs="unbounded"/>
          <xsd:element ref="stringArray" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:choice>
         </xsd:choice>

         <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
         <xsd:attribute name="elementType" type="elementTypeArrayType">
            <xsd:annotation>
               <xsd:documentation>
                   <div class="summary">Almost mandatory. see <a href="el.atom.elementType">elementType</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="count" type="integerArrayType">
            <xsd:annotation>
               <xsd:documentation>
                   <div class="summary">See <a href="el.atom.count">count</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="formalCharge" type="integerArrayType">
            <xsd:annotation>
               <xsd:documentation>
                   <div class="summary">See <a href="el.atom.formalCharge">formalCharge</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="hydrogenCount" type="integerArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">See <a href="el.atom.hydrogenCount">hydrogenCount</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="nonHydrogenCount" type="integerArrayType">
            <xsd:annotation>
               <xsd:documentation>
                 <div class="summary">See <a href="el.atom.nonHydrogenCount">nonHydrogenCount</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="isotope" type="floatArrayType">
            <xsd:annotation>
               <xsd:documentation>
                   <div class="summary">See <a href="el.atom.isotope">isotope</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="occupancy" type="floatArrayType">
            <xsd:annotation>
               <xsd:documentation>
                   <div class="summary">See <a href="el.atom.occupancy">occupancy</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="x2" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">See <a href="el.atom.x2">x2</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="x3" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">See <a href="el.atom.x3">x3</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="xFract" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">See <a href="el.atom.xFract">xFract</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="y2" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">See <a href="el.atom.y2">y2</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="y3" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                      <div class="summary">See <a href="el.atom.y3">y3</a></div>
             </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="yFract" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">See <a href="el.atom.yFract">yFract</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="z3" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                    <div class="summary">See <a href="el.atom.z3">z3</a></div>
             </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="zFract" type="coordinateComponentArrayType">
            <xsd:annotation>
               <xsd:documentation>
                    <div class="summary">See <a href="el.atom.zFract">zFract</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="atomID" type="atomRefArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">See <a href="el.atom.id">atomID</a></div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
        <xsd:attributeGroup ref="ref">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">Available for subclassing to provide alternative collections for atoms.</div>
              </xsd:documentation>
            </xsd:annotation>
        </xsd:attributeGroup>
      </xsd:complexType>
   </xsd:element>


   <xsd:element name="atomParity" id="el.atomParity">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">The stereochemistry round an atom centre. </div>
      <div class="description">
            <p>It follows the
        convention of the MIF format, and uses 4 distinct atoms to define the
        chirality. These can be any atoms (though they are normally bonded to
        the current atom). There is no default order and the order is defined
        by the atoms in the atomRefs4 attribute. If there are only 3 ligands, the
        current atom should be included in the 4 atomRefs.
        </p>
            <p>The value of the parity is a signed number. (It can only be zero if
        two or more atoms are coincident or the configuration is planar). The
        sign is the sign of the chiral volume created by the four atoms (a1, a2,
        a3, a4):</p>
            <pre>
       |  1  1  1  1 |
       | x1 x2 x3 x4 |
       | y1 y2 y3 y4 |
       | z1 z2 z3 z4 |
        </pre>
            <p>Note that <tt>atomParity</tt> cannot be used with the *Array syntax for
        atoms.</p>
      </div>
      <div class="example">
       <pre>
<cml title="atom parity example">
  <atom id="a1">
    <atomParity atomRefs4="a3 a5 a2 a9">1</atomParity>
  </atom>
</cml>

       </pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:float">
        <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
        <xsd:attributeGroup ref="atomRefs4"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

     <xsd:element name="bond" id="el.bond">
      <xsd:annotation>
         <xsd:documentation>
         <div class="summary">A bond between <a href="el.atom">atom</a>s, or between atoms and bonds</div>
           <div class="general"><p>
               <tt>bond</tt> is a child of <tt>bondArray</tt> and contains
          bond information. Bond must refer to at least two atoms (using
          <a href="st.atomRefs2Type">atomRefs2</a>)
          but may also refer to more for multicentre bonds. Bond is often EMPTY but
          may contain <a href="el.electron">electron</a>, <a href="el.length">length</a>
          or <a href="el.bondStereo">bondStereo</a> elements.</p></div>
      <div class="example">
       <pre>
<cml title="bondArray example">
  <bondArray>
    <bond id="b1" atomRefs2="a3 a8" order="D">
      <electron bondRef="b1"/>
      <bondStereo>C</bondStereo>
    </bond>
    <bond id="b2" atomRefs2="a3 a8" order="S">
      <bondStereo convention="MDL" conventionValue="6"/>
    </bond>
  </bondArray>
</cml>

       </pre>
      </div>
      <div class="example">
       <pre>
<cml title="metal-bond example">
<!-- Zeise's salt: [Cl3Pt(CH2=CH2)]- -->
  <atomArray>
    <atom id="pt1" elementType="Pt"/>
    <atom id="cl1" elementType="Cl"/>
    <atom id="cl2" elementType="Cl"/>
    <atom id="cl3" elementType="Cl"/>
    <atom id="c1" elementType="C" hydrogenCount="2"/>
    <atom id="c2" elementType="C" hydrogenCount="2"/>
  </atomArray>
  <bondArray>
    <bond id="b1" atomRefs2="c1 c2" order="D"/>
    <bond id="b2" atomRefs2="pt1 cl1" order="S"/>
    <bond id="b3" atomRefs2="pt1 cl2" order="S"/>
    <bond id="b4" atomRefs2="pt1 cl3" order="S"/>
    <bond id="b5" atomRefs="pt1" bondRefs="b1"/>
  </bondArray>
</cml>

       </pre>
      </div>
       </xsd:documentation>
       <xsd:documentation>
      <div class="validation">
       <pre>

       </pre>
      </div>
       </xsd:documentation>
        <xsd:appinfo>
          <val:comment>Validate Bonds</val:comment>
          <val:template match="bond" id="val-bond">
          <val:comment>Atom Refs for 2-atom bond</val:comment>
            <val:variable name="at1" select="substring-before(normalize-space(@atomRefs2),' ')"/>
            <val:variable name="at2" select="substring-after(normalize-space(@atomRefs2),' ')"/>
            <val:comment>Do both atoms exist in current molecule context?</val:comment>
            <val:if test="not(key('atoms', $at1))">
              <val:call-template name="error">
                <val:with-param name="error">BOND (<val:value-of select="@id"/>): ATOMREF not found: <val:value-of select="$at1"/></val:with-param>
              </val:call-template>
            </val:if>
          </val:template>
        </xsd:appinfo>
      </xsd:annotation>
      <xsd:complexType>
        <xsd:choice>
         <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element ref="electron">
               <xsd:annotation>
                  <xsd:documentation>
                    <div class="summary">One or more electrons associated with the bond</div>
                     <div class="general"><p>. The <a href="st.bondRefType">bondRef</a> on the <tt>electron</tt> should
                     point to the id on the bond. We may relax this later and allow
                     reference by context.(We </p>
                  </div>
                 </xsd:documentation>
               </xsd:annotation>
            </xsd:element>
            <xsd:element ref="bondStereo">
               <xsd:annotation>
                  <xsd:documentation>
                    <div class="summary">The stereo convention for the bond</div>
                     <div class="general"><p>only one convention allowed</p>
                   </div>
                 </xsd:documentation>
               </xsd:annotation>
            </xsd:element>
            <xsd:element ref="length">
               <xsd:annotation>
                  <xsd:documentation>
                    <div class="summary">the length between the atoms</div>
                    <div class="general"><p>This is either an experimental measurement
              or used to build up internal coordinates (as in a z-matrix)  (only one allowed)</p>
              <p>We expect to move length as a child of <a href="el.molecule">molecule</a> and
              remove it from here</p>
                  </div>
                 </xsd:documentation>
               </xsd:annotation>
            </xsd:element>
         </xsd:choice>
<!-- CML-1 (deprecated) -->
         <xsd:choice minOccurs="0" maxOccurs="unbounded">
       <xsd:element ref="float" minOccurs="0" maxOccurs="unbounded"/>
       <xsd:element ref="integer" minOccurs="0" maxOccurs="unbounded"/>
       <xsd:element ref="string" minOccurs="0" maxOccurs="unbounded"/>
     </xsd:choice>
       </xsd:choice>

         <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
         <xsd:attributeGroup ref="ref"/>
         <xsd:attribute name="atomRefs2" type="atomRefs2Type">
            <xsd:annotation>
               <xsd:documentation>
                 <div class="summary">The two atoms in the bond</div>
                 <div class="general"><p>. This will be the normal reference attribute on the bond element. The order of atoms is preserved and may
                  matter for some conventions (e.g. wedge/hatch or donor bonds)</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="atomRefs" type="atomRefArrayType">
            <xsd:annotation>
               <xsd:documentation>
                 <div class="summary">The atoms in the bond</div>
                 <div class="general"><p>. This is designed for multicentre bonds (as in delocalised systems or electron-deficient centres. The semantics are experimental at this stage. As an example, a B-H-B bond might be described as
                 <tt><bond atomRefs="b1 h2 b2"/></tt></p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="bondRefs" type="bondRefArrayType">
            <xsd:annotation>
               <xsd:documentation>
                 <div class="summary">Bonds involved in the bond</div>
                 <div class="general"><p>. This is designed for pi-bonds and other systems where formal valence bonds are not drawn to atoms. The semantics are experimental at this stage. As an example, a Pt-|| bond (as the Pt-ethene bond in Zeise's salt) might be described as
                 <tt><bond atomRefs="pt1" bondRefs="b32"/></tt></p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="order" type="orderType">
            <xsd:annotation>
               <xsd:documentation>
                    <div class="summary">The order of the bond</div>
                 <div class="general"><p>There is NO default. This order is for
               bookkeeping only and is not related to length, QM calculations
               or other experimental or theoretical calculations.
               see <a href="st.orderType">
                        <tt>orderType</tt>
                     </a>
                  </p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>

<!-- attribute extensions to core CML -->
<!-- atom.atts.extensions -->
<!-- this is reserved for extending core CML through attributes to bonds -->


         </xsd:complexType>
   </xsd:element>


   <xsd:element name="bondArray" id="el.bondArray">
      <xsd:annotation>
         <xsd:documentation>
           <div class="summary">A container for a number of <a href="el.bond">bond</a></div>
           <div class="description">
            <p>
               <tt>bondArray</tt> is a child of <tt>molecule</tt> and contains
          <tt>bond</tt> information. There are two strategies:</p>
            <ul>
               <li>Create individual <tt>bond</tt> elements under <tt>bondArray</tt>
        (in any order). This gives the greatest flexibility but is the most verbose.</li>
               <li>Create <tt>*Array</tt> attributes (e.g. of <tt>orderArrayType</tt> under
        <tt>bondArray</tt>. This requires all arrays to be of identical lengths
        with explicit values for all bonds in every array.
        This is NOT suitable for complexType
        bond children such as <a href="el.bondStereo">
                     <tt>bondStereo</tt>
                  </a>,
        nor can IDs be added to bonds..
        It also cannot be checked as easily by schema- and schematron validation. The
        <tt>atomRef1Array</tt> and <tt>atomRef2Array</tt> attributes are then
        mandatory. It is allowed (though not yet recommended) to
        add <tt>*Array</tt> children such as <tt>floatArray</tt>
               </li>
            </ul>
            <p>The attributes are directly related to the scalar attributes under
        <a href="el.atom">
                  <tt>atom</tt>
               </a> which should be consulted for more info.</p>
               </div>
           <div class="example">
            <p>Example - these are exactly equivalent representations</p>
            <pre>
<cml title="bondArray example 1">
  <list>
    <bondArray>
      <bond id="b1" atomRefs2="a1 a2"
        order="1"/>
      <bond id="b2" atomRefs2="a1 a3" order="2"/>
      <bond id="b3" atomRefs2="a3 a5" order="1"/>
    </bondArray>
    <bondArray
      atomRef1="a1 a1 a3"
      atomRef2="a2 a3 a5"
      order="1 2 1"/>
  </list>
</cml>

            </pre>
        </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:choice>
            <xsd:element ref="bond" maxOccurs="unbounded"/>
            <xsd:element ref="array" minOccurs="0" maxOccurs="unbounded"/>
<!-- CML-1 (deprecated) -->
        <xsd:choice minOccurs="0" maxOccurs="unbounded">
          <xsd:element ref="floatArray" minOccurs="0" maxOccurs="unbounded"/>
          <xsd:element ref="integerArray" minOccurs="0" maxOccurs="unbounded"/>
          <xsd:element ref="stringArray" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:choice>
         </xsd:choice>

         <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
         <xsd:attribute name="bondID" type="bondRefArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <p>The IDs for the bonds. Required in array mode</p>
               </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="atomRef1" type="atomRefArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <p>The first atoms in each bond. Required in array mode</p>
               </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="atomRef2" type="atomRefArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <p>The second atoms in each bond. Required in array mode</p>
               </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="order" type="orderArrayType">
            <xsd:annotation>
               <xsd:documentation>
                  <p>The bond orders in each bond. Used in array mode</p>
               </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
      </xsd:complexType>
   </xsd:element>

   <xsd:element name="cml" id="el.cml">
   <xsd:annotation>
      <xsd:documentation>
   <div class="summary">A general container for CML elements</div>
   <div class="description">
         <p>Often the root of the
             CML (sub)document. Has no explicit function but serves to hold
             the dictionaries, namespace, and can alert CML processors and search/XMLQuery tools
             that there is chemistry in the document. Can contain
             any content, but usually a list of molecules and other CML
             components. Can be nested</p>
             </div>
      <div class="example">
       <pre>

       </pre>
      </div>
      </xsd:documentation>
   </xsd:annotation>
   <xsd:complexType>
     <xsd:sequence minOccurs="0" maxOccurs="unbounded">
       <xsd:annotation>
         <xsd:documentation>
           <div class="description">No specific restrictions</div>
         </xsd:documentation>
       </xsd:annotation>
       <xsd:any processContents="lax"/>
     </xsd:sequence>
     <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
   </xsd:complexType>
</xsd:element>

   <xsd:element name="crystal" id="el.crystal">
   <xsd:annotation>
      <xsd:documentation>
       <div class="summary">A container for crystallographic
       cell parameters and spacegroup</div>
   <div class="description">
         <p>. Required if
     fractional coordinates are provided for a molecule.</p>
     <p>There are precisely SIX child <tt>scalar</tt>s to represent the cell lengths
     and angles in that order. There are no default values; </p></div>
   <div class="example">
    <pre>
<cml title="crystal example">
  <molecule id="m1">
    <crystal z="4">
      <scalar title="a" errorValue="0.001" units="units:angstrom">4.500</scalar>
      <scalar title="b" errorValue="0.001" units="units:angstrom">4.500</scalar>
      <scalar title="c" errorValue="0.001" units="units:angstrom">4.500</scalar>
      <scalar title="alpha" units="units:degree">90</scalar>
      <scalar title="beta" units="units:degree">90</scalar>
      <scalar title="gamma" units="units:degree">90</scalar>
      <symmetry id="s1" spaceGroup="Fm3m"/>
    </crystal>
    <atomArray>
      <atom id="a1" elementType="Na" formalCharge="1" xyzFract="0.0 0.0 0.0" xy2="+23.2 -21.0"/>
      <atom id="a2" elementType="Cl" formalCharge="-1" xyzFract="0.5 0.0 0.0"/>
    </atomArray>
  </molecule>
</cml>

    </pre>
   </div>
     </xsd:documentation>
   </xsd:annotation>
   <xsd:complexType>
     <xsd:sequence>
       <xsd:element ref="scalar" minOccurs="6" maxOccurs="6">
         <xsd:annotation>
            <xsd:documentation>
      <div class="summary">All 6 cell parameters must be given, even where angles are
      fixed by symmetry. The order is fixed as a,b,c,alpha,gamma,beta and software can
      neglect any title or dictRef attributes. Error estimates can be given if required.
      Any units can be used, but the defaults are Angstrom (10^-10 m) and degrees.
    </div>
            </xsd:documentation>
         </xsd:annotation>
       </xsd:element>
       <xsd:element ref="symmetry" minOccurs="0"/>
     </xsd:sequence>
      <xsd:attribute name="z" type="xsd:nonNegativeInteger">
         <xsd:annotation>
            <xsd:documentation>
               <p>The number of molecules per cell. Molecules
         are defined as the <tt>molecule</tt> which directly contains
         the <tt>crystal</tt> element.</p>
            </xsd:documentation>
         </xsd:annotation>
      </xsd:attribute>
      <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
   </xsd:complexType>
</xsd:element>


   <xsd:element name="electron" id="el.electron">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">One or more electrons</div>
      <div class="description">
            <p>Since there is very little use of electrons in current
            chemical information this is a fluid concept. I expect it to be used for electron
            counting, input and output of theochem operations, descriptions of orbitals,
            spin states, oxidation states, etc. Electrons can be associated with atoms, bonds
            and combinations of these. At present there is no hardcoded semantics. However,
            <tt>atomRef</tt> and similar attributes can be used to associate electrons with
            atoms or bonds
        </p></div>
       <div class="example">
       <pre>
<cml title="electron example">
  <molecule id="m1">
    <atomArray atomID="a1 a2 a3 a4 a5 a6"/>
    <bondArray
      order="A A A A A A"
      bondID="b1 b2 b3 b4 b5 b6"
      atomRef1="a1 a2 a3 a4 a5 a6"
      atomRef2="a6 a1 a2 a3 a4 a5"/>
    <electron count="6"
      bondRefs="b1 b2 b3 b4 b5 b6"
      atomRefs="a1 a2 a3 a4 a5 a6"/>
  </molecule>
</cml>


       </pre>
      </div>
        </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:sequence/>
         <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
         <xsd:attribute name="atomRef" type="atomRefType"/>
         <xsd:attribute name="atomRefs" type="atomRefArrayType"/>
         <xsd:attribute name="bondRef" type="bondRefType"/>
         <xsd:attribute name="bondRefs" type="bondRefArrayType"/>
         <xsd:attribute name="count" type="xsd:positiveInteger">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">The number of electrons</div>
               <div class="description">No formal default, but assumed to be 1. At present restricted to integers.
               </div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
        <xsd:attributeGroup ref="ref">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">Available for subclassing to provide alternative properties for atoms.</div>
              </xsd:documentation>
            </xsd:annotation>
        </xsd:attributeGroup>
      </xsd:complexType>
   </xsd:element>

      <xsd:element name="formula" id="el.formula">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">The stochiometry of the molecule</div>
      <div class="description">
            <p>It is
        defined by <tt>atomArray</tt>s each with a list of elementTypes and their
        counts (or default=1). All other information in the <tt>atomArray</tt>
        is ignored. <tt>formula</tt> are nestable so that aggregates (e.g. hydrates,
        salts, etc.) can be described. CML does not require that formula information
        is consistent with (say) crystallographic information; this allows for
        experimental variance.</p>
        <p>An alternative briefer representation is also available through the
        <tt>conciseForm</tt>. This must include whitespace round all elements and
        their counts, which must be explicit. </p>
      </div>
      <div class="example">
       <pre>
<cml title="formula example">
  <molecule id="sulfuricAcid">
    <formula concise="H 2 S 1 O 4"/>
  </molecule>
  <molecule id="CuprammoniumSulfate">
    <formula title="[Cu(NH3)4]2+ SO42-]">
      <formula formalCharge="+2">
        <atomArray elementType="Cu"/>
        <formula count="4">
          <atomArray elementType="N H" count="1 3"/>
        </formula>
      </formula>
      <formula formalCharge="-2">
        <atomArray elementType="S O" count="1 4"/>
      </formula>
    </formula>
  </molecule>
</cml>

       </pre>
      </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:choice>
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
              <xsd:element ref="formula"/>
              <xsd:element ref="atomArray"/>
            </xsd:choice>
         </xsd:choice>
         <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
         <xsd:attribute name="count" type="positiveNumberType">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">A multiplier for the formula</div>
               <div class="description">No formal default but assumed to be 1. Allows for fractional components.</div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="formalCharge" type="xsd:integer">
           <xsd:annotation>
             <xsd:documentation>
            <p>The formal charge is normally calculated from the formal charges of the
            atoms. If the <tt>formalCharge</tt> attribute is given it overrides this
            information completely. This allows (say) metal complexes to be represented
            when it is difficult to apportion the charges to atoms.</p>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="concise" type="formulaType">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">A concise string representing an (unstructured) formula</div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>

      </xsd:complexType>
   </xsd:element>

   <xsd:element name="identifier" id="el.identifier">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">IChI identifier</div>
      <div class="description">
      <p>Supports compund identifiers such as IChI. At present uses the V0.9 IChI XML representation verbatim but will almost certainly change with future IChIs. </p>
      <p>The inclusion of elements from other namespaces causes problems with validation. The content model is deliberately LAX but the actual elements in IChI will fail the validation as they are not declared in CML.</p>
      </div>
      <div class="example"><pre/></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
  <!-- to avoid problems as IChI structure is updated -->
    <xsd:sequence>
      <xsd:element ref="basic"/>
      <xsd:element ref="charge" minOccurs="0"/>
      <xsd:element ref="stereo" minOccurs="0"/>
    </xsd:sequence>
    <xsd:attribute name="version" type="xsd:string"/>
    <xsd:attribute name="tautomeric" type="xsd:string"/>
  </xsd:complexType>
</xsd:element>

      <xsd:element name="basic" id="el.basic">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">IChI basic string</div>
      <div class="description">
      <p>NOT PART OF CML. this is the IChI element supporting the unique string for the connection
      table. It is included in this distribution because validation requires all elements
      to have been declared.</p>
      </div>
    </xsd:documentation>
  </xsd:annotation>
        <xsd:complexType>
          <xsd:simpleContent>
            <xsd:extension base="xsd:string"/>
          </xsd:simpleContent>
        </xsd:complexType>
      </xsd:element>

      <xsd:element name="charge" id="el.charge">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">IChI formal charge</div>
      <div class="description">
      <p>NOT PART OF CML. this is the IChI element supporting the charge on a molecular fragment. It is included in this distribution because validation requires all elements
      to have been declared.</p>
      </div>
    </xsd:documentation>
  </xsd:annotation>
        <xsd:complexType>
          <xsd:simpleContent>
            <xsd:extension base="xsd:string"/>
          </xsd:simpleContent>
        </xsd:complexType>
      </xsd:element>

      <xsd:element name="stereo" id="el.stereo">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">IChI stereo</div>
      <div class="description">
      <p>NOT PART OF CML. this is the IChI element supporting the stereochemistry of a molecular fragment. It is included in this distribution because validation requires all elements
      to have been declared.</p>
      </div>
    </xsd:documentation>
  </xsd:annotation>
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element ref="dbond" minOccurs="0"/>
            <xsd:element ref="sp3" minOccurs="0"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>

             <xsd:element name="dbond" id="el.dbond">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">IChI double bobd stereochemistry</div>
      <div class="description">
      <p>NOT PART OF CML. this is the IChI element supporting the stereochemistry of "double bonds". It is included in this distribution because validation requires all elements
      to have been declared.</p>
      </div>
    </xsd:documentation>
  </xsd:annotation>
              <xsd:complexType>
                <xsd:simpleContent>
                  <xsd:extension base="xsd:string"/>
                </xsd:simpleContent>
              </xsd:complexType>
            </xsd:element>

             <xsd:element name="sp3" id="el.sp3">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">IChI atom-based stereochemistry</div>
      <div class="description">
      <p>NOT PART OF CML. this is the IChI element supporting the stereochemistry of an
      atom. It is included in this distribution because validation requires all elements
      to have been declared.</p>
      </div>
    </xsd:documentation>
  </xsd:annotation>
              <xsd:complexType>
                <xsd:simpleContent>
                  <xsd:extension base="xsd:string"/>
                </xsd:simpleContent>
              </xsd:complexType>
            </xsd:element>


      <xsd:element name="length" id="el.length">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">A length between two atoms</div>
      <div class="description">
            <p/>
      </div>
      <div class="example">
       <pre><cml title="length example">
  <molecule id="m1">
    <atomArray atomID="a1 a2 a3"/>
    <length atomRefs2="a3 a1">1.534</length>
  </molecule>
</cml>
</pre>
      </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:simpleContent>
            <xsd:extension base="xsd:float">
               <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
               <xsd:attributeGroup ref="atomRefs2"/>
               <xsd:attributeGroup ref="units"/>
               <xsd:attributeGroup ref="errorValue"/>
               <xsd:attributeGroup ref="errorBasis"/>
               <xsd:attributeGroup ref="min"/>
               <xsd:attributeGroup ref="max"/>
               <xsd:attributeGroup ref="ref">
                 <xsd:annotation>
                   <xsd:documentation>
                     <div class="summary">Available for subclassing to provide alternative lengths (e.g. in conformations).</div>
                   </xsd:documentation>
                 </xsd:annotation>
               </xsd:attributeGroup>
            </xsd:extension>
         </xsd:simpleContent>
      </xsd:complexType>
   </xsd:element>


   <xsd:element name="molecule" id="el.molecule">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">A container for atoms, bonds and submolecules</div>
      <div class="description">
            <p>
         <tt>molecule</tt> is a container for atoms, bonds and submolecules along
        with properties such as crystal and non-builtin properties. It should either
        contain <tt>molecule</tt> or *Array for atoms and bonds. A molecule
        can be empty (e.g. we just know its name, id, etc.)</p>
        <p>"Molecule" need not represent a chemically meaningful molecule. It
        can contain atoms with bonds (as in the solid-sate) and it could
        simply carry a name (e.g. "taxol") without formal representation
        of the structure. It can contain "sub molecules", which are often
        discrete subcomponents (e.g. guest-host).</p>
        <p>Molecule can contain a <list> element to contain data
        related to the molecule.
        Within this can be string/float/integer and other nested lists</p>
        </div>
        <div class="example">
        <pre><cml title="schematic molecule example">
  <molecule id="dummyId">
    <atomArray>
      <atom id="a1" elementType="C"
        hydrogenCount="0" x2="6.1964" y2="8.988"/>
      <atom id="a2" elementType="C"
        hydrogenCount="0" x2="6.1964" y2="7.587"/>
      <atom id="a3" elementType="C"
        hydrogenCount="2" x2="4.983" y2="6.887"/>
<!-- omitted -->
      <atom id="a28" elementType="C"
        hydrogenCount="3" x2="15.777" y2="6.554"/>
      <atom id="a29" elementType="O"
        hydrogenCount="0" x2="13.388" y2="6.188"/>
    </atomArray>
    <bondArray>
      <bond atomRefs2="a1 a2" order="1"/>
      <bond atomRefs2="a2 a3" order="1"/>
      <bond atomRefs2="a3 a4" order="1"/>
<!-- omitted -->
      <bond atomRefs2="a11 a15" order="1"/>
      <bond atomRefs2="a12 a18" order="1">
        <bondStereo>W</bondStereo>
      </bond>
      <bond atomRefs2="a2 a19" order="1">
        <bondStereo>W</bondStereo>
      </bond>
      <bond atomRefs2="a5 a20" order="2"/>
      <bond atomRefs2="a17 a21" order="1"/>
      <bond atomRefs2="a21 a22" order="1"/>
<!-- omitted -->
      <bond atomRefs2="a10 a9" order="1"/>
      <bond atomRefs2="a16 a29" order="2"/>
    </bondArray>
  </molecule>
</cml>

</pre>
        </div>
         </xsd:documentation>
         <xsd:documentation>
           <div class="curation">Revised content model to allow any order of lengths, angles, torsions 2003-01-01</div>
         </xsd:documentation>
      </xsd:annotation>


      <xsd:complexType>
        <xsd:annotation>
          <xsd:documentation>
           <div>
             <p>The float|integer|string children are for compatibility with CML-1 and are deprecated. scalar|array|matrix should be used instead.</p>
           </div>
          </xsd:documentation>
        </xsd:annotation>

<!-- content model: entity mechanism allows extension to core CML -->
<!-- content extension to core CML -->
<!-- overloaded in derived CML supersets -->

         <xsd:sequence>
           <xsd:element ref="metadataList" minOccurs="0" maxOccurs="unbounded"/>
           <xsd:element ref="formula" minOccurs="0"/>
           <xsd:element ref="identifier" minOccurs="0"/>
           <xsd:element ref="name" minOccurs="0" maxOccurs="unbounded"/>
           <xsd:element ref="symmetry" minOccurs="0"/>
           <xsd:element ref="crystal" minOccurs="0"/>
           <xsd:choice>
             <xsd:element ref="molecule" minOccurs="0" maxOccurs="unbounded"/>
             <xsd:sequence>
               <xsd:element ref="atomArray"/>
               <xsd:element ref="bondArray" minOccurs="0"/>
               <xsd:element ref="electron" minOccurs="0" maxOccurs="unbounded"/>
               <xsd:choice minOccurs="0" maxOccurs="unbounded">
                 <xsd:element ref="length"/>
                 <xsd:element ref="angle"/>
                 <xsd:element ref="torsion"/>
                 </xsd:choice>
             </xsd:sequence>
           </xsd:choice>
           <xsd:sequence minOccurs="0" maxOccurs="unbounded">
             <xsd:element ref="scalar" minOccurs="0" maxOccurs="unbounded"/>
             <xsd:element ref="array" minOccurs="0" maxOccurs="unbounded"/>
             <xsd:element ref="matrix" minOccurs="0" maxOccurs="unbounded"/>
             <xsd:element ref="list" minOccurs="0" maxOccurs="unbounded"/>
           </xsd:sequence>
           <xsd:choice minOccurs="0" maxOccurs="unbounded">
             <xsd:element ref="float" minOccurs="0" maxOccurs="unbounded"/>
             <xsd:element ref="integer" minOccurs="0" maxOccurs="unbounded"/>
             <xsd:element ref="string" minOccurs="0" maxOccurs="unbounded"/>
           </xsd:choice>
     </xsd:sequence>



         <xsd:attributeGroup ref="dictRef"/>
         <xsd:attributeGroup ref="convention"/>
         <xsd:attributeGroup ref="title"/>
         <xsd:attributeGroup ref="id"/>
         <xsd:attributeGroup ref="ref"/>
         <xsd:attribute name="formula" type="formulaType">
           <xsd:annotation>
             <xsd:documentation>
            <p>
        The <tt>formula</tt> attribute should only be used for simple formulae (i.e.
        without brackets or other nesting for which the <a href="el.formula">formula</a>
        child should be used. The attribute might be used as a check on the child
        elements or for ease of representation.</p>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="count" type="positiveNumberType">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">The count for the molecule</div>
               <div class="description">No formal default but assumed to be 1. Fractional values are allowed to describe variable stoichiometry.</div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="chirality">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">The chirality of the complete system</div>
               <div class="description">This is being actively investigated by a IUPAC committee (2002) so the convention is likely to change. No formaldefault</div>
             </xsd:documentation>
           </xsd:annotation>
           <xsd:simpleType>
             <xsd:restriction base="xsd:string">
               <xsd:enumeration value="enantiomer"/>
               <xsd:enumeration value="racemate"/>
               <xsd:enumeration value="unknown"/>
               <xsd:enumeration value="other"/>
             </xsd:restriction>
           </xsd:simpleType>
         </xsd:attribute>
         <xsd:attribute id="el.molecule.formalCharge" name="formalCharge" type="formalChargeType">
            <xsd:annotation>
               <xsd:documentation>
                 <div class="summary">The formalCharge on the molecule</div>
                 <div class="description">NOT the calculated charge or oxidation state.
               This attribute should be used when it is impossible or artificial to assign charges
               to each atom, as in coordination complexes. It is then required that <b>all</b>
               atom formalCharge attributes are omitted. No formal default, but assumed to be zero if omitted. It may become good practice to include it.
                 </div>
               </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.spinMultiplicity" name="spinMultiplicity" type="xsd:positiveInteger">
            <xsd:annotation>
               <xsd:documentation>
               <div class="summary">The spin multiplicity for the molecule</div>
               <div class="description"><p>This attribute gives the spin multiplicity of the molecule
               and is independent of any atomic information. No default, and it may take any positive integer
               value (though values are normally between 1 and 5)</p>
               </div>
              </xsd:documentation>
            </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute id="el.atom.symmetryOriented" name="symmetryOriented" type="xsd:boolean">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Is the molecule oriented to the symmetry</div>
               <div class="description"><p>No formal default, but a molecule is assumed to be oriented according to any
             <symmetry> children. This is required for crystallographic data,
             but some systems for isolated molecules allow specification of arbitrary
             Cartesian or internal coordinates, which must be fitted or refined to
             a prescribed symmetry. In this case the attribute value is <tt>false</tt>.
             </p>
             </div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>

<!-- attribute extensions to core CML -->
<!-- atom.atts.extensions -->
<!-- this is reserved for extending core CML through attributes to molecules -->


      </xsd:complexType>
   </xsd:element>

   <xsd:element name="name" id="el.name">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A string identifying a <a href="el.molecule">molecule</a>,
<a href="el.atom">atom</a> or (possibly) other elements.
      </div>
      <div class="description">
            <p><tt>name</tt> is used for chemical names (formal and trivial)
            for molecules and also for identifiers such as CAS registry and RTECS.
            It can also be used for labelling atoms. It should be used
            in preference to the <tt>title</tt>
            attribute because it is repeatable and can be linked to a
            dictionary.
</p>
<p>Constraining patterns can be described in the dictionary and used to
validate <tt>name</tt>s.</p>
      </div>
      <div class="example">
        <pre>
<cml title="name example">
  <molecule id="aspirin">
    <name convention="INN"> name="builtin" type="xsd:string"in</name>
    <name convention="IUPAC">2-acetoxybenzoic acid</name>
    <name convention="trivial">acetylsalicylic acid</name>
  </molecule>
</cml>

        </pre>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:string">
        <xsd:attributeGroup ref="id"/>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attributeGroup ref="dictRef"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

   <xsd:element name="property" id="el.property">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A container for a property</div>
      <div class="description">
        <p><tt>property</tt> can contain one or more children, usually <tt>scalar</tt>, <tt>array</tt> or <tt>matrix</tt>. The <tt>dictRef</tt> attribute is required, even if there is a single scalar child with the same dictRef. The property may have a different dictRef from the child, thus providing an extension mechanism.
        </p>
        <p>Properties may have a <tt>state</tt> attribute to distinguish the state of matter</p>
      </div>
      <div class="example">
        <pre/>
      </div>
    </xsd:documentation>
  </xsd:annotation>

  <xsd:complexType>
    <xsd:sequence>
      <xsd:element ref="metadataList" minOccurs="0" maxOccurs="unbounded"/>
      <xsd:element ref="name" minOccurs="0" maxOccurs="unbounded"/>
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="scalar"/>
        <xsd:element ref="array"/>
        <xsd:element ref="matrix"/>
        <!-- content extension to core CML -->
<!-- overloaded in derived CML supersets -->



      </xsd:choice>
    </xsd:sequence>
    <xsd:attributeGroup ref="dictRef"/>
    <xsd:attributeGroup ref="convention"/>
    <xsd:attributeGroup ref="title"/>
    <xsd:attributeGroup ref="id"/>
    <xsd:attributeGroup ref="ref"/>
    <xsd:attribute name="role" id="property.att.role">
      <xsd:annotation>
        <xsd:documentation>
          <div>
            <p>The role of the property. Semantics are not yet controlled but could include thermochemistry, kinetics or other common properties.</p>
          </div>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
    <xsd:attribute name="state" type="stateType" id="property.att.state">
      <xsd:annotation>
        <xsd:documentation>
          <div>
            <p>The role of the property. Semantics are not yet controlled but could include thermochemistry, kinetics or other common properties.</p>
          </div>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
  </xsd:complexType>
</xsd:element>

   <xsd:element name="propertyList" id="el.propertyList">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A container for one or more properties</div>
      <div class="description">
        <p><tt>propertyList</tt> can contain several properties. These include (but are not limited to observations, or numeric quantities.
        </p>
      </div>
      <div class="example">
        <pre/>
      </div>
    </xsd:documentation>
  </xsd:annotation>

  <xsd:complexType>
    <xsd:sequence>
      <xsd:element ref="metadataList" minOccurs="0" maxOccurs="unbounded"/>
      <xsd:element ref="name" minOccurs="0" maxOccurs="unbounded"/>
      <xsd:choice minOccurs="0" maxOccurs="unbounded">
        <xsd:element ref="property"/>
        <xsd:element ref="observation"/>
      </xsd:choice>
<!--      <xsd:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>-->
    </xsd:sequence>
    <xsd:attributeGroup ref="dictRef"/>
    <xsd:attributeGroup ref="convention"/>
    <xsd:attributeGroup ref="title"/>
    <xsd:attributeGroup ref="id"/>
    <xsd:attributeGroup ref="ref"/>
    <xsd:attribute name="role">
      <xsd:annotation>
        <xsd:documentation>
          <div>
            <p>The role of the propertyList. Semantics are not yet controlled but could include thermochemistry, kinetics or other common properties.</p>
          </div>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
  </xsd:complexType>
</xsd:element>

      <xsd:element name="bondStereo" id="el.bondStereo">
      <xsd:annotation>
         <xsd:documentation>
           <div class="summary">A container supporting "cis/trans", "wedge hatch"
           and other stereochemistry. </div>
            <div class="description"><p>An explict
        list of atomRefs must be given, or it must be a child of <tt>bond</tt>.
        There are no implicit conventions
        such as E/Z. This will be extended to other types
        of stereochemistry.</p>
        <p>At present the following are supported:</p>
        <ul>
          <li>No atomRefs attribute. <b>Deprecated, but probably unavoidable</b>.
          This must be a child of <tt>bond</tt> where it picks up the two atomRefs
          in the <tt>atomRefs2</tt> attribute. Possible values are C/T (which only makes sense
          if there is exactly one ligand at each end of the bond) and W/H. The latter
          should be raplaced by <tt>atomParity</tt> wherever possible. Note that W/H makes
          no sense without 2D atom coordinates.</li>
          <li><b>atomRefs4 attribute</b>. The 4 atoms represent a cis or trans configuration.
          This may or may not be a child of <tt>bond</tt>; if so the second and third atomRefs
          should be identical with the two atomRefs in the bond. This structure can be used
          to guide processors in processing stereochemistry and is recommended, since there is
          general agreement on the semantics. The semantics of <tt>bondStereo</tt> not related to
          bonds is less clear (e.g. cumulenes, substituted ring nuclei) etc.It is
          currently an error to have more than one <tt>bondStereo</tt> referring to the same ordered
          4-atom list</li>
          <li><b>atomRefs attribute</b>. There are other stereochemical conventions such as cis/trans
          for metal complexes which require a variable number of reference atoms. This allows
          users to create their own - at present we do not see CML creating exhaustive tables.
          For example cis/trans square-planar complexes might require 4 (or 5) atoms for their
          definition, octahedral 6 or 7, etc. In principle this is very powerful and could
          supplement or replace the use of <i>cis-</i>, <i>mer-</i>, etc.</li>
        </ul>
        <p>the <tt>atomRefs</tt> and <tt>atomRefs4</tt> attributes cannot be used
        simultaneously.</p></div>
        <div class="example">
        <pre>
<cml title="bondArray example">
  <bondArray>
    <bond id="b1" atomRefs2="a3 a8" order="D">
      <electron bondRef="b1"/>
      <bondStereo>C</bondStereo>
    </bond>
    <bond id="b2" atomRefs2="a3 a8" order="S">
      <bondStereo convention="MDL" conventionValue="6"/>
    </bond>
  </bondArray>
</cml>

        </pre>
        </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:simpleContent>
            <xsd:extension base="stereoType">
               <xsd:attributeGroup ref="atomRefs4"/>
               <xsd:attributeGroup ref="atomRefArray"/>
               <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
               <xsd:attribute name="conventionValue" type="xsd:string">
                 <xsd:annotation>
                   <xsd:documentation>
                     <div class="summary">The stereo value when the <tt>convention</tt>
                     attribute is used</div>
                     <div class="description">When convention is used this attribute must be present
                     and element content must be empty.</div>
                   </xsd:documentation>
                 </xsd:annotation>
               </xsd:attribute>
            </xsd:extension>
         </xsd:simpleContent>
      </xsd:complexType>
   </xsd:element>

   <xsd:element name="substance" id="el.substance">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">A "chemical substance" </div>
      <div class="description">
          <p>
      <tt>substance</tt> represents a "chemical substance" which is deliberately very
        general. It can represent things that may or may not be molecules, can and cannot be stored
        in bottles and may or may not be microscopic. Solutions and mixtures
        can be described by <a href="el.substanceList">
        substanceList</a>s of substances. The <tt>type</tt> attribute can be used to give qualitative information characterising the substance ("granular", "90%", etc.)
        and <tt>role</tt> to describe the role in process ("desiccant", "support", etc.). There is currently no controlled vocabulary.
        Note that <tt>reaction</tt> is likely to have more precise semantics.</p>
      <p>The amount of a substance is controlled by the optional <tt>amount</tt> child</p>
      </div>
      <div class="example">
        <pre><cml title="substance example">
  <substance title="ethanol" id="ethanol">
    <amount units="units:l">1.2</amount>
  </substance>
</cml>

</pre>
      </div>
    </xsd:documentation>
    <xsd:documentation>
      <div class="curation">
        <p>Added property as a child 2002-12-29</p>
      </div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element ref="metadataList" minOccurs="0" maxOccurs="unbounded"/>
      <xsd:element ref="amount" minOccurs="0"/>
      <xsd:choice>
        <xsd:element ref="molecule" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:element ref="name" minOccurs="0" maxOccurs="unbounded"/>
        <xsd:element ref="property" minOccurs="0" maxOccurs="unbounded"/>
      </xsd:choice>
    </xsd:sequence>
    <xsd:attributeGroup ref="dictRef"/>
    <xsd:attributeGroup ref="convention"/>
    <xsd:attributeGroup ref="title"/>
    <xsd:attributeGroup ref="id"/>
    <xsd:attribute name="type" type="xsd:string">
      <xsd:annotation>
        <xsd:documentation>
         <p>
      <tt>type</tt> can represent concepts such as physical form, but is not limited
        to any vocabulary.</p>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
    <xsd:attribute name="role" type="xsd:string">
      <xsd:annotation>
        <xsd:documentation>
          <p>
      <tt>role</tt> depends on context, and indicates some purpose associated with
        the substance. It might indicate 'catalyst', 'solvent', 'antoxidant', etc. but is not limited
        to any vocabulary.</p>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
    <xsd:attributeGroup ref="ref"/>
    <xsd:attribute name="count" type="positiveNumberType">
      <xsd:annotation>
        <xsd:documentation>
          <div class="summary">The count of the substance</div>
          <div class="description">No fixed semantics or default.
          </div>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
    <xsd:attribute name="state" type="stateType" id="substance.att.state">
      <xsd:annotation>
        <xsd:documentation>
          <div>
            <p>The state of the substance</p>
          </div>
        </xsd:documentation>
      </xsd:annotation>
    </xsd:attribute>
  </xsd:complexType>
</xsd:element>


   <xsd:element name="substanceList" id="el.substanceList">
<xsd:annotation>
  <xsd:documentation>
    <div class="summary">A list of "chemical substances"</div>
    <div class="description">
            <p>
        Deliberately very
        general - see <a href="el.substance">substance</a>. <tt>substanceList</tt> is designed to
        manage solutions, mixtures, etc. and there is a small enumerated controlled vocabulary,
        but this can be extended through dictionaries.</p>
        <p><tt>substanceList</tt> can have an <a href="el.amount">amount</a> child. This can indicate
        the amount of a solution or mixture; this example describes 100 ml of 0.1M NaOH(aq).
        Although apparently longwinded it is precise and fully machine-interpretable</p>
    </div>
    <div class="example">
       <pre>
<cml title="substanceList example">
  <substanceList id="s1">
    <amount units="units:ml">100</amount>
    <substance id="s1">
      <amount units="units:l">1</amount>
      <molecule id="h2o" ref="mols:water"/>
    </substance>
    <substance id="s2">
      <amount units="units:mole">0.1</amount>
      <molecule id="nacl" formula="Na 1 O 1 H 1"/>
    </substance>
  </substanceList>
</cml>


       </pre>
    </div>
  </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:sequence>
           <xsd:element ref="metadataList" minOccurs="0" maxOccurs="unbounded"/>
           <xsd:element ref="amount" minOccurs="0"/>
<!--           <xsd:choice>-->
           <xsd:element ref="substance" minOccurs="0" maxOccurs="unbounded"/>
<!-- PMR 2003-01-26
              <xsd:sequence>
                <xsd:element ref="scalar" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element ref="array" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element ref="matrix" minOccurs="0" maxOccurs="unbounded"/>
                <xsd:element ref="list" minOccurs="0" maxOccurs="unbounded"/>
              </xsd:sequence>
-->
           <xsd:element ref="propertyList" minOccurs="0"/>
<!--            </xsd:choice>-->
         </xsd:sequence>
         <xsd:attributeGroup ref="dictRef"/>
         <xsd:attributeGroup ref="convention"/>
         <xsd:attributeGroup ref="title"/>
         <xsd:attributeGroup ref="id"/>
         <xsd:attribute name="type">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">Type of the substanceList: </div>
               <div class="description">Extension is allowed through the "other" value</div>
             </xsd:documentation>
           </xsd:annotation>
           <xsd:simpleType>
             <xsd:restriction base="xsd:string">
               <xsd:enumeration value="solution"/>
               <xsd:enumeration value="mixture"/>
               <xsd:enumeration value="other"/>
            </xsd:restriction>
           </xsd:simpleType>
         </xsd:attribute>
         <xsd:attributeGroup ref="ref"/>
      </xsd:complexType>
   </xsd:element>



   <xsd:element name="symmetry" id="el.symmetry">
      <xsd:annotation>
         <xsd:documentation>
      <div class="summary">Molecular, crystallographic or other symmetry</div>
      <div class="description">
            <p>
         <tt>symmetry</tt> provides a label and/or symmetry operations for molecules
         or crystals. Point and spacegroups can be specified by strings, though these are not
         enumerated, because of variability in syntax (spaces, case-sensitivity, etc.),
         potential high symmetries (e.g. TMV disk is D17) and
         non-standard spacegroup settings. Provision is made for explicit symmetry operations
         through <matrix> child elements.</p>
         <p>By default the axes of symmetry are defined by the symbol - thus C2v requires
         z to be the unique axis, while P21/c requires b/y. Spacegroups imply the semantics
         defined in International Tables for Crystallography, (Int Union for Cryst., Munksgaard).
         Point groups are also defined therein. </p>
         <p>The element may also be used to give a label for the symmetry species (irreducible
         representation) such as "A1u" for a vibration or orbital.
         </p>
         <p>The matrices should be 3x3 for point group operators and 3x4 for spacegroup operators.
         The use of crystallographic notation ("x,1/2+y,-z") is not supported - this would
         be <matrix>1 0 0 0.0   0 1 0 0.5  0 0 1 0.0<matrix>.</p>
         <p>The default convention for point group symmetry is <tt>Schoenflies</tt> and for
         spacegroups is "H-M". Other conventions (e.g. "Hall") must be specfied through
         the <tt>convention</tt> attribute.</p>
         <p>This element implies that the Cartesians or fractional coordinates in a molecule
         are oriented appropriately. In some cases it may be useful to specify the symmetry of
         an arbitarily oriented molecule and the <molecule> element has the attribute
         <tt>symmetryOriented</tt> for this purpose.</p>
        </div>
        <div class="example">
        <pre><cml title="symmetry example 1">
<symmetry pointGroup="C2v" id="s1">
  <matrix id="e" rows="3" columns="3" dataType="xsd:float" matrixType="rotation33">
    1 0 0
    0 1 0
    0 0 1
  </matrix>
  <matrix id="c2" rows="3" columns="3" dataType="xsd:float" matrixType="rotation33">
    -1 0 0
    0 -1 0
    0 0 1
  </matrix>
  <matrix id="sx" rows="3" columns="3" dataType="xsd:float" matrixType="rotation33">
    -1 0 0
    0 1 0
    0 0 1
  </matrix>
  <matrix id="sy" rows="3" columns="3" dataType="xsd:float" matrixType="rotation33">
    1 0 0
    0 -1 0
    0 0 1
  </matrix>
</symmetry>
</cml>
</pre>
        </div>
         </xsd:documentation>
      </xsd:annotation>
      <xsd:complexType>
         <xsd:sequence>
           <xsd:element ref="matrix" minOccurs="0" maxOccurs="unbounded"/>
         </xsd:sequence>
         <xsd:attributeGroup ref="dictRef"/>
         <xsd:attributeGroup ref="convention"/>
         <xsd:attributeGroup ref="title"/>
         <xsd:attributeGroup ref="id"/>
         <xsd:attribute name="pointGroup" type="xsd:string">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">A point group</div>
               <div class="description">No fixed semantics, though Schoenflies is recommended over Hermann-Mauguin. We may provide a controlled-extensible list in the future.
               </div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="spaceGroup" type="xsd:string">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">A point group</div>
               <div class="description">No fixed semantics, though Hermann-Mauguin or Hall is recommended over Schoenflies. We may provide a controlled-extensible list in the future.
               </div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
         <xsd:attribute name="irreducibleRepresentation" type="xsd:string">
           <xsd:annotation>
             <xsd:documentation>
               <div class="summary">A symmetry species</div>
               <div class="description">No fixed semantics, though we may provide a controlled-extensible list in the future.
               </div>
             </xsd:documentation>
           </xsd:annotation>
         </xsd:attribute>
      </xsd:complexType>
   </xsd:element>

   <xsd:element name="torsion" id="el.torsion">
   <xsd:annotation>
      <xsd:documentation>
   <div class="summary">A torsion angle ("dihedral") between 4 distinct atoms</div>
   <div class="description">
         <p>The atoms need not
     be formally bonded. It can be used for:</p>
         <ul>
            <li>Recording experimentally determined torsion angles (e.g. in
     a crystallographic paper).</li>
            <li>Providing the torsion component for internal coordinates (e.g.
     z-matrix).</li>
         </ul>
         <p>Note that the order of atoms is important.</p>
   </div>
   <div class="example">
    <pre>
<molecule id="m1">
  <atomArray atomID="a1 a2 a3 a4"/>
  <torsion atomRefs4="a4 a2 a3 a1" units="degrees">123</torsion>
</molecule>

    </pre>
   </div>
      </xsd:documentation>
   </xsd:annotation>
   <xsd:complexType>
     <xsd:simpleContent>
       <xsd:extension base="torsionAngleType">
         <xsd:attributeGroup ref="tit_id_conv_dictGroup"/>
         <xsd:attributeGroup ref="atomRefs4"/>
         <xsd:attributeGroup ref="units"/>
         <xsd:attributeGroup ref="errorValue"/>
         <xsd:attributeGroup ref="errorBasis"/>
         <xsd:attributeGroup ref="min"/>
         <xsd:attributeGroup ref="max"/>
         <xsd:attributeGroup ref="ref">
            <xsd:annotation>
               <xsd:documentation>
                  <div class="summary">A reference to an exitsing torsion.</div>
                  <div class="description">Available for subclassing to provide alternative torsions for conformations.</div>
              </xsd:documentation>
            </xsd:annotation>
        </xsd:attributeGroup>
       </xsd:extension>
     </xsd:simpleContent>
   </xsd:complexType>
</xsd:element>




 <!-- CML-1 (deprecated) -->
     <xsd:element name="float" id="el.float">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">CML-1 dataType (DEPRECATED)</div>
      <div class="description">
      </div>
      <div class="example"><pre/></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:float">
        <xsd:attribute name="builtin" type="xsd:string"/>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attributeGroup ref="dictRef"/>
        <xsd:attributeGroup ref="id"/>
        <xsd:attributeGroup ref="title"/>
        <xsd:attributeGroup ref="min"/>
        <xsd:attributeGroup ref="max"/>
        <xsd:attributeGroup ref="units"/>
        <xsd:attribute name="unitsRef" type="xsd:string"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

  <xsd:element name="floatArray" id="el.floatArray">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">CML-1 dataType (DEPRECATED)</div>
      <div class="description">
      </div>
      <div class="example"><pre/></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:string">
        <xsd:attribute name="builtin" type="xsd:string"/>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attributeGroup ref="dictRef"/>
        <xsd:attributeGroup ref="id"/>
        <xsd:attributeGroup ref="title"/>
        <xsd:attributeGroup ref="min"/>
        <xsd:attributeGroup ref="max"/>
        <xsd:attributeGroup ref="size"/>
        <xsd:attributeGroup ref="units"/>
        <xsd:attribute name="unitsRef" type="xsd:string"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

  <xsd:element name="integer" id="el.integer">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">CML-1 dataType (DEPRECATED)</div>
      <div class="description">
      </div>
      <div class="example"><pre/></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:integer">
        <xsd:attribute name="builtin" type="xsd:string"/>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attributeGroup ref="dictRef"/>
        <xsd:attributeGroup ref="id"/>
        <xsd:attributeGroup ref="title"/>
        <xsd:attributeGroup ref="min"/>
        <xsd:attributeGroup ref="max"/>
        <xsd:attributeGroup ref="units"/>
        <xsd:attribute name="unitsRef" type="xsd:string"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

  <xsd:element name="integerArray" id="el.integerArray">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">CML-1 dataType (DEPRECATED)</div>
      <div class="description">
      </div>
      <div class="example"><pre/></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:string">
        <xsd:attribute name="builtin" type="xsd:string"/>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attributeGroup ref="dictRef"/>
        <xsd:attributeGroup ref="id"/>
        <xsd:attributeGroup ref="title"/>
        <xsd:attributeGroup ref="min"/>
        <xsd:attributeGroup ref="max"/>
        <xsd:attributeGroup ref="size"/>
        <xsd:attributeGroup ref="units"/>
        <xsd:attribute name="unitsRef" type="xsd:string"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

  <xsd:element name="string" id="el.string">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">CML-1 dataType (DEPRECATED)</div>
      <div class="description">
      </div>
      <div class="example"><pre/></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:string">
        <xsd:attribute name="builtin" type="xsd:string"/>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attributeGroup ref="dictRef"/>
        <xsd:attributeGroup ref="id"/>
        <xsd:attributeGroup ref="title"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>

  <xsd:element name="stringArray" id="el.stringArray">
  <xsd:annotation>
    <xsd:documentation>
      <div class="summary">CML-1 dataType (DEPRECATED)</div>
      <div class="description">
      </div>
      <div class="example"><pre/></div>
    </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
    <xsd:simpleContent>
      <xsd:extension base="xsd:string">
        <xsd:attribute name="builtin" type="xsd:string"/>
        <xsd:attributeGroup ref="convention"/>
        <xsd:attributeGroup ref="dictRef"/>
        <xsd:attributeGroup ref="id"/>
        <xsd:attributeGroup ref="title"/>
        <xsd:attributeGroup ref="min"/>
        <xsd:attributeGroup ref="max"/>
        <xsd:attributeGroup ref="size"/>
        <xsd:attributeGroup ref="delimiter"/>
      </xsd:extension>
    </xsd:simpleContent>
  </xsd:complexType>
</xsd:element>




</xsd:schema>