IDFilter.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-2012.
//
// 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: Mathias Walzer $
// $Authors: Nico Pfeifer, Mathias Walzer$
// --------------------------------------------------------------------------

#ifndef OPENMS_FILTERING_ID_IDFILTER_H
#define OPENMS_FILTERING_ID_IDFILTER_H

#include <OpenMS/config.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/FORMAT/FASTAFile.h>

#include <vector>
#include <climits>

namespace OpenMS
{
  class OPENMS_DLLAPI IDFilter
  {
public:

    IDFilter();

    virtual ~IDFilter();

    template <class IdentificationType>
    void filterIdentificationsByThreshold(const IdentificationType& identification, DoubleReal threshold_fraction, IdentificationType& filtered_identification)
    {
      typedef typename IdentificationType::HitType HitType;
      std::vector<HitType> temp_hits;
      std::vector<HitType> filtered_hits;

      filtered_identification = identification;
      filtered_identification.setHits(std::vector<HitType>());

      for (typename std::vector<HitType>::const_iterator it = identification.getHits().begin();
           it != identification.getHits().end();
           ++it)
      {
        if (it->getScore() >= threshold_fraction * identification.getSignificanceThreshold())
        {
          filtered_hits.push_back(*it);
        }
      }

      if (!filtered_hits.empty())
      {
        filtered_identification.setHits(filtered_hits);
        filtered_identification.assignRanks();
      }
    }

    template <class IdentificationType>
    void filterIdentificationsByScore(const IdentificationType& identification, DoubleReal threshold_score, IdentificationType& filtered_identification)
    {
      typedef typename IdentificationType::HitType HitType;
      std::vector<HitType> temp_hits;
      std::vector<HitType> filtered_hits;

      filtered_identification = identification;
      filtered_identification.setHits(std::vector<HitType>());

      for (typename std::vector<HitType>::const_iterator it = identification.getHits().begin();
           it != identification.getHits().end();
           ++it)
      {
        if (identification.isHigherScoreBetter())
        {
          if (it->getScore() >= threshold_score)
          {
            filtered_hits.push_back(*it);
          }
        }
        else
        {
          if (it->getScore() <= threshold_score)
          {
            filtered_hits.push_back(*it);
          }
        }
      }

      if (!filtered_hits.empty())
      {
        filtered_identification.setHits(filtered_hits);
        filtered_identification.assignRanks();
      }
    }

    template <class IdentificationType>
    void filterIdentificationsByBestNHits(const IdentificationType& identification, Size n, IdentificationType& filtered_identification)
    {
      typedef typename IdentificationType::HitType HitType;
      std::vector<HitType> temp_hits;
      std::vector<HitType> filtered_hits;
      Size count = 0;

      IdentificationType temp_identification = identification;
      temp_identification.sort(); // .. by score

      filtered_identification = identification;
      filtered_identification.setHits(std::vector<HitType>());


      typename std::vector<HitType>::const_iterator it = temp_identification.getHits().begin();
      while (it != temp_identification.getHits().end()
            && count < n)
      {
        filtered_hits.push_back(*it);
        ++it;
        ++count;
      }

      if (!filtered_hits.empty())
      {
        filtered_identification.setHits(filtered_hits);
        filtered_identification.assignRanks();
      }
    }

    template <class IdentificationType>
    void filterIdentificationsByBestNToMHits(const IdentificationType& identification, Size n, Size m, IdentificationType& filtered_identification)
    {
      if (n > m)
      {
        std::swap(n, m);
      }

      typedef typename IdentificationType::HitType HitType;
      std::vector<HitType> filtered_hits;

      IdentificationType temp_identification = identification;
      temp_identification.sort(); // .. by score

      filtered_identification = identification;
      filtered_identification.setHits(std::vector<HitType>());

      const std::vector<HitType>& hits = temp_identification.getHits();
      for (Size i = n - 1; n <= m - 1; ++i)
      {
        if (i >= hits.size())
        {
          break;
        }
        filtered_hits.push_back(hits[i]);
      }

      if (!filtered_hits.empty())
      {
        filtered_identification.setHits(filtered_hits);
        filtered_identification.assignRanks();
      }
    }

    void filterIdentificationsByBestHits(const PeptideIdentification& identification, PeptideIdentification& filtered_identification, bool strict = false);

    void filterIdentificationsByProteins(const PeptideIdentification& identification, const std::vector<FASTAFile::FASTAEntry>& proteins, PeptideIdentification& filtered_identification, bool no_protein_identifiers = false);

    void filterIdentificationsByProteins(const ProteinIdentification& identification, const std::vector<FASTAFile::FASTAEntry>& proteins, ProteinIdentification& filtered_identification);

    void filterIdentificationsByExclusionPeptides(const PeptideIdentification& identification, const std::set<String>& peptides, PeptideIdentification& filtered_identification);

    void filterIdentificationsByLength(const PeptideIdentification& identification, PeptideIdentification& filtered_identification, Size min_length, Size max_length = UINT_MAX);

    void filterIdentificationsByCharge(const PeptideIdentification& identification, Int charge, PeptideIdentification& filtered_identification);

    void filterIdentificationsByVariableModifications(const PeptideIdentification& identification, const std::vector<String>& fixed_modifications, PeptideIdentification& filtered_identification);

    void removeUnreferencedProteinHits(const ProteinIdentification& identification, const std::vector<PeptideIdentification> peptide_identifications, ProteinIdentification& filtered_identification);

    void filterIdentificationsUnique(const PeptideIdentification& identification, PeptideIdentification& filtered_identification);

    void filterIdentificationsByMzError(const PeptideIdentification& identification, DoubleReal mass_error, bool unit_ppm, PeptideIdentification& filtered_identification);

    void filterIdentificationsByRTPValues(const PeptideIdentification& identification, PeptideIdentification& filtered_identification, DoubleReal p_value = 0.05);

    void filterIdentificationsByRTFirstDimPValues(const PeptideIdentification& identification,
                                                  PeptideIdentification& filtered_identification,
                                                  DoubleReal                                      p_value = 0.05);

    template <class PeakT>
    void filterIdentificationsByThresholds(MSExperiment<PeakT>& experiment, DoubleReal peptide_threshold_fraction, DoubleReal protein_threshold_fraction)
    {
      //filter protein hits
      ProteinIdentification temp_protein_identification;
      std::vector<ProteinIdentification> filtered_protein_identifications;

      for (Size j = 0; j < experiment.getProteinIdentifications().size(); j++)
      {
        filterIdentificationsByThreshold(experiment.getProteinIdentifications()[j], protein_threshold_fraction, temp_protein_identification);
        if (!temp_protein_identification.getHits().empty())
        {
          filtered_protein_identifications.push_back(temp_protein_identification);
        }
      }
      experiment.setProteinIdentifications(filtered_protein_identifications);

      //filter peptide hits
      PeptideIdentification temp_identification;
      std::vector<PeptideIdentification> filtered_identifications;

      for (Size i = 0; i < experiment.size(); i++)
      {
        for (Size j = 0; j < experiment[i].getPeptideIdentifications().size(); j++)
        {
          filterIdentificationsByThreshold(experiment[i].getPeptideIdentifications()[j], peptide_threshold_fraction, temp_identification);
          if (!temp_identification.getHits().empty())
          {
            filtered_identifications.push_back(temp_identification);
          }
        }
        experiment[i].setPeptideIdentifications(filtered_identifications);
        filtered_identifications.clear();
      }
    }

    template <class PeakT>
    void filterIdentificationsByScores(MSExperiment<PeakT>& experiment, DoubleReal peptide_threshold_score, DoubleReal protein_threshold_score)
    {
      //filter protein hits
      ProteinIdentification temp_protein_identification;
      std::vector<ProteinIdentification> filtered_protein_identifications;

      for (Size j = 0; j < experiment.getProteinIdentifications().size(); j++)
      {
        filterIdentificationsByScore(experiment.getProteinIdentifications()[j], protein_threshold_score, temp_protein_identification);
        if (!temp_protein_identification.getHits().empty())
        {
          filtered_protein_identifications.push_back(temp_protein_identification);
        }
      }
      experiment.setProteinIdentifications(filtered_protein_identifications);

      //filter peptide hits
      PeptideIdentification temp_identification;
      std::vector<PeptideIdentification> filtered_identifications;

      for (Size i = 0; i < experiment.size(); i++)
      {
        for (Size j = 0; j < experiment[i].getPeptideIdentifications().size(); j++)
        {
          filterIdentificationsByScore(experiment[i].getPeptideIdentifications()[j], peptide_threshold_score, temp_identification);
          if (!temp_identification.getHits().empty())
          {
            filtered_identifications.push_back(temp_identification);
          }
        }
        experiment[i].setPeptideIdentifications(filtered_identifications);
        filtered_identifications.clear();
      }
    }

    template <class PeakT>
    void filterIdentificationsByBestNHits(MSExperiment<PeakT>& experiment, Size n)
    {
      //filter protein hits
      ProteinIdentification temp_protein_identification;
      std::vector<ProteinIdentification> filtered_protein_identifications;

      for (Size j = 0; j < experiment.getProteinIdentifications().size(); j++)
      {
        filterIdentificationsByBestNHits(experiment.getProteinIdentifications()[j], n, temp_protein_identification);
        if (!temp_protein_identification.getHits().empty())
        {
          filtered_protein_identifications.push_back(temp_protein_identification);
        }
      }
      experiment.setProteinIdentifications(filtered_protein_identifications);

      //filter peptide hits
      PeptideIdentification temp_identification;
      std::vector<PeptideIdentification> filtered_identifications;

      for (Size i = 0; i < experiment.size(); i++)
      {
        for (Size j = 0; j < experiment[i].getPeptideIdentifications().size(); j++)
        {
          filterIdentificationsByBestNHits(experiment[i].getPeptideIdentifications()[j], n, temp_identification);
          if (!temp_identification.getHits().empty())
          {
            filtered_identifications.push_back(temp_identification);
          }
        }
        experiment[i].setPeptideIdentifications(filtered_identifications);
        filtered_identifications.clear();
      }
    }

    template <class PeakT>
    void filterIdentificationsByProteins(MSExperiment<PeakT>& experiment,
                                         const std::vector<FASTAFile::FASTAEntry>& proteins)
    {
      std::vector<PeptideIdentification> temp_identifications;
      std::vector<PeptideIdentification> filtered_identifications;
      PeptideIdentification temp_identification;

      for (Size i = 0; i < experiment.size(); i++)
      {
        if (experiment[i].getMSLevel() == 2)
        {
          temp_identifications = experiment[i].getPeptideIdentifications();
          for (Size j = 0; j < temp_identifications.size(); j++)
          {
            filterIdentificationsByProteins(temp_identifications[j], proteins, temp_identification);
            if (!temp_identification.getHits().empty())
            {
              filtered_identifications.push_back(temp_identification);
            }
          }
          experiment[i].setPeptideIdentifications(filtered_identifications);
          filtered_identifications.clear();
        }
      }
    }

  };

} // namespace OpenMS

#endif // OPENMS_FILTERING_ID_IDFILTER_H