added template=self capability to chimers.slayer, worked on corr.axes and added accno...

[mothur.git] / chimera.h

diff --git a/chimera.h b/chimera.h
index a968a02fa61cb06d7bef2d92386db5d55cf020f3..6ac6191692a10c7c445b442721fc289784ff549d 100644 (file)
--- a/chimera.h
+++ b/chimera.h
@@ -17,13 +17,14 @@
 /***********************************************************************/
 struct Preference {
                string name;
-               vector<string> leftParent; //keep the name of closest left associated with the two scores
-               vector<string> rightParent; //keep the name of closest right associated with the two scores
-               vector<float> score;  //so you can keep last score and calc this score and keep whichever is bigger.
-               vector<float> closestLeft;  //keep the closest left associated with the two scores
-               vector<float> closestRight; //keep the closest right associated with the two scores
+               string leftParent; //keep the name of closest left 
+               string rightParent; //keep the name of closest 
+               float score;  //preference score
+               float closestLeft;  //keep the closest left 
+               float closestRight; //keep the closest right 
                int midpoint;
-
+               Preference() { name = ""; leftParent = ""; rightParent = ""; score = 0.0; closestLeft = 10000.0; closestRight = 10000.0; midpoint = 0;  }
+               ~Preference() {}
 };
 /***********************************************************************/
 struct score_struct {
@@ -45,28 +46,18 @@ struct results {
        int nastRegionStart;
        int nastRegionEnd;
        string parent;
+       string parentAligned;
        float queryToParent;
        float queryToParentLocal;
        float divR;
 };
 /***********************************************************************/
-struct rank {
-               int num;
-               float score;
-               rank(int n, float s) : num(n), score(s) {}
-};
-/***********************************************************************/
-
 struct SeqDist {
        Sequence* seq;
        float dist;
+       int index;
 };
 //********************************************************************************************************************
-//sorts highest to lowest
-inline bool compareMembers(rank left, rank right){
-       return (left.score > right.score);      
-} 
-//********************************************************************************************************************
 //sorts lowest to highest
 inline bool compareRegionStart(results left, results right){
        return (left.nastRegionStart < right.nastRegionStart);  
@@ -86,67 +77,45 @@ struct sim {
 };
 
 struct linePair {
-                       int start;
-                       int end;
-                       linePair(int i, int j) : start(i), end(j) {}
+                       unsigned long int start;
+                       unsigned long int end;
+                       linePair(unsigned long int i, unsigned long int j) : start(i), end(j) {}
                        linePair(){}
 };
 
+
 /***********************************************************************/
 
 class Chimera {
 
        public:
        
-               Chimera(){};
-               Chimera(string);
-               Chimera(string, string);
-               virtual ~Chimera(){};
-               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 void setTemplateSeqs(vector<Sequence*> t)       {       templateSeqs = t;       }
+               Chimera(){ m = MothurOut::getInstance(); length = 0; unaligned = false; }
+               virtual ~Chimera(){     for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i];  } };
                virtual bool getUnaligned()                             {       return unaligned;                       }
-               virtual void setTemplateFile(string t)  {   templateFileName = t;       }
-               
-               virtual void setCons(string){};
-               virtual void setQuantiles(string){};
-               virtual void doPrep(){};
+               virtual int getLength()                                 {   return length;      }
                virtual vector<Sequence*> readSeqs(string);
-               virtual vector< vector<float> > readQuantiles();
                virtual void setMask(string);
-               virtual void runFilter(Sequence*);
-               virtual void createFilter(vector<Sequence*>);
-               
+               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 void print(ostream&){}; 
+               virtual int print(ostream&, ostream&){  return 0; }
+               
+               #ifdef USE_MPI
+               virtual int print(MPI_File&, MPI_File&){  return 0; }
+               #endif
                
                
        protected:
                
                vector<Sequence*> templateSeqs;
-               bool filter, correction, svg, unaligned;
-               int processors, window, increment, numWanted, kmerSize, match, misMatch, minSim, minCov, minBS, minSNP, parents, iters;
-               float divR;
-               string seqMask, quanfile, filterString, name, outputDir, templateFileName;
+               bool filter, unaligned; 
+               int length; 
+               string seqMask, filterString, outputDir, templateFileName; 
                Sequence* getSequence(string);  //find sequence from name       
+               MothurOut* m;
 };
 
 /***********************************************************************/