alignment.h

Go to the documentation of this file.

#ifndef ALIGNMENT_H
#define ALIGNMENT_H

// file: alignment.h

#include <iostream>
//#include <fstream.h>
#include <string>
#include <vector>

using namespace std;

enum quality { best, good, partial_good, ok, bad };
// best good identity with nogaps
// good: good identity in all non-gapped columns
// partial_good:  good identity all columns with gap char < 0.4
// ok: not used yet
// bad: failed the above test

enum alnmethod { clustal, dialign };

list<pair<int, int> > listgap(const string &s, const char gapChar='-');

class alignpos {
        public:
        alignpos(int l, int w) : length(l), width(w) { allocate(); }
        ~alignpos() { deallocate(); }
        alignpos(const alignpos &alp);
        alignpos& operator=(const alignpos &alp);

        private:
                void deallocate();
                void allocate();
                int **posmap;
                int length;
                int width;
};

class alignment {
        public:
                alignment() : idenCnt(0), nogapCol(0), nogapsimCnt(0), simCnt(0) {}

                /* reading will refresh member values to default 
                 * will automatically call readDia or readClustal depending on
                 * the header of the sequence alignemnt file.*/
                void read(istream &in);   

                void readDia(istream &in);
                void readClustal(istream &in);

                void printPolymorphic(ostream &ous) const;

                alignpos getPosition() const;

                /* output the alignment model in gapinsert format*/
                friend ostream& operator<<(ostream &ou, const alignment &aln);
                string getalnmodel() const;
                //string lengthToString() const;
                //char getQualityAsChar() const;

                void dumpaln();
                bool highQuality(float cut=0.2);

                /* length of the alignment */
                int length() const { return seqarr[0].length(); }
                int nogapLength() const { return nogapCol; }

                /* identity of the multiple alignment */
                float identity() const { return (float)idenCnt/length(); }

                float similarity() const { return (idenCnt+simCnt)/(float)length(); }
                int getIdentityCount() const { return idenCnt; }
                int getSimilarityCount() const { return simCnt; }
                bool goodSegment();
                float nogapIdentity() const { return (float)idenCnt/nogapCol; }
                float nogapSimilarity() { return (float)(idenCnt + nogapsimCnt)/nogapCol; }
                int seqCount() const { return seqarr.size(); }
                int size() const { return seqarr.size(); }  // number of sequences
                ostream& dumpQuality(ostream &ou);

                /* column gap char proportion < 0.49 will be considered */
                float partialCount(float gapcut = 0.51); // returns partial identity
                bool partialGood(float base);

                quality getqual(float base = 0.08, float top = 1.2);  // return the quality values

                static const int nogapcolcut;  // set to 8
                float idenCut;
                alnmethod method;
                string clusterid;


        protected:
                float calcut(float top, float n, int iden);
                void count();
                void countDia();

                /* the core model structure, 
                 * as two array of strings: the name and the actual sequence
                 * */
                vector<string> seqarr, namearr;
                string consensus;
                int idenCnt, simCnt;  // simCnt is the similarity count of 
                // nongapped region only
                int nogapsimCnt, nogapCol;  // number of nongapped columns
                int partiden, partcol;   // only needed when failed QC
                float avgThick;  // similar to size()
};


#endif