ProteoWizard
IdentData.hpp
Go to the documentation of this file.
1//
2// $Id$
3//
4//
5// Original author: Robert Burke <robert.burke@proteowizard.org>
6//
7// Copyright 2009 Spielberg Family Center for Applied Proteomics
8// University of Southern California, Los Angeles, California 90033
9//
10// Licensed under the Apache License, Version 2.0 (the "License");
11// you may not use this file except in compliance with the License.
12// You may obtain a copy of the License at
13//
14// http://www.apache.org/licenses/LICENSE-2.0
15//
16// Unless required by applicable law or agreed to in writing, software
17// distributed under the License is distributed on an "AS IS" BASIS,
18// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19// See the License for the specific language governing permissions and
20// limitations under the License.
21//
22
23
24#ifndef _IDENTDATA_HPP_
25#define _IDENTDATA_HPP_
26
27
32#include "boost/logic/tribool.hpp"
33#include <vector>
34#include <string>
35#include <map>
36
37
38#ifdef USE_RAW_PTR
39#define TYPEDEF_SHARED_PTR(type) typedef type* type##Ptr
40#define BOOST_FOREACH(a, b) a;
41#else
42#include <boost/foreach.hpp>
43#define TYPEDEF_SHARED_PTR(type) typedef boost::shared_ptr<type> type##Ptr
44#endif
45
46
47namespace pwiz {
48namespace identdata {
49
50
51using namespace pwiz::cv;
52using namespace pwiz::data;
53
54/// returns a default list of CVs used in an IdentData document;
55/// currently includes PSI-MS, Unit Ontology, and UNIMOD
56PWIZ_API_DECL std::vector<CV> defaultCVList();
57
58/// Parent class representing extensions of the IdentifiableType from
59/// the mzIdentML schema.
60///
61/// Other classes in the model can be specified as sub-classes,
62/// inheriting from Identifiable. Identifiable gives classes a unique
63/// identifier within the scope and a name that need not be unique.
65{
66 Identifiable(const std::string& id_ = "",
67 const std::string& name_ = "");
68 virtual ~Identifiable() {}
69
70 std::string id;
71 std::string name;
72
73 virtual bool empty() const;
74};
75
76/// Parent class of all Identifiable objects that have ParamGroups.
77///
78/// Represents bibliographic references.
80{
81 IdentifiableParamContainer(const std::string& id_ = "",
82 const std::string& name_ = "");
84
85 std::string id;
86 std::string name;
87
88 virtual bool empty() const;
89};
90
91/// Implementation for the BibliographicReferenceType tag in the
92/// mzIdentML schema.
93///
94/// Represents bibliographic references.
96{
98
99 std::string authors;
100 std::string publication;
101 std::string publisher;
102 std::string editor;
103 int year;
104 std::string volume;
105 std::string issue;
106 std::string pages;
107 std::string title;
108
109 bool empty() const;
110};
111
113
114/// Implementation of ContactType from mzIdentML.
115///
116/// A contact is either a person or an organization.
118{
119 Contact(const std::string& id_ = "",
120 const std::string& name_ = "");
121 virtual ~Contact() {}
122
123 virtual bool empty() const;
124};
125
127
128/// \brief Implementation of AbstractOrganizationType from the
129/// mzIdentML schema.
130///
131/// Organizations are entities like companies, universities,
132/// government agencies. Any additional information such as the
133/// address, email etc. should be supplied either as CV parameters or
134/// as user parameters.
136{
137 Organization(const std::string& id_ = "",
138 const std::string& name_ = "");
139
140 boost::shared_ptr<Organization> parent;
141
142 virtual bool empty() const;
143};
144
146
147/// Implementation of PersonType from the mzIdentML schema.
148///
149/// A person's name and contact details. Any additional information
150/// such as the address, contact email etc. should be supplied using
151/// CV parameters or user parameters.
153{
154 Person(const std::string& id_ = "",
155 const std::string& name_ = "");
156
157 std::string lastName;
158 std::string firstName;
159 std::string midInitials;
160
161 std::vector<OrganizationPtr> affiliations;
162
163 virtual bool empty() const;
164};
165
167
168/// Implementation of ContactRoleType from the mzIdentML schema.
169///
170/// The role that a Contact plays in an organization or with respect
171/// to the associating class. A Contact may have several Roles within
172/// scope, and as such, associations to ContactRole allow the use of a
173/// Contact in a certain manner. Examples might include a provider, or
174/// a data analyst.
176{
178 const ContactPtr& contactPtr_ = ContactPtr());
179
180 ContactPtr contactPtr;
181
182 bool empty() const;
183};
184
186
187/// Implementation of the SampleType from the mzIdentML schema.
188///
189/// A description of the sample analysed by mass spectrometry using
190/// CVParams or UserParams. If a composite sample has been analysed, a
191/// parent sample should be defined, which references subsamples. This
192/// represents any kind of substance used in an experimental workflow,
193/// such as whole organisms, cells, DNA, solutions, compounds and
194/// experimental substances (gels, arrays etc.).
196{
197 Sample(const std::string& id_ = "",
198 const std::string& name_ = "");
199
200 std::vector<ContactRolePtr> contactRole;
201 std::vector<boost::shared_ptr<Sample> > subSamples;
202
203 bool empty() const;
204};
205
207
208/// Implementation of AnalysisSoftwareType from the mzIdentML schema.
209///
210/// The software used for performing the analyses.
212{
213 AnalysisSoftware(const std::string& id_ = "",
214 const std::string& name_ = "");
215
216 // SoftwareType attributes
217 std::string version;
218 std::string URI;
219 std::string customizations;
220
221 // SoftwareType elements
222 ContactRolePtr contactRolePtr;
224
225 virtual bool empty() const;
226};
227
229
230/// Implementation of ProviderType from the mzIdentML schema.
231///
232/// The provider of the document in terms of the Contact and the
233/// software the produced the document instance.
235{
236 Provider(const std::string id_ = "",
237 const std::string name_ = "");
238
239 ContactRolePtr contactRolePtr;
240 AnalysisSoftwarePtr analysisSoftwarePtr;
241
242 bool empty() const;
243};
244
246
247
248// TODO find example document w/ this in it and determine best
249// representation for data model
250
251/// Implementation of AnalysisSampleCollectionType from mzIdentML
252/// schema.
253///
254/// The samples analysed can optionally be recorded using CV terms for
255/// descriptions. If a composite sample has been analysed, the
256/// subsample association can be used to build a hierarchical
257/// description.
259{
260 std::vector<SamplePtr> samples;
261
262 bool empty() const;
263};
264
265
266/// Implementation of SearchDatabaseType from the mzIdentML schema.
267///
268/// A database for searching mass spectra. Examples include a set of
269/// amino acid sequence entries, or annotated spectra libraries.
271{
272 SearchDatabase(const std::string& id_ = "",
273 const std::string& name_ = "");
274
275 std::string location;
276 std::string version;
277 std::string releaseDate;
280
283
284 bool empty() const;
285};
286
288
289
290/// Implementation of DBSequenceType from the mzIdentML schema.
291///
292/// A database sequence from the specified SearchDatabase (nucleic
293/// acid or amino acid). If the sequence is nucleic acid, the source
294/// nucleic acid sequence should be given in the seq attribute rather
295/// than a translated sequence.
297{
298 DBSequence(const std::string id_ = "",
299 const std::string name_ = "");
300
302 std::string accession;
303 SearchDatabasePtr searchDatabasePtr;
304
305 std::string seq;
306
307 bool empty() const;
308};
309
311
312
313/// Implementation of ModificationType from the mzIdentML schema.
314///
315/// A molecule modification specification. If n modifications have
316/// been found on a peptide, there should be n instances of
317/// Modification. If multiple modifications are provided as cvParams,
318/// it is assumed that the modification is ambiguous i.e. one
319/// modification or another. A cvParam must be provided with the
320/// identification of the modification sourced from a suitable CV
321/// e.g. UNIMOD. If the modification is not present in the CV (and
322/// this will be checked by the semantic validator within a given
323/// tolerance window), there is a “unknown modification” CV
324/// term that must be used instead. A neutral loss should be defined
325/// as an additional CVParam within Modification. If more complex
326/// information should be given about neutral losses (such as
327/// presence/absence on particular product ions), this can
328/// additionally be encoded within the FragmentationArray.
330{
332
334 std::vector<char> residues;
337
338 bool empty() const;
339};
340
342
343
344/// Implementation of SubstitutionModificationType from the mzIdentML
345/// schema.
346///
347/// A modification where one residue is substituted by another (amino
348/// acid change).
361
363
364/// Implementation of PeptideType from the mzIdentML schema.
365///
366/// One (poly)peptide (a sequence with modifications). The combination
367/// of Peptide sequence and modifications must be unique in the file.
369{
370 Peptide(const std::string& id="",
371 const std::string& name="");
372
373 std::string peptideSequence;
374 std::vector<ModificationPtr> modification;
375 std::vector<SubstitutionModificationPtr> substitutionModification;
376
377 bool empty() const;
378};
379
381
382
383/// Implementation of SearchModificationType from the mzIdentML schema.
384///
385/// Filters applied to the search database. The filter must include at
386/// least one of Include and Exclude. If both are used, it is assumed
387/// that inclusion is performed first.
389{
391
393 double massDelta;
394 std::vector<char> residues;
396
397 bool empty() const;
398};
399
401
402
403/// Implementation of EnzymeType from the mzIdentML schema.
404///
405/// The details of an individual cleavage enzyme should be provided by
406/// giving a regular expression or a CV term if a "standard" enzyme
407/// cleavage has been performed.
409{
410 Enzyme(const std::string& id = "",
411 const std::string& name = "");
412
413 std::string nTermGain;
414 std::string cTermGain;
415 proteome::Digestion::Specificity terminalSpecificity;
418
419 std::string siteRegexp;
421
422 bool empty() const;
423};
424
426
427
428/// Implementation of EnzymesType from the mzIdentML schema.
429///
430/// The list of enzymes used in experiment.
432{
433 boost::logic::tribool independent;
434
435 std::vector<EnzymePtr> enzymes;
436
437 bool empty() const;
438};
439
440
441/// Implementation of ResidueType from the mzIdentML schema.
442///
443/// Representation of the Residue tags that holds a letter code and
444/// residue mass in Daltons (not including any fixed modifications).
446{
448
449 char code;
450 double mass;
451
452 bool empty() const;
453};
454
456
457
458/// Implementation of AmbiguousResidueType from the mzIdentML schema.
459///
460/// Ambiguous residues e.g. X can be specified by the Code attribute
461/// and a set of parameters for example giving the different masses
462/// that will be used in the search.
464{
466
467 char code;
468
469 bool empty() const;
470};
471
473
474
475/// Implementation of MassTableType from the mzIdentML schema.
476///
477/// Ambiguous residues e.g. X can be specified by the Code attribute
478/// and a set of parameters for example giving the different masses
479/// that will be used in the search.
481{
482 MassTable(const std::string id = "");
483
484 std::string id;
485 std::vector<int> msLevel;
486
487 std::vector<ResiduePtr> residues;
488 std::vector<AmbiguousResiduePtr> ambiguousResidue;
489
490 bool empty() const;
491};
492
494
495
496/// Implementation of FilterType from the mzIdentML schema.
497///
498/// Filters applied to the search database. The filter must include at
499/// least one of Include and Exclude. If both are used, it is assumed
500/// that inclusion is performed first.
509
511
512
513/// Implementation of TranslationTableType from the mzIdentML schema.
514///
515/// The table used to translate codons into nucleic acids e.g. by
516/// reference to the NCBI translation table.
518{
519 TranslationTable(const std::string& id = "",
520 const std::string& name = "");
521};
522
524
525
526/// Implementation of DatabaseTranslationType from the mzIdentML schema.
527///
528/// A specification of how a nucleic acid sequence database was
529/// translated for searching.
531{
532 std::vector<int> frames;
533 std::vector<TranslationTablePtr> translationTable;
534
535 bool empty() const;
536};
537
539
540
541/// Implementation of SpectrumIdentificationProtocolType from the
542/// mzIdentML schema.
543///
544/// The parameters and settings of a SpectrumIdentification analysis.
546{
547 SpectrumIdentificationProtocol(const std::string& id_ = "",
548 const std::string& name_ = "");
549
550 AnalysisSoftwarePtr analysisSoftwarePtr;
551
554 std::vector<SearchModificationPtr> modificationParams;
556 std::vector<MassTablePtr> massTable;
560 std::vector<FilterPtr> databaseFilters;
561 DatabaseTranslationPtr databaseTranslation;
562
563 bool empty() const;
564};
565
567
568
569/// Implementation of MeasureType from the mzIdentML schema.
570///
571/// References to CV terms defining the measures about product ions to
572/// be reported in SpectrumIdentificationItem.
574{
575 Measure(const std::string id = "",
576 const std::string name = "");
577
578 bool empty() const;
579};
580
582
583
584/// Implementation of FragmentArrayType from the mzIdentML schema.
585///
586/// Contains the types of measures that will be reported in generic
587/// arrays for each SpectrumIdentificationItem e.g. product ion m/z,
588/// product ion intensity, product ion m/z error
590{
591 std::vector<double> values;
592 MeasurePtr measurePtr;
593
594 bool empty() const;
595};
596
598
599
600/// Implementation of IonTypeType from the mzIdentML schema.
601///
602/// IonType defines the index of fragmentation ions being reported,
603/// importing a CV term for the type of ion e.g. b ion. Example: if b3
604/// b7 b8 and b10 have been identified, the index attribute will
605/// contain 3 7 8 10, and the corresponding values will be reported in
606/// parallel arrays below
608{
610
611 std::vector<int> index;
613 std::vector<FragmentArrayPtr> fragmentArray;
614
615 bool empty() const;
616};
617
619
620
621/// Implementation of PeptideEvidenceType from the mzIdentML schema.
622///
623/// PeptideEvidence links a specific Peptide element to a specific
624/// position in a DBSequence. There must only be one PeptideEvidence
625/// item per Peptide-to-DBSequence-position.
627{
628 PeptideEvidence(const std::string& id = "",
629 const std::string& name = "");
630
631 PeptidePtr peptidePtr;
632 DBSequencePtr dbSequencePtr;
633 int start;
634 int end;
635 char pre;
636 char post;
637 TranslationTablePtr translationTablePtr;
638 int frame;
640
641 bool empty() const;
642};
643
645
646
647/// Implementation of SequenceCollectionType from the mzIdentML schema.
648///
649/// The collection of sequences (DBSequence or Peptide) identified and
650/// their relationship between each other (PeptideEvidence) to be
651/// referenced elsewhere in the results.
653{
654 std::vector<DBSequencePtr> dbSequences;
655 std::vector<PeptidePtr> peptides;
656 std::vector<PeptideEvidencePtr> peptideEvidence;
657 bool empty() const;
658};
659
660
661/// Implementation of SpectrumIdentificationItemType from the
662/// mzIdentML schema.
663///
664/// An identification of a single (poly)peptide, resulting from
665/// querying an input spectra, along with the set of confidence values
666/// for that identification. PeptideEvidence elements should be given
667/// for all mappings of the corresponding Peptide sequence within
668/// protein sequences.
670{
671 SpectrumIdentificationItem(const std::string& id = "",
672 const std::string& name = "");
673
678 PeptidePtr peptidePtr;
679 int rank;
681 MassTablePtr massTablePtr;
682 SamplePtr samplePtr;
683
684 std::vector<PeptideEvidencePtr> peptideEvidencePtr;
685 std::vector<IonTypePtr> fragmentation;
686
687 bool empty() const;
688};
689
691
692
693/// Implementation of SpectraDataType from the mzIdentML schema.
694///
695/// A data set containing spectra data (consisting of one or more
696/// spectra).
698{
699 SpectraData(const std::string id = "",
700 const std::string name = "");
701
702 std::string location;
703
704 std::vector<std::string> externalFormatDocumentation;
707
708 bool empty() const;
709};
710
712
713
714/// Implementation of SpectrumIdentificationResultType from the
715/// mzIdentML schema.
716///
717/// All identifications made from searching one spectrum. For PMF
718/// data, all peptide identifications will be listed underneath as
719/// SpectrumIdentificationItems. For MS/MS data, there will be ranked
720/// SpectrumIdentificationItems corresponding to possible different
721/// peptide IDs.
723{
724 SpectrumIdentificationResult(const std::string& id_ = "",
725 const std::string& name_ = "");
726
727 std::string spectrumID;
728 SpectraDataPtr spectraDataPtr;
729
730 std::vector<SpectrumIdentificationItemPtr> spectrumIdentificationItem;
731
732 bool empty() const;
733};
734
736
737
738/// Implementation of SpectrumIdentificationListType from the
739/// mzIdentML schema.
740///
741/// Represents the set of all search results from
742/// SpectrumIdentification.
744{
745 SpectrumIdentificationList(const std::string& id_ = "",
746 const std::string& name_ = "");
747
749
750 std::vector<MeasurePtr> fragmentationTable;
751 std::vector<SpectrumIdentificationResultPtr> spectrumIdentificationResult;
752
753 bool empty() const;
754};
755
757
758
759/// Implementation of SpectrumIdentificationType from the mzIdentML schema.
760///
761/// An Analysis which tries to identify peptides in input spectra,
762/// referencing the database searched, the input spectra, the output
763/// results and the protocol that is run.
765{
766 SpectrumIdentification(const std::string& id_ = "",
767 const std::string& name_ = "");
768
769 SpectrumIdentificationProtocolPtr spectrumIdentificationProtocolPtr;
770 SpectrumIdentificationListPtr spectrumIdentificationListPtr;
771 std::string activityDate;
772
773 std::vector<SpectraDataPtr> inputSpectra;
774 std::vector<SearchDatabasePtr> searchDatabase;
775
776 bool empty() const;
777};
778
780
781
782/// Implementation of ProteinDetectionProtocolType from the mzIdentML
783/// schema.
784///
785/// The parameters and settings of a ProteinDetection process.
787{
788 ProteinDetectionProtocol(const std::string& id_ = "",
789 const std::string& name_ = "");
790
791 AnalysisSoftwarePtr analysisSoftwarePtr;
792
795
796 bool empty() const;
797};
798
800
801
802/// Implementation of PeptideHypothesisType from the mzIdentML schema.
803///
804/// Peptide evidence on which this ProteinHypothesis is based by
805/// reference to a PeptideEvidence element.
807{
808 PeptideEvidencePtr peptideEvidencePtr;
809 std::vector<SpectrumIdentificationItemPtr> spectrumIdentificationItemPtr;
810
811 bool empty() const;
812};
813
814
815/// Implementation of ProteinDetectionHypothesisType from the
816/// mzIdentML schema.
817///
818/// A single result of the ProteinDetection analysis (i.e. a protein).
820{
821 ProteinDetectionHypothesis(const std::string& id_ = "",
822 const std::string& name_ = "");
823
824 DBSequencePtr dbSequencePtr;
826 std::vector<PeptideHypothesis> peptideHypothesis;
827
828 bool empty() const;
829};
830
832
833
834/// Implementation of ProteinAmbiguityGroupType from the mzIdentML schema.
835///
836/// A set of logically related results from a protein detection, for
837/// example to represent conflicting assignments of peptides to
838/// proteins.
840{
841 ProteinAmbiguityGroup(const std::string& id_ = "",
842 const std::string& name_ = "");
843
844 std::vector<ProteinDetectionHypothesisPtr> proteinDetectionHypothesis;
845
846 bool empty() const;
847};
848
850
851
852/// Implementation of ProteinDetectionListType from the mzIdentML schema.
853///
854/// The protein list resulting from a protein detection process.
856{
857 ProteinDetectionList(const std::string& id_ = "",
858 const std::string& name_ = "");
859
860 std::vector<ProteinAmbiguityGroupPtr> proteinAmbiguityGroup;
861
862 bool empty() const;
863};
864
866
867
868/// Implementation of ProteinDetectionType from the mzIdentML schema.
869///
870/// An Analysis which assembles a set of peptides (e.g. from a spectra
871/// search analysis) to proteins.
873{
874 ProteinDetection(const std::string id_ = "",
875 const std::string name_ = "");
876
877 ProteinDetectionProtocolPtr proteinDetectionProtocolPtr;
878 ProteinDetectionListPtr proteinDetectionListPtr;
879 std::string activityDate;
880
881 std::vector<SpectrumIdentificationListPtr> inputSpectrumIdentifications;
882
883 virtual bool empty() const;
884};
885
887
888
889/// Implementation of AnalysisCollectionType from the mzIdentML schema
890///
891/// The analyses performed to get the results, which map the input and
892/// output data sets. Analyses are for example: SpectrumIdentification
893/// (resulting in peptides) or ProteinDetection (assemble proteins
894/// from peptides).
896{
897 std::vector<SpectrumIdentificationPtr> spectrumIdentification;
899
900 bool empty() const;
901};
902
903
904/// Implementation of AnalysisProtocolCollectionType from the
905/// mzIdentML schema.
906///
907/// The collection of protocols which include the parameters and
908/// settings of the performed analyses.
910{
911 std::vector<SpectrumIdentificationProtocolPtr> spectrumIdentificationProtocol;
912 std::vector<ProteinDetectionProtocolPtr> proteinDetectionProtocol;
913
914 bool empty() const;
915};
916
918
919
920/// Implementation of SourceFileType from the mzIdentML schema.
921///
922/// A file from which this mzIdentML instance was created.
924{
925 std::string location;
927
928 std::vector<std::string> externalFormatDocumentation;
929
930 bool empty() const;
931};
932
934
935
936/// Implementation of the InputsType from the mzIdentML schema.
937///
938/// The inputs to the analyses including the databases searched, the
939/// spectral data and the source file converted to mzIdentML.
940///
941/// Input element. Contains 0+ of SourceFile, SearchDatabase,
942/// SpectraData
944{
945 // Replace these 3 members w/ their types
946 std::vector<SourceFilePtr> sourceFile;
947 std::vector<SearchDatabasePtr> searchDatabase;
948 std::vector<SpectraDataPtr> spectraData;
949
950 bool empty() const;
951};
952
954
955
956/// Implementation of AnalysisDataType from the mzIdentML schema.
957///
958/// Data sets generated by the analyses, including peptide and protein
959/// lists.
961{
962 std::vector<SpectrumIdentificationListPtr> spectrumIdentificationList;
963 ProteinDetectionListPtr proteinDetectionListPtr;
964
965 bool empty() const;
966};
967
969
970
971/// Implementation of DataCollectionType from the mzIdentML schema.
972///
973/// The collection of input and output data sets of the analyses.
981
983
984
985namespace IO {struct HandlerIdentData;} // forward declaration for friend
986
987
988/// Implementation of the MzIdentMLType from the mzIdentML schema.
989///
990/// The upper-most hierarchy level of mzIdentML with sub-containers
991/// for example describing software, protocols and search results
992/// (spectrum identifications or protein detection results).
994{
995 IdentData(const std::string& id_ = "",
996 const std::string& creationDate_ = "");
997
998 // attributes included in the IdentData schema
999 std::string creationDate;
1000
1001 ///////////////////////////////////////////////////////////////////////
1002 // Elements
1003
1004 std::vector<CV> cvs;
1005
1006 std::vector<AnalysisSoftwarePtr> analysisSoftwareList;
1007
1009
1010 std::vector<ContactPtr> auditCollection;
1011
1013
1015
1017
1019
1021
1022 std::vector<BibliographicReferencePtr> bibliographicReference;
1023
1024 bool empty() const;
1025
1026 /// returns the version of this mzIdentML document;
1027 /// for a document created programmatically, the version is the current release version of mzIdentML;
1028 /// for a document created from a file/stream, the version is the schema version read from the file/stream
1029 const std::string& version() const;
1030
1031 protected:
1032 std::string version_; // schema version read from the file/stream
1033 friend struct IO::HandlerIdentData;
1034};
1035
1037
1038
1039/// given a protocol and a PeptideEvidence instance, returns the PeptideEvidence as a DigestedPeptide instance
1041
1042/// given a protocol and a SpectrumIdentificationItem, builds a set of DigestedPeptides
1043PWIZ_API_DECL std::vector<proteome::DigestedPeptide> digestedPeptides(const SpectrumIdentificationProtocol& sip, const SpectrumIdentificationItem& sii);
1044
1045/// creates a proteome::Peptide from an identdata::Peptide
1047
1048/// creates a proteome::Modification from an identdata::Modification
1050
1051/// returns a cleavage agent CVID for an identdata::Enzyme
1053
1054/// returns a list of cleavage agent CVIDs for an identdata::Enzymes instance
1055PWIZ_API_DECL std::vector<CVID> cleavageAgents(const Enzymes& enzymes);
1056
1057/// returns a regular expression for an identdata::Enzyme
1059
1060/// returns a list of regular expressions for an identdata::Enzymes instance
1061PWIZ_API_DECL std::vector<std::string> cleavageAgentRegexes(const Enzymes& enzymes);
1062
1063/// sets Unimod CV terms (if possible) for all SearchModifications and Modification elements
1065
1066
1067} // namespace identdata
1068} // namespace pwiz
1069
1070#endif // _IDENTDATA_HPP_
#define PWIZ_API_DECL
Definition Export.hpp:32
#define TYPEDEF_SHARED_PTR(type)
Definition IdentData.hpp:43
peptide subclass that contains extra metadata provided by digestion
Definition Digestion.hpp:48
represents a post-translational modification (PTM) modification formula or masses must be provided at...
represents a peptide or polypeptide (a sequence of amino acids)
Definition Peptide.hpp:62
CVID_Unknown
Definition cv.hpp:114
PWIZ_API_DECL void snapModificationsToUnimod(const SpectrumIdentification &si)
sets Unimod CV terms (if possible) for all SearchModifications and Modification elements
PWIZ_API_DECL std::vector< CVID > cleavageAgents(const Enzymes &enzymes)
returns a list of cleavage agent CVIDs for an identdata::Enzymes instance
PWIZ_API_DECL std::vector< std::string > cleavageAgentRegexes(const Enzymes &enzymes)
returns a list of regular expressions for an identdata::Enzymes instance
PWIZ_API_DECL std::string cleavageAgentRegex(const Enzyme &ez)
returns a regular expression for an identdata::Enzyme
PWIZ_API_DECL proteome::DigestedPeptide digestedPeptide(const SpectrumIdentificationProtocol &sip, const PeptideEvidence &peptideEvidence)
given a protocol and a PeptideEvidence instance, returns the PeptideEvidence as a DigestedPeptide ins...
PWIZ_API_DECL proteome::Modification modification(const Modification &mod)
creates a proteome::Modification from an identdata::Modification
PWIZ_API_DECL std::vector< CV > defaultCVList()
returns a default list of CVs used in an IdentData document; currently includes PSI-MS,...
PWIZ_API_DECL proteome::Peptide peptide(const Peptide &peptide)
creates a proteome::Peptide from an identdata::Peptide
PWIZ_API_DECL std::vector< proteome::DigestedPeptide > digestedPeptides(const SpectrumIdentificationProtocol &sip, const SpectrumIdentificationItem &sii)
given a protocol and a SpectrumIdentificationItem, builds a set of DigestedPeptides
PWIZ_API_DECL CVID cleavageAgent(const Enzyme &ez)
returns a cleavage agent CVID for an identdata::Enzyme
represents a tag-value pair, where the tag comes from the controlled vocabulary
The base class for elements that may contain cvParams, userParams, or paramGroup references.
Implementation of AmbiguousResidueType from the mzIdentML schema.
Implementation of AnalysisCollectionType from the mzIdentML schema.
std::vector< SpectrumIdentificationPtr > spectrumIdentification
Implementation of AnalysisDataType from the mzIdentML schema.
std::vector< SpectrumIdentificationListPtr > spectrumIdentificationList
ProteinDetectionListPtr proteinDetectionListPtr
Implementation of AnalysisProtocolCollectionType from the mzIdentML schema.
std::vector< ProteinDetectionProtocolPtr > proteinDetectionProtocol
std::vector< SpectrumIdentificationProtocolPtr > spectrumIdentificationProtocol
Implementation of AnalysisSampleCollectionType from mzIdentML schema.
Implementation of AnalysisSoftwareType from the mzIdentML schema.
AnalysisSoftware(const std::string &id_="", const std::string &name_="")
Implementation for the BibliographicReferenceType tag in the mzIdentML schema.
Definition IdentData.hpp:96
Implementation of ContactType from mzIdentML.
virtual bool empty() const
Contact(const std::string &id_="", const std::string &name_="")
Implementation of ContactRoleType from the mzIdentML schema.
ContactRole(CVID role_=CVID_Unknown, const ContactPtr &contactPtr_=ContactPtr())
Implementation of DBSequenceType from the mzIdentML schema.
SearchDatabasePtr searchDatabasePtr
DBSequence(const std::string id_="", const std::string name_="")
Implementation of DataCollectionType from the mzIdentML schema.
Implementation of DatabaseTranslationType from the mzIdentML schema.
std::vector< TranslationTablePtr > translationTable
Implementation of EnzymeType from the mzIdentML schema.
Enzyme(const std::string &id="", const std::string &name="")
proteome::Digestion::Specificity terminalSpecificity
ParamContainer enzymeName
Implementation of EnzymesType from the mzIdentML schema.
std::vector< EnzymePtr > enzymes
boost::logic::tribool independent
Implementation of FilterType from the mzIdentML schema.
ParamContainer exclude
ParamContainer filterType
ParamContainer include
Implementation of FragmentArrayType from the mzIdentML schema.
std::vector< double > values
Implementation of the MzIdentMLType from the mzIdentML schema.
SequenceCollection sequenceCollection
DataCollection dataCollection
AnalysisProtocolCollection analysisProtocolCollection
std::vector< AnalysisSoftwarePtr > analysisSoftwareList
std::vector< ContactPtr > auditCollection
const std::string & version() const
returns the version of this mzIdentML document; for a document created programmatically,...
IdentData(const std::string &id_="", const std::string &creationDate_="")
std::vector< BibliographicReferencePtr > bibliographicReference
AnalysisSampleCollection analysisSampleCollection
AnalysisCollection analysisCollection
Parent class representing extensions of the IdentifiableType from the mzIdentML schema.
Definition IdentData.hpp:65
virtual bool empty() const
Identifiable(const std::string &id_="", const std::string &name_="")
Parent class of all Identifiable objects that have ParamGroups.
Definition IdentData.hpp:80
IdentifiableParamContainer(const std::string &id_="", const std::string &name_="")
Implementation of the InputsType from the mzIdentML schema.
std::vector< SourceFilePtr > sourceFile
std::vector< SearchDatabasePtr > searchDatabase
std::vector< SpectraDataPtr > spectraData
Implementation of IonTypeType from the mzIdentML schema.
std::vector< int > index
std::vector< FragmentArrayPtr > fragmentArray
Implementation of MassTableType from the mzIdentML schema.
std::vector< ResiduePtr > residues
std::vector< AmbiguousResiduePtr > ambiguousResidue
std::vector< int > msLevel
MassTable(const std::string id="")
Implementation of MeasureType from the mzIdentML schema.
Measure(const std::string id="", const std::string name="")
Implementation of ModificationType from the mzIdentML schema.
std::vector< char > residues
Implementation of AbstractOrganizationType from the mzIdentML schema.
Organization(const std::string &id_="", const std::string &name_="")
boost::shared_ptr< Organization > parent
virtual bool empty() const
Implementation of PeptideEvidenceType from the mzIdentML schema.
PeptideEvidence(const std::string &id="", const std::string &name="")
TranslationTablePtr translationTablePtr
Implementation of PeptideType from the mzIdentML schema.
std::vector< ModificationPtr > modification
std::vector< SubstitutionModificationPtr > substitutionModification
Peptide(const std::string &id="", const std::string &name="")
Implementation of PeptideHypothesisType from the mzIdentML schema.
PeptideEvidencePtr peptideEvidencePtr
std::vector< SpectrumIdentificationItemPtr > spectrumIdentificationItemPtr
Implementation of PersonType from the mzIdentML schema.
Person(const std::string &id_="", const std::string &name_="")
virtual bool empty() const
std::vector< OrganizationPtr > affiliations
Implementation of ProteinAmbiguityGroupType from the mzIdentML schema.
std::vector< ProteinDetectionHypothesisPtr > proteinDetectionHypothesis
ProteinAmbiguityGroup(const std::string &id_="", const std::string &name_="")
Implementation of ProteinDetectionType from the mzIdentML schema.
std::vector< SpectrumIdentificationListPtr > inputSpectrumIdentifications
ProteinDetection(const std::string id_="", const std::string name_="")
ProteinDetectionProtocolPtr proteinDetectionProtocolPtr
ProteinDetectionListPtr proteinDetectionListPtr
Implementation of ProteinDetectionHypothesisType from the mzIdentML schema.
std::vector< PeptideHypothesis > peptideHypothesis
ProteinDetectionHypothesis(const std::string &id_="", const std::string &name_="")
Implementation of ProteinDetectionListType from the mzIdentML schema.
std::vector< ProteinAmbiguityGroupPtr > proteinAmbiguityGroup
ProteinDetectionList(const std::string &id_="", const std::string &name_="")
Implementation of ProteinDetectionProtocolType from the mzIdentML schema.
ProteinDetectionProtocol(const std::string &id_="", const std::string &name_="")
Implementation of ProviderType from the mzIdentML schema.
Provider(const std::string id_="", const std::string name_="")
ContactRolePtr contactRolePtr
AnalysisSoftwarePtr analysisSoftwarePtr
Implementation of ResidueType from the mzIdentML schema.
Implementation of the SampleType from the mzIdentML schema.
Sample(const std::string &id_="", const std::string &name_="")
std::vector< boost::shared_ptr< Sample > > subSamples
std::vector< ContactRolePtr > contactRole
Implementation of SearchDatabaseType from the mzIdentML schema.
SearchDatabase(const std::string &id_="", const std::string &name_="")
Implementation of SearchModificationType from the mzIdentML schema.
Implementation of SequenceCollectionType from the mzIdentML schema.
std::vector< DBSequencePtr > dbSequences
std::vector< PeptideEvidencePtr > peptideEvidence
std::vector< PeptidePtr > peptides
Implementation of SourceFileType from the mzIdentML schema.
std::vector< std::string > externalFormatDocumentation
Implementation of SpectraDataType from the mzIdentML schema.
SpectraData(const std::string id="", const std::string name="")
std::vector< std::string > externalFormatDocumentation
Implementation of SpectrumIdentificationType from the mzIdentML schema.
std::vector< SpectraDataPtr > inputSpectra
SpectrumIdentification(const std::string &id_="", const std::string &name_="")
SpectrumIdentificationListPtr spectrumIdentificationListPtr
std::vector< SearchDatabasePtr > searchDatabase
SpectrumIdentificationProtocolPtr spectrumIdentificationProtocolPtr
Implementation of SpectrumIdentificationItemType from the mzIdentML schema.
SpectrumIdentificationItem(const std::string &id="", const std::string &name="")
std::vector< PeptideEvidencePtr > peptideEvidencePtr
std::vector< IonTypePtr > fragmentation
Implementation of SpectrumIdentificationListType from the mzIdentML schema.
std::vector< SpectrumIdentificationResultPtr > spectrumIdentificationResult
std::vector< MeasurePtr > fragmentationTable
SpectrumIdentificationList(const std::string &id_="", const std::string &name_="")
Implementation of SpectrumIdentificationProtocolType from the mzIdentML schema.
SpectrumIdentificationProtocol(const std::string &id_="", const std::string &name_="")
std::vector< SearchModificationPtr > modificationParams
Implementation of SpectrumIdentificationResultType from the mzIdentML schema.
SpectrumIdentificationResult(const std::string &id_="", const std::string &name_="")
std::vector< SpectrumIdentificationItemPtr > spectrumIdentificationItem
Implementation of SubstitutionModificationType from the mzIdentML schema.
Implementation of TranslationTableType from the mzIdentML schema.
TranslationTable(const std::string &id="", const std::string &name="")