changes while testing

[mothur.git] / chimera.h

diff --git a/chimera.h b/chimera.h
index 6ac6191692a10c7c445b442721fc289784ff549d..e187bfc60d8d504d80561d4347f9a838f1ddabee 100644 (file)
--- a/chimera.h
+++ b/chimera.h
@@ -13,7 +13,52 @@
 
 #include "mothur.h"
 #include "sequence.hpp"
-
+/***********************************************************************/
+struct data_struct { 
+       float divr_qla_qrb;
+       float divr_qlb_qra;
+       float qla_qrb;
+       float qlb_qra;
+       float qla;
+       float qrb;
+       float ab; 
+       float qa;
+       float qb; 
+       float lab; 
+       float rab; 
+       float qra; 
+       float qlb; 
+       int winLStart;
+       int winLEnd; 
+       int winRStart; 
+       int winREnd; 
+       Sequence querySeq; 
+       Sequence parentA;
+       Sequence parentB;
+       float bsa;
+       float bsb;
+       float bsMax;
+       float chimeraMax;
+       
+};
+/***********************************************************************/
+struct data_results {
+       vector<data_struct> results;
+       string flag;
+       Sequence trimQuery;
+       //results malignerResults;
+       
+       data_results(vector<data_struct> d, string f, map<int, int> s, Sequence t) : results(d), flag(f), trimQuery(t) {}
+       data_results() {}
+};
+/***********************************************************************/
+//sorts lowest to highest first by bsMax, then if tie by chimeraMax
+inline bool compareDataStruct(data_struct left, data_struct right){
+       if (left.bsMax < right.bsMax) { return true; }
+       else if (left.bsMax == right.bsMax) {
+               return (left.chimeraMax < right.chimeraMax);
+       }else { return false;   }
+} 
 /***********************************************************************/
 struct Preference {
                string name;
@@ -32,6 +77,7 @@ struct score_struct {
        int score;
        int row;
        int col;
+//     int mismatches;
 };
 /***********************************************************************/
 struct trace_struct {
@@ -57,6 +103,12 @@ struct SeqDist {
        float dist;
        int index;
 };
+/***********************************************************************/
+struct SeqCompare {
+       Sequence seq;
+       float dist;
+       int index;
+};
 //********************************************************************************************************************
 //sorts lowest to highest
 inline bool compareRegionStart(results left, results right){
@@ -68,7 +120,11 @@ inline bool compareSeqDist(SeqDist left, SeqDist right){
        return (left.dist < right.dist);        
 } 
 //********************************************************************************************************************
-
+//sorts lowest to highest
+inline bool compareSeqCompare(SeqCompare left, SeqCompare right){
+       return (left.dist < right.dist);        
+} 
+//********************************************************************************************************************
 struct sim {
                string leftParent;
                string rightParent; 
@@ -77,9 +133,9 @@ struct sim {
 };
 
 struct linePair {
-                       unsigned long int start;
-                       unsigned long int end;
-                       linePair(unsigned long int i, unsigned long int j) : start(i), end(j) {}
+                       unsigned long long start;
+                       unsigned long long end;
+                       linePair(unsigned long long i, unsigned long long j) : start(i), end(j) {}
                        linePair(){}
 };
 
@@ -90,8 +146,8 @@ class Chimera {
 
        public:
        
-               Chimera(){ m = MothurOut::getInstance(); length = 0; unaligned = false; }
-               virtual ~Chimera(){     for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i];  } };
+               Chimera(){ m = MothurOut::getInstance(); length = 0; unaligned = false;  byGroup = false; }
+               virtual ~Chimera(){     for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i];  } for (int i = 0; i < filteredTemplateSeqs.size(); i++) { delete filteredTemplateSeqs[i];  } };
                virtual bool getUnaligned()                             {       return unaligned;                       }
                virtual int getLength()                                 {   return length;      }
                virtual vector<Sequence*> readSeqs(string);
@@ -101,17 +157,24 @@ class Chimera {
                virtual void printHeader(ostream&){};
                virtual int getChimeras(Sequence*){ return 0; }
                virtual int getChimeras(){ return 0; }
-               virtual int print(ostream&, ostream&){  return 0; }
+               virtual Sequence print(ostream&, ostream&){  Sequence temp; return temp; }
+               virtual Sequence print(ostream&, ostream&, data_results, data_results) { Sequence temp; return temp; }
+               virtual int print(ostream&, ostream&, string){  return 0; }
+               virtual int getNumNoParents(){  return 0; }
+               virtual data_results getResults() { data_results results; return results; }
                
                #ifdef USE_MPI
-               virtual int print(MPI_File&, MPI_File&){  return 0; }
+               virtual Sequence print(MPI_File&, MPI_File&){  Sequence temp; return temp; }
+               virtual Sequence print(MPI_File&, MPI_File&, data_results, data_results, bool&){  Sequence temp; return temp; }
+               virtual int print(MPI_File&, MPI_File&, string){  return 0; }
                #endif
                
                
        protected:
                
                vector<Sequence*> templateSeqs;
-               bool filter, unaligned; 
+               vector<Sequence*> filteredTemplateSeqs;
+               bool filter, unaligned, byGroup; 
                int length; 
                string seqMask, filterString, outputDir, templateFileName; 
                Sequence* getSequence(string);  //find sequence from name