<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="emd" type="entry_type">
        <xs:annotation>
            <xs:documentation>TODO:
* crossreferences (emdb and pdb entries)
* electronCrystallographyValidation
* do we want to include a keyword field?
* modelling
* segmentation</xs:documentation>
            <xs:documentation>Enumerations
Enumerations are generally capitalized
Exceptions include
1) Units 
2) Important enumerations that are kept the same as in 1.9 for compatibility
3) Names etc that need a particular case

</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:complexType name="entry_type">
        <xs:sequence>
            <xs:element name="admin" type="admin_type">
                <xs:annotation>
                    <xs:documentation>_emd_admin
Contains administrative details about the entry.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="crossreferences" type="crossreferences_type"/>
            <xs:element name="sample" type="sample_type">
                <xs:annotation>
                    <xs:documentation>At least one assembly or a component must be described.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="structure_determination_list">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="structure_determination"
                            type="structure_determination_type" maxOccurs="unbounded"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="map" type="map_type">
                <xs:annotation>
                    <xs:documentation>This map represent the final reconstructions. This can be the result of several imageProcessing techniques, with different symmetries. Therefore, the final map should be considered as a composite of maps.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="interpretation" type="interpretation_type"/>
            <xs:element name="validation">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" ref="validation_type"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="emdb_id" type="emdb_id_type" use="required">
            <xs:annotation>
                <xs:documentation>For example: EMD-1001</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="version" use="required">
            <xs:annotation>
                <xs:documentation>The XML schema version that validates the header file.
This attribute should contain a default value: the current schema version.</xs:documentation>
            </xs:annotation>
            <xs:simpleType>
                <xs:restriction base="xs:token">
                    <xs:pattern value="\d+(\.\d+)*"/>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="admin_type">
        <xs:annotation>
            <xs:documentation>for pdbx categories with "PDB" in name, we should request duplicate categories with "EMDB" substituted</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="status_history_list" type="version_list_type">
                <xs:annotation>
                    <xs:documentation>_pdbx_version</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="current_status" type="version_type">
                <xs:annotation>
                    <xs:documentation>_pdbx_database_status
Copy of the last status element in the status_history_list.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="sites">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="deposition">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="PDBe"/>
                                    <xs:enumeration value="PDBj"/>
                                    <xs:enumeration value="RCSB"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="last_processing">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="PDBe"/>
                                    <xs:enumeration value="PDBj"/>
                                    <xs:enumeration value="RCSB"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="key_dates">
                <xs:annotation>
                    <xs:documentation>_database_PDB_rev is used in coordinate files
_audit is equivalent content, currently used for PDB SF files
Should we have lastUpdate?
Should we have headerReleaseDate?</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="deposition" type="xs:date"/>
                        <xs:element name="header_release" type="xs:date" minOccurs="0"/>
                        <xs:element name="map_release" type="xs:date" minOccurs="0">
                            <xs:annotation>
                                <xs:documentation>This date refers to when map, structure factors, layerlines, images, FSCs and all other related files are released publicly. This date should correspond to a Wednesday according to the current release cycle. </xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element minOccurs="0" name="obsolete" type="xs:date"/>
                        <xs:element name="update" type="xs:date"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="obsolete_list" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>This list contains old entries that have been replaced because of this newer entry.</xs:documentation>
                    <xs:documentation>_pdbx_database_PDB_obs_spr</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="entry" type="supersedes_type">
                            <xs:annotation>
                                <xs:documentation>List of old entries</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="superseded_by_list">
                <xs:annotation>
                    <xs:documentation>_pdbx_database_PDB_obs_spr </xs:documentation>
                    <xs:documentation>If this element appears means that the current entry is obsoleted. The newer entry which replaces this entry is listed here. </xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="entry" type="supersedes_type">
                            <xs:annotation>
                                <xs:documentation>List of new entries.</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="grant_support" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>new pdbx category to be created for this, will link grant#/funding body with _pdbx_audit_author</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="grant_reference" maxOccurs="unbounded"
                            type="grant_reference_type">
                            <xs:annotation>
                                <xs:documentation/>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="contact_author" maxOccurs="unbounded">
                <xs:annotation>
                    <xs:documentation>_pdbx_contact_author with role "responsible scientist"</xs:documentation>
                    <xs:documentation>Private information. Do not expose to the public. It can be the same as principalInvestigator.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:complexContent>
                        <xs:extension base="contact_details_type">
                            <xs:attribute fixed="true" name="private" use="required"/>
                        </xs:extension>
                    </xs:complexContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="title" type="xs:token">
                <xs:annotation>
                    <xs:documentation>_struct.title (type=text)</xs:documentation>
                    <xs:documentation>Should it be string or normalizedString?</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="authors_list">
                <xs:annotation>
                    <xs:documentation>_pdbx_audit_author -- atomization of address category desired, at least country.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="author" type="author_type">
                            <xs:annotation>
                                <xs:documentation>PubMed format: Taylor TJ
'author' element includes principalInvestigator and correspodingScientitst (if different from principalInvestigator).</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="details" type="xs:token">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="keywords" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="replace_existing_entry" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>Deprecated (2015-11-18)</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="version_list_type">
        <xs:sequence>
            <xs:element name="status" maxOccurs="unbounded">
                <xs:complexType>
                    <xs:complexContent>
                        <xs:extension base="version_type">
                            <xs:attribute name="id" type="xs:positiveInteger" use="required"/>
                        </xs:extension>
                    </xs:complexContent>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="version_type">
        <xs:sequence>
            <xs:element name="date">
                <xs:annotation>
                    <xs:documentation>_emd_admin.last_update</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:date">
                        <xs:minInclusive value="2002-01-01"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="code" type="code_type">
                <xs:annotation>
                    <xs:documentation>_emd_admin.current_status
These are PDB standard statuses (in order of common progression):
* Not yet released
  PROC: to be processed
  WAIT: processing started, waiting for author input to continue processing
  AUTH: processed, waiting for author review and approval
  REPL: author sent new coordinates, entry to be reprocessed
  REFI: re-refined entry, processing pending availability of primary publication
  POLC: waiting for a wwPDB policy decision
  HPUB: processing complete, entry on hold until publication
  HOLD: processing complete, entry on hold until a certain date
  
* REL: present in current archive
* WDRN: never publicly released
* OBS: no longer in the archive


HOLD1 and HOLD2 should be converted to HOLD</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="processing_site">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="PDBe"/>
                        <xs:enumeration value="RCSB"/>
                        <xs:enumeration value="PDBj"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="annotator">
                <xs:annotation>
                    <xs:documentation>What format? Initials? Full names?</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="xs:token">
                            <xs:attribute fixed="true" name="private" type="xs:token" use="required"
                            />
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="details" type="xs:string" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Comments are meaningful only to track changes in released entries. Example: "Change in pixel size from: 1.3 to 2.5 angs."</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:simpleType name="status_code_type">
        <xs:restriction base="xs:token">
            <xs:enumeration value="PROC"/>
            <xs:enumeration value="WAIT"/>
            <xs:enumeration value="AUTH"/>
            <xs:enumeration value="REPL"/>
            <xs:enumeration value="REFI"/>
            <xs:enumeration value="POLC"/>
            <xs:enumeration value="HPUB"/>
            <xs:enumeration value="HOLD"/>
            <xs:enumeration value="REL"/>
            <xs:enumeration value="WDRN"/>
            <xs:enumeration value="OBS"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="status_type">
        <xs:sequence>
            <xs:element name="date" type="xs:date"/>
            <xs:element name="code" type="code_type"> </xs:element>
            <xs:element name="details" type="xs:string"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="supersedes_type">
        <xs:sequence>
            <xs:element name="date" type="xs:date"/>
            <xs:element name="entry" type="emdb_id_type"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="contact_details_type">
        <xs:sequence>
            <xs:element name="role">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="PRINCIPAL INVESTIGATOR"/>
                        <xs:enumeration value="RESPONSIBLE SCIENTIST"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="title">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="PROF."/>
                        <xs:enumeration value="DR."/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="first_name" type="xs:token">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
            </xs:element>
            <xs:element name="middle_name">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="[A-Z]"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="last_name" type="xs:token"/>
            <xs:element name="organization">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="xs:token">
                            <xs:attribute name="type" use="required">
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="ACADEMIC"/>
                                        <xs:enumeration value="INDUSTRIAL"/>
                                        <xs:enumeration value="GOVERMENT"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="street" type="xs:string"> </xs:element>
            <xs:element name="town_or_city" type="xs:token"/>
            <xs:element name="state_or_province" type="xs:token">
                <xs:annotation>
                    <xs:documentation>British would specify county here</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="country" type="xs:token"/>
            <xs:element name="post_or_zip_code" type="xs:token"/>
            <xs:element name="email">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="telephone" type="telephone_number_type"/>
            <xs:element name="fax" type="telephone_number_type"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="name_type">
        <xs:sequence> </xs:sequence>
    </xs:complexType>
    <xs:complexType name="address_type">
        <xs:sequence> </xs:sequence>
    </xs:complexType>
    <xs:complexType name="crossreferences_type">
        <xs:sequence>
            <xs:element name="citation_list">
                <xs:annotation>
                    <xs:documentation>_citation
_citation_author</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="primary_citation">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element ref="citation_type"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="secondary_citation">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element ref="citation_type"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="emdb_list" type="emdb_cross_reference_list_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Some policy decision has to be agreed about who and in what circunstances this section can be included/modified.

Example 1:

Author 1 solves Component A -&gt; submit structure
Author 2 solves Component B -&gt; submit structure related to Component A, but author 1 entry is not modified.

Can author 1 (after submission) request the addition of this new relationship? That can add a lot of work for annotators.

Example 2:

Author 1 solves a ribosome structure. Can he link to all the tomographms that include ribosomes?</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="pdb_list" type="pdb_cross_reference_list_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Do these 'related PDB structures' refer to the initial PDB model?
If we want to include a transformation matrices for rigid-body fitted models, then this section only applies to flexible fitted models or de-novo built.
I think we should include Ingvar in this discussion.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="auxiliary_link_list" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Links can be specified to other databases holding related image data. For example a link to a database with the raw 2D images used in the map reconstruction. You may also specify links to databases holding image data at the lightmicroscopy scale that is related to this experiment.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence minOccurs="1" maxOccurs="1">
                        <xs:element name="auxiliary_link" type="auxiliary_link_type"
                            maxOccurs="unbounded"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="citation_list_type">
        <xs:sequence> </xs:sequence>
    </xs:complexType>
    <xs:complexType name="emdb_cross_reference_type">
        <xs:annotation>
            <xs:documentation>EMDB entries related to this entry</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="emdb_id" type="emdb_id_type"/>
            <xs:element name="relationship">
                <xs:complexType>
                    <xs:choice>
                        <xs:element name="in_frame">
                            <xs:annotation>
                                <xs:documentation>Add docked?</xs:documentation>
                            </xs:annotation>
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="NOOVERLAP"/>
                                    <xs:enumeration value="PARTIALOVERLAP"/>
                                    <xs:enumeration value="FULLOVERLAP"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="other" type="xs:string"> </xs:element>
                    </xs:choice>
                </xs:complexType>
            </xs:element>
            <xs:element name="details" minOccurs="0" type="xs:string"/>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger"/>
    </xs:complexType>
    <xs:complexType name="emdb_cross_reference_list_type">
        <xs:annotation>
            <xs:documentation>List of related EMDB entries
Maybe it can be combined with pdbReference into one datatype.</xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="1" maxOccurs="1">
            <xs:element name="emdb_reference" maxOccurs="unbounded" type="emdb_cross_reference_type"
                > </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="pdb_cross_reference_type">
        <xs:annotation>
            <xs:documentation>PDB entries related to this entry. The chainID list can be used to specify which specific chains are related to this map.</xs:documentation>
        </xs:annotation>
        <xs:sequence>
            <xs:element name="pdb_id" type="pdb_code_type"/>
            <xs:element name="relationship">
                <xs:complexType>
                    <xs:choice>
                        <xs:element name="in_frame">
                            <xs:annotation>
                                <xs:documentation>Add docked?</xs:documentation>
                            </xs:annotation>
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="NOOVERLAP"/>
                                    <xs:enumeration value="PARTIALOVERLAP"/>
                                    <xs:enumeration value="FULLOVERLAP"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="other" type="xs:string"> </xs:element>
                    </xs:choice>
                </xs:complexType>
            </xs:element>
            <xs:element name="details" minOccurs="0" type="xs:string"/>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger"/>
    </xs:complexType>
    <xs:complexType name="pdb_cross_reference_list_type">
        <xs:annotation>
            <xs:documentation>List of related PDB entries</xs:documentation>
        </xs:annotation>
        <xs:sequence minOccurs="1" maxOccurs="1">
            <xs:element name="pdb_reference" maxOccurs="unbounded" type="pdb_cross_reference_type">
                <xs:annotation>
                    <xs:documentation>'id' attribute: Autogenerated unique identifier that it used internally to cross reference this external cross reference!</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="structure_determination_type">
        <xs:sequence>
            <xs:element name="method">
                <xs:annotation>
                    <xs:documentation>We are assuming one method per map - is that OK?</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="singleParticle"/>
                        <xs:enumeration value="subtomogramAveraging"/>
                        <xs:enumeration value="tomography"/>
                        <xs:enumeration value="electronCrystallography"/>
                        <xs:enumeration value="helical"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="aggregation_state">
                <xs:annotation>
                    <xs:documentation>This should be an element of the spceimen preparation. However, we only want one instance of it, and the specimenPreparation is a list.

</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="particle"/>
                        <xs:enumeration value="filament"/>
                        <xs:enumeration value="twoDArray"/>
                        <xs:enumeration value="threeDArray"/>
                        <xs:enumeration value="helicalArray"/>
                        <xs:enumeration value="cell"/>
                        <xs:enumeration value="tissue"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="macromolecules_and_complexes" type="macromolecules_and_complexes_type">
                <xs:annotation>
                    <xs:documentation>_emd_specimen.macromolecules_and_complexes ADDED
If this is not specified then it is assumed that the processing applies to all components.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="specimen_preparation_list">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" ref="specimen_preparation"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="microscopy_list">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" ref="microscopy"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element ref="image_processing" maxOccurs="unbounded">
                <xs:annotation>
                    <xs:documentation>More than one imageProcessing element can be specified. This is useful when more that one symmetry was used to obtain final map. imageProcessing is an abstract element forming a substitution group. It must be substituted by a derived element. Enforcement of which substitutions are valid for which method will be done in Schematron:

Substitution                            Method
===============================================================
singleparticleProcessing                singleparticle
maximumliklihoodProcessing              singleparticle
subtomogramAveragingProcessing          subtomogramAveraging
tomographyProcessing                    tomography
electronCrystallographyProcessing       electronCrystallography
ihrsrHelicalProcessing                  helicalReconstruction
layerlinesHelicalProcessing             helicalReconstruction</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required">
            <xs:annotation>
                <xs:documentation>Unique identifier that will allow the DA system to be refactored in terms of experiments rather than maps. Can be autogenerated unless user wants to specify a previously existing one.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="sample_type">
        <xs:sequence>
            <xs:element name="name" type="xs:token">
                <xs:annotation>
                    <xs:documentation>General term describing the sample. For example: Human papillomavirus</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="supramolecule_list" maxOccurs="1">
                <xs:annotation>
                    <xs:documentation>Coarse grained representation of sample described in form of GO terms. This approach give great flexibility, allowing depositors to describe the sample at very different levels of complexity. This is useful for tomography, when depositors don't want to fully describe the map at fine detail. There are links between components and assemblies and viceversa.
Problem: there is not direct mapping between the assembly and the corresponding region of the map. This can be achieved using the segmentation mechanism.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" ref="supramolecule"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="macromolecule_list" type="macromolecule_list_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Fine grained description of the sample.</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="particle_selection_type">
        <xs:sequence>
            <xs:element name="number_particles_selected" type="xs:positiveInteger"/>
            <xs:element name="reference_model" minOccurs="0" type="xs:token">
                <xs:annotation>
                    <xs:documentation>TODO: what should format should this field has? EMDB?</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="method" minOccurs="0" type="xs:string">
                <xs:annotation>
                    <xs:documentation>TODO:format
Unnecessary? -&gt; could go into details.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="grid_type">
        <xs:sequence>
            <xs:element name="model">
                <xs:annotation>
                    <xs:documentation>Provide company + model of the grids
</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token"> </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="material">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_grid.material</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="GOLD"/>
                        <xs:enumeration value="COPPER"/>
                        <xs:enumeration value="MOLYBDENUM"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="mesh" type="xs:positiveInteger">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_grid.mesh
This is the number of squares in the grid.
This can be autogenerated from the gridType</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="support_film" type="film_type" maxOccurs="unbounded">
                <xs:annotation>
                    <xs:documentation>Additional layers of carbon can also be specified here.
How do we enforce directionality?</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="glow_discharge" minOccurs="0">
                <xs:complexType>
                    <xs:choice>
                        <xs:element name="glow_discharge_params" type="glow_discharge_params_type">
                            <xs:annotation>
                                <xs:documentation>Is it really meaningful to ask for time/pressure?</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:choice>
                </xs:complexType>
            </xs:element>
            <xs:element name="details" minOccurs="0" type="xs:string">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_grid.details
_emd_specimen.grid_details</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="glow_discharge_params_type">
        <xs:sequence>
            <xs:element name="time">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_time_glow_discharge">
                            <xs:attribute fixed="second" name="units" type="xs:token" use="required"
                            />
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="atmosphere">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="AIR"/>
                        <xs:enumeration value="AMYLAMINE"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="pressure">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_pressure_glow_discharge">
                            <xs:attribute name="units" type="xs:token" fixed="k_pa" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="stain_type">
        <xs:sequence>
            <xs:element name="ammonium_molybdate"/>
            <xs:element name="uranyl_acetate"/>
            <xs:element name="uranyl_formate"/>
            <xs:element name="phophotungstic_acid"/>
            <xs:element name="osmium_tetroxide"/>
            <xs:element name="osmium_ferricyanide"/>
            <xs:element name="auro_glucothionate"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="specialist_optics_type">
        <xs:sequence>
            <xs:element name="phase_plate" minOccurs="0" type="xs:token"/>
            <xs:element name="sph_aberration_corrector" minOccurs="0" type="xs:token"/>
            <xs:element name="chr_aberration_corrector" minOccurs="0" type="xs:token"/>
            <xs:element name="energy_filter" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="name" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>_emd_structure_determination_microscopy.optics_energyfilter_name</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="lower_energy_threshold">
                            <xs:annotation>
                                <xs:documentation>_emd_structure_determination_microscopy.optics_energyfilter_lower</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_energy_window">
                                        <xs:attribute fixed="e_v" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="upper_energy_threshold">
                            <xs:annotation>
                                <xs:documentation>_emd_structure_determination_microscopy.optics_energyfilter_upper</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_energy_window">
                                        <xs:attribute fixed="e_v" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="results_type">
        <xs:sequence> </xs:sequence>
    </xs:complexType>
    <xs:complexType name="regexp_string">
        <xs:sequence>
            <xs:element name="help_text" type="xs:string"/>
            <xs:element name="string" type="xs:string"/>
            <xs:element name="validation_list">
                <xs:complexType>
                    <xs:choice maxOccurs="unbounded">
                        <xs:element name="soft_validation_regexp">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="warning_text" type="xs:string"/>
                                    <xs:element name="regexp" type="xs:string"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="hard_validation_regexp">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="_error_text" type="xs:string"/>
                                    <xs:element name="regexp" type="xs:string"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                    </xs:choice>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="string_type">
        <xs:complexContent>
            <xs:extension base="base_type"/>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="string_validation_type">
        <xs:choice>
            <xs:element name="regular_expression" type="xs:string"/>
            <xs:element name="enum" type="xs:string" maxOccurs="unbounded"/>
            <xs:element name="controlled_vocabulary_link" type="xs:string"/>
        </xs:choice>
    </xs:complexType>
    <xs:complexType name="base_type">
        <xs:sequence>
            <xs:element name="help_text" type="xs:string"/>
            <xs:element name="warning_text" type="xs:string"/>
            <xs:element name="error_text" type="xs:string"/>
            <xs:element name="validation_rules" type="string_validation_type" maxOccurs="unbounded"/>
            <xs:element name="label" type="xs:string"/>
            <xs:element name="value" type="xs:string"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="buffer_type">
        <xs:sequence>
            <xs:element name="ph">
                <xs:annotation>
                    <xs:documentation>_emd_buffer.ph</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:float">
                        <xs:minInclusive value="0"/>
                        <xs:maxInclusive value="14"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="component" maxOccurs="unbounded">
                <xs:annotation>
                    <xs:documentation>_emd_buffer_component category ADDED</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="concentration">
                            <xs:annotation>
                                <xs:documentation>_emd_buffer_component.concentration ADDED</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_concentration">
                                        <xs:attribute name="units" use="required">
                                            <xs:annotation>
                                                <xs:documentation>_emd_buffer_component.concentration_units</xs:documentation>
                                            </xs:annotation>
                                            <xs:simpleType>
                                                <xs:restriction base="xs:string">
                                                  <xs:enumeration value="MG/ML"/>
                                                  <xs:enumeration value="MM"/>
                                                  <xs:enumeration value="% (V/V)"/>
                                                  <xs:enumeration value="% (W/V)"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:choice>
                            <xs:element name="formula">
                                <xs:annotation>
                                    <xs:documentation>_emd_buffer_component.formula ADDED</xs:documentation>
                                </xs:annotation>
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:pattern
                                            value="([\[\]\(\)]*[A-Z][a-z]?[\+\-\d/\[\]\(\)]*)+"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:element>
                            <xs:element name="name" type="xs:token">
                                <xs:annotation>
                                    <xs:documentation>_emd_buffer_component.name ADDED</xs:documentation>
                                </xs:annotation>
                            </xs:element>
                        </xs:choice>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="details" minOccurs="0" type="xs:string">
                <xs:annotation>
                    <xs:documentation>_emd_buffer.details</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="vitrification_type">
        <xs:sequence>
            <xs:element name="cryogen_name">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_vitrification.cryogen_name</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="ETHANE"/>
                        <xs:enumeration value="FREON 12"/>
                        <xs:enumeration value="FREON 22"/>
                        <xs:enumeration value="HELIUM"/>
                        <xs:enumeration value="METHANE"/>
                        <xs:enumeration value="NITROGEN"/>
                        <xs:enumeration value="PROPANE"/>
                        <xs:enumeration value="ETHANE-PROPANE"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="chamber_humidity" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_vitrification.chamber_humidity</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_humidity_vitrification">
                            <xs:attribute fixed="percentage" name="units" type="xs:token"
                                use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="chamber_temperature" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_vitrification.chamber_temperature</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_temperature_vitrification">
                            <xs:attribute fixed="K" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="instrument" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_vitrification.instrument</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="EMS-002 RAPID IMMERSION FREEZER"/>
                        <xs:enumeration value="FEI VITROBOT MARK I"/>
                        <xs:enumeration value="FEI VITROBOT MARK II"/>
                        <xs:enumeration value="FEI VITROBOT MARK III"/>
                        <xs:enumeration value="FEI VITROBOT MARK IV"/>
                        <xs:enumeration value="GATAN CRYOPLUNGE 3"/>
                        <xs:enumeration value="HOMEMADE PLUNGER"/>
                        <xs:enumeration value="LEICA PLUNGER"/>
                        <xs:enumeration value="LEICA EM GP"/>
                        <xs:enumeration value="LEICA EM CPC"/>
                        <xs:enumeration value="LEICA KF80"/>
                        <xs:enumeration value="REICHERT-JUNG PLUNGER"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="details" minOccurs="0" type="xs:string">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_vitrification.details</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="timed_resolved_state" type="xs:token">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="method" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014/11/13)</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="base_preparation_type">
        <xs:sequence>
            <xs:element name="concentration" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_specimen.concentration</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_concentration">
                            <xs:attribute name="units" use="required">
                                <xs:simpleType>
                                    <xs:restriction base="xs:string">
                                        <xs:enumeration value="MG/ML"/>
                                        <xs:enumeration value="MM"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="buffer" type="buffer_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_buffer category ADDED</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="staining" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_specimen.staining ADDED</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="type">
                            <xs:annotation>
                                <xs:documentation>_emd_specimen.staining_type ADDED</xs:documentation>
                            </xs:annotation>
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="NEGATIVE"/>
                                    <xs:enumeration value="POSITIVE"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="material" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>_emd_specimen.staining_material ADDED
Add controlled vocabulary</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="details" minOccurs="0" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>_emd_specimen.staining_details</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="sugar_embedding" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_specimen.sugar_embedding ADDED</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="material">
                            <xs:annotation>
                                <xs:documentation>_emd_specimen.sugar_embedding.material ADDED
Add controlled vocabulary</xs:documentation>
                            </xs:annotation>
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="GLUCOSE"/>
                                    <xs:enumeration value="TREHALOSE"/>
                                    <xs:enumeration value="TANNIC ACID"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="details" minOccurs="0" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>_emd_specimen.sugar_embedding.details ADDED</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="shadowing" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_shadowing ADDED as a category in dict</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="material" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>_emd_shadowing.material ADDED
Add controlled vocabulary</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="angle">
                            <xs:annotation>
                                <xs:documentation>_emd_shadowing.angle ADDED</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_angle_shadowing">
                                        <xs:attribute fixed="deg" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="thickness">
                            <xs:annotation>
                                <xs:documentation>_emd_shadowing.thickness ADDED
Check units and range.</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_thickness_shadowing">
                                        <xs:attribute fixed="nanometer" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="details" minOccurs="0" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>_emd_shadowing.details ADDED</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="grid" type="grid_type">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_grid
## EMD_SPECIMEN_GRID ##</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="vitrification" type="vitrification_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_vitrification
## EMD_SPECIMEN_VITRIFICATION ##</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="details" type="xs:string">
                <xs:annotation>
                    <xs:documentation>_emd_specimen.details
example:
'This sample was monodisperse.'
1775  'Au was deposited at a 30 degree angle to 15 nm thickness.'
1776  'Colloidal gold particles were deposited by dipping into dilute solution.'
1777  'The specimen was frozen at high pressure using the bal-tec hpm 010 instrument.'
1778  'The embedded sample was sectioned at 100 K to 50 nm final thickness.'</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required">
            <xs:annotation>
                <xs:documentation>Unique identifier. Autogenerated</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="tomography_preparation_type">
        <xs:annotation>
            <xs:documentation>TODO: add limits and units.</xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="base_preparation_type">
                <xs:sequence>
                    <xs:element name="fiducial_markers_list" minOccurs="0">
                        <xs:complexType>
                            <xs:sequence>
                                <xs:element maxOccurs="unbounded" name="fiducial_marker"
                                    type="fiducial_marker_type"/>
                            </xs:sequence>
                        </xs:complexType>
                    </xs:element>
                    <xs:element name="high_pressure_freezing" minOccurs="0">
                        <xs:annotation>
                            <xs:documentation>Add freeze fracture</xs:documentation>
                        </xs:annotation>
                        <xs:complexType>
                            <xs:sequence>
                                <xs:element name="instrument">
                                    <xs:simpleType>
                                        <xs:restriction base="xs:token">
                                            <xs:enumeration value="BAL-TEC HPM 010"/>
                                            <xs:enumeration value="EMS-002 RAPID IMMERSION FREEZER"/>
                                            <xs:enumeration value="LEICA EM HPM100"/>
                                            <xs:enumeration value="LEICA EM PACT"/>
                                            <xs:enumeration value="LEICA EM PACT2"/>
                                        </xs:restriction>
                                    </xs:simpleType>
                                </xs:element>
                                <xs:element name="details" type="xs:string"/>
                            </xs:sequence>
                        </xs:complexType>
                    </xs:element>
                    <xs:element name="embedding_material" minOccurs="0" type="xs:token">
                        <xs:annotation>
                            <xs:documentation>Add controlled vocabulary</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element name="cryo_protectant" minOccurs="0" type="xs:token">
                        <xs:annotation>
                            <xs:documentation>Add controlled vocabulary</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element name="sectioning" minOccurs="0">
                        <xs:complexType>
                            <xs:choice>
                                <xs:element name="ultramicrotomy">
                                    <xs:complexType>
                                        <xs:sequence>
                                            <xs:element name="instrument" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>Add controlled vocabulary?</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element name="temperature" type="temperature_type"/>
                                            <xs:element name="final_thickness"
                                                type="ultramicrotomy_final_thickness_type"> </xs:element>
                                            <xs:element name="details" type="xs:string"/>
                                        </xs:sequence>
                                    </xs:complexType>
                                </xs:element>
                                <xs:element name="focused_ion_beam">
                                    <xs:complexType>
                                        <xs:sequence>
                                            <xs:element name="instrument">
                                                <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:enumeration value="DB235"/>
                                                  </xs:restriction>
                                                </xs:simpleType>
                                            </xs:element>
                                            <xs:element name="ion">
                                                <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:enumeration value="GALLIUM+"/>
                                                  </xs:restriction>
                                                </xs:simpleType>
                                            </xs:element>
                                            <xs:element name="voltage" type="fib_voltage_type"> </xs:element>
                                            <xs:element name="current" type="fib_current_type"> </xs:element>
                                            <xs:element name="dose_rate" type="fib_dose_rate_type"> </xs:element>
                                            <xs:element name="duration" type="fib_duration_type"> </xs:element>
                                            <xs:element name="temperature" type="temperature_type"/>
                                            <xs:element name="initial_thickness"
                                                type="fib_initial_thickness_type">
                                                <xs:annotation>
                                                  <xs:documentation>TODO: add limits and units.</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element name="final_thickness"
                                                type="fib_final_thickness_type">
                                                <xs:annotation>
                                                  <xs:documentation/>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element name="details" type="xs:string"/>
                                        </xs:sequence>
                                    </xs:complexType>
                                </xs:element>
                                <xs:element name="other_sectioning" type="xs:string"/>
                            </xs:choice>
                        </xs:complexType>
                    </xs:element>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:element name="specimen_preparation" type="base_preparation_type">
        <xs:annotation>
            <xs:documentation>_emd_specimen
Should we include at this level helical and crystal parameters?

For a given EM method the relevant derived specimenPreparation substitution element may be specified. Checking will be enforced via Schematron. For tomography only 1 microscopy element should be specified.

Rules:
Method                   Preparation element
singleparticle           none - specimenPreparation
electronCrystallography  none - specimenPreparation
helicalReconstruction    none - specimenPreparation
tomography               tomographyPreparation, max occurs = 1
subtomogramAveraging     tomographyPreparation</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="tomography_preparation" type="tomography_preparation_type"
        substitutionGroup="specimen_preparation">
        <xs:annotation>
            <xs:documentation>Substitution when method is tomography or subtomogramAveraging. For tomography, maxoccurs = 1.</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="crystallography_preparation" type="crystallography_preparation_type"
        substitutionGroup="specimen_preparation">
        <xs:annotation>
            <xs:documentation>Substitution when method is tomography or subtomogramAveraging. For tomography, maxoccurs = 1.</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:complexType name="base_microscopy_type">
        <xs:sequence>
            <xs:element name="specimen_preparations">
                <xs:annotation>
                    <xs:documentation>Specimen preparation techniques used on this scope.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence maxOccurs="unbounded">
                        <xs:element name="specimen_preparation_id" type="xs:positiveInteger"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="microscope">
                <xs:annotation>
                    <xs:documentation>Microsocpe model</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="FEI MORGAGNI"/>
                        <xs:enumeration value="FEI POLARA 300"/>
                        <xs:enumeration value="FEI TECNAI 12"/>
                        <xs:enumeration value="FEI TECNAI 20"/>
                        <xs:enumeration value="FEI TECNAI F20"/>
                        <xs:enumeration value="FEI TECNAI F30"/>
                        <xs:enumeration value="FEI TECNAI SPHERA"/>
                        <xs:enumeration value="FEI TITAN KRIOS"/>
                        <xs:enumeration value="FEI/PHILIPS CM120T"/>
                        <xs:enumeration value="FEI/PHILIPS CM200FEG"/>
                        <xs:enumeration value="FEI/PHILIPS CM2000FEG/SOPHIE"/>
                        <xs:enumeration value="FEI/PHILIPS CM200FEG/ST"/>
                        <xs:enumeration value="FEI/PHILIPS CM200FEG/UT"/>
                        <xs:enumeration value="FEI/PHILIPS CM200T"/>
                        <xs:enumeration value="FEI/PHILIPS CM300FEG/HE"/>
                        <xs:enumeration value="FEI/PHIILIPS CM300FEG/ST"/>
                        <xs:enumeration value="FEI/PHILIPS CM300FEG/T"/>
                        <xs:enumeration value="FEI/PHILIPS EM400"/>
                        <xs:enumeration value="FEI/PHILIPS EM420"/>
                        <xs:enumeration value="HITACHI EF2000"/>
                        <xs:enumeration value="HITACHI HF2000"/>
                        <xs:enumeration value="HITACHI HF3000"/>
                        <xs:enumeration value="HITACHI H-95000SD"/>
                        <xs:enumeration value="JEOL100CX"/>
                        <xs:enumeration value="JEOL 1010"/>
                        <xs:enumeration value="JEOL 1200"/>
                        <xs:enumeration value="JEOL 1200EX"/>
                        <xs:enumeration value="JEOL 1200EXII"/>
                        <xs:enumeration value="JEOL 1230"/>
                        <xs:enumeration value="JEOL 2000EX"/>
                        <xs:enumeration value="JEOL 2000EXII"/>
                        <xs:enumeration value="JEOL 2010F"/>
                        <xs:enumeration value="JEOL 2010HT"/>
                        <xs:enumeration value="JEOL 2010UHR"/>
                        <xs:enumeration value="JEOL 2100"/>
                        <xs:enumeration value="JEOL 2100F"/>
                        <xs:enumeration value="JEOL 2200FS"/>
                        <xs:enumeration value="JEOL 2200FSC"/>
                        <xs:enumeration value="JEOL 3000SFF"/>
                        <xs:enumeration value="JEOL KYOTO-3000SFF"/>
                        <xs:enumeration value="JEOL 3200FSC"/>
                        <xs:enumeration value="JEOL 4000EX"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="illumination_mode">
                <xs:annotation>
                    <xs:documentation>Do we want to support 'spotscan'?
_emd_structure_determination_microscopy.illumination_mode</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="FLOOD BEAM"/>
                        <xs:enumeration value="SPOT SCAN"/>
                        <xs:enumeration value="OTHER"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="imaging_mode">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.imaging_mode
in emd-DA.dic but not here:
DARK FIELD
DIFFRACTION</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="BRIGHT FIELD"/>
                        <xs:enumeration value="DARK FIELD"/>
                        <xs:enumeration value="DIFFRACTION"/>
                        <xs:enumeration value="OTHER"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="electron_source">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.electron_source</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="TUNGSTEN HAIRPIN"/>
                        <xs:enumeration value="LAB6"/>
                        <xs:enumeration value="FIELD EMISSION GUN"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="acceleration_voltage">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.acceleration_voltage</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_acceleration_voltage">
                            <xs:attribute fixed="k_v" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="c2_aperture_diameter">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_c2_aperture_diameter">
                            <xs:attribute fixed="µm" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="nominal_cs" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.nominal_cs</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_nominal_cs">
                            <xs:attribute fixed="mm" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="nominal_defocus_min" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Positive values: underfocus
Negative values: overfocus
_emd_structure_determination_microscopy.nominal_defocus_min</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_defocus_min">
                            <xs:attribute fixed="µm" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="calibrated_defocus_min" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Positive values: underfocus
Negative values: overfocus
_emd_structure_determination_microscopy.calibrated_defocus_min</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_defocus_min">
                            <xs:attribute fixed="µm" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="nominal_defocus_max" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Positive values: underfocus
Negative values: overfocus
_emd_structure_determination_microscopy.nominal_defocus_max</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_defocus_max">
                            <xs:attribute fixed="µm" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="calibrated_defocus_max" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Positive values: underfocus
Negative values: overfocus
_emd_structure_determination_microscopy.calibrated_defocus_max</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_defocus_max">
                            <xs:attribute fixed="µm" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="nominal_magnification" minOccurs="0" type="allowed_magnification">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.nominal_magnification</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="calibrated_magnification" minOccurs="0" type="allowed_magnification">
                <xs:annotation>
                    <xs:documentation>From a biological perspective, it it really meaningful to ask for this?
As measured on image. Should take into account post-column magnification.
_emd_structure_determination_microscopy.calibrated_magnification</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="specimen_holder_model">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.specimen_holder_model
in emd-DA.dic but not here:
FEI TITAN KRIOS AUTOGRID HOLDER</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="GATAN HELIUM"/>
                        <xs:enumeration value="GATAN LIQUID NITROGEN"/>
                        <xs:enumeration value="HOME BUILD"/>
                        <xs:enumeration value="JEM3400FSC CRYOHOLDER"/>
                        <xs:enumeration value="JEOL"/>
                        <xs:enumeration value="PHILIPS ROTATION HOLDER"/>
                        <xs:enumeration value="SIDE ENTRY, EUCENTRIC"/>
                        <xs:enumeration
                            value="GATAN 626 SINGLE TILT LIQUID NITROGEN CRYO TRANSFER HOLDER"/>
                        <xs:enumeration
                            value="GATAN CT3500 SINGLE TILT LIQUID NITROGEN CRYO TRANSFER HOLDER"/>
                        <xs:enumeration
                            value="GATAN CT3500TR SINGLE TILT ROTATION LIQUID NITROGEN CRYO TRANSFER HOLDER"/>
                        <xs:enumeration
                            value="GATAN 910 MULTI-SPECIMEN SINGLE TILT CRYO TRANSFER HOLDER"/>
                        <xs:enumeration
                            value="GATAN 914 HIGH TILT LIQUID NITROGEN CRYO TRANSFER TOMOGRAPHY HOLDER"/>
                        <xs:enumeration
                            value="GATAN 915 DOUBLE TILT LIQUID NITROGEN CRYO TRANSFER HOLDER"/>
                        <xs:enumeration
                            value="GATAN UHRST 3500 SINGLE TILT ULTRA HIGH RESOLUTION NITROGEN COOLING HOLDER"/>
                        <xs:enumeration
                            value="GATAN CHDT 3504 DOUBLE TILT HIGH RESOLUTION NITROGEN COOLING HOLDER"/>
                        <xs:enumeration
                            value="GATAN HC 3500 SINGLE TILT HEATING/NITROGEN COOLING HOLDER"/>
                        <xs:enumeration
                            value="GATAN HCHST 3008 SINGLE TILT HIGH RESOLUTION HELIUM COOLING HOLDER"/>
                        <xs:enumeration
                            value="GATAN ULTST ULTRA LOW TEMPERATURE SINGLE TILT HELIUM COOLING HOLDER"/>
                        <xs:enumeration
                            value="GATAN HCHDT 3010 DOUBLE TILT HIGH RESOLUTION HELIUM COOLING HOLDER"/>
                        <xs:enumeration
                            value="GATAN ULTDT ULTRA LOW TEMPERATURE DOUBLE TILT HELIUM COOLING HOLDER"
                        />
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element minOccurs="0" name="cooling_holder_cryogen">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.cooling_holder_cryogen</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="HELIUM"/>
                        <xs:enumeration value="NITROGEN"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="temperature">
                <xs:annotation>
                    <xs:documentation>Temperature at which the microscope is maintained</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element minOccurs="0" name="temperature_min">
                            <xs:annotation>
                                <xs:documentation>Modify!!! Average temperature that the specimen is maintained in the microscope.
_emd_structure_determination_microscopy.average_temperature</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="complex_category_type">
                                        <xs:attribute fixed="K" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element minOccurs="0" name="temperature_max">
                            <xs:annotation>
                                <xs:documentation>Modify !!!
Average temperature that the specimen is maintained in the microscope.
_emd_structure_determination_microscopy.average_temperature</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="complex_category_type">
                                        <xs:attribute fixed="K" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element minOccurs="0" name="temperature_average">
                            <xs:annotation>
                                <xs:documentation>Average temperature that the specimen is maintained in the microscope.
_emd_structure_determination_microscopy.average_temperature</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="complex_category_type">
                                        <xs:attribute fixed="K" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="alignment_procedure" minOccurs="0">
                <xs:complexType>
                    <xs:choice>
                        <xs:element name="none">
                            <xs:complexType/>
                        </xs:element>
                        <xs:element name="basic">
                            <xs:complexType/>
                        </xs:element>
                        <xs:element name="zemlin_tableau">
                            <xs:complexType/>
                        </xs:element>
                        <xs:element name="coma_free">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="residual_tilt" type="xs:float">
                                        <xs:annotation>
                                            <xs:documentation>TODO: add allowed range and units</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="other">
                            <xs:complexType/>
                        </xs:element>
                        <xs:element name="legacy">
                            <xs:annotation>
                                <xs:documentation>Only for backward compatibility with v1.9.6. Should not be used with any new entries</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="astigmatism" type="xs:string"/>
                                    <xs:element name="electron_beam_tilt_params" type="xs:string"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                    </xs:choice>
                </xs:complexType>
            </xs:element>
            <xs:element name="specialist_optics" type="specialist_optics_type" minOccurs="0"/>
            <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
            <xs:element name="details" minOccurs="0" type="xs:string">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.details</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="date" type="xs:date">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="image_recording_list">
                <xs:complexType>
                    <xs:sequence maxOccurs="unbounded">
                        <xs:element name="image_recording">
                            <xs:annotation>
                                <xs:documentation>We should add _em_imaging.detector_distance (in crystallographyMicroscopy)</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="film_or_detector_model">
                                        <xs:annotation>
                                            <xs:documentation>TODO: add controlled vocabulary</xs:documentation>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="allowed_film_or_detector_model">
                                                  <xs:attribute name="category" use="required">
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:string">
                                                  <xs:enumeration value="CCD"/>
                                                  <xs:enumeration value="CMOS"/>
                                                  <xs:enumeration value="DIRECT ELECTRON DETECTOR"/>
                                                  <xs:enumeration
                                                  value="STORAGE PHOSPOR (IMAGE PLATES)"/>
                                                  <xs:enumeration value="FILM"/>
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                  </xs:attribute>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="detector_mode">
                                        <xs:simpleType>
                                            <xs:restriction base="xs:token">
                                                <xs:enumeration value="COUNTING"/>
                                                <xs:enumeration value="INTEGRATING"/>
                                                <xs:enumeration value="SUPER-RESOLUTION"/>
                                            </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                    <xs:element name="digitization_details">
                                        <xs:complexType>
                                            <xs:sequence>
                                                <xs:element name="scanner" minOccurs="0">
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:enumeration value="EIKONIX IEEE 488"/>
                                                  <xs:enumeration value="EMIL 10"/>
                                                  <xs:enumeration value="NIKON COOLSCAN"/>
                                                  <xs:enumeration value="NIKON SUPER COOLSCAN 9000"/>
                                                  <xs:enumeration value="OPTRONICS"/>
                                                  <xs:enumeration value="PATCHWORK DENSITOMETER"/>
                                                  <xs:enumeration value="PERKIN ELMER"/>
                                                  <xs:enumeration value="PRIMESCAN"/>
                                                  <xs:enumeration value="TEMSCAN"/>
                                                  <xs:enumeration value="ZEISS SCAI"/>
                                                  <xs:enumeration value="OTHER"/>
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                </xs:element>
                                                <xs:element name="dimensions">
                                                  <xs:annotation>
                                                  <xs:documentation>Can be derived from detectorModel so is this meaningful?</xs:documentation>
                                                  </xs:annotation>
                                                  <xs:complexType>
                                                  <xs:sequence>
                                                  <xs:element name="width">
                                                  <xs:complexType>
                                                  <xs:simpleContent>
                                                  <xs:extension base="xs:positiveInteger">
                                                  <xs:attribute fixed="pixel" name="units"
                                                  use="required" type="xs:token"/>
                                                  </xs:extension>
                                                  </xs:simpleContent>
                                                  </xs:complexType>
                                                  </xs:element>
                                                  <xs:element name="height">
                                                  <xs:complexType>
                                                  <xs:simpleContent>
                                                  <xs:extension base="xs:positiveInteger">
                                                  <xs:attribute fixed="pixel" name="units"
                                                  use="required" type="xs:token"/>
                                                  </xs:extension>
                                                  </xs:simpleContent>
                                                  </xs:complexType>
                                                  </xs:element>
                                                  </xs:sequence>
                                                  </xs:complexType>
                                                </xs:element>
                                                <xs:element name="sampling_interval">
                                                  <xs:complexType>
                                                  <xs:simpleContent>
                                                  <xs:extension base="allowed_scaning_interval">
                                                  <xs:attribute fixed="µm" name="units"
                                                  use="required" type="xs:token"/>
                                                  </xs:extension>
                                                  </xs:simpleContent>
                                                  </xs:complexType>
                                                </xs:element>
                                                <xs:element name="frames_per_image" minOccurs="0"
                                                  type="xs:positiveInteger">
                                                  <xs:annotation>
                                                  <xs:documentation>Sometimes multiple frames are added up to one image</xs:documentation>
                                                  </xs:annotation>
                                                </xs:element>
                                            </xs:sequence>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element name="number_grids_imaged" type="xs:positiveInteger"/>
                                    <xs:element name="number_real_images" type="xs:positiveInteger"
                                        minOccurs="0"/>
                                    <xs:element name="number_diffraction_images"
                                        type="xs:positiveInteger" minOccurs="0"/>
                                    <xs:element minOccurs="0" name="average_exposure_time">
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension
                                                  base="allowed_average_exposure_time_type">
                                                  <xs:attribute fixed="second" name="units"
                                                  use="required" type="xs:token"/>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element name="average_electron_dose_per_image" minOccurs="0">
                                        <xs:annotation>
                                            <xs:documentation>Tomography: electron dose per image.
Crystallography: the dose per real/diffraction image.</xs:documentation>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="allowed_electron_dose">
                                                  <xs:attribute fixed="e/Å^2" name="units"
                                                  type="xs:token" use="required"/>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="detector_distance"
                                        type="xs:string"/>
                                    <xs:element name="details" minOccurs="0" type="xs:string"/>
                                    <xs:element minOccurs="0" name="od_range" type="xs:float">
                                        <xs:annotation>
                                            <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="bits_per_pixel" type="xs:float">
                                        <xs:annotation>
                                            <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                </xs:sequence>
                                <xs:attribute name="id" type="xs:positiveInteger"/>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="specimen_holder" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014/11/12)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="tilt_angle_min">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014/11/14)</xs:documentation>
                    <xs:documentation>SHOULD NOT BE USED FOR TOMOGRAPHY - only for compatibility purposes with v1.9!! Use tomography microscopy instead.
Angle is assumed in degrees</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="tilt_angle_max">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014/11/14)</xs:documentation>
                    <xs:documentation>SHOULD NOT BE USED FOR TOMOGRAPHY - only for compatibility purposes with v1.9!! Use tomography microscopy instead.
Angle is assumed in degrees</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required">
            <xs:annotation>
                <xs:documentation>Auto generated by application</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="tomography_microscopy_type">
        <xs:complexContent>
            <xs:extension base="base_microscopy_type">
                <xs:sequence>
                    <xs:element name="tilt_series" type="tilt_series_type" maxOccurs="unbounded">
                        <xs:annotation>
                            <xs:documentation>Multiple series are only relevant for subtomogram averages</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="axis_type">
        <xs:sequence>
            <xs:element name="min_angle">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.tomography_axis1_min_angle</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_angle_tomography">
                            <xs:attribute fixed="deg" name="units" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="max_angle">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.tomography_axis1_max_angle</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_angle_tomography">
                            <xs:attribute fixed="deg" name="units" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="angle_increment">
                <xs:annotation>
                    <xs:documentation>_emd_structure_determination_microscopy.tomography_axis1_angle_increment</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_angle_increment">
                            <xs:attribute fixed="deg" name="units" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="tilt_series_type">
        <xs:sequence>
            <xs:element name="axis1" type="axis_type"/>
            <xs:element name="axis2" minOccurs="0">
                <xs:complexType>
                    <xs:complexContent>
                        <xs:extension base="axis_type">
                            <xs:sequence>
                                <xs:element name="axis_rotation">
                                    <xs:annotation>
                                        <xs:documentation>Rotation of axis relative to axis1</xs:documentation>
                                    </xs:annotation>
                                </xs:element>
                            </xs:sequence>
                        </xs:extension>
                    </xs:complexContent>
                </xs:complexType>
            </xs:element>
            <xs:element fixed="90" name="axis_rotation">
                <xs:annotation>
                    <xs:documentation>Differences between axis1 and axis2 in degrees.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="xs:float">
                            <xs:attribute fixed="deg" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="crystallography_microscopy_type">
        <xs:complexContent>
            <xs:extension base="base_microscopy_type">
                <xs:sequence>
                    <xs:element name="camera_length">
                        <xs:annotation>
                            <xs:documentation>_emd_structure_determination_microscopy.crystallography_camera_length</xs:documentation>
                        </xs:annotation>
                        <xs:complexType>
                            <xs:simpleContent>
                                <xs:extension base="allowed_camera_length">
                                    <xs:attribute fixed="mm" name="units" type="xs:token"
                                        use="required"/>
                                </xs:extension>
                            </xs:simpleContent>
                        </xs:complexType>
                    </xs:element>
                    <xs:choice>
                        <xs:element name="tilt_list" minOccurs="1">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="angle" maxOccurs="unbounded">
                                        <xs:annotation>
                                            <xs:documentation>_emd_structure_determination_microscopy.crystallography_tilt_angle_list</xs:documentation>
                                        </xs:annotation>
                                        <xs:simpleType>
                                            <xs:restriction base="xs:float">
                                                <xs:minInclusive value="-70"/>
                                                <xs:maxInclusive value="70"/>
                                            </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="tilt_series" type="tilt_series_type" maxOccurs="unbounded"
                            minOccurs="1">
                            <xs:annotation>
                                <xs:documentation>Multiple series are only relevant for subtomogram averages</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:choice>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="crystallography_tilt_type">
        <xs:sequence> </xs:sequence>
    </xs:complexType>
    <xs:element name="microscopy" type="base_microscopy_type">
        <xs:annotation>
            <xs:documentation>Does this correspond to microscope or microscopy??
For a given EM method the relevant derived microscopy substitution element may be specified. Checking will be enforced via Schematron. For tomography only 1 microscopy element should be specified.

Rules:
Method                   Substition element
==========================================================
singleparticle           none - use microscopy
electronCrystallography  crystallographyMicroscopy
helicalReconstruction    none - use microscopy
tomography               tomographyMicroscopy, max occurs = 1
subtomogramAveraging     tomographyMicroscopy</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="tomography_microscopy" type="tomography_microscopy_type"
        substitutionGroup="microscopy">
        <xs:annotation>
            <xs:documentation>Derived microscopy type used for tomography and sub-tomogram averaging </xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="crystallography_microscopy" type="crystallography_microscopy_type"
        substitutionGroup="microscopy">
        <xs:annotation>
            <xs:documentation>Derived microscopy type used for electron crystallography</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:complexType name="image_recording_type">
        <xs:choice maxOccurs="unbounded">
            <xs:annotation>
                <xs:documentation>Images may have been recorded on different detectors</xs:documentation>
            </xs:annotation>
            <xs:element name="film"> </xs:element>
        </xs:choice>
    </xs:complexType>
    <xs:complexType name="reconstruction_type">
        <xs:sequence>
            <xs:element name="number_images_used" minOccurs="0" type="xs:positiveInteger">
                <xs:annotation>
                    <xs:documentation>Number of 2D images used in making the 3D reconstruction</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="number_classes_used" type="xs:positiveInteger"/>
            <xs:element name="applied_symmetry" type="applied_symmetry_type">
                <xs:annotation>
                    <xs:documentation>Only one symmetry element per processing type. Use additional processing type elements, and specify the sample components for each if more that one symmetry has been applied.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="algorithm" minOccurs="0" type="reconstruction_algorithm_type">
                <xs:annotation>
                    <xs:documentation>Add facet: FAT...</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="resolution">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="resolution_type">
                            <xs:attribute fixed="Å" name="units" type="xs:token" use="required"/>
                            <xs:attribute name="type" use="required">
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="BY AUTHOR"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="resolution_method">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="FSC 0.5 CUT-OFF"/>
                        <xs:enumeration value="FSC 0.33 CUT-OFF"/>
                        <xs:enumeration value="FSC 0.143 CUT-OFF"/>
                        <xs:enumeration value="3σ"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element minOccurs="0" name="reconstruction_filtering"
                type="reconstruction_filtering_type">
                <xs:annotation>
                    <xs:documentation>Contour, mask dilation filtering.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="software_list" type="software_list_type"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="film_type">
        <xs:sequence>
            <xs:element name="film_material" type="xs:token">
                <xs:annotation>
                    <xs:documentation>_emd_specimen_grid.support_film_material
enumeration:
     CARBON
     'FORMVAR PLUS CARBON'
     'CELLULOSE ACETATE PLUS CARBON'
     'PARLODION PLUS CARBON'
     'HOLEY CARBON'
</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="film_topology">
                <xs:annotation>
                    <xs:documentation>Lacy: Net of holes, with minimum support film between the holes.
Holey: Irregularly spaced holes of varying sizes
Hole array: Regularly spaced holes of constant sizes</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="CONTINUOUS"/>
                        <xs:enumeration value="LACEY"/>
                        <xs:enumeration value="HOLEY"/>
                        <xs:enumeration value="HOLEARRAY"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="film_thickness">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_film_thickness">
                            <xs:attribute fixed="nm" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required"/>
    </xs:complexType>
    <xs:complexType name="coordinate_type">
        <xs:sequence>
            <xs:element name="spatial_frequency">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="xs:float"/>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="y">
                <xs:simpleType>
                    <xs:restriction base="xs:float">
                        <xs:minInclusive value="0"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element minOccurs="0" name="y_noise">
                <xs:simpleType>
                    <xs:restriction base="xs:float">
                        <xs:minInclusive value="0"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="figure_type">
        <xs:sequence>
            <xs:element name="file">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="emd_\d{4,}.+"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ctf_correction_type">
        <xs:sequence>
            <xs:element name="phase_reversal" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="anisotropic" type="xs:boolean"/>
                        <xs:element name="correction_space" type="correction_space_type"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="amplitude_correction" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="factor" type="xs:float">
                            <xs:annotation>
                                <xs:documentation>Find in paper the standard way to encode it.
</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="correction_space" type="correction_space_type"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="correction_operation">
                <xs:simpleType>
                    <xs:restriction base="xs:string">
                        <xs:enumeration value="MULTIPLICATION"/>
                        <xs:enumeration value="DIVISION"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="software_list" type="software_list_type"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="angle_assignment_type">
        <xs:sequence>
            <xs:element name="type">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="ANGULAR RECONSTITUTION"/>
                        <xs:enumeration value="COMMON LINES"/>
                        <xs:enumeration value="PROJECTION MATCHING"/>
                        <xs:enumeration value="RANDOM ASSIGNMENT"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="projection_matching_processing" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Assignment of Euler angles by matching to closest reference projection</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="number_reference_projections" type="xs:positiveInteger"/>
                        <xs:element name="merit_function" type="xs:token"/>
                        <xs:element name="angular_sampling">
                            <xs:annotation>
                                <xs:documentation>Angular distance between neighboring reference projections in degrees</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_angular_sampling">
                                        <xs:attribute fixed="degrees" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="modelling_type">
        <xs:sequence>
            <xs:element maxOccurs="unbounded" name="initial_model">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="access_code">
                            <xs:annotation>
                                <xs:documentation>Allow portions of PDBs </xs:documentation>
                            </xs:annotation>
                            <xs:simpleType>
                                <xs:restriction base="pdb_code_type">
                                    <xs:pattern value="\d[\dA-Za-z]{3}"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="chain">
                            <xs:complexType>
                                <xs:complexContent>
                                    <xs:extension base="chain_model_type">
                                        <xs:sequence>
                                            <xs:element name="number_of_copies_in_final_model"
                                                type="xs:positiveInteger">
                                                <xs:annotation>
                                                  <xs:documentation>Number of copies in map. Should it be part of 'interpretation' section?</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                        </xs:sequence>
                                    </xs:extension>
                                </xs:complexContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element minOccurs="0" name="details" type="xs:string"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="final_model">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="access_code" type="pdb_code_type">
                            <xs:annotation>
                                <xs:documentation>Allow portions of PDBs </xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="chain"
                            type="chain_model_type"> </xs:element>
                        <xs:element minOccurs="0" name="details" type="xs:string"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="refinement_protocol" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>It should be a controlled vocabulary:
* Rigid body docking (manual or automatic)
* Flexible fitting
* Rigid body docking + flexible fitting</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:string">
                        <xs:enumeration value="RIGID BODY FITTING"/>
                        <xs:enumeration value="RIGID BODY DOCKING"/>
                        <xs:enumeration value="FLEXIBLE FITTING"/>
                        <xs:enumeration value="FLEXIBLE DOCKING"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
            <xs:element name="details" minOccurs="0" type="xs:string"/>
            <xs:element minOccurs="0" name="target_criteria" type="xs:token">
                <xs:annotation>
                    <xs:documentation>Necessary?</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="refinement_space" type="xs:token">
                <xs:annotation>
                    <xs:documentation>Necessary?</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="overall_bvalue" type="xs:float" nillable="true">
                <xs:annotation>
                    <xs:documentation>Necessary?</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="maximum_likelihood_type">
        <xs:sequence>
            <xs:element name="parameters">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="in_plane_translation" minOccurs="0"/>
                        <xs:element name="in_plane_rotation" minOccurs="0"/>
                        <xs:element name="out_of_plane_rotation" minOccurs="0"/>
                        <xs:element name="model_heterogeneity" minOccurs="0">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="number_classes"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="other" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="noise_model">
                <xs:complexType>
                    <xs:choice>
                        <xs:element name="white_gaussian"/>
                        <xs:element name="coloured_gaussian"/>
                        <xs:element name="other"/>
                    </xs:choice>
                </xs:complexType>
            </xs:element>
            <xs:element name="software_list" type="software_list_type"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="base_processing_type">
        <xs:sequence>
            <xs:element name="image_recording_id" type="xs:positiveInteger"/>
            <xs:element minOccurs="0" name="details" type="xs:token"/>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required"/>
    </xs:complexType>
    <xs:group name="single_particle_proc_add_group">
        <xs:sequence>
            <xs:element name="particle_selection" type="particle_selection_type"
                maxOccurs="unbounded"/>
            <xs:element name="ctf_correction" type="ctf_correction_type" minOccurs="0"/>
            <xs:element minOccurs="0" name="startup_model" type="starting_map_type">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
            </xs:element>
            <xs:element name="initial_angle_assignment" type="angle_assignment_type" minOccurs="0"/>
            <xs:element name="final_reconstruction" type="reconstruction_type"/>
            <xs:element name="final_angle_assignment" type="angle_assignment_type" minOccurs="0"/>
            <xs:element name="final_multi_reference_alignment" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Final round of alignment</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="number_reference_projections" type="xs:positiveInteger"/>
                        <xs:element name="merit_function" minOccurs="0" type="xs:string"/>
                        <xs:element name="angular_sampling" minOccurs="0">
                            <xs:annotation>
                                <xs:documentation>Angular distance between neighboring reference projections in degrees</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_angular_sampling">
                                        <xs:attribute fixed="degrees" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="final_two_d_classification" minOccurs="0" type="classification_type"> </xs:element>
            <xs:element minOccurs="0" name="final_three_d_classification" type="classification_type"
            />
        </xs:sequence>
    </xs:group>
    <xs:group name="maximum_likelihood_proc_add_group">
        <xs:sequence>
            <xs:element name="particle_selection" type="particle_selection_type"
                maxOccurs="unbounded"/>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="startup_model"
                type="starting_map_type">
                <xs:annotation>
                    <xs:documentation>Example of more that one starting model: one model used for particle picking and another used for Euler angle assignment.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="ctf_correction" type="ctf_correction_type" minOccurs="0"/>
            <xs:element name="maximum_liklihood" type="maximum_likelihood_type" minOccurs="0"/>
        </xs:sequence>
    </xs:group>
    <xs:group name="subtomogram_averaging_proc_add_group">
        <xs:sequence>
            <xs:element name="final_reconstruction" type="subtomogram_reconstruction_type"> </xs:element>
            <xs:element name="extraction">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="number_tomograms" type="xs:positiveInteger"/>
                        <xs:element name="number_subtomograms" type="xs:positiveInteger"/>
                        <xs:element name="reference_model" minOccurs="0" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>TODO: what should format should this field has? EMDB?</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="method" minOccurs="0" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>TODO:format</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="ctf_correction" type="ctf_correction_type"/>
            <xs:element name="final_multi_reference_alignment" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Final round of alignment</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="number_reference_projections" type="xs:positiveInteger"/>
                        <xs:element name="merit_function" minOccurs="0" type="xs:string"/>
                        <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="final_three_d_classification" minOccurs="0" type="classification_type"
                > </xs:element>
            <xs:element name="final_angle_assignment" type="angle_assignment_type" minOccurs="0"/>
            <xs:element minOccurs="0" name="crystal_parameters" type="crystal_parameters_type"/>
        </xs:sequence>
    </xs:group>
    <xs:group name="tomography_proc_add_group">
        <xs:sequence>
            <xs:element name="final_reconstruction" type="reconstruction_type"/>
            <xs:element name="series_aligment_software_list" type="software_list_type"/>
            <xs:element name="ctf_correction" type="ctf_correction_type"/>
            <xs:element name="crystal_parameters" type="crystal_parameters_type" minOccurs="0">
            </xs:element>
        </xs:sequence>
    </xs:group>
    <xs:group name="crystallography_proc_add_group">
        <xs:sequence>
            <xs:element name="final_reconstruction" type="reconstruction_type"/>
            <xs:element name="crystal_parameters" type="crystal_parameters_type"> </xs:element>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="startup_model"
                type="starting_map_type">
                <xs:annotation>
                    <xs:documentation>Example of more that one starting model: one model used for particle picking and another used for Euler angle assignment.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="ctf_correction" type="ctf_correction_type"/>
            <xs:element name="molecular_replacement">
                <xs:annotation>
                    <xs:documentation>Phasing?</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="starting_model">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="access_code" type="pdb_code_type">
                                        <xs:annotation>
                                            <xs:documentation>Allow porions of PDBs </xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                    <xs:element maxOccurs="unbounded" minOccurs="0" name="chain"
                                        type="chain_type"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="resolution_range">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="high_resolution">
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="resolution_type">
                                                  <xs:attribute fixed="Å" name="units"
                                                  type="xs:token" use="required"/>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element name="low_resolution">
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="resolution_type">
                                                  <xs:attribute fixed="Å" name="units"
                                                  type="xs:token" use="required"/>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="lattice_distortion_correction">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="symmetry_determination">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="merging">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="crystallography_statistics" type="crystallography_statistics_type">
            </xs:element>
        </xs:sequence>
    </xs:group>
    <xs:group name="helical_processing_add_group">
        <xs:sequence>
            <xs:element name="final_reconstruction" type="reconstruction_type"/>
            <xs:element name="ctf_correction" type="ctf_correction_type"/>
            <xs:element name="segment_selection" maxOccurs="unbounded">
                <xs:annotation>
                    <xs:documentation>Carsten Sachse suggested to add number of ASU.</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="number_segments" type="xs:positiveInteger"/>
                        <xs:element name="segment_length">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="non_zero_float">
                                        <xs:attribute fixed="Å" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="segment_overlap">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="non_zero_float">
                                        <xs:attribute fixed="Å" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element minOccurs="0" name="total_filament_length">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="non_zero_float">
                                        <xs:attribute fixed="Å" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="refinement">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="startup_model"
                            type="starting_map_type">
                            <xs:annotation>
                                <xs:documentation>Example of more that one starting model: one model used for particle picking and another used for Euler angle assignment.</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="starting_symmetry" maxOccurs="unbounded">
                            <xs:complexType>
                                <xs:sequence>
                                    <!--xs:element name="helical_parameters">
                                        <xs:complexType>
                                            <xs:sequence>
                                                <xs:element name="rise">
                                                  <xs:complexType>
                                                  <xs:simpleContent>
                                                  <xs:extension base="allowed_rise_type">
                                                  <xs:attribute fixed="Å" name="units"
                                                  type="xs:token" use="required"/>
                                                  </xs:extension>
                                                  </xs:simpleContent>
                                                  </xs:complexType>
                                                </xs:element>
                                                <xs:element name="twist">
                                                  <xs:complexType>
                                                  <xs:simpleContent>
                                                  <xs:extension base="allowed_twist_type">
                                                  <xs:attribute fixed="degree" name="units"
                                                  type="xs:token" use="required"/>
                                                  </xs:extension>
                                                  </xs:simpleContent>
                                                  </xs:complexType>
                                                </xs:element>
                                                <xs:element name="cyclic_symmetry">
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:pattern value="c[1-9]\d*"/>
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                </xs:element>
                                                <xs:element name="dyad_symmetry" type="xs:boolean"/>
                                            </xs:sequence>
                                        </xs:complexType>
                                    </xs:element-->
                                    <xs:element name="helical_parameters"
                                        type="helical_parameters_type"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="startup_model"
                type="starting_map_type">
                <xs:annotation>
                    <xs:documentation>Example of more that one starting model: one model used for particle picking and another used for Euler angle assignment.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="layer_lines" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="number_helices"/>
                        <xs:element name="helix_length">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="min"/>
                                    <xs:element name="max"/>
                                    <xs:element name="average"/>
                                    <xs:element name="software_list" type="software_list_type"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="straightening" minOccurs="0" type="xs:boolean"> </xs:element>
                        <xs:element name="indexing">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="software_list" type="software_list_type"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="initial_angle_assignment" type="angle_assignment_type"/>
            <xs:element minOccurs="0" name="final_angle_assignment" type="angle_assignment_type"/>
            <xs:element minOccurs="0" name="crystal_parameters" type="crystal_parameters_type"/>
        </xs:sequence>
    </xs:group>
    <xs:complexType name="singleparticle_processing_type">
        <xs:complexContent>
            <xs:extension base="base_processing_type">
                <xs:group ref="single_particle_proc_add_group"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="subtomogram_averaging_processing_type">
        <xs:complexContent>
            <xs:extension base="base_processing_type">
                <xs:group ref="subtomogram_averaging_proc_add_group"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="tomography_processing_type">
        <xs:complexContent>
            <xs:extension base="base_processing_type">
                <xs:group ref="tomography_proc_add_group"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="crystallography_processing_type">
        <xs:complexContent>
            <xs:extension base="base_processing_type">
                <xs:group ref="crystallography_proc_add_group"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="helical_processing_type">
        <xs:complexContent>
            <xs:extension base="base_processing_type">
                <xs:group ref="helical_processing_add_group"/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:element abstract="true" name="image_processing" type="base_processing_type"/>
    <xs:element name="singleparticle_processing" substitutionGroup="image_processing"
        type="singleparticle_processing_type"/>
    <xs:element name="subtomogram_averaging_processing" substitutionGroup="image_processing"
        type="subtomogram_averaging_processing_type"/>
    <xs:element name="tomography_processing" substitutionGroup="image_processing"
        type="tomography_processing_type"/>
    <xs:element name="crystallography_processing" substitutionGroup="image_processing"
        type="crystallography_processing_type"/>
    <xs:element name="helical_processing" substitutionGroup="image_processing"
        type="helical_processing_type"/>
    <xs:complexType name="applied_symmetry_type">
        <xs:choice>
            <xs:element name="space_group" type="plane_and_space_group_type"/>
            <xs:element name="point_group">
                <xs:annotation>
                    <xs:documentation>Add support for helical</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="point_group_symmetry_type">
                        <xs:pattern value="C\d+|D\d+|O|T|I"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="helical_parameters" type="helical_parameters_type">
                <xs:annotation>
                    <xs:documentation>It could be combined with point symmetry if we adopt Heymman et al.</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:complexType>
    <xs:complexType name="starting_map_type">
        <xs:choice>
            <xs:element name="random_conical_tilt" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="number_images" type="xs:positiveInteger"/>
                        <xs:element name="tilt_angle">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_tilt_angle_random_conical">
                                        <xs:attribute fixed="degrees" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="orthogonal_tilt" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element name="number_images" type="xs:positiveInteger"/>
                        <xs:element name="tilt_angle1">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_tilt_angle1Orthogonal">
                                        <xs:attribute fixed="degrees" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="tilt_angle2">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_tilt_angle2Orthogonal">
                                        <xs:attribute fixed="degrees" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="details" type="xs:string" minOccurs="0"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="emdb_id" minOccurs="0" type="emdb_id_type"/>
            <xs:element name="pdb_model" maxOccurs="unbounded" type="pdb_model_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>The pdb model may have been built up from several actual PDB models.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="insilico_model" minOccurs="0" type="xs:token"> </xs:element>
            <xs:element name="other" minOccurs="0" type="xs:string"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:choice>
    </xs:complexType>
    <xs:complexType name="map_type">
        <xs:sequence>
            <xs:element name="file">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="emd_\d{4,}([A-Za-z0-9_]*).map(.gz|)"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="symmetry" type="applied_symmetry_type">
                <xs:annotation>
                    <xs:documentation>Only one symmetry element per processing type. Use additional processing type elements, and specify the sample components for each if more that one symmetry has been applied.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="data_type" type="map_data_type"> </xs:element>
            <xs:element name="dimensions" type="integer_vector_map_type"/>
            <xs:element name="origin">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="col" type="xs:integer"/>
                        <xs:element name="row" type="xs:integer"/>
                        <xs:element name="sec" type="xs:integer"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="spacing">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="x" type="xs:positiveInteger"/>
                        <xs:element name="y" type="xs:nonNegativeInteger"/>
                        <xs:element name="z" type="xs:nonNegativeInteger"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="cell">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="a" type="cell_type"/>
                        <xs:element name="b" type="cell_type"/>
                        <xs:element name="c" type="cell_type"/>
                        <xs:element name="alpha" type="cell_angle_type"/>
                        <xs:element name="beta" type="cell_angle_type"/>
                        <xs:element name="gamma" type="cell_angle_type"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="axis_order">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="fast">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="X|Y|Z"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="medium">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="X|Y|Z"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="slow">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="X|Y|Z"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="statistics" type="map_statistics_type"> </xs:element>
            <xs:element name="pixel_spacing">
                <xs:annotation>
                    <xs:appinfo/>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="x" type="pixel_spacing_type"> </xs:element>
                        <xs:element name="y" type="pixel_spacing_type"> </xs:element>
                        <xs:element name="z" type="pixel_spacing_type"> </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="contour_list">
                <xs:annotation>
                    <xs:documentation>Optional for tomography</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="contour">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="level" type="xs:float">
                                        <xs:annotation>
                                            <xs:documentation>Optional for tomography.</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                    <xs:element name="source" minOccurs="0">
                                        <xs:annotation>
                                            <xs:documentation>Optional for tomography.</xs:documentation>
                                        </xs:annotation>
                                        <xs:simpleType>
                                            <xs:restriction base="xs:token">
                                                <xs:enumeration value="EMDB"/>
                                                <xs:enumeration value="AUTHOR"/>
                                            </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                </xs:sequence>
                                <xs:attribute name="primary" type="xs:boolean" use="required"/>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="label" type="xs:token"/>
            <xs:element name="annotation_details" minOccurs="0" type="xs:string"/>
            <xs:element name="details" minOccurs="0" type="xs:string">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute fixed="CCP4" name="format" use="required"/>
        <xs:attribute name="size_kbytes" type="xs:positiveInteger" use="required"/>
    </xs:complexType>
    <xs:complexType name="validation_type">
        <xs:sequence>
            <xs:element minOccurs="0" ref="fsc_curve"/>
            <xs:element minOccurs="0" ref="crystallography_validation"/>
        </xs:sequence>
    </xs:complexType>
    <xs:element name="validation_type"/>
    <xs:element name="fsc_curve" substitutionGroup="validation_type">
        <xs:annotation>
            <xs:documentation/>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element name="file">
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:pattern value="emd_\d{4,}_fsc.xml"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element minOccurs="0" name="details" type="xs:string"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="layer_lines" substitutionGroup="validation_type">
        <xs:annotation>
            <xs:documentation/>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element name="file">
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:pattern value="emd_\d{4,}_fsc.xml"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="structure_factors" substitutionGroup="validation_type">
        <xs:annotation>
            <xs:documentation/>
        </xs:annotation>
        <xs:complexType>
            <xs:sequence>
                <xs:element name="file">
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:pattern value="emd_\d{4,}_fsc.xml"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="crystallography_validation" substitutionGroup="validation_type">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="parallel_resolution"/>
                <xs:element name="perpendicular_resolution"/>
                <xs:element name="number_observed_reflections"/>
                <xs:element name="number_unique_reflections"/>
                <xs:element name="weighted_phase_residual"/>
                <xs:element name="weighted_r_factor"/>
                <xs:element name="data_completeness"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="grant_reference_type">
        <xs:sequence>
            <xs:element name="funding_body" type="xs:token"/>
            <xs:element name="code" type="xs:token"/>
            <xs:element name="country" type="xs:token"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="chain_type">
        <xs:sequence>
            <xs:element name="id" type="chain_pdb_id"> </xs:element>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="residue_range">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="\d+-\d+"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="pdb_model_type">
        <xs:sequence>
            <xs:element name="pdb_id" type="pdb_code_type"/>
            <xs:element minOccurs="0" name="chain_id_list" type="chain_type"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="macromolecules_and_complexes_type">
        <xs:annotation>
            <xs:documentation>Depending on the problem, one can either reference the sample on the macromolecule level or the complex level. </xs:documentation>
        </xs:annotation>
        <xs:choice maxOccurs="unbounded">
            <xs:element name="macromolecule_id" type="xs:positiveInteger">
                <xs:annotation>
                    <xs:documentation>_emd_specimen.macromolecule_id_list</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="complex_id" type="xs:nonNegativeInteger">
                <xs:annotation>
                    <xs:documentation>_emd_specimen.complex_id_list ADDED</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:choice>
    </xs:complexType>
    <!--xs:element name="sample" substitutionGroup="supramolecule">
    <xs:complexType>
        <xs:complexContent>
            <xs:extension base="base_supramolecule_type">
                <xs:sequence>
                    <xs:element name="natural_source">
                        <xs:complexType>
                            <xs:complexContent>
                                <xs:extension base="base_natural_source_type">
                                    <xs:sequence>
                                        <xs:element minOccurs="0" name="organ" type="xs:token"/>
                                    </xs:sequence>
                                </xs:extension>
                            </xs:complexContent>
                        </xs:complexType>
                    </xs:element>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    </xs:element-->
    <xs:element name="sample" substitutionGroup="supramolecule">
        <xs:annotation>
            <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_supramolecule_type">
                    <xs:sequence>
                        <xs:element name="natural_source">
                            <xs:complexType>
                                <xs:complexContent>
                                    <xs:extension base="base_natural_source_type">
                                        <xs:sequence>
                                            <xs:element minOccurs="0" name="organ" type="xs:token"/>
                                            <xs:element minOccurs="0" name="tissue" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>Same content as 'name'</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element minOccurs="0" name="cell" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>Same content as 'name' element</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                        </xs:sequence>
                                    </xs:extension>
                                </xs:complexContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="number_unique_components" type="xs:positiveInteger"
                            minOccurs="0"/>
                        <xs:element minOccurs="0" name="molecular_weight"
                            type="molecular_weight_type"/>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="cell" substitutionGroup="supramolecule">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_supramolecule_type">
                    <xs:sequence>
                        <xs:element name="natural_source">
                            <xs:complexType>
                                <xs:complexContent>
                                    <xs:extension base="base_natural_source_type">
                                        <xs:sequence>
                                            <xs:element minOccurs="0" name="organ" type="xs:token"/>
                                            <xs:element minOccurs="0" name="tissue" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>Same content as 'name'</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element minOccurs="0" name="cell" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>Same content as 'name' element</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                        </xs:sequence>
                                    </xs:extension>
                                </xs:complexContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="tissue" substitutionGroup="supramolecule">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_supramolecule_type">
                    <xs:sequence>
                        <xs:element name="natural_source">
                            <xs:complexType>
                                <xs:complexContent>
                                    <xs:extension base="base_natural_source_type">
                                        <xs:sequence>
                                            <xs:element minOccurs="0" name="organ" type="xs:token"/>
                                            <xs:element minOccurs="0" name="tissue" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>Same content as 'name'</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                        </xs:sequence>
                                    </xs:extension>
                                </xs:complexContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="organelle_or_cellular_component" substitutionGroup="supramolecule">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_supramolecule_type">
                    <xs:sequence>
                        <xs:element name="natural_source">
                            <xs:complexType>
                                <xs:complexContent>
                                    <xs:extension base="base_natural_source_type">
                                        <xs:sequence>
                                            <xs:element minOccurs="0" name="organ" type="xs:token"/>
                                            <xs:element minOccurs="0" name="tissue" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>Same content as 'name'</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element minOccurs="0" name="cell" type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>For example: HeLa</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element minOccurs="0" name="organelle"
                                                type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation>For example: Mitochondrion</xs:documentation>
                                                </xs:annotation>
                                            </xs:element>
                                            <xs:element minOccurs="0" name="cellular_location"
                                                type="xs:token">
                                                <xs:annotation>
                                                  <xs:documentation/>
                                                </xs:annotation>
                                            </xs:element>
                                        </xs:sequence>
                                    </xs:extension>
                                </xs:complexContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element minOccurs="0" name="molecular_weight"
                            type="molecular_weight_type"/>
                        <xs:element maxOccurs="1" minOccurs="0" name="recombinant_expression"
                            type="recombinant_source_type">
                            <xs:annotation>
                                <xs:documentation>Expression system (or host system if virus)</xs:documentation>
                                <xs:documentation>Deprecated (2014/11/14)
Does not make any sense for cellular component
Present for legacy compatibility with 1.9</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="virus" substitutionGroup="supramolecule">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_supramolecule_type">
                    <xs:sequence>
                        <xs:element minOccurs="0" name="sci_species_name"
                            type="virus_species_name_type">
                            <xs:annotation>
                                <xs:documentation/>
                            </xs:annotation>
                        </xs:element>
                        <xs:element maxOccurs="1" minOccurs="0" name="sci_species_strain"
                            type="xs:string">
                            <xs:annotation>
                                <xs:documentation/>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="natural_host" maxOccurs="unbounded">
                            <xs:complexType>
                                <xs:complexContent>
                                    <xs:extension base="base_natural_source_type">
                                        <!--xs:sequence>
                                        <xs:element name="category">
                                            <xs:simpleType>
                                            <xs:restriction base="xs:token">
                                            <xs:enumeration value="ALGAE"/>
                                            <xs:enumeration value="ARCHAEA"/>
                                            <xs:enumeration value="BACTERIA(EUBACTERIA)"/>
                                            <xs:enumeration value="FUNGI"/>
                                            <xs:enumeration value="INVERTEBRATES"/>
                                            <xs:enumeration value="PLANTAE(HIGHER PLANTS)"/>
                                            <xs:enumeration value="PROTOZOA"/>
                                            <xs:enumeration value="VERTEBRATES"/>
                                            </xs:restriction>
                                            </xs:simpleType>
                                        </xs:element>
                                    </xs:sequence-->
                                    </xs:extension>
                                </xs:complexContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="host_system" type="recombinant_source_type">
                            <xs:annotation>
                                <xs:documentation/>
                            </xs:annotation>
                        </xs:element>
                        <xs:element minOccurs="0" name="molecular_weight"
                            type="molecular_weight_type"/>
                        <xs:element minOccurs="0" name="virus_shell" maxOccurs="unbounded">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element minOccurs="0" name="name" type="xs:token"
                                        nillable="false"/>
                                    <xs:element name="diameter" minOccurs="0">
                                        <xs:annotation>
                                            <xs:documentation>This item is currently optional, but I propose to make it mandatory.</xs:documentation>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="allowed_shell_diameter">
                                                  <xs:attribute fixed="Å" name="units"
                                                  use="required"/>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element name="triangulation" type="xs:positiveInteger"
                                        minOccurs="0">
                                        <xs:annotation>
                                            <xs:documentation>This item is currently optional, but I propose to make it mandatory.</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                </xs:sequence>
                                <xs:attribute name="id" type="xs:positiveInteger"/>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="virus_type">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="VIRION"/>
                                    <xs:enumeration value="SATELLITE"/>
                                    <xs:enumeration value="PRION"/>
                                    <xs:enumeration value="VIROID"/>
                                    <xs:enumeration value="VIRUS-LIKE PARTICLE"/>
                                    <xs:enumeration value="OTHER"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="virus_isolate">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="STRAIN"/>
                                    <xs:enumeration value="SEROTYPE"/>
                                    <xs:enumeration value="SEROCOMPLEX"/>
                                    <xs:enumeration value="SUBSPECIES"/>
                                    <xs:enumeration value="SPECIES"/>
                                    <xs:enumeration value="OTHER"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="virus_enveloped" type="xs:boolean"/>
                        <xs:element name="virus_empty" type="xs:boolean"/>
                        <xs:element maxOccurs="1" minOccurs="0" name="syn_species_name"
                            type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Deprecated (2014/11/17)
Placeholder for corresponding element in v1.9</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element maxOccurs="1" minOccurs="0" name="sci_species_serotype"
                            type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Deprecated (2014/11/17)
Placeholder for corresponding element in v1.9</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element maxOccurs="1" minOccurs="0" name="sci_species_serocomplex"
                            type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Deprecated (2014/11/17)
Placeholder for corresponding element in v1.9</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element maxOccurs="1" minOccurs="0" name="sci_species_subspecies"
                            type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Deprecated (2014/11/17)
Placeholder for corresponding element in v1.9</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="complex" substitutionGroup="supramolecule">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_supramolecule_type">
                    <xs:sequence>
                        <xs:element name="natural_source" type="natural_source_type"
                            maxOccurs="unbounded" minOccurs="0"/>
                        <xs:element name="recombinant_expression" type="recombinant_source_type"
                            maxOccurs="unbounded" minOccurs="0">
                            <xs:annotation>
                                <xs:documentation>Expression system (or host system if virus)</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element minOccurs="0" name="molecular_weight"
                            type="molecular_weight_type"/>
                        <xs:element minOccurs="0" name="ribosome-details" type="xs:string">
                            <xs:annotation>
                                <xs:documentation>Deprecated (2014/11/17)
Added only to transfer eukaryotic (eukaryotic-ribosomes) and prokaryotic (prokaryotic-robosomes) from v1.9</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                    <xs:attribute fixed="true" name="chimera" type="xs:boolean"/>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="base_supramolecule_type">
        <xs:sequence>
            <xs:element name="name" type="sci_name_type">
                <xs:annotation>
                    <xs:documentation>Take this name from Gene Ontology.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="category">
                <xs:annotation>
                    <xs:documentation>Should more than one category allowed?

All the GO terms should be descendant of 'cellular_component'
http://www.ebi.ac.uk/QuickGO/GTerm?id=GO:0005575</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="complex_category_type">
                            <xs:attribute name="type" use="required">
                                <xs:annotation>
                                    <xs:documentation>Currently we only support Gene Ontology.</xs:documentation>
                                </xs:annotation>
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="GO"/>
                                        <xs:enumeration value="ARBITRARY DEFINITION"/>
                                        <xs:enumeration value="PROTEIN ONTOLOGY"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="parent" type="xs:nonNegativeInteger">
                <xs:annotation>
                    <xs:documentation>'sample' supramolecule has value 0</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="macromolecule_list" minOccurs="0">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="macromolecule">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="id" type="xs:positiveInteger">
                                        <xs:annotation>
                                            <xs:documentation>Links to the sample macromolecule list</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                    <xs:element name="number_of_copies" type="xs:positiveInteger"/>
                                    <xs:element name="oligomeric_state" type="xs:token"/>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="details" type="xs:string"/>
            <xs:element name="number_of_copies" type="pos_int_or_string_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Number of copies within parent</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="oligomeric_state" type="pos_int_or_string_type" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Oligomeric state in parent, or if sample, the oligomeric state of sample</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="external_references">
                <xs:annotation>
                    <xs:documentation>UniProtKB, UniParc, interPro</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="xs:token">
                            <xs:attribute name="type" use="required">
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="UNIPROTKB"/>
                                        <xs:enumeration value="UNIPARC"/>
                                        <xs:enumeration value="INTERPRO"/>
                                        <xs:enumeration value="GO"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element maxOccurs="1" minOccurs="0" name="recombinant_exp_flag" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>Deprecated 2014/12/3</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required"/>
    </xs:complexType>
    <xs:complexType name="complex_type">
        <xs:sequence>
            <xs:element name="name" type="xs:token">
                <xs:annotation>
                    <xs:documentation>Take this name from Gene Ontology.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="category">
                <xs:annotation>
                    <xs:documentation>More than one category is allowed.
All the GO terms should be descendant of 'cellular_component'
http://www.ebi.ac.uk/QuickGO/GTerm?id=GO:0005575
Should be ICTV number be allowed for virus?
</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="complex_category_type">
                            <xs:attribute name="type" use="required">
                                <xs:annotation>
                                    <xs:documentation>Currently we only support Gene Ontology.</xs:documentation>
                                </xs:annotation>
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="GO"/>
                                        <xs:enumeration value="ARBITRARY DEFINITION"/>
                                        <xs:enumeration value="PROTEIN ONTOLOGY"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="parent" type="xs:nonNegativeInteger">
                <xs:annotation>
                    <xs:documentation>Root complex is 0</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="macromolecule_list" minOccurs="0">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="macromolecule_id" maxOccurs="unbounded"
                            type="xs:positiveInteger">
                            <xs:annotation>
                                <xs:documentation>Links to the sample macromolecule list</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="natural_source" type="natural_source_type" maxOccurs="unbounded"/>
            <xs:element name="recombinant_expression" type="recombinant_source_type"
                maxOccurs="unbounded">
                <xs:annotation>
                    <xs:documentation>Expression system (or host system if virus)</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="molecular_weight" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Allowed values: 1 kDa - 10^9 MDa</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_assembly_weights">
                            <xs:attribute name="units" use="required">
                                <xs:annotation>
                                    <xs:documentation>kDa/nm is for helices.</xs:documentation>
                                </xs:annotation>
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="MDA"/>
                                        <xs:enumeration value="KDA/NM"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                            <xs:attribute name="theoretical" type="xs:boolean" fixed="true"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="virus_shell">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element minOccurs="0" name="name" type="xs:token"/>
                        <xs:element name="diameter">
                            <xs:annotation>
                                <xs:documentation>This item is currently optional, but I propose to make it mandatory.</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_shell_diameter">
                                        <xs:attribute fixed="Å" name="units" use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="triangulation" type="xs:positiveInteger">
                            <xs:annotation>
                                <xs:documentation>This item is currently optional, but I propose to make it mandatory.</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="details" type="xs:string"/>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required"/>
        <xs:attribute fixed="true" name="chimera" type="xs:boolean"/>
    </xs:complexType>
    <xs:complexType name="interpretation_type">
        <xs:sequence>
            <xs:element name="modelling_list" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="modelling" type="modelling_type">
                            <xs:annotation>
                                <xs:documentation>Link to assembly or component id.</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="figure_list" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="figure" type="figure_type" maxOccurs="unbounded"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="segmentation_list" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="segmentation">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="file">
                                        <xs:simpleType>
                                            <xs:restriction base="xs:token">
                                                <xs:pattern value="emd_\d{4,}_seg.xml"/>
                                            </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="details" type="xs:string"/>
                                    <xs:element minOccurs="0" name="mask_details" type="map_type">
                                        <xs:annotation>
                                            <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="slices_list" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="slice" type="map_type">
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="additional_map_list" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="additional_map" type="map_type">
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="half_map_list" minOccurs="0">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="half_map" type="map_type">
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="software_list_type">
        <xs:sequence>
            <xs:element maxOccurs="unbounded" name="software" type="software_type"> </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:simpleType name="correction_space_type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="2D"/>
            <xs:enumeration value="3D"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="code_type">
        <xs:simpleContent>
            <xs:extension base="status_code_type">
                <xs:attribute name="superseded" type="xs:boolean">
                    <xs:annotation>
                        <xs:documentation>It is true, if the current status is 'OBS' and the entry has been replaced by newer entries. </xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="supersedes" type="xs:boolean">
                    <xs:annotation>
                        <xs:documentation>This is true if the current status is 'REL' and there are older entries that have been made obsoleted because of this one.</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="auxiliary_link_type">
        <xs:sequence>
            <xs:element name="type">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="2D EM DATA"/>
                        <xs:enumeration value="CORRELATIVE LIGHT MICROSCOPY"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="link">
                <xs:annotation>
                    <xs:documentation>URL link to publicly available database of light microscopy images.
</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:anyURI">
                        <xs:pattern value="(https?|ftp)://.*"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="author_order_type">
        <xs:simpleContent>
            <xs:extension base="author_type">
                <xs:attribute name="order" type="xs:positiveInteger"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:simpleType name="emdb_id_type">
        <xs:restriction base="xs:token">
            <xs:pattern value="EMD-\d{4,}"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="pdb_code_type">
        <xs:restriction base="xs:token">
            <xs:pattern value="\d[\dA-Za-z]{3}"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="complex_category_type">
        <xs:restriction base="xs:token">
            <xs:pattern value="GO:\d+"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="author_type">
        <xs:restriction base="xs:token">
            <xs:pattern value="[A-Za-z '\-]+ [A-Z\-]+"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="page_type">
        <xs:restriction base="xs:string"> </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_assembly_weights">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0.001"/>
            <xs:maxInclusive value="1000000000.0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_component_weights">
        <xs:restriction base="xs:float">
            <xs:maxInclusive value="5000"/>
            <xs:minInclusive value="0.001"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="macromolecule_list_type">
        <xs:sequence>
            <xs:element maxOccurs="unbounded" ref="macromolecule"/>
        </xs:sequence>
    </xs:complexType>
    <xs:element name="macromolecule" type="base_macromolecule_type">
        <xs:annotation>
            <xs:documentation>Unique set of macromolecular chain(s)
We need to have a base type and specific types for each componenetType: protein (ask uniprot id, EC, interPro, etc...), DNA sequence, etc..</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:element name="supramolecule" type="base_supramolecule_type">
        <xs:annotation>
            <xs:documentation>Unique set of macromolecular chain(s)
            We need to have a base type and specific types for each componenetType: protein (ask uniprot id, EC, interPro, etc...), DNA sequence, etc..</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:simpleType name="allowed_film_thickness">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="5"/>
            <xs:maxInclusive value="50"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_time_glow_discharge">
        <xs:restriction base="xs:positiveInteger">
            <xs:maxInclusive value="300"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_pressure_glow_discharge">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0.1"/>
            <xs:maxInclusive value="100"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_temperature_vitrification">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="270"/>
            <xs:maxInclusive value="300"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_angle_shadowing">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="90"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_thickness_shadowing">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0.1"/>
            <xs:maxInclusive value="30"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_diameter_colloidal_gold">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0.1"/>
            <xs:maxInclusive value="20"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="temperature_type">
        <xs:simpleContent>
            <xs:extension base="allowed_temperature">
                <xs:attribute fixed="K" name="units" type="xs:token" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:simpleType name="allowed_focus_ion_final_thickness">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="10"/>
            <xs:maxInclusive value="300"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_cell_dim">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0.0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="cell_type">
        <xs:simpleContent>
            <xs:extension base="allowed_cell_dim">
                <xs:attribute fixed="Å" name="units" type="xs:token" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:simpleType name="allowed_cell_angle">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0.0"/>
            <xs:maxExclusive value="180.0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="cell_angle_type">
        <xs:simpleContent>
            <xs:extension base="allowed_cell_angle">
                <xs:attribute fixed="deg" name="units" type="xs:token" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="integer_vector_map_type">
        <xs:sequence>
            <xs:element name="col" type="xs:positiveInteger"/>
            <xs:element name="row" type="xs:positiveInteger"/>
            <xs:element name="sec" type="xs:positiveInteger"/>
        </xs:sequence>
    </xs:complexType>
    <xs:simpleType name="map_data_type">
        <xs:restriction base="xs:string">
            <xs:enumeration value="IMAGE STORED AS SIGNED BYTE"/>
            <xs:enumeration value="IMAGE STORED AS SIGNED INTEGER (2 BYTES)"/>
            <xs:enumeration value="IMAGE STORED AS FLOATING POINT NUMBER (4 BYTES)"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:element name="citation_type"/>
    <xs:element name="non_journal_citation" substitutionGroup="citation_type">
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" name="author" type="author_order_type"/>
                <xs:element name="editor" maxOccurs="unbounded" type="author_order_type"
                    minOccurs="0"/>
                <xs:element name="book_title" type="xs:token">
                    <xs:annotation>
                        <xs:documentation>Thesis/dissertations included</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element name="thesis_title" type="xs:token" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                    </xs:annotation>
                </xs:element>
                <xs:element name="book_chapter_title" type="xs:token" minOccurs="0"/>
                <xs:element minOccurs="0" name="volume" type="xs:string"/>
                <xs:element name="publisher" type="xs:token"/>
                <xs:element name="publication_location">
                    <xs:annotation>
                        <xs:documentation>Example: London</xs:documentation>
                    </xs:annotation>
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:pattern value="[\w -]+(, [\w -]+)*"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element name="country" type="xs:token"/>
                <xs:element name="first_page" type="page_type"> </xs:element>
                <xs:element name="last_page" type="page_type"> </xs:element>
                <xs:element name="year">
                    <xs:simpleType>
                        <xs:restriction base="xs:gYear">
                            <xs:minInclusive value="1900"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element minOccurs="0" name="language" type="xs:language"/>
                <xs:element maxOccurs="unbounded" minOccurs="0" name="external_references">
                    <xs:annotation>
                        <xs:documentation>This should be substitution group so each external reference type has a proper format: example doi -&gt; doi format; pubmed -&gt; pubmed format, etc...</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:simpleContent>
                            <xs:extension base="xs:token">
                                <xs:attribute name="type" use="required">
                                    <xs:simpleType>
                                        <xs:restriction base="xs:token">
                                            <xs:enumeration value="PUBMED"/>
                                            <xs:enumeration value="DOI"/>
                                            <xs:enumeration value="ISBN"/>
                                            <xs:enumeration value="ISSN"/>
                                            <xs:enumeration value="CAS"/>
                                            <xs:whiteSpace value="collapse"/>
                                            <xs:enumeration value="CSD"/>
                                            <xs:enumeration value="MEDLINE"/>
                                            <xs:enumeration value="ASTM"/>
                                        </xs:restriction>
                                    </xs:simpleType>
                                </xs:attribute>
                            </xs:extension>
                        </xs:simpleContent>
                    </xs:complexType>
                </xs:element>
                <xs:element minOccurs="0" name="details" type="xs:string"/>
            </xs:sequence>
            <xs:attribute name="published" type="xs:boolean" use="required"/>
        </xs:complexType>
    </xs:element>
    <xs:element name="journal_citation" substitutionGroup="citation_type">
        <xs:complexType>
            <xs:sequence>
                <xs:element maxOccurs="unbounded" name="author" type="author_order_type"/>
                <xs:element name="editor" maxOccurs="unbounded" type="author_order_type"
                    minOccurs="0"/>
                <xs:element name="title" type="xs:token"/>
                <xs:element name="journal" type="xs:token"/>
                <xs:element name="journal_abbreviation" minOccurs="0">
                    <xs:annotation>
                        <xs:documentation>PubMed abbreviation format</xs:documentation>
                    </xs:annotation>
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:pattern value="[A-Z][a-z]*\.?( [A-Z][a-z]+\.?)*"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element name="country" type="xs:token"/>
                <xs:element name="issue" type="xs:positiveInteger"/>
                <xs:element name="volume" type="xs:string" nillable="true"/>
                <xs:element name="first_page" type="page_type" nillable="false"> </xs:element>
                <xs:element name="last_page" type="page_type"> </xs:element>
                <xs:element name="year">
                    <xs:simpleType>
                        <xs:restriction base="xs:gYear">
                            <xs:minInclusive value="1900"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element minOccurs="0" name="language" type="xs:language"/>
                <xs:element maxOccurs="unbounded" minOccurs="0" name="external_references">
                    <xs:annotation>
                        <xs:documentation>This should be substitution group so each external reference type has a proper format: example doi -&gt; doi format; pubmed -&gt; pubmed format, etc...</xs:documentation>
                    </xs:annotation>
                    <xs:complexType>
                        <xs:simpleContent>
                            <xs:extension base="xs:token">
                                <xs:attribute name="type" use="required">
                                    <xs:simpleType>
                                        <xs:restriction base="xs:token">
                                            <xs:enumeration value="PUBMED"/>
                                            <xs:enumeration value="DOI"/>
                                            <xs:enumeration value="ISBN"/>
                                            <xs:enumeration value="ISSN"/>
                                            <xs:enumeration value="CAS"/>
                                            <xs:whiteSpace value="collapse"/>
                                            <xs:enumeration value="CSD"/>
                                            <xs:enumeration value="MEDLINE"/>
                                            <xs:enumeration value="ASTM"/>
                                        </xs:restriction>
                                    </xs:simpleType>
                                </xs:attribute>
                            </xs:extension>
                        </xs:simpleContent>
                    </xs:complexType>
                </xs:element>
                <xs:element minOccurs="0" name="details" type="xs:string"/>
            </xs:sequence>
            <xs:attribute name="published" type="xs:boolean" use="required"/>
        </xs:complexType>
    </xs:element>
    <xs:simpleType name="point_group_symmetry_type">
        <xs:restriction base="xs:token">
            <xs:pattern value="C\d+|D\d+|O|T|I"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_electron_dose">
        <xs:annotation>
            <xs:documentation>Range not suitable for electronDiffraction.</xs:documentation>
        </xs:annotation>
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
            <xs:maxInclusive value="1000"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_defocus_min">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="-10"/>
            <xs:maxInclusive value="10"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_defocus_max">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="-20"/>
            <xs:maxInclusive value="20"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_acceleration_voltage">
        <xs:restriction base="xs:positiveInteger">
            <xs:minInclusive value="25"/>
            <xs:maxInclusive value="400"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_magnification">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="100"/>
            <xs:maxInclusive value="100000"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_temperature">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
            <xs:maxInclusive value="310"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_nominal_cs">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="10"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_c2_aperture_diameter">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="5"/>
            <xs:maxInclusive value="50"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_energy_window">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="500"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_camera_length">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="3000"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_tilt_angle">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="-70"/>
            <xs:maxInclusive value="70"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_scaning_interval">
        <xs:restriction base="xs:float">
            <xs:maxInclusive value="50"/>
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="software_type">
        <xs:sequence>
            <xs:element name="name" type="xs:token"/>
            <xs:element minOccurs="0" name="version" type="xs:token"/>
            <xs:element minOccurs="0" name="processing_details" type="xs:string"/>
        </xs:sequence>
    </xs:complexType>
    <xs:simpleType name="allowed_tilt_angle_random_conical">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="45"/>
            <xs:maxInclusive value="70"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_tilt_angle1Orthogonal">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="-50"/>
            <xs:maxInclusive value="-30"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_tilt_angle2Orthogonal">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="30"/>
            <xs:maxInclusive value="50"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="chain_pdb_id">
        <xs:restriction base="xs:token">
            <xs:pattern value="\d|[A-Za-z]"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_angular_sampling">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="plane_and_space_group_type">
        <xs:restriction base="xs:token">
            <xs:enumeration value="1"/>
            <xs:enumeration value="P 1"/>
            <xs:enumeration value="P 1 2"/>
            <xs:enumeration value="P 1 21"/>
            <xs:enumeration value="P 2"/>
            <xs:enumeration value="P 2 2 2"/>
            <xs:enumeration value="P 2 2 21"/>
            <xs:enumeration value="P 2 21 21"/>
            <xs:enumeration value="P 3"/>
            <xs:enumeration value="P 3 1 2"/>
            <xs:enumeration value="P 3 2 1"/>
            <xs:enumeration value="P 4"/>
            <xs:enumeration value="P 4 2 2"/>
            <xs:enumeration value="P 4 21 2"/>
            <xs:enumeration value="P 6"/>
            <xs:enumeration value="P 6 2 2"/>
            <xs:enumeration value="C 1 2"/>
            <xs:enumeration value="C 2 2"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_pixel_sampling">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
            <xs:maxExclusive value="50"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_humidity_vitrification">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="100"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="telephone_number_type">
        <xs:sequence>
            <xs:element name="country">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="\d{1,3}"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="area">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="\d{2,5}"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="local">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="\d+( ext. \d+)?"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:simpleType name="allowed_film_or_detector_model">
        <xs:restriction base="xs:token">
            <xs:enumeration value="KODAK SO-163"/>
            <xs:enumeration value="FEI EAGLE 2K"/>
            <xs:enumeration value="GATAN K2 SUMMIT"/>
            <xs:enumeration value="GATAN K2 BASE"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="resolution_type">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_concentration">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_microtome_thickness">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="4"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_focus_ion_current">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="1"/>
            <xs:maxInclusive value="20000"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_focus_ion_voltage">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="5"/>
            <xs:maxInclusive value="30"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_focus_ion_initial_thickness">
        <xs:restriction base="xs:float">
            <xs:maxInclusive value="2000"/>
            <xs:minInclusive value="10"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_focus_ion_dose_rate">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
            <xs:maxInclusive value="10"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_angle_tomography">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="-70"/>
            <xs:maxExclusive value="70"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_angle_increment">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
            <xs:maxExclusive value="15"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_shell_diameter">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="10"/>
            <xs:maxInclusive value="5000"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="crystallography_preparation_type">
        <xs:annotation>
            <xs:documentation>TODO: add limits and units.</xs:documentation>
        </xs:annotation>
        <xs:complexContent>
            <xs:extension base="base_preparation_type">
                <xs:sequence>
                    <xs:element name="crystal_formation">
                        <xs:complexType>
                            <xs:sequence>
                                <xs:element name="lipid_protein_ratio" minOccurs="0" type="xs:float"
                                    > </xs:element>
                                <xs:element name="lipid_mixture" minOccurs="0" type="xs:token"> </xs:element>
                                <xs:element name="instrument" minOccurs="0">
                                    <xs:simpleType>
                                        <xs:restriction base="xs:token"> </xs:restriction>
                                    </xs:simpleType>
                                </xs:element>
                                <xs:element minOccurs="0" name="atmosphere" type="xs:token"/>
                                <xs:element name="temperature" minOccurs="0"
                                    type="crystal_formation_temperature_type"> </xs:element>
                                <xs:element name="time" minOccurs="0"
                                    type="crystal_formation_time_type"> </xs:element>
                                <xs:element name="details" minOccurs="0" type="xs:string">
                                    <xs:annotation>
                                        <xs:documentation>_emd_specimen.crystal_formation_details</xs:documentation>
                                    </xs:annotation>
                                </xs:element>
                            </xs:sequence>
                        </xs:complexType>
                    </xs:element>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:simpleType name="allowed_rise_type">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_twist_type">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_average_exposure_time_type">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
            <xs:maxExclusive value="20"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="non_zero_float">
        <xs:restriction base="xs:float">
            <xs:minExclusive value="0"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="reconstruction_algorithm_type">
        <xs:restriction base="xs:token">
            <xs:enumeration value="ARTS"/>
            <xs:enumeration value="SIRT"/>
            <xs:enumeration value="BACK-PROJECTION RECONSTRUCTION"/>
            <xs:enumeration value="EXACT BACK-PROJECTION RECONSTRUCTION"/>
            <xs:enumeration value="FOURIER SPACE RECONSTRUCTION"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:complexType name="background_masked_type">
        <xs:sequence>
            <xs:element name="geometrical_shape">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="SPHERE"/>
                        <xs:enumeration value="SOFT SPHERE"/>
                        <xs:enumeration value="GAUSSIAN"/>
                        <xs:enumeration value="CIRCLE"/>
                        <xs:enumeration value="RECTANGLE"/>
                        <xs:enumeration value="CYLINDER"/>
                        <xs:enumeration value="OTHER"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element minOccurs="0" name="dimensions">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element minOccurs="0" name="radius">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:float">
                                        <xs:attribute name="units" use="required">
                                            <xs:simpleType>
                                                <xs:restriction base="xs:token">
                                                  <xs:enumeration value="PIXEL"/>
                                                  <xs:enumeration value="Å"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="width">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:float">
                                        <xs:attribute name="units" use="required">
                                            <xs:simpleType>
                                                <xs:restriction base="xs:token">
                                                  <xs:enumeration value="PIXEL"/>
                                                  <xs:enumeration value="Å"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="height">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:float">
                                        <xs:attribute name="units" use="required">
                                            <xs:simpleType>
                                                <xs:restriction base="xs:token">
                                                  <xs:enumeration value="PIXEL"/>
                                                  <xs:enumeration value="Å"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="depth">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:float">
                                        <xs:attribute name="units" use="required">
                                            <xs:simpleType>
                                                <xs:restriction base="xs:token">
                                                  <xs:enumeration value="PIXEL"/>
                                                  <xs:enumeration value="Å"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="software_list" type="software_list_type"/>
            <xs:element minOccurs="0" name="details" type="xs:string"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="reconstruction_filtering_type">
        <xs:sequence>
            <xs:element minOccurs="0" name="background_masked" type="background_masked_type"> </xs:element>
            <xs:element minOccurs="0" name="spatial_filtering">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="low_frequency_cutoff">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:float">
                                        <xs:attribute fixed="1/Å" name="units" use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="high_frequency_cutoff">
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:float">
                                        <xs:attribute fixed="1/Å" name="units" use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="filter_function" type="xs:token"/>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element minOccurs="0" name="details" type="xs:string"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="sharpening">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element minOccurs="0" name="details" type="xs:string"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="b-factorSharpening">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="_brestore">
                            <xs:annotation>
                                <xs:documentation>Rosenthal PB and Henderson R, Optimal Determination of Particle Orientation, Absolute Hand, and Contrast Loss in Single-particle Electron Cryomicroscopy, J. Mol. Biol. 333 (2003), 721–745
http://dx.doi.org/10.1016/j.jmb.2003.07.013</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="allowed_brestore_type">
                                        <xs:attribute fixed="Å^2" name="units" type="xs:token"
                                            use="required"/>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element minOccurs="0" name="details" type="xs:string"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element minOccurs="0" name="other">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="software_list" type="software_list_type"/>
                        <xs:element minOccurs="0" name="details" type="xs:string"/>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:simpleType name="allowed_brestore_type">
        <xs:restriction base="xs:float">
            <xs:maxExclusive value="0"/>
            <xs:minExclusive value="-1000"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:simpleType name="allowed_crystal_formation_temperature_type">
        <xs:restriction base="xs:float">
            <xs:minInclusive value="270"/>
            <xs:maxInclusive value="343"/>
        </xs:restriction>
    </xs:simpleType>
    <xs:element name="chain_id_list">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="chain_type"/>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="recombinant_source_type">
        <xs:sequence>
            <xs:element name="organism" type="organism_type">
                <xs:annotation>
                    <xs:documentation>Mandatory for all component. For synthetic components like 'EM labels' is 'synthetic construct' Taxonomy ID: 32630</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="strain" type="xs:token"/>
            <xs:element minOccurs="0" name="cell" type="xs:token">
                <xs:annotation>
                    <xs:documentation>For example: HeLa</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="plasmid" type="xs:token"/>
            <xs:element name="synonym_organism" type="xs:token" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="database" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:token">
                    <xs:enumeration value="NCBI"/>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="organism_type">
        <xs:simpleContent>
            <xs:extension base="xs:token">
                <xs:attribute name="ncbi" type="xs:positiveInteger" use="optional"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="base_natural_source_type">
        <xs:sequence>
            <xs:element name="organism" type="organism_type">
                <xs:annotation>
                    <xs:documentation>Mandatory for all component. For synthetic components like 'EM labels' is 'synthetic construct' Taxonomy ID: 32630</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="strain" type="organism_type"/>
            <xs:element name="synonym_organism" type="xs:token" minOccurs="0">
                <xs:annotation>
                    <xs:documentation>Deprecated (2014-10-21)</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="database" use="required">
            <xs:simpleType>
                <xs:restriction base="xs:token">
                    <xs:enumeration value="NCBI"/>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
    </xs:complexType>
    <xs:complexType name="natural_source_type">
        <xs:complexContent>
            <xs:extension base="base_natural_source_type">
                <xs:sequence>
                    <xs:element minOccurs="0" name="organ" type="xs:token"/>
                    <xs:element minOccurs="0" name="tissue" type="xs:token">
                        <xs:annotation>
                            <xs:documentation>For example: Epithelium</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element minOccurs="0" name="cell" type="xs:token">
                        <xs:annotation>
                            <xs:documentation>For example: HeLa</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element minOccurs="0" name="organelle" type="xs:token">
                        <xs:annotation>
                            <xs:documentation>For example: Mitochondrion</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                    <xs:element minOccurs="0" name="cellular_location" type="xs:token">
                        <xs:annotation>
                            <xs:documentation>For example: Mitochondrion intermembrane space</xs:documentation>
                        </xs:annotation>
                    </xs:element>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="model_type">
        <xs:sequence>
            <xs:element name="access_code" type="pdb_code_type">
                <xs:annotation>
                    <xs:documentation>Allow portions of PDBs </xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element maxOccurs="unbounded" minOccurs="0" name="chain">
                <xs:complexType>
                    <xs:complexContent>
                        <xs:extension base="chain_model_type">
                            <xs:sequence>
                                <xs:element name="number_of_copies_in_final_model"
                                    type="xs:positiveInteger">
                                    <xs:annotation>
                                        <xs:documentation>Number of copies in map. Should it be part of 'interpretation' section?</xs:documentation>
                                    </xs:annotation>
                                </xs:element>
                            </xs:sequence>
                        </xs:extension>
                    </xs:complexContent>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="chain_model_type">
        <xs:complexContent>
            <xs:extension base="chain_type"> </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    <xs:complexType name="helical_parameters_type">
        <xs:sequence>
            <xs:element name="delta_z">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_rise_type">
                            <xs:attribute fixed="Å" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="delta_phi">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_twist_type">
                            <xs:attribute fixed="deg" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="axial_symmetry">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:pattern value="[C|D][1-9][0-9]*"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <!--xs:element name="dyad_axis" type="xs:boolean"/-->
            <!--xs:element name="hand">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="LEFT HANDED"/>
                        <xs:enumeration value="RIGHT HANDED"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element-->
            <xs:element name="hand">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="LEFT HANDED"/>
                        <xs:enumeration value="RIGHT HANDED"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="sci_name_type">
        <xs:simpleContent>
            <xs:extension base="xs:token">
                <xs:attribute name="synonym" type="xs:token">
                    <xs:annotation>
                        <xs:documentation>Deprecated (2014/11/12)</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="molecular_weight_type">
        <xs:sequence>
            <xs:element name="experimental">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_assembly_weights">
                            <xs:attribute name="units" use="required">
                                <xs:annotation>
                                    <xs:documentation>kDa/nm is for helices.</xs:documentation>
                                </xs:annotation>
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="MDA"/>
                                        <xs:enumeration value="KDA/NM"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="theoretical">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="allowed_assembly_weights">
                            <xs:attribute name="units" use="required">
                                <xs:annotation>
                                    <xs:documentation>kDa/nm is for helices.</xs:documentation>
                                </xs:annotation>
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="MDA"/>
                                        <xs:enumeration value="KDA/NM"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="method" type="xs:token"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="virus_species_name_type">
        <xs:simpleContent>
            <xs:extension base="xs:token">
                <xs:attribute name="ncbi" type="xs:positiveInteger"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="base_macromolecule_type">
        <xs:sequence>
            <xs:element name="name" type="sci_name_type">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
            </xs:element>
            <xs:element name="natural_source" type="natural_source_type"/>
            <xs:element minOccurs="0" name="molecular_weight" type="molecular_weight_type">
                <xs:annotation>
                    <xs:documentation>Allowed values: 1 Da - 5 MDa</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="details" type="xs:string"/>
            <xs:element minOccurs="0" name="number_of_copies" type="pos_int_or_string_type"/>
            <xs:element minOccurs="0" name="oligomeric_state" type="pos_int_or_string_type">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
            </xs:element>
            <xs:element maxOccurs="1" minOccurs="0" name="recombinant_exp_flag" type="xs:boolean">
                <xs:annotation>
                    <xs:documentation>Deprecated 2014/12/3</xs:documentation>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
        <xs:attribute name="id" type="xs:positiveInteger" use="required">
            <xs:annotation>
                <xs:documentation>Autogenerated unique identifier.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name="mutant" type="xs:boolean"/>
        <xs:attribute name="chimera" type="xs:boolean"/>
    </xs:complexType>
    <xs:element name="protein_or_peptide" substitutionGroup="macromolecule">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element minOccurs="0" name="recombinant_expression"
                            type="recombinant_source_type"> </xs:element>
                        <xs:element name="enantiomer">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="LEVO"/>
                                    <xs:enumeration value="DEXTRO"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="sequence">
                            <xs:annotation>
                                <xs:documentation>
</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="string">
                                        <xs:annotation>
                                            <xs:documentation/>
                                        </xs:annotation>
                                        <xs:simpleType>
                                            <xs:restriction base="xs:token">
                                                <xs:pattern value="[ ARNDCEQGHILKMFPSTWYVUOBZJX]+"/>
                                            </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="discrepancy_list">
                                        <xs:annotation>
                                            <xs:documentation/>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:sequence>
                                                <xs:element maxOccurs="unbounded" name="discrepancy">
                                                  <xs:annotation>
                                                  <xs:documentation>Format: A1C</xs:documentation>
                                                  </xs:annotation>
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:pattern
                                                  value="[ARNDCEQGHILKMFPSTWYVUOBZJX]\d+[ARNDCEQGHILKMFPSTWYVUOBZJX]"
                                                  />
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                </xs:element>
                                            </xs:sequence>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="connectivity">
                                        <xs:complexType>
                                            <xs:sequence>
                                                <xs:element minOccurs="0" name="_n-link">
                                                  <xs:complexType>
                                                  <xs:sequence>
                                                  <xs:element name="molecule_id"/>
                                                  </xs:sequence>
                                                  </xs:complexType>
                                                </xs:element>
                                                <xs:element minOccurs="0" name="_c-link">
                                                  <xs:complexType>
                                                  <xs:sequence>
                                                  <xs:element name="molecule_id"/>
                                                  </xs:sequence>
                                                  </xs:complexType>
                                                </xs:element>
                                            </xs:sequence>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element maxOccurs="unbounded" minOccurs="0"
                                        name="external_references">
                                        <xs:annotation>
                                            <xs:documentation>UniProtKB, UniParc, interPro</xs:documentation>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="xs:token">
                                                  <xs:attribute name="type" use="required">
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:enumeration value="UNIPROTKB"/>
                                                  <xs:enumeration value="UNIPARC"/>
                                                  <xs:enumeration value="INTERPRO"/>
                                                  <xs:enumeration value="GO"/>
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                  </xs:attribute>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="ec_number">
                            <xs:annotation>
                                <xs:documentation>Enzyme classification. Format: "EC 3.4.11.4"</xs:documentation>
                            </xs:annotation>
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="EC \d+(\.\d+){3}"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="dna" substitutionGroup="macromolecule">
        <xs:annotation>
            <xs:documentation>Is naturalExpression and recombinantExpression suitable for this component?
</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element name="sequence">
                            <xs:annotation>
                                <xs:documentation/>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="string">
                                        <xs:annotation>
                                            <xs:documentation/>
                                        </xs:annotation>
                                        <xs:simpleType>
                                            <xs:restriction base="xs:token">
                                                <xs:pattern value="[ ACGTRYSWKMBDHVN\.-]+"/>
                                            </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="discrepancy_list">
                                        <xs:annotation>
                                            <xs:documentation/>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:sequence>
                                                <xs:element maxOccurs="unbounded" name="discrepancy">
                                                  <xs:annotation>
                                                  <xs:documentation>Format: A1C</xs:documentation>
                                                  </xs:annotation>
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:pattern
                                                  value="[AGCTRYSWKMBDHVN\.-]\d+[AGCTRYSWKMBDHVN\.-]"
                                                  />
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                </xs:element>
                                            </xs:sequence>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element maxOccurs="unbounded" minOccurs="0"
                                        name="external_references">
                                        <xs:annotation>
                                            <xs:documentation>RefSeq, genbank</xs:documentation>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="xs:token">
                                                  <xs:attribute name="type" use="required">
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:enumeration value="REFSEQ"/>
                                                  <xs:enumeration value="GENBANK"/>
                                                  <xs:whiteSpace value="collapse"/>
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                  </xs:attribute>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="classification">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="DNA"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="structure" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>Deprecated 2014/11/29
Only added for transfer of 1.9 </xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="synthetic_flag" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Deprecated 2014/11/29
Added only for transfer of 1.9 data</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="rna" substitutionGroup="macromolecule">
        <xs:annotation>
            <xs:documentation>Is naturalExpression and recombinantExpression suitable for this component?</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element name="sequence">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="string">
                                        <xs:annotation>
                                            <xs:documentation>What would be a proper format?</xs:documentation>
                                        </xs:annotation>
                                        <xs:simpleType>
                                            <xs:restriction base="xs:token">
                                                <xs:pattern value="[ ACGURYSWKMBDHVN\.-]+"/>
                                            </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="discrepancy_list">
                                        <xs:annotation>
                                            <xs:documentation/>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:sequence>
                                                <xs:element maxOccurs="unbounded" name="discrepancy">
                                                  <xs:annotation>
                                                  <xs:documentation>Format: A1C</xs:documentation>
                                                  </xs:annotation>
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:pattern
                                                  value="[AGCURYSWKMBDHVN\.-]\d+[AGCURYSWKMBDHVN\.-]"
                                                  />
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                </xs:element>
                                            </xs:sequence>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element maxOccurs="unbounded" minOccurs="0"
                                        name="external_references">
                                        <xs:annotation>
                                            <xs:documentation>RefSeq, Genbank should have their own validation</xs:documentation>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="xs:token">
                                                  <xs:attribute name="type">
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:enumeration value="REFSEQ"/>
                                                  <xs:enumeration value="GENBANK"/>
                                                  <xs:whiteSpace value="collapse"/>
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                  </xs:attribute>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="classification">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="MESSENGER"/>
                                    <xs:enumeration value="TRANSFER"/>
                                    <xs:enumeration value="RIBOSOMAL"/>
                                    <xs:enumeration value="NON-CODING"/>
                                    <xs:enumeration value="INTERFERENCE"/>
                                    <xs:enumeration value="SMALL INTERFERENCE"/>
                                    <xs:enumeration value="GENOMIC"/>
                                    <xs:enumeration value="PRE-MESSENGER"/>
                                    <xs:enumeration value="SMALL NUCLEOLAR"/>
                                    <xs:enumeration value="TRANSFER-MESSENGER"/>
                                    <xs:enumeration value="OTHER"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element name="structure" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>Deprecated 2014/11/29
Only added for transfer of 1.9 </xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="synthetic_flag" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Deprecated 2014/11/29
Added only for transfer of 1.9 data</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="saccharide" substitutionGroup="macromolecule">
        <xs:annotation>
            <xs:documentation>Is naturalExpression and recombinantExpression suitable for this component?</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element name="enantiomer">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:enumeration value="LEVO"/>
                                    <xs:enumeration value="DEXTRO"/>
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element minOccurs="0" name="formula">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="([\[\]\(\)]*[A-Z][a-z]?[\+\-\d/\[\]\(\)]*)+"
                                    />
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="external_references">
                            <xs:annotation>
                                <xs:documentation>CardBank</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:token">
                                        <xs:attribute name="type">
                                            <xs:simpleType>
                                                <xs:restriction base="xs:token">
                                                  <xs:enumeration value="CARDBANK"/>
                                                  <xs:whiteSpace value="collapse"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="lipid" substitutionGroup="macromolecule">
        <xs:annotation>
            <xs:documentation>Is naturalExpression and recombinantExpression suitable for this component?
</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element minOccurs="0" name="formula">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="([\[\]\(\)]*[A-Z][a-z]?[\+\-\d/\[\]\(\)]*)+"
                                    />
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="external_references">
                            <xs:annotation>
                                <xs:documentation>LMSD (Lipidomics database)</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:token">
                                        <xs:attribute name="type">
                                            <xs:simpleType>
                                                <xs:restriction base="xs:token">
                                                  <xs:enumeration value="LMSD"/>
                                                  <xs:whiteSpace value="collapse"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="ligand" substitutionGroup="macromolecule">
        <xs:annotation>
            <xs:documentation>Is naturalExpression and recombinantExpression suitable for this component?
</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element minOccurs="0" name="formula">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="([\[\]\(\)]*[A-Z][a-z]?[\+\-\d/\[\]\(\)]*)+"
                                    />
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                        <xs:element maxOccurs="unbounded" minOccurs="0" name="external_references">
                            <xs:annotation>
                                <xs:documentation>CAS, PubChem, DrugBank, ChEBI, ChEMBL</xs:documentation>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:simpleContent>
                                    <xs:extension base="xs:token">
                                        <xs:attribute name="type">
                                            <xs:simpleType>
                                                <xs:restriction base="xs:token">
                                                  <xs:enumeration value="CAS"/>
                                                  <xs:whiteSpace value="collapse"/>
                                                  <xs:enumeration value="PUBCHEM"/>
                                                  <xs:enumeration value="DRUGBANK"/>
                                                  <xs:enumeration value="CHEBI"/>
                                                  <xs:enumeration value="CHEMBL"/>
                                                </xs:restriction>
                                            </xs:simpleType>
                                        </xs:attribute>
                                    </xs:extension>
                                </xs:simpleContent>
                            </xs:complexType>
                        </xs:element>
                        <xs:element minOccurs="0" name="natural_source" type="natural_source_type"/>
                        <xs:element minOccurs="0" name="recombinant_expression"
                            type="recombinant_source_type"> </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:element name="em_label" substitutionGroup="macromolecule">
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element minOccurs="0" name="formula">
                            <xs:simpleType>
                                <xs:restriction base="xs:token">
                                    <xs:pattern value="([\[\]\(\)]*[A-Z][a-z]?[\+\-\d/\[\]\(\)]*)+"
                                    />
                                </xs:restriction>
                            </xs:simpleType>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:simpleType name="pos_int_or_string_type">
        <xs:union memberTypes="xs:positiveInteger xs:string"> </xs:union>
    </xs:simpleType>
    <xs:complexType name="map_statistics_type">
        <xs:sequence>
            <xs:element name="minimum" type="xs:float"/>
            <xs:element name="maximum" type="xs:float"/>
            <xs:element name="average" type="xs:float"/>
            <xs:element name="std" type="xs:float"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="pixel_spacing_type">
        <xs:simpleContent>
            <xs:extension base="allowed_pixel_sampling">
                <xs:attribute fixed="Å" name="units" type="xs:token" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="fiducial_marker_type">
        <xs:sequence>
            <xs:element minOccurs="0" name="fiducial_type" type="xs:token"/>
            <xs:element name="manufacturer" type="xs:token">
                <xs:annotation>
                    <xs:documentation>Controlled vocabulary?</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="diameter" type="fiducial_marker_diameter_type"> </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ultramicrotomy_final_thickness_type">
        <xs:simpleContent>
            <xs:extension base="allowed_microtome_thickness">
                <xs:attribute default="nm" name="units" type="xs:token"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="fib_voltage_type">
        <xs:simpleContent>
            <xs:extension base="allowed_focus_ion_voltage">
                <xs:attribute name="units" fixed="kV"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="fib_current_type">
        <xs:simpleContent>
            <xs:extension base="allowed_focus_ion_current">
                <xs:attribute name="units" fixed="pA"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="fib_dose_rate_type">
        <xs:simpleContent>
            <xs:extension base="allowed_focus_ion_dose_rate">
                <xs:attribute default="ions/nm^2/s" name="units" type="xs:token"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="fib_duration_type">
        <xs:simpleContent>
            <xs:extension base="xs:positiveInteger">
                <xs:attribute name="units" fixed="s" type="xs:token"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="fib_initial_thickness_type">
        <xs:simpleContent>
            <xs:extension base="allowed_focus_ion_initial_thickness">
                <xs:attribute default="nm" name="units" type="xs:token"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="fib_final_thickness_type">
        <xs:simpleContent>
            <xs:extension base="allowed_focus_ion_final_thickness">
                <xs:attribute default="nm" name="units" type="xs:token"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="crystal_formation_temperature_type">
        <xs:simpleContent>
            <xs:extension base="allowed_crystal_formation_temperature_type">
                <xs:attribute fixed="K" name="units" type="xs:token" use="required"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="crystal_formation_time_type">
        <xs:simpleContent>
            <xs:extension base="non_zero_float">
                <xs:attribute name="units" use="required">
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:enumeration value="MINUTE"/>
                            <xs:enumeration value="HOUR"/>
                            <xs:enumeration value="DAY"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:attribute>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    <xs:complexType name="subtomogram_reconstruction_type">
        <xs:sequence>
            <xs:element name="number_subtomograms_used" minOccurs="0" type="xs:positiveInteger">
                <xs:annotation>
                    <xs:documentation>Number of 2D images used in making the 3D reconstruction</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="applied_symmetry" type="applied_symmetry_type">
                <xs:annotation>
                    <xs:documentation>Only one symmetry element per processing type. Use additional processing type elements, and specify the sample components for each if more that one symmetry has been applied.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element minOccurs="0" name="number_classes_used" type="xs:positiveInteger"/>
            <xs:element name="algorithm" minOccurs="0" type="reconstruction_algorithm_type">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
            </xs:element>
            <xs:element name="resolution">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="resolution_type">
                            <xs:attribute fixed="Å" name="units" type="xs:token" use="required"/>
                            <xs:attribute name="type" use="required">
                                <xs:simpleType>
                                    <xs:restriction base="xs:token">
                                        <xs:enumeration value="BY AUTHOR"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:attribute>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="resolution_method">
                <xs:simpleType>
                    <xs:restriction base="xs:token">
                        <xs:enumeration value="FSC 0.5 CUT-OFF"/>
                        <xs:enumeration value="FSC 0.33 CUT-OFF"/>
                        <xs:enumeration value="FSC 0.143 CUT-OFF"/>
                        <xs:enumeration value="3σ"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element minOccurs="0" name="reconstruction_filtering"
                type="reconstruction_filtering_type">
                <xs:annotation>
                    <xs:documentation>Contour, mask dilation filtering.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="software_list" type="software_list_type"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:element name="other_macromolecule" substitutionGroup="macromolecule">
        <xs:annotation>
            <xs:documentation>Use to cater for cyclic-pseudo-peptide, other, peptide nucleic acid and polydeoxyribonucleotide/polyribonucleotide hybrid categories. Most items are optional and there is no checking done</xs:documentation>
        </xs:annotation>
        <xs:complexType>
            <xs:complexContent>
                <xs:extension base="base_macromolecule_type">
                    <xs:sequence>
                        <xs:element name="sequence" minOccurs="0">
                            <xs:annotation>
                                <xs:documentation/>
                            </xs:annotation>
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="string">
                                        <xs:annotation>
                                            <xs:documentation/>
                                        </xs:annotation>
                                        <xs:simpleType>
                                            <xs:restriction base="xs:token"> </xs:restriction>
                                        </xs:simpleType>
                                    </xs:element>
                                    <xs:element minOccurs="0" name="discrepancy_list">
                                        <xs:annotation>
                                            <xs:documentation/>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:sequence>
                                                <xs:element maxOccurs="unbounded" name="discrepancy">
                                                  <xs:annotation>
                                                  <xs:documentation>Format: A1C</xs:documentation>
                                                  </xs:annotation>
                                                  <xs:simpleType>
                                                  <xs:restriction base="xs:token">
                                                  <xs:pattern
                                                  value="[AGCTRYSWKMBDHVN\.-]\d+[AGCTRYSWKMBDHVN\.-]"
                                                  />
                                                  </xs:restriction>
                                                  </xs:simpleType>
                                                </xs:element>
                                            </xs:sequence>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element maxOccurs="unbounded" minOccurs="0"
                                        name="external_references">
                                        <xs:annotation>
                                            <xs:documentation>RefSeq, genbank</xs:documentation>
                                        </xs:annotation>
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="xs:token">
                                                  <xs:attribute name="type" use="required"
                                                  type="xs:token"> </xs:attribute>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                </xs:sequence>
                            </xs:complexType>
                        </xs:element>
                        <xs:element name="classification" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>For now: cyclic-pseudo-peptide, other, peptide nucleic acid and polydeoxyribonucleotide/polyribonucleotide hybrid categories</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element minOccurs="0" name="recombinant_expression"
                            type="recombinant_source_type"> </xs:element>
                        <xs:element name="structure" type="xs:token">
                            <xs:annotation>
                                <xs:documentation>Deprecated 2015/11/16
Only added for transfer of 1.9 </xs:documentation>
                            </xs:annotation>
                        </xs:element>
                        <xs:element name="synthetic_flag" type="xs:boolean">
                            <xs:annotation>
                                <xs:documentation>Deprecated 2015/11/16
Added only for transfer of 1.9 data</xs:documentation>
                            </xs:annotation>
                        </xs:element>
                    </xs:sequence>
                </xs:extension>
            </xs:complexContent>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="unit_cell_type">
        <xs:sequence>
            <xs:element name="a" type="cell_type">
                <xs:annotation>
                    <xs:documentation>vertical</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="b" type="cell_type">
                <xs:annotation>
                    <xs:documentation>horizontal</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="c" type="cell_type">
                <xs:annotation>
                    <xs:documentation>
</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="c_sampling_length" type="cell_type">
                <xs:annotation>
                    <xs:documentation>Length used to sample the reciprocal lattice lines in
the c-direction.</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="gamma" type="cell_angle_type">
                <xs:annotation>
                    <xs:documentation>180 &gt;= gamma &gt;= 90</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="alpha" type="cell_angle_type">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
            </xs:element>
            <xs:element name="beta" type="cell_angle_type">
                <xs:annotation>
                    <xs:documentation/>
                </xs:annotation>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="crystal_parameters_type">
        <xs:sequence>
            <xs:element name="unit_cell" type="unit_cell_type"> </xs:element>
            <xs:choice>
                <xs:element name="plane_group">
                    <xs:annotation>
                        <xs:documentation>17 groups</xs:documentation>
                    </xs:annotation>
                    <xs:simpleType>
                        <xs:restriction base="xs:token">
                            <xs:enumeration value="P 1"/>
                            <xs:enumeration value="P 2"/>
                            <xs:enumeration value="P 1 2"/>
                            <xs:enumeration value="P 1 21"/>
                            <xs:enumeration value="C 1 2"/>
                            <xs:enumeration value="P 2 2 2"/>
                            <xs:enumeration value="P 2 2 21"/>
                            <xs:enumeration value="P2 21 21"/>
                            <xs:enumeration value="C 2 2 2"/>
                            <xs:enumeration value="P 4"/>
                            <xs:enumeration value="P 4 2 2"/>
                            <xs:enumeration value="P 4 21 2"/>
                            <xs:enumeration value="P 3"/>
                            <xs:enumeration value="P 3 1 2"/>
                            <xs:enumeration value="P 3 2 1"/>
                            <xs:enumeration value="P 6"/>
                            <xs:enumeration value="P 6  2 2"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element name="space_group" type="xs:token">
                    <xs:annotation>
                        <xs:documentation/>
                    </xs:annotation>
                </xs:element>
            </xs:choice>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="crystallography_statistics_type">
        <xs:sequence>
            <xs:element name="number_intensities_measured" type="xs:positiveInteger"/>
            <xs:element name="number_structure_factors" type="xs:positiveInteger"/>
            <xs:element name="fourier_space_coverage" type="xs:float">
                <xs:annotation>
                    <xs:documentation>datatype: fraction</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="r_sym" type="xs:float"/>
            <xs:element name="r_merge" type="xs:float"/>
            <xs:element name="overall_phase_error" type="xs:float"/>
            <xs:element name="overall_phase_residual" type="xs:float"/>
            <xs:element name="phase_error_rejection_criteria" type="xs:float"/>
            <xs:element name="high_resolution">
                <xs:complexType>
                    <xs:simpleContent>
                        <xs:extension base="resolution_type">
                            <xs:attribute fixed="Å" name="units" type="xs:token" use="required"/>
                        </xs:extension>
                    </xs:simpleContent>
                </xs:complexType>
            </xs:element>
            <xs:element name="shell_list">
                <xs:complexType>
                    <xs:sequence>
                        <xs:element maxOccurs="unbounded" name="shell">
                            <xs:complexType>
                                <xs:sequence>
                                    <xs:element name="high_resolution">
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="resolution_type">
                                                  <xs:attribute fixed="Å" name="units"
                                                  type="xs:token" use="required"/>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element name="low_resolution">
                                        <xs:complexType>
                                            <xs:simpleContent>
                                                <xs:extension base="resolution_type">
                                                  <xs:attribute fixed="Å" name="units"
                                                  type="xs:token" use="required"/>
                                                </xs:extension>
                                            </xs:simpleContent>
                                        </xs:complexType>
                                    </xs:element>
                                    <xs:element name="number_structure_factors"
                                        type="xs:positiveInteger"/>
                                    <xs:element name="phase_residual" type="xs:float"/>
                                    <xs:element name="fourier_space_coverage" type="xs:float">
                                        <xs:annotation>
                                            <xs:documentation>datatype: fraction</xs:documentation>
                                        </xs:annotation>
                                    </xs:element>
                                    <xs:element name="multiplicity" type="xs:float"/>
                                </xs:sequence>
                                <xs:attribute name="id" type="xs:positiveInteger"/>
                            </xs:complexType>
                        </xs:element>
                    </xs:sequence>
                </xs:complexType>
            </xs:element>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="classification_type">
        <xs:sequence>
            <xs:element name="number_classes" type="xs:positiveInteger">
                <xs:annotation>
                    <xs:documentation>Final number of classes used</xs:documentation>
                </xs:annotation>
            </xs:element>
            <xs:element name="average_number_members_per_class">
                <xs:annotation>
                    <xs:documentation>Average number of members (images, 3D volumes or subtomograms) per class in the final set of class averages</xs:documentation>
                </xs:annotation>
                <xs:simpleType>
                    <xs:restriction base="xs:float">
                        <xs:minExclusive value="0"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <xs:element name="software_list" type="software_list_type" minOccurs="0"/>
            <xs:element name="details" type="xs:string" minOccurs="0"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="fiducial_marker_diameter_type">
        <xs:simpleContent>
            <xs:extension base="allowed_diameter_colloidal_gold">
                <xs:attribute fixed="nanometer" name="units" use="required" type="xs:token"/>
            </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
</xs:schema>
