X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=treegroupscommand.cpp;h=626659501a531db80f5193bef33e88793414a874;hb=d04f948b1a2a1a2984fc4a45d04403b8c121c5bc;hp=e8f68e7f34c52258e480bd8e6f369a200734df1f;hpb=315e38cf393c82be238da5b32574f225a020d25c;p=mothur.git

diff --git a/treegroupscommand.cpp b/treegroupscommand.cpp
index e8f68e7..6266595 100644
--- a/treegroupscommand.cpp
+++ b/treegroupscommand.cpp
@@ -19,10 +19,58 @@
 #include "sharedmorisitahorn.h"
 #include "sharedbraycurtis.h"
 
-
+//**********************************************************************************************************************
+vector<string> TreeGroupCommand::getValidParameters(){	
+	try {
+		string Array[] =  {"label","calc","groups", "phylip", "column", "name", "precision","cutoff","outputdir","inputdir"};
+		vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
+		return myArray;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "TreeGroupCommand", "getValidParameters");
+		exit(1);
+	}
+}
+//**********************************************************************************************************************
+TreeGroupCommand::TreeGroupCommand(){	
+	try {
+		abort = true;
+		globaldata = GlobalData::getInstance();
+		//initialize outputTypes
+		vector<string> tempOutNames;
+		outputTypes["tree"] = tempOutNames;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "TreeGroupCommand", "TreeGroupCommand");
+		exit(1);
+	}
+}
+//**********************************************************************************************************************
+vector<string> TreeGroupCommand::getRequiredParameters(){	
+	try {
+		vector<string> myArray;
+		return myArray;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "TreeGroupCommand", "getRequiredParameters");
+		exit(1);
+	}
+}
+//**********************************************************************************************************************
+vector<string> TreeGroupCommand::getRequiredFiles(){	
+	try {
+		string Array[] =  {"phylip","column","shared","or"};
+		vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
+		return myArray;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "TreeGroupCommand", "getRequiredFiles");
+		exit(1);
+	}
+}
 //**********************************************************************************************************************
 
-TreeGroupCommand::TreeGroupCommand(string option){
+TreeGroupCommand::TreeGroupCommand(string option)  {
 	try {
 		globaldata = GlobalData::getInstance();
 		abort = false;
@@ -50,6 +98,10 @@ TreeGroupCommand::TreeGroupCommand(string option){
 				if (validParameter.isValidParameter(it->first, myArray, it->second) != true) {  abort = true;  }
 			}
 			
+			//initialize outputTypes
+			vector<string> tempOutNames;
+			outputTypes["tree"] = tempOutNames;
+			
 			//if the user changes the input directory command factory will send this info to us in the output parameter 
 			string inputDir = validParameter.validFile(parameters, "inputdir", false);		
 			if (inputDir == "not found"){	inputDir = "";		}
@@ -58,7 +110,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 				it = parameters.find("phylip");
 				//user has given a template file
 				if(it != parameters.end()){ 
-					path = hasPath(it->second);
+					path = m->hasPath(it->second);
 					//if the user has not given a path then, add inputdir. else leave path alone.
 					if (path == "") {	parameters["phylip"] = inputDir + it->second;		}
 				}
@@ -66,7 +118,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 				it = parameters.find("column");
 				//user has given a template file
 				if(it != parameters.end()){ 
-					path = hasPath(it->second);
+					path = m->hasPath(it->second);
 					//if the user has not given a path then, add inputdir. else leave path alone.
 					if (path == "") {	parameters["column"] = inputDir + it->second;		}
 				}
@@ -74,7 +126,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 				it = parameters.find("name");
 				//user has given a template file
 				if(it != parameters.end()){ 
-					path = hasPath(it->second);
+					path = m->hasPath(it->second);
 					//if the user has not given a path then, add inputdir. else leave path alone.
 					if (path == "") {	parameters["name"] = inputDir + it->second;		}
 				}
@@ -86,12 +138,12 @@ TreeGroupCommand::TreeGroupCommand(string option){
 			phylipfile = validParameter.validFile(parameters, "phylip", true);
 			if (phylipfile == "not open") { abort = true; }
 			else if (phylipfile == "not found") { phylipfile = ""; }	
-			else {  format = "phylip";  globaldata->setPhylipFile(phylipfile);	}
+			else {  globaldata->newRead(); format = "phylip";  globaldata->setPhylipFile(phylipfile);	}
 			
 			columnfile = validParameter.validFile(parameters, "column", true);
 			if (columnfile == "not open") { abort = true; }	
 			else if (columnfile == "not found") { columnfile = ""; }
-			else {  format = "column"; globaldata->setColumnFile(columnfile);	}
+			else {  globaldata->newRead(); format = "column"; globaldata->setColumnFile(columnfile);	}
 			
 			namefile = validParameter.validFile(parameters, "name", true);
 			if (namefile == "not open") { abort = true; }	
@@ -99,11 +151,11 @@ TreeGroupCommand::TreeGroupCommand(string option){
 			else {  globaldata->setNameFile(namefile);	}
 			
 			//error checking on files			
-			if ((globaldata->getSharedFile() == "") && ((phylipfile == "") && (columnfile == "")))	{ mothurOut("You must run the read.otu command or provide a distance file before running the tree.shared command."); mothurOutEndLine(); abort = true; }
-			else if ((phylipfile != "") && (columnfile != "")) { mothurOut("When running the tree.shared command with a distance file you may not use both the column and the phylip parameters."); mothurOutEndLine(); abort = true; }
+			if ((globaldata->getSharedFile() == "") && ((phylipfile == "") && (columnfile == "")))	{ m->mothurOut("You must run the read.otu command or provide a distance file before running the tree.shared command."); m->mothurOutEndLine(); abort = true; }
+			else if ((phylipfile != "") && (columnfile != "")) { m->mothurOut("When running the tree.shared command with a distance file you may not use both the column and the phylip parameters."); m->mothurOutEndLine(); abort = true; }
 			
 			if (columnfile != "") {
-				if (namefile == "") {  mothurOut("You need to provide a namefile if you are going to use the column format."); mothurOutEndLine(); abort = true; }
+				if (namefile == "") {  m->mothurOut("You need to provide a namefile if you are going to use the column format."); m->mothurOutEndLine(); abort = true; }
 			}
 
 			//check for optional parameter and set defaults
@@ -111,7 +163,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 			label = validParameter.validFile(parameters, "label", false);			
 			if (label == "not found") { label = ""; }
 			else { 
-				if(label != "all") {  splitAtDash(label, labels);  allLines = 0;  }
+				if(label != "all") {  m->splitAtDash(label, labels);  allLines = 0;  }
 				else { allLines = 1;  }
 			}
 			
@@ -124,7 +176,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 			groups = validParameter.validFile(parameters, "groups", false);			
 			if (groups == "not found") { groups = ""; }
 			else { 
-				splitAtDash(groups, Groups);
+				m->splitAtDash(groups, Groups);
 				globaldata->Groups = Groups;
 			}
 				
@@ -133,7 +185,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 			else { 
 				 if (calc == "default")  {  calc = "jclass-thetayc";  }
 			}
-			splitAtDash(calc, Estimators);
+			m->splitAtDash(calc, Estimators);
 
 			string temp;
 			temp = validParameter.validFile(parameters, "precision", false);			if (temp == "not found") { temp = "100"; }
@@ -146,7 +198,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 			//if the user changes the output directory command factory will send this info to us in the output parameter 
 			outputDir = validParameter.validFile(parameters, "outputdir", false);		if (outputDir == "not found"){	
 				outputDir = "";	
-				outputDir += hasPath(globaldata->inputFileName); //if user entered a file with a path then preserve it	
+				outputDir += m->hasPath(globaldata->inputFileName); //if user entered a file with a path then preserve it	
 			}
 
 				
@@ -187,7 +239,7 @@ TreeGroupCommand::TreeGroupCommand(string option){
 
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "TreeGroupCommand");
+		m->errorOut(e, "TreeGroupCommand", "TreeGroupCommand");
 		exit(1);
 	}
 }
@@ -196,25 +248,25 @@ TreeGroupCommand::TreeGroupCommand(string option){
 
 void TreeGroupCommand::help(){
 	try {
-		mothurOut("The tree.shared command creates a .tre to represent the similiarity between groups or sequences.\n");
-		mothurOut("The tree.shared command can only be executed after a successful read.otu command or by providing a distance file.\n");
-		mothurOut("The tree.shared command parameters are groups, calc, phylip, column, name, cutoff, precision and label.\n");
-		mothurOut("The groups parameter allows you to specify which of the groups in your groupfile you would like included used.\n");
-		mothurOut("The group names are separated by dashes. The label allow you to select what distance levels you would like trees created for, and are also separated by dashes.\n");
-		mothurOut("The phylip or column parameter are required if you do not run the read.otu command first, and only one may be used.  If you use a column file the name filename is required. \n");
-		mothurOut("If you do not provide a cutoff value 10.00 is assumed. If you do not provide a precision value then 100 is assumed.\n");
-		mothurOut("The tree.shared command should be in the following format: tree.shared(groups=yourGroups, calc=yourCalcs, label=yourLabels).\n");
-		mothurOut("Example tree.shared(groups=A-B-C, calc=jabund-sorabund).\n");
-		mothurOut("The default value for groups is all the groups in your groupfile.\n");
-		mothurOut("The default value for calc is jclass-thetayc.\n");
-		mothurOut("The tree.shared command outputs a .tre file for each calculator you specify at each distance you choose.\n");
+		m->mothurOut("The tree.shared command creates a .tre to represent the similiarity between groups or sequences.\n");
+		m->mothurOut("The tree.shared command can only be executed after a successful read.otu command or by providing a distance file.\n");
+		m->mothurOut("The tree.shared command parameters are groups, calc, phylip, column, name, cutoff, precision and label.\n");
+		m->mothurOut("The groups parameter allows you to specify which of the groups in your groupfile you would like included used.\n");
+		m->mothurOut("The group names are separated by dashes. The label allow you to select what distance levels you would like trees created for, and are also separated by dashes.\n");
+		m->mothurOut("The phylip or column parameter are required if you do not run the read.otu command first, and only one may be used.  If you use a column file the name filename is required. \n");
+		m->mothurOut("If you do not provide a cutoff value 10.00 is assumed. If you do not provide a precision value then 100 is assumed.\n");
+		m->mothurOut("The tree.shared command should be in the following format: tree.shared(groups=yourGroups, calc=yourCalcs, label=yourLabels).\n");
+		m->mothurOut("Example tree.shared(groups=A-B-C, calc=jabund-sorabund).\n");
+		m->mothurOut("The default value for groups is all the groups in your groupfile.\n");
+		m->mothurOut("The default value for calc is jclass-thetayc.\n");
+		m->mothurOut("The tree.shared command outputs a .tre file for each calculator you specify at each distance you choose.\n");
 		validCalculator->printCalc("treegroup", cout);
-		mothurOut("Or the tree.shared command can be in the following format: tree.shared(phylip=yourPhylipFile).\n");
-		mothurOut("Example tree.shared(phylip=abrecovery.dist).\n");
-		mothurOut("Note: No spaces between parameter labels (i.e. groups), '=' and parameters (i.e.yourGroups).\n\n");
+		m->mothurOut("Or the tree.shared command can be in the following format: tree.shared(phylip=yourPhylipFile).\n");
+		m->mothurOut("Example tree.shared(phylip=abrecovery.dist).\n");
+		m->mothurOut("Note: No spaces between parameter labels (i.e. groups), '=' and parameters (i.e.yourGroups).\n\n");
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "help");
+		m->errorOut(e, "TreeGroupCommand", "help");
 		exit(1);
 	}
 }
@@ -223,6 +275,7 @@ void TreeGroupCommand::help(){
 //**********************************************************************************************************************
 
 TreeGroupCommand::~TreeGroupCommand(){
+	globaldata->Groups.clear();  
 	if (abort == false) {
 		
 		if (format == "sharedfile") { delete read;  delete input; globaldata->ginput = NULL; }
@@ -242,8 +295,9 @@ int TreeGroupCommand::execute(){
 		
 		if (format == "sharedfile") {
 			//if the users entered no valid calculators don't execute command
-			if (treeCalculators.size() == 0) { mothurOut("You have given no valid calculators."); mothurOutEndLine(); return 0; }
-
+			if (treeCalculators.size() == 0) { m->mothurOut("You have given no valid calculators."); m->mothurOutEndLine(); return 0; }
+			
+			if (globaldata->gGroupmap != NULL) {  delete globaldata->gGroupmap;   globaldata->gGroupmap = NULL;  }
 			//you have groups
 			read = new ReadOTUFile(globaldata->inputFileName);	
 			read->read(&*globaldata); 
@@ -252,13 +306,28 @@ int TreeGroupCommand::execute(){
 			lookup = input->getSharedRAbundVectors();
 			lastLabel = lookup[0]->getLabel();
 			
-			if (lookup.size() < 2) { mothurOut("You have not provided enough valid groups.  I cannot run the command."); mothurOutEndLine(); return 0; }
+			if (lookup.size() < 2) { m->mothurOut("You have not provided enough valid groups.  I cannot run the command."); m->mothurOutEndLine(); return 0; }
 			
 			//used in tree constructor 
 			globaldata->runParse = false;
 			
+			//create treemap class from groupmap for tree class to use
+			tmap = new TreeMap();
+			tmap->makeSim(globaldata->gGroupmap);
+			globaldata->gTreemap = tmap;
+			
+			//clear globaldatas old tree names if any
+			globaldata->Treenames.clear();
+			
+			//fills globaldatas tree names
+			globaldata->Treenames = globaldata->Groups;
+		
+			if (m->control_pressed) { return 0; }
+			
 			//create tree file
 			makeSimsShared();
+			
+			if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) {	remove(outputNames[i].c_str());  } return 0; }
 		}else{
 			//read in dist file
 			filename = globaldata->inputFileName;
@@ -282,6 +351,9 @@ int TreeGroupCommand::execute(){
 
 			//make treemap
 			tmap = new TreeMap();
+			
+			if (m->control_pressed) { return 0; }
+			
 			tmap->makeSim(list);
 			globaldata->gTreemap = tmap;
 			
@@ -296,28 +368,42 @@ int TreeGroupCommand::execute(){
 			//used in tree constructor 
 			globaldata->runParse = false;
 			
+			if (m->control_pressed) { return 0; }
+			
 			makeSimsDist();
+			
+			if (m->control_pressed) { return 0; }
 
 			//create a new filename
-			outputFile = outputDir + getRootName(getSimpleName(globaldata->inputFileName)) + "tre";	
+			outputFile = outputDir + m->getRootName(m->getSimpleName(globaldata->inputFileName)) + "tre";	
+			outputNames.push_back(outputFile); outputTypes["tree"].push_back(outputFile);
 				
 			createTree();
-			mothurOut("Tree complete. "); mothurOutEndLine();
+			
+			if (m->control_pressed) { return 0; }
+
+			m->mothurOut("Tree complete. "); m->mothurOutEndLine();
+			
 		}
 				
 		//reset groups parameter
 		globaldata->Groups.clear();  
+		
+		m->mothurOutEndLine();
+		m->mothurOut("Output File Names: "); m->mothurOutEndLine();
+		for (int i = 0; i < outputNames.size(); i++) {	m->mothurOut(outputNames[i]); m->mothurOutEndLine();	}
+		m->mothurOutEndLine();
 
 		return 0;
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "execute");
+		m->errorOut(e, "TreeGroupCommand", "execute");
 		exit(1);
 	}
 }
 //**********************************************************************************************************************
 
-void TreeGroupCommand::createTree(){
+int TreeGroupCommand::createTree(){
 	try {
 		//create tree
 		t = new Tree();
@@ -326,7 +412,9 @@ void TreeGroupCommand::createTree(){
 		//there are numGroups - 1 merges to do
 		for (int i = 0; i < (numGroups - 1); i++) {
 			float largest = -1000.0;
-
+			
+			if (m->control_pressed) { delete t; return 1; }
+			
 			int row, column;
 			//find largest value in sims matrix by searching lower triangle
 			for (int j = 1; j < simMatrix.size(); j++) {
@@ -380,15 +468,21 @@ void TreeGroupCommand::createTree(){
 		//assemble tree
 		t->assembleTree();
 		
+		if (m->control_pressed) { delete t; return 1; }
+		
 		//print newick file
 		t->createNewickFile(outputFile);
 		
 		//delete tree
 		delete t;
+		
+		if (m->control_pressed) { remove(outputFile.c_str()); outputNames.pop_back(); return 1; }
+		
+		return 0;
 	
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "createTree");
+		m->errorOut(e, "TreeGroupCommand", "createTree");
 		exit(1);
 	}
 }
@@ -412,12 +506,12 @@ void TreeGroupCommand::printSims(ostream& out) {
 
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "printSims");
+		m->errorOut(e, "TreeGroupCommand", "printSims");
 		exit(1);
 	}
 }
 /***********************************************************/
-void TreeGroupCommand::makeSimsDist() {
+int TreeGroupCommand::makeSimsDist() {
 	try {
 		numGroups = list->size();
 		
@@ -428,9 +522,9 @@ void TreeGroupCommand::makeSimsDist() {
 		//initialize simMatrix
 		simMatrix.clear();
 		simMatrix.resize(numGroups);
-		for (int m = 0; m < simMatrix.size(); m++)	{
+		for (int k = 0; k < simMatrix.size(); k++)	{
 			for (int j = 0; j < simMatrix.size(); j++)	{
-				simMatrix[m].push_back(0.0);
+				simMatrix[k].push_back(0.0);
 			}
 		}
 		
@@ -439,53 +533,45 @@ void TreeGroupCommand::makeSimsDist() {
 		for(MatData currentCell = matrix->begin(); currentCell != matrix->end(); currentCell++){
 			//similairity = -(distance-1)
 			simMatrix[currentCell->row][currentCell->column] = -(currentCell->dist -1.0);	
-			simMatrix[currentCell->column][currentCell->row] = -(currentCell->dist -1.0);				
+			simMatrix[currentCell->column][currentCell->row] = -(currentCell->dist -1.0);	
+			
+			if (m->control_pressed) { return 1; }
+			
 		}
 
-
+		return 0;
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "makeSimsDist");
+		m->errorOut(e, "TreeGroupCommand", "makeSimsDist");
 		exit(1);
 	}
 }
 
 /***********************************************************/
-void TreeGroupCommand::makeSimsShared() {
+int TreeGroupCommand::makeSimsShared() {
 	try {
-	
-		//clear globaldatas old tree names if any
-		globaldata->Treenames.clear();
-		
-		//fills globaldatas tree names
-		globaldata->Treenames = globaldata->Groups;
-		
-		//create treemap class from groupmap for tree class to use
-		tmap = new TreeMap();
-		tmap->makeSim(globaldata->gGroupmap);
-		globaldata->gTreemap = tmap;
-		
 		set<string> processedLabels;
 		set<string> userLabels = labels;
 		
 		//as long as you are not at the end of the file or done wih the lines you want
 		while((lookup[0] != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
+			if (m->control_pressed) { for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } for(int i = 0 ; i < treeCalculators.size(); i++) {  delete treeCalculators[i]; } return 1; }
 		
 			if(allLines == 1 || labels.count(lookup[0]->getLabel()) == 1){			
-				mothurOut(lookup[0]->getLabel()); mothurOutEndLine();
+				m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
 				process(lookup);
 				
 				processedLabels.insert(lookup[0]->getLabel());
 				userLabels.erase(lookup[0]->getLabel());
 			}
 			
-			if ((anyLabelsToProcess(lookup[0]->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
+			if ((m->anyLabelsToProcess(lookup[0]->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
 				string saveLabel = lookup[0]->getLabel();
 			
 				for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } 
 				lookup = input->getSharedRAbundVectors(lastLabel);
 
-				mothurOut(lookup[0]->getLabel()); mothurOutEndLine();
+				m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
 				process(lookup);
 					
 				processedLabels.insert(lookup[0]->getLabel());
@@ -502,16 +588,18 @@ void TreeGroupCommand::makeSimsShared() {
 			lookup = input->getSharedRAbundVectors();
 		}
 		
+		if (m->control_pressed) { for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } for(int i = 0 ; i < treeCalculators.size(); i++) {  delete treeCalculators[i]; } return 1; }
+
 		//output error messages about any remaining user labels
 		set<string>::iterator it;
 		bool needToRun = false;
 		for (it = userLabels.begin(); it != userLabels.end(); it++) {  
-			mothurOut("Your file does not include the label " + *it); 
+			m->mothurOut("Your file does not include the label " + *it); 
 			if (processedLabels.count(lastLabel) != 1) {
-				mothurOut(". I will use " + lastLabel + "."); mothurOutEndLine();
+				m->mothurOut(". I will use " + lastLabel + "."); m->mothurOutEndLine();
 				needToRun = true;
 			}else {
-				mothurOut(". Please refer to " + lastLabel + "."); mothurOutEndLine();
+				m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine();
 			}
 		}
 		
@@ -520,21 +608,23 @@ void TreeGroupCommand::makeSimsShared() {
 			for (int i = 0; i < lookup.size(); i++) {  if (lookup[i] != NULL) {		delete lookup[i]; }		} 
 			lookup = input->getSharedRAbundVectors(lastLabel);
 
-			mothurOut(lookup[0]->getLabel()); mothurOutEndLine();
+			m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
 			process(lookup);
 			for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } 	
 		}
 		
 		for(int i = 0 ; i < treeCalculators.size(); i++) {  delete treeCalculators[i]; }
+		
+		return 0;
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "makeSimsShared");
+		m->errorOut(e, "TreeGroupCommand", "makeSimsShared");
 		exit(1);
 	}
 }
 
 /***********************************************************/
-void TreeGroupCommand::process(vector<SharedRAbundVector*> thisLookup) {
+int TreeGroupCommand::process(vector<SharedRAbundVector*> thisLookup) {
 	try{
 				EstOutput data;
 				vector<SharedRAbundVector*> subset;
@@ -545,9 +635,9 @@ void TreeGroupCommand::process(vector<SharedRAbundVector*> thisLookup) {
 					//initialize simMatrix
 					simMatrix.clear();
 					simMatrix.resize(numGroups);
-					for (int m = 0; m < simMatrix.size(); m++)	{
+					for (int k = 0; k < simMatrix.size(); k++)	{
 						for (int j = 0; j < simMatrix.size(); j++)	{
-							simMatrix[m].push_back(0.0);
+							simMatrix[k].push_back(0.0);
 						}
 					}
 		
@@ -556,7 +646,8 @@ void TreeGroupCommand::process(vector<SharedRAbundVector*> thisLookup) {
 					for (int g = 0; g < numGroups; g++) {	index[g] = g;	}
 		
 					//create a new filename
-					outputFile = outputDir + getRootName(getSimpleName(globaldata->inputFileName)) + treeCalculators[i]->getName() + "." + thisLookup[0]->getLabel() + ".tre";				
+					outputFile = outputDir + m->getRootName(m->getSimpleName(globaldata->inputFileName)) + treeCalculators[i]->getName() + "." + thisLookup[0]->getLabel() + ".tre";				
+					outputNames.push_back(outputFile); outputTypes["tree"].push_back(outputFile); 
 												
 					for (int k = 0; k < thisLookup.size(); k++) { 
 						for (int l = k; l < thisLookup.size(); l++) {
@@ -568,20 +659,43 @@ void TreeGroupCommand::process(vector<SharedRAbundVector*> thisLookup) {
 								subset.push_back(thisLookup[k]); subset.push_back(thisLookup[l]); 
 								
 								data = treeCalculators[i]->getValues(subset); //saves the calculator outputs
+						//cout << thisLookup[k]->getGroup() << '\t' << thisLookup[l]->getGroup() << '\t' << (1.0 - data[0]) << endl;
+								if (m->control_pressed) { return 1; }
+								
 								//save values in similarity matrix
 								simMatrix[k][l] = data[0];
 								simMatrix[l][k] = data[0];
 							}
 						}
 					}
-				
+					
+					//createdistance file from simMatrix
+					/*string o = outputDir + m->getRootName(m->getSimpleName(globaldata->inputFileName)) + treeCalculators[i]->getName() + "." + thisLookup[0]->getLabel() + ".dist";
+					ofstream outDist;
+					m->openOutputFile(o, outDist);
+					outDist << simMatrix.size() << endl;
+					for (int k = 0; k < simMatrix.size(); k++) {
+						outDist << thisLookup[k]->getGroup() << '\t';
+						for (int l = 0; l < k; l++) {
+							outDist << (1.0-simMatrix[k][l]) << '\t';
+						}
+						outDist << endl;
+					}
+					outDist.close();*/
+
+					
+					if (m->control_pressed) { return 1; }
 					//creates tree from similarity matrix and write out file
 					createTree();
+					
+					if (m->control_pressed) { return 1; }
 				}
+				
+				return 0;
 
 	}
 	catch(exception& e) {
-		errorOut(e, "TreeGroupCommand", "process");
+		m->errorOut(e, "TreeGroupCommand", "process");
 		exit(1);
 	}
 }