msparser/help/ms__aahelper_8hpp_source.html

/*

##############################################################################

# File: ms_aahelper.hpp                                                      #

# Mascot Parser toolkit                                                      #

# Utility functions for generating peptides, peptide and fragment masses     #

##############################################################################

# COPYRIGHT NOTICE                                                           #

# Copyright 1998-2006 Matrix Science Limited  All Rights Reserved.           #

#                                                                            #

##############################################################################

#    $Source: parser/inc/ms_aahelper.hpp $

#    $Author: robertog@matrixscience.com $

#      $Date: 2022-06-13 11:48:05 +0100 $

#  $Revision: 8fe02c5d122124d6c17183492bfe19018028b6e5 | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $

##############################################################################

*/


#ifndef MS_AAHELPER_HPP

#define MS_AAHELPER_HPP


#include <string>

#include <vector>


namespace matrix_science {

    class MS_MASCOTRESFILE_API ms_aahelper: public ms_errors

    {

    public:


        enum FRAG_NL {

            FRAG_NL_PRIMARY = 0x0001,

            FRAG_NL_SECONDARY = 0x0010

        };


        ms_aahelper();


        ms_aahelper(const ms_mascotresfilebase& resfile,

                    const char * enzymeFileName,

                    const char * quantSchemaFilePath = "http://www.matrixscience.com/xmlns/schema/quantitation_2  ../html/xmlns/schema/quantitation_2/quantitation_2.xsd http://www.matrixscience.com/xmlns/schema/quantitation_1 ../html/xmlns/schema/quantitation_1/quantitation_1.xsd",

                    const char * unimodSchemaFilePath = "http://www.unimod.org/xmlns/schema/unimod_2 ../html/xmlns/schema/unimod_2/unimod_2.xsd");


        ms_aahelper(const ms_mascotresults & summary,

                    const char * enzymeFileName,

                    const char * quantSchemaFilePath = "http://www.matrixscience.com/xmlns/schema/quantitation_2  ../html/xmlns/schema/quantitation_2/quantitation_2.xsd http://www.matrixscience.com/xmlns/schema/quantitation_1 ../html/xmlns/schema/quantitation_1/quantitation_1.xsd",

                    const char * unimodSchemaFilePath = "http://www.unimod.org/xmlns/schema/unimod_2 ../html/xmlns/schema/unimod_2/unimod_2.xsd");


        ms_aahelper(const ms_aahelper& right);


        ~ms_aahelper();


#ifndef SWIG

        ms_aahelper& operator=(const ms_aahelper& right);

#endif

        void copyFrom(const ms_aahelper* right);


        void defaultValues();


        void setEnzyme(const ms_enzyme* enzyme);


        const ms_enzyme* getEnzyme() const;


        void setMasses(const ms_masses *masses);


        const ms_masses* getMasses() const;


        void setAvailableModifications(const ms_modvector *fixedModVector,

                                       const ms_modvector *varModVector);


        ms_modvector getFixedMods() const;


        ms_modvector getVarMods() const;


        void startIteratePeptides(const char* sequenceProtein,

                                  const int sizeProtein,

                                  const int pfa);


        bool getNextPeptide();


        int getPepStart() const;


        int getPepEnd() const;


        int getMissed() const;


        void stopIteratePeptides();


        double calcPeptideMZ(const char* proteinStr,

                             const int proteinLen,

                             const int startPos,

                             const int endPos,

                             const std::vector< int > numThatMustBeModded,

                             const int charge,

                             const MASS_TYPE massType,

                             ms_errs *err) const;


        ms_peptide createPeptide(const char* proteinStr,

                                 const int proteinLen,

                                 const int startPos,

                                 const int endPos,

                                 const std::vector< int > varMods,

                                 const std::vector< int > varModsWhichNl,

                                 const int charge,

                                 const MASS_TYPE massType,

                                 ms_errs *err) const;


        ms_peptide createPeptide(const char* proteinStr,

                                 const int proteinLen,

                                 const int startPos,

                                 const int endPos,

                                 const std::vector< int > varMods,

                                 const std::vector< int > varModsWhichNl,

                                 const std::vector< int > summedMods,

                                 const std::vector< int > summedModsWhichNl,

                                 const int charge,

                                 const MASS_TYPE massType,

                                 ms_errs *err) const;


        ms_peptide createCrosslinkedPeptide(const ms_peptide &pepAlpha,

                                            const ms_peptide &pepBeta,

                                            const ms_linker_site_vector &linkedSites,

                                            ms_errs *err) const;


        std::vector< double > calcFragments(const ms_peptide* peptide,

                                            const int seriesID,

                                            const bool doubleCharged,

                                            const double minMass,

                                            const double maxMass,

                                            const MASS_TYPE massType,

                                            ms_fragmentvector* fragments,

                                            ms_errs* err,

                                            const FRAG_NL fragNlType = FRAG_NL_PRIMARY) const;


        bool calcFragmentsEx(const ms_peptide* peptide,

                             const int seriesID,

                             const int fragCharge,

                             const double minMass,

                             const double maxMass,

                             const MASS_TYPE massType,

                             ms_fragmentvector* fragments,

                             ms_errs* err,

                             const FRAG_NL fragNlType = FRAG_NL_PRIMARY) const;


#ifndef SWIG

        std::vector< double > calcFragments(const ms_peptide* peptide,

                                            const int seriesID,

                                            const bool doubleCharged,

                                            const double minMass,

                                            const double maxMass,

                                            const MASS_TYPE massType,

                                            std::vector< ms_fragment > *fragments,

                                            ms_errs* err,

                                            const FRAG_NL fragNlType = FRAG_NL_PRIMARY) const;


        bool calcFragmentsEx(const ms_peptide* peptide,

                             const int seriesID,

                             const int fragCharge,

                             const double minMass,

                             const double maxMass,

                             const MASS_TYPE massType,

                             std::vector< ms_fragment > *fragments,

                             ms_errs* err,

                             const FRAG_NL fragNlType = FRAG_NL_PRIMARY) const;

#endif


    private:

        // Nasty const issue with logging and tracing.

        ms_errs* getLog() const { return const_cast<ms_errs*>(getErrorHandler()); }


        std::string convertPrimaryNlVectorToString(const std::vector< int > modded,

                                                   const std::vector< int > whichNl,

                                                   const ms_modvector &varMods,

                                                   const ms_modvector &varMods_used,

                                                   ms_errs* err) const;


        std::vector< int > convertPrimaryNlStringToVector(const std::string varModStr,

                                                          const std::string primaryNlStr,

                                                          const ms_modvector &varMods_used,

                                                          ms_errs* err) const;


        void initialiseFromResfile(const ms_mascotresfilebase& resfile,

                                   const char * enzymeFileName,

                                   const char * quantSchemaFilePath,

                                   const char * unimodSchemaFilePath);

        bool checkVarModConflicts(const ms_modvector *varModVector, ms_modvector &varMods, std::vector<int> &varModsSrc, ms_modvector &varMods_used, ms_errs &err) const;

        bool iscleavagepoint(const char left, const char right) const;

        bool switchIndependent();

        void updatemissed(const int leftPos);

        void dropmissed();

        void clearMods();

        bool calcUnionFragmentList(const ms_peptide* peptide,

                                   const int seriesID,

                                   const int fragCharge,

                                   const double minMass,

                                   const double maxMass,

                                   const MASS_TYPE massType,

                                   const FRAG_NL fragNlType,

                                   std::vector< ms_fragment > *fragments,

                                   ms_errs *err,

                                   std::vector< double > *vi) const;

        bool calcCrosslinkedFragments(const ms_peptide *peptide,

                                      const int seriesID,

                                      const int fragCharge,

                                      const double minMass,

                                      const double maxMass,

                                      const MASS_TYPE massType,

                                      const FRAG_NL fragNlType,

                                      std::vector< ms_fragment > *fragments,

                                      ms_errs *err,

                                      std::vector< double > *vi) const;

        bool cfr(const ms_peptide* peptide,

                const ms_peptide::PSM psmComponent,

                const int seriesID,

                const int fragCharge,

                const double minMass,

                const double maxMass,

                const MASS_TYPE massType,

                const FRAG_NL fragNlType,

                const int linkerColumn,

                const double linkerMassOffset,

                std::vector< ms_fragment > *fragments,

                ms_errs* err,

                std::vector< double > *vi) const;


        void getSeriesParams(const char* pepStr,

                             const int seriesID,

                             const ms_masses & masses,

                             const MASS_TYPE massType,

                             double& delta,

                             int& start,

                             int& end,

                             bool& forward) const;


        void prepareCumulativeMassAndNL(const std::string &pepStr,

                                        const ms_masses *pMasses,

                                        const MASS_TYPE massType,

                                        const std::vector<bool> &residue_has_varmod,

                                        const std::vector<double> &fixedModNlVals,

                                        const std::vector<double> &totalModDelta,

                                        const std::vector<double> &totalNlVals,

                                        const bool isMasterNL,

                                        std::vector<double> &m,

                                        std::vector<double> &cumulativeNlVals) const;


        class IonSet;

        void calculateSeriesMasses(const int seriesID,

                                   const int fragCharge,

                                   const MASS_TYPE massType,

                                   const ms_peptide::PSM psmComponent,

                                   const int linkerColumn,

                                   const double linkerMassOffset,

                                   const ms_masses *pMasses,

                                   const std::string &pepStr,

                                   const std::vector<double> &m,

                                   const std::vector<double> &cumulativeNlVals,

                                   const std::vector<bool> &loopLinkingAllows,

                                   IonSet &ionSet) const;


        void setupFromPre2_2ResultsFile(const std::string & peptide, const std::string & varMods);


        class ModLookupHelper;

        bool initialiseModsAtResidues(const ModLookupHelper &lookupHelper,

                                      const std::string &pepStr,

                                      const std::string &modStr,

                                      const std::vector<int> &primaryNl,

                                      const std::string &monoLinkStr,

                                      const ms_modvector *varmods,

                                      const std::vector<int> *varmods_src,

                                      const ms_modvector *varmods_used,

                                      const ms_peptide::PSM psmComponent,

                                      std::vector< const ms_modification* > &mod_at_residue,

                                      ms_errs *err) const;


        bool lookupLocalModVectors(int q, const ms_modvector* &local_mods, const std::vector<int>* &local_mods_src, const ms_modvector* &local_mods_used);

        void clearLocalModVectors();


        ms_masses   massesUnmod_;

        ms_masses   masses_;

        ms_umod_configfile umodFile_;

        ms_quant_configfile quantFile_;

    const ms_mascotresfilebase* pResfile_;

        const ms_mascotresults * pSummary_;


        ms_modvector fixedMods_;

        ms_modvector varMods_;

        std::vector< int > varModsSrc_;

        ms_modvector varMods_used_;


        typedef std::map<int, ms_modvector > queryParsedLocalMods_t;

        typedef std::map<int, std::vector<int> > queryParsedLocalModsSrc_t;

        queryParsedLocalMods_t queryParsedLocalMods_;

        queryParsedLocalModsSrc_t queryParsedLocalModsSrc_;

        queryParsedLocalMods_t queryParsedLocalModsUsed_;


        ms_enzyme   enzyme_;

        bool        bEnzymeSet_;

        std::string protStr_;

        int         protLen_;

        int         pfa_; // missed cleavages limit


        // internal iteration parameters

        int         numInd_; // current independent enzyme ID

        int         l_, r_; // the last peptide ends

        int         missed_; // number of missed cleavages in the current peptide

        int         enzymesPassed_;


        // for the sake of semi-specific enzymes

        bool        forward_;


        // For a pre 2.2 results file, need to keep track of what we know

        enum DERIVED_MOD_SPECIFICITY_STATUS

        {

            DMSS_NOT_INITIALISED,

            DMSS_WORKING,

            DMSS_COMPLETED,

            DMSS_FROM_V2_2_OR_LATER_RESFILE,

            DMSS_NOT_FROM_RESFILE

        };

        DERIVED_MOD_SPECIFICITY_STATUS derivedModSpecificityStatus_;

        std::vector<MOD_TYPES> derivedModSpecificities_;

        typedef std::vector< std::vector<bool> > modifiedResidues_t;

        modifiedResidues_t derivedModifiedResidues_;


    }; // ms_aahelper // end of mass_calculation_group

} // matrix_science


#endif // MS_AAHELPER_HPP


/*------------------------------- End of File -------------------------------*/

matrix_science::ms_aahelper
This class facilitates creation of peptides and calculation of MS-fragment masses.
Definition: ms_aahelper.hpp:35

matrix_science::ms_aahelper::FRAG_NL
FRAG_NL
Flag for controlling iteration over multiple neutral losses.
Definition: ms_aahelper.hpp:47

matrix_science::ms_enzyme
Represent a single entry in the enzymes file.
Definition: ms_enzyme.hpp:67

matrix_science::ms_errors
This class is used as a base class for several Mascot Parser classes.
Definition: ms_errors.hpp:696

matrix_science::ms_errs
All errors are collected in an instance of this class.
Definition: ms_errors.hpp:37

matrix_science::ms_fragmentvector
Class for holding a list of ms_fragment objects.
Definition: ms_fragmentvector.hpp:47

matrix_science::ms_linker_site_vector
A vector of linker sites.
Definition: ms_linker_site_vector.hpp:46

matrix_science::ms_mascotresfilebase
Abstract base class of ms_mascotresfile_dat and ms_mascotresfile_msr.
Definition: ms_mascotresfilebase.hpp:72

matrix_science::ms_mascotresults
Abstract class for either ms_peptidesummary or ms_proteinsummary.
Definition: ms_mascotresults.hpp:83

matrix_science::ms_masses
Reads and parses the masses file with residue and atom masses.
Definition: ms_masses.hpp:48

matrix_science::ms_modvector
General usage class for creating lists of modifications to be passed as parameters.
Definition: ms_modfile.hpp:339

matrix_science::ms_peptide
This class encapsulates a peptide from the mascot results file.
Definition: ms_peptide.hpp:57

matrix_science::MASS_TYPE
MASS_TYPE
All possible mass types.
Definition: ms_modfile.hpp:65