X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=matrixoutputcommand.cpp;h=4ea8f021d3046a3f25be73b201869a73b98898ce;hb=e150b0b0664caec517485ee6d69dcdade6dcae77;hp=3ecf6df36e5ea33266d409fecee2620aec7a2d9f;hpb=a8f5a612bba54ceb74e17efc027d3a7f5aa93c9a;p=mothur.git

diff --git a/matrixoutputcommand.cpp b/matrixoutputcommand.cpp
index 3ecf6df..4ea8f02 100644
--- a/matrixoutputcommand.cpp
+++ b/matrixoutputcommand.cpp
@@ -8,6 +8,10 @@
  */
 
 #include "matrixoutputcommand.h"
+#include "sharedsobscollectsummary.h"
+#include "sharedchao1.h"
+#include "sharedace.h"
+#include "sharednseqs.h"
 #include "sharedjabund.h"
 #include "sharedsorabund.h"
 #include "sharedjclass.h"
@@ -16,180 +20,424 @@
 #include "sharedsorest.h"
 #include "sharedthetayc.h"
 #include "sharedthetan.h"
+#include "sharedkstest.h"
+#include "whittaker.h"
+#include "sharedochiai.h"
+#include "sharedanderbergs.h"
+#include "sharedkulczynski.h"
+#include "sharedkulczynskicody.h"
+#include "sharedlennon.h"
 #include "sharedmorisitahorn.h"
 #include "sharedbraycurtis.h"
+#include "sharedjackknife.h"
+#include "whittaker.h"
+#include "odum.h"
+#include "canberra.h"
+#include "structeuclidean.h"
+#include "structchord.h"
+#include "hellinger.h"
+#include "manhattan.h"
+#include "structpearson.h"
+#include "soergel.h"
+#include "spearman.h"
+#include "structkulczynski.h"
+#include "structchi2.h"
+#include "speciesprofile.h"
+#include "hamming.h"
+#include "gower.h"
+#include "memchi2.h"
+#include "memchord.h"
+#include "memeuclidean.h"
+#include "mempearson.h"
 
-
+//**********************************************************************************************************************
+vector<string> MatrixOutputCommand::setParameters(){	
+	try {
+		CommandParameter pshared("shared", "InputTypes", "", "", "none", "none", "none",false,true); parameters.push_back(pshared);
+		CommandParameter plabel("label", "String", "", "", "", "", "",false,false); parameters.push_back(plabel);
+		CommandParameter pgroups("groups", "String", "", "", "", "", "",false,false); parameters.push_back(pgroups);
+		CommandParameter pcalc("calc", "Multiple", "sharedsobs-sharedchao-sharedace-jabund-sorabund-jclass-sorclass-jest-sorest-thetayc-thetan-kstest-sharednseqs-ochiai-anderberg-kulczynski-kulczynskicody-lennon-morisitahorn-braycurtis-whittaker-odum-canberra-structeuclidean-structchord-hellinger-manhattan-structpearson-soergel-spearman-structkulczynski-speciesprofile-hamming-structchi2-gower-memchi2-memchord-memeuclidean-mempearson", "jclass-thetayc", "", "", "",true,false); parameters.push_back(pcalc);
+		CommandParameter poutput("output", "Multiple", "lt-square", "lt", "", "", "",false,false); parameters.push_back(poutput);
+		CommandParameter pinputdir("inputdir", "String", "", "", "", "", "",false,false); parameters.push_back(pinputdir);
+		CommandParameter poutputdir("outputdir", "String", "", "", "", "", "",false,false); parameters.push_back(poutputdir);
+		
+		vector<string> myArray;
+		for (int i = 0; i < parameters.size(); i++) {	myArray.push_back(parameters[i].name);		}
+		return myArray;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "MatrixOutputCommand", "setParameters");
+		exit(1);
+	}
+}
+//**********************************************************************************************************************
+string MatrixOutputCommand::getHelpString(){	
+	try {
+		string helpString = "";
+		ValidCalculators validCalculator;
+		helpString += "The dist.shared command parameters are shared, groups, calc, output and label.  shared is a required, unless you have a valid current file.\n";
+		helpString += "The groups parameter allows you to specify which of the groups in your groupfile you would like included used.\n";
+		helpString += "The group names are separated by dashes. The label parameter allows you to select what distance levels you would like distance matrices created for, and is also separated by dashes.\n";
+		helpString += "The dist.shared command should be in the following format: dist.shared(groups=yourGroups, calc=yourCalcs, label=yourLabels).\n";
+		helpString += "The output parameter allows you to specify format of your distance matrix. Options are lt, and square. The default is lt.\n";
+		helpString += "Example dist.shared(groups=A-B-C, calc=jabund-sorabund).\n";
+		helpString += "The default value for groups is all the groups in your groupfile.\n";
+		helpString += "The default value for calc is jclass and thetayc.\n";
+		helpString += validCalculator.printCalc("matrix");
+		helpString += "The dist.shared command outputs a .dist file for each calculator you specify at each distance you choose.\n";
+		helpString += "Note: No spaces between parameter labels (i.e. groups), '=' and parameters (i.e.yourGroups).\n";
+		return helpString;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "MatrixOutputCommand", "getHelpString");
+		exit(1);
+	}
+}
+//**********************************************************************************************************************
+MatrixOutputCommand::MatrixOutputCommand(){	
+	try {
+		abort = true; calledHelp = true; 
+		setParameters();
+		vector<string> tempOutNames;
+		outputTypes["phylip"] = tempOutNames;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "MatrixOutputCommand", "MatrixOutputCommand");
+		exit(1);
+	}
+}
 //**********************************************************************************************************************
 
-MatrixOutputCommand::MatrixOutputCommand(){
+MatrixOutputCommand::MatrixOutputCommand(string option)  {
 	try {
-		globaldata = GlobalData::getInstance();
-		validCalculator = new ValidCalculators();
+		abort = false; calledHelp = false;   
+		allLines = 1;
+				
+		//allow user to run help
+		if(option == "help") {  help(); abort = true; calledHelp = true; }
+		else if(option == "citation") { citation(); abort = true; calledHelp = true;}
+		
+		else {
+			vector<string> myArray = setParameters();
+			
+			OptionParser parser(option);
+			map<string,string> parameters  = parser.getParameters();
+			map<string,string>::iterator it;
+			
+			ValidParameters validParameter;
+		
+			//check to make sure all parameters are valid for command
+			for (it = parameters.begin(); it != parameters.end(); it++) { 
+				if (validParameter.isValidParameter(it->first, myArray, it->second) != true) {  abort = true;  }
+			}
+			
+			//initialize outputTypes
+			vector<string> tempOutNames;
+			outputTypes["phylip"] = 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 = "";		}
+			else {
+				string path;
+				it = parameters.find("shared");
+				//user has given a template file
+				if(it != parameters.end()){ 
+					path = m->hasPath(it->second);
+					//if the user has not given a path then, add inputdir. else leave path alone.
+					if (path == "") {	parameters["shared"] = inputDir + it->second;		}
+				}
+			}
+			
+			sharedfile = validParameter.validFile(parameters, "shared", true);
+			if (sharedfile == "not found") { 			
+				//if there is a current shared file, use it
+				sharedfile = m->getSharedFile(); 
+				if (sharedfile != "") { m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); }
+				else { 	m->mothurOut("You have no current sharedfile and the shared parameter is required."); m->mothurOutEndLine(); abort = true; }
+			}else if (sharedfile == "not open") { sharedfile = ""; abort = true; }
+			
+			//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 += m->hasPath(sharedfile); //if user entered a file with a path then preserve it	
+			}
+			
+			//check for optional parameter and set defaults
+			// ...at some point should added some additional type checking...
+			label = validParameter.validFile(parameters, "label", false);			
+			if (label == "not found") { label = ""; }
+			else { 
+				if(label != "all") {  m->splitAtDash(label, labels);  allLines = 0;  }
+				else { allLines = 1;  }
+			}
+			
+			output = validParameter.validFile(parameters, "output", false);		if(output == "not found"){	output = "lt"; }
+			if ((output != "lt") && (output != "square")) { m->mothurOut(output + " is not a valid output form. Options are lt and square. I will use lt."); m->mothurOutEndLine(); output = "lt"; }
+			
+			groups = validParameter.validFile(parameters, "groups", false);			
+			if (groups == "not found") { groups = ""; }
+			else { 
+				m->splitAtDash(groups, Groups);
+				m->Groups = Groups;
+			}
+				
+			calc = validParameter.validFile(parameters, "calc", false);			
+			if (calc == "not found") { calc = "jclass-thetayc";  }
+			else { 
+				 if (calc == "default")  {  calc = "jclass-thetayc";  }
+			}
+			m->splitAtDash(calc, Estimators);
+
+			if (abort == false) {
 			
-		int i;
-		for (i=0; i<globaldata->Estimators.size(); i++) {
-			if (validCalculator->isValidCalculator("matrix", globaldata->Estimators[i]) == true) { 
-				if (globaldata->Estimators[i] == "jabund") { 	
-					matrixCalculators.push_back(new JAbund());
-				}else if (globaldata->Estimators[i] == "sorabund") { 
-					matrixCalculators.push_back(new SorAbund());
-				}else if (globaldata->Estimators[i] == "jclass") { 
-					matrixCalculators.push_back(new Jclass());
-				}else if (globaldata->Estimators[i] == "sorclass") { 
-					matrixCalculators.push_back(new SorClass());
-				}else if (globaldata->Estimators[i] == "jest") { 
-					matrixCalculators.push_back(new Jest());
-				}else if (globaldata->Estimators[i] == "sorest") { 
-					matrixCalculators.push_back(new SorEst());
-				}else if (globaldata->Estimators[i] == "thetayc") { 
-					matrixCalculators.push_back(new ThetaYC());
-				}else if (globaldata->Estimators[i] == "thetan") { 
-					matrixCalculators.push_back(new ThetaN());
-				}else if (globaldata->Estimators[i] == "morisitahorn") { 
-					matrixCalculators.push_back(new MorHorn());
-				}else if (globaldata->Estimators[i] == "braycurtis") { 
-					matrixCalculators.push_back(new BrayCurtis());
+				ValidCalculators validCalculator;
+				
+				int i;
+				for (i=0; i<Estimators.size(); i++) {
+					if (validCalculator.isValidCalculator("matrix", Estimators[i]) == true) { 
+						if (Estimators[i] == "sharedsobs") { 
+							matrixCalculators.push_back(new SharedSobsCS());
+						}else if (Estimators[i] == "sharedchao") { 
+							matrixCalculators.push_back(new SharedChao1());
+						}else if (Estimators[i] == "sharedace") { 
+							matrixCalculators.push_back(new SharedAce());
+						}else if (Estimators[i] == "jabund") { 	
+							matrixCalculators.push_back(new JAbund());
+						}else if (Estimators[i] == "sorabund") { 
+							matrixCalculators.push_back(new SorAbund());
+						}else if (Estimators[i] == "jclass") { 
+							matrixCalculators.push_back(new Jclass());
+						}else if (Estimators[i] == "sorclass") { 
+							matrixCalculators.push_back(new SorClass());
+						}else if (Estimators[i] == "jest") { 
+							matrixCalculators.push_back(new Jest());
+						}else if (Estimators[i] == "sorest") { 
+							matrixCalculators.push_back(new SorEst());
+						}else if (Estimators[i] == "thetayc") { 
+							matrixCalculators.push_back(new ThetaYC());
+						}else if (Estimators[i] == "thetan") { 
+							matrixCalculators.push_back(new ThetaN());
+						}else if (Estimators[i] == "kstest") { 
+							matrixCalculators.push_back(new KSTest());
+						}else if (Estimators[i] == "sharednseqs") { 
+							matrixCalculators.push_back(new SharedNSeqs());
+						}else if (Estimators[i] == "ochiai") { 
+							matrixCalculators.push_back(new Ochiai());
+						}else if (Estimators[i] == "anderberg") { 
+							matrixCalculators.push_back(new Anderberg());
+						}else if (Estimators[i] == "kulczynski") { 
+							matrixCalculators.push_back(new Kulczynski());
+						}else if (Estimators[i] == "kulczynskicody") { 
+							matrixCalculators.push_back(new KulczynskiCody());
+						}else if (Estimators[i] == "lennon") { 
+							matrixCalculators.push_back(new Lennon());
+						}else if (Estimators[i] == "morisitahorn") { 
+							matrixCalculators.push_back(new MorHorn());
+						}else if (Estimators[i] == "braycurtis") { 
+							matrixCalculators.push_back(new BrayCurtis());
+						}else if (Estimators[i] == "whittaker") { 
+							matrixCalculators.push_back(new Whittaker());
+						}else if (Estimators[i] == "odum") { 
+							matrixCalculators.push_back(new Odum());
+						}else if (Estimators[i] == "canberra") { 
+							matrixCalculators.push_back(new Canberra());
+						}else if (Estimators[i] == "structeuclidean") { 
+							matrixCalculators.push_back(new StructEuclidean());
+						}else if (Estimators[i] == "structchord") { 
+							matrixCalculators.push_back(new StructChord());
+						}else if (Estimators[i] == "hellinger") { 
+							matrixCalculators.push_back(new Hellinger());
+						}else if (Estimators[i] == "manhattan") { 
+							matrixCalculators.push_back(new Manhattan());
+						}else if (Estimators[i] == "structpearson") { 
+							matrixCalculators.push_back(new StructPearson());
+						}else if (Estimators[i] == "soergel") { 
+							matrixCalculators.push_back(new Soergel());
+						}else if (Estimators[i] == "spearman") { 
+							matrixCalculators.push_back(new Spearman());
+						}else if (Estimators[i] == "structkulczynski") { 
+							matrixCalculators.push_back(new StructKulczynski());
+						}else if (Estimators[i] == "speciesprofile") { 
+							matrixCalculators.push_back(new SpeciesProfile());
+						}else if (Estimators[i] == "hamming") { 
+							matrixCalculators.push_back(new Hamming());
+						}else if (Estimators[i] == "structchi2") { 
+							matrixCalculators.push_back(new StructChi2());
+						}else if (Estimators[i] == "gower") { 
+							matrixCalculators.push_back(new Gower());
+						}else if (Estimators[i] == "memchi2") { 
+							matrixCalculators.push_back(new MemChi2());
+						}else if (Estimators[i] == "memchord") { 
+							matrixCalculators.push_back(new MemChord());
+						}else if (Estimators[i] == "memeuclidean") { 
+							matrixCalculators.push_back(new MemEuclidean());
+						}else if (Estimators[i] == "mempearson") { 
+							matrixCalculators.push_back(new MemPearson());
+						}
+					}
 				}
+				
 			}
 		}
 		
-		//reset calc for next command
-		globaldata->setCalc("");
-
 	}
 	catch(exception& e) {
-		cout << "Standard Error: " << e.what() << " has occurred in the MatrixOutputCommand class Function MatrixOutputCommand. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+		m->errorOut(e, "MatrixOutputCommand", "MatrixOutputCommand");
 		exit(1);
 	}
-	catch(...) {
-		cout << "An unknown error has occurred in the MatrixOutputCommand class function MatrixOutputCommand. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-		exit(1);
-	}	
 }
+
 //**********************************************************************************************************************
 
-MatrixOutputCommand::~MatrixOutputCommand(){
-	delete input;
-	delete read;
-}
+MatrixOutputCommand::~MatrixOutputCommand(){}
 
 //**********************************************************************************************************************
 
 int MatrixOutputCommand::execute(){
 	try {
-		int count = 1;	
-				
+		
+		if (abort == true) { if (calledHelp) { return 0; }  return 2;	}
+			
 		//if the users entered no valid calculators don't execute command
-		if (matrixCalculators.size() == 0) { cout << "No valid calculators." << endl; return 0; }
-
-		//you have groups
-		read = new ReadOTUFile(globaldata->inputFileName);	
-		read->read(&*globaldata); 
+		if (matrixCalculators.size() == 0) { m->mothurOut("No valid calculators."); m->mothurOutEndLine();  return 0; }
 			
-		input = globaldata->ginput;
+		input = new InputData(sharedfile, "sharedfile");
 		lookup = input->getSharedRAbundVectors();
-		vector<SharedRAbundVector*> lastLookup = lookup;
+		string lastLabel = lookup[0]->getLabel();
 		
 		//if the users enters label "0.06" and there is no "0.06" in their file use the next lowest label.
 		set<string> processedLabels;
-		set<string> userLabels = globaldata->labels;
-				
-		if (lookup.size() < 2) { cout << "You have not provided enough valid groups.  I cannot run the command." << endl; return 0;}
+		set<string> userLabels = labels;
+					
+		if (lookup.size() < 2) { m->mothurOut("You have not provided enough valid groups.  I cannot run the command."); m->mothurOutEndLine(); delete input; for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } return 0;}
+		
+		numGroups = lookup.size();
 		
-		numGroups = globaldata->Groups.size();
+		if (m->control_pressed) { delete input; for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } m->Groups.clear(); return 0;  }
 				
 		//as long as you are not at the end of the file or done wih the lines you want
-		while((lookup[0] != NULL) && ((globaldata->allLines == 1) || (userLabels.size() != 0))) {
+		while((lookup[0] != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
+		
+			if (m->control_pressed) { outputTypes.clear(); delete input; for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } for (int i = 0; i < outputNames.size(); i++) {	remove(outputNames[i].c_str()); } m->Groups.clear(); return 0;  }
 		
-			if(globaldata->allLines == 1 || globaldata->lines.count(count) == 1 || globaldata->labels.count(lookup[0]->getLabel()) == 1){			
-				cout << lookup[0]->getLabel() << '\t' << count << endl;
+			if(allLines == 1 || labels.count(lookup[0]->getLabel()) == 1){			
+				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(lastLookup[0]->getLabel()) != 1)) {
-				cout << lastLookup[0]->getLabel() << '\t' << count << endl;
-				process(lastLookup);
+			if ((m->anyLabelsToProcess(lookup[0]->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
+				string saveLabel = lookup[0]->getLabel();
 				
-				processedLabels.insert(lastLookup[0]->getLabel());
-				userLabels.erase(lastLookup[0]->getLabel());
+				for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } 
+				lookup = input->getSharedRAbundVectors(lastLabel);
+
+				m->mothurOut(lookup[0]->getLabel()); m->mothurOutEndLine();
+				process(lookup);
+				
+				processedLabels.insert(lookup[0]->getLabel());
+				userLabels.erase(lookup[0]->getLabel());
+				
+				//restore real lastlabel to save below
+				lookup[0]->setLabel(saveLabel);
 			}
 
-			//prevent memory leak
-			if (count != 1) { for (int i = 0; i < lastLookup.size(); i++) {  delete lastLookup[i];  } }
-			lastLookup = lookup;			
+			lastLabel = lookup[0]->getLabel();			
 			
 			//get next line to process
+			for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  } 
 			lookup = input->getSharedRAbundVectors();
-			count++;
 		}
 		
+		if (m->control_pressed) { outputTypes.clear(); delete input; for (int i = 0; i < outputNames.size(); i++) {	remove(outputNames[i].c_str()); } m->Groups.clear(); return 0;  }
+
 		//output error messages about any remaining user labels
 		set<string>::iterator it;
 		bool needToRun = false;
 		for (it = userLabels.begin(); it != userLabels.end(); it++) {  
-			cout << "Your file does not include the label "<< *it; 
-			if (processedLabels.count(lastLookup[0]->getLabel()) != 1) {
-				cout << ". I will use " << lastLookup[0]->getLabel() << "." << endl;
+			m->mothurOut("Your file does not include the label " + *it);  
+			if (processedLabels.count(lastLabel) != 1) {
+				m->mothurOut(". I will use " + lastLabel + "."); m->mothurOutEndLine();
 				needToRun = true;
 			}else {
-				cout << ". Please refer to " << lastLookup[0]->getLabel() << "." << endl;
+				m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine();
 			}
 		}
 		
-		//run last line if you need to
+		if (m->control_pressed) { outputTypes.clear(); delete input;  for (int i = 0; i < outputNames.size(); i++) {	remove(outputNames[i].c_str()); } m->Groups.clear(); return 0;  }
+
+		//run last label if you need to
 		if (needToRun == true)  {
-			cout << lastLookup[0]->getLabel() << '\t' << count << endl;
-			process(lastLookup);		
+			for (int i = 0; i < lookup.size(); i++) {  if (lookup[i] != NULL) {  delete lookup[i]; }  } 
+			lookup = input->getSharedRAbundVectors(lastLabel);
+
+			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 < lastLookup.size(); i++) {  delete lastLookup[i];  }
-
+		if (m->control_pressed) { outputTypes.clear();  delete input;  for (int i = 0; i < outputNames.size(); i++) {	remove(outputNames[i].c_str()); } m->Groups.clear(); return 0;  }
 		
 		//reset groups parameter
-		globaldata->Groups.clear();  globaldata->setGroups("");
+		m->Groups.clear();  
+		
+		//set phylip file as new current phylipfile
+		string current = "";
+		itTypes = outputTypes.find("phylip");
+		if (itTypes != outputTypes.end()) {
+			if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setPhylipFile(current); }
+		}
+		
+		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) {
-		cout << "Standard Error: " << e.what() << " has occurred in the MatrixOutputCommand class Function execute. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+		m->errorOut(e, "MatrixOutputCommand", "execute");
 		exit(1);
 	}
-	catch(...) {
-		cout << "An unknown error has occurred in the MatrixOutputCommand class function execute. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-		exit(1);
-	}		
 }
 /***********************************************************/
 void MatrixOutputCommand::printSims(ostream& out) {
 	try {
 		
-		//output column headers
+		out.setf(ios::fixed, ios::floatfield); out.setf(ios::showpoint);
+		
+		//output num seqs
 		out << simMatrix.size() << endl;
 		
-		for (int m = 0; m < simMatrix.size(); m++)	{
-			out << lookup[m]->getGroup() << '\t';
-			for (int n = 0; n < m; n++)	{
-				out << simMatrix[m][n] << '\t'; 
+		if (output == "lt") {
+			for (int m = 0; m < simMatrix.size(); m++)	{
+				out << lookup[m]->getGroup() << '\t';
+				for (int n = 0; n < m; n++)	{
+					out << simMatrix[m][n] << '\t'; 
+				}
+				out << endl;
+			}
+		}else{
+			for (int m = 0; m < simMatrix.size(); m++)	{
+				out << lookup[m]->getGroup() << '\t';
+				for (int n = 0; n < simMatrix[m].size(); n++)	{
+					out << simMatrix[m][n] << '\t'; 
+				}
+				out << endl;
 			}
-			out << endl;
 		}
-
 	}
 	catch(exception& e) {
-		cout << "Standard Error: " << e.what() << " has occurred in the MatrixOutputCommand class Function printSims. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+		m->errorOut(e, "MatrixOutputCommand", "printSims");
 		exit(1);
 	}
-	catch(...) {
-		cout << "An unknown error has occurred in the MatrixOutputCommand class function printSims. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-		exit(1);
-	}		
 }
 /***********************************************************/
-void MatrixOutputCommand::process(vector<SharedRAbundVector*> thisLookup){
+int MatrixOutputCommand::process(vector<SharedRAbundVector*> thisLookup){
 	try {
 	
 				EstOutput data;
@@ -201,9 +449,9 @@ void MatrixOutputCommand::process(vector<SharedRAbundVector*> thisLookup){
 					//initialize simMatrix
 					simMatrix.clear();
 					simMatrix.resize(numGroups);
-					for (int m = 0; m < simMatrix.size(); m++)	{
+					for (int p = 0; p < simMatrix.size(); p++)	{
 						for (int j = 0; j < simMatrix.size(); j++)	{
-							simMatrix[m].push_back(0.0);
+							simMatrix[p].push_back(0.0);
 						}
 					}
 				
@@ -212,10 +460,20 @@ void MatrixOutputCommand::process(vector<SharedRAbundVector*> thisLookup){
 							if (k != l) { //we dont need to similiarity of a groups to itself
 								//get estimated similarity between 2 groups
 								
+								if (m->control_pressed) { return 0; }
+								
 								subset.clear(); //clear out old pair of sharedrabunds
 								//add new pair of sharedrabunds
 								subset.push_back(thisLookup[k]); subset.push_back(thisLookup[l]); 
 								
+								//if this calc needs all groups to calculate the pair load all groups
+								if (matrixCalculators[i]->getNeedsAll()) { 
+									//load subset with rest of lookup for those calcs that need everyone to calc for a pair
+									for (int w = 0; w < thisLookup.size(); w++) {
+										if ((w != k) && (w != l)) { subset.push_back(thisLookup[w]); }
+									}
+								}
+								
 								data = matrixCalculators[i]->getValues(subset); //saves the calculator outputs
 								//save values in similarity matrix
 								simMatrix[k][l] = 1.0 - data[0];  //convert similiarity to distance
@@ -224,24 +482,22 @@ void MatrixOutputCommand::process(vector<SharedRAbundVector*> thisLookup){
 						}
 					}
 					
-					exportFileName = getRootName(globaldata->inputFileName) + matrixCalculators[i]->getName() + "." + thisLookup[0]->getLabel() + ".dist";
-					openOutputFile(exportFileName, out);
+					exportFileName = outputDir + m->getRootName(m->getSimpleName(sharedfile)) + matrixCalculators[i]->getName() + "." + thisLookup[0]->getLabel() + "." + output + ".dist";
+					m->openOutputFile(exportFileName, out);
+					outputNames.push_back(exportFileName); outputTypes["phylip"].push_back(exportFileName);
+					
 					printSims(out);
 					out.close();
 					
 				}
 
-	
+				return 0;
 		
 	}
 	catch(exception& e) {
-		cout << "Standard Error: " << e.what() << " has occurred in the MatrixOutputCommand class Function process. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+		m->errorOut(e, "MatrixOutputCommand", "process");
 		exit(1);
 	}
-	catch(...) {
-		cout << "An unknown error has occurred in the MatrixOutputCommand class function process. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-		exit(1);
-	}		
 }
 /***********************************************************/