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 struct data_struct {
  18         float divr_qla_qrb;
  19         float divr_qlb_qra;
  20         float qla_qrb;
  21         float qlb_qra;
  22         float qla;
  23         float qrb;
  24         float ab;
  25         float qa;
  26         float qb;
  27         float lab;
  28         float rab;
  29         float qra;
  30         float qlb;
  31         int winLStart;
  32         int winLEnd;
  33         int winRStart;
  34         int winREnd;
  35         Sequence querySeq;
  36         Sequence parentA;
  37         Sequence parentB;
  38         float bsa;
  39         float bsb;
  40         float bsMax;
  41         float chimeraMax;
  42
  43 };
  44 /***********************************************************************/
  45 struct data_results {
  46         vector<data_struct> results;
  47         string flag;
  48         Sequence trimQuery;
  49         //results malignerResults;
  50
  51         data_results(vector<data_struct> d, string f, map<int, int> s, Sequence t) : results(d), flag(f), trimQuery(t) {}
  52         data_results() {}
  53 };
  54 /***********************************************************************/
  55 //sorts lowest to highest first by bsMax, then if tie by chimeraMax
  56 inline bool compareDataStruct(data_struct left, data_struct right){
  57         if (left.bsMax < right.bsMax) { return true; }
  58         else if (left.bsMax == right.bsMax) {
  59                 return (left.chimeraMax < right.chimeraMax);
  60         }else { return false;   }
  61 }
  62 /***********************************************************************/
  63 struct Preference {
  64                 string name;
  65                 string leftParent; //keep the name of closest left
  66                 string rightParent; //keep the name of closest
  67                 float score;  //preference score
  68                 float closestLeft;  //keep the closest left
  69                 float closestRight; //keep the closest right
  70                 int midpoint;
  71                 Preference() { name = ""; leftParent = ""; rightParent = ""; score = 0.0; closestLeft = 10000.0; closestRight = 10000.0; midpoint = 0;  }
  72                 ~Preference() {}
  73 };
  74 /***********************************************************************/
  75 struct score_struct {
  76         int prev;
  77         int score;
  78         int row;
  79         int col;
  80 //      int mismatches;
  81 };
  82 /***********************************************************************/
  83 struct trace_struct {
  84         int col;
  85         int oldCol;
  86         int row;
  87 };
  88 /***********************************************************************/
  89 struct results {
  90         int regionStart;
  91         int regionEnd;
  92         int nastRegionStart;
  93         int nastRegionEnd;
  94         string parent;
  95         string parentAligned;
  96         float queryToParent;
  97         float queryToParentLocal;
  98         float divR;
  99 };
 100 /***********************************************************************/
 101 struct SeqDist {
 102         Sequence* seq;
 103         float dist;
 104         int index;
 105 };
 106 /***********************************************************************/
 107 struct SeqCompare {
 108         Sequence seq;
 109         float dist;
 110         int index;
 111 };
 112 //********************************************************************************************************************
 113 //sorts lowest to highest
 114 inline bool compareRegionStart(results left, results right){
 115         return (left.nastRegionStart < right.nastRegionStart);
 116 }
 117 //********************************************************************************************************************
 118 //sorts lowest to highest
 119 inline bool compareSeqDist(SeqDist left, SeqDist right){
 120         return (left.dist < right.dist);
 121 }
 122 //********************************************************************************************************************
 123 //sorts lowest to highest
 124 inline bool compareSeqCompare(SeqCompare left, SeqCompare right){
 125         return (left.dist < right.dist);
 126 }
 127 //********************************************************************************************************************
 128 struct sim {
 129                 string leftParent;
 130                 string rightParent;
 131                 float score;
 132                 int midpoint;
 133 };
 134
 135 struct linePair {
 136                         unsigned long long start;
 137                         unsigned long long end;
 138                         linePair(unsigned long long i, unsigned long long j) : start(i), end(j) {}
 139                         linePair(){}
 140 };
 141
 142
 143 /***********************************************************************/
 144
 145 class Chimera {
 146
 147         public:
 148
 149                 Chimera(){ m = MothurOut::getInstance(); length = 0; unaligned = false;  byGroup = false; }
 150                 virtual ~Chimera(){     for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i];  } for (int i = 0; i < filteredTemplateSeqs.size(); i++) { delete filteredTemplateSeqs[i];  } };
 151                 virtual bool getUnaligned()                             {       return unaligned;                       }
 152                 virtual int getLength()                                 {   return length;      }
 153                 virtual vector<Sequence*> readSeqs(string);
 154                 virtual void setMask(string);
 155                 virtual map<int, int> runFilter(Sequence*);
 156                 virtual string createFilter(vector<Sequence*>, float);
 157                 virtual void printHeader(ostream&){};
 158                 virtual int getChimeras(Sequence*){ return 0; }
 159                 virtual int getChimeras(){ return 0; }
 160                 virtual Sequence print(ostream&, ostream&){  Sequence temp; return temp; }
 161                 virtual Sequence print(ostream&, ostream&, data_results, data_results) { Sequence temp; return temp; }
 162                 virtual int print(ostream&, ostream&, string){  return 0; }
 163                 virtual int getNumNoParents(){  return 0; }
 164                 virtual data_results getResults() { data_results results; return results; }
 165
 166                 #ifdef USE_MPI
 167                 virtual Sequence print(MPI_File&, MPI_File&){  Sequence temp; return temp; }
 168                 virtual Sequence print(MPI_File&, MPI_File&, data_results, data_results, bool&){  Sequence temp; return temp; }
 169                 virtual int print(MPI_File&, MPI_File&, string){  return 0; }
 170                 #endif
 171
 172
 173         protected:
 174
 175                 vector<Sequence*> templateSeqs;
 176                 vector<Sequence*> filteredTemplateSeqs;
 177                 bool filter, unaligned, byGroup;
 178                 int length;
 179                 string seqMask, filterString, outputDir, templateFileName;
 180                 Sequence* getSequence(string);  //find sequence from name
 181                 MothurOut* m;
 182 };
 183
 184 /***********************************************************************/
 185
 186 #endif
 187