FragmentIonLikelihoodModel.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: Timo Sachsenberg, Oliver Kohlbacher $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CHEMISTRY/Residue.h>
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/Macros.h>
#include <OpenMS/KERNEL/MSSpectrum.h>
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace OpenMS
{
  class AASequence;
 
  class OPENMS_DLLAPI FragmentIonLikelihoodModel
  {
  public:
    enum class ContextSet
    {
      BASIC, 
      RICH   
    };
 
    static constexpr Size SERIES = 4;
    static constexpr Size PRECURSOR_BUCKETS = 3; 
    static constexpr Size FRAGMENT_CHARGES = 2;  
    static constexpr Size POSITION_BINS = 10;    
    static constexpr Size CLEAVAGE_SITES = 3;    
    static constexpr Size COMPLEMENT_STATES = 2; 
    static constexpr Size RANK_BINS = 7;         
    static constexpr Size ERROR_BINS = 3;        
 
    class OPENMS_DLLAPI PeakLists
    {
    public:
      void reset(Size spectra);
 
      void clear();
 
      Size size() const { return mz_.size(); }
 
      void assign(Size index, const MSSpectrum& spectrum);
 
      Size peaks(Size index) const { return mz_[index].size(); }
 
      double mz(Size index, Size peak) const { return mz_[index][peak]; }
 
      Size rankBin(Size index, Size peak) const { return rank_bins_[index][peak]; }
 
      Int findNearest(Size index, double mz, double tolerance) const;
 
      Size totalPeaks() const;
 
      Size memoryUsage() const;
 
    private:
      std::vector<std::vector<float>> mz_;        
      std::vector<std::vector<std::uint8_t>> rank_bins_; 
    };
 
    struct Ion
    {
      UInt32 context; 
      UInt32 outcome; 
    };
 
    struct Features
    {
      double log_likelihood_ratio = 0.0;   
      double explained_presence = 0.0;     
      double top_predicted_observed = 0.0; 
      Size matched_ions = 0;               
      Size theoretical_ions = 0;           
    };
 
    explicit FragmentIonLikelihoodModel(ContextSet context_set = ContextSet::RICH, double pseudo_count = 20.0);
 
    ContextSet contextSet() const { return context_set_; }
 
    Size contexts() const { return contexts_; }
 
    Size outcomes() const { return outcomes_; }
 
    Size absentOutcome() const { return outcomes_ - 1; }
 
    static Size rankBin(Size rank);
 
    static Size errorBin(double relative_error);
 
    static bool parseIonName(const std::string& name, bool& prefix, Size& ordinal);
 
    static bool parseIonSeries(const std::string& name, Size& series, Size& ordinal);
 
    static Size seriesOf(Residue::ResidueType type);
 
    void matchIons(const PeakLists& peaks,
                   Size index,
                   const MSSpectrum& theoretical,
                   const AASequence& peptide,
                   int precursor_charge,
                   double tolerance,
                   bool ppm,
                   std::vector<Ion>& ions) const;
 
    void matchIons(const PeakLists& peaks,
                   Size index,
                   const MSSpectrum& theoretical,
                   const std::vector<Residue::ResidueType>& ion_types,
                   const std::vector<UInt>& ion_ordinals,
                   const std::vector<Int>& ion_charges,
                   const AASequence& peptide,
                   int precursor_charge,
                   double tolerance,
                   bool ppm,
                   std::vector<Ion>& ions) const;
 
    void addObservations(const std::vector<Ion>& ions, bool noise);
 
    void finalize();
 
    bool isTrained() const { return finalized_; }
 
    Size signalPsms() const { return signal_psms_; }
 
    Size noisePsms() const { return noise_psms_; }
 
    double pseudoCount() const { return pseudo_count_; }
 
    double logLikelihoodRatio(Size context, Size outcome) const;
 
    double presenceProbability(Size context) const;
 
    Features score(const std::vector<Ion>& ions, Size top_k = 6) const;
 
  private:
    template <typename IonOf, typename ChargeOf>
    void matchIons_(const PeakLists& peaks, Size index, const MSSpectrum& theoretical, IonOf&& ion_of, ChargeOf&& charge_of,
                    const AASequence& peptide, int precursor_charge, double tolerance, bool ppm, std::vector<Ion>& ions) const;
 
    Size level1Context_(Size context) const;
    Size level2Context_(Size context) const;
 
    std::vector<double> smooth_(const std::vector<double>& counts) const;
 
    void requireTrained_() const;
 
    ContextSet context_set_;
    Size sites_;      
    Size complement_; 
    Size errors_;     
    Size contexts_;
    Size outcomes_;
    std::vector<double> signal_counts_; 
    std::vector<double> noise_counts_;  
    std::vector<double> signal_logp_;   
    std::vector<double> noise_logp_;    
    Size signal_psms_ = 0;
    Size noise_psms_ = 0;
    double pseudo_count_ = 20.0;
    bool finalized_ = false;
  };
} // namespace OpenMS