fixed blast code path problem

[mothur.git] / treegroupscommand.cpp

diff --git a/treegroupscommand.cpp b/treegroupscommand.cpp
index 7791d5ecd913c431114a9de5afb2ca651ec1232c..43e39f52d6447384133c1c566bfa1fcfe9c7179e 100644 (file)
--- a/treegroupscommand.cpp
+++ b/treegroupscommand.cpp
@@ -17,6 +17,7 @@
 #include "sharedthetayc.h"
 #include "sharedthetan.h"
 #include "sharedmorisitahorn.h"
+#include "sharedbraycurtis.h"
 
 
 //**********************************************************************************************************************
@@ -26,8 +27,7 @@ TreeGroupCommand::TreeGroupCommand(){
                globaldata = GlobalData::getInstance();
                format = globaldata->getFormat();
                validCalculator = new ValidCalculators();
-               util = new SharedUtil();
-               
+                       
                int i;
                for (i=0; i<globaldata->Estimators.size(); i++) {
                        if (validCalculator->isValidCalculator("treegroup", globaldata->Estimators[i]) == true) { 
@@ -49,6 +49,8 @@ TreeGroupCommand::TreeGroupCommand(){
                                        treeCalculators.push_back(new ThetaN());
                                }else if (globaldata->Estimators[i] == "morisitahorn") { 
                                        treeCalculators.push_back(new MorHorn());
+                               }else if (globaldata->Estimators[i] == "braycurtis") { 
+                                       treeCalculators.push_back(new BrayCurtis());
                                }
                        }
                }
@@ -71,7 +73,6 @@ TreeGroupCommand::TreeGroupCommand(){
 TreeGroupCommand::~TreeGroupCommand(){
        delete input;
        delete read;
-       delete util;
 }
 
 //**********************************************************************************************************************
@@ -80,28 +81,20 @@ int TreeGroupCommand::execute(){
        try {
                int count = 1;  
                EstOutput data;
-       
+               vector<SharedRAbundVector*> subset;
+               
                //if the users entered no valid calculators don't execute command
                if (treeCalculators.size() == 0) { return 0; }
 
-               if (format == "sharedfile") {
-                       read = new ReadOTUFile(globaldata->inputFileName);      
-                       read->read(&*globaldata); 
+               //you have groups
+               read = new ReadOTUFile(globaldata->inputFileName);      
+               read->read(&*globaldata); 
                        
-                       input = globaldata->ginput;
-                       order = input->getSharedOrderVector();
-               }else {
-                       //you are using a list and a groupfile
-                       read = new ReadOTUFile(globaldata->inputFileName);      
-                       read->read(&*globaldata); 
-               
-                       input = globaldata->ginput;
-                       SharedList = globaldata->gSharedList;
-                       order = SharedList->getSharedOrderVector();
-               }
+               input = globaldata->ginput;
+               lookup = input->getSharedRAbundVectors();
+                               
+               if (lookup.size() < 2) { cout << "You have not provided enough valid groups.  I cannot run the command." << endl; return 0; }
                
-               //set users groups
-               util->setGroups(globaldata->Groups, globaldata->gGroupmap->namesOfGroups, "treegroup");
                numGroups = globaldata->Groups.size();
                groupNames = "";
                for (int i = 0; i < numGroups; i++) { groupNames += globaldata->Groups[i]; }
@@ -117,12 +110,11 @@ int TreeGroupCommand::execute(){
                tmap->makeSim(globaldata->gGroupmap);
                globaldata->gTreemap = tmap;
                        
-               while(order != NULL){
+               while(lookup[0] != NULL){
                
-                       if(globaldata->allLines == 1 || globaldata->lines.count(count) == 1 || globaldata->labels.count(order->getLabel()) == 1){                       
+                       if(globaldata->allLines == 1 || globaldata->lines.count(count) == 1 || globaldata->labels.count(lookup[0]->getLabel()) == 1){                   
                                
-                               cout << order->getLabel() << '\t' << count << endl;
-                               util->getSharedVectors(globaldata->Groups, lookup, order);  //fills group vectors from order vector.
+                               cout << lookup[0]->getLabel() << '\t' << count << endl;
                                
                                //for each calculator                                                                                           
                                for(int i = 0 ; i < treeCalculators.size(); i++) {
@@ -141,13 +133,19 @@ int TreeGroupCommand::execute(){
                                        for (int g = 0; g < numGroups; g++) {   index[g] = g;   }
                
                                        //create a new filename
-                                       outputFile = getRootName(globaldata->inputFileName) + treeCalculators[i]->getName() + "." + order->getLabel() + ".tre";
-                                                       
+                                       outputFile = getRootName(globaldata->inputFileName) + treeCalculators[i]->getName() + "." + lookup[0]->getLabel() + ".tre";
+                                       
+                                                                                               
                                        for (int k = 0; k < lookup.size(); k++) { 
                                                for (int l = k; l < lookup.size(); l++) {
                                                        if (k != l) { //we dont need to similiarity of a groups to itself
                                                                //get estimated similarity between 2 groups
-                                                               data = treeCalculators[i]->getValues(lookup[k], lookup[l]); //saves the calculator outputs
+                                                               
+                                                               subset.clear(); //clear out old pair of sharedrabunds
+                                                               //add new pair of sharedrabunds
+                                                               subset.push_back(lookup[k]); subset.push_back(lookup[l]); 
+                                                               
+                                                               data = treeCalculators[i]->getValues(subset); //saves the calculator outputs
                                                                //save values in similarity matrix
                                                                simMatrix[k][l] = data[0];
                                                                simMatrix[l][k] = data[0];
@@ -159,19 +157,12 @@ int TreeGroupCommand::execute(){
                                        createTree();
                                }
                        }
-               
+                       
+                       //prevent memory leak
+                       for (int i = 0; i < lookup.size(); i++) {       delete lookup[i];       }
+                       
                        //get next line to process
-                       if (format == "sharedfile") {
-                               order = input->getSharedOrderVector();
-                       }else {
-                               //you are using a list and a groupfile
-                               SharedList = input->getSharedListVector(); //get new list vector to process
-                               if (SharedList != NULL) {
-                                       order = SharedList->getSharedOrderVector(); //gets new order vector with group info.
-                               }else {
-                                       break;
-                               }
-                       }
+                       lookup = input->getSharedRAbundVectors();
                        count++;
                }
                
@@ -267,14 +258,21 @@ void TreeGroupCommand::createTree(){
        }
 }
 /***********************************************************/
-void TreeGroupCommand::printSims() {
+void TreeGroupCommand::printSims(ostream& out) {
        try {
-               cout << "simsMatrix" << endl;
+               
+               //output column headers
+               out << '\t';
+               for (int i = 0; i < lookup.size(); i++) {       out << lookup[i]->getGroup() << '\t';           }
+               out << endl;
+               
+               
                for (int m = 0; m < simMatrix.size(); m++)      {
+                       out << lookup[m]->getGroup() << '\t';
                        for (int n = 0; n < simMatrix.size(); n++)      {
-                               cout << simMatrix[m][n] << '\t'; 
+                               out << simMatrix[m][n] << '\t'; 
                        }
-                       cout << endl;
+                       out << endl;
                }
 
        }