OpenMS
IdentificationData.h
Go to the documentation of this file.
1 // Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
2 // SPDX-License-Identifier: BSD-3-Clause
3 //
4 // --------------------------------------------------------------------------
5 // $Maintainer: Hendrik Weisser $
6 // $Authors: Hendrik Weisser $
7 // --------------------------------------------------------------------------
8 
9 #pragma once
10 
24 
25 #include <unordered_set>
26 
27 namespace OpenMS
28 {
70  template <typename ContainerType, typename PredicateType>
71  static void removeFromSetIf_(ContainerType& container, PredicateType predicate)
72  {
73  for (auto it = container.begin(); it != container.end(); )
74  {
75  if (predicate(it))
76  {
77  it = container.erase(it);
78  }
79  else
80  {
81  ++it;
82  }
83  }
84  }
85 
86  class OPENMS_DLLAPI IdentificationData: public MetaInfoInterface
87  {
88  public:
89 
90  // to be able to add overloads and still find the inherited ones
92 
93  // type definitions:
96 
100 
107 
111 
116 
120 
123 
128 
132 
136 
139 
144 
149 
153 
155 
157 
161 
165 
166  // @todo: allow multiple sets of groups, like with parent sequences
167  // ("ParentGroupSets")?
171 
173  using ParentGroups =
180 
181  using AddressLookup = std::unordered_set<uintptr_t>;
182 
184  struct RefTranslator {
185  std::map<InputFileRef, InputFileRef> input_file_refs;
186  std::map<ScoreTypeRef, ScoreTypeRef> score_type_refs;
187  std::map<ProcessingSoftwareRef, ProcessingSoftwareRef> processing_software_refs;
188  std::map<SearchParamRef, SearchParamRef> search_param_refs;
189  std::map<ProcessingStepRef, ProcessingStepRef> processing_step_refs;
190  std::map<ObservationRef, ObservationRef> observation_refs;
191  std::map<ParentSequenceRef, ParentSequenceRef> parent_sequence_refs;
192  std::map<IdentifiedPeptideRef, IdentifiedPeptideRef> identified_peptide_refs;
193  std::map<IdentifiedOligoRef, IdentifiedOligoRef> identified_oligo_refs;
194  std::map<IdentifiedCompoundRef, IdentifiedCompoundRef> identified_compound_refs;
195  std::map<AdductRef, AdductRef> adduct_refs;
196  std::map<ObservationMatchRef, ObservationMatchRef> observation_match_refs;
197 
198  bool allow_missing = false;
199 
201 
203 
204  };
205 
208  current_step_ref_(processing_steps_.end()), no_checks_(false)
209  {
210  }
211 
219 
224 
229 
234 
241 
248  const ProcessingSoftware& software);
249 
256 
263  step);
264 
271  const ProcessingStep& step, SearchParamRef search_ref);
272 
279 
286 
293 
296 
303  peptide);
304 
311  compound);
312 
319 
326 
333 
340 
342  const InputFiles& getInputFiles() const
343  {
344  return input_files_;
345  }
346 
349  {
350  return processing_softwares_;
351  }
352 
355  {
356  return processing_steps_;
357  }
358 
361  {
362  return db_search_params_;
363  }
364 
367  {
368  return db_search_steps_;
369  }
370 
372  const ScoreTypes& getScoreTypes() const
373  {
374  return score_types_;
375  }
376 
379  {
380  return observations_;
381  }
382 
385  {
386  return parents_;
387  }
388 
391  {
392  return parent_groups_;
393  }
394 
397  {
398  return identified_peptides_;
399  }
400 
403  {
404  return identified_compounds_;
405  }
406 
409  {
410  return identified_oligos_;
411  }
412 
414  const Adducts& getAdducts() const
415  {
416  return adducts_;
417  }
418 
421  {
422  return observation_matches_;
423  }
424 
427  {
428  return observation_match_groups_;
429  }
430 
432  void addScore(ObservationMatchRef match_ref, ScoreTypeRef score_ref,
433  double value);
434 
443 
450 
453 
460  std::vector<ObservationMatchRef> getBestMatchPerObservation(ScoreTypeRef score_ref,
461  bool require_score = false) const;
462  // @todo: this currently doesn't take molecule type into account - should it?
463 
465  std::pair<ObservationMatchRef, ObservationMatchRef> getMatchesForObservation(ObservationRef obs_ref) const;
466 
474  template <typename PredicateType>
475  void removeObservationMatchesIf(PredicateType&& func)
476  {
477  auto count = observation_matches_.size();
478  removeFromSetIf_(observation_matches_, func);
479  if (count != observation_matches_.size()) cleanup();
480  }
481 
489  template <typename PredicateType>
490  void removeParentSequencesIf(PredicateType&& func)
491  {
492  auto count = parents_.size();
493  removeFromSetIf_(parents_, func);
494  if (count != parents_.size()) cleanup();
495  }
496 
497  template <typename PredicateType>
498  void applyToObservations(PredicateType&& func)
499  {
500  for (auto it = observations_.begin(); it != observations_.end(); ++it)
501  observations_.modify(it, func);
502  }
503 
509  ScoreTypeRef findScoreType(const String& score_name) const;
510 
512  void calculateCoverages(bool check_molecule_length = false);
513 
525  void cleanup(bool require_observation_match = true,
526  bool require_identified_sequence = true,
527  bool require_parent_match = true,
528  bool require_parent_group = false,
529  bool require_match_group = false);
530 
532  bool empty() const;
533 
545 
547  void swap(IdentificationData& other);
548 
550  void clear();
551 
567  template <class ScoredProcessingResults>
568  ScoreTypeRef pickScoreType(const ScoredProcessingResults& container,
569  bool all_elements = false, bool any_score = false) const
570  {
571  std::map<ScoreTypeRef, Size> score_counts;
572 
573  if (any_score)
574  {
575  for (const auto& element : container)
576  {
577  for (const auto& step : element.steps_and_scores)
578  {
579  for (const auto& pair : step.scores)
580  {
581  score_counts[pair.first]++;
582  }
583  }
584  }
585  }
586  else
587  {
588  for (const auto& element : container)
589  {
590  auto score_info = element.getMostRecentScore();
591  if (std::get<2>(score_info)) // check success indicator
592  {
593  ScoreTypeRef score_ref = *std::get<1>(score_info); // unpack the option
594  if (!all_elements) return score_ref;
595  score_counts[score_ref]++; // elements are zero-initialized
596  }
597  }
598  }
599  if (score_counts.empty()) return score_types_.end();
600  auto pos = max_element(score_counts.begin(), score_counts.end());
601  // @TODO: break ties according to some criterion
602  return pos->first;
603  }
604 
606  void setMetaValue(const ObservationMatchRef ref, const String& key, const DataValue& value);
607 
609  void setMetaValue(const ObservationRef ref, const String& key, const DataValue& value);
610 
612  void setMetaValue(const IdentifiedMolecule& var, const String& key, const DataValue& value);
613 
614  // @TODO: add overloads for other data types derived from MetaInfoInterface
615 
618  void removeMetaValue(const ObservationMatchRef ref, const String& key);
619 
620  protected:
621 
622  // containers:
627  // @TODO: store SearchParamRef inside ProcessingStep? (may not be required
628  // for many processing steps)
640 
643 
650 
651  // look-up tables for fast checking of reference validity:
654  // @TODO: just use one "identified_molecule_lookup_" for all molecule types?
659 
661  void checkScoreTypes_(const std::map<ScoreTypeRef, double>& scores) const;
662 
665  steps_and_scores) const;
666 
668  void checkParentMatches_(const ParentMatches& matches,
669  MoleculeType expected_type) const;
670 
679  const ScoredProcessingResult& other,
680  const RefTranslator& trans);
681 
687  template <typename ElementType>
689 
695  template <typename ElementType>
697 
703  template <typename ElementType>
705 
707  template <typename ContainerType, typename ElementType>
708  typename ContainerType::iterator insertIntoMultiIndex_(ContainerType& container, const ElementType& element);
709 
711  template <typename ContainerType, typename ElementType>
712  typename ContainerType::iterator insertIntoMultiIndex_(
713  ContainerType& container, const ElementType& element,
714  AddressLookup& lookup);
715 
716  };
717 
718 }
OpenMS::InputFile InputFile
Definition: FLASHDeconvTabWidget.h:102
Definition: AdductInfo.h:17
Class to hold strings, numeric values, lists of strings and lists of numeric values.
Definition: DataValue.h:33
Definition: IdentificationData.h:87
ObservationRef registerObservation(const Observation &obs)
Register an observation (e.g. MS2 spectrum or feature)
IdentificationDataInternal::PeakAnnotations PeakAnnotations
Definition: IdentificationData.h:156
DBSearchParams db_search_params_
Definition: IdentificationData.h:626
ParentGroupSets parent_groups_
Definition: IdentificationData.h:633
IdentificationDataInternal::ParentMatches ParentMatches
Definition: IdentificationData.h:138
void calculateCoverages(bool check_molecule_length=false)
Calculate sequence coverages of parent sequences.
ProcessingSoftwares processing_softwares_
Definition: IdentificationData.h:624
IdentificationData(const IdentificationData &other)
Copy constructor.
std::unordered_set< uintptr_t > AddressLookup
Definition: IdentificationData.h:181
ProcessingSteps processing_steps_
Definition: IdentificationData.h:625
const DBSearchParams & getDBSearchParams() const
Return the registered database search parameters (immutable)
Definition: IdentificationData.h:360
IdentificationData(IdentificationData &&other) noexcept
Move constructor.
ObservationMatchGroups observation_match_groups_
Definition: IdentificationData.h:639
ObservationMatches observation_matches_
Definition: IdentificationData.h:638
void removeObservationMatchesIf(PredicateType &&func)
Helper function for filtering observation matches (e.g. PSMs) in IdentificationData.
Definition: IdentificationData.h:475
ScoreTypeRef findScoreType(const String &score_name) const
Look up a score type by name.
IdentificationDataInternal::ScoreTypes ScoreTypes
Definition: IdentificationData.h:118
const ProcessingSoftwares & getProcessingSoftwares() const
Return the registered data processing software (immutable)
Definition: IdentificationData.h:348
AdductRef registerAdduct(const AdductInfo &adduct)
Register an adduct.
AddressLookup observation_match_lookup_
Definition: IdentificationData.h:658
IdentificationDataInternal::IdentifiedOligos IdentifiedOligos
Definition: IdentificationData.h:151
const InputFiles & getInputFiles() const
Return the registered input files (immutable)
Definition: IdentificationData.h:342
MatchGroupRef registerObservationMatchGroup(const ObservationMatchGroup &group)
Register a group of observation matches that belong together.
AddressLookup observation_lookup_
Definition: IdentificationData.h:652
void removeMetaValue(const ObservationMatchRef ref, const String &key)
ProcessingStepRef registerProcessingStep(const ProcessingStep &step, SearchParamRef search_ref)
Register a database search step with associated parameters.
AddressLookup identified_oligo_lookup_
Definition: IdentificationData.h:657
IdentifiedOligos identified_oligos_
Definition: IdentificationData.h:636
const ObservationMatchGroups & getObservationMatchGroups() const
Return the registered groups of observation matches (immutable)
Definition: IdentificationData.h:426
const ParentSequences & getParentSequences() const
Return the registered parent sequences (immutable)
Definition: IdentificationData.h:384
bool no_checks_
Suppress validity checks in register... calls?
Definition: IdentificationData.h:649
void setMetaValue(const ObservationRef ref, const String &key, const DataValue &value)
Set a meta value on a stored observation.
const IdentifiedCompounds & getIdentifiedCompounds() const
Return the registered compounds (immutable)
Definition: IdentificationData.h:402
void addScore(ObservationMatchRef match_ref, ScoreTypeRef score_ref, double value)
Add a score to an input match (e.g. PSM)
IdentifiedCompoundRef registerIdentifiedCompound(const IdentifiedCompound &compound)
Register an identified compound (small molecule)
ObservationMatchRef registerObservationMatch(const ObservationMatch &match)
Register an observation match (e.g. peptide-spectrum match)
IdentificationDataInternal::Adducts Adducts
Definition: IdentificationData.h:158
IdentifiedOligoRef registerIdentifiedOligo(const IdentifiedOligo &oligo)
Register an identified RNA oligonucleotide.
bool empty() const
Return whether the data structure is empty (no data)
Adducts adducts_
Definition: IdentificationData.h:637
void setCurrentProcessingStep(ProcessingStepRef step_ref)
Set a data processing step that will apply to all subsequent "register..." calls.
IdentificationDataInternal::Observations Observations
Definition: IdentificationData.h:130
void swap(IdentificationData &other)
Swap contents with a second instance.
void setMetaValue(const ObservationMatchRef ref, const String &key, const DataValue &value)
Set a meta value on a stored observation match (e.g. PSM)
IdentificationData & operator=(IdentificationData &&other) noexcept
Move assignment operator.
IdentificationDataInternal::ParentSequences ParentSequences
Definition: IdentificationData.h:134
ScoreTypeRef registerScoreType(const ScoreType &score)
Register a score type.
IdentificationDataInternal::AppliedProcessingSteps AppliedProcessingSteps
Definition: IdentificationData.h:127
const ProcessingSteps & getProcessingSteps() const
Return the registered data processing steps (immutable)
Definition: IdentificationData.h:354
void applyToObservations(PredicateType &&func)
Definition: IdentificationData.h:498
const ParentGroupSets & getParentGroupSets() const
Return the registered parent sequence groupings (immutable)
Definition: IdentificationData.h:390
IdentificationDataInternal::InputFiles InputFiles
Definition: IdentificationData.h:98
std::pair< ObservationMatchRef, ObservationMatchRef > getMatchesForObservation(ObservationRef obs_ref) const
Get range of matches (cf. equal_range) for a given observation.
ProcessingStepRef registerProcessingStep(const ProcessingStep &step)
Register a data processing step.
IdentificationDataInternal::DBSearchParams DBSearchParams
Definition: IdentificationData.h:113
const ScoreTypes & getScoreTypes() const
Return the registered score types (immutable)
Definition: IdentificationData.h:372
IdentificationData()
Default constructor.
Definition: IdentificationData.h:207
IdentifiedCompounds identified_compounds_
Definition: IdentificationData.h:635
const IdentifiedOligos & getIdentifiedOligos() const
Return the registered identified oligonucleotides (immutable)
Definition: IdentificationData.h:408
IdentificationDataInternal::IdentifiedPeptides IdentifiedPeptides
Definition: IdentificationData.h:141
DBSearchSteps db_search_steps_
Definition: IdentificationData.h:629
ProcessingStepRef getCurrentProcessingStep()
Return the current processing step (set via setCurrentProcessingStep()).
ProcessingSoftwareRef registerProcessingSoftware(const ProcessingSoftware &software)
Register data processing software.
void checkParentMatches_(const ParentMatches &matches, MoleculeType expected_type) const
Helper function to check if all parent matches are valid.
Observations observations_
Definition: IdentificationData.h:631
IdentificationDataInternal::ProcessingSteps ProcessingSteps
Definition: IdentificationData.h:109
IdentificationDataInternal::DBSearchSteps DBSearchSteps
Definition: IdentificationData.h:115
void setMetaValue(const IdentifiedMolecule &var, const String &key, const DataValue &value)
Set a meta value on a stored identified molecule (variant)
ParentSequenceRef registerParentSequence(const ParentSequence &parent)
Register a parent sequence (e.g. protein or intact RNA)
const DBSearchSteps & getDBSearchSteps() const
Return the registered database search steps (immutable)
Definition: IdentificationData.h:366
ScoreTypes score_types_
Definition: IdentificationData.h:630
InputFiles input_files_
Definition: IdentificationData.h:623
IdentificationDataInternal::AdductOpt AdductOpt
Definition: IdentificationData.h:160
const Adducts & getAdducts() const
Return the registered adducts (immutable)
Definition: IdentificationData.h:414
IdentificationDataInternal::ParentGroupSets ParentGroupSets
Definition: IdentificationData.h:179
void mergeScoredProcessingResults_(ScoredProcessingResult &result, const ScoredProcessingResult &other, const RefTranslator &trans)
Helper function to merge scored processing results while updating references (to processing steps and...
ContainerType::iterator insertIntoMultiIndex_(ContainerType &container, const ElementType &element)
Helper function for adding entries (derived from ScoredProcessingResult) to a boost::multi_index_cont...
InputFileRef registerInputFile(const InputFile &file)
Register an input file.
IdentifiedPeptideRef registerIdentifiedPeptide(const IdentifiedPeptide &peptide)
Register an identified peptide.
AddressLookup identified_peptide_lookup_
Definition: IdentificationData.h:655
ContainerType::iterator insertIntoMultiIndex_(ContainerType &container, const ElementType &element, AddressLookup &lookup)
Variant of insertIntoMultiIndex_() that also updates a look-up table of valid references (addresses)
ProcessingStepRef current_step_ref_
Reference to the current data processing step (see setCurrentProcessingStep())
Definition: IdentificationData.h:642
void clear()
Clear all contents.
const IdentifiedPeptides & getIdentifiedPeptides() const
Return the registered identified peptides (immutable)
Definition: IdentificationData.h:396
void clearCurrentProcessingStep()
Cancel the effect of setCurrentProcessingStep().
std::vector< ObservationMatchRef > getBestMatchPerObservation(ScoreTypeRef score_ref, bool require_score=false) const
Return the best match for each observation, according to a given score type.
void cleanup(bool require_observation_match=true, bool require_identified_sequence=true, bool require_parent_match=true, bool require_parent_group=false, bool require_match_group=false)
Clean up the data structure after filtering parts of it.
IdentificationDataInternal::ProcessingSoftwares ProcessingSoftwares
Definition: IdentificationData.h:104
void removeParentSequencesIf(PredicateType &&func)
Helper function for filtering parent sequences (e.g. protein sequences) in IdentificationData.
Definition: IdentificationData.h:490
SearchParamRef registerDBSearchParam(const DBSearchParam &param)
Register database search parameters.
void checkScoreTypes_(const std::map< ScoreTypeRef, double > &scores) const
Helper function to check if all score types are valid.
const Observations & getObservations() const
Return the registered observations (immutable)
Definition: IdentificationData.h:378
AddressLookup parent_lookup_
Definition: IdentificationData.h:653
void checkAppliedProcessingSteps_(const AppliedProcessingSteps &steps_and_scores) const
Helper function to check if all applied processing steps are valid.
IdentificationDataInternal::ParentGroups ParentGroups
Definition: IdentificationData.h:174
AddressLookup identified_compound_lookup_
Definition: IdentificationData.h:656
RefTranslator merge(const IdentificationData &other)
Merge in data from another instance.
IdentificationDataInternal::ObservationMatchGroups ObservationMatchGroups
Definition: IdentificationData.h:169
IdentificationData & operator=(const IdentificationData &other)
Copy assignment operator.
const ObservationMatches & getObservationMatches() const
Return the registered observation matches (immutable)
Definition: IdentificationData.h:420
IdentificationDataInternal::IdentifiedCompounds IdentifiedCompounds
Definition: IdentificationData.h:146
IdentifiedPeptides identified_peptides_
Definition: IdentificationData.h:634
void registerParentGroupSet(const ParentGroupSet &groups)
Register a grouping of parent sequences (e.g. protein inference result)
ParentSequences parents_
Definition: IdentificationData.h:632
IdentificationDataInternal::ObservationMatches ObservationMatches
Definition: IdentificationData.h:163
ScoreTypeRef pickScoreType(const ScoredProcessingResults &container, bool all_elements=false, bool any_score=false) const
Definition: IdentificationData.h:568
Helper functor for adding processing steps to elements in a boost::multi_index_container structure.
Definition: IdentificationData.h:688
Helper functor for adding scores to elements in a boost::multi_index_container structure.
Definition: IdentificationData.h:696
Helper functor for removing invalid parent matches from elements in a boost::multi_index_container st...
Definition: IdentificationData.h:704
Interface for classes that can store arbitrary meta information (Type-Name-Value tuples).
Definition: MetaInfoInterface.h:35
void setMetaValue(const String &name, const DataValue &value)
Sets the DataValue corresponding to a name.
A more convenient string class.
Definition: String.h:34
static void removeFromSetIf_(ContainerType &container, PredicateType predicate)
Representation of spectrum identification results and associated data.
Definition: IdentificationData.h:71
std::map< ProcessingStepRef, SearchParamRef > DBSearchSteps
Definition: DBSearchParam.h:100
IteratorWrapper< ObservationMatchGroups::iterator > MatchGroupRef
Definition: ObservationMatchGroup.h:74
IteratorWrapper< IdentifiedCompounds::iterator > IdentifiedCompoundRef
Definition: IdentifiedCompound.h:55
IdentifiedSequence< NASequence > IdentifiedOligo
Definition: IdentifiedSequence.h:81
IteratorWrapper< IdentifiedOligos::iterator > IdentifiedOligoRef
Definition: IdentifiedSequence.h:99
boost::multi_index_container< Observation, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::composite_key< Observation, boost::multi_index::member< Observation, InputFileRef, &Observation::input_file >, boost::multi_index::member< Observation, String, &Observation::data_id > > > > > Observations
Definition: Observation.h:69
boost::multi_index_container< ObservationMatch, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::composite_key< ObservationMatch, boost::multi_index::member< ObservationMatch, ObservationRef, &ObservationMatch::observation_ref >, boost::multi_index::member< ObservationMatch, IdentifiedMolecule, &ObservationMatch::identified_molecule_var >, boost::multi_index::member< ObservationMatch, AdductOpt, &ObservationMatch::adduct_opt > > > > > ObservationMatches
Definition: ObservationMatch.h:124
std::optional< AdductRef > AdductOpt
Definition: ObservationMatch.h:44
std::set< ScoreType > ScoreTypes
Definition: ScoreType.h:65
IteratorWrapper< IdentifiedPeptides::iterator > IdentifiedPeptideRef
Definition: IdentifiedSequence.h:90
IteratorWrapper< ScoreTypes::iterator > ScoreTypeRef
Definition: ScoreType.h:66
IteratorWrapper< Adducts::iterator > AdductRef
Definition: ObservationMatch.h:43
std::set< DBSearchParam > DBSearchParams
Definition: DBSearchParam.h:98
IteratorWrapper< Observations::iterator > ObservationRef
Definition: Observation.h:70
boost::multi_index_container< AppliedProcessingStep, boost::multi_index::indexed_by< boost::multi_index::sequenced<>, boost::multi_index::ordered_unique< boost::multi_index::member< AppliedProcessingStep, std::optional< ProcessingStepRef >, &AppliedProcessingStep::processing_step_opt > > > > AppliedProcessingSteps
Definition: AppliedProcessingStep.h:107
IteratorWrapper< ObservationMatches::iterator > ObservationMatchRef
Definition: ObservationMatch.h:126
boost::multi_index_container< IdentifiedPeptide, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::member< IdentifiedPeptide, AASequence, &IdentifiedPeptide::sequence > > > > IdentifiedPeptides
Definition: IdentifiedSequence.h:89
IteratorWrapper< ProcessingSoftwares::iterator > ProcessingSoftwareRef
Definition: ProcessingSoftware.h:42
IteratorWrapper< DBSearchParams::iterator > SearchParamRef
Definition: DBSearchParam.h:99
std::vector< PeptideHit::PeakAnnotation > PeakAnnotations
Definition: ObservationMatch.h:26
MoleculeType
Definition: MetaData.h:40
boost::multi_index_container< ParentSequence, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::member< ParentSequence, String, &ParentSequence::accession > > > > ParentSequences
Definition: ParentSequence.h:94
std::vector< ParentGroupSet > ParentGroupSets
Definition: ParentGroup.h:56
boost::multi_index_container< ParentGroup, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::member< ParentGroup, std::set< ParentSequenceRef >, &ParentGroup::parent_refs > > > > ParentGroups
Definition: ParentGroup.h:38
boost::multi_index_container< IdentifiedOligo, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::member< IdentifiedOligo, NASequence, &IdentifiedOligo::sequence > > > > IdentifiedOligos
Definition: IdentifiedSequence.h:98
boost::multi_index_container< IdentifiedCompound, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::member< IdentifiedCompound, String, &IdentifiedCompound::identifier > > > > IdentifiedCompounds
Definition: IdentifiedCompound.h:54
std::map< ParentSequenceRef, std::set< ParentMatch > > ParentMatches
mapping: parent sequence -> match information
Definition: ParentMatch.h:75
std::set< ProcessingStep > ProcessingSteps
Definition: ProcessingStep.h:62
std::set< ProcessingSoftware > ProcessingSoftwares
Definition: ProcessingSoftware.h:41
IteratorWrapper< ProcessingSteps::iterator > ProcessingStepRef
Definition: ProcessingStep.h:63
boost::multi_index_container< ObservationMatchGroup, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::member< ObservationMatchGroup, std::set< ObservationMatchRef >, &ObservationMatchGroup::observation_match_refs > > > > ObservationMatchGroups
Definition: ObservationMatchGroup.h:73
IdentifiedSequence< AASequence > IdentifiedPeptide
Definition: IdentifiedSequence.h:80
IteratorWrapper< InputFiles::iterator > InputFileRef
Definition: include/OpenMS/METADATA/ID/InputFile.h:69
MassType
Definition: MetaData.h:48
IteratorWrapper< ParentSequences::iterator > ParentSequenceRef
Definition: ParentSequence.h:95
IteratorWrapper< ParentGroups::iterator > ParentGroupRef
Definition: ParentGroup.h:39
boost::multi_index_container< InputFile, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::member< InputFile, String, &InputFile::name > > > > InputFiles
Definition: include/OpenMS/METADATA/ID/InputFile.h:68
std::set< AdductInfo, AdductCompare > Adducts
Definition: ObservationMatch.h:42
: Group of ambiguously identified parent sequences (e.g. protein group)
Definition: ParentGroup.h:25
Main OpenMS namespace.
Definition: openswathalgo/include/OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.h:19
Definition: AppliedProcessingStep.h:30
Parameters specific to a database search step.
Definition: DBSearchParam.h:22
Variant type holding Peptide/Compound/Oligo references and convenience functions.
Definition: IdentifiedMolecule.h:29
Representation of an identified sequence (peptide or oligonucleotide)
Definition: IdentifiedSequence.h:27
Information about input files that were processed.
Definition: include/OpenMS/METADATA/ID/InputFile.h:25
: Group of related (co-identified) input matches
Definition: ObservationMatchGroup.h:25
Representation of a search hit (e.g. peptide-spectrum match).
Definition: ObservationMatch.h:48
Representation of an observation, e.g. a spectrum or feature, in an input data file.
Definition: Observation.h:28
Set of groups of ambiguously identified parent sequences (e.g. results of running a protein inference...
Definition: ParentGroup.h:44
Meta data for the association between an identified molecule (e.g. peptide) and a parent sequence (e....
Definition: ParentMatch.h:20
Representation of a parent sequence that is identified only indirectly (e.g. a protein).
Definition: ParentSequence.h:24
Information about software used for data processing.
Definition: ProcessingSoftware.h:23
Data processing step that is applied to the data (e.g. database search, PEP calculation,...
Definition: ProcessingStep.h:22
Information about a score type.
Definition: ScoreType.h:20
Base class for ID data with scores and processing steps (and meta info)
Definition: ScoredProcessingResult.h:19
structure that maps references of corresponding objects after copying
Definition: IdentificationData.h:184
std::map< ObservationMatchRef, ObservationMatchRef > observation_match_refs
Definition: IdentificationData.h:196
std::map< ProcessingSoftwareRef, ProcessingSoftwareRef > processing_software_refs
Definition: IdentificationData.h:187
std::map< IdentifiedPeptideRef, IdentifiedPeptideRef > identified_peptide_refs
Definition: IdentificationData.h:192
IdentifiedMolecule translate(IdentifiedMolecule old) const
std::map< ParentSequenceRef, ParentSequenceRef > parent_sequence_refs
Definition: IdentificationData.h:191
ObservationMatchRef translate(ObservationMatchRef old) const
std::map< SearchParamRef, SearchParamRef > search_param_refs
Definition: IdentificationData.h:188
std::map< ScoreTypeRef, ScoreTypeRef > score_type_refs
Definition: IdentificationData.h:186
std::map< IdentifiedCompoundRef, IdentifiedCompoundRef > identified_compound_refs
Definition: IdentificationData.h:194
std::map< ProcessingStepRef, ProcessingStepRef > processing_step_refs
Definition: IdentificationData.h:189
std::map< AdductRef, AdductRef > adduct_refs
Definition: IdentificationData.h:195
std::map< ObservationRef, ObservationRef > observation_refs
Definition: IdentificationData.h:190
std::map< IdentifiedOligoRef, IdentifiedOligoRef > identified_oligo_refs
Definition: IdentificationData.h:193
std::map< InputFileRef, InputFileRef > input_file_refs
Definition: IdentificationData.h:185