OpenMS  2.6.0
ProteinResolver.h
Go to the documentation of this file.
1 // --------------------------------------------------------------------------
2 // OpenMS -- Open-Source Mass Spectrometry
3 // --------------------------------------------------------------------------
4 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
5 // ETH Zurich, and Freie Universitaet Berlin 2002-2020.
6 //
7 // This software is released under a three-clause BSD license:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of any author or any participating institution
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 // For a full list of authors, refer to the file AUTHORS.
17 // --------------------------------------------------------------------------
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
22 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // --------------------------------------------------------------------------
31 // $Maintainer: Timo Sachsenberg $
32 // $Authors: David Wojnar $
33 // --------------------------------------------------------------------------
34 
35 #pragma once
36 
43 
44 namespace OpenMS
45 {
56  class OPENMS_DLLAPI ProteinResolver :
57  public DefaultParamHandler
58  {
59 
60 public:
61 
62  //default constructor
64 
65  //copy constructor
66  ProteinResolver(const ProteinResolver & rhs);
67 
68  //assignment operator
69  ProteinResolver & operator=(const ProteinResolver & rhs);
70 
71  //destructor
72  ~ProteinResolver() override;
73 
74 
75  struct ProteinEntry;
76  struct PeptideEntry;
77  struct ISDGroup;
78  struct MSDGroup;
79  struct ResolverResult;
80 
82  struct ProteinEntry
83  {
84  std::list<PeptideEntry *> peptides;
85  bool traversed;
87  enum type {primary, secondary, primary_indistinguishable, secondary_indistinguishable} protein_type;
88  double weight; //monoisotopic
89  float coverage; //in percent
90  //if Protein is indistinguishable all his fellows are in the list indis
91  std::list<ProteinEntry *> indis;
93  Size msd_group; //index
94  Size isd_group; //index
96  };
97 
99  struct PeptideEntry
100  {
101  std::list<ProteinEntry *> proteins;
102  bool traversed;
107  Size msd_group; //index
108  Size isd_group; //index
110  float intensity;
112  };
113 
115  struct MSDGroup
116  {
117  std::list<ProteinEntry *> proteins;
118  std::list<PeptideEntry *> peptides;
124  float intensity;
125  };
126 
127  struct ISDGroup
128  {
129  std::list<ProteinEntry *> proteins;
130  std::list<PeptideEntry *> peptides;
132  std::list<Size> msd_groups;
133  };
134 
136  {
138  std::vector<ISDGroup> * isds;
139  std::vector<MSDGroup> * msds;
140  std::vector<ProteinEntry> * protein_entries;
141  std::vector<PeptideEntry> * peptide_entries;
142  std::vector<Size> * reindexed_peptides;
143  std::vector<Size> * reindexed_proteins;
144  enum type {PeptideIdent, Consensus} input_type;
145  std::vector<PeptideIdentification> * peptide_identification;
147  };
148 
156  void resolveConsensus(ConsensusMap & consensus);
157 
165  void resolveID(std::vector<PeptideIdentification> & peptide_identifications);
166 
167  // /**
168  // @brief NOT IMPLEMENTED YET
169 
170  // @param protein_nodes
171  // @param peptide_nodes
172  // @param reindexed_proteins
173  // @param reindexed_peptides
174  // @param peptide_identifications
175  // @param output
176  // */
177  // void writeProteinsAndPeptidesmzTab(std::vector<ProteinEntry>& protein_nodes, std::vector<PeptideEntry>& peptide_nodes, std::vector<Size>& reindexed_proteins, std::vector<Size>& reindexed_peptides, std::vector<PeptideIdentification>& peptide_identifications, String& output );
178  // /**
179  // @brief Writing peptide table into text file
180 
181  // @param peptides
182  // @param reindexed_peptides
183  // @param identifications
184  // @param output_file
185  // */
186  // void writePeptideTable(std::vector<PeptideEntry> & peptides, std::vector<Size> & reindexed_peptides, std::vector<PeptideIdentification> & identifications, String & output_file); // not implemented
187  // /**
188  // @brief Writing peptide table into text file
189 
190  // @param peptides
191  // @param reindexed_peptides
192  // @param consensus
193  // @param output
194  // */
195  // void writePeptideTable(std::vector<PeptideEntry> & peptides, std::vector<Size> & reindexed_peptides, ConsensusMap & consensus, String & output_file); // not implemented
196  // /**
197  // @brief Writing protein table into text file
198 
199  // @param proteins
200  // @param reindexed_proteins
201  // @param output_file
202  // */
203  // void writeProteinTable(std::vector<ProteinEntry> & proteins, std::vector<Size> & reindexed_proteins, String & output_file); // not implemented
204  // /**
205  // @brief Writing protein groups into text file
206 
207  // @param isd_groups ISD groups
208  // @param msd_groups MSD groups
209  // @param output_file Path of output file
210  // */
211  // void writeProteinGroups(std::vector<ISDGroup> & isd_groups, std::vector<MSDGroup> & msd_groups, String & output_file); // not implemented
212 
219  void countTargetDecoy(std::vector<MSDGroup> & msd_groups, ConsensusMap & consensus);
220 
227  void countTargetDecoy(std::vector<MSDGroup> & msd_groups, std::vector<PeptideIdentification> & peptide_nodes);
228 
229  void clearResult();
230 
231  void setProteinData(std::vector<FASTAFile::FASTAEntry> & protein_data);
232 
233  const std::vector<ResolverResult> & getResults();
234 
236  static const PeptideIdentification & getPeptideIdentification(const ConsensusMap & consensus, const PeptideEntry * peptide);
237  static const PeptideHit & getPeptideHit(const ConsensusMap & consensus, const PeptideEntry * peptide);
238  static const PeptideIdentification & getPeptideIdentification(const std::vector<PeptideIdentification> & peptide_nodes, const PeptideEntry * peptide);
239  static const PeptideHit & getPeptideHit(const std::vector<PeptideIdentification> & peptide_nodes, const PeptideEntry * peptide);
240 
241 private:
242 
243  std::vector<ResolverResult> resolver_result_;
244  std::vector<FASTAFile::FASTAEntry> protein_data_;
245 
246  void computeIntensityOfMSD_(std::vector<MSDGroup> & msd_groups);
247 
249  void traverseProtein_(ProteinEntry * prot_node, MSDGroup & group);
250  void traversePeptide_(PeptideEntry * pep_node, MSDGroup & group);
252  Size findPeptideEntry_(String seq, std::vector<PeptideEntry> & nodes);
254  Size binarySearchNodes_(String & seq, std::vector<PeptideEntry> & nodes, Size start, Size end);
256  Size includeMSMSPeptides_(std::vector<PeptideIdentification> & peptide_identifications, std::vector<PeptideEntry> & peptide_nodes);
259  Size includeMSMSPeptides_(ConsensusMap & consensus, std::vector<PeptideEntry> & peptide_nodes);
261  void reindexingNodes_(std::vector<MSDGroup> & msd_groups, std::vector<Size> & reindexed_proteins, std::vector<Size> & reindexed_peptides);
263  void primaryProteins_(std::vector<PeptideEntry> & peptide_nodes, std::vector<Size> & reindexed_peptides);
264  void buildingMSDGroups_(std::vector<MSDGroup> & msd_groups, std::vector<ISDGroup> & isd_groups);
265  void buildingISDGroups_(std::vector<ProteinEntry> & protein_nodes, std::vector<PeptideEntry> & peptide_nodes,
266  std::vector<ISDGroup> & isd_groups);
267  // disabled/buggy
268  //ProteinResolver::indistinguishableProteins(vector<MSDGroup>& msd_groups);
269 
270  }; // class
271 
272 } // namespace
273 
DefaultParamHandler.h
OpenMS::FileTypes::IDXML
OpenMS identification format (.idXML)
Definition: FileTypes.h:66
OpenMS::PeptideHit::getCharge
Int getCharge() const
returns the charge of the peptide
ConsensusXMLFile.h
MzTabFile.h
OpenMS::TOPPBase
Base class for TOPP applications.
Definition: TOPPBase.h:144
OpenMS::ExperimentalDesign
Representation of an experimental design in OpenMS. Instances can be loaded with the ExperimentalDesi...
Definition: ExperimentalDesign.h:243
OpenMS::ExperimentalDesignFile::load
static ExperimentalDesign load(const String &tsv_file, bool require_spectra_files)
Loads an experimental design from a tabular separated file.
FileHandler.h
FileTypes.h
OpenMS::MzTabFile
File adapter for MzTab files.
Definition: MzTabFile.h:58
TextFile.h
OpenMS::PeptideProteinResolution
Resolves shared peptides based on protein scores.
Definition: PeptideProteinResolution.h:86
OpenMS::PeptideAndProteinQuant::Statistics
Statistics for processing summary.
Definition: PeptideAndProteinQuant.h:117
OpenMS::ProteinResolver::ProteinEntry
represents a protein from FASTA file
Definition: ProteinResolver.h:82
OpenMS::String::QuotingMethod
QuotingMethod
How to handle embedded quotes when quoting strings.
Definition: String.h:82
OpenMS::ProteinResolver::ProteinEntry::indis
std::list< ProteinEntry * > indis
Definition: ProteinResolver.h:91
OpenMS::ProteinResolver::ResolverResult
Definition: ProteinResolver.h:135
OpenMS::ProteinResolver::ProteinEntry::peptides
std::list< PeptideEntry * > peptides
Definition: ProteinResolver.h:84
OpenMS::ProteinIdentification::getIndistinguishableProteins
const std::vector< ProteinGroup > & getIndistinguishableProteins() const
Returns the indistinguishable proteins.
OpenMS::ProteinResolver::ResolverResult::identifier
String identifier
Definition: ProteinResolver.h:137
OpenMS::ProteinResolver::setProteinData
void setProteinData(std::vector< FASTAFile::FASTAEntry > &protein_data)
OpenMS::ProteinResolver::ResolverResult::peptide_entries
std::vector< PeptideEntry > * peptide_entries
Definition: ProteinResolver.h:141
OpenMS::ProteinResolver::PeptideEntry::peptide_hit
Size peptide_hit
Definition: ProteinResolver.h:105
OpenMS::PeptideHit::getSequence
const AASequence & getSequence() const
returns the peptide sequence without trailing or following spaces
ExperimentalDesignFile.h
OpenMS::SVOutStream::modifyStrings
bool modifyStrings(bool modify)
Switch modification of strings (quoting/replacing of separators) on/off.
OpenMS::FASTAFile::FASTAEntry::identifier
String identifier
Definition: FASTAFile.h:78
OpenMS::ProteinResolver::PeptideEntry::traversed
bool traversed
Definition: ProteinResolver.h:102
OpenMS::ProteinResolver::ResolverResult::msds
std::vector< MSDGroup > * msds
Definition: ProteinResolver.h:139
OpenMS::String::substitute
String & substitute(char from, char to)
Replaces all occurrences of the character from by the character to.
OpenMS::FASTAFile
This class serves for reading in and writing FASTA files.
Definition: FASTAFile.h:64
OpenMS::ProteinResolver::ProteinEntry::weight
double weight
Definition: ProteinResolver.h:88
OpenMS::ProteinResolver::resolver_result_
std::vector< ResolverResult > resolver_result_
Definition: ProteinResolver.h:243
OpenMS::String::NONE
Definition: String.h:82
OpenMS::ProteinResolver::ResolverResult::input_type
enum OpenMS::ProteinResolver::ResolverResult::type input_type
OpenMS::String
A more convenient string class.
Definition: String.h:59
OpenMS::ProteinResolver::MSDGroup
representation of an msd group. Contains peptides, proteins and a pointer to its ISD group
Definition: ProteinResolver.h:115
OpenMS::ProteinResolver::PeptideEntry::intensity
float intensity
Definition: ProteinResolver.h:110
OpenMS::ProteinResolver::getPeptideIdentification
static const PeptideIdentification & getPeptideIdentification(const ConsensusMap &consensus, const PeptideEntry *peptide)
overloaded functions – return a const reference to a PeptideIdentification object or a peptideHit eit...
ConsensusMap.h
OpenMS::QuantitativeExperimentalDesign::applyDesign2Resolver
void applyDesign2Resolver(ProteinResolver &resolver, TextFile &file, StringList &fileNames)
xxxxxxx
OpenMS::ProteinResolver::MSDGroup::number_of_target
Size number_of_target
Definition: ProteinResolver.h:122
OpenMS::TextFile
This class provides some basic file handling methods for text files.
Definition: TextFile.h:46
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:127
OpenMS::AASequence::getMonoWeight
double getMonoWeight(Residue::ResidueType type=Residue::Full, Int charge=0) const
IdXMLFile.h
FeatureXMLFile.h
OpenMS::ExperimentalDesign::getNumberOfSamples
unsigned getNumberOfSamples() const
OpenMS::ProteinResolver::ProteinEntry::fasta_entry
FASTAFile::FASTAEntry * fasta_entry
Definition: ProteinResolver.h:86
OpenMS::ProteinIdentification::findHit
std::vector< ProteinHit >::iterator findHit(const String &accession)
Finds a protein hit by accession (returns past-the-end iterator if not found)
OpenMS::MzTab
Data model of MzTab files. Please see the official MzTab specification at https://code....
Definition: MzTab.h:800
OpenMS::Param::getValue
const DataValue & getValue(const String &key) const
Returns a value of a parameter.
OpenMS::AASequence::toString
String toString() const
returns the peptide as string with modifications embedded in brackets
OpenMS::ProteinResolver::ProteinEntry::number_of_experimental_peptides
Size number_of_experimental_peptides
Definition: ProteinResolver.h:95
OpenMS::PeptideAndProteinQuant::Statistics::n_samples
Size n_samples
number of samples (or assays in mzTab terms)
Definition: PeptideAndProteinQuant.h:120
OpenMS::String::DOUBLE
Definition: String.h:82
OpenMS::AASequence::toUnmodifiedString
String toUnmodifiedString() const
returns the peptide as string without any modifications or (e.g., "PEPTIDER")
PeptideAndProteinQuant.h
OpenMS::PeptideAndProteinQuant::getPeptideResults
const PeptideQuant & getPeptideResults()
Get peptide abundance data.
OpenMS::ProteinIdentification
Representation of a protein identification run.
Definition: ProteinIdentification.h:70
OpenMS::FASTAFile::FASTAEntry
FASTA entry type (identifier, description and sequence)
Definition: FASTAFile.h:76
OpenMS::PeptideAndProteinQuant::getStatistics
const Statistics & getStatistics()
Get summary statistics.
OpenMS::ProteinResolver::MSDGroup::isd_group
ISDGroup * isd_group
Definition: ProteinResolver.h:120
OpenMS::PeptideAndProteinQuant::quantifyPeptides
void quantifyPeptides(const std::vector< PeptideIdentification > &peptides=std::vector< PeptideIdentification >())
Compute peptide abundances.
OpenMS::ProteinResolver::ProteinEntry::traversed
bool traversed
Definition: ProteinResolver.h:85
OpenMS::DefaultParamHandler
A base class for all classes handling default parameters.
Definition: DefaultParamHandler.h:92
OpenMS::PeptideIdentification::getHits
const std::vector< PeptideHit > & getHits() const
returns the peptide hits as const
OpenMS::ExperimentalDesign::fromConsensusMap
static ExperimentalDesign fromConsensusMap(const ConsensusMap &c)
Extract experimental design from consensus map.
OpenMS::IdXMLFile::load
void load(const String &filename, std::vector< ProteinIdentification > &protein_ids, std::vector< PeptideIdentification > &peptide_ids)
Loads the identifications of an idXML file without identifier.
OpenMS::Exception::InvalidParameter
Exception indicating that an invalid parameter was handed over to an algorithm.
Definition: Exception.h:347
OpenMS::ListUtils::concatenate
static String concatenate(const std::vector< T > &container, const String &glue="")
Concatenates all elements of the container and puts the glue string between elements.
Definition: ListUtils.h:193
OpenMS::MzTab::exportConsensusMapToMzTab
static MzTab exportConsensusMapToMzTab(const ConsensusMap &consensus_map, const String &filename, const bool first_run_inference_only, const bool export_unidentified_features, const bool export_unassigned_ids, const bool export_subfeatures, const bool export_empty_pep_ids=false, const String &title="ConsensusMap export from OpenMS")
export linked peptide features aka consensus map
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:46
OpenMS::ProteinResolver::PeptideEntry
represents a peptide. First in silico. If experimental is set to true it is MS/MS derived.
Definition: ProteinResolver.h:99
OpenMS::ProteinResolver::ProteinEntry::msd_group
Size msd_group
Definition: ProteinResolver.h:93
OpenMS::FileTypes::FEATUREXML
OpenMS feature file (.featureXML)
Definition: FileTypes.h:65
OpenMS::PeptideAndProteinQuant::SampleAbundances
std::map< UInt64, double > SampleAbundances
Mapping: sample ID -> abundance.
Definition: PeptideAndProteinQuant.h:59
OpenMS::ProteinResolver::MSDGroup::number_of_decoy
Size number_of_decoy
Definition: ProteinResolver.h:121
OpenMS::PeptideAndProteinQuant::readQuantData
void readQuantData(FeatureMap &features, const ExperimentalDesign &ed)
Read quantitative data from a feature map.
FASTAFile.h
OpenMS::SVOutStream
Stream class for writing to comma/tab/...-separated values files.
Definition: SVOutStream.h:54
OpenMS::ProteinResolver::PeptideEntry::experimental
bool experimental
Definition: ProteinResolver.h:109
OpenMS::ProteinResolver::getResults
const std::vector< ResolverResult > & getResults()
OpenMS::ConsensusMap::getProteinIdentifications
const std::vector< ProteinIdentification > & getProteinIdentifications() const
non-mutable access to the protein identifications
OpenMS::ProteinIdentification::getHits
const std::vector< ProteinHit > & getHits() const
Returns the protein hits.
OpenMS::ProteinResolver::ResolverResult::isds
std::vector< ISDGroup > * isds
Definition: ProteinResolver.h:138
OpenMS::ProteinResolver::protein_data_
std::vector< FASTAFile::FASTAEntry > protein_data_
Definition: ProteinResolver.h:244
OpenMS::FeatureXMLFile::load
void load(const String &filename, FeatureMap &feature_map)
loads the file with name filename into map and calls updateRanges().
FeatureMap.h
ProteinIdentification.h
OpenMS::ProteinResolver::ResolverResult::PeptideIdent
Definition: ProteinResolver.h:144
OpenMS::FileTypes::Type
Type
Actual file types enum.
Definition: FileTypes.h:58
OpenMS::QuantitativeExperimentalDesign
Merge files according to experimental design.
Definition: QuantitativeExperimentalDesign.h:56
QuantitativeExperimentalDesign.h
OpenMS::ProteinResolver::ProteinEntry::index
Size index
Definition: ProteinResolver.h:92
OpenMS::ProteinResolver::ResolverResult::reindexed_peptides
std::vector< Size > * reindexed_peptides
Definition: ProteinResolver.h:142
OpenMS::MzTabFile::store
void store(const String &filename, const MzTab &mz_tab) const
OpenMS::FileHandler::getType
static FileTypes::Type getType(const String &filename)
Tries to determine the file type (by name or content)
OpenMS::DefaultParamHandler::setParameters
void setParameters(const Param &param)
Sets the parameters.
MzTab.h
OpenMS::String::toQString
QString toQString() const
Conversion to Qt QString.
OpenMS::DefaultParamHandler::getParameters
const Param & getParameters() const
Non-mutable access to the parameters.
OpenMS::Logger::LogStream
Log Stream Class.
Definition: LogStream.h:311
OpenMS::ConsensusMap
A container for consensus elements.
Definition: ConsensusMap.h:80
OpenMS::StringList
std::vector< String > StringList
Vector of String.
Definition: ListUtils.h:70
OpenMS::ConsensusXMLFile::load
void load(const String &filename, ConsensusMap &map)
Loads a consensus map from file and calls updateRanges.
OpenMS::String::ESCAPE
Definition: String.h:82
OpenMS::ProteinResolver::ISDGroup::msd_groups
std::list< Size > msd_groups
Definition: ProteinResolver.h:132
OpenMS::ProteinResolver::PeptideEntry::sequence
String sequence
Definition: ProteinResolver.h:103
SVOutStream.h
main
int main(int argc, const char **argv)
Definition: INIFileEditor.cpp:73
ExperimentalDesign.h
OpenMS::PeptideProteinResolution::buildGraph
void buildGraph(ProteinIdentification &protein, const std::vector< PeptideIdentification > &peptides, bool skip_sort=false)
OpenMS::ProteinResolver::MSDGroup::index
Size index
Definition: ProteinResolver.h:119
OpenMS::ProteinResolver::ResolverResult::type
type
Definition: ProteinResolver.h:144
OpenMS::ProteinResolver::MSDGroup::proteins
std::list< ProteinEntry * > proteins
Definition: ProteinResolver.h:117
OpenMS::ConsensusMap::getColumnHeaders
const ColumnHeaders & getColumnHeaders() const
Non-mutable access to the file descriptions.
OpenMS::ProteinResolver::ProteinEntry::isd_group
Size isd_group
Definition: ProteinResolver.h:94
OpenMS::ProteinResolver::PeptideEntry::msd_group
Size msd_group
Definition: ProteinResolver.h:107
OpenMS::Param::update
bool update(const Param &p_outdated, const bool add_unknown=false)
Rescue parameter values from p_outdated to current param.
OpenMS::Exception::RequiredParameterNotGiven
A required parameter was not given.
Definition: TOPPBase.h:111
OpenMS::PeptideAndProteinQuant::getProteinResults
const ProteinQuant & getProteinResults()
Get protein abundance data.
OpenMS::FeatureMap
A container for features.
Definition: FeatureMap.h:97
OpenMS::PeptideIdentification
Represents the peptide hits for a spectrum.
Definition: PeptideIdentification.h:62
OpenMS::PeptideIdentification::getMZ
double getMZ() const
returns the MZ of the MS2 spectrum
OpenMS::FASTAFile::load
static void load(const String &filename, std::vector< FASTAEntry > &data)
loads a FASTA file given by 'filename' and stores the information in 'data'
OpenMS::ProteinResolver::ResolverResult::peptide_identification
std::vector< PeptideIdentification > * peptide_identification
Definition: ProteinResolver.h:145
OpenMS::PeptideHit::getScore
double getScore() const
returns the PSM score
OpenMS::ProteinResolver::PeptideEntry::origin
String origin
Definition: ProteinResolver.h:111
OpenMS::ProteinResolver::MSDGroup::peptides
std::list< PeptideEntry * > peptides
Definition: ProteinResolver.h:118
OpenMS::ExperimentalDesign::fromFeatureMap
static ExperimentalDesign fromFeatureMap(const FeatureMap &f)
Extract experimental design from feature map.
OpenMS::ProteinResolver::ResolverResult::consensus_map
ConsensusMap * consensus_map
Definition: ProteinResolver.h:146
OpenMS::FeatureXMLFile
This class provides Input/Output functionality for feature maps.
Definition: FeatureXMLFile.h:68
float
OpenMS::ProteinResolver::resolveConsensus
void resolveConsensus(ConsensusMap &consensus)
Computing protein groups from peptide identifications OR consensus map.
OpenMS::ProteinResolver::ResolverResult::protein_entries
std::vector< ProteinEntry > * protein_entries
Definition: ProteinResolver.h:140
OpenMS::Param
Management and storage of parameters / INI files.
Definition: Param.h:73
OpenMS::AASequence
Representation of a peptide/protein sequence.
Definition: AASequence.h:111
OpenMS::ExperimentalDesign::fromIdentifications
static ExperimentalDesign fromIdentifications(const std::vector< ProteinIdentification > &proteins)
Extract experimental design from identifications.
OpenMS::ProteinResolver::ISDGroup
Definition: ProteinResolver.h:127
IDFilter.h
OpenMS::ProteinResolver::PeptideEntry::peptide_identification
Size peptide_identification
Definition: ProteinResolver.h:104
OpenMS::ProteinResolver::getPeptideHit
static const PeptideHit & getPeptideHit(const ConsensusMap &consensus, const PeptideEntry *peptide)
ProteinResolver.h
OpenMS::Exception::MissingInformation
Not all required information provided.
Definition: Exception.h:195
OPENMS_LOG_INFO
#define OPENMS_LOG_INFO
Macro if a information, e.g. a status should be reported.
Definition: LogStream.h:465
PeptideIdentification.h
OpenMS::ProteinResolver::ProteinEntry::coverage
float coverage
Definition: ProteinResolver.h:89
OpenMS::PeptideAndProteinQuant::ProteinQuant
std::map< String, ProteinData > ProteinQuant
Mapping: protein accession -> protein data.
Definition: PeptideAndProteinQuant.h:114
OpenMS::ProteinResolver::ResolverResult::reindexed_proteins
std::vector< Size > * reindexed_proteins
Definition: ProteinResolver.h:143
OpenMS::ProteinResolver
Helper class for peptide and protein quantification based on feature data annotated with IDs.
Definition: ProteinResolver.h:56
OpenMS::TextFile::load
void load(const String &filename, bool trim_lines=false, Int first_n=-1, bool skip_empty_lines=false)
Loads data from a text file.
OpenMS::ProteinResolver::ProteinEntry::type
type
Definition: ProteinResolver.h:87
PeptideProteinResolution.h
OpenMS::ProteinResolver::PeptideEntry::isd_group
Size isd_group
Definition: ProteinResolver.h:108
TOPPBase.h
OpenMS::FeatureMap::getProteinIdentifications
const std::vector< ProteinIdentification > & getProteinIdentifications() const
non-mutable access to the protein identifications
OpenMS::PeptideAndProteinQuant::quantifyProteins
void quantifyProteins(const ProteinIdentification &proteins=ProteinIdentification())
Compute protein abundances.
OpenMS::ConsensusXMLFile
This class provides Input functionality for ConsensusMaps and Output functionality for alignments and...
Definition: ConsensusXMLFile.h:62
OpenMS::IdXMLFile
Used to load and store idXML files.
Definition: IdXMLFile.h:63
OpenMS::PeptideIdentification::getRT
double getRT() const
returns the RT of the MS2 spectrum where the identification occurred
OpenMS::PeptideAndProteinQuant::annotateQuantificationsToProteins
static void annotateQuantificationsToProteins(const ProteinQuant &protein_quants, ProteinIdentification &proteins, const UInt n_samples, bool remove_unquantified=true)
Annotate protein quant results as meta data to protein ids.
OpenMS::ConsensusMap::ColumnHeaders
std::map< UInt64, ColumnHeader > ColumnHeaders
Definition: ConsensusMap.h:168
OpenMS::ProteinIdentification::ProteinGroup
Bundles multiple (e.g. indistinguishable) proteins in a group.
Definition: ProteinIdentification.h:117
OpenMS::ProteinResolver::MSDGroup::number_of_target_plus_decoy
Size number_of_target_plus_decoy
Definition: ProteinResolver.h:123
OpenMS::PeptideAndProteinQuant::PeptideQuant
std::map< AASequence, PeptideData > PeptideQuant
Mapping: peptide sequence (modified) -> peptide data.
Definition: PeptideAndProteinQuant.h:87
OpenMS::PeptideHit
Representation of a peptide hit.
Definition: PeptideHit.h:55
OpenMS::PeptideAndProteinQuant
Helper class for peptide and protein quantification based on feature data annotated with IDs.
Definition: PeptideAndProteinQuant.h:53
OpenMS::ProteinResolver::resolveID
void resolveID(std::vector< PeptideIdentification > &peptide_identifications)
Computing protein groups from peptide identifications OR consensus map.