fixed mpi version compile issue with chimera.slayer

[mothur.git] / chimera.h

diff --git a/chimera.h b/chimera.h
index 7120478f1df89cb9038ddea7f848cad376ca83d7..2f8ce6106f88fff9a9483550085c7e7d9542e0d1 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;
+       map<int, int> spotMap;
+       Sequence trimQuery;
+       
+       data_results(vector<data_struct> d, string f, map<int, int> s, Sequence t) : results(d), flag(f), spotMap(s), 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;
@@ -83,6 +128,7 @@ struct linePair {
                        linePair(){}
 };
 
+
 /***********************************************************************/
 
 class Chimera {
@@ -90,58 +136,34 @@ class Chimera {
        public:
        
                Chimera(){ m = MothurOut::getInstance(); length = 0; unaligned = false; }
-               //Chimera(string) { m = MothurOut::getInstance(); }
-               //Chimera(string, bool, string) { m = MothurOut::getInstance(); }
-               //Chimera(string, string) { m = MothurOut::getInstance(); }
                virtual ~Chimera(){     for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i];  } };
-               //virtual void setFilter(bool f)                        {       filter = f;                     }
-               //virtual void setCorrection(bool c)            {       correction = c;         }
-               //virtual void setProcessors(int p)             {       processors = p;         }
-               //virtual void setWindow(int w)                 {       window = w;                     }
-               //virtual void setIncrement(int i)              {       increment = i;          }
-               //virtual void setNumWanted(int n)              {       numWanted = n;          }
-               //virtual void setKmerSize(int k)                       {       kmerSize = k;           }
-               //virtual void setSVG(int s)                            {       svg = s;                        }
-               //virtual void setName(string n)                        {       name = n;                       }
-               //virtual void setMatch(int m)                  {       match = m;                      }
-               //virtual void setMisMatch(int m)                       {       misMatch = m;           }
-               //virtual void setDivR(float d)                 {       divR = d;                       }
-               //virtual void setParents(int p)                        {       parents = p;            }
-               //virtual void setMinSim(int s)                 {       minSim = s;                     }
-               //virtual void setMinCoverage(int c)            {       minCov = c;                     }
-               //virtual void setMinBS(int b)                  {       minBS = b;                      }
-               //virtual void setMinSNP(int s)                 {       minSNP = s;                     }
-               //virtual void setIters(int i)                  {       iters = i;                      }
                virtual bool getUnaligned()                             {       return unaligned;                       }
-               //virtual void setTemplateFile(string t)        {   templateFileName = t;       templateSeqs = readSeqs(t);  }
                virtual int getLength()                                 {   return length;      }
-               
-               //virtual void setCons(string){};
-               //virtual void setQuantiles(string){};
-               //virtual int doPrep(){ return 0; }
                virtual vector<Sequence*> readSeqs(string);
-               //virtual vector< vector<float> > readQuantiles();
                virtual void setMask(string);
                virtual map<int, int> runFilter(Sequence*);
                virtual string createFilter(vector<Sequence*>, float);
-               
                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&){  return NULL; }
+               virtual Sequence* print(ostream&, ostream&, data_results, data_results) { return NULL; }
+               virtual int print(ostream&, ostream&, string){  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&){  return 0; }
+               virtual Sequence* print(MPI_File&, MPI_File&, data_results, data_results){  return NULL; }
+               virtual int print(MPI_File&, MPI_File&, string){  return 0; }
                #endif
                
                
        protected:
                
                vector<Sequence*> templateSeqs;
-               bool filter, unaligned; //  correction, svg,
-               int length; //processors, window, increment, numWanted, kmerSize, match, misMatch, minSim, minCov, minBS, minSNP, parents, iters,
-               //float divR;
-               string seqMask, filterString, outputDir, templateFileName; //quanfile, name, 
+               bool filter, unaligned; 
+               int length; 
+               string seqMask, filterString, outputDir, templateFileName; 
                Sequence* getSequence(string);  //find sequence from name       
                MothurOut* m;
 };