MRMDecoy.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: George Rosenberger $
// $Authors: George Rosenberger, Hannes Roest $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/ANALYSIS/OPENSWATH/MRMIonSeries.h>
#include <OpenMS/ANALYSIS/TARGETED/TargetedExperiment.h>
#include <OpenMS/CONCEPT/ProgressLogger.h>
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/TransitionExperiment.h>
 
 
#include <string>
#include <utility> // for pair
#include <vector>
#include <map>
 
// #define DEBUG_MRMDECOY
 
namespace OpenMS
{
  class OPENMS_DLLAPI MRMDecoy :
    public DefaultParamHandler,
    public ProgressLogger
  {
 
public:
 
    typedef std::vector<size_t> IndexType;
 
    MRMDecoy();
 
    void generateDecoys(const OpenMS::TargetedExperiment& exp,
                        OpenMS::TargetedExperiment& dec,
                        const std::string& method,
                        const double aim_decoy_fraction,
                        const bool switchKR,
                        const std::string& decoy_tag,
                        const int max_attempts,
                        const double identity_threshold,
                        const double precursor_mz_shift,
                        const double product_mz_shift,
                        const double product_mz_threshold,
                        const std::vector<std::string>& fragment_types,
                        const std::vector<size_t>& fragment_charges,
                        const bool enable_specific_losses,
                        const bool enable_unspecific_losses,
                        const int round_decPow = -4,
                        const Int shuffle_seed = 1) const;
 
    void generateDecoysLight(const OpenSwath::LightTargetedExperiment& exp,
                             OpenSwath::LightTargetedExperiment& dec,
                             const std::string& method,
                             const double aim_decoy_fraction,
                             const bool switchKR,
                             const std::string& decoy_tag,
                             const int max_attempts,
                             const double identity_threshold,
                             const double precursor_mz_shift,
                             const double product_mz_shift,
                             const double product_mz_threshold,
                             const std::vector<std::string>& fragment_types,
                             const std::vector<size_t>& fragment_charges,
                             const bool enable_specific_losses,
                             const bool enable_unspecific_losses,
                             const int round_decPow = -4,
                             const Int shuffle_seed = 1) const;
 
    void switchKR(OpenMS::TargetedExperiment::Peptide& peptide) const;
 
    typedef std::vector<OpenMS::TargetedExperiment::Protein> ProteinVectorType;
    typedef std::vector<OpenMS::TargetedExperiment::Peptide> PeptideVectorType;
    typedef std::vector<OpenMS::ReactionMonitoringTransition> TransitionVectorType;
 
    typedef std::map<std::string, std::vector<const ReactionMonitoringTransition*> > PeptideTransitionMapType;
 
    float AASequenceIdentity(const std::string& sequence, const std::string& decoy) const;
 
    OpenMS::TargetedExperiment::Peptide shufflePeptide(
                OpenMS::TargetedExperiment::Peptide peptide,
                const double identity_threshold,
                int seed = -1,
                const int max_attempts = 100) const;
 
    static OpenMS::TargetedExperiment::Peptide reversePeptide(
                const OpenMS::TargetedExperiment::Peptide& peptide,
                const bool keepN,
                const bool keepC,
                const std::string& const_pattern = std::string());
 
    static IndexType findFixedResidues(const std::string& sequence,
        bool keepN, bool keepC, const std::string& keep_const_pattern);
 
    static std::pair<std::string, std::vector<OpenSwath::LightModification>> reversePeptideLight(
        const std::string& sequence,
        const std::vector<OpenSwath::LightModification>& modifications,
        bool keepN,
        bool keepC,
        const std::string& const_pattern = std::string());
 
    std::pair<std::string, std::vector<OpenSwath::LightModification>> shufflePeptideLight(
        const std::string& sequence,
        const std::vector<OpenSwath::LightModification>& modifications,
        double identity_threshold,
        int seed = -1,
        int max_attempts = 100) const;
 
    static void switchKRLight(std::string& sequence);
 
protected:
 
    bool hasCNterminalMods_(const OpenMS::TargetedExperiment::Peptide& peptide, bool checkCterminalAA) const;
 
    static bool hasCNterminalModsLight_(
        const std::vector<OpenSwath::LightModification>& modifications,
        size_t sequence_length,
        bool checkCterminalAA);
 
    std::pair<std::string, std::vector<OpenSwath::LightModification>> pseudoreversePeptideLight_(
        const std::string& sequence,
        const std::vector<OpenSwath::LightModification>& modifications) const;
 
    IndexType findFixedResidues_(const std::string& sequence) const;
 
    IndexType findFixedAndTermResidues_(const std::string& sequence) const;
 
    OpenMS::TargetedExperiment::Peptide pseudoreversePeptide_(
      const OpenMS::TargetedExperiment::Peptide& peptide) const;
 
    OpenMS::TargetedExperiment::Peptide reversePeptide_(
      const OpenMS::TargetedExperiment::Peptide& peptide) const;
 
    std::string getModifiedPeptideSequence_(const OpenMS::TargetedExperiment::Peptide& pep) const;
 
    void updateMembers_() override;
 
    std::string keep_const_pattern_;
    bool keepN_;
    bool keepC_;
  };
}