#include "parsimonycommand.h"
+//**********************************************************************************************************************
+vector<string> ParsimonyCommand::getValidParameters(){
+ try {
+ string Array[] = {"random","groups","iters","processors","outputdir","inputdir"};
+ vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
+ return myArray;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "ParsimonyCommand", "getValidParameters");
+ exit(1);
+ }
+}
+//**********************************************************************************************************************
+ParsimonyCommand::ParsimonyCommand(){
+ try {
+ abort = true;
+ //initialize outputTypes
+ vector<string> tempOutNames;
+ outputTypes["parsimony"] = tempOutNames;
+ outputTypes["psummary"] = tempOutNames;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "ParsimonyCommand", "ParsimonyCommand");
+ exit(1);
+ }
+}
+//**********************************************************************************************************************
+vector<string> ParsimonyCommand::getRequiredParameters(){
+ try {
+ vector<string> myArray;
+ return myArray;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "ParsimonyCommand", "getRequiredParameters");
+ exit(1);
+ }
+}
+//**********************************************************************************************************************
+vector<string> ParsimonyCommand::getRequiredFiles(){
+ try {
+ vector<string> myArray;
+ return myArray;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "ParsimonyCommand", "getRequiredFiles");
+ exit(1);
+ }
+}
/***********************************************************/
ParsimonyCommand::ParsimonyCommand(string option) {
try {
else {
//valid paramters for this command
- string Array[] = {"random","groups","iters","outputdir","inputdir"};
+ string Array[] = {"random","groups","processors","iters","outputdir","inputdir"};
vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
OptionParser parser(option);
if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; }
}
+ //initialize outputTypes
+ vector<string> tempOutNames;
+ outputTypes["parsimony"] = tempOutNames;
+ outputTypes["psummary"] = tempOutNames;
+
randomtree = validParameter.validFile(parameters, "random", false); if (randomtree == "not found") { randomtree = ""; }
//are you trying to use parsimony without reading a tree or saying you want random distribution
}
//if the user changes the output directory command factory will send this info to us in the output parameter
- string outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; }
+ string outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; if (randomtree == "") { outputDir += m->hasPath(globaldata->inputFileName); } }
//check for optional parameter and set defaults
// ...at some point should added some additional type checking...
groups = validParameter.validFile(parameters, "groups", false);
if (groups == "not found") { groups = ""; globaldata->Groups.clear(); }
else {
- splitAtDash(groups, Groups);
+ m->splitAtDash(groups, Groups);
globaldata->Groups = Groups;
}
itersString = validParameter.validFile(parameters, "iters", false); if (itersString == "not found") { itersString = "1000"; }
convert(itersString, iters);
+
+ string temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = "1"; }
+ convert(temp, processors);
if (abort == false) {
//randomtree will tell us if user had their own treefile or if they just want the random distribution
T = globaldata->gTree;
tmap = globaldata->gTreemap;
- if(outputDir == "") { outputDir += hasPath(globaldata->getTreeFile()); }
- output = new ColumnFile(outputDir + getSimpleName(globaldata->getTreeFile()) + ".parsimony", itersString);
- outputNames.push_back(outputDir + getSimpleName(globaldata->getTreeFile()) + ".parsimony");
+ if(outputDir == "") { outputDir += m->hasPath(globaldata->getTreeFile()); }
+ output = new ColumnFile(outputDir + m->getSimpleName(globaldata->getTreeFile()) + ".parsimony", itersString);
+ outputNames.push_back(outputDir + m->getSimpleName(globaldata->getTreeFile()) + ".parsimony");
+ outputTypes["parsimony"].push_back(outputDir + m->getSimpleName(globaldata->getTreeFile()) + ".parsimony");
- sumFile = outputDir + getSimpleName(globaldata->getTreeFile()) + ".psummary";
- openOutputFile(sumFile, outSum);
+ sumFile = outputDir + m->getSimpleName(globaldata->getTreeFile()) + ".psummary";
+ m->openOutputFile(sumFile, outSum);
outputNames.push_back(sumFile);
+ outputTypes["psummary"].push_back(sumFile);
}else { //user wants random distribution
savetmap = globaldata->gTreemap;
getUserInput();
- if(outputDir == "") { outputDir += hasPath(randomtree); }
- output = new ColumnFile(outputDir+ getSimpleName(randomtree), itersString);
- outputNames.push_back(outputDir+ getSimpleName(randomtree));
+ if(outputDir == "") { outputDir += m->hasPath(randomtree); }
+ output = new ColumnFile(outputDir+ m->getSimpleName(randomtree), itersString);
+ outputNames.push_back(outputDir+ m->getSimpleName(randomtree));
+ outputTypes["parsimony"].push_back(outputDir+ m->getSimpleName(randomtree));
}
//set users groups to analyze
void ParsimonyCommand::help(){
try {
m->mothurOut("The parsimony command can only be executed after a successful read.tree command, unless you use the random parameter.\n");
- m->mothurOut("The parsimony command parameters are random, groups and iters. No parameters are required.\n");
+ m->mothurOut("The parsimony command parameters are random, groups, processors and iters. No parameters are required.\n");
m->mothurOut("The groups parameter allows you to specify which of the groups in your groupfile you would like analyzed. You must enter at least 1 valid group.\n");
m->mothurOut("The group names are separated by dashes. The iters parameter allows you to specify how many random trees you would like compared to your tree.\n");
m->mothurOut("The parsimony command should be in the following format: parsimony(random=yourOutputFilename, groups=yourGroups, iters=yourIters).\n");
+ m->mothurOut("The processors parameter allows you to specify the number of processors to use. The default is 1.\n");
m->mothurOut("Example parsimony(random=out, iters=500).\n");
m->mothurOut("The default value for random is "" (meaning you want to use the trees in your inputfile, randomtree=out means you just want the random distribution of trees outputted to out.rd_parsimony),\n");
m->mothurOut("and iters is 1000. The parsimony command output two files: .parsimony and .psummary their descriptions are in the manual.\n");
if (m->control_pressed) {
delete reading; delete pars; delete util; delete output;
if (randomtree == "") { outSum.close(); }
- for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); }
+ for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } outputTypes.clear();
globaldata->Groups.clear();
return 0;
}
if (randomtree == "") {
//get pscores for users trees
for (int i = 0; i < T.size(); i++) {
- userData = pars->getValues(T[i]); //data = AB, AC, BC, ABC.
+ userData = pars->getValues(T[i], processors, outputDir); //data = AB, AC, BC, ABC.
if (m->control_pressed) {
delete reading; delete pars; delete util; delete output;
if (randomtree == "") { outSum.close(); }
- for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); }
+ for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } outputTypes.clear();
globaldata->Groups.clear();
return 0;
}
randT->assembleRandomTree();
//get pscore of random tree
- randomData = pars->getValues(randT);
+ randomData = pars->getValues(randT, processors, outputDir);
if (m->control_pressed) {
delete reading; delete pars; delete util; delete output; delete randT;
if (randomtree == "") { outSum.close(); }
- for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); }
+ for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } outputTypes.clear();
globaldata->Groups.clear();
return 0;
}
if (m->control_pressed) {
delete reading; delete pars; delete util; delete output; delete randT;
globaldata->gTreemap = savetmap;
- for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); }
+ for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } outputTypes.clear();
globaldata->Groups.clear();
return 0;
}
//get pscore of random tree
- randomData = pars->getValues(randT);
+ randomData = pars->getValues(randT, processors, outputDir);
if (m->control_pressed) {
delete reading; delete pars; delete util; delete output; delete randT;
globaldata->gTreemap = savetmap;
- for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); }
+ for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } outputTypes.clear();
globaldata->Groups.clear();
return 0;
}
delete reading; delete pars; delete util; delete output;
if (randomtree == "") { outSum.close(); }
else { globaldata->gTreemap = savetmap; }
- for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); }
+ for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } outputTypes.clear();
globaldata->Groups.clear();
return 0;
}
if (m->control_pressed) {
delete pars; delete util; delete output;
- for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); }
+ for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } outputTypes.clear();
return 0;
}
projects / mothur.git / blobdiff