OPXLDataStructs.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: Eugen Netz $
// $Authors: Eugen Netz $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/METADATA/PeptideHit.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/CHEMISTRY/ResidueModification.h>
#include <OpenMS/FORMAT/FASTAFile.h>
#include <OpenMS/CHEMISTRY/EnzymaticDigestion.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <functional>
//#include <numeric>
 
namespace OpenMS
{
  class OPENMS_DLLAPI OPXLDataStructs
  {
 
    public:
 
      enum ProteinProteinCrossLinkType
      {
        CROSS = 0,
        MONO = 1,
        LOOP = 2,
        NUMBER_OF_CROSS_LINK_TYPES
      };
 
      struct ProteinProteinCrossLink
      {
        const AASequence *alpha = nullptr; 
        const AASequence *beta = nullptr; 
        std::pair<SignedSize, SignedSize> cross_link_position; 
        double cross_linker_mass = 0;
        String cross_linker_name;
        ResidueModification::TermSpecificity term_spec_alpha = ResidueModification::TermSpecificity::ANYWHERE;
        ResidueModification::TermSpecificity term_spec_beta = ResidueModification::TermSpecificity::ANYWHERE;
        int precursor_correction = 0;
 
        ProteinProteinCrossLinkType getType() const
        {
          if (beta && !beta->empty()) return CROSS;
 
          if (cross_link_position.second == -1) return MONO;
 
          return LOOP;
        }
 
        bool operator==(const ProteinProteinCrossLink & other) const
        {
          return alpha == other.alpha &&
                      beta == other.beta &&
                      cross_link_position == other.cross_link_position &&
                      cross_linker_mass == other.cross_linker_mass &&
                      cross_linker_name == other.cross_linker_name &&
                      term_spec_alpha == other.term_spec_alpha &&
                      term_spec_beta == other.term_spec_beta &&
                      precursor_correction == other.precursor_correction;
        }
      };
 
      struct CrossLinkSpectrumMatch
      {
        ProteinProteinCrossLink cross_link;
 
        Size scan_index_light = 0;
        Size scan_index_heavy = 0;
 
        double score = 0;
 
        Size rank = 0;
 
        double xquest_score = 0;
        double pre_score = 0;
        double percTIC = 0;
        double wTIC = 0;
        double wTICold = 0;
        double int_sum = 0;
        double intsum_alpha = 0;
        double intsum_beta = 0;
        double total_current = 0;
        double precursor_error_ppm = 0;
 
        double match_odds = 0;
        double match_odds_alpha = 0;
        double match_odds_beta = 0;
        double log_occupancy = 0;
        double log_occupancy_alpha = 0;
        double log_occupancy_beta = 0;
        double xcorrx_max = 0;
        double xcorrc_max = 0;
        Size matched_linear_alpha = 0;
        Size matched_linear_beta = 0;
        Size matched_xlink_alpha = 0;
        Size matched_xlink_beta = 0;
 
        double num_iso_peaks_mean = 0;
        double num_iso_peaks_mean_linear_alpha = 0;
        double num_iso_peaks_mean_linear_beta = 0;
        double num_iso_peaks_mean_xlinks_alpha = 0;
        double num_iso_peaks_mean_xlinks_beta = 0;
 
        double ppm_error_abs_sum_linear_alpha = 0;
        double ppm_error_abs_sum_linear_beta = 0;
        double ppm_error_abs_sum_xlinks_alpha = 0;
        double ppm_error_abs_sum_xlinks_beta = 0;
        double ppm_error_abs_sum_linear = 0;
        double ppm_error_abs_sum_xlinks = 0;
        double ppm_error_abs_sum_alpha = 0;
        double ppm_error_abs_sum_beta = 0;
        double ppm_error_abs_sum = 0;
 
        int precursor_correction = 0;
 
        double precursor_total_intensity = 0;
        double precursor_target_intensity = 0;
        double precursor_signal_proportion = 0;
        Size precursor_target_peak_count = 0;
        Size precursor_residual_peak_count = 0;
 
        std::vector<PeptideHit::PeakAnnotation> frag_annotations;
 
        Size peptide_id_index = 0;
      };
 
      struct CLSMScoreComparator
      {
        bool operator() (const CrossLinkSpectrumMatch& a, const CrossLinkSpectrumMatch& b)
        {
          if (a.score == b.score)
          {
            // in rare cases when the sequences are the same, multiple candidates with different cross-linked positions can have the same score
            // that leads to ambiguous sorting and may cause differences between compilers
            // in those cases we prefer higher positions (just like the score),
            // because the lower position might be an N-term link, which is usually less likely and all other positions are equal (because the score is equal)
            if (a.cross_link.cross_link_position.first == b.cross_link.cross_link_position.first)
            {
              return a.cross_link.cross_link_position.second < b.cross_link.cross_link_position.second;
            }
            return a.cross_link.cross_link_position.first < b.cross_link.cross_link_position.first;
          }
          return a.score < b.score;
        }
      };
 
      struct XLPrecursor
      {
        float precursor_mass{};
        unsigned int alpha_index = 0;
        unsigned int beta_index = 0;
        String alpha_seq;
        String beta_seq;
      };
 
      // comparator for sorting XLPrecursor vectors and using upper_bound and lower_bound using only a precursor mass
      struct XLPrecursorComparator
      {
        bool operator() (const XLPrecursor& a, const XLPrecursor& b) const
        {
          return a.precursor_mass < b.precursor_mass;
        }
        bool operator() (const XLPrecursor& a, const double& b) const
        {
          return a.precursor_mass < b;
        }
        bool operator() (const double& a, const XLPrecursor& b) const
        {
          return a < b.precursor_mass;
        }
      };
 
      enum PeptidePosition
      {
        INTERNAL = 0,
        C_TERM = 1,
        N_TERM = 2
      };
 
      struct AASeqWithMass
      {
        double peptide_mass = 0;
        AASequence peptide_seq;
        PeptidePosition position = PeptidePosition::INTERNAL;
        String unmodified_seq;
      };
 
      struct AASeqWithMassComparator
      {
        bool operator() (const AASeqWithMass& a, const AASeqWithMass& b) const
        {
          return a.peptide_mass < b.peptide_mass;
        }
        bool operator() (const AASeqWithMass& a, const double& b) const
        {
          return a.peptide_mass < b;
        }
        bool operator() (const double& a, const AASeqWithMass& b) const
        {
          return a < b.peptide_mass;
        }
      };
 
      struct PreprocessedPairSpectra
      {
 
        MSExperiment spectra_linear_peaks; 
        MSExperiment spectra_xlink_peaks; 
        MSExperiment spectra_all_peaks;
 
        // pre-initialize so we can simply std::swap the spectra (no synchronization in multi-threading context needed as we get no reallocation of the PeakMaps).
        PreprocessedPairSpectra(Size size)
        {
          for (Size i = 0; i != size; ++i)
          {
            spectra_linear_peaks.addSpectrum(PeakSpectrum());
            spectra_xlink_peaks.addSpectrum(PeakSpectrum());
            spectra_all_peaks.addSpectrum(PeakSpectrum());
          }
        }
      };
 
  }; // class
} // namespace OpenMS
 
namespace std
{
  template<>
  struct hash<OpenMS::OPXLDataStructs::ProteinProteinCrossLink>
  {
    std::size_t operator()(const OpenMS::OPXLDataStructs::ProteinProteinCrossLink& link) const noexcept
    {
      std::size_t seed = 0;
 
      // Hash pointers (alpha and beta) - these are compared by pointer value in operator==
      OpenMS::hash_combine(seed, OpenMS::hash_int(reinterpret_cast<std::uintptr_t>(link.alpha)));
      OpenMS::hash_combine(seed, OpenMS::hash_int(reinterpret_cast<std::uintptr_t>(link.beta)));
 
      // Hash cross_link_position (pair of SignedSize)
      OpenMS::hash_combine(seed, OpenMS::hash_int(link.cross_link_position.first));
      OpenMS::hash_combine(seed, OpenMS::hash_int(link.cross_link_position.second));
 
      // Hash cross_linker_mass (double)
      OpenMS::hash_combine(seed, OpenMS::hash_float(link.cross_linker_mass));
 
      // Hash cross_linker_name (String, which is std::string)
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(link.cross_linker_name));
 
      // Hash term_spec_alpha and term_spec_beta (enums)
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(link.term_spec_alpha)));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(link.term_spec_beta)));
 
      // Hash precursor_correction (int)
      OpenMS::hash_combine(seed, OpenMS::hash_int(link.precursor_correction));
 
      return seed;
    }
  };
} // namespace std