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-2017.
//
// 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 $
// --------------------------------------------------------------------------

#ifndef OPENMS_ANALYSIS_XLMS_OPXLDATASTRUCTS
#define OPENMS_ANALYSIS_XLMS_OPXLDATASTRUCTS

#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;

        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;
        }
      };

      struct CrossLinkSpectrumMatch
      {
        ProteinProteinCrossLink cross_link;

        Size scan_index_light;
        Size scan_index_heavy;

        double score;

        Size rank;

        double pre_score;
        double percTIC;
        double wTIC;
        double int_sum;
        double match_odds;
        std::vector< double > xcorrx;
        double xcorrx_max;
        std::vector< double > xcorrc;
        double xcorrc_max;
        Size matched_common_alpha;
        Size matched_common_beta;
        Size matched_xlink_alpha;
        Size matched_xlink_beta;
        double HyperCommon;
        double HyperXlink;
        double HyperAlpha;
        double HyperBeta;
        double HyperBoth;
        double PScoreCommon;
        double PScoreXlink;
        double PScoreAlpha;
        double PScoreBeta;
        double PScoreBoth;

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

        Size peptide_id_index;

        bool operator<(const CrossLinkSpectrumMatch& other) const
        {
          return score < other.score;
        }

        bool operator==(const CrossLinkSpectrumMatch& other) const
        {
          return cross_link == other.cross_link &&
                     scan_index_light == other.scan_index_light &&
                     scan_index_heavy == other.scan_index_heavy &&
                     score == other.score &&
                     rank == other.rank &&
                     pre_score == other.pre_score &&
                     percTIC == other.percTIC &&
                     wTIC == other.wTIC &&
                     int_sum == other.int_sum &&
                     match_odds == other.match_odds &&
                     xcorrx == other.xcorrx &&
                     xcorrx_max == other.xcorrx_max &&
                     xcorrc == other.xcorrc &&
                     xcorrc_max == other.xcorrc_max &&
                     matched_common_alpha == other.matched_common_alpha &&
                     matched_common_beta == other.matched_common_beta &&
                     matched_xlink_alpha == other.matched_xlink_alpha &&
                     matched_xlink_beta == other.matched_xlink_beta &&
                     HyperCommon == other.HyperCommon &&
                     HyperXlink == other.HyperXlink &&
                     HyperAlpha == other.HyperAlpha &&
                     HyperBeta == other.HyperBeta &&
                     HyperBoth == other.HyperBoth &&
                     PScoreCommon == other.PScoreCommon &&
                     PScoreXlink == other.PScoreXlink &&
                     PScoreAlpha == other.PScoreAlpha &&
                     PScoreBeta == other.PScoreBeta &&
                     PScoreBoth == other.PScoreBoth;
        }
      };

      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_common_peaks; // merge spectrum of common peaks (present in both spectra)
        MSExperiment spectra_xlink_peaks; // Xlink peaks in the light spectrum (common 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_common_peaks.addSpectrum(PeakSpectrum());
            spectra_xlink_peaks.addSpectrum(PeakSpectrum());
            spectra_all_peaks.addSpectrum(PeakSpectrum());
          }
        }
      };

  }; // class
} // namespace OpenMS


#endif