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         float queryToParent;
  49         float queryToParentLocal;
  50         float divR;
  51 };
  52 /***********************************************************************/
  53 struct SeqDist {
  54         Sequence* seq;
  55         float dist;
  56 };
  57 //********************************************************************************************************************
  58 //sorts lowest to highest
  59 inline bool compareRegionStart(results left, results right){
  60         return (left.nastRegionStart < right.nastRegionStart);
  61 }
  62 //********************************************************************************************************************
  63 //sorts lowest to highest
  64 inline bool compareSeqDist(SeqDist left, SeqDist right){
  65         return (left.dist < right.dist);
  66 }
  67 //********************************************************************************************************************
  68
  69 struct sim {
  70                 string leftParent;
  71                 string rightParent;
  72                 float score;
  73                 int midpoint;
  74 };
  75
  76 struct linePair {
  77                         int start;
  78                         int end;
  79                         linePair(int i, int j) : start(i), end(j) {}
  80                         linePair(){}
  81 };
  82
  83 /***********************************************************************/
  84
  85 class Chimera {
  86
  87         public:
  88
  89                 Chimera(){};
  90                 Chimera(string);
  91                 Chimera(string, bool);
  92                 Chimera(string, string);
  93                 virtual ~Chimera(){};
  94                 virtual void setFilter(bool f)                  {       filter = f;                     }
  95                 virtual void setCorrection(bool c)              {       correction = c;         }
  96                 virtual void setProcessors(int p)               {       processors = p;         }
  97                 virtual void setWindow(int w)                   {       window = w;                     }
  98                 virtual void setIncrement(int i)                {       increment = i;          }
  99                 virtual void setNumWanted(int n)                {       numWanted = n;          }
 100                 virtual void setKmerSize(int k)                 {       kmerSize = k;           }
 101                 virtual void setSVG(int s)                              {       svg = s;                        }
 102                 virtual void setName(string n)                  {       name = n;                       }
 103                 virtual void setMatch(int m)                    {       match = m;                      }
 104                 virtual void setMisMatch(int m)                 {       misMatch = m;           }
 105                 virtual void setDivR(float d)                   {       divR = d;                       }
 106                 virtual void setParents(int p)                  {       parents = p;            }
 107                 virtual void setMinSim(int s)                   {       minSim = s;                     }
 108                 virtual void setMinCoverage(int c)              {       minCov = c;                     }
 109                 virtual void setMinBS(int b)                    {       minBS = b;                      }
 110                 virtual void setMinSNP(int s)                   {       minSNP = s;                     }
 111                 virtual void setIters(int i)                    {       iters = i;                      }
 112                 virtual void setTemplateSeqs(vector<Sequence*> t)       {       templateSeqs = t;       }
 113                 virtual bool getUnaligned()                             {       return unaligned;                       }
 114                 virtual void setTemplateFile(string t)  {   templateFileName = t;       }
 115
 116                 virtual void setCons(string){};
 117                 virtual void setQuantiles(string){};
 118                 virtual void doPrep(){};
 119                 virtual vector<Sequence*> readSeqs(string);
 120                 virtual vector< vector<float> > readQuantiles();
 121                 virtual void setMask(string);
 122                 virtual void runFilter(Sequence*);
 123                 virtual void createFilter(vector<Sequence*>);
 124
 125                 virtual void printHeader(ostream&){};
 126                 virtual int getChimeras(Sequence*){ return 0; }
 127                 virtual int getChimeras(){ return 0; }
 128                 virtual void print(ostream&){};
 129
 130
 131         protected:
 132
 133                 vector<Sequence*> templateSeqs;
 134                 bool filter, correction, svg, unaligned;
 135                 int processors, window, increment, numWanted, kmerSize, match, misMatch, minSim, minCov, minBS, minSNP, parents, iters;
 136                 float divR;
 137                 string seqMask, quanfile, filterString, name, outputDir, templateFileName;
 138                 Sequence* getSequence(string);  //find sequence from name
 139 };
 140
 141 /***********************************************************************/
 142
 143 #endif
 144