FLASHHelperClasses.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Kyowon Jeong, Jihyung Kim $
// $Authors: Kyowon Jeong, Jihyung Kim $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/APPLICATIONS/TOPPBase.h>
#include <OpenMS/CHEMISTRY/ISOTOPEDISTRIBUTION/CoarseIsotopePatternGenerator.h>
#include <OpenMS/CHEMISTRY/ISOTOPEDISTRIBUTION/IsotopeDistribution.h>
#include <OpenMS/CONCEPT/Constants.h>
#include <OpenMS/FILTERING/DATAREDUCTION/MassTraceDetection.h>
#include <boost/dynamic_bitset.hpp>
 
namespace OpenMS
{
struct OPENMS_DLLAPI FLASHHelperClasses
{
  class OPENMS_DLLAPI PrecalculatedAveragine
  {
  private:
    std::vector<IsotopeDistribution> isotopes_;
    std::vector<double> norms_;
    std::vector<double> average_mono_mass_difference_;
    std::vector<double> abundant_mono_mass_difference_;
 
    std::vector<double> snr_mul_factor_;
    std::vector<int> left_count_from_apex_;
    std::vector<int> right_count_from_apex_;
    std::vector<Size> apex_index_;
 
    Size max_isotope_index_;
    double mass_interval_;
    double min_mass_;
    Size massToIndex_(double mass) const;
 
  public:
    PrecalculatedAveragine() = default;
 
    PrecalculatedAveragine(double min_mass, double max_mass, double delta, CoarseIsotopePatternGenerator& generator, bool use_RNA_averagine, double decoy_iso_distance = -1, bool is_centroid = true);
 
    PrecalculatedAveragine(const PrecalculatedAveragine&) = default;
 
    PrecalculatedAveragine(PrecalculatedAveragine&& other) noexcept = default;
 
    PrecalculatedAveragine& operator=(const PrecalculatedAveragine& pc) = default;
 
    PrecalculatedAveragine& operator=(PrecalculatedAveragine&& pc) noexcept = default;
 
    ~PrecalculatedAveragine() = default;
 
 
    IsotopeDistribution get(double mass) const;
 
    size_t getMaxIsotopeIndex() const;
 
    void setMaxIsotopeIndex(int index);
 
    Size getLeftCountFromApex(double mass) const;
 
    Size getRightCountFromApex(double mass) const;
 
    Size getApexIndex(double mass) const;
 
    Size getLastIndex(double mass) const;
 
    double getAverageMassDelta(double mass) const;
 
    double getMostAbundantMassDelta(double mass) const;
 
    double getSNRMultiplicationFactor(double mass) const;
  };
 
  struct OPENMS_DLLAPI MassFeature
  {
  public:
    uint index;
    MassTrace mt;
    std::vector<float> per_charge_intensity;
    std::vector<float> per_isotope_intensity;
    int iso_offset;
    int scan_number, min_scan_number, max_scan_number, rep_charge;
    double avg_mass;
    int min_charge, max_charge, charge_count;
    double isotope_score, qscore;
    double rep_mz;
    bool is_decoy;
    uint ms_level;
    bool operator<(const MassFeature& a) const
    {
      return avg_mass < a.avg_mass;
    }
    bool operator>(const MassFeature& a) const
    {
      return avg_mass > a.avg_mass;
    }
    bool operator==(const MassFeature& other) const
    {
      return avg_mass == other.avg_mass;
    }
  };
 
  struct OPENMS_DLLAPI IsobaricQuantities
  {
  public:
    int scan;
    double rt;
    double precursor_mz;
    double precursor_mass;
    std::vector<double> quantities;
    std::vector<double> merged_quantities;
 
    bool empty() const;
  };
 
  class OPENMS_DLLAPI LogMzPeak
  {
  public:
    double mz = 0;
    float intensity = 0;
    double logMz = -1000;
    double mass = .0;
    int abs_charge = 0;
    bool is_positive = true;
    int isotopeIndex = -1;
 
    LogMzPeak() = default;
 
    explicit LogMzPeak(const Peak1D& peak, bool positive);
 
    LogMzPeak(const LogMzPeak&) = default;
 
    ~LogMzPeak() = default;
 
    double getUnchargedMass() const;
 
    bool operator<(const LogMzPeak& a) const;
    bool operator>(const LogMzPeak& a) const;
    bool operator==(const LogMzPeak& other) const;
  };
 
  class OPENMS_DLLAPI Tag
  {
  public:
    explicit Tag(String seq, double n_mass, double c_mass, std::vector<double>& mzs, std::vector<int>& scores, int scan);
 
    Tag(const Tag&) = default;
 
    ~Tag() = default;
 
    bool operator<(const Tag& a) const;
    bool operator>(const Tag& a) const;
    bool operator==(const Tag& other) const;
 
    const String& getSequence() const;
    const String& getUppercaseSequence() const;
    double getNtermMass() const;
    double getCtermMass() const;
    Size getLength() const;
    int getScore() const;
    int getScore(int pos) const;
    int getScan() const;
    int getIndex() const
    {
      return index_;
    }
 
    void setIndex(int i)
    {
      index_ = i;
    }
    float getRetentionTime() const
    {
      return rt_;
    }
 
    void setRetentionTime(float i)
    {
      rt_ = i;
    }
 
 
    String toString() const;
    const std::vector<double>& getMzs() const;
 
  private:
    String seq_, upper_seq_;
    double n_mass_ = -1, c_mass_ = -1;
    float rt_ = -1;
    std::vector<double> mzs_;
    std::vector<int> scores_;
    int scan_;
    int index_;
    Size length_;
  };
 
  class OPENMS_DLLAPI DAG
  {
  public:
    DAG()
    {
    }
    explicit DAG(Size vertice_count): vertex_count_(vertice_count)
    {
    }
 
    Size size() const
    {
      return vertex_count_;
    }
 
    bool addEdge(Size vertex1, Size vertex2, boost::dynamic_bitset<>& visited)
    {
      if (vertex1 >= vertex_count_ || vertex2 >= vertex_count_) return false;
      if (! visited[vertex2]) return false;
      visited[vertex1] = true;
      adj_list_for_speed_up_[vertex2].insert(vertex1); //
      return true;
    }
 
    bool hasEdge(Size vertex1, Size vertex2) const
    {
      auto iter = adj_list_for_speed_up_.find(vertex2);
      if (iter == adj_list_for_speed_up_.end()) return false;
      return iter->second.find(vertex1) != iter->second.end();
    }
 
    void findAllPaths(Size source, Size sink, std::vector<std::vector<Size>>& all_paths, Size max_count)
    {
      std::unordered_set<Size> visited;
      std::vector<Size> path;
 
      if (adj_list_.empty())
      {
        for (const auto& [v2, vertices] : adj_list_for_speed_up_)
        {
          for (const auto& v1 : vertices)
          {
            adj_list_[v1].push_back(v2);
          }
        }
        for (auto& v : adj_list_)
        {
          std::sort(v.second.begin(), v.second.end());
        }
      }
 
      findAllPaths_(source, sink, visited, path, all_paths, max_count); // reverse traveling
    }
 
  private:
    Size vertex_count_;
    // 0, 1, 2, ... ,vertex_count - 1
    std::map<Size, std::vector<Size>> adj_list_; //
    std::unordered_map<Size, std::unordered_set<Size>> adj_list_for_speed_up_; // vertex swapped for fast stroing of edges
    void findAllPaths_(Size current,
                       Size destination,
                       std::unordered_set<Size>& visited,
                       std::vector<Size>& path,
                       std::vector<std::vector<Size>>& all_paths,
                       Size max_count)
    {
      if (max_count > 0 && all_paths.size() >= max_count) return;
 
      visited.insert(current);
      path.push_back(current);
 
      if (current == destination) { all_paths.push_back(path);}
      else
      {
        for (Size i : adj_list_[current])
        {
          if (visited.find(i) == visited.end()) { findAllPaths_(i, destination, visited, path, all_paths, max_count); }
        }
      }
 
      // Backtrack
      path.pop_back();
      visited.erase(current);
    }
  };
 
  static double getLogMz(double mz, bool positive);
 
  static float getChargeMass(bool positive_ioniziation_mode);
};
} // namespace OpenMS