ms_protein.hpp

/*
##############################################################################
# file: ms_mascotresprotein.hpp                                              #
# 'msparser' toolkit                                                         #
# Encapsulates a protein - either for protein summary or peptide summary     #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2018 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Archive:: /Mowse/ms_mascotresfile/include/ms_mascotresprotein.hpp    $ #
#     $Author: robertog@matrixscience.com $ #
#       $Date: 2023-08-29 15:05:00 +0100 $ #
#   $Revision: 59a8ab98151c86e0bdeddc2efea60d287d6087ba | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/
 
#ifndef MS_MASCOTRESPROTEIN_HPP
#define MS_MASCOTRESPROTEIN_HPP
 
 
// Includes from the standard template library
#include <string>
#include <list>
#include <vector>
#include <set>
#include <map>
#include <ostream>
 
namespace msparser_internal {
    class ms_protein_match_data;
    class PEPINFO;
    class ms_mascotresultsbase;
    class ms_peptidesumsql;
}
 
namespace matrix_science {
    class ms_mascotresults;
    class ms_proteinsummary;
    class ms_pepinfoSortByScore;
    class ms_peptide;
 
 
    class MS_MASCOTRESFILE_API ms_protein
    {
        public:
 
            enum GROUP 
            { 
                GROUP_UNKNOWN,  
                GROUP_NO,       
                GROUP_SUBSET,   
                GROUP_COMPLETE, 
                GROUP_FAMILY    
            };
 
#ifdef DUPLICATE
    #ifdef _WIN32
//        #pragma message("WARNING: The identifier 'DUPLICATE' was defined but is incompatible with the definition for ms_protein")
    #endif
    #undef DUPLICATE
#endif
 
 
            enum DUPLICATE 
            { 
                DUPE_NotDuplicate,           
                DUPE_Duplicate,              
                DUPE_DuplicateSameQuery,     
                DUPE_HighestScoringDuplicate, 
                DUPE_Ignored                 
            };
 
 
            enum MASS_FLAGS
            {
                MASS_NON_SELECT_NON_MATCH   = 0x0001, 
                MASS_SELECT_NON_MATCH       = 0x0010, 
                MASS_NON_SELECT_MATCH       = 0x0100, 
                MASS_SELECT_MATCH           = 0x1000  
            };
 
 
            enum DISTINCT_PEPTIDE_FLAGS
            {
                DPF_SEQUENCE        = 0x0001,  
                DPF_CHARGE          = 0x0002,  
                DPF_MODS            = 0x0004,  
                DPF_UNIQUE          = 0x0008,  
                DPF_NODUPSAMEQUERY  = 0x0010   
            };
 
            // Types for uniquely identifying a protein
            typedef std::pair<int, std::string> dbIdxPlusAcc_t;
            typedef std::vector<dbIdxPlusAcc_t> dbIdxPlusAccVect_t;
            typedef std::set<dbIdxPlusAcc_t>    dbIdxPlusAccSet_t;
 
 
            ms_protein(const double score,
                       const std::string accession,
                       const bool updateScoreFromPepScores,
                       const int  proteinSummaryHit = 0);
 
            ms_protein(const ms_protein& src);
 
            ~ms_protein();
 
#ifndef SWIG
            ms_protein& operator=(const ms_protein& right);
#endif
 
            void copyFrom(const ms_protein* src);
 
            int64_t getProteinId() const;
 
            void setProteinId(int64_t proteinId);
 
            std::string getAccession() const;
 
            int getDB() const;
 
            void setDB(int dbIdx);
 
            double getScore()          const;
 
            double getNonMudpitScore()     const;
 
            double getScoreWithET() const;
 
            int    getNumPeptides()    const;
 
            int    getNumDisplayPeptides(bool aboveThreshold = false)    const;
 
            GROUP getGrouping() const;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
            void setGrouping(GROUP g)         { group_ = g;       }
 
            std::string getForCache(dbIdxPlusAccVect_t & supersetProteinsUnsorted,
                                    dbIdxPlusAccVect_t & components) const;
 
            bool setFromCache(const std::string & str, msparser_internal::ms_mascotresultsbase & results,
                              const dbIdxPlusAccVect_t & supersetProteinsUnsorted,
                              const dbIdxPlusAccVect_t & components,
                              const std::string & cdbFeatures);
 
            std::vector<std::pair<int, int> > getIgnoredQPs() const;
 
            bool isIgnoredQP(const int q, const int p) const;
#endif
 
            void getIgnoredQPs(std::vector<int> &q, std::vector<int> &p) const;
 
            int    getPeptideQuery         (const int   pepNumber) const;
 
            int    getPeptideP             (const int   pepNumber) const;
 
            int getPepNumber(const int q, const int p) const;
 
            int    getPeptideFrame         (const int   pepNumber, const ms_peptide::PSM psmComponent = ms_peptide::PSM_COMPLETE) const;
 
            long   getPeptideStart         (const int   pepNumber, const ms_peptide::PSM psmComponent = ms_peptide::PSM_COMPLETE) const;
 
            long   getPeptideEnd           (const int   pepNumber, const ms_peptide::PSM psmComponent = ms_peptide::PSM_COMPLETE) const;
 
            long   getPeptideMultiplicity  (const int   pepNumber, const ms_peptide::PSM psmComponent = ms_peptide::PSM_COMPLETE) const;
 
            DUPLICATE getPeptideDuplicate  (const int   pepNumber, const bool allowErrTolDuplicate = true) const;
 
            double getPeptideIonsScore     (const int   pepNumber) const;
            
            bool   getPeptideIsBold        (const int   pepNumber) const;
            
            void   setPeptideIsBold        (const int   pepNumber);
 
            bool   getPeptideShowCheckbox  (const int   pepNumber) const;
            
            void   setPeptideShowCheckbox  (const int   pepNumber);
            
            int    getPeptideComponentID   (const int   pepNumber) const;
            
            char   getPeptideResidueBefore (const int   pepNumber, const ms_peptide::PSM psmComponent = ms_peptide::PSM_COMPLETE) const;
 
            char   getPeptideResidueAfter  (const int   pepNumber, const ms_peptide::PSM psmComponent = ms_peptide::PSM_COMPLETE) const;
 
            bool isASimilarProtein(const ms_protein       * prot, 
                                   const ms_mascotresults * results,
                                   const bool groupByQueryNumber = false);
 
            std::string getSimilarProteinName() const;
 
            int getSimilarProteinDB() const;
 
            bool isSimilarProtein(const std::string & acc, const int dbIdx) const;
 
            int getSimilarProteins(std::vector<std::string> & accessions, std::vector<int> & dbIdxs) const;
 
            void setSimilarProtein(const ms_protein * prot);
 
            void addOnePeptide(      ms_mascotresults & results,
                               const int q, const int p,
                               const msparser_internal::ms_protein_match_data &proteinMatchData,
                               const double correctedScore,
                               const double uncorrectedScore,
                               const ms_protein * component,
                               const ms_peptide::SEARCH_PHASE searchPhase,
                               const bool isIgnored);
 
 
            long getCoverage() const;
 
            bool anyMatchToQuery(const int query) const;
 
            bool anyMatchToQueryAndP(const int query, const int P) const;
 
    std::string getUnmatchedMasses(ms_mascotresfilebase & resfile,
                                           const int numDecimalPlaces = 2) const;
 
    std::string getMasses(ms_mascotresfilebase & resfile,
                                  const ms_proteinsummary & summary,
                                  const unsigned int flags = MASS_SELECT_MATCH,
                                  const int numDecimalPlaces = 2) const;
 
            int getFrame() const;
 
            bool anyBoldRedPeptides(const ms_mascotresults & results) const;
 
            bool isUnigene() const;
 
            void setIsUnigeneEntry();
 
            bool isPMFMixture() const;
 
            void setIsPMFMixture();
 
            bool isUpdateScoreFromPepScores() const;
 
            void sortPeptides(const ms_mascotresults & results, bool keepAlive = false, int keepAlivePercent = 0, const char * keepAliveAccession = "", int keepAliveCount = 0);
 
            int getNumComponents() const;
 
            const ms_protein * getComponent(const int componentNumber) const;
 
            int getProteinSummaryHit() const;
 
            double getRMSDeltas(const ms_mascotresults & results) const;
 
            int getHitNumber() const;
 
            void setHitNumber(const int hit) { hitNum_ = hit;}
 
            int getMemberNumber() const;
 
            int getLongestPeptideLen() const;
 
            int getNumDistinctPeptides(bool aboveThreshold = false,
                                       DISTINCT_PEPTIDE_FLAGS flags = DPF_SEQUENCE) const;
 
            int getNumDistinctPeptideRepeats(
                    int distinctIndex, // 1..getNumDistinctPeptides
                    bool aboveThreshold = false,
                    DISTINCT_PEPTIDE_FLAGS flags = DPF_SEQUENCE) const;
 
            ms_peptide getDistinctPeptide(
                    int distinctIndex, // 1..getNumDistinctPeptides
                    int repeatIndex = 1, // 1..getNumDistinctPeptideRepeats
                    bool aboveThreshold = false,
                    DISTINCT_PEPTIDE_FLAGS flags = DPF_SEQUENCE) const;
 
            int getLongestSigPeptideLen() const;
 
            int getNumObservedForEmPAI() const;
#ifndef SWIG
 
            friend inline bool operator<(const ms_protein & lhs, const ms_protein & rhs) { 
                if (lhs.dbIdx_ == rhs.dbIdx_) {
                    if ( lhs.proteinSummaryHit_ == 0 ) {
                        return lhs.accession_ < rhs.accession_;
                    } else { // i.e ms_proteinsummary - see parser bug 493
                        if ( lhs.accession_ == rhs.accession_) {
                            return lhs.getFrame() < rhs.getFrame();
                        } else {
                            return lhs.accession_ < rhs.accession_;
                        }
                    }
                } else {
                    return lhs.dbIdx_ < rhs.dbIdx_; 
                }
            }
#endif
            // Undocumented function for fast access
            const char * getAccessionStr() const { return accession_.c_str(); }
 
            const std::vector<std::pair<int,int64_t>>& getSupersetProteinIds() const { return supersetProteinIdsUnsorted_; }
            const std::vector<std::pair<int,int64_t>>& getComponentProteinIds() const { return  componentProteinIds_; }
 
        std::string stringify() const;
 
        private:
 
        // Values for flags_
        // These ones are not cached in the cdb file (obviously!)
        static constexpr unsigned char  FL_LOADED_BASE_INFO_FROM_CACHE = 0x01;  // False if not using cdb, otherwise true once setFromCache() has been called
        static constexpr unsigned char FL_LOADED_QP_FROM_CACHE = 0x02;  // True is using cdb and just q/p values loaded.
        static constexpr unsigned char FL_LOADED_ALL_FROM_CACHE = 0x02;  // Same as FL_SORTED
        // These ones are cached in the cdb file
        static constexpr unsigned char FL_SORTED = 0x10;  // Sorting the list of peptides is expensive - don't repeat...
        static constexpr unsigned char FL_UNIGENE = 0x20;  // For unigene, we need to get the description line from the unigene file
        static constexpr unsigned char FL_UPDATE_SCORE_FROM_PEP_SCORES = 0x40;  // For protein summary, the protein score is calculated by
                                              // nph-mascot.exe, and is in the results file. For the
                                              // peptide summary, the score is calculated by adding the ions
                                              // scores
 
        static constexpr unsigned char FL_PMF_MIXTURE = 0x80;  // True if protein actually originates from a PMF mixture
 
            void initialiseDistinctPeptideTree(
                    bool  aboveThreshold,
                    DISTINCT_PEPTIDE_FLAGS flags) const;
 
            ms_errs* getErrorHandler() const;
 
            // --- Start of uncached variables
            mutable std::vector<msparser_internal::PEPINFO *> peptides_; // sort by query
            mutable std::vector<msparser_internal::PEPINFO *> ignoredPeptides_;
            mutable std::vector<msparser_internal::PEPINFO>   allPeptides_;
 
            msparser_internal::ms_mascotresultsbase * results_;
//          bool loadedFromCache_;
            // --- End of uncached variables
 
            // Start of all cached variables
            unsigned char    flags_; // See FL_... not all bits are cached
 
            int numPeptides_;  // Only used if loadedFromCache_ is true - otherwise peptides_.size();
            mutable int numDisplayPeptides_;
            mutable int numDisplayPeptidesAboveThresh_;
            mutable int numDistinctPeptides_;
            mutable int numDistinctPeptidesAboveThresh_;
            mutable int numDistinctUniquePeptides_;
            mutable int numDistinctUniqPepAboveThresh_;
            mutable int lenLongestPeptideAboveThresh_;
            mutable int numObservedForEmPAI_;
            mutable int frame_;
            mutable bool distinctPeptideAboveThreshold_;
            mutable DISTINCT_PEPTIDE_FLAGS distinctPeptideFlags_;
            mutable std::list<std::list<ms_peptide*> > distinctPeptideTree_;
            dbIdxPlusAccSet_t  supersetProteins_;  // This one is filled when loading from cache
            dbIdxPlusAccVect_t supersetProteinsUnsorted_;
            // Same as supersetProteinsUnsorted_ but using protein ids
            std::vector<std::pair<int,int64_t>> supersetProteinIdsUnsorted_;
 
            // For unignene and PMF mixture, the protein is really a 'pseudo'
            // protein, made up from a number of 'real' proteins
            dbIdxPlusAccVect_t components_;
            // Same as components_but using protein ids
            std::vector<std::pair<int,int64_t>> componentProteinIds_;
 
            int64_t proteinId_;
            std::string accession_;
            int dbIdx_;
            double score_;
            double nonMudPITScore_;
            double scoreWithET_;
            GROUP group_;
            int proteinSummaryHit_;
            int hitNum_;
            mutable int memberNum_;
            int longestPeptideLen_;         // Useful with minPepLenInPepSummary
            mutable long coverage_;
//          bool pmfMixture_;               // True if protein actually originates from a PMF mixture
//          bool sorted_;                   // Sorting the list of peptides is expensive - don't repeat...
//          bool unigene_;                  // For unigene, we need to get the description line from the unigene file
//          bool updateScoreFromPepScores_; // For protein summary, the protein score is calculated by
                                            // nph-mascot.exe, and is in the results file. For the
                                            // peptide summary, the score is calculated by adding the ions
                                            // scores
 
            // Functions
            void copyPeptidePointers(std::vector<msparser_internal::PEPINFO *> &pointersTo, const std::vector<msparser_internal::PEPINFO *> &pointersFrom, const ms_protein *src);
            void checkFromCache(const char * calledBy) const;
            void checkQPFromCache(const char * calledBy) const;
            bool isFlagSet(unsigned char fl) const { return (flags_ & fl)?true:false; }
            void setFlag(unsigned char fl, bool val) {
                if (val) {
                    flags_ |= fl;
                } else {
                    //the standard says that complement must promote to an int... there is no performance difference though
                    flags_ = static_cast<unsigned char>(flags_ & ~fl); 
                }
            }
 
            static bool isVarModStrEmpty(const std::string &str);
 
            friend class prot_sort;
            friend class ms_pepinfoSortByScore;
            friend class msparser_internal::ms_peptidesumsql;
    };
#ifndef SWIG
    // Helper class - don't use from outside library
    class ms_proteinPtrSortByAccession
    {
        public:
            bool operator() (const ms_protein * p1, const ms_protein * p2) const {
                return (*p1 < *p2);
            }
    };
 
    class ms_proteinPtrSortByScore
    {
        public:
            bool operator() (const ms_protein * p1, const ms_protein * p2) const {
                if (p1->getScore() != p2->getScore()) {
                    return (p1->getScore() > p2->getScore());
                } else {
                    return (*p1 < *p2);
                }
            }
    };
 
 
    class ms_pepinfoSortByScore
    {
    public:
        ms_pepinfoSortByScore(std::pair<bool, bool> pairParam): removeDiffPos_(pairParam.first), anyLibraryMatches_(pairParam.second) { }
        bool operator() (const msparser_internal::PEPINFO * p1, const msparser_internal::PEPINFO * p2) const;
        ms_pepinfoSortByScore(const ms_pepinfoSortByScore& other): removeDiffPos_(other.removeDiffPos_), anyLibraryMatches_(other.anyLibraryMatches_){}
        ms_pepinfoSortByScore& operator=(const ms_pepinfoSortByScore& other)
        {
            if (&other != this) {
                removeDiffPos_ = other.removeDiffPos_;
                anyLibraryMatches_ = other.anyLibraryMatches_;
            }
            return *this;
        }
 
    private:
        bool removeDiffPos_;
        bool anyLibraryMatches_;
    };
 
    inline std::ostream& operator << (std::ostream& out, const ms_protein& prot)
    {
        out << prot.stringify();
        return out;
    }
 
#endif // end of resfile_group
}   // matrix_science namespace
 
 
#endif // MS_MASCOTRESPROTEIN_HPP
 
/*------------------------------- End of File -------------------------------*/