MultiplexResolverAlgorithm.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: Timo Sachsenberg $
// $Authors: Lars Nilse, Timo Sachsenberg $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
#include <OpenMS/FEATUREFINDER/MultiplexDeltaMasses.h>
#include <OpenMS/KERNEL/ConsensusMap.h>
#include <OpenMS/KERNEL/MSExperiment.h>
 
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace OpenMS
{
  class AASequence;
  class MultiplexDeltaMassesGenerator;
 
  class OPENMS_DLLAPI MultiplexResolverAlgorithm : public DefaultParamHandler
  {
  public:
    MultiplexResolverAlgorithm();
 
    void resolve(const ConsensusMap& map_in, ConsensusMap& map_out, ConsensusMap& map_conflicts,
                 const MSExperiment& blacklist = MSExperiment()) const;
 
    std::vector<bool> checkIdentifications(const ConsensusFeature& consensus) const;
 
    std::vector<double> expectedChannelMZs(const AASequence& sequence, int charge, Size& position) const;
 
    static bool hasBlacklistOwners(const MSExperiment& blacklist);
 
    static UInt64 blacklistOwner(const MSSpectrum& spectrum, Size peak_index);
 
    static void setBlacklistOwners(MSSpectrum& spectrum, const std::vector<UInt64>& owners);
 
    enum class OwnerRelation
    {
      ORPHAN,        
      OWN,           
      SAME_PEPTIDE,  
      UNIDENTIFIED,  
      OTHER_PEPTIDE  
    };
 
    using OwnerPeptides = std::unordered_map<UInt64, std::string>;
 
    OwnerPeptides ownerPeptides(const ConsensusMap& multiplets) const;
 
    std::string peptideKey(const PeptideHit& hit, int charge) const;
 
    static OwnerRelation classifyBlacklistOwner(UInt64 owner, const ConsensusFeature& consensus, const OwnerPeptides& peptides);
 
    static OwnerRelation classifyBlacklistOwner(UInt64 owner, const std::string& peptide, const OwnerPeptides& peptides);
 
    static bool isForeign(OwnerRelation relation);
 
  protected:
    MultiplexDeltaMassesGenerator createGenerator_() const;
 
    static double deltaMassFromMapIndex_(const ConsensusFeature::HandleSetType& feature_handles, unsigned idx);
 
    static double matchLabelSet_(const std::vector<MultiplexDeltaMasses::DeltaMass>& pattern,
                                 const MultiplexDeltaMasses::LabelSet& label_set, int& index_label_set);
 
    bool matchDeltaMasses_(const ConsensusFeature& consensus, double detected_delta_mass_at_label_set,
                           const std::vector<MultiplexDeltaMasses::DeltaMass>& pattern,
                           double theoretical_delta_mass_at_label_set, std::vector<bool>& delta_mass_matched) const;
 
    int findMatchingPattern_(const ConsensusFeature& consensus, double detected_delta_mass_at_label_set,
                             const AASequence& sequence, const MultiplexDeltaMasses::LabelSet& label_set,
                             const std::vector<MultiplexDeltaMasses>& theoretical_patterns,
                             const std::vector<std::vector<std::string>>& samples,
                             std::vector<bool>& delta_mass_matched, int& index_label_set) const;
 
    static bool matchesResidues_(const std::vector<MultiplexDeltaMasses::DeltaMass>& pattern, const AASequence& sequence,
                                 const std::vector<std::vector<std::string>>& samples);
 
    static double findNewMZ_(double mz, int charge, const std::vector<MultiplexDeltaMasses::DeltaMass>& pattern,
                             const std::vector<bool>& delta_mass_matched);
 
    bool isBlacklisted_(const MSExperiment& blacklist, double rt, double mz, size_t charge, const ConsensusFeature& consensus) const;
 
    struct OwnerCheckCounts_
    {
      Size dummies = 0;        
      Size added = 0;          
      Size dummies_vetoed = 0; 
      Size added_vetoed = 0;   
      Size other_peptide = 0;  
      Size same_peptide = 0;   
      Size unidentified = 0;   
      Size usable = 0;         
      Size own = 0;            
      Size orphan = 0;         
      Size anonymous = 0;      
    };
 
    bool isReservedByOther_(const MSExperiment& blacklist, double rt, double mz, size_t charge, const ConsensusFeature& consensus,
                            const OwnerPeptides& peptides, OwnerCheckCounts_& counts) const;
 
    ConsensusFeature completeConsensus_(const ConsensusFeature& consensus, const std::vector<MultiplexDeltaMasses::DeltaMass>& pattern,
                                        const std::vector<bool>& delta_mass_matched, int index_label_set,
                                        const MSExperiment& blacklist, const OwnerPeptides* peptides = nullptr,
                                        OwnerCheckCounts_* counts = nullptr) const;
 
    double mass_tolerance_ = 0.1;
    double mz_tolerance_ = 10.0;
    double rt_tolerance_ = 5.0;
    bool use_blacklist_owners_ = false;
 
    void updateMembers_() override;
  };
} // namespace OpenMS