chimera.h

   1 #ifndef CHIMERA_H
   2 #define CHIMERA_H
   3
   4 /*
   5  *  chimera.h
   6  *  Mothur
   7  *
   8  *  Created by Sarah Westcott on 7/9/09.
   9  *  Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
  10  *
  11  */
  12
  13
  14 #include "mothur.h"
  15 #include "sequence.hpp"
  16
  17 /***********************************************************************/
  18 struct Preference {
  19                 string name;
  20                 vector<string> leftParent; //keep the name of closest left associated with the two scores
  21                 vector<string> rightParent; //keep the name of closest right associated with the two scores
  22                 vector<float> score;  //so you can keep last score and calc this score and keep whichever is bigger.
  23                 vector<float> closestLeft;  //keep the closest left associated with the two scores
  24                 vector<float> closestRight; //keep the closest right associated with the two scores
  25                 int midpoint;
  26
  27 };
  28 /***********************************************************************/
  29 struct score_struct {
  30         int prev;
  31         int score;
  32         int row;
  33         int col;
  34 };
  35 /***********************************************************************/
  36 struct trace_struct {
  37         int col;
  38         int oldCol;
  39         int row;
  40 };
  41 /***********************************************************************/
  42 struct results {
  43         int regionStart;
  44         int regionEnd;
  45         int nastRegionStart;
  46         int nastRegionEnd;
  47         string parent;
  48         string parentAligned;
  49         float queryToParent;
  50         float queryToParentLocal;
  51         float divR;
  52 };
  53 /***********************************************************************/
  54 struct SeqDist {
  55         Sequence* seq;
  56         float dist;
  57         int index;
  58 };
  59 //********************************************************************************************************************
  60 //sorts lowest to highest
  61 inline bool compareRegionStart(results left, results right){
  62         return (left.nastRegionStart < right.nastRegionStart);
  63 }
  64 //********************************************************************************************************************
  65 //sorts lowest to highest
  66 inline bool compareSeqDist(SeqDist left, SeqDist right){
  67         return (left.dist < right.dist);
  68 }
  69 //********************************************************************************************************************
  70
  71 struct sim {
  72                 string leftParent;
  73                 string rightParent;
  74                 float score;
  75                 int midpoint;
  76 };
  77
  78 struct linePair {
  79                         int start;
  80                         int end;
  81                         linePair(int i, int j) : start(i), end(j) {}
  82                         linePair(){}
  83 };
  84
  85 /***********************************************************************/
  86
  87 class Chimera {
  88
  89         public:
  90
  91                 Chimera(){};
  92                 Chimera(string);
  93                 Chimera(string, bool, string);
  94                 Chimera(string, string);
  95                 virtual ~Chimera(){     for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i];  } };
  96                 virtual void setFilter(bool f)                  {       filter = f;                     }
  97                 virtual void setCorrection(bool c)              {       correction = c;         }
  98                 virtual void setProcessors(int p)               {       processors = p;         }
  99                 virtual void setWindow(int w)                   {       window = w;                     }
 100                 virtual void setIncrement(int i)                {       increment = i;          }
 101                 virtual void setNumWanted(int n)                {       numWanted = n;          }
 102                 virtual void setKmerSize(int k)                 {       kmerSize = k;           }
 103                 virtual void setSVG(int s)                              {       svg = s;                        }
 104                 virtual void setName(string n)                  {       name = n;                       }
 105                 virtual void setMatch(int m)                    {       match = m;                      }
 106                 virtual void setMisMatch(int m)                 {       misMatch = m;           }
 107                 virtual void setDivR(float d)                   {       divR = d;                       }
 108                 virtual void setParents(int p)                  {       parents = p;            }
 109                 virtual void setMinSim(int s)                   {       minSim = s;                     }
 110                 virtual void setMinCoverage(int c)              {       minCov = c;                     }
 111                 virtual void setMinBS(int b)                    {       minBS = b;                      }
 112                 virtual void setMinSNP(int s)                   {       minSNP = s;                     }
 113                 virtual void setIters(int i)                    {       iters = i;                      }
 114                 virtual bool getUnaligned()                             {       return unaligned;                       }
 115                 virtual void setTemplateFile(string t)  {   templateFileName = t;       templateSeqs = readSeqs(t);  }
 116                 virtual int getLength()                                 {   return length;      }
 117
 118                 virtual void setCons(string){};
 119                 virtual void setQuantiles(string){};
 120                 virtual void doPrep(){};
 121                 virtual vector<Sequence*> readSeqs(string);
 122                 virtual vector< vector<float> > readQuantiles();
 123                 virtual void setMask(string);
 124                 virtual map<int, int> runFilter(Sequence*);
 125                 virtual string createFilter(vector<Sequence*>, float);
 126
 127                 virtual void printHeader(ostream&){};
 128                 virtual int getChimeras(Sequence*){ return 0; }
 129                 virtual int getChimeras(){ return 0; }
 130                 virtual void print(ostream&, ostream&){};
 131
 132
 133         protected:
 134
 135                 vector<Sequence*> templateSeqs;
 136                 bool filter, correction, svg, unaligned;
 137                 int processors, window, increment, numWanted, kmerSize, match, misMatch, minSim, minCov, minBS, minSNP, parents, iters, length;
 138                 float divR;
 139                 string seqMask, quanfile, filterString, name, outputDir, templateFileName;
 140                 Sequence* getSequence(string);  //find sequence from name
 141 };
 142
 143 /***********************************************************************/
 144
 145 #endif
 146