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 //sorts lowest to highest
 108 inline bool compareRegionStart(results left, results right){
 109         return (left.nastRegionStart < right.nastRegionStart);
 110 }
 111 //********************************************************************************************************************
 112 //sorts lowest to highest
 113 inline bool compareSeqDist(SeqDist left, SeqDist right){
 114         return (left.dist < right.dist);
 115 }
 116 //********************************************************************************************************************
 117
 118 struct sim {
 119                 string leftParent;
 120                 string rightParent;
 121                 float score;
 122                 int midpoint;
 123 };
 124
 125 struct linePair {
 126                         unsigned long int start;
 127                         unsigned long int end;
 128                         linePair(unsigned long int i, unsigned long int j) : start(i), end(j) {}
 129                         linePair(){}
 130 };
 131
 132
 133 /***********************************************************************/
 134
 135 class Chimera {
 136
 137         public:
 138
 139                 Chimera(){ m = MothurOut::getInstance(); length = 0; unaligned = false;  }
 140                 virtual ~Chimera(){     for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i];  } for (int i = 0; i < filteredTemplateSeqs.size(); i++) { delete filteredTemplateSeqs[i];  } };
 141                 virtual bool getUnaligned()                             {       return unaligned;                       }
 142                 virtual int getLength()                                 {   return length;      }
 143                 virtual vector<Sequence*> readSeqs(string);
 144                 virtual void setMask(string);
 145                 virtual map<int, int> runFilter(Sequence*);
 146                 virtual string createFilter(vector<Sequence*>, float);
 147                 virtual void printHeader(ostream&){};
 148                 virtual int getChimeras(Sequence*){ return 0; }
 149                 virtual int getChimeras(){ return 0; }
 150                 virtual Sequence* print(ostream&, ostream&){  return NULL; }
 151                 virtual Sequence* print(ostream&, ostream&, data_results, data_results) { return NULL; }
 152                 virtual int print(ostream&, ostream&, string){  return 0; }
 153                 virtual data_results getResults() { data_results results; return results; }
 154
 155                 #ifdef USE_MPI
 156                 virtual Sequence* print(MPI_File&, MPI_File&){  return 0; }
 157                 virtual Sequence* print(MPI_File&, MPI_File&, data_results, data_results){  return NULL; }
 158                 virtual int print(MPI_File&, MPI_File&, string){  return 0; }
 159                 #endif
 160
 161
 162         protected:
 163
 164                 vector<Sequence*> templateSeqs;
 165                 vector<Sequence*> filteredTemplateSeqs;
 166                 bool filter, unaligned;
 167                 int length;
 168                 string seqMask, filterString, outputDir, templateFileName;
 169                 Sequence* getSequence(string);  //find sequence from name
 170                 MothurOut* m;
 171 };
 172
 173 /***********************************************************************/
 174
 175 #endif
 176