psi

package
v0.0.0-...-8c2d65e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 21, 2024 License: GPL-3.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Activation 

type Activation struct {
	XMLName xml.Name  `xml:"activation"`
	CVParam []CVParam `xml:"cvParam"`
}

Activation tag

type AdditionalSearchParams 

type AdditionalSearchParams struct {
	XMLName   xml.Name    `xml:"AdditionalSearchParams"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

AdditionalSearchParams is the search parameters other than the modifications searched

type Affiliation 

type Affiliation struct {
	XMLName         xml.Name `xml:"Affiliation"`
	OrganizationRef string   `xml:"organization_ref,attr,omitempty"`
}

Affiliation is the organization a person belongs to

type AmbiguousResidue 

type AmbiguousResidue struct {
	XMLName   xml.Name    `xml:"AmbiguousResidue"`
	Code      string      `xml:"code,attr,omitempty"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

AmbiguousResidue is the specification of a single residue within the mass table

type AnalysisCollection 

type AnalysisCollection struct {
	XMLName                xml.Name                 `xml:"AnalysisCollection"`
	SpectrumIdentification []SpectrumIdentification `xml:"SpectrumIdentification"`
	ProteinDetection       ProteinDetection         `xml:"ProteinDetection"`
}

AnalysisCollection is the analyses performed to get the results, which map the input and output data sets. Analyses are for example: SpectrumIdentification (resulting in peptides) or ProteinDetection (assemble proteins from peptides)

type AnalysisData 

type AnalysisData struct {
	XMLName                    xml.Name                     `xml:"AnalysisData"`
	SpectrumIdentificationList []SpectrumIdentificationList `xml:"SpectrumIdentificationList"`
	ProteinDetectionList       ProteinDetectionList         `xml:"ProteinDetectionList"`
}

AnalysisData are sets generated by the analyses, including peptide and protein lists

type AnalysisParams 

type AnalysisParams struct {
	XMLName   xml.Name    `xml:"AnalysisParams"`
	CVParam   CVParam     `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

AnalysisParams is the parameters and settings for the protein detection given as CV terms

type AnalysisProtocolCollection 

type AnalysisProtocolCollection struct {
	XMLName                        xml.Name                         `xml:"AnalysisProtocolCollection"`
	SpectrumIdentificationProtocol []SpectrumIdentificationProtocol `xml:"SpectrumIdentificationProtocol"`
	ProteinDetectionProtocol       ProteinDetectionProtocol         `xml:"ProteinDetectionProtocol"`
}

AnalysisProtocolCollection is the collection of protocols which include the parameters and settings of the performed analyses

type AnalysisSampleCollection 

type AnalysisSampleCollection struct {
	XMLName xml.Name `xml:"AnalysisSampleCollection"`
	Sample  []Sample `xml:"Sample"`
}

AnalysisSampleCollection is the samples analysed can optionally be recorded using CV terms for descriptions. If a composite sample has been analysed, the subsample association can be used to build a hierarchical description

type AnalysisSoftware 

type AnalysisSoftware struct {
	XMLName        xml.Name       `xml:"AnalysisSoftware"`
	ID             string         `xml:"id,attr,omitempty"`
	Name           string         `xml:"name,attr,omitempty"`
	URI            string         `xml:"uri,attr,omitempty"`
	Version        string         `xml:"version,attr,omitempty"`
	ContactRole    ContactRole    `xml:"ContactRole"`
	SoftwareName   SoftwareName   `xml:"SoftwareName"`
	Customizations Customizations `xml:"Customizations"`
}

AnalysisSoftware is the software used for performing the analysis

type AnalysisSoftwareList 

type AnalysisSoftwareList struct {
	XMLName          xml.Name           `xml:"AnalysisSoftwareList"`
	AnalysisSoftware []AnalysisSoftware `xml:"AnalysisSoftware"`
}

AnalysisSoftwareList is the software packages used to perform the analyses

type Analyzer 

type Analyzer struct {
	XMLName                    xml.Name                     `xml:"analyzer"`
	Order                      int                          `xml:"order,attr,omitempty"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

Analyzer is a analyzer component

type AuditCollection 

type AuditCollection struct {
	XMLName      xml.Name     `xml:"AuditCollection"`
	Person       Person       `xml:"Person"`
	Organization Organization `xml:"Organization"`
}

AuditCollection is the complete set of Contacts (people and organisations) for this file

type BibliographicReference 

type BibliographicReference struct {
	XMLName     xml.Name `xml:"BibliographicReference"`
	Authors     string   `xml:"authors,attr,omitempty"`
	DOI         string   `xml:"doi,attr,omitempty"`
	Editor      string   `xml:"editor,attr,omitempty"`
	ID          string   `xml:"id,attr,omitempty"`
	Issue       string   `xml:"issue,attr,omitempty"`
	Name        string   `xml:"name,attr,omitempty"`
	Pages       string   `xml:"pages,attr,omitempty"`
	Publication string   `xml:"publication,attr,omitempty"`
	Publisher   string   `xml:"publisher,attr,omitempty"`
	Title       string   `xml:"title,attr,omitempty"`
	Volume      string   `xml:"volume,attr,omitempty"`
	Year        string   `xml:"year,attr,omitempty"`
}

BibliographicReference is any bibliographic references associated with the file

type Binary 

type Binary struct {
	XMLName xml.Name `xml:"binary"`
	Value   []byte   `xml:",chardata"`
}

Binary tag

type BinaryDataArray 

type BinaryDataArray struct {
	XMLName       xml.Name  `xml:"binaryDataArray"`
	EncodedLength float64   `xml:"encodedLength,attr"`
	CVParam       []CVParam `xml:"cvParam"`
	Binary        Binary    `xml:"binary"`
}

BinaryDataArray tag

type BinaryDataArrayList 

type BinaryDataArrayList struct {
	XMLName         xml.Name          `xml:"binaryDataArrayList"`
	Count           int               `xml:"count,attr"`
	BinaryDataArray []BinaryDataArray `xml:"binaryDataArray"`
}

BinaryDataArrayList tag

type CV 

type CV struct {
	XMLName  xml.Name `xml:"cv"`
	ID       string   `xml:"id,attr,omitempty"`
	Version  string   `xml:"version,attr,omitempty"`
	URI      string   `xml:"URI,attr,omitempty"`
	FullName string   `xml:"fullName,attr,omitempty"`
}

CV is a ource controlled vocabulary from which cvParams will be obtained

type CVParam 

type CVParam struct {
	XMLName       xml.Name `xml:"cvParam"`
	Accession     string   `xml:"accession,attr"`
	CVRef         string   `xml:"cvRef,attr,omitempty"`
	Name          string   `xml:"name,attr"`
	UnitAccession string   `xml:"unitAccession,attr,omitempty"`
	UnitCvRef     string   `xml:"unitCvRef,attr,omitempty"`
	UnitName      string   `xml:"unitName,attr,omitempty"`
	Value         string   `xml:"value,attr,omitempty"`
}

CVParam is single entry from an ontology or a controlled vocabulary

type Chromatogram 

type Chromatogram struct {
	XMLName             xml.Name            `xml:"chromatogram"`
	Index               int                 `xml:"index,attr"`
	ID                  string              `xml:"id,attr"`
	DefaultArrayLength  float64             `xml:"defaultArrayLength,attr"`
	CVParam             []CVParam           `xml:"cvParam"`
	UserParam           []UserParam         `xml:"userParam"`
	Precursor           Precursor           `xml:"precursor"`
	Product             Product             `xml:"product"`
	BinaryDataArrayList BinaryDataArrayList `xml:"binaryDataArrayList"`
}

Chromatogram tag

type ChromatogramList 

type ChromatogramList struct {
	XMLName                  xml.Name       `xml:"chromatogramList"`
	Count                    int            `xml:"count,attr"`
	DefaultDataProcessingRef string         `xml:"defaultDataProcessingRef,attr"`
	Chromatogram             []Chromatogram `xml:"chromatogram"`
}

ChromatogramList tag

type ComponentList 

type ComponentList struct {
	XMLName  xml.Name `xml:"componentList"`
	Count    int      `xml:"count,attr,omitempty"`
	Source   Source   `xml:"source"`
	Analyzer Analyzer `xml:"analyzer"`
	Detector Detector `xml:"detector"`
}

ComponentList is a list with the different components used in the mass spectrometer. At least one source, one mass analyzer and one detector need to be specified

type ContactRole 

type ContactRole struct {
	XMLName    xml.Name `xml:"ContactRole"`
	ContactRef string   `xml:"contact_ref,attr,omitempty"`
	Role       Role     `xml:"Role"`
}

ContactRole is the Contact that provided the document instance

type Customizations 

type Customizations struct {
	XMLName xml.Name `xml:"Customizations"`
	Value   string   `xml:",chardata"`
}

Customizations is Any customizations to the software, such as alternative scoring mechanisms implemented, should be documented here as free text

type CvList 

type CvList struct {
	XMLName xml.Name `xml:"cvList"`
	Count   int      `xml:"count,attr,omitempty"`
	CV      []CV     `xml:"cv"`
}

CvList is the container for one or more controlled vocabulary definitions

type DBSequence 

type DBSequence struct {
	XMLName           xml.Name    `xml:"DBSequence"`
	Accession         string      `xml:"accession,attr,omitempty"`
	ID                string      `xml:"id,attr,omitempty"`
	Length            string      `xml:"length,attr,omitempty"`
	Name              string      `xml:"name,attr,omitempty"`
	SearchDatabaseRef string      `xml:"searchDatabase_ref,attr,omitempty"`
	Seq               Seq         `xml:"Seq"`
	CVParam           []CVParam   `xml:"cvParam"`
	UserParam         []UserParam `xml:"userParam"`
}

DBSequence is a database sequence from the specified SearchDatabase (nucleic acid or amino acid). If the sequence is nucleic acid, the source nucleic acid sequence should be given in the seq attribute rather than a translated sequence

type DataCollection 

type DataCollection struct {
	XMLName      xml.Name     `xml:"DataCollection"`
	Inputs       Inputs       `xml:"Inputs"`
	AnalysisData AnalysisData `xml:"AnalysisData"`
}

DataCollection is the collection of input and output data sets of the analyses

type DataFormat 

type DataFormat interface {
	Parse()
}

DataFormat defines different data type from PSI

type DataProcessing 

type DataProcessing struct {
	XMLName          xml.Name           `xml:"dataProcessing"`
	ID               string             `xml:"id,attr,omitempty"`
	ProcessingMethod []ProcessingMethod `xml:"processingMethod"`
}

DataProcessing is a description of the way in which a particular software was used

type DataProcessingList 

type DataProcessingList struct {
	XMLName        xml.Name         `xml:"dataProcessingList"`
	Count          int              `xml:"count,attr,omitempty"`
	DataProcessing []DataProcessing `xml:"dataProcessing"`
}

DataProcessingList is a list and descriptions of data processing applied to this data

type DatabaseFilters 

type DatabaseFilters struct {
	XMLName xml.Name `xml:"DatabaseFilters"`
	Filter  []Filter `xml:"Filter"`
}

DatabaseFilters is the specification of filters applied to the database searched

type DatabaseName 

type DatabaseName struct {
	XMLName   xml.Name  `xml:"DatabaseName"`
	CVParam   CVParam   `xml:"cvParam"`
	UserParam UserParam `xml:"userParam"`
}

DatabaseName is the database name may be given as a cvParam if it maps exactly to one of the release databases listed in the CV, otherwise a userParam should be used

type DatabaseTranslation 

type DatabaseTranslation struct {
	XMLName          xml.Name           `xml:"DatabaseTranslation"`
	Frames           string             `xml:"frames,attr,omitempty"`
	TranslationTable []TranslationTable `xml:"TranslationTable"`
}

DatabaseTranslation is a specification of how a nucleic acid sequence database was translated for searching

type Detector 

type Detector struct {
	XMLName                    xml.Name                     `xml:"detector"`
	Order                      int                          `xml:"order,attr,omitempty"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

Detector is a detector component

type Enzyme 

type Enzyme struct {
	XMLName         xml.Name   `xml:"Enzyme"`
	CTermGain       string     `xml:"cTermGain,attr,omitempty"`
	ID              string     `xml:"id,attr,omitempty"`
	MinDistance     int        `xml:"minDistance,attr,omitempty"`
	MissedCleavages int        `xml:"missedCleavages,attr,omitempty"`
	NTermGain       string     `xml:"nTermGain,attr,omitempty"`
	Name            string     `xml:"name,attr,omitempty"`
	SemiSpecific    bool       `xml:"semiSpecific,attr,omitempty"`
	SiteRegexp      SiteRegexp `xml:"SiteRegexp"`
	EnzymeName      EnzymeName `xml:"EnzymeName"`
}

Enzyme is the details of an individual cleavage enzyme should be provided by giving a regular expression or a CV term if a "standard" enzyme cleavage has been performed

type EnzymeName 

type EnzymeName struct {
	XMLName   xml.Name    `xml:"EnzymeName"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

EnzymeName is the name of the enzyme from a CV

type Enzymes 

type Enzymes struct {
	XMLName     xml.Name `xml:"Enzymes"`
	Independent bool     `xml:"independent,attr,omitempty"`
	Enzyme      []Enzyme `xml:"Enzyme"`
}

Enzymes is the list of enzymes used in experiment

type Exclude 

type Exclude struct {
	XMLName   xml.Name    `xml:"Exclude"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

Exclude all sequences fulfilling the specified criteria are excluded

type ExternalFormatDocumentation 

type ExternalFormatDocumentation struct {
	XMLName xml.Name `xml:"ExternalFormatDocumentation"`
	Value   []byte   `xml:",chardata"`
}

ExternalFormatDocumentation is a URI to access documentation and tools to interpret the external format of the ExternalData instance. For example, XML Schema or static libraries (APIs) to access binary formats

type FileContent 

type FileContent struct {
	XMLName                    xml.Name                     `xml:"fileContent"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

FileContent tag

type FileDescription 

type FileDescription struct {
	XMLName        xml.Name       `xml:"fileDescription"`
	FileContent    FileContent    `xml:"fileContent"`
	SourceFileList SourceFileList `xml:"sourceFileList"`
}

FileDescription contains the information pertaining to the entire mzML file (i.e. not specific to any part of the data set) is stored here

type FileFormat 

type FileFormat struct {
	XMLName xml.Name `xml:"FileFormat"`
	CVParam CVParam  `xml:"cvParam"`
}

FileFormat is the format of the ExternalData file, for example "tiff" for image files.

type Filter 

type Filter struct {
	XMLName    xml.Name   `xml:"Filter"`
	FilterType FilterType `xml:"FilterType"`
	Include    Include    `xml:"Include"`
	Exclude    Exclude    `xml:"Exclude"`
}

Filter applied to the search database. The filter MUST include at least one of Include and Exclude. If both are used, it is assumed that inclusion is performed first.

type FilterType 

type FilterType struct {
	XMLName   xml.Name    `xml:"FilterType"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

FilterType is the type of filter e.g. database taxonomy filter, pi filter, mw filter

type FragmentArray 

type FragmentArray struct {
	XMLName    xml.Name `xml:"FragmentArray"`
	MeasureRef string   `xml:"measure_ref,attr,omitempty"`
	Values     []string `xml:"values,attr,omitempty"`
}

FragmentArray is an array of values for a given type of measure and for a particular ion type, in parallel to the index of ions identified

type FragmentTolerance 

type FragmentTolerance struct {
	XMLName xml.Name  `xml:"FragmentTolerance"`
	CVParam []CVParam `xml:"cvParam"`
}

FragmentTolerance is the tolerance of the search given as a plus and minus value with units

type Fragmentation 

type Fragmentation struct {
	XMLName xml.Name  `xml:"Fragmentation"`
	IonType []IonType `xml:"IonType"`
}

Fragmentation is the product ions identified in this result

type FragmentationTable 

type FragmentationTable struct {
	XMLName xml.Name  `xml:"FragmentationTable"`
	Measure []Measure `xml:"Measure"`
}

FragmentationTable is the the types of measures that will be reported in generic arrays for each SpectrumIdentificationItem e.g. product ion m/z, product ion intensity, product ion m/z error

type Include 

type Include struct {
	XMLName   xml.Name    `xml:"Include"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

Include is all sequences fulfilling the specified criteria are included

type IndexedMzML 

type IndexedMzML struct {
	XMLName xml.Name `xml:"indexedmzML"`
	Name    string
	MzML    MzML `xml:"mzML"`
}

IndexedMzML is the root level tag

func (*IndexedMzML) Parse 

func (p *IndexedMzML) Parse(f string)

Parse is the main function for parsing IndexedMzML data

type InputSpectra 

type InputSpectra struct {
	XMLName        xml.Name `xml:"InputSpectra"`
	SpectraDataRef string   `xml:"spectraData_ref,attr,omitempty"`
}

InputSpectra is one of the spectra data sets used

type InputSpectrumIdentifications 

type InputSpectrumIdentifications struct {
	XMLName                       xml.Name `xml:"InputSpectrumIdentifications"`
	SpectrumIdentificationListRef string   `xml:"spectrumIdentificationList_ref,attr,omitempty"`
}

InputSpectrumIdentifications is the lists of spectrum identifications that are input to the protein detection process

type Inputs 

type Inputs struct {
	XMLName        xml.Name         `xml:"Inputs"`
	SourceFile     []SourceFile     `xml:"SourceFile"`
	SearchDatabase []SearchDatabase `xml:"SearchDatabase"`
	SpectraData    []SpectraData    `xml:"SpectraData"`
}

Inputs is the inputs to the analyses including the databases searched, the spectral data and the source file converted to mzIdentML

type InstrumentConfiguration 

type InstrumentConfiguration struct {
	XMLName                    xml.Name                     `xml:"instrumentConfiguration"`
	ID                         string                       `xml:"id,attr,omitempty"`
	ScanSettingsRef            string                       `xml:"scanSettingsRef,attr,omitempty"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
	ComponentList              ComponentList                `xml:"componentList"`
	SoftwareRef                SoftwareRef                  `xml:"softwareRef"`
}

InstrumentConfiguration tag

type InstrumentConfigurationList 

type InstrumentConfigurationList struct {
	XMLName                 xml.Name                  `xml:"instrumentConfigurationList"`
	Count                   int                       `xml:"count,attr"`
	InstrumentConfiguration []InstrumentConfiguration `xml:"instrumentConfiguration"`
}

InstrumentConfigurationList is a list and descriptions of instrument configurations. At least one instrument configuration MUST be specified, even if it is only to specify that the instrument is unknown. In that case, the "instrument model" term is used to indicate the unknown instrument in the instrumentConfiguration

type IonType 

type IonType struct {
	XMLName       xml.Name        `xml:"IonType"`
	Charge        int             `xml:"charge,attr,omitempty"`
	Index         []string        `xml:"index,attr,omitempty"`
	FragmentArray []FragmentArray `xml:"FragmentArray"`
	CVParam       []CVParam       `xml:"cvParam"`
	UserParam     []UserParam     `xml:"userParam"`
}

IonType defines the index of fragmentation ions being reported, importing a CV term for the Type of ion e.g. b ion. Example: if b3 b7 b8 and b10 have been identified, the index attribute will contain 3 7 8 10, and the corresponding values will be reported in parallel arrays below

type IsolationWindow 

type IsolationWindow struct {
	InstConfigurationRef string      `xml:"isolationWindow,attr"`
	CVParam              []CVParam   `xml:"cvParam"`
	UserParam            []UserParam `xml:"userParam"`
}

IsolationWindow tag

type MassTable 

type MassTable struct {
	XMLName          xml.Name           `xml:"MassTable"`
	ID               string             `xml:"id,attr,omitempty"`
	MSLevel          []int              `xml:"msLevel,attr,omitempty"`
	Name             string             `xml:"Name,attr,omitempty"`
	Residue          []Residue          `xml:"Residue"`
	AmbiguousResidue []AmbiguousResidue `xml:"AmbiguousResidue"`
	CVParam          []CVParam          `xml:"cvParam"`
	UserParam        []UserParam        `xml:"userParam"`
}

MassTable is the masses of residues used in the search

type Measure 

type Measure struct {
	XMLName xml.Name  `xml:"Measure"`
	ID      string    `xml:"id,attr,omitempty"`
	Name    string    `xml:"name,attr,omitempty"`
	CVParam []CVParam `xml:"cvParam"`
}

Measure references to CV terms defining the measures about product ions to be reported in SpectrumIdentificationItem

type Modification 

type Modification struct {
	XMLName               xml.Name  `xml:"Modification"`
	AvgMassDelta          float64   `xml:"avgMassDelta,attr,omitempty"`
	MonoIsotopicMassDelta float64   `xml:"monoisotopicMassDelta,attr,omitempty"`
	Location              string    `xml:"location,attr,omitempty"`
	Residues              string    `xml:"residues,attr,omitempty"`
	CVParam               []CVParam `xml:"cvParam"`
}

Modification is a molecule modification specification. If n modifications have been found on a peptide, there should be n instances of Modification. If multiple modifications are provided as cvParams, it is assumed that the modification is ambiguous i.e. one modification or another. A cvParam MUST be provided with the identification of the modification sourced from a suitable CV e.g. UNIMOD. If the modification is not present in the CV (and this will be checked by the semantic validator within a given tolerance window), there is a “unknown modification� CV term that MUST be used instead. A neutral loss should be defined as an additional CVParam within Modification. If more complex information should be given about neutral losses (such as presence/absence on particular product ions), this can additionally be encoded within the FragmentationArray

type ModificationParams 

type ModificationParams struct {
	XMLName            xml.Name             `xml:"ModificationParams"`
	SearchModification []SearchModification `xml:"SearchModification"`
}

ModificationParams is the specification of static/variable modifications (e.g. Oxidation of Methionine) that are to be considered in the spectra search

type MzIdentML 

type MzIdentML struct {
	XMLName                    xml.Name                   `xml:"MzIdentML"`
	CreationDate               string                     `xml:"creationDate,attr,omitempty"`
	Name                       string                     `xml:"name,attr,omitempty"`
	ID                         string                     `xml:"id,attr,omitempty"`
	Version                    string                     `xml:"version,attr,omitempty"`
	Xmlns                      string                     `xml:"xmlns,attr"`
	XmlnsXsi                   string                     `xml:"xmlns:xsi,attr"`
	XsiSchemaLocation          string                     `xml:"xsi:schemaLocation,attr"`
	CvList                     CvList                     `xml:"cvList"`
	AnalysisSoftwareList       AnalysisSoftwareList       `xml:"AnalysisSoftwareList"`
	Provider                   Provider                   `xml:"Provider"`
	AuditCollection            AuditCollection            `xml:"AuditCollection"`
	AnalysisSampleCollection   AnalysisSampleCollection   `xml:"AnalysisSampleCollection"`
	SequenceCollection         SequenceCollection         `xml:"SequenceCollection"`
	AnalysisCollection         AnalysisCollection         `xml:"AnalysisCollection"`
	AnalysisProtocolCollection AnalysisProtocolCollection `xml:"AnalysisProtocolCollection"`
	DataCollection             DataCollection             `xml:"DataCollection"`
	BibliographicReference     []BibliographicReference   `xml:"BibliographicReference"`
}

MzIdentML is the upper-most hierarchy level of mzIdentML with sub-containers for example describing software, protocols and search results (spectrum identifications or protein detection results)

func (*MzIdentML) Parse 

func (p *MzIdentML) Parse(f string)

Parse is the main function for parsing MzIdentML data

func (*MzIdentML) Write 

func (p *MzIdentML) Write()

Parse is the main function for parsing pepxml data

type MzML 

type MzML struct {
	XMLName                     xml.Name                    `xml:"mzML"`
	Accession                   string                      `xml:"accession,attr"`
	ID                          string                      `xml:"id,attr"`
	Version                     string                      `xml:"version,attr"`
	CvList                      CvList                      `xml:"cvList"`
	FileDescription             FileDescription             `ml:"fileDescription"`
	RefParamGroupList           RefParamGroupList           `xml:"referenceableParamGroupList"`
	SampleList                  SampleList                  `xml:"sampleList"`
	SoftwareList                SoftwareList                `xml:"softwareList"`
	ScanSettingsList            ScanSettingsList            `xml:"scanSettingsList"`
	InstrumentConfigurationList InstrumentConfigurationList `xml:"instrumentConfigurationList"`
	DataProcessingList          DataProcessingList          `xml:"dataProcessingList"`
	Run                         Run                         `xml:"run"`
}

MzML This is the root element for the Proteomics Standards Initiative (PSI) mzML schema, which is intended to capture the use of a mass spectrometer, the data generated, and the initial processing of that data

type MzMLSourceFile 

type MzMLSourceFile struct {
	XMLName                     xml.Name                    `xml:"sourceFile"`
	ID                          string                      `xml:"id,attr"`
	Location                    string                      `xml:"location,attr"`
	Name                        string                      `xml:"name,attr"`
	ExternalFormatDocumentation ExternalFormatDocumentation `xml:"ExternalFormatDocumentation"`
	FileFormat                  FileFormat                  `xml:"FileFormat"`
	CVParam                     []CVParam                   `xml:"cvParam"`
	UserParam                   []UserParam                 `xml:"userParam"`
}

MzMLSourceFile is a file from which this instance was created

type Organization 

type Organization struct {
	XMLName   xml.Name    `xml:"Organization"`
	ID        string      `xml:"id,attr,omitempty"`
	Name      string      `xml:"name,attr,omitempty"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
	Parent    Parent      `xml:"Parent"`
}

Organization are entities like companies, universities, government agencies. Any additional information such as the address, email etc. should be supplied either as CV parameters or as user parameters.

type Parent 

type Parent struct {
	XMLName         xml.Name `xml:"Parent"`
	OrganizationRef string   `xml:"organization_ref,attr,omitempty"`
}

Parent is the containing organization (the university or business which a lab belongs to, etc.)

type ParentTolerance 

type ParentTolerance struct {
	XMLName xml.Name  `xml:"ParentTolerance"`
	CVParam []CVParam `xml:"cvParam"`
}

ParentTolerance is the tolerance of the search given as a plus and minus value with units

type Peptide 

type Peptide struct {
	XMLName                  xml.Name                   `xml:"Peptide"`
	ID                       string                     `xml:"id,attr,omitempty"`
	Name                     string                     `xml:"name,attr,omitempty"`
	PeptideSequence          PeptideSequence            `xml:"PeptideSequence"`
	Modification             []Modification             `xml:"Modification"`
	SubstitutionModification []SubstitutionModification `xml:"SubstitutionModification"`
	CVParam                  []CVParam                  `xml:"cvParam"`
	UserParam                []UserParam                `xml:"userParam"`
}

Peptide is One (poly)peptide (a sequence with modifications). The combination of Peptide sequence and modifications MUST be unique in the file

type PeptideEvidence 

type PeptideEvidence struct {
	XMLName             xml.Name    `xml:"PeptideEvidence"`
	DBSequenceRef       string      `xml:"dBSequence_ref,attr,omitempty"`
	End                 int         `xml:"end,attr,omitempty"`
	Frame               string      `xml:"frame,attr,omitempty"`
	ID                  string      `xml:"id,attr,omitempty"`
	IsDecoy             string      `xml:"isDecoy,attr,omitempty"`
	Name                string      `xml:"name,attr,omitempty"`
	PeptideRef          string      `xml:"peptide_ref,attr,omitempty"`
	Post                string      `xml:"post,attr,omitempty"`
	Pre                 string      `xml:"pre,attr,omitempty"`
	Start               string      `xml:"start,attr,omitempty"`
	TranslationTableRef string      `xml:"translationTable_ref,attr,omitempty"`
	CVParam             []CVParam   `xml:"cvParam"`
	UserParam           []UserParam `xml:"userParam"`
}

PeptideEvidence links a specific Peptide element to a specific position in a DBSequence. There MUST only be one PeptideEvidence item per Peptide-to-DBSequence-position

type PeptideEvidenceRef 

type PeptideEvidenceRef struct {
	XMLName            xml.Name `xml:"PeptideEvidenceRef"`
	PeptideEvidenceRef string   `xml:"peptideEvidence_ref,attr,omitempty"`
}

PeptideEvidenceRef reference to the PeptideEvidence element identified. If a specific sequence can be assigned to multiple proteins and or positions in a protein all possible PeptideEvidence elements should be referenced here

type PeptideHypothesis 

type PeptideHypothesis struct {
	XMLName                       xml.Name                        `xml:"PeptideHypothesis"`
	PeptideEvidenceRef            string                          `xml:"peptideEvidence_ref,attr,omitempty"`
	SpectrumIdentificationItemRef []SpectrumIdentificationItemRef `xml:"SpectrumIdentificationItemRef,omitempty"`
}

PeptideHypothesis is the evidence on which this ProteinHypothesis is based by reference to a PeptideEvidence element

type PeptideSequence 

type PeptideSequence struct {
	XMLName xml.Name `xml:"PeptideSequence"`
	Value   string   `xml:",chardata"`
}

PeptideSequence is the amino acid sequence of the (poly)peptide. If a substitution modification has been found, the original sequence should be reported

type Person 

type Person struct {
	XMLName     xml.Name      `xml:"Person"`
	FirstName   string        `xml:"firstName,attr,omitempty"`
	ID          string        `xml:"id,attr,omitempty"`
	LastName    string        `xml:"lastName,attr,omitempty"`
	MidInitials string        `xml:"midInitials,attr,omitempty"`
	Name        string        `xml:"name,attr,omitempty"`
	CVParam     []CVParam     `xml:"cvParam"`
	UserParam   []UserParam   `xml:"userParam"`
	Affiliation []Affiliation `xml:"Affiliation"`
}

Person is a person's name and contact details. Any additional information such as the address, contact email etc. should be supplied using CV parameters or user parameters

type Precursor 

type Precursor struct {
	XMLName         xml.Name        `xml:"precursor"`
	SpectrumRef     string          `xml:"spectrumRef,attr"`
	UserParam       []UserParam     `xml:"userParam"`
	IsolationWindow IsolationWindow `xml:"isolationWindow"`
	SelectedIonList SelectedIonList `xml:"selectedIonList"`
	Activation      Activation      `xml:"activation"`
}

Precursor tag

type PrecursorList 

type PrecursorList struct {
	XMLName   xml.Name    `xml:"precursorList"`
	Count     int         `xml:"count,attr"`
	Precursor []Precursor `xml:"precursor"`
}

PrecursorList tag

type ProcessingMethod 

type ProcessingMethod struct {
	XMLName                    xml.Name                     `xml:"processingMethod"`
	Order                      int                          `xml:"order,attr,omitempty"`
	SoftwareRef                string                       `xml:"softwareRef,attr,omitempty"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

ProcessingMethod is the description of the default peak processing method. This element describes the base method used in the generation of a particular mzML file. Variable methods should be described in the appropriate acquisition section - if no acquisition-specific details are found, then this information serves as the default

type Product 

type Product struct {
	XMLName         xml.Name        `xml:"product"`
	IsolationWindow IsolationWindow `xml:"isolationWindow"`
}

Product is the method of product ion selection and activation in a precursor ion scan

type ProteinAmbiguityGroup 

type ProteinAmbiguityGroup struct {
	XMLName                    xml.Name                     `xml:"ProteinAmbiguityGroup"`
	ID                         string                       `xml:"id,attr,omitempty"`
	Name                       string                       `xml:"name,attr,omitempty"`
	ProteinDetectionHypothesis []ProteinDetectionHypothesis `xml:"ProteinDetectionHypothesis"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

ProteinAmbiguityGroup is a set of logically related results from a protein detection, for example to represent conflicting assignments of peptides to proteins

type ProteinDetection 

type ProteinDetection struct {
	XMLName                      xml.Name                       `xml:"ProteinDetection"`
	ActivityDate                 string                         `xml:"activityDate,attr,omitempty"`
	ID                           string                         `xml:"id,attr,omitempty"`
	Name                         string                         `xml:"name,attr,omitempty"`
	ProteinDetectionListRef      string                         `xml:"proteinDetectionList_ref,attr,omitempty"`
	ProteinDetectionProtocolRef  string                         `xml:"proteinDetectionProtocol_ref,attr,omitempty"`
	InputSpectrumIdentifications []InputSpectrumIdentifications `xml:"InputSpectrumIdentifications"`
}

ProteinDetection is an Analysis which assembles a set of peptides (e.g. from a spectra search analysis) to proteins

type ProteinDetectionHypothesis 

type ProteinDetectionHypothesis struct {
	XMLName           xml.Name            `xml:"ProteinDetectionHypothesis"`
	DBSquenceRef      string              `xml:"dBSequence_ref,attr,omitempty"`
	ID                string              `xml:"id,attr,omitempty"`
	Name              string              `xml:"name,attr,omitempty"`
	PassThreshold     string              `xml:"PassThreshold,attr"`
	PeptideHypothesis []PeptideHypothesis `xml:"PeptideHypothesis"`
	CVParam           []CVParam           `xml:"cvParam"`
	UserParam         []UserParam         `xml:"userParam"`
}

ProteinDetectionHypothesis is a single result of the ProteinDetection analysis (i.e. a protein)

type ProteinDetectionList 

type ProteinDetectionList struct {
	XMLName               xml.Name                `xml:"ProteinDetectionList"`
	ID                    string                  `xml:"id,attr,omitempty"`
	Name                  string                  `xml:"name,attr,omitempty"`
	ProteinAmbiguityGroup []ProteinAmbiguityGroup `xml:"ProteinAmbiguityGroup"`
	CVParam               []CVParam               `xml:"cvParam"`
	UserParam             []UserParam             `xml:"userParam"`
}

ProteinDetectionList is the protein list resulting from a protein detection process

type ProteinDetectionProtocol 

type ProteinDetectionProtocol struct {
	XMLName             xml.Name       `xml:"ProteinDetectionProtocol"`
	AnalysisSoftwareRef string         `xml:"analysisSoftware_ref,attr,omitempty"`
	ID                  string         `xml:"id,attr,omitempty"`
	Name                string         `xml:"name,attr,omitempty"`
	AnalysisParams      AnalysisParams `xml:"AnalysisParams"`
	Threshold           Threshold      `xml:"Threshold"`
}

ProteinDetectionProtocol is the parameters and settings of a ProteinDetection process

type Provider 

type Provider struct {
	XMLName             xml.Name    `xml:"Provider"`
	AnalysisSoftwareRef string      `xml:"analysisSoftware_ref,attr,omitempty"`
	ID                  string      `xml:"id,attr,omitempty"`
	Name                string      `xml:"name,attr,omitempty"`
	ContactRole         ContactRole `xml:"ContactRole"`
}

Provider is the Provider of the mzIdentML record in terms of the contact and software

type RefParamGroupList 

type RefParamGroupList struct {
	XMLName                 xml.Name                  `xml:"referenceableParamGroupList"`
	Count                   int                       `xml:"count,attr"`
	ReferenceableParamGroup []ReferenceableParamGroup `xml:"referenceableParamGroup"`
}

RefParamGroupList is the container for a list of referenceableParamGroups

type ReferenceableParamGroup 

type ReferenceableParamGroup struct {
	XMLName   xml.Name    `xml:"referenceableParamGroup"`
	ID        string      `xml:"id,attr"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

ReferenceableParamGroup is a collection of CVParam and UserParam elements that can be referenced from elsewhere in this mzML document by using the 'paramGroupRef' element in that location to reference the 'id' attribute value of this element

type ReferenceableParamGroupRef 

type ReferenceableParamGroupRef struct {
	XMLName xml.Name `xml:"referenceableParamGroupRef"`
	Ref     string   `xml:"ref"`
}

ReferenceableParamGroupRef is a reference to a previously defined ParamGroup, which is a reusable container of one or more cvParams

type Residue 

type Residue struct {
	XMLName xml.Name `xml:"Residue"`
	Code    string   `xml:"code,attr,omitempty"`
	Mass    float64  `xml:"mass,attr,omitempty"`
}

Residue is the specification of a single residue within the mass table

type Role 

type Role struct {
	XMLName xml.Name `xml:"Role"`
	CVParam CVParam  `xml:"cvParam"`
}

Role is single entry from an ontology or a controlled vocabulary

type Run 

type Run struct {
	XMLName                           xml.Name                     `xml:"run"`
	DefaultInstrumentConfigurationRef string                       `xml:"defaultInstrumentConfigurationRef,attr,omitempty"`
	DefaultSourceFileRef              string                       `xml:"defaultSourceFileRef,attr,omitempty"`
	ID                                string                       `xml:"id,attr,omitempty"`
	SampleRef                         string                       `xml:"sampleRef,attr,omitempty"`
	StartTimeStamp                    string                       `xml:"startTimeStamp,attr,omitempty"`
	ReferenceableParamGroupRef        []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                           []CVParam                    `xml:"cvParam"`
	UserParam                         []UserParam                  `xml:"userParam"`
	SpectrumList                      SpectrumList                 `xml:"spectrumList"`
	ChromatogramList                  ChromatogramList             `xml:"chromatogramList"`
}

Run tag

type Sample 

type Sample struct {
	XMLName     xml.Name      `xml:"sample"`
	ID          string        `xml:"id,attr,omitempty"`
	Name        string        `xml:"name,attr,omitempty"`
	ContactRole []ContactRole `xml:"ContactRole"`
	SubSample   []SubSample   `xml:"SubSample"`
	CVParam     []CVParam     `xml:"cvParam"`
	UserParam   []UserParam   `xml:"userParam"`
}

Sample is a description of the sample analysed by mass spectrometry using CVParams or UserParams. If a composite sample has been analysed, a parent sample should be defined, which references subsamples. This represents any kind of substance used in an experimental workflow, such as whole organisms, cells, DNA, solutions, compounds and experimental substances (gels, arrays etc.)

type SampleList 

type SampleList struct {
	XMLName xml.Name `xml:"sampleList"`
	Count   int      `xml:"count,attr"`
	Sample  []Sample `xml:"sample"`
}

SampleList is a list and descriptions of samples

type Scan 

type Scan struct {
	XMLName              xml.Name       `xml:"scan"`
	InstConfigurationRef string         `xml:"instrumentConfigurationRef,attr"`
	CVParam              []CVParam      `xml:"cvParam"`
	UserParam            []UserParam    `xml:"userParam"`
	ScanWindowList       ScanWindowList `xml:"scanWindowList"`
}

Scan tag

type ScanList 

type ScanList struct {
	XMLName xml.Name  `xml:"scanList"`
	Count   int       `xml:"count,attr"`
	CVParam []CVParam `xml:"cvParam"`
	Scan    []Scan    `xml:"scan"`
}

ScanList tag

type ScanSettings 

type ScanSettings struct {
	XMLName                    xml.Name                     `xml:"scanSettings"`
	ID                         string                       `xml:"id,attr"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
	SourceFileRefList          SourceFileRefList            `xml:"sourceFileRefList"`
	TargetList                 TargetList                   `xml:"targetList"`
}

ScanSettings contains the description of the acquisition settings of the instrument prior to the start of the run

type ScanSettingsList 

type ScanSettingsList struct {
	XMLName      xml.Name       `xml:"scanSettingsList"`
	Count        int            `xml:"count,attr"`
	ScanSettings []ScanSettings `xml:"scanSettings"`
}

ScanSettingsList is a list with the descriptions of the acquisition settings applied prior to the start of data acquisition

type ScanWindow 

type ScanWindow struct {
	XMLName xml.Name  `xml:"scanWindow"`
	CVParam []CVParam `xml:"cvParam"`
}

ScanWindow tag

type ScanWindowList 

type ScanWindowList struct {
	XMLName    xml.Name     `xml:"scanWindowList"`
	Count      int          `xml:"count,attr"`
	ScanWindow []ScanWindow `xml:"scanWindow"`
}

ScanWindowList tag

type SearchDatabase 

type SearchDatabase struct {
	XMLName                     xml.Name                    `xml:"SearchDatabase"`
	ID                          string                      `xml:"id,attr,omitempty"`
	Location                    string                      `xml:"location,attr,omitempty"`
	Name                        string                      `xml:"name,attr,omitempty"`
	NumDatabaseSequences        int                         `xml:"numDatabaseSequences,attr,omitempty"`
	NumResidues                 string                      `xml:"numResidues,attr,omitempty"`
	ReleaseDate                 string                      `xml:"releaseDate,attr,omitempty"`
	Version                     string                      `xml:"version,attr,omitempty"`
	ExternalFormatDocumentation ExternalFormatDocumentation `xml:"ExternalFormatDocumentation"`
	FileFormat                  FileFormat                  `xml:"FileFormat"`
	DatabaseName                DatabaseName                `xml:"DatabaseName"`
	CVParam                     []CVParam                   `xml:"cvParam"`
}

SearchDatabase is a database for searching mass spectra. Examples include a set of amino acid sequence entries, nucleotide databases (e.g. 6 frame translated) or annotated spectra libraries

type SearchDatabaseRef 

type SearchDatabaseRef struct {
	XMLName           xml.Name `xml:"SearchDatabaseRef"`
	SearchDatabaseRef string   `xml:"searchDatabase_ref,attr,omitempty"`
}

SearchDatabaseRef is one of the search databases used

type SearchModification 

type SearchModification struct {
	XMLName          xml.Name           `xml:"SearchModification"`
	FixedMod         string             `xml:"fixedMod,attr,omitempty"`
	MassDelta        float64            `xml:"massDelta,attr,omitempty"`
	Residues         string             `xml:"residues,attr,omitempty"`
	SpecificityRules []SpecificityRules `xml:"SpecificityRules"`
	CVParam          []CVParam          `xml:"cvParam"`
}

SearchModification of a search modification as parameter for a spectra search. Contains the name of the modification, the mass, the specificity and whether it is a static modification

type SearchType 

type SearchType struct {
	XMLName   xml.Name    `xml:"SearchType"`
	CVParam   CVParam     `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

SearchType is the type of search performed e.g. PMF, Tag searches, MS-MS

type SelectedIon 

type SelectedIon struct {
	XMLName xml.Name  `xml:"selectedIon"`
	CVParam []CVParam `xml:"cvParam"`
}

SelectedIon tag

type SelectedIonList 

type SelectedIonList struct {
	XMLName     xml.Name      `xml:"selectedIonList"`
	Count       int           `xml:"count,attr"`
	SelectedIon []SelectedIon `xml:"selectedIon"`
}

SelectedIonList tag

type Seq 

type Seq struct {
	XMLName xml.Name `xml:"Seq"`
	Value   string   `xml:",chardata"`
}

Seq is the actual sequence of amino acids or nucleic acid

type SequenceCollection 

type SequenceCollection struct {
	XMLName         xml.Name          `xml:"SequenceCollection"`
	DBSequence      []DBSequence      `xml:"DBSequence"`
	Peptide         []Peptide         `xml:"Peptide"`
	PeptideEvidence []PeptideEvidence `xml:"PeptideEvidence"`
}

SequenceCollection is the collection of sequences (DBSequence or Peptide) identified and their relationship between each other (PeptideEvidence) to be referenced elsewhere in the results

type SiteRegexp 

type SiteRegexp struct {
	XMLName xml.Name `xml:"SiteRegexp"`
	Value   []byte   `xml:",chardata"`
}

SiteRegexp is the Regular expression for specifying the enzyme cleavage site

type Software 

type Software struct {
	XMLName                    xml.Name                     `xml:"software"`
	ID                         string                       `xml:"id,attr"`
	Version                    string                       `xml:"version,attr"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

Software ia a piece of software

type SoftwareList 

type SoftwareList struct {
	XMLName  xml.Name   `xml:"softwareList"`
	Count    int        `xml:"count,attr"`
	Software []Software `xml:"software"`
}

SoftwareList contains descriptions of software used to acquire and/or process the data in this mzML file

type SoftwareName 

type SoftwareName struct {
	XMLName   xml.Name  `xml:"SoftwareName"`
	CVParam   CVParam   `xml:"cvParam"`
	UserParam UserParam `xml:"userParam"`
}

SoftwareName is the name of the analysis software package, sourced from a CV if available

type SoftwareRef 

type SoftwareRef struct {
	XMLName xml.Name `xml:"softwareRef"`
	Ref     string   `xml:"ref,attr,omitempty"`
}

SoftwareRef is a reference to a previously defined software element

type Source 

type Source struct {
	XMLName                    xml.Name                     `xml:"source"`
	Order                      int                          `xml:"order,attr,omitempty"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

Source is a source component

type SourceFile 

type SourceFile struct {
	XMLName                     xml.Name                    `xml:"SourceFile"`
	ID                          string                      `xml:"id,attr,omitempty"`
	Location                    string                      `xml:"location,attr,omitempty"`
	Name                        string                      `xml:"name,attr,omitempty"`
	ExternalFormatDocumentation ExternalFormatDocumentation `xml:"ExternalFormatDocumentation"`
	FileFormat                  FileFormat                  `xml:"FileFormat"`
	CVParam                     []CVParam                   `xml:"cvParam"`
	UserParam                   []UserParam                 `xml:"userParam"`
}

SourceFile is a file from which this instance was created

type SourceFileList 

type SourceFileList struct {
	XMLName    xml.Name         `xml:"sourceFileList"`
	Count      int              `xml:"count,attr"`
	SourceFile []MzMLSourceFile `xml:"sourceFile"`
}

SourceFileList tag

type SourceFileRef 

type SourceFileRef struct {
	XMLName xml.Name `xml:"SourceFile"`
	Ref     string   `xml:"ref,attr,omitempty"`
}

SourceFileRef is a file from which this instance was created

type SourceFileRefList 

type SourceFileRefList struct {
	XMLName       xml.Name        `xml:"sourceFileRefList"`
	Count         int             `xml:"count,attr"`
	SourceFileRef []SourceFileRef `xml:"sourceFileRef"`
}

SourceFileRefList is a list with the source files containing the acquisition settings

type SpecificityRules 

type SpecificityRules struct {
	XMLName   xml.Name    `xml:"SpecificityRules"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

SpecificityRules is the specificity rules of the searched modification including for example the probability of a modification's presence or peptide or protein termini. Standard fixed or variable status should be provided by the attribute fixedMod

type SpectraData 

type SpectraData struct {
	XMLName                     xml.Name                    `xml:"SpectraData"`
	ID                          string                      `xml:"id,attr,omitempty"`
	Location                    string                      `xml:"location,attr,omitempty"`
	Name                        string                      `xml:"name,attr,omitempty"`
	ExternalFormatDocumentation ExternalFormatDocumentation `xml:"ExternalFormatDocumentation"`
	FileFormat                  FileFormat                  `xml:"FileFormat"`
	SpectrumIDFormat            SpectrumIDFormat            `xml:"SpectrumIDFormat"`
}

SpectraData should be used

type Spectrum 

type Spectrum struct {
	XMLName             xml.Name            `xml:"spectrum"`
	DataProcessingRef   string              `xml:"dataProcessingRef,attr"`
	DefaultArrayLength  float64             `xml:"defaultArrayLength,attr"`
	ID                  string              `xml:"id,attr"`
	Index               string              `xml:"index,attr"`
	SourceFileRef       string              `xml:"sourceFileRef,attr"`
	SpotID              string              `xml:"spotID,attr"`
	CVParam             []CVParam           `xml:"cvParam"`
	ScanList            ScanList            `xml:"scanList"`
	PrecursorList       PrecursorList       `xml:"precursorList"`
	BinaryDataArrayList BinaryDataArrayList `xml:"binaryDataArrayList"`
	Peaks               []float64
	Intensities         []float64
}

Spectrum tag

type SpectrumIDFormat 

type SpectrumIDFormat struct {
	XMLName xml.Name `xml:"SpectrumIDFormat"`
	CVParam CVParam  `xml:"cvParam"`
}

SpectrumIDFormat is the format of the spectrum identifier within the source file

type SpectrumIdentification 

type SpectrumIdentification struct {
	XMLName                           xml.Name            `xml:"SpectrumIdentification"`
	ActivityDate                      string              `xml:"activityDate,attr,omitempty"`
	ID                                string              `xml:"id,attr,omitempty"`
	Name                              string              `xml:"name,attr,omitempty"`
	SpectrumIdentificationListRef     string              `xml:"spectrumIdentificationList_ref,attr,omitempty"`
	SpectrumIdentificationProtocolRef string              `xml:"spectrumIdentificationProtocol_ref,attr,omitempty"`
	InputSpectra                      []InputSpectra      `xml:"InputSpectra"`
	SearchDatabaseRef                 []SearchDatabaseRef `xml:"SearchDatabaseRef"`
}

SpectrumIdentification is an analysis which tries to identify peptides in input spectra, referencing the database searched, the input spectra, the output results and the protocol that is run

type SpectrumIdentificationItem 

type SpectrumIdentificationItem struct {
	XMLName                  xml.Name             `xml:"SpectrumIdentificationItem"`
	CalculatedMassToCharge   float64              `xml:"calculatedMassToCharge,attr,omitempty"`
	CalculatedPI             float64              `xml:"calculatedPI,attr,omitempty"`
	ChargeState              uint8                `xml:"chargeState,attr,omitempty"`
	ExperimentalMassToCharge float64              `xml:"experimentalMassToCharge,attr,omitempty"`
	ID                       string               `xml:"id,attr,omitempty"`
	MassTableRef             string               `xml:"massTable_ref,attr,omitempty"`
	Name                     string               `xml:"name,attr,omitempty"`
	PassThreshold            string               `xml:"passThreshold,attr,omitempty"`
	PeptideRef               string               `xml:"peptide_ref,attr,omitempty"`
	Rank                     uint8                `xml:"rank,attr,omitempty"`
	SampleRef                string               `xml:"sample_ref,attr,omitempty"`
	PeptideEvidenceRef       []PeptideEvidenceRef `xml:"PeptideEvidenceRef"`
	Fragmentation            Fragmentation        `xml:"Fragmentation"`
	CVParam                  []CVParam            `xml:"cvParam"`
	UserParam                []UserParam          `xml:"userParam"`
}

SpectrumIdentificationItem is an identification of a single (poly)peptide, resulting from querying an input spectra, along with the set of confidence values for that identification. PeptideEvidence elements should be given for all mappings of the corresponding Peptide sequence within protein sequences

type SpectrumIdentificationItemRef 

type SpectrumIdentificationItemRef struct {
	XMLName                       xml.Name `xml:"SpectrumIdentificationItemRef"`
	SpectrumIdentificationItemRef string   `xml:"spectrumIdentificationItem_ref,attr"`
}

SpectrumIdentificationItemRef Reference(s) to the SpectrumIdentificationItem element(s) that support the given PeptideEvidence element. Using these references it is possible to indicate which spectra were actually accepted as evidence for this peptide identification in the given protein

type SpectrumIdentificationList 

type SpectrumIdentificationList struct {
	XMLName                      xml.Name                       `xml:"SpectrumIdentificationList"`
	ID                           string                         `xml:"id,attr,omitempty"`
	Name                         string                         `xml:"name,attr,omitempty"`
	NumSequencesSearched         float64                        `xml:"numSequencesSearched,attr,omitempty"`
	FragmentationTable           FragmentationTable             `xml:"FragmentationTable"`
	SpectrumIdentificationResult []SpectrumIdentificationResult `xml:"SpectrumIdentificationResult"`
	CVParam                      []CVParam                      `xml:"cvParam"`
	UserParam                    []UserParam                    `xml:"userParam"`
}

SpectrumIdentificationList is the set of all search results from SpectrumIdentification

type SpectrumIdentificationProtocol 

type SpectrumIdentificationProtocol struct {
	XMLName                xml.Name               `xml:"SpectrumIdentificationProtocol"`
	AnalysisSoftwareRef    string                 `xml:"analysisSoftware_ref,attr,omitempty"`
	ID                     string                 `xml:"id,attr,omitempty"`
	Name                   string                 `xml:"name,attr,omitempty"`
	SearchType             SearchType             `xml:"SearchType"`
	AdditionalSearchParams AdditionalSearchParams `xml:"AdditionalSearchParams"`
	ModificationParams     ModificationParams     `xml:"ModificationParams"`
	Enzymes                Enzymes                `xml:"Enzymes"`
	MassTable              []MassTable            `xml:"MassTable"`
	FragmentTolerance      FragmentTolerance      `xml:"FragmentTolerance"`
	ParentTolerance        ParentTolerance        `xml:"ParentTolerance"`
	Threshold              Threshold              `xml:"Threshold"`
	DatabaseFilters        DatabaseFilters        `xml:"DatabaseFilters"`
	DatabaseTranslation    DatabaseTranslation    `xml:"DatabaseTranslation"`
}

SpectrumIdentificationProtocol is the parameters and settings of a SpectrumIdentification analysis

type SpectrumIdentificationResult 

type SpectrumIdentificationResult struct {
	XMLName                    xml.Name                     `xml:"SpectrumIdentificationResult"`
	ID                         string                       `xml:"id,attr,omitempty"`
	Name                       string                       `xml:"name,attr,omitempty"`
	SpectraDataRef             string                       `xml:"spectraData_ref,attr,omitempty"`
	SpectrumID                 string                       `xml:"spectrumID,attr,omitempty"`
	SpectrumIdentificationItem []SpectrumIdentificationItem `xml:"SpectrumIdentificationItem"`
}

SpectrumIdentificationResult is All identifications made from searching one spectrum. For PMF data, all peptide identifications will be listed underneath as SpectrumIdentificationItems. For MS/MS data, there will be ranked SpectrumIdentificationItems corresponding to possible different peptide IDs

type SpectrumList 

type SpectrumList struct {
	XMLName                  xml.Name   `xml:"spectrumList"`
	Count                    int        `xml:"count,attr"`
	DefaultDataProcessingRef string     `xml:"defaultDataProcessingRef,attr"`
	Spectrum                 []Spectrum `xml:"spectrum"`
}

SpectrumList tag

type SubSample 

type SubSample struct {
	XMLName   xml.Name `xml:"SubSample"`
	SampleRef string   `xml:"sample_ref,attr,omitempty"`
}

SubSample is the references to the individual component samples within a mixed parent sample

type SubstitutionModification 

type SubstitutionModification struct {
	XMLName               xml.Name `xml:"SubstitutionModification"`
	AvgMassDelta          float64  `xml:"avgMassDelta,attr,omitempty"`
	Location              int      `xml:"location,attr,omitempty"`
	MonoisotopicMassDelta float64  `xml:"monoisotopicMassDelta,attr,omitempty"`
	OriginalResidue       string   `xml:"originalResidue,attr,omitempty"`
	ReplacementResidue    string   `xml:"replacementResidue,attr,omitempty"`
}

SubstitutionModification is a modification where one residue is substituted by another (amino acid change)

type Target 

type Target struct {
	XMLName                    xml.Name                     `xml:"target"`
	ReferenceableParamGroupRef []ReferenceableParamGroupRef `xml:"referenceableParamGroupRef"`
	CVParam                    []CVParam                    `xml:"cvParam"`
	UserParam                  []UserParam                  `xml:"userParam"`
}

Target is a structure allowing the use of a controlled (cvParam) or uncontrolled vocabulary (userParam), or a reference to a predefined set of these in this mzML file (paramGroupRef)

type TargetList 

type TargetList struct {
	XMLName xml.Name `xml:"targetList"`
	Count   int      `xml:"count,attr"`
	Target  []Target `xml:"target"`
}

TargetList (or 'inclusion list') configured prior to the run

type Threshold 

type Threshold struct {
	XMLName   xml.Name    `xml:"Threshold"`
	CVParam   []CVParam   `xml:"cvParam"`
	UserParam []UserParam `xml:"userParam"`
}

Threshold is applied to determine that a result is significant. If multiple terms are used it is assumed that all conditions are satisfied by the passing results. Also applied to determine that a result is significant. If multiple terms are used it is assumed that all conditions are satisfied by the passing results

type TranslationTable 

type TranslationTable struct {
	XMLName xml.Name  `xml:"TranslationTable"`
	CVParam []CVParam `xml:"cvParam"`
}

TranslationTable is the table used to translate codons into nucleic acids e.g. by reference to the NCBI translation table

type UserParam 

type UserParam struct {
	XMLName       xml.Name `xml:"userParam"`
	Name          string   `xml:"name,attr,omitempty"`
	Type          string   `xml:"type,attr,omitempty"`
	UnitAccession string   `xml:"unitAccession,attr,omitempty"`
	UnitCvRef     string   `xml:"unitCvRef,attr,omitempty"`
	UnitName      string   `xml:"UnitName,attr,omitempty"`
	Value         string   `xml:"value,attr,omitempty"`
}

UserParam In case more information about the ions annotation has to be conveyed, that has no fit in FragmentArray. Note: It is suggested that the value attribute takes the form of a list of the same size as FragmentArray values. However, there is no formal encoding and it cannot be expeceted that other software will process or impart that information properly

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.