Profile.h

/*  This file is part of Victor.

    Victor is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Victor is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Victor.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef __Profile_H__
#define __Profile_H__

#include <Alignment.h>
#include <AminoAcidCode.h>
#include <Debug.h>
#include <IoTools.h>
#include <string>
#include <vector>

namespace Victor { namespace Align2{

    class Profile {
    public:

        // CONSTRUCTORS:

        Profile();

        Profile(const Profile &orig);

        virtual ~Profile();


        // OPERATORS:

        Profile& operator =(const Profile &orig);


        // PREDICATES:

        virtual double getAminoFrequencyFromCode(AminoAcidCode amino,
                unsigned int i);

        virtual double getAminoFrequency(char amino, unsigned int i);

        virtual double getFreqMaxAminoFrequency(unsigned int i);

        virtual AminoAcidCode getAminoMaxFrequencyCode(unsigned int i);

        virtual char getAminoMaxFrequency(unsigned int i);

        virtual unsigned int getNumGap(unsigned int i);

        virtual unsigned int getNumSequences();

        virtual unsigned int getSequenceLength();

        virtual const string getSeq();

        virtual string getConsensus();


        // MODIFIERS:

        virtual void copy(const Profile &orig);

        virtual Profile* newCopy();

        virtual void setFrequency(double freq, AminoAcidCode amino, int i);

        virtual void setFrequency(double freq, char amino, int i);

        virtual void setNumGap(int numGap, int j);

        virtual void setNumSequences(int i);

        virtual void setSeq(string master);

        virtual void setProfile(Alignment &ali);

        virtual void setProfile(Alignment &ali, istream &is);

        virtual void setAllowGaps(bool g);

        virtual void reverse();


        // HELPERS:

        virtual void pCalculateRawFrequency(vector<double> &freq, double &gapFreq,
                Alignment &ali, unsigned int i);

        virtual void pConstructData(Alignment &ali);

        virtual void pResetData();


        // ATTRIBUTES:

        vector< vector<double> > profAliFrequency; 
        vector<double> gapFreq; 
        string seq; 
        unsigned int seqLen; 
        unsigned int numSeq; 
        bool gap; 


    protected:


    private:

    };

    // -----------------------------------------------------------------------------
    //                                   Profile
    // -----------------------------------------------------------------------------

    // PREDICATES:

    inline double
    Profile::getAminoFrequencyFromCode(AminoAcidCode amino, unsigned int i) {
        return profAliFrequency[i][amino];
    }

    inline double
    Profile::getAminoFrequency(char amino, unsigned int i) {
        return getAminoFrequencyFromCode(aminoAcidOneLetterTranslator(amino), i);
    }

    inline double
    Profile::getFreqMaxAminoFrequency(unsigned int i) {
        return profAliFrequency[i][getAminoMaxFrequencyCode(i)];
    }

    inline AminoAcidCode
    Profile::getAminoMaxFrequencyCode(unsigned int i) {
        AminoAcidCode amino = XXX;
        double max = 0;

        for (AminoAcidCode j = ALA; j <= TYR; j++) {
            double tmp = profAliFrequency[i][j];
            if (tmp > max) {
                amino = j;
                max = tmp;
            }
        }

        return amino;
    }

    inline char
    Profile::getAminoMaxFrequency(unsigned int i) {
        return aminoAcidOneLetterTranslator(getAminoMaxFrequencyCode(i));
    }

    inline unsigned int
    Profile::getNumGap(unsigned int i) {
        return static_cast<int> (gapFreq[i]);
    }

    inline unsigned int
    Profile::getNumSequences() {
        return numSeq;
    }

    inline unsigned int
    Profile::getSequenceLength() {
        return profAliFrequency.size();
    }

    inline const string
    Profile::getSeq() {
        return seq;
    }

    inline string
    Profile::getConsensus() {
        string consensus;

        for (unsigned int i = 0; i < getSequenceLength(); i++) {
            char amino = getAminoMaxFrequency(i);
            consensus += amino;
        }

        return consensus;
    }


    // MODIFIERS:

    inline void
    Profile::setFrequency(double freq, AminoAcidCode amino, int i) {
        profAliFrequency[i][amino] = freq;
    }

    inline void
    Profile::setFrequency(double freq, char amino, int i) {
        setFrequency(freq, aminoAcidOneLetterTranslator(amino), i);
    }

    inline void
    Profile::setNumGap(int numGap, int j) {
        gapFreq[j] = numGap;
    }

    inline void
    Profile::setNumSequences(int i) {
        numSeq = i;
    }

    inline void
    Profile::setSeq(string master) {
        seq = master;
    }

    inline void
    Profile::setAllowGaps(bool g) {
        gap = g;
    }

}} // namespace

#endif