added otu.association command. added calcSpearman, calcKendall and calcPearson functi...

[mothur.git] / weighted.cpp

diff --git a/weighted.cpp b/weighted.cpp
index b158815f90f266e07d64d4efa173fb7c4edaa0a0..d8a4b857ad19d8057ed4eb11a592aa11e6787721 100644 (file)
--- a/weighted.cpp
+++ b/weighted.cpp
@@ -13,15 +13,13 @@
 
 EstOutput Weighted::getValues(Tree* t, int p, string o) {
     try {
-               globaldata = GlobalData::getInstance();
-               
                data.clear(); //clear out old values
                int numGroups;
                vector<double> D;
                processors = p;
                outputDir = o;
                
-               numGroups = globaldata->Groups.size();
+               numGroups = m->getNumGroups();
                
                if (m->control_pressed) { return data; }
                
@@ -31,7 +29,7 @@ EstOutput Weighted::getValues(Tree* t, int p, string o) {
                        for (int l = 0; l < i; l++) {   
                                //initialize weighted scores
                                //WScore[globaldata->Groups[i]+globaldata->Groups[l]] = 0.0;
-                               vector<string> groups; groups.push_back(globaldata->Groups[i]); groups.push_back(globaldata->Groups[l]);
+                               vector<string> groups; groups.push_back((m->getGroups())[i]); groups.push_back((m->getGroups())[l]);
                                namesOfGroupCombos.push_back(groups);
                        }
                }
@@ -141,7 +139,7 @@ EstOutput Weighted::createProcesses(Tree* t, vector< vector<string> > namesOfGro
                                m->gobble(in);
                        }
                        in.close();
-                       remove(s.c_str());
+                       m->mothurRemove(s);
                }
                
                m->mothurOut("DONE."); m->mothurOutEndLine(); m->mothurOutEndLine();
@@ -228,12 +226,19 @@ EstOutput Weighted::driver(Tree* t, vector< vector<string> > namesOfGroupCombos,
                                        u -= (double) t->tree[i].pcount[groupB] / (double) tmap->seqsPerGroup[groupB];
                                }
                                
-                               //if this is not the root then add it
-                               if (rootForGrouping[namesOfGroupCombos[h]].count(i) == 0) {
+                               if (includeRoot) {
                                        if (t->tree[i].getBranchLength() != -1) {
                                                u = abs(u * t->tree[i].getBranchLength());
                                                WScore[(groupA+groupB)] += u; 
                                        }
+                               }else {
+                                       //if this is not the root then add it
+                                       if (rootForGrouping[namesOfGroupCombos[h]].count(i) == 0) {
+                                               if (t->tree[i].getBranchLength() != -1) {
+                                                       u = abs(u * t->tree[i].getBranchLength());
+                                                       WScore[(groupA+groupB)] += u; 
+                                               }
+                                       }
                                }
                        }
                        
@@ -260,7 +265,6 @@ EstOutput Weighted::driver(Tree* t, vector< vector<string> > namesOfGroupCombos,
 /**************************************************************************************************/
 EstOutput Weighted::getValues(Tree* t, string groupA, string groupB) { 
  try {
-               globaldata = GlobalData::getInstance();
                
                data.clear(); //clear out old values
                
@@ -317,12 +321,19 @@ EstOutput Weighted::getValues(Tree* t, string groupA, string groupB) {
                                u -= (double) t->tree[i].pcount[groupB] / (double) tmap->seqsPerGroup[groupB];
                        }
                        
-                       //if this is not the root then add it
-                       if (rootForGrouping[groups].count(i) == 0) {
+                       if (includeRoot) {
                                if (t->tree[i].getBranchLength() != -1) {
                                        u = abs(u * t->tree[i].getBranchLength());
                                        WScore[(groupA+groupB)] += u;
                                }
+                       }else{
+                               //if this is not the root then add it
+                               if (rootForGrouping[groups].count(i) == 0) {
+                                       if (t->tree[i].getBranchLength() != -1) {
+                                               u = abs(u * t->tree[i].getBranchLength());
+                                               WScore[(groupA+groupB)] += u;
+                                       }
+                               }
                        }
                }               
                /********************************************************/
@@ -361,37 +372,43 @@ double Weighted::getLengthToRoot(Tree* t, int v, string groupA, string groupB) {
                while(t->tree[index].getParent() != -1){
 
                        if (m->control_pressed) {  return sum; }
-                               
-                       //am I the root for this grouping? if so I want to stop "early"
-                       //does my sibling have descendants from the users groups? 
+                       
                        int parent = t->tree[index].getParent();
-                       int lc = t->tree[parent].getLChild();
-                       int rc = t->tree[parent].getRChild();
                        
-                       int sib = lc;
-                       if (lc == index) { sib = rc; }
-                                               
-                       map<string, int>::iterator itGroup;
-                       int pcountSize = 0;
-                       itGroup = t->tree[sib].pcount.find(groupA);
-                       if (itGroup != t->tree[sib].pcount.end()) { pcountSize++;  } 
-                       itGroup = t->tree[sib].pcount.find(groupB);
-                       if (itGroup != t->tree[sib].pcount.end()) { pcountSize++;  } 
-                                                       
-                       //if yes, I am not the root so add me
-                       if (pcountSize != 0) {
-                               if (t->tree[index].getBranchLength() != -1) {
-                                       sum += abs(t->tree[index].getBranchLength()) + tempTotal;
-                                       tempTotal = 0.0;
-                               }else {
-                                       sum += tempTotal;
-                                       tempTotal = 0.0;
-                               }
-                               rootForGrouping[grouping].clear();
-                               rootForGrouping[grouping].insert(parent);
-                       }else { //if no, I may be the root so add my br to tempTotal until I am proven innocent
-                               if (t->tree[index].getBranchLength() != -1) {
-                                       tempTotal += abs(t->tree[index].getBranchLength()); 
+                       if (includeRoot) { //add everyone
+                               if(t->tree[index].getBranchLength() != -1){     sum += abs(t->tree[index].getBranchLength());   }
+                       }else {
+                               
+                               //am I the root for this grouping? if so I want to stop "early"
+                               //does my sibling have descendants from the users groups? 
+                               int lc = t->tree[parent].getLChild();
+                               int rc = t->tree[parent].getRChild();
+                               
+                               int sib = lc;
+                               if (lc == index) { sib = rc; }
+                               
+                               map<string, int>::iterator itGroup;
+                               int pcountSize = 0;
+                               itGroup = t->tree[sib].pcount.find(groupA);
+                               if (itGroup != t->tree[sib].pcount.end()) { pcountSize++;  } 
+                               itGroup = t->tree[sib].pcount.find(groupB);
+                               if (itGroup != t->tree[sib].pcount.end()) { pcountSize++;  } 
+                               
+                               //if yes, I am not the root so add me
+                               if (pcountSize != 0) {
+                                       if (t->tree[index].getBranchLength() != -1) {
+                                               sum += abs(t->tree[index].getBranchLength()) + tempTotal;
+                                               tempTotal = 0.0;
+                                       }else {
+                                               sum += tempTotal;
+                                               tempTotal = 0.0;
+                                       }
+                                       rootForGrouping[grouping].clear();
+                                       rootForGrouping[grouping].insert(parent);
+                               }else { //if no, I may be the root so add my br to tempTotal until I am proven innocent
+                                       if (t->tree[index].getBranchLength() != -1) {
+                                               tempTotal += abs(t->tree[index].getBranchLength()); 
+                                       }
                                }
                        }