Alignment.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 __Alignment_H__
#define __Alignment_H__

#include <AlignmentBase.h>
#include <Debug.h>
#include <string>
#include <vector>

namespace Victor { namespace Align2{

    class Alignment : public AlignmentBase {
    public:

        // CONSTRUCTORS:

        Alignment();

        Alignment(const Alignment &orig);

        virtual ~Alignment();


        // OPERATORS:

        Alignment& operator =(const Alignment &orig);


        // PREDICATES:

        double getScore(unsigned int index = 0) const;

        double getEvalue(unsigned int index = 0) const;

        void saveMSAF(ostream &output) const;

        virtual void saveFasta(ostream &output) const;


        // MODIFIERS:

        virtual void clearAlignment();

        virtual void swapTemplate(unsigned int index1, unsigned int index2);

        virtual void setTemplate(string t, string tName = "template",
                double tScore = 0.0, double tEvalue = -1.0);

        void setScore(double val, unsigned int index = 0);

        void setEvalue(long double val, unsigned int index = 0);

        virtual void clearTemplate();

        virtual void cutTemplate(unsigned int index);

        virtual void doMatchPlusHeader(ostream &os, string headerTarget,
                int startTarget, int endTarget, string headerTemplate, int startTemplate,
                int endTemplate, string alignType, string gapOpen, string gapExtension,
                double pWeigth, double sWeigth, double tWeigth, string seqTarget,
                string seqTemplat) const;

        void loadFasta(istream &input);

        void loadCEBody(istream &input);

        void loadCE(istream &input);

        vector< vector<int> > loadMap(istream &is);

        vector<int> mapStructureCE2Sequence(vector< vector<int> > mapIn, istream &pdbstream,
                string startingChain, vector<int> shiftedSeqresEntries);

        int getTrueMapFromPdb(istream &is, string startingChain, int structEntryMapCe);

        void loadBlastMode6(istream &input);
        void loadPsiBlastMode4(istream &input);
        void loadBlastMode6FullSeq(istream &input, string masterTarget);

        void loadMSAF(istream &input);

        virtual void copy(const Alignment &orig);

        virtual void addAlignment(const Alignment &other);

        virtual void RemoveLowerSimple(double ID);

        virtual void RemoveLowerAll(double ID);

        virtual void RemoveUpperSimple(double ID);

        virtual void RemoveUpperAll(double ID);


    protected:


    private:

        void loadCEHeader(istream &input);


        // ATTRIBUTES:

        vector<double> score; 
        vector<long double> evalue; 

    };

    // -----------------------------------------------------------------------------
    //                                  Alignment
    // -----------------------------------------------------------------------------

    // PREDICATES:

    inline double
    Alignment::getScore(unsigned int index) const {
        if (index >= score.size())
            ERROR("Invalid template requested.", exception);
        return score[index];
    }

    inline double
    Alignment::getEvalue(unsigned int index) const {
        if (index >= evalue.size())
            ERROR("Invalid template requested.", exception);
        return evalue[index];
    }


    // MODIFIERS:

    inline void
    Alignment::clearAlignment() {
        AlignmentBase::clearAlignment();
        score.clear();
        evalue.clear();
    }

    inline void
    Alignment::clearTemplate() {
        AlignmentBase::clearTemplate();
        score.clear();
        evalue.clear();
    }

}} // namespace

#endif