OpenMS  3.0.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-2022.
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 {
54  class OPENMS_DLLAPI ProteinResolver :
55  public DefaultParamHandler
56  {
57 
58 public:
59 
60  //default constructor
62 
63  //copy constructor
64  ProteinResolver(const ProteinResolver & rhs);
65 
66  //assignment operator
67  ProteinResolver & operator=(const ProteinResolver & rhs);
68 
69  //destructor
70  ~ProteinResolver() override;
71 
72 
73  struct ProteinEntry;
74  struct PeptideEntry;
75  struct ISDGroup;
76  struct MSDGroup;
77  struct ResolverResult;
78 
80  struct ProteinEntry
81  {
82  std::list<PeptideEntry *> peptides;
83  bool traversed;
85  enum type {primary, secondary, primary_indistinguishable, secondary_indistinguishable} protein_type;
86  double weight; //monoisotopic
87  float coverage; //in percent
88  //if Protein is indistinguishable all his fellows are in the list indis
89  std::list<ProteinEntry *> indis;
91  Size msd_group; //index
92  Size isd_group; //index
94  };
95 
97  struct PeptideEntry
98  {
99  std::list<ProteinEntry *> proteins;
100  bool traversed;
105  Size msd_group; //index
106  Size isd_group; //index
108  float intensity;
110  };
111 
113  struct MSDGroup
114  {
115  std::list<ProteinEntry *> proteins;
116  std::list<PeptideEntry *> peptides;
122  float intensity;
123  };
124 
125  struct ISDGroup
126  {
127  std::list<ProteinEntry *> proteins;
128  std::list<PeptideEntry *> peptides;
130  std::list<Size> msd_groups;
131  };
132 
134  {
136  std::vector<ISDGroup> * isds;
137  std::vector<MSDGroup> * msds;
138  std::vector<ProteinEntry> * protein_entries;
139  std::vector<PeptideEntry> * peptide_entries;
140  std::vector<Size> * reindexed_peptides;
141  std::vector<Size> * reindexed_proteins;
142  enum type {PeptideIdent, Consensus} input_type;
143  std::vector<PeptideIdentification> * peptide_identification;
145  };
146 
154  void resolveConsensus(ConsensusMap & consensus);
155 
163  void resolveID(std::vector<PeptideIdentification> & peptide_identifications);
164 
165  // /**
166  // @brief NOT IMPLEMENTED YET
167 
168  // @param protein_nodes
169  // @param peptide_nodes
170  // @param reindexed_proteins
171  // @param reindexed_peptides
172  // @param peptide_identifications
173  // @param output
174  // */
175  // 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 );
176  // /**
177  // @brief Writing peptide table into text file
178 
179  // @param peptides
180  // @param reindexed_peptides
181  // @param identifications
182  // @param output_file
183  // */
184  // void writePeptideTable(std::vector<PeptideEntry> & peptides, std::vector<Size> & reindexed_peptides, std::vector<PeptideIdentification> & identifications, String & output_file); // not implemented
185  // /**
186  // @brief Writing peptide table into text file
187 
188  // @param peptides
189  // @param reindexed_peptides
190  // @param consensus
191  // @param output
192  // */
193  // void writePeptideTable(std::vector<PeptideEntry> & peptides, std::vector<Size> & reindexed_peptides, ConsensusMap & consensus, String & output_file); // not implemented
194  // /**
195  // @brief Writing protein table into text file
196 
197  // @param proteins
198  // @param reindexed_proteins
199  // @param output_file
200  // */
201  // void writeProteinTable(std::vector<ProteinEntry> & proteins, std::vector<Size> & reindexed_proteins, String & output_file); // not implemented
202  // /**
203  // @brief Writing protein groups into text file
204 
205  // @param isd_groups ISD groups
206  // @param msd_groups MSD groups
207  // @param output_file Path of output file
208  // */
209  // void writeProteinGroups(std::vector<ISDGroup> & isd_groups, std::vector<MSDGroup> & msd_groups, String & output_file); // not implemented
210 
217  void countTargetDecoy(std::vector<MSDGroup> & msd_groups, ConsensusMap & consensus);
218 
225  void countTargetDecoy(std::vector<MSDGroup> & msd_groups, std::vector<PeptideIdentification> & peptide_nodes);
226 
227  void clearResult();
228 
229  void setProteinData(std::vector<FASTAFile::FASTAEntry> & protein_data);
230 
231  const std::vector<ResolverResult> & getResults();
232 
234  static const PeptideIdentification & getPeptideIdentification(const ConsensusMap & consensus, const PeptideEntry * peptide);
235  static const PeptideHit & getPeptideHit(const ConsensusMap & consensus, const PeptideEntry * peptide);
236  static const PeptideIdentification & getPeptideIdentification(const std::vector<PeptideIdentification> & peptide_nodes, const PeptideEntry * peptide);
237  static const PeptideHit & getPeptideHit(const std::vector<PeptideIdentification> & peptide_nodes, const PeptideEntry * peptide);
238 
239 private:
240 
241  std::vector<ResolverResult> resolver_result_;
242  std::vector<FASTAFile::FASTAEntry> protein_data_;
243 
244  void computeIntensityOfMSD_(std::vector<MSDGroup> & msd_groups);
245 
247  void traverseProtein_(ProteinEntry * prot_node, MSDGroup & group);
248  void traversePeptide_(PeptideEntry * pep_node, MSDGroup & group);
250  Size findPeptideEntry_(String seq, std::vector<PeptideEntry> & nodes);
252  Size binarySearchNodes_(String & seq, std::vector<PeptideEntry> & nodes, Size start, Size end);
254  Size includeMSMSPeptides_(std::vector<PeptideIdentification> & peptide_identifications, std::vector<PeptideEntry> & peptide_nodes);
257  Size includeMSMSPeptides_(ConsensusMap & consensus, std::vector<PeptideEntry> & peptide_nodes);
259  void reindexingNodes_(std::vector<MSDGroup> & msd_groups, std::vector<Size> & reindexed_proteins, std::vector<Size> & reindexed_peptides);
261  void primaryProteins_(std::vector<PeptideEntry> & peptide_nodes, std::vector<Size> & reindexed_peptides);
262  void buildingMSDGroups_(std::vector<MSDGroup> & msd_groups, std::vector<ISDGroup> & isd_groups);
263  void buildingISDGroups_(std::vector<ProteinEntry> & protein_nodes, std::vector<PeptideEntry> & peptide_nodes,
264  std::vector<ISDGroup> & isd_groups);
265  // disabled/buggy
266  //ProteinResolver::indistinguishableProteins(vector<MSDGroup>& msd_groups);
267 
268  }; // class
269 
270 } // namespace
271 
DefaultParamHandler.h
OpenMS::FileTypes::IDXML
OpenMS identification format (.idXML)
Definition: FileTypes.h:64
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:147
OpenMS::ExperimentalDesign
Representation of an experimental design in OpenMS. Instances can be loaded with the ExperimentalDesi...
Definition: ExperimentalDesign.h:242
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:55
TextFile.h
OpenMS::PeptideProteinResolution
Resolves shared peptides based on protein scores.
Definition: PeptideProteinResolution.h:79
OpenMS::PeptideAndProteinQuant::Statistics
Statistics for processing summary.
Definition: PeptideAndProteinQuant.h:118
OpenMS::ProteinResolver::ProteinEntry
represents a protein from FASTA file
Definition: ProteinResolver.h:80
OpenMS::String::QuotingMethod
QuotingMethod
How to handle embedded quotes when quoting strings.
Definition: String.h:81
OpenMS::ProteinResolver::ProteinEntry::indis
std::list< ProteinEntry * > indis
Definition: ProteinResolver.h:89
OpenMS::ProteinResolver::ResolverResult
Definition: ProteinResolver.h:133
Size
OpenMS::ProteinResolver::ProteinEntry::peptides
std::list< PeptideEntry * > peptides
Definition: ProteinResolver.h:82
OpenMS::ProteinIdentification::getIndistinguishableProteins
const std::vector< ProteinGroup > & getIndistinguishableProteins() const
Returns the indistinguishable proteins.
OpenMS::ProteinResolver::ResolverResult::identifier
String identifier
Definition: ProteinResolver.h:135
OpenMS::ProteinResolver::setProteinData
void setProteinData(std::vector< FASTAFile::FASTAEntry > &protein_data)
OpenMS::ProteinResolver::ResolverResult::peptide_entries
std::vector< PeptideEntry > * peptide_entries
Definition: ProteinResolver.h:139
OpenMS::ProteinResolver::PeptideEntry::peptide_hit
Size peptide_hit
Definition: ProteinResolver.h:103
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:73
OpenMS::ProteinResolver::PeptideEntry::traversed
bool traversed
Definition: ProteinResolver.h:100
OpenMS::ProteinResolver::ResolverResult::msds
std::vector< MSDGroup > * msds
Definition: ProteinResolver.h:137
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 If the protein/gene sequence contains unusua...
Definition: FASTAFile.h:60
OpenMS::ProteinResolver::ProteinEntry::weight
double weight
Definition: ProteinResolver.h:86
OpenMS::ProteinResolver::resolver_result_
std::vector< ResolverResult > resolver_result_
Definition: ProteinResolver.h:241
OpenMS::String::NONE
Definition: String.h:81
OpenMS::ProteinResolver::ResolverResult::input_type
enum OpenMS::ProteinResolver::ResolverResult::type input_type
OpenMS::String
A more convenient string class.
Definition: String.h:58
OpenMS::ProteinResolver::MSDGroup
representation of an msd group. Contains peptides, proteins and a pointer to its ISD group
Definition: ProteinResolver.h:113
OpenMS::ProteinResolver::PeptideEntry::intensity
float intensity
Definition: ProteinResolver.h:108
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:120
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:84
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::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:93
OpenMS::PeptideAndProteinQuant::Statistics::n_samples
Size n_samples
number of samples (or assays in mzTab terms)
Definition: PeptideAndProteinQuant.h:121
OpenMS::String::DOUBLE
Definition: String.h:81
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) The first String corresponds to the identifie...
Definition: FASTAFile.h:71
OpenMS::PeptideAndProteinQuant::getStatistics
const Statistics & getStatistics()
Get summary statistics.
OpenMS::ProteinResolver::MSDGroup::isd_group
ISDGroup * isd_group
Definition: ProteinResolver.h:118
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:83
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:339
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:209
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:47
OpenMS::ProteinResolver::PeptideEntry
represents a peptide. First in silico. If experimental is set to true it is MS/MS derived.
Definition: ProteinResolver.h:97
OpenMS::ProteinResolver::ProteinEntry::msd_group
Size msd_group
Definition: ProteinResolver.h:91
OpenMS::FileTypes::FEATUREXML
OpenMS feature file (.featureXML)
Definition: FileTypes.h:63
OpenMS::PeptideAndProteinQuant::SampleAbundances
std::map< UInt64, double > SampleAbundances
Mapping: sample ID -> abundance.
Definition: PeptideAndProteinQuant.h:60
OpenMS::ProteinResolver::MSDGroup::number_of_decoy
Size number_of_decoy
Definition: ProteinResolver.h:119
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:56
OpenMS::ProteinResolver::PeptideEntry::experimental
bool experimental
Definition: ProteinResolver.h:107
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:136
OpenMS::ProteinResolver::protein_data_
std::vector< FASTAFile::FASTAEntry > protein_data_
Definition: ProteinResolver.h:242
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:142
OpenMS::FileTypes::Type
Type
Actual file types enum.
Definition: FileTypes.h:56
OpenMS::QuantitativeExperimentalDesign
Merge files according to experimental design.
Definition: QuantitativeExperimentalDesign.h:56
QuantitativeExperimentalDesign.h
OpenMS::ProteinResolver::ProteinEntry::index
Size index
Definition: ProteinResolver.h:90
OpenMS::ProteinResolver::ResolverResult::reindexed_peptides
std::vector< Size > * reindexed_peptides
Definition: ProteinResolver.h:140
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::String::hasSuffix
bool hasSuffix(const String &string) const
true if String ends with string, false otherwise
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:82
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:81
OpenMS::ProteinResolver::ISDGroup::msd_groups
std::list< Size > msd_groups
Definition: ProteinResolver.h:130
OpenMS::ProteinResolver::PeptideEntry::sequence
String sequence
Definition: ProteinResolver.h:101
SVOutStream.h
OpenMS::ParamValue::toString
std::string toString(bool full_precision=true) const
Convert ParamValue to string.
main
int main(int argc, const char **argv)
Definition: INIFileEditor.cpp:71
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:117
OpenMS::ProteinResolver::ResolverResult::type
type
Definition: ProteinResolver.h:142
OpenMS::ProteinResolver::MSDGroup::proteins
std::list< ProteinEntry * > proteins
Definition: ProteinResolver.h:115
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:92
OpenMS::ProteinResolver::PeptideEntry::msd_group
Size msd_group
Definition: ProteinResolver.h:105
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:114
OpenMS::PeptideAndProteinQuant::getProteinResults
const ProteinQuant & getProteinResults()
Get protein abundance data.
OpenMS::FeatureMap
A container for features.
Definition: FeatureMap.h:98
OpenMS::PeptideIdentification
Represents the peptide hits for a spectrum.
Definition: PeptideIdentification.h:63
OpenMS::PeptideIdentification::getMZ
double getMZ() const
returns the MZ of the MS2 spectrum
OpenMS::ProteinResolver::ResolverResult::peptide_identification
std::vector< PeptideIdentification > * peptide_identification
Definition: ProteinResolver.h:143
OpenMS::PeptideHit::getScore
double getScore() const
returns the PSM score
OpenMS::ProteinResolver::PeptideEntry::origin
String origin
Definition: ProteinResolver.h:109
OpenMS::FASTAFile::load
void load(const String &filename, std::vector< FASTAEntry > &data) const
loads a FASTA file given by 'filename' and stores the information in 'data' This uses more RAM than r...
OpenMS::ProteinResolver::MSDGroup::peptides
std::list< PeptideEntry * > peptides
Definition: ProteinResolver.h:116
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:144
OpenMS::FeatureXMLFile
This class provides Input/Output functionality for feature maps.
Definition: FeatureXMLFile.h:62
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:138
OpenMS::Param
Management and storage of parameters / INI files.
Definition: Param.h:69
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:125
IDFilter.h
OpenMS::ProteinResolver::PeptideEntry::peptide_identification
Size peptide_identification
Definition: ProteinResolver.h:102
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:186
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:87
OpenMS::PeptideAndProteinQuant::ProteinQuant
std::map< String, ProteinData > ProteinQuant
Mapping: protein accession -> protein data.
Definition: PeptideAndProteinQuant.h:115
OpenMS::ProteinResolver::ResolverResult::reindexed_proteins
std::vector< Size > * reindexed_proteins
Definition: ProteinResolver.h:141
OpenMS::Param::getValue
const ParamValue & getValue(const std::string &key) const
Returns a value of a parameter.
OpenMS::ProteinResolver
Helper class for peptide and protein quantification based on feature data annotated with IDs.
Definition: ProteinResolver.h:54
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:85
PeptideProteinResolution.h
OpenMS::ProteinResolver::PeptideEntry::isd_group
Size isd_group
Definition: ProteinResolver.h:106
TOPPBase.h
OpenMS::FeatureMap::getProteinIdentifications
const std::vector< ProteinIdentification > & getProteinIdentifications() const
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:58
OpenMS::IdXMLFile
Used to load and store idXML files.
Definition: IdXMLFile.h:68
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:164
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:121
OpenMS::PeptideAndProteinQuant::PeptideQuant
std::map< AASequence, PeptideData > PeptideQuant
Mapping: peptide sequence (modified) -> peptide data.
Definition: PeptideAndProteinQuant.h:88
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:54
OpenMS::ProteinResolver::resolveID
void resolveID(std::vector< PeptideIdentification > &peptide_identifications)
Computing protein groups from peptide identifications OR consensus map.