ms_mascotresparams.hpp

/*
##############################################################################
# file: ms_mascotresparams.hpp                                               #
# 'msparser' toolkit                                                         #
# Encapsulates the parameters & masses sections from the mascot results file #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2019 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Archive:: /MowseBranches/ms_mascotresfile_1.2/include/ms_mascotrespa $ #
#     $Author: francoisr@matrixscience.com $ #
#       $Date: 2021-07-22 14:03:31 +0100 $ #
#   $Revision: 0ea29aa2aa389c9ba7d3f7b5485b56c02719f01e | MSPARSER_REL_2_8_1-0-gea32989045 $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/

#ifndef MS_MASCOTRESPARAMS_HPP
#define MS_MASCOTRESPARAMS_HPP


// Includes from the standard template library
#include <string>

namespace matrix_science {



    class MS_MASCOTRESFILE_API ms_searchparams
    {
        public:


            enum MULTI_SITE_MODS {
                MSM_NOT_PERMITTED           = 0x0000, 
                MSM_EXCLUSIVE_PLUS_VARIABLE = 0x0001  
            };

            ms_searchparams(const ms_mascotresfile &resfile);

            ~ms_searchparams() {};

            std::string  getLICENSE();
#ifndef SWIGCSHARP

            std::string  getCOM();
#else
            std::wstring getCOM() {
                return getCOMWide();
            };      
#endif

            int          getSEG();

            double       getTOL();

            std::string  getTOLU();

            double       getITOL();

            std::string  getITOLU();

            int          getPFA();

            std::string  getDB(int idx = 1);

            int getNumberOfDatabases();

            std::string  getMODS();

            std::string  getMASS();

            MASS_TYPE    getMassType();

            std::string  getCLE();

            std::string  getFILENAME();

            std::string  getDATAURL();

            std::string  getQUE();

            std::string  getSEARCH();

#ifndef SWIGCSHARP

            std::string  getUSERNAME();
#else
            std::wstring getUSERNAME() {
                return getUSERNAMEWide();
            };
#endif

#ifndef SWIGCSHARP

            std::string  getUSEREMAIL();
#else
            std::wstring getUSEREMAIL() {
                return getUSEREMAILWide();
            };
#endif

            int getUSERID();

            std::string  getCHARGE();

            std::string  getINTERMEDIATE();

            int          getREPORT();

            bool         getOVERVIEW();

            std::string  getFORMAT();

            std::string  getFORMVER();

            std::string  getIT_MODS();

            std::string  getUSERField(int num);

            std::string getAllUSERParams() const;

            double       getPRECURSOR();

            std::string  getTAXONOMY();

            std::string  getREPTYPE();

            std::string  getACCESSION();

            int          getSUBCLUSTER();

            bool         getICAT();

            std::string  getINSTRUMENT();

            bool         getERRORTOLERANT();

            std::string  getRULES();

            double getMinInternalMass();

            double getMaxInternalMass();

            double       getResidueMass(char residue);

            double       getCTermMass();

            double       getNTermMass();

            double       getHydrogenMass() const;

            double       getOxygenMass() const;

            double       getCarbonMass() const;

            double       getNitrogenMass() const;

            double       getElectronMass() const;

            // Returns the name of the specified variable modification selected by the user.
            std::string  getVarModsName(int num) const;

            double       getVarModsDelta(int num);

            double       getVarModsNeutralLoss(int num);

            std::vector<double> getVarModsNeutralLosses(int num) const;

            std::vector<double> getVarModsPepNeutralLoss(int num);

            std::vector<double> getVarModsReqPepNeutralLoss(int num);

            // Returns the name of the specified fixed modification selected by the user.
            std::string  getFixedModsName(int num) const;

            double       getFixedModsDelta(int num);

            double       getFixedModsNeutralLoss(int num);

            std::string  getFixedModsResidues(int num) const;

            int          getNumberOfLibraryMods() const;

            std::string  getLibraryModName(int num) const;

            double       getLibraryModDelta(int num) const;

            std::string  getErrTolParentFilename();

            std::string  getQUANTITATION() const;

            std::string  getCROSSLINKING() const;

            int  getPEP_ISOTOPE_ERROR() const;

            int  getDECOY() const;

            double getTARGET_FDR_PERCENT() const;

            int  getLIBRARY_SEARCH() const;

            unsigned int getMULTI_SITE_MODS() const;

        protected:
            // Not safe to copy or assign this object.
#ifndef SWIG
            ms_searchparams(const ms_searchparams & rhs);
            ms_searchparams & operator=(const ms_searchparams & rhs);
#endif

        private:
            std::wstring getCOMWide();
            std::wstring getUSERNAMEWide();
            std::wstring getUSEREMAILWide();
            std::string decryptNumber(const std::string & input) const;
            bool parseLibraryMod(const ms_mascotresfile & resfile, int num, std::string & name, double & delta) const;
            

            int numDB_;
            std::string license_;
            std::string com_;
            int seg_;
            double tol_;
            std::string tolu_;
            double itol_;
            std::string itolu_;
            int PFA_;
            std::vector<std::string> DBnames_;
            std::string mods_;
            std::string massTypeStr_;
            std::string cle_;
            std::string FILENAME_;
            std::string DATAURL_;
            std::string QUE_;
            std::string SEARCH_;
            std::string USERNAME_;
            int USERID_;
            std::string USEREMAIL_;
            std::string CHARGE_;
            std::string INTERMEDIATE_;
            int REPORT_;
            bool OVERVIEW_;
            std::string FORMAT_;
            std::string FORMVER_;
            std::string IT_MODS_;
            std::vector<std::string> userField_;
            std::string allUserParams_;
            double PRECURSOR_;
            std::string TAXONOMY_;
            std::string REPTYPE_;
            std::string ACCESSION_;
            int SUBCLUSTER_;
            bool ICAT_;
            std::string INSTRUMENT_;
            bool ERRORTOLERANT_;
            std::string RULES_;
            double minInternalMass_;
            double maxInternalMass_;
            std::map<char, double> residueMasses_;
            double C_term_;
            double N_term_;
            double HydrogenMass_;
            double OxygenMass_;
            double CarbonMass_;
            double NitrogenMass_;
            double ElectronMass_;
            std::map<int, std::string> varModsName_;
            std::map<int, double> varModsDelta_;
            std::map<int, std::vector<double> > varModsNeutralLosses_;
            std::map<int, std::vector<double> > pepNeutralLoss_;
            std::map<int, std::vector<double> > reqPepNeutralLoss_;
            std::map<int, std::string> fixedModsName_;
            std::map<int, double> fixedModsDelta_;
            std::map<int, double> fixedModsNeutralLoss_;
            std::map<int, std::string> fixedModsResidues_;
            std::vector<std::string> libraryModNames_;
            std::vector<double> libraryModDeltas_;
            int numLibraryMods_;
            std::string errTolParentFilename_;
            std::string QUANTITATION_;
            std::string CROSSLINKING_;
            int PEP_ISOTOPE_ERROR_;
            int decoy_;
            double TARGET_FDR_PERCENT_;
            int LIBRARY_SEARCH_;
            int MULTI_SITE_MODS_;

            int getNumberOfDatabases(const ms_mascotresfile & resfile) const;

    }; // end of resfile_group
}   // matrix_science namespace

#endif // MS_MASCOTRESPARAMS_HPP

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