ProteinIdentification.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: Chris Bielow $
// $Authors: Nico Pfeifer, Chris Bielow $
// --------------------------------------------------------------------------

#ifndef OPENMS_METADATA_PROTEINIDENTIFICATION_H
#define OPENMS_METADATA_PROTEINIDENTIFICATION_H

#include <OpenMS/METADATA/ProteinHit.h>
#include <OpenMS/METADATA/MetaInfoInterface.h>
#include <OpenMS/DATASTRUCTURES/DateTime.h>

#include <set>

namespace OpenMS
{
  class PeptideIdentification;
  class OPENMS_DLLAPI ProteinIdentification :
    public MetaInfoInterface
  {
public:
    typedef ProteinHit HitType;

    struct ProteinGroup
    {
      DoubleReal probability;
      StringList accessions;

      ProteinGroup() :
        probability(0.0), accessions()
      {}

      bool operator==(const ProteinGroup rhs) const
      {
        return probability == rhs.probability &&
               accessions == rhs.accessions;
      }

    };

    enum PeakMassType
    {
      MONOISOTOPIC,
      AVERAGE,
      SIZE_OF_PEAKMASSTYPE
    };
    static const std::string NamesOfPeakMassType[SIZE_OF_PEAKMASSTYPE];


    enum DigestionEnzyme
    {
      TRYPSIN,
      PEPSIN_A,
      PROTEASE_K,
      CHYMOTRYPSIN,
      NO_ENZYME,
      UNKNOWN_ENZYME,
      SIZE_OF_DIGESTIONENZYME
    };
    static const std::string NamesOfDigestionEnzyme[SIZE_OF_DIGESTIONENZYME];

    struct SearchParameters :
      public MetaInfoInterface
    {
      String db;           
      String db_version;           
      String taxonomy;           
      String charges;           
      PeakMassType mass_type;           
      std::vector<String> fixed_modifications;           
      std::vector<String> variable_modifications;           
      DigestionEnzyme enzyme;           
      UInt missed_cleavages;           
      DoubleReal peak_mass_tolerance;           
      DoubleReal precursor_tolerance;           

      SearchParameters() :
        db(),
        db_version(),
        taxonomy(),
        charges(),
        mass_type(MONOISOTOPIC),
        fixed_modifications(),
        variable_modifications(),
        enzyme(UNKNOWN_ENZYME),
        missed_cleavages(0),
        peak_mass_tolerance(0.0),
        precursor_tolerance(0.0)
      {
      }

      bool operator==(const SearchParameters & rhs) const
      {
        return db == rhs.db &&
               db_version == rhs.db_version &&
               taxonomy == rhs.taxonomy &&
               charges == rhs.charges &&
               mass_type == rhs.mass_type &&
               fixed_modifications == rhs.fixed_modifications &&
               variable_modifications == rhs.variable_modifications &&
               enzyme == rhs.enzyme &&
               missed_cleavages == rhs.missed_cleavages &&
               peak_mass_tolerance == rhs.peak_mass_tolerance &&
               precursor_tolerance == rhs.precursor_tolerance;
      }

      bool operator!=(const SearchParameters & rhs) const
      {
        return !(*this == rhs);
      }

    };



    ProteinIdentification();
    virtual ~ProteinIdentification();
    ProteinIdentification(const ProteinIdentification & source);
    ProteinIdentification & operator=(const ProteinIdentification & source);
    bool operator==(const ProteinIdentification & rhs) const;
    bool operator!=(const ProteinIdentification & rhs) const;



    const std::vector<ProteinHit> & getHits() const;
    std::vector<ProteinHit> & getHits();
    void insertHit(const ProteinHit & input);
    void setHits(const std::vector<ProteinHit> & hits);
    std::vector<ProteinHit>::iterator findHit(const String & accession);

    const std::vector<ProteinGroup> & getProteinGroups() const;
    std::vector<ProteinGroup> & getProteinGroups();
    void insertProteinGroup(const ProteinGroup & group);

    const std::vector<ProteinGroup> & getIndistinguishableProteins() const;
    std::vector<ProteinGroup> & getIndistinguishableProteins();
    void insertIndistinguishableProteins(const ProteinGroup & group);

    DoubleReal getSignificanceThreshold() const;
    void setSignificanceThreshold(DoubleReal value);
    const String & getScoreType() const;
    void setScoreType(const String & type);
    bool isHigherScoreBetter() const;
    void setHigherScoreBetter(bool higher_is_better);
    void sort();
    void assignRanks();
    Size computeCoverage(const std::vector<PeptideIdentification> & pep_ids);



    const DateTime & getDateTime() const;
    void setDateTime(const DateTime & date);
    void setSearchEngine(const String & search_engine);
    const String & getSearchEngine() const;
    void setSearchEngineVersion(const String & search_engine_version);
    const String & getSearchEngineVersion() const;
    void setSearchParameters(const SearchParameters & search_parameters);
    const SearchParameters & getSearchParameters() const;
    const String & getIdentifier() const;
    void setIdentifier(const String & id);

protected:

    String id_;
    String search_engine_;
    String search_engine_version_;
    SearchParameters search_parameters_;
    DateTime date_;


    String protein_score_type_;
    bool higher_score_better_;
    std::vector<ProteinHit> protein_hits_;
    std::vector<ProteinGroup> protein_groups_;
    std::vector<ProteinGroup> indistinguishable_proteins_;
    DoubleReal protein_significance_threshold_;
  };

} //namespace OpenMS
#endif // OPENMS_METADATA_PROTEINIDENTIFICATION_H