OpenMS  3.0.0
ProtonDistributionModel.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: Andreas Bertsch $
33 // --------------------------------------------------------------------------
34 
35 
36 #pragma once
37 
38 #include <OpenMS/CONCEPT/Types.h>
41 #include <vector>
42 
43 namespace OpenMS
44 {
45  class AASequence;
46 
70  class OPENMS_DLLAPI ProtonDistributionModel :
71  public DefaultParamHandler
72  {
73 public:
74 
80 
83 
85  ~ProtonDistributionModel() override;
87 
89  ProtonDistributionModel & operator=(const ProtonDistributionModel & pdm);
90 
96  {
97  ChargeDirected = 0,
99  SideChain
100  };
102 
111  void getProtonDistribution(std::vector<double> & bb_charges, std::vector<double> & sc_charges, const AASequence & peptide, Int charge, Residue::ResidueType res_type = Residue::YIon);
112 
124  //void getChargeStateIntensities(const AASequence& peptide, const AASequence& n_term_ion, const AASequence& c_term_ion, Int charge, Residue::ResidueType n_term_type, double& n_term1, double& c_term1, double& n_term2, double& c_term2, FragmentationType type);
125 
126 
127  void getChargeStateIntensities(const AASequence & peptide, const AASequence & n_term_ion, const AASequence & c_term_ion, Int charge, Residue::ResidueType n_term_type,
128  std::vector<double> & n_term_intensities, std::vector<double> & c_term_intensities, FragmentationType type);
129 
131  void setPeptideProtonDistribution(const std::vector<double> & bb_charge, const std::vector<double> & sc_charge);
132 
133 protected:
134 
135  // calculates the proton distribution
136  void calculateProtonDistribution_(const AASequence & peptide, Int charge, Residue::ResidueType res_type = Residue::YIon, bool fixed_proton = false, Size cleavage_site = 0, bool use_most_basic_site = false);
137 
138  void calculateProtonDistributionCharge1_(const AASequence & peptide, Residue::ResidueType res_type);
139  void calculateProtonDistributionCharge2_(const AASequence & peptide, Residue::ResidueType res_type, bool fixed_proton, Size cleavage_site, bool use_most_basic_site);
140  void calculateProtonDistributionGreater2_(const AASequence & peptide, Int charge, Residue::ResidueType res_type);
141 
142  void calculateProtonDistributionIonPair_(const AASequence & peptide, Residue::ResidueType type, Size cleavage_site);
143 
144  // returns the proton affinity of the peptide with the given charge and ion type
145  //double getProtonAffinity_(const AASequence& ion, Int charge, Residue::ResidueType res_type);
146 
147  // returns the (relative) Intensities of the possible charge states of the ion from peptide
148  //std::vector<double> getChargeStateIntensities_(const AASequence& peptide, const AASequence& ion, Int charge, Residue::ResidueType res_type);
149 
150 
151  void calcChargeStateIntensities_(const AASequence & peptide, const AASequence & n_term_ion, const AASequence & c_term_ion, Int charge,
152  Residue::ResidueType n_term_type, std::vector<double> & n_term_intensities, std::vector<double> & c_term_intensities, FragmentationType type);
153 
154  // calculates the intensities of the different possible charge states
155  void calcChargeStateIntensities_(const AASequence & peptide, const AASequence & n_term_ion, const AASequence & c_term_ion, Int charge, Residue::ResidueType n_term_type, double & n_term1, double & c_term1, double & n_term2, double & c_term2, FragmentationType type);
156 
157  // returns the left and right GB values, NH2 and COOH if at terminus
158  void getLeftAndRightGBValues_(const AASequence & peptide, double & left_gb, double & right_gb, Size position);
159 
160  std::vector<double> sc_charge_;
161  std::vector<double> bb_charge_;
162  std::vector<double> sc_charge_full_;
163  std::vector<double> bb_charge_full_;
164  std::vector<double> sc_charge_ion_n_term_;
165  std::vector<double> bb_charge_ion_n_term_;
166  std::vector<double> sc_charge_ion_c_term_;
167  std::vector<double> bb_charge_ion_c_term_;
168  double E_;
169  double E_c_term_;
170  double E_n_term_;
171 
172  };
173 }
IDScoreSwitcherAlgorithm.h
DefaultParamHandler.h
ConsensusXMLFile.h
TriqlerFile.h
MzTabFile.h
OpenMS::TOPPBase
Base class for TOPP applications.
Definition: TOPPBase.h:147
OpenMS::ConsensusMap::applyMemberFunction
Size applyMemberFunction(Size(Type::*member_function)())
Applies a member function of Type to the container itself and all consensus features....
Definition: ConsensusMap.h:333
OpenMS::ExperimentalDesign
Representation of an experimental design in OpenMS. Instances can be loaded with the ExperimentalDesi...
Definition: ExperimentalDesign.h:242
OpenMS::MZTrafoModel::setRANSACParams
static void setRANSACParams(const Math::RANSACParam &p)
Set the global (program wide) parameters for RANSAC.
FeatureFindingMetabo.h
OpenMS::ExperimentalDesignFile::load
static ExperimentalDesign load(const String &tsv_file, bool require_spectra_files)
Loads an experimental design from a tabular separated file.
OpenMS::MzTabFile
File adapter for MzTab files.
Definition: MzTabFile.h:55
OpenMS::MapAlignmentTransformer
This class collects functions for applying retention time transformations to data structures.
Definition: MapAlignmentTransformer.h:57
OpenMS::MapAlignmentTransformer::transformRetentionTimes
static void transformRetentionTimes(PeakMap &msexp, const TransformationDescription &trafo, bool store_original_rt=false)
Applies the given transformation to a peak map.
OpenMS::SpectrumMetaDataLookup::addMissingSpectrumReferences
static bool addMissingSpectrumReferences(std::vector< PeptideIdentification > &peptides, const String &filename, bool stop_on_error=false, bool override_spectra_data=false, bool override_spectra_references=false, std::vector< ProteinIdentification > proteins=std::vector< ProteinIdentification >())
Add missing "spectrum_reference"s to peptide identifications based on raw data.
OpenMS::FeatureGroupingAlgorithmQT
A feature grouping algorithm for unlabeled data.
Definition: FeatureGroupingAlgorithmQT.h:52
ConversionHelper.h
OpenMS::MassTraceDetection
A mass trace extraction method that gathers peaks similar in m/z and moving along retention time.
Definition: MassTraceDetection.h:72
Size
OpenMS::IDFilter::keepUniquePeptidesPerProtein
static void keepUniquePeptidesPerProtein(std::vector< PeptideIdentification > &peptides)
Removes all peptides that are not annotated as unique for a protein (by PeptideIndexer)
OpenMS::PeptideIndexing::PEPTIDE_IDS_EMPTY
Definition: PeptideIndexing.h:125
OpenMS::BayesianProteinInferenceAlgorithm
Performs a Bayesian protein inference on Protein/Peptide identifications or ConsensusMap (experimenta...
Definition: BayesianProteinInferenceAlgorithm.h:75
OpenMS::FalseDiscoveryRate::apply
void apply(std::vector< PeptideIdentification > &fwd_ids, std::vector< PeptideIdentification > &rev_ids) const
Calculates the FDR of two runs, a forward run and a decoy run on peptide level.
OpenMS::FeatureFinderMultiplexAlgorithm::run
void run(MSExperiment &exp, bool progress)
main method for feature detection
OpenMS::FeatureFinderIdentificationAlgorithm::getChromatograms
PeakMap & getChromatograms()
OpenMS::ConsensusXMLFile::store
void store(const String &filename, const ConsensusMap &consensus_map)
Stores a consensus map to file.
OpenMS::Param::setValue
void setValue(const std::string &key, const ParamValue &value, const std::string &description="", const std::vector< std::string > &tags=std::vector< std::string >())
Sets a value.
OpenMS::Exception::IllegalArgument
A method or algorithm argument contains illegal values.
Definition: Exception.h:648
OpenMS::Math::median
static double median(IteratorType begin, IteratorType end, bool sorted=false)
Calculates the median of a range of values.
Definition: StatisticFunctions.h:138
OpenMS::IdXMLFile::store
void store(const String &filename, const std::vector< ProteinIdentification > &protein_ids, const std::vector< PeptideIdentification > &peptide_ids, const String &document_id="")
Stores the data in an idXML file.
OpenMS::MapConversion::convert
static void convert(UInt64 const input_map_index, PeakMap &input_map, ConsensusMap &output_map, Size n=-1)
Similar to convert for FeatureMaps.
OpenMS::ProtonDistributionModel::sc_charge_ion_c_term_
std::vector< double > sc_charge_ion_c_term_
Definition: ProtonDistributionModel.h:166
Types.h
ExperimentalDesignFile.h
OpenMS::Param::insert
void insert(const std::string &prefix, const Param &param)
OpenMS::ConsensusMap::sortByPosition
void sortByPosition()
Lexicographically sorts the peaks by their position (First RT then m/z).
OpenMS::FeatureFinderIdentificationAlgorithm::getMSData
PeakMap & getMSData()
OpenMS::ExperimentalDesign::MSFileSectionEntry::sample
unsigned sample
allows grouping by sample
Definition: ExperimentalDesign.h:260
IDMergerAlgorithm.h
OpenMS::File::basename
static String basename(const String &file)
OpenMS::PeptideIdentification::setIdentifier
void setIdentifier(const String &id)
sets the identifier which links this PI to its corresponding ProteinIdentification
OpenMS::DataProcessing::ALIGNMENT
Retention time alignment of different maps.
Definition: DataProcessing.h:68
OpenMS::ExperimentalDesign::getFractionToMSFilesMapping
std::map< unsigned int, std::vector< String > > getFractionToMSFilesMapping() const
return fraction index to file paths (ordered by fraction_group)
OpenMS::MzMLFile::store
void store(const String &filename, const PeakMap &map) const
Stores a map in an MzML file.
OpenMS::MZTrafoModel::setCoefficientLimits
static void setCoefficientLimits(double offset, double scale, double power)
Set coefficient boundaries for which the model coefficient must not exceed to be considered a valid m...
OpenMS::ProtonDistributionModel
A proton distribution model to calculate the proton distribution over charged peptides.
Definition: ProtonDistributionModel.h:70
OpenMS::Constants::k
const double k
Definition: Constants.h:153
OpenMS::MZTrafoModel::MODELTYPE
MODELTYPE
Definition: MZTrafoModel.h:97
OpenMS::FeatureGroupingAlgorithmQT::group
void group(const std::vector< FeatureMap > &maps, ConsensusMap &out) override
Applies the algorithm to feature maps.
InternalCalibration.h
OpenMS::FalseDiscoveryRate::applyPickedProteinFDR
void applyPickedProteinFDR(ProteinIdentification &id, String decoy_string="", bool prefix=true, bool groups_too=true)
Applies a picked protein FDR. Behaves like a normal target-decoy FDR where only the score of the best...
OpenMS::Math::RANSACParam
A simple struct to carry all the parameters required for a RANSAC run.
Definition: RANSAC.h:58
OpenMS::FeatureFinderIdentificationAlgorithm::getProgressLogger
ProgressLogger & getProgressLogger()
OpenMS::MzMLFile
File adapter for MzML files.
Definition: MzMLFile.h:57
OpenMS::String
A more convenient string class.
Definition: String.h:58
OpenMS::ProtonDistributionModel::FragmentationType
FragmentationType
the type of fragmentation
Definition: ProtonDistributionModel.h:95
OpenMS::Exception::FileNotFound
File not found exception.
Definition: Exception.h:509
MzMLFile.h
OpenMS::DoubleList
std::vector< double > DoubleList
Vector of double precision real types.
Definition: ListUtils.h:62
OpenMS::MSExperiment
In-Memory representation of a mass spectrometry run.
Definition: MSExperiment.h:70
OpenMS::IDFilter::updateProteinReferences
static void updateProteinReferences(std::vector< PeptideIdentification > &peptides, const std::vector< ProteinIdentification > &proteins, bool remove_peptides_without_reference=false)
Removes references to missing proteins.
OpenMS::CalibrationData::size
Size size() const
Number of calibration points.
OpenMS::PeakPickerHiRes::pickExperiment
void pickExperiment(const PeakMap &input, PeakMap &output, const bool check_spectrum_type=true) const
Applies the peak-picking algorithm to a map (MSExperiment). This method picks peaks for each scan in ...
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:127
IdXMLFile.h
FeatureXMLFile.h
OpenMS::Constants::c
const double c
Definition: Constants.h:209
OpenMS::IDFilter::updateProteinGroups
static bool updateProteinGroups(std::vector< ProteinIdentification::ProteinGroup > &groups, const std::vector< ProteinHit > &hits)
Update protein groups after protein hits were filtered.
OpenMS::IDConflictResolverAlgorithm::resolve
static void resolve(FeatureMap &features, bool keep_matching=false)
Resolves ambiguous annotations of features with peptide identifications. The the filtered identificat...
StatisticFunctions.h
MapAlignmentAlgorithmTreeGuided.h
MapAlignmentTransformer.h
OpenMS::PrecursorCorrection::correctToHighestIntensityMS1Peak
static std::set< Size > correctToHighestIntensityMS1Peak(MSExperiment &exp, double mz_tolerance, bool ppm, std::vector< double > &delta_mzs, std::vector< double > &mzs, std::vector< double > &rts)
Selection of the peak with the highest intensity as corrected precursor mass in a given mass range (e...
OpenMS::PeptideIndexing::run
ExitCodes run(std::vector< FASTAFile::FASTAEntry > &proteins, std::vector< ProteinIdentification > &prot_ids, std::vector< PeptideIdentification > &pep_ids)
forward for old interface and pyOpenMS; use other run() methods for more control
OpenMS::FeatureMap::setPrimaryMSRunPath
void setPrimaryMSRunPath(const StringList &s)
set the file path to the primary MS run (usually the mzML file obtained after data conversion from ra...
OpenMS::IDScoreSwitcherAlgorithm::switchToGeneralScoreType
void switchToGeneralScoreType(std::vector< PeptideIdentification > &id, ScoreType type, Size &counter)
Definition: IDScoreSwitcherAlgorithm.h:119
PeptideAndProteinQuant.h
OpenMS::IntList
std::vector< Int > IntList
Vector of signed integers.
Definition: ListUtils.h:55
OPENMS_PRECONDITION
#define OPENMS_PRECONDITION(condition, message)
Precondition macro.
Definition: openms/include/OpenMS/CONCEPT/Macros.h:120
OpenMS::FeatureFinderMultiplexAlgorithm::getFeatureMap
FeatureMap & getFeatureMap()
get methods
SpectrumMetaDataLookup.h
OpenMS::MSExperiment::clearMetaDataArrays
bool clearMetaDataArrays()
Clears the meta data arrays of all contained spectra (float, integer and string arrays)
OpenMS::ExperimentalDesign::MSFileSectionEntry::path
std::string path
file name, mandatory
Definition: ExperimentalDesign.h:258
OPENMS_LOG_WARN
#define OPENMS_LOG_WARN
Macro if a warning, a piece of information which should be read by the user, should be logged.
Definition: LogStream.h:460
OpenMS::InternalCalibration
A mass recalibration method using linear/quadratic interpolation (robust/weighted) of given reference...
Definition: InternalCalibration.h:62
OpenMS::ProtonDistributionModel::bb_charge_
std::vector< double > bb_charge_
Definition: ProtonDistributionModel.h:161
MZTrafoModel.h
OpenMS::PeptideIndexing::UNEXPECTED_RESULT
Definition: PeptideIndexing.h:127
OpenMS::IDMergerAlgorithm
Creates a new Protein ID run into which other runs can be inserted. Creates union of protein hits but...
Definition: IDMergerAlgorithm.h:61
OpenMS::TriqlerFile::storeLFQ
void storeLFQ(const String &filename, const ConsensusMap &consensus_map, const ExperimentalDesign &design, const StringList &reannotate_filenames, const String &condition)
store label free experiment
OpenMS::MSExperiment::size
Size size() const
Definition: MSExperiment.h:120
OpenMS::PeptideAndProteinQuant::quantifyPeptides
void quantifyPeptides(const std::vector< PeptideIdentification > &peptides=std::vector< PeptideIdentification >())
Compute peptide abundances.
OpenMS::DefaultParamHandler
A base class for all classes handling default parameters.
Definition: DefaultParamHandler.h:92
OpenMS::PeptideIndexing::isPrefix
bool isPrefix() const
Is the decoy string position a prefix or suffix?
OpenMS::FeatureFinderIdentificationAlgorithm
Definition: FeatureFinderIdentificationAlgorithm.h:56
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::ProtonDistributionModel::E_c_term_
double E_c_term_
Definition: ProtonDistributionModel.h:169
OpenMS::Exception::InvalidParameter
Exception indicating that an invalid parameter was handed over to an algorithm.
Definition: Exception.h:339
OPENMS_LOG_FATAL_ERROR
#define OPENMS_LOG_FATAL_ERROR
Macro to be used if fatal error are reported (processing stops)
Definition: LogStream.h:450
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::FeatureFinderIdentificationAlgorithm::run
void run(std::vector< PeptideIdentification > peptides, const std::vector< ProteinIdentification > &proteins, std::vector< PeptideIdentification > peptides_ext, std::vector< ProteinIdentification > proteins_ext, FeatureMap &features, const FeatureMap &seeds=FeatureMap(), const String spectra_file="")
OpenMS::File::validateMatchingFileNames
static bool validateMatchingFileNames(const StringList &sl1, const StringList &sl2, bool basename=true, bool ignore_extension=true, bool strict=false)
Helper function to test if filenames provided in two StringLists match.
OpenMS::InternalCalibration::calibrate
bool calibrate(PeakMap &exp, const IntList &target_mslvl, MZTrafoModel::MODELTYPE model_type, double rt_chunk, bool use_RANSAC, double post_ppm_median, double post_ppm_MAD, const String &file_models="", const String &file_models_plot="", const String &file_residuals="", const String &file_residuals_plot="", const String &rscript_executable="Rscript")
Apply calibration to data.
OpenMS::Math::getPPMAbs
T getPPMAbs(T mz_obs, T mz_ref)
Compute absolute parts-per-million of two m/z values.
Definition: MathFunctions.h:276
OpenMS::TransformationDescription::TransformationStatistics
Summary statistics before/after applying the transformation. For deviations before/after transformati...
Definition: TransformationDescription.h:72
MSstatsFile.h
MassTrace.h
OpenMS::Int
int Int
Signed integer type.
Definition: Types.h:102
OpenMS::TriqlerFile
File adapter for Triqler files.
Definition: TriqlerFile.h:57
OpenMS::ConsensusMap::sortPeptideIdentificationsByMapIndex
void sortPeptideIdentificationsByMapIndex()
Sorts PeptideIdentifications of consensus features with respect to their map index.
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:47
OpenMS::MSExperiment::addSpectrum
void addSpectrum(const MSSpectrum &spectrum)
adds a spectrum to the list
OpenMS::Param::addTag
void addTag(const std::string &key, const std::string &tag)
Adds the tag tag to the entry key.
OpenMS::PeakPickerHiRes
This class implements a fast peak-picking algorithm best suited for high resolution MS data (FT-ICR-M...
Definition: PeakPickerHiRes.h:81
OpenMS::BasicProteinInferenceAlgorithm
Algorithm class that implements simple protein inference by aggregation of peptide scores....
Definition: BasicProteinInferenceAlgorithm.h:60
OpenMS::IDFilter::removeUnreferencedProteins
static void removeUnreferencedProteins(ConsensusMap &cmap, bool include_unassigned)
OpenMS::ConsensusMap::appendColumns
ConsensusMap & appendColumns(const ConsensusMap &rhs)
Add consensus map entries as new columns.
OpenMS::MzMLFile::load
void load(const String &filename, PeakMap &map)
Loads a map from a MzML file. Spectra and chromatograms are sorted by default (this can be disabled u...
OpenMS::PeptideAndProteinQuant::readQuantData
void readQuantData(FeatureMap &features, const ExperimentalDesign &ed)
Read quantitative data from a feature map.
TransformationXMLFile.h
OpenMS::IDScoreSwitcherAlgorithm::switchScores
void switchScores(IDType &id, Size &counter)
Definition: IDScoreSwitcherAlgorithm.h:78
OpenMS::ProtonDistributionModel::bb_charge_full_
std::vector< double > bb_charge_full_
Definition: ProtonDistributionModel.h:163
OpenMS::ConsensusMap::getProteinIdentifications
const std::vector< ProteinIdentification > & getProteinIdentifications() const
non-mutable access to the protein identifications
OpenMS::ExperimentalDesign::MSFileSectionEntry::fraction
unsigned fraction
fraction 1..m, mandatory, 1 if not set
Definition: ExperimentalDesign.h:257
OpenMS::ExperimentalDesign::getNumberOfLabels
unsigned getNumberOfLabels() const
OpenMS::IDFilter::keepBestPeptideHits
static void keepBestPeptideHits(std::vector< PeptideIdentification > &peptides, bool strict=false)
Filters peptide identifications keeping only the single best-scoring hit per ID.
OpenMS::ProtonDistributionModel::bb_charge_ion_n_term_
std::vector< double > bb_charge_ion_n_term_
Definition: ProtonDistributionModel.h:165
OpenMS::FalseDiscoveryRate::applyBasic
void applyBasic(const std::vector< ProteinIdentification > &run_info, std::vector< PeptideIdentification > &ids)
simpler reimplementation of the apply function above for PSMs. With charge and identifier info from r...
OpenMS::PeptideEvidence
Representation of a peptide evidence.
Definition: PeptideEvidence.h:50
PeakTypeEstimator.h
OpenMS::Math::getPPM
T getPPM(T mz_obs, T mz_ref)
Compute parts-per-million of two m/z values.
Definition: MathFunctions.h:261
OpenMS::ConsensusFeature
A consensus feature spanning multiple LC-MS/MS experiments.
Definition: ConsensusFeature.h:69
OpenMS::ExperimentalDesign::getPathLabelToFractionGroupMapping
std::map< std::pair< String, unsigned >, unsigned > getPathLabelToFractionGroupMapping(bool use_basename_only) const
return <file_path, label> to fraction_group mapping
PrecursorCorrection.h
MapAlignmentAlgorithmIdentification.h
OpenMS::MapAlignmentAlgorithmIdentification::align
void align(std::vector< DataType > &data, std::vector< TransformationDescription > &transformations, Int reference_index=-1)
Align feature maps, consensus maps, peak maps, or peptide identifications.
Definition: MapAlignmentAlgorithmIdentification.h:112
OpenMS::ProtonDistributionModel::bb_charge_ion_c_term_
std::vector< double > bb_charge_ion_c_term_
Definition: ProtonDistributionModel.h:167
OpenMS::MzTabFile::store
void store(const String &filename, const MzTab &mz_tab) const
OpenMS::UniqueIdInterface::setUniqueId
Size setUniqueId()
Assigns a new, valid unique id. Always returns 1.
OpenMS::Math::MAD
double MAD(IteratorType begin, IteratorType end, double median_of_numbers)
median absolute deviation (MAD)
Definition: StatisticFunctions.h:185
BasicProteinInferenceAlgorithm.h
OpenMS::ExperimentalDesign::MSFileSectionEntry::fraction_group
unsigned fraction_group
fraction group id
Definition: ExperimentalDesign.h:256
OpenMS::IDScoreSwitcherAlgorithm
Definition: IDScoreSwitcherAlgorithm.h:48
IDBoostGraph.h
OpenMS::ConsensusMap::getUnassignedPeptideIdentifications
const std::vector< PeptideIdentification > & getUnassignedPeptideIdentifications() const
non-mutable access to the unassigned peptide identifications
OpenMS::DefaultParamHandler::setParameters
void setParameters(const Param &param)
Sets the parameters.
OpenMS::DefaultParamHandler::getDefaults
const Param & getDefaults() const
Non-mutable access to the default parameters.
MzTab.h
OpenMS::ProtonDistributionModel::ChargeRemote
Definition: ProtonDistributionModel.h:98
OpenMS::DefaultParamHandler::getParameters
const Param & getParameters() const
Non-mutable access to the parameters.
OpenMS::MSExperiment::empty
bool empty() const
Definition: MSExperiment.h:130
OpenMS::ExperimentalDesign::MSFileSectionEntry
Definition: ExperimentalDesign.h:252
OpenMS::DataProcessing::FEATURE_GROUPING
Feature grouping
Definition: DataProcessing.h:73
OpenMS::Residue::ResidueType
ResidueType
Definition: Residue.h:151
OpenMS::PeptideIndexing::ExitCodes
ExitCodes
Exit codes.
Definition: PeptideIndexing.h:121
OpenMS::MZTrafoModel::LINEAR
Definition: MZTrafoModel.h:97
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::FeatureXMLFile::store
void store(const String &filename, const FeatureMap &feature_map)
stores the map feature_map in file with name filename.
OpenMS::ProtonDistributionModel::E_
double E_
Definition: ProtonDistributionModel.h:168
OpenMS::MapAlignmentAlgorithmTreeGuided::align
void align(std::vector< FeatureMap > &data, std::vector< TransformationDescription > &transformations)
Align feature maps tree guided using align() of OpenMS::MapAlignmentAlgorithmIdentification and use T...
OpenMS::MapAlignmentAlgorithmIdentification
A map alignment algorithm based on peptide identifications from MS2 spectra.
Definition: MapAlignmentAlgorithmIdentification.h:72
OpenMS::FalseDiscoveryRate
Calculates false discovery rates (FDR) from identifications.
Definition: FalseDiscoveryRate.h:77
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::ExperimentalDesign::MSFileSection
std::vector< MSFileSectionEntry > MSFileSection
Definition: ExperimentalDesign.h:312
Residue.h
MSExperiment.h
OpenMS::BasicProteinInferenceAlgorithm::run
void run(std::vector< PeptideIdentification > &pep_ids, std::vector< ProteinIdentification > &prot_ids) const
OpenMS::ConsensusMap::getColumnHeaders
const ColumnHeaders & getColumnHeaders() const
Non-mutable access to the file descriptions.
OpenMS::ProtonDistributionModel::sc_charge_ion_n_term_
std::vector< double > sc_charge_ion_n_term_
Definition: ProtonDistributionModel.h:164
OPENMS_LOG_ERROR
#define OPENMS_LOG_ERROR
Macro to be used if non-fatal error are reported (processing continues)
Definition: LogStream.h:455
OpenMS::File::absolutePath
static String absolutePath(const String &file)
Replaces the relative path in the argument with the absolute path.
OpenMS::PeptideAndProteinQuant::getProteinResults
const ProteinQuant & getProteinResults()
Get protein abundance data.
OpenMS::FeatureMap
A container for features.
Definition: FeatureMap.h:98
OpenMS::IDScoreSwitcherAlgorithm::ScoreType::PEP
OpenMS::OpenMS_Log_debug
Logger::LogStream OpenMS_Log_debug
Global static instance of a LogStream to capture messages classified as debug output....
OpenMS::PeptideIdentification
Represents the peptide hits for a spectrum.
Definition: PeptideIdentification.h:63
OpenMS::TransformationXMLFile
Used to load and store TransformationXML files.
Definition: TransformationXMLFile.h:56
OpenMS::ThresholdMower::filterPeakMap
void filterPeakMap(PeakMap &exp)
OpenMS::Param::copy
Param copy(const std::string &prefix, bool remove_prefix=false) const
Returns a new Param object containing all entries that start with prefix.
OpenMS::ConsensusMap::clear
void clear(bool clear_meta_data=true)
Clears all data and meta data.
IDConflictResolverAlgorithm.h
FeatureGroupingAlgorithmQT.h
OpenMS::PeptideIndexing::DATABASE_EMPTY
Definition: PeptideIndexing.h:124
OpenMS::PeptideIndexing
Refreshes the protein references for all peptide hits in a vector of PeptideIdentifications and adds ...
Definition: PeptideIndexing.h:113
OpenMS::FeatureXMLFile
This class provides Input/Output functionality for feature maps.
Definition: FeatureXMLFile.h:62
OpenMS::ExperimentalDesign::getNumberOfFractionGroups
unsigned getNumberOfFractionGroups() const
OpenMS::ThresholdMower
ThresholdMower removes all peaks below a threshold.
Definition: ThresholdMower.h:51
OpenMS::FeatureFinderMultiplexAlgorithm
Definition: FeatureFinderMultiplexAlgorithm.h:56
OpenMS::IDFilter::removeEmptyIdentifications
static void removeEmptyIdentifications(std::vector< IdentificationType > &ids)
Removes peptide or protein identifications that have no hits in them.
Definition: IDFilter.h:828
ElutionPeakDetection.h
PeptideIndexing.h
OpenMS::ProtonDistributionModel::sc_charge_full_
std::vector< double > sc_charge_full_
Definition: ProtonDistributionModel.h:162
OpenMS::MassTraceDetection::run
void run(const PeakMap &, std::vector< MassTrace > &, const Size max_traces=0)
Main method of MassTraceDetection. Extracts mass traces of a MSExperiment and gathers them into a vec...
OpenMS::FileHandler::stripExtension
static String stripExtension(const String &filename)
If filename contains an extension, it will be removed (including the '.'). Special extensions,...
OpenMS::MapAlignmentAlgorithmTreeGuided
A map alignment algorithm based on peptide identifications from MS2 spectra.
Definition: MapAlignmentAlgorithmTreeGuided.h:70
MapAlignerBase.h
OpenMS::Param
Management and storage of parameters / INI files.
Definition: Param.h:69
OpenMS::PeptideIndexing::getDecoyString
const String & getDecoyString() const
Which string is used to determine if a protein is a decoy or not.
OpenMS::TransformationXMLFile::store
void store(String filename, const TransformationDescription &transformation)
Stores the data in an TransformationXML file.
OpenMS::MSExperiment::clear
void clear(bool clear_meta_data)
Clears all data and meta data.
OpenMS::AASequence
Representation of a peptide/protein sequence.
Definition: AASequence.h:111
OpenMS::ExperimentalDesign::MSFileSectionEntry::label
unsigned label
the label (e.g.,: 1 for label-free, 1..8 for TMT8plex)
Definition: ExperimentalDesign.h:259
IDFilter.h
CalibrationData.h
OPENMS_POSTCONDITION
#define OPENMS_POSTCONDITION(condition, message)
Postcondition macro.
Definition: openms/include/OpenMS/CONCEPT/Macros.h:127
FeatureFinderMultiplexAlgorithm.h
OpenMS::MSstatsFile::storeLFQ
void storeLFQ(const String &filename, const ConsensusMap &consensus_map, const ExperimentalDesign &design, const StringList &reannotate_filenames, const bool is_isotope_label_type, const String &bioreplicate, const String &condition, const String &retention_time_summarization_method)
store label free experiment (MSstats)
OpenMS::MSstatsFile
File adapter for MSstats files.
Definition: MSstatsFile.h:57
OpenMS::IDFilter::filterHitsByScore
static void filterHitsByScore(std::vector< IdentificationType > &ids, double threshold_score)
Filters peptide or protein identifications according to the score of the hits.
Definition: IDFilter.h:840
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
OpenMS::Residue::YIon
MS:1001220 peptide bond up to the C-terminus.
Definition: Residue.h:161
OpenMS::ExperimentalDesign::setMSFileSection
void setMSFileSection(const MSFileSection &msfile_section)
PeakPickerHiRes.h
OpenMS::ExperimentalDesign::filterByBasenames
Size filterByBasenames(const std::set< String > &bns)
OpenMS::IDFilter::removeDecoyHits
static void removeDecoyHits(std::vector< IdentificationType > &ids)
Removes hits annotated as decoys from peptide or protein identifications.
Definition: IDFilter.h:940
OpenMS::PeptideIndexing::EXECUTION_OK
Definition: PeptideIndexing.h:123
MSDataWritingConsumer.h
BayesianProteinInferenceAlgorithm.h
MassTraceDetection.h
OpenMS::ProtonDistributionModel::sc_charge_
std::vector< double > sc_charge_
Definition: ProtonDistributionModel.h:160
OpenMS::Internal::IDBoostGraph
Creates and maintains a boost graph based on the OpenMS ID datastructures.
Definition: IDBoostGraph.h:80
OpenMS::Param::getValue
const ParamValue & getValue(const std::string &key) const
Returns a value of a parameter.
FalseDiscoveryRate.h
OpenMS::ConsensusMapNormalizerAlgorithmMedian::NM_SCALE
Definition: ConsensusMapNormalizerAlgorithmMedian.h:70
OpenMS::TransformationDescription
Generic description of a coordinate transformation.
Definition: TransformationDescription.h:62
OpenMS::Param::remove
void remove(const std::string &key)
Remove the entry key or a section key (when suffix is ':')
OpenMS::ConsensusMapNormalizerAlgorithmMedian::normalizeMaps
static void normalizeMaps(ConsensusMap &map, NormalizationMethod method, const String &acc_filter, const String &desc_filter)
normalizes the maps of the consensusMap
OpenMS::ConsensusMap::setExperimentType
void setExperimentType(const String &experiment_type)
Mutable access to the experiment type.
FeatureFinderIdentificationAlgorithm.h
OpenMS::InternalCalibration::fillCalibrants
Size fillCalibrants(const PeakMap &exp, const std::vector< InternalCalibration::LockMass > &ref_masses, double tol_ppm, bool lock_require_mono, bool lock_require_iso, CalibrationData &failed_lock_masses, bool verbose=true)
Extract calibrants from Raw data (mzML)
File.h
PeptideProteinResolution.h
OpenMS::ProgressLogger::setLogType
void setLogType(LogType type) const
Sets the progress log that should be used. The default type is NONE!
TOPPBase.h
OpenMS::ExperimentalDesign::sameNrOfMSFilesPerFraction
bool sameNrOfMSFilesPerFraction() const
OpenMS::PeptideAndProteinQuant::quantifyProteins
void quantifyProteins(const ProteinIdentification &proteins=ProteinIdentification())
Compute protein abundances.
OpenMS::InternalCalibration::getCalibrationPoints
const CalibrationData & getCalibrationPoints() const
Get container of calibration points.
OpenMS::ProtonDistributionModel::E_n_term_
double E_n_term_
Definition: ProtonDistributionModel.h:170
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
ThresholdMower.h
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.
ConsensusMapNormalizerAlgorithmMedian.h
OpenMS::FASTAContainer< TFI_File >
FASTAContainer<TFI_File> will make FASTA entries available chunk-wise from start to end by loading it...
Definition: FASTAContainer.h:93
OpenMS::MSExperiment::swap
void swap(MSExperiment &from)
Swaps the content of this map with the content of from.
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::BayesianProteinInferenceAlgorithm::inferPosteriorProbabilities
void inferPosteriorProbabilities(std::vector< ProteinIdentification > &proteinIDs, std::vector< PeptideIdentification > &peptideIDs, bool greedy_group_resolution, std::optional< const ExperimentalDesign > exp_des=std::optional< const ExperimentalDesign >())