OPXLDataStructs.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2018.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $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 <numeric>

namespace OpenMS
{
  class OPENMS_DLLAPI OPXLDataStructs
  {

    public:

      enum ProteinProteinCrossLinkType
      {
        CROSS = 0,
        MONO = 1,
        LOOP = 2,
        NUMBER_OF_CROSS_LINK_TYPES
      };

      struct ProteinProteinCrossLink
      {
        AASequence alpha; // longer peptide
        AASequence beta; // shorter peptide (empty for mono-link), tie bracker: mass then lexicographical
        std::pair<SignedSize, SignedSize> cross_link_position; // index in alpha, beta or between alpha, alpha in loop-links
        double cross_linker_mass;
        String cross_linker_name;
        ResidueModification::TermSpecificity term_spec_alpha;
        ResidueModification::TermSpecificity term_spec_beta;
        int precursor_correction;

        ProteinProteinCrossLinkType getType() const
        {
          if (!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;
        Size scan_index_heavy;

        double score;

        Size rank;

        double xquest_score;
        double pre_score;
        double percTIC;
        double wTIC;
        double wTICold;
        double int_sum;
        double intsum_alpha;
        double intsum_beta;
        double total_current;
        double precursor_error_ppm;

        double match_odds;
        double match_odds_alpha;
        double match_odds_beta;
        double log_occupancy;
        double log_occupancy_alpha;
        double log_occupancy_beta;
        double xcorrx_max;
        double xcorrc_max;
        Size matched_linear_alpha;
        Size matched_linear_beta;
        Size matched_xlink_alpha;
        Size matched_xlink_beta;

        double num_iso_peaks_mean;
        double num_iso_peaks_mean_linear_alpha;
        double num_iso_peaks_mean_linear_beta;
        double num_iso_peaks_mean_xlinks_alpha;
        double num_iso_peaks_mean_xlinks_beta;

        double ppm_error_abs_sum_linear_alpha;
        double ppm_error_abs_sum_linear_beta;
        double ppm_error_abs_sum_xlinks_alpha;
        double ppm_error_abs_sum_xlinks_beta;
        double ppm_error_abs_sum_linear;
        double ppm_error_abs_sum_xlinks;
        double ppm_error_abs_sum_alpha;
        double ppm_error_abs_sum_beta;
        double ppm_error_abs_sum;

        int precursor_correction;

        std::vector<PeptideHit::PeakAnnotation> frag_annotations;

        Size peptide_id_index;
      };

      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 ambigious 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;
        unsigned int beta_index;
      };

      // 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;
        AASequence peptide_seq;
        PeptidePosition position;
      };

      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; // merge spectrum of linear peaks (present in both spectra)
        MSExperiment spectra_xlink_peaks; // Xlink peaks in the light spectrum (linear peaks between spectra_light_different and spectra heavy_to_light)
        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