MergeGroupsCommand::MergeGroupsCommand(string option) {
try {
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();
ValidParameters validParameter;
//check to make sure all parameters are valid for command
map<string,string>::iterator it;
for (it = parameters.begin(); it != parameters.end(); it++) {
if (!validParameter.isValidParameter(it->first, myArray, it->second)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["shared"] = tempOutNames;
outputTypes["group"] = tempOutNames;
outputTypes["count"] = tempOutNames;
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; }
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("design");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["design"] = inputDir + it->second; }
}
it = parameters.find("shared");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("group");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["group"] = inputDir + it->second; }
}
it = parameters.find("count");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["count"] = inputDir + it->second; }
}
it = parameters.find("fasta");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["fasta"] = inputDir + it->second; }
}
}
//check for required parameters
designfile = validParameter.validFile(parameters, "design");
if (designfile == "not open") { abort = true; }
else if (designfile == "not found") {
//if there is a current shared file, use it
designfile = current->getDesignFile();
if (designfile != "") { m->mothurOut("Using " + designfile + " as input file for the design parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current designfile and the design parameter is required."); m->mothurOutEndLine(); abort = true; }
}else { current->setDesignFile(designfile); }
sharedfile = validParameter.validFile(parameters, "shared");
if (sharedfile == "not open") { abort = true; sharedfile = ""; }
else if (sharedfile == "not found") { sharedfile = ""; }
else { current->setSharedFile(sharedfile); }
groupfile = validParameter.validFile(parameters, "group");
if (groupfile == "not open") { abort = true; groupfile = ""; }
else if (groupfile == "not found") { groupfile = ""; }
else { current->setGroupFile(groupfile); }
countfile = validParameter.validFile(parameters, "count");
if (countfile == "not open") { abort = true; countfile = ""; }
else if (countfile == "not found") { countfile = ""; }
else { current->setCountFile(countfile); }
fastafile = validParameter.validFile(parameters, "fasta");
if (fastafile == "not open") { abort = true; countfile = ""; }
else if (fastafile == "not found") { fastafile = ""; }
else { current->setFastaFile(fastafile); }
//check for optional parameter and set defaults
// ...at some point should added some additional type checking...
label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
groups = validParameter.valid(parameters, "groups");
if (groups == "not found") { groups = "all"; }
util.splitAtDash(groups, Groups);
if (Groups.size() != 0) { if (Groups[0]== "all") { Groups.clear(); } }
method = validParameter.valid(parameters, "method"); if(method == "not found"){ method = "sum"; }
if ((method != "sum") && (method != "average") && (method != "median")) { m->mothurOut(method + " is not a valid method. Options are sum, average and median. I will use sum."); m->mothurOutEndLine(); method = "sum"; }
if ((groupfile != "") && (countfile != "")) {
m->mothurOut("[ERROR]: you may only use one of the following: group or count."); m->mothurOutEndLine(); abort=true;
}
if ((sharedfile == "") && (groupfile == "") && (countfile == "")) {
//give priority to group, then shared
groupfile = current->getGroupFile();
if (groupfile != "") { m->mothurOut("Using " + groupfile + " as input file for the group parameter."); m->mothurOutEndLine(); }
else {
sharedfile = current->getSharedFile();
if (sharedfile != "") { m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); }
else {
countfile = current->getCountFile();
if (countfile != "") { m->mothurOut("Using " + countfile + " as input file for the count parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("You have no current groupfile, countfile or sharedfile and one is required."); m->mothurOutEndLine(); abort = true;
}
}
}
}
if ((countfile == "") && (fastafile != "")) { m->mothurOut("[ERROR]: You may only use the fasta file with the count file, quitting."); m->mothurOutEndLine(); abort=true; }
else if ((countfile != "") && (method == "average")) { m->mothurOut("You may not use the average method with the count file. I will use the sum method."); m->mothurOutEndLine(); method = "sum"; }
else if ((countfile != "") && (method == "median") && (fastafile == "")) {
fastafile = current->getFastaFile();
if (fastafile != "") { m->mothurOut("Using " + fastafile + " as input file for the fasta parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("[ERROR]: Fasta file is required with the median method and a count file so that sequences removed from your count table can also be removed from your fasta file to avoid downstream file mismatches, quitting.\n"); abort=true;
}
}
}
}
catch(exception& e) {
m->errorOut(e, "MergeGroupsCommand", "MergeGroupsCommand");
exit(1);
}
}
//**********************************************************************************************************************
//This function checks to make sure the cluster command has no errors and then clusters based on the method chosen.
ClusterDoturCommand::ClusterDoturCommand(string option) {
try{
abort = false; calledHelp = false;
//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();
ValidParameters validParameter;
//check to make sure all parameters are valid for command
map<string,string>::iterator it;
for (it = parameters.begin(); it != parameters.end(); it++) {
if (!validParameter.isValidParameter(it->first, myArray, it->second)) {
abort = true;
}
}
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("phylip");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("name");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("count");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["count"] = inputDir + it->second; }
}
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["list"] = tempOutNames;
outputTypes["rabund"] = tempOutNames;
outputTypes["sabund"] = tempOutNames;
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; }
//check for required parameters
phylipfile = validParameter.validFile(parameters, "phylip");
if (phylipfile == "not open") { abort = true; }
else if (phylipfile == "not found") {
phylipfile = current->getPhylipFile();
if (phylipfile != "") { m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("You need to provide a phylip file with the cluster.classic command."); m->mothurOutEndLine();
abort = true;
}
}else { current->setPhylipFile(phylipfile); }
//check for optional parameter and set defaults
namefile = validParameter.validFile(parameters, "name");
if (namefile == "not open") { abort = true; namefile = ""; }
else if (namefile == "not found") { namefile = ""; }
else { current->setNameFile(namefile); }
countfile = validParameter.validFile(parameters, "count");
if (countfile == "not open") { abort = true; countfile = ""; }
else if (countfile == "not found") { countfile = ""; }
else { current->setCountFile(countfile); }
if ((countfile != "") && (namefile != "")) { m->mothurOut("When executing a cluster.classic command you must enter ONLY ONE of the following: count or name."); m->mothurOutEndLine(); abort = true; }
string temp;
temp = validParameter.valid(parameters, "precision");
if (temp == "not found") { temp = "100"; }
//saves precision legnth for formatting below
length = temp.length();
util.mothurConvert(temp, precision);
temp = validParameter.valid(parameters, "cutoff");
if (temp == "not found") { temp = "10"; }
util.mothurConvert(temp, cutoff);
temp = validParameter.valid(parameters, "sim"); if (temp == "not found") { temp = "F"; }
sim = util.isTrue(temp);
method = validParameter.valid(parameters, "method");
if (method == "not found") { method = "average"; }
if ((method == "furthest") || (method == "nearest") || (method == "average") || (method == "weighted")) {
if (method == "furthest") { tag = "fn"; }
else if (method == "nearest") { tag = "nn"; }
else if (method == "average") { tag = "an"; }
else if (method == "weighted") { tag = "wn"; }
}else { m->mothurOut("Not a valid clustering method. Valid clustering algorithms are furthest, nearest, average, weighted."); m->mothurOutEndLine(); abort = true; }
}
}
catch(exception& e) {
m->errorOut(e, "ClusterDoturCommand", "ClusterCommand");
exit(1);
}
}
DeconvoluteCommand::DeconvoluteCommand(string option) {
try {
abort = false; calledHelp = false;
//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();
ValidParameters validParameter;
map<string, string>::iterator it;
//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)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["fasta"] = tempOutNames;
outputTypes["name"] = tempOutNames;
outputTypes["count"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("fasta");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["fasta"] = inputDir + it->second; }
}
it = parameters.find("name");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("count");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["count"] = inputDir + it->second; }
}
}
//check for required parameters
fastafile = validParameter.validFile(parameters, "fasta");
if (fastafile == "not open") { abort = true; }
else if (fastafile == "not found") {
fastafile = current->getFastaFile();
if (fastafile != "") { m->mothurOut("Using " + fastafile + " as input file for the fasta parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current fastafile and the fasta parameter is required."); m->mothurOutEndLine(); abort = true; }
}else { current->setFastaFile(fastafile); }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){
outputDir = "";
outputDir += util.hasPath(fastafile); //if user entered a file with a path then preserve it
}
namefile = validParameter.validFile(parameters, "name");
if (namefile == "not open") { namefile = ""; abort = true; }
else if (namefile == "not found"){ namefile = ""; }
else { current->setNameFile(namefile); }
countfile = validParameter.validFile(parameters, "count");
if (countfile == "not open") { abort = true; countfile = ""; }
else if (countfile == "not found") { countfile = ""; }
else { current->setCountFile(countfile); }
if ((countfile != "") && (namefile != "")) { m->mothurOut("When executing a unique.seqs command you must enter ONLY ONE of the following: count or name."); m->mothurOutEndLine(); abort = true; }
format = validParameter.valid(parameters, "format");
if(format == "not found"){
if (countfile != "") { format = "count"; }
else { format = "name"; }
}
if ((format != "name") && (format != "count")) {
m->mothurOut(format + " is not a valid format option. Options are count or name.");
if (countfile == "") { m->mothurOut("I will use name.\n"); format = "name"; }
else { m->mothurOut("I will use count.\n"); format = "count"; }
}
if (countfile == "") {
if (namefile == "") {
vector<string> files; files.push_back(fastafile);
if (!current->getMothurCalling()) { parser.getNameFile(files); }
}
}
}
}
catch(exception& e) {
m->errorOut(e, "DeconvoluteCommand", "DeconvoluteCommand");
exit(1);
}
}
//**********************************************************************************************************************
NewCommand::NewCommand(string option) {
try {
////////////////////////////////////////////////////////
/////////////////// start leave alone block ////////////
////////////////////////////////////////////////////////
abort = false; calledHelp = false;
//allow user to run help
if(option == "help") { help(); abort = true; calledHelp = true; }
else if(option == "citation") { citation(); abort = true; calledHelp = true;}
else {
//valid paramters for this command
vector<string> myArray = setParameters();
OptionParser parser(option);
map<string,string> parameters = parser.getParameters();
ValidParameters validParameter;
map<string,string>::iterator it;
//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)) { abort = true; }
}
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
///////////////////////////////////////////////////////////////
//////////////// stop leave alone block ///////////////////////
///////////////////////////////////////////////////////////////
//edit file types below to include only the types you added as parameters
string path;
it = parameters.find("phylip");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("column");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("fasta");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["fasta"] = inputDir + it->second; }
}
it = parameters.find("name");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("shared");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
}
///////////////////////////////////////////////////////////////////////////////
/////////// example of getting filenames and checking dependancies ////////////
// the validParameter class will make sure file exists, fill with correct //
// and name is current is given ///////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///variables for examples below that you will most likely want to put in the header for
//use by the other class functions.
string phylipfile, columnfile, namefile, fastafile, sharedfile, method, countfile;
int processors;
bool useTiming, allLines;
vector<string> Estimators, Groups;
set<string> labels;
//if allLines is used it should be initialized to 1 above.
//check for parameters
phylipfile = validParameter.validFile(parameters, "phylip");
if (phylipfile == "not open") { phylipfile = ""; abort = true; }
else if (phylipfile == "not found") { phylipfile = ""; }
else { current->setPhylipFile(phylipfile); }
columnfile = validParameter.validFile(parameters, "column");
if (columnfile == "not open") { columnfile = ""; abort = true; }
else if (columnfile == "not found") { columnfile = ""; }
else { current->setColumnFile(columnfile); }
namefile = validParameter.validFile(parameters, "name");
if (namefile == "not open") { abort = true; }
else if (namefile == "not found") { namefile = ""; }
else { current->setNameFile(namefile); }
//get fastafile - it is not required
fastafile = validParameter.validFile(parameters, "fasta");
if (fastafile == "not open") { fastafile = ""; abort=true; }
else if (fastafile == "not found") { fastafile = ""; }
if (fastafile != "") { current->setFastaFile(fastafile); }
if ((phylipfile == "") && (columnfile == "")) {
//is there are current file available for either of these?
//give priority to column, then phylip
columnfile = current->getColumnFile();
if (columnfile != "") { m->mothurOut("Using " + columnfile + " as input file for the column parameter."); m->mothurOutEndLine(); }
else {
phylipfile = current->getPhylipFile();
if (phylipfile != "") { m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("No valid current files. You must provide a phylip or column file before you can use the cluster command."); m->mothurOutEndLine();
abort = true;
}
}
}
else if ((phylipfile != "") && (columnfile != "")) { m->mothurOut("When executing a cluster command you must enter ONLY ONE of the following: phylip or column."); m->mothurOutEndLine(); abort = true; }
if (columnfile != "") {
if (namefile == "") {
namefile = current->getNameFile();
if (namefile != "") { m->mothurOut("Using " + namefile + " as input file for the name parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("You need to provide a namefile if you are going to use the column format."); m->mothurOutEndLine();
abort = true;
}
}
}
//get shared file, it is required
sharedfile = validParameter.validFile(parameters, "shared");
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") {
//if there is a current shared file, use it
sharedfile = current->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 { current->setSharedFile(sharedfile); }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){
outputDir = util.hasPath(sharedfile); //if user entered a file with a path then preserve it
}
//////////////////////////////////////////////////////////////////////
////////// example of getting other types of parameters //////////////
//////////////////////////////////////////////////////////////////////
//use only one Mutliple type
method = validParameter.valid(parameters, "method");
if (method == "not found") { method = "average"; }
if ((method == "furthest") || (method == "nearest") || (method == "average") || (method == "weighted")) { }
else { m->mothurOut("Not a valid clustering method. Valid clustering algorithms are furthest, nearest, average, and weighted."); m->mothurOutEndLine(); abort = true; }
//use more than one multiple type. do not check to make sure the entry is valid.
string calc = validParameter.valid(parameters, "calc");
if (calc == "not found") { calc = "sobs-chao-ace-jack-shannon-npshannon-simpson"; }
else {
if (calc == "default") { calc = "sobs-chao-ace-jack-shannon-npshannon-simpson"; }
}
util.splitAtDash(calc, Estimators);
//Boolean type - m->isTrue looks for t, true, f or false and is case insensitive
string timing = validParameter.valid(parameters, "timing");
if (timing == "not found") { timing = "F"; }
useTiming = util.isTrue(timing);
//Number type - mothurConvert makes sure the convert can happen to avoid a crash.
string temp = validParameter.valid(parameters, "processors"); if (temp == "not found"){ temp = current->getProcessors(); }
processors = current->setProcessors(temp);
//Groups must be checked later to make sure they are valid. SharedUtilities has functions of check the validity, just make to so m->setGroups() after the checks. If you are using these with a shared file no need to check the SharedRAbundVector class will call SharedUtilites for you, kinda nice, huh?
string groups = validParameter.valid(parameters, "groups");
if (groups == "not found") { groups = ""; }
else {
util.splitAtDash(groups, Groups);
if (Groups.size() != 0) { if (Groups[0]== "all") { Groups.clear(); } }
}
//Commonly used to process list, rabund, sabund, shared and relabund files. Look at "smart distancing" examples below in the execute function.
string label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
//if your command has a namefile as an option, you may want ot check to see if there is a current namefile
//saved by mothur that is associated with the other files you are using as inputs.
//You can do so by adding the files associated with the namefile to the files vector and then asking parser to check.
//This saves our users headaches over file mismatches because they forgot to include the namefile, :)
if (countfile == "") {
if (namefile == "") {
vector<string> files; files.push_back(fastafile);
if (!current->getMothurCalling()) { parser.getNameFile(files); }
}
}
}
}
catch(exception& e) {
m->errorOut(e, "NewCommand", "NewCommand");
exit(1);
}
}
//**********************************************************************************************************************
ClassifyRFSharedCommand::ClassifyRFSharedCommand(string option) {
try {
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 {
//valid paramters for this command
vector<string> myArray = setParameters();
OptionParser parser(option);
map<string,string> parameters = parser.getParameters();
ValidParameters validParameter;
map<string,string>::iterator it;
//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)) { abort = true; }
}
vector<string> tempOutNames;
outputTypes["summary"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("shared");
//user has given a shared file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("design");
//user has given a design file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["design"] = inputDir + it->second; }
}
}
//check for parameters
//get shared file, it is required
sharedfile = validParameter.validFile(parameters, "shared");
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") {
//if there is a current shared file, use it
sharedfile = current->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 { current->setSharedFile(sharedfile); }
//get design file, it is required
designfile = validParameter.validFile(parameters, "design");
if (designfile == "not open") { sharedfile = ""; abort = true; }
else if (designfile == "not found") {
//if there is a current shared file, use it
designfile = current->getDesignFile();
if (designfile != "") { m->mothurOut("Using " + designfile + " as input file for the design parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current designfile and the design parameter is required."); m->mothurOutEndLine(); abort = true; }
}else { current->setDesignFile(designfile); }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){
outputDir = util.hasPath(sharedfile); //if user entered a file with a path then preserve it
}
// NEW CODE for OTU per split selection criteria
string temp = validParameter.valid(parameters, "splitcriteria");
if (temp == "not found") { temp = "gainratio"; }
if ((temp == "gainratio") || (temp == "infogain")) {
treeSplitCriterion = temp;
} else { m->mothurOut("Not a valid tree splitting criterio. Valid tree splitting criteria are 'gainratio' and 'infogain'.");
m->mothurOutEndLine();
abort = true;
}
temp = validParameter.valid(parameters, "numtrees"); if (temp == "not found"){ temp = "100"; }
util.mothurConvert(temp, numDecisionTrees);
// parameters for pruning
temp = validParameter.valid(parameters, "prune");
if (temp == "not found") { temp = "f"; }
doPruning = util.isTrue(temp);
temp = validParameter.valid(parameters, "pruneaggressiveness");
if (temp == "not found") { temp = "0.9"; }
util.mothurConvert(temp, pruneAggressiveness);
temp = validParameter.valid(parameters, "discarderrortrees");
if (temp == "not found") { temp = "f"; }
discardHighErrorTrees = util.isTrue(temp);
temp = validParameter.valid(parameters, "errorthreshold");
if (temp == "not found") { temp = "0.4"; }
util.mothurConvert(temp, highErrorTreeDiscardThreshold);
temp = validParameter.valid(parameters, "otupersplit");
if (temp == "not found") { temp = "log2"; }
if ((temp == "squareroot") || (temp == "log2")) {
optimumFeatureSubsetSelectionCriteria = temp;
} else { m->mothurOut("Not a valid OTU per split selection method. Valid OTU per split selection methods are 'log2' and 'squareroot'.");
m->mothurOutEndLine();
abort = true;
}
temp = validParameter.valid(parameters, "stdthreshold");
if (temp == "not found") { temp = "0.0"; }
util.mothurConvert(temp, featureStandardDeviationThreshold);
// end of pruning params
string groups = validParameter.valid(parameters, "groups");
if (groups == "not found") { groups = ""; }
else { util.splitAtDash(groups, Groups); if (Groups.size() != 0) { if (Groups[0]== "all") { Groups.clear(); } } }
//Commonly used to process list, rabund, sabund, shared and relabund files. Look at "smart distancing" examples below in the execute function.
string label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
}
}
catch(exception& e) {
m->errorOut(e, "ClassifySharedCommand", "ClassifySharedCommand");
exit(1);
}
}
//***************************************************************************************************************
DegapSeqsCommand::DegapSeqsCommand(string option) {
try {
abort = false; calledHelp = false;
//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();
ValidParameters validParameter;
map<string,string>::iterator it;
//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)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["fasta"] = tempOutNames;
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("fasta");
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["fasta"] = inputDir + it->second; }
}
}
fastafile = validParameter.validFile(parameters, "fasta");
if (fastafile == "not found") {
fastafile = current->getFastaFile();
if (fastafile != "") { m->mothurOut("Using " + fastafile + " as input file for the fasta parameter.\n"); }
else { m->mothurOut("[ERROR]: You have no current fasta file and the fasta parameter is required.\n"); abort = true; }
}
else if (fastafile == "not open") { abort = true; }
else { current->setFastaFile(fastafile); }
string temp = validParameter.valid(parameters, "processors"); if (temp == "not found"){ temp = current->getProcessors(); }
processors = current->setProcessors(temp);
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){
outputDir = "";
outputDir += util.hasPath(fastafile); //if user entered a file with a path then preserve it
}
}
}
catch(exception& e) {
m->errorOut(e, "DegapSeqsCommand", "DegapSeqsCommand");
exit(1);
}
}
//**********************************************************************************************************************
RemoveDistsCommand::RemoveDistsCommand(string option) {
try {
abort = false; calledHelp = false;
//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();
ValidParameters validParameter;
map<string,string>::iterator it;
//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)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["column"] = tempOutNames;
outputTypes["phylip"] = tempOutNames;
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; }
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("phylip");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("column");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("accnos");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["accnos"] = inputDir + it->second; }
}
}
//check for required parameters
accnosfile = validParameter.validFile(parameters, "accnos");
if (accnosfile == "not open") { abort = true; }
else if (accnosfile == "not found") {
accnosfile = current->getAccnosFile();
if (accnosfile != "") { m->mothurOut("Using " + accnosfile + " as input file for the accnos parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("You have no valid accnos file and accnos is required."); m->mothurOutEndLine();
abort = true;
}
}else { current->setAccnosFile(accnosfile); }
phylipfile = validParameter.validFile(parameters, "phylip");
if (phylipfile == "not open") { phylipfile = ""; abort = true; }
else if (phylipfile == "not found") { phylipfile = ""; }
else { current->setPhylipFile(phylipfile); }
columnfile = validParameter.validFile(parameters, "column");
if (columnfile == "not open") { columnfile = ""; abort = true; }
else if (columnfile == "not found") { columnfile = ""; }
else { current->setColumnFile(columnfile); }
if ((phylipfile == "") && (columnfile == "")) {
//is there are current file available for either of these?
//give priority to column, then phylip
columnfile = current->getColumnFile();
if (columnfile != "") { m->mothurOut("Using " + columnfile + " as input file for the column parameter."); m->mothurOutEndLine(); }
else {
phylipfile = current->getPhylipFile();
if (phylipfile != "") { m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("No valid current files. You must provide a phylip or column file."); m->mothurOutEndLine();
abort = true;
}
}
}
}
}
catch(exception& e) {
m->errorOut(e, "RemoveDistsCommand", "RemoveDistsCommand");
exit(1);
}
}
//**********************************************************************************************************************
GetRelAbundCommand::GetRelAbundCommand(string option) {
try {
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)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["relabund"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("shared");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
}
//get shared file
sharedfile = validParameter.validFile(parameters, "shared");
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") {
//if there is a current shared file, use it
sharedfile = current->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 { current->setSharedFile(sharedfile); }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = util.hasPath(sharedfile); }
//check for optional parameter and set defaults
// ...at some point should added some additional type checking...
label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
groups = validParameter.valid(parameters, "groups");
if (groups == "not found") { groups = ""; pickedGroups = false; }
else {
pickedGroups = true;
util.splitAtDash(groups, Groups);
if (Groups.size() != 0) { if (Groups[0]== "all") { Groups.clear(); } }
}
scale = validParameter.valid(parameters, "scale"); if (scale == "not found") { scale = "totalgroup"; }
if ((scale != "totalgroup") && (scale != "totalotu") && (scale != "averagegroup") && (scale != "averageotu")) {
m->mothurOut(scale + " is not a valid scaling option for the get.relabund command. Choices are totalgroup, totalotu, averagegroup, averageotu."); m->mothurOutEndLine(); abort = true;
}
}
}
catch(exception& e) {
m->errorOut(e, "GetRelAbundCommand", "GetRelAbundCommand");
exit(1);
}
}
ListSeqsCommand::ListSeqsCommand(string option) {
try {
abort = false; calledHelp = false;
//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();
ValidParameters validParameter;
map<string,string>::iterator it;
//check to make sure all parameters are valid for command
for (map<string,string>::iterator it = parameters.begin(); it != parameters.end(); it++) {
if (!validParameter.isValidParameter(it->first, myArray, it->second)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["accnos"] = tempOutNames;
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; }
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("alignreport");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["alignreport"] = inputDir + it->second; }
}
it = parameters.find("fasta");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["fasta"] = inputDir + it->second; }
}
it = parameters.find("list");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["list"] = inputDir + it->second; }
}
it = parameters.find("name");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("group");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["group"] = inputDir + it->second; }
}
it = parameters.find("taxonomy");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["taxonomy"] = inputDir + it->second; }
}
it = parameters.find("count");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["count"] = inputDir + it->second; }
}
it = parameters.find("fastq");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["fastq"] = inputDir + it->second; }
}
}
//check for required parameters
fastafile = validParameter.validFile(parameters, "fasta");
if (fastafile == "not open") { abort = true; }
else if (fastafile == "not found") { fastafile = ""; }
else { current->setFastaFile(fastafile); }
namefile = validParameter.validFile(parameters, "name");
if (namefile == "not open") { abort = true; }
else if (namefile == "not found") { namefile = ""; }
else { current->setNameFile(namefile); }
groupfile = validParameter.validFile(parameters, "group");
if (groupfile == "not open") { abort = true; }
else if (groupfile == "not found") { groupfile = ""; }
else { current->setGroupFile(groupfile); }
alignfile = validParameter.validFile(parameters, "alignreport");
if (alignfile == "not open") { abort = true; }
else if (alignfile == "not found") { alignfile = ""; }
listfile = validParameter.validFile(parameters, "list");
if (listfile == "not open") { abort = true; }
else if (listfile == "not found") { listfile = ""; }
else { current->setListFile(listfile); }
taxfile = validParameter.validFile(parameters, "taxonomy");
if (taxfile == "not open") { abort = true; }
else if (taxfile == "not found") { taxfile = ""; }
else { current->setTaxonomyFile(taxfile); }
countfile = validParameter.validFile(parameters, "count");
if (countfile == "not open") { abort = true; }
else if (countfile == "not found") { countfile = ""; }
else { current->setCountFile(countfile); }
fastqfile = validParameter.validFile(parameters, "fastq");
if (fastqfile == "not open") { abort = true; }
else if (fastqfile == "not found") { fastqfile = ""; }
if ((fastqfile == "") && (countfile == "") && (fastafile == "") && (namefile == "") && (listfile == "") && (groupfile == "") && (alignfile == "") && (taxfile == "")) { m->mothurOut("You must provide a file."); m->mothurOutEndLine(); abort = true; }
bool formatFound = true;
format = validParameter.valid(parameters, "format"); if (format == "not found"){ formatFound = false; format = "illumina1.8+"; }
if ((format != "sanger") && (format != "illumina") && (format != "illumina1.8+") && (format != "solexa")) {
m->mothurOut(format + " is not a valid format. Your format choices are sanger, solexa, illumina1.8+ and illumina, aborting." ); m->mothurOutEndLine();
abort=true;
}
int okay = 1;
if (outputDir != "") { okay++; }
if (inputDir != "") { okay++; }
if (formatFound) { okay++; }
if (parameters.size() > okay) { m->mothurOut("You may only enter one file."); m->mothurOutEndLine(); abort = true; }
}
}
catch(exception& e) {
m->errorOut(e, "ListSeqsCommand", "ListSeqsCommand");
exit(1);
}
}
//**********************************************************************************************************************
SharedCommand::SharedCommand(string option) {
try {
abort = false; calledHelp = false; pickedGroups=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();
ValidParameters validParameter;
map<string, string>::iterator it;
//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)) { abort = true; }
}
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("list");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["list"] = inputDir + it->second; }
}
it = parameters.find("group");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["group"] = inputDir + it->second; }
}
it = parameters.find("count");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["count"] = inputDir + it->second; }
}
it = parameters.find("biom");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["biom"] = inputDir + it->second; }
}
}
vector<string> tempOutNames;
outputTypes["shared"] = tempOutNames;
outputTypes["group"] = tempOutNames;
outputTypes["map"] = tempOutNames;
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; }
//check for required parameters
listfile = validParameter.validFile(parameters, "list");
if (listfile == "not open") { listfile = ""; abort = true; }
else if (listfile == "not found") { listfile = ""; }
else { current->setListFile(listfile); }
biomfile = validParameter.validFile(parameters, "biom");
if (biomfile == "not open") { biomfile = ""; abort = true; }
else if (biomfile == "not found") { biomfile = ""; }
else { current->setBiomFile(biomfile); }
ordergroupfile = validParameter.validFile(parameters, "ordergroup");
if (ordergroupfile == "not open") { abort = true; }
else if (ordergroupfile == "not found") { ordergroupfile = ""; }
groupfile = validParameter.validFile(parameters, "group");
if (groupfile == "not open") { groupfile = ""; abort = true; }
else if (groupfile == "not found") { groupfile = ""; }
else { current->setGroupFile(groupfile); }
countfile = validParameter.validFile(parameters, "count");
if (countfile == "not open") { countfile = ""; abort = true; }
else if (countfile == "not found") { countfile = ""; }
else {
current->setCountFile(countfile);
CountTable temp;
if (!temp.testGroups(countfile)) {
m->mothurOut("\n[WARNING]: Your count file does not have group info, all reads will be assigned to mothurGroup.\n");
temp.readTable(countfile, false, false); //dont read groups
map<string, int> seqs = temp.getNameMap();
CountTable newCountTable;
newCountTable.addGroup("mothurGroup");
for (map<string, int>::iterator it = seqs.begin(); it != seqs.end(); it++) {
vector<int> counts; counts.push_back(it->second);
newCountTable.push_back(it->first, counts);
}
string newCountfileName = util.getRootName(countfile) + "mothurGroup" + util.getExtension(countfile);
newCountTable.printTable(newCountfileName);
current->setCountFile(newCountfileName);
countfile = newCountfileName;
outputNames.push_back(newCountfileName);
}
}
if ((biomfile == "") && (listfile == "") && (countfile == "")) { //you must provide at least one of the following
//is there are current file available for either of these?
//give priority to list, then biom, then count
listfile = current->getListFile();
if (listfile != "") { m->mothurOut("Using " + listfile + " as input file for the list parameter.\n"); }
else {
biomfile = current->getBiomFile();
if (biomfile != "") { m->mothurOut("Using " + biomfile + " as input file for the biom parameter.\n"); }
else {
countfile = current->getCountFile();
if (countfile != "") { m->mothurOut("Using " + countfile + " as input file for the count parameter.\n"); }
else {
m->mothurOut("[ERROR]: No valid current files. You must provide a list or biom or count file before you can use the make.shared command.\n"); abort = true;
}
}
}
}
else if ((biomfile != "") && (listfile != "")) { m->mothurOut("When executing a make.shared command you must enter ONLY ONE of the following: list or biom.\n"); abort = true; }
if (listfile != "") {
if ((groupfile == "") && (countfile == "")) {
groupfile = current->getGroupFile();
if (groupfile != "") { m->mothurOut("Using " + groupfile + " as input file for the group parameter.\n"); }
else {
countfile = current->getCountFile();
if (countfile != "") { m->mothurOut("Using " + countfile + " as input file for the count parameter.\n"); }
else { m->mothurOut("[ERROR]: You need to provide a groupfile or countfile if you are going to use the list format.\n"); abort = true; }
}
}
}
string groups = validParameter.valid(parameters, "groups");
if (groups == "not found") { groups = ""; }
else {
pickedGroups=true;
util.splitAtDash(groups, Groups);
if (Groups.size() != 0) { if (Groups[0]== "all") { Groups.clear(); } }
}
//check for optional parameter and set defaults
// ...at some point should added some additional type checking...
string label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
if ((listfile == "") && (biomfile == "") && (countfile != "")) { //building a shared file from a count file, require label
if (labels.size() == 0) {
m->mothurOut("[ERROR]: You must provide a label when converting a count file to a shared file, please correct.\n"); abort = true;
}
}
}
}
catch(exception& e) {
m->errorOut(e, "SharedCommand", "SharedCommand");
exit(1);
}
}
//**********************************************************************************************************************
ClassifyOtuCommand::ClassifyOtuCommand(string option) {
try{
abort = false; calledHelp = false;
allLines = 1;
labels.clear();
//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();
ValidParameters validParameter;
map<string, string>::iterator it;
//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)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["constaxonomy"] = tempOutNames;
outputTypes["taxsummary"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("list");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["list"] = inputDir + it->second; }
}
it = parameters.find("name");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("taxonomy");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["taxonomy"] = inputDir + it->second; }
}
it = parameters.find("group");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["group"] = inputDir + it->second; }
}
it = parameters.find("count");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["count"] = inputDir + it->second; }
}
}
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = ""; }
//check for required parameters
listfile = validParameter.validFile(parameters, "list");
if (listfile == "not found") {
//if there is a current list file, use it
listfile = current->getListFile();
if (listfile != "") { m->mothurOut("Using " + listfile + " as input file for the list parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current listfile and the list parameter is required."); m->mothurOutEndLine(); abort = true; }
}
else if (listfile == "not open") { abort = true; }
else { current->setListFile(listfile); }
taxfile = validParameter.validFile(parameters, "taxonomy");
if (taxfile == "not found") { //if there is a current list file, use it
taxfile = current->getTaxonomyFile();
if (taxfile != "") { m->mothurOut("Using " + taxfile + " as input file for the taxonomy parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current taxonomy file and the taxonomy parameter is required."); m->mothurOutEndLine(); abort = true; }
}
else if (taxfile == "not open") { abort = true; }
else { current->setTaxonomyFile(taxfile); }
namefile = validParameter.validFile(parameters, "name");
if (namefile == "not open") { namefile = ""; abort = true; }
else if (namefile == "not found") { namefile = ""; }
else { current->setNameFile(namefile); }
groupfile = validParameter.validFile(parameters, "group");
if (groupfile == "not open") { abort = true; }
else if (groupfile == "not found") { groupfile = ""; }
else { current->setGroupFile(groupfile); }
countfile = validParameter.validFile(parameters, "count");
if (countfile == "not open") { countfile = ""; abort = true; }
else if (countfile == "not found") { countfile = ""; }
else { current->setCountFile(countfile); }
if ((namefile != "") && (countfile != "")) {
m->mothurOut("[ERROR]: you may only use one of the following: name or count."); m->mothurOutEndLine(); abort = true;
}
if ((groupfile != "") && (countfile != "")) {
m->mothurOut("[ERROR]: you may only use one of the following: group or count."); m->mothurOutEndLine(); abort=true;
}
//check for optional parameter and set defaults
// ...at some point should added some additional type checking...
label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; allLines = 1; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
basis = validParameter.valid(parameters, "basis");
if (basis == "not found") { basis = "otu"; }
if ((basis != "otu") && (basis != "sequence")) { m->mothurOut("Invalid option for basis. basis options are otu and sequence, using otu."); m->mothurOutEndLine(); }
string temp = validParameter.valid(parameters, "cutoff"); if (temp == "not found") { temp = "51"; }
util.mothurConvert(temp, cutoff);
temp = validParameter.valid(parameters, "threshold"); if (temp == "not found") { temp = "0"; }
util.mothurConvert(temp, threshold);
temp = validParameter.valid(parameters, "probs"); if (temp == "not found"){ temp = "true"; }
probs = util.isTrue(temp);
temp = validParameter.valid(parameters, "persample"); if (temp == "not found"){ temp = "f"; }
persample = util.isTrue(temp);
temp = validParameter.valid(parameters, "relabund"); if (temp == "not found"){ temp = "false"; }
relabund = util.isTrue(temp);
temp = validParameter.valid(parameters, "printlevel"); if (temp == "not found"){ temp = "-1"; }
util.mothurConvert(temp, printlevel);
output = validParameter.valid(parameters, "output"); if(output == "not found"){ output = "detail"; }
if ((output != "simple") && (output != "detail")) { m->mothurOut(output + " is not a valid output form. Options are simple and detail. I will use detail."); m->mothurOutEndLine(); output = "detail"; }
if ((groupfile == "") && (countfile == "")) { if (persample) { m->mothurOut("persample is only valid with a group file, or count file with group information. Setting persample=f.\n"); persample = false; }
}
if (countfile != "") {
CountTable cts;
if (!cts.testGroups(countfile)) {
if (persample) { m->mothurOut("persample is only valid with a group file, or count file with group information. Setting persample=f.\n"); persample = false; }
}
}
if ((cutoff < 51) || (cutoff > 100)) { m->mothurOut("cutoff must be above 50, and no greater than 100."); m->mothurOutEndLine(); abort = true; }
if (countfile == "") {
if (namefile == ""){
vector<string> files; files.push_back(taxfile);
if (!current->getMothurCalling()) { parser.getNameFile(files); }
}
}
}
}
catch(exception& e) {
m->errorOut(e, "ClassifyOtuCommand", "ClassifyOtuCommand");
exit(1);
}
}
TreeGroupCommand::TreeGroupCommand(string option) {
try {
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();
ValidParameters validParameter;
map<string, string>::iterator it;
//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)) { 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.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("phylip");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("column");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("name");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("count");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["count"] = inputDir + it->second; }
}
}
//check for required parameters
phylipfile = validParameter.validFile(parameters, "phylip");
if (phylipfile == "not open") { phylipfile = ""; abort = true; }
else if (phylipfile == "not found") { phylipfile = ""; }
else { inputfile = phylipfile; format = "phylip"; current->setPhylipFile(phylipfile); }
columnfile = validParameter.validFile(parameters, "column");
if (columnfile == "not open") { columnfile = ""; abort = true; }
else if (columnfile == "not found") { columnfile = ""; }
else { inputfile = columnfile; format = "column"; current->setColumnFile(columnfile); }
sharedfile = validParameter.validFile(parameters, "shared");
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") { sharedfile = ""; }
else { inputfile = sharedfile; format = "sharedfile"; current->setSharedFile(sharedfile); }
namefile = validParameter.validFile(parameters, "name");
if (namefile == "not open") { abort = true; }
else if (namefile == "not found") { namefile = ""; }
else { current->setNameFile(namefile); }
countfile = validParameter.validFile(parameters, "count");
if (countfile == "not open") { abort = true; countfile = ""; }
else if (countfile == "not found") { countfile = ""; }
else { current->setCountFile(countfile); }
if ((phylipfile == "") && (columnfile == "") && (sharedfile == "")) {
//is there are current file available for either of these?
//give priority to shared, then column, then phylip
sharedfile = current->getSharedFile();
if (sharedfile != "") { inputfile = sharedfile; format = "sharedfile"; m->mothurOut("Using " + sharedfile + " as input file for the shared parameter.\n"); }
else {
columnfile = current->getColumnFile();
if (columnfile != "") { inputfile = columnfile; format = "column"; m->mothurOut("Using " + columnfile + " as input file for the column parameter.\n"); }
else {
phylipfile = current->getPhylipFile();
if (phylipfile != "") { inputfile = phylipfile; format = "phylip"; m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter.\n"); }
else {
m->mothurOut("No valid current files. You must provide a shared, phylip or column file.\n");
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.\n"); abort = true; }
if (columnfile != "") {
if ((namefile == "") && (countfile == "")){
namefile = current->getNameFile();
if (namefile != "") { m->mothurOut("Using " + namefile + " as input file for the name parameter.\n"); }
else {
countfile = current->getCountFile();
if (countfile != "") { m->mothurOut("Using " + countfile + " as input file for the count parameter.\n"); }
else {
m->mothurOut("You need to provide a namefile or countfile if you are going to use the column format.\n");
abort = true;
}
}
}
}
//check for optional parameter and set defaults
// ...at some point should added some additional type checking...
label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
groups = validParameter.valid(parameters, "groups");
if (groups == "not found") { groups = ""; }
else {
util.splitAtDash(groups, Groups);
if (Groups.size() != 0) { if (Groups[0]== "all") { Groups.clear(); } }
}
calc = validParameter.valid(parameters, "calc");
if (calc == "not found") { calc = "jclass-thetayc"; }
else {
if (calc == "default") { calc = "jclass-thetayc"; }
}
util.splitAtDash(calc, Estimators);
if (util.inUsersGroups("citation", Estimators)) {
ValidCalculators validCalc; validCalc.printCitations(Estimators);
//remove citation from list of calcs
for (int i = 0; i < Estimators.size(); i++) { if (Estimators[i] == "citation") { Estimators.erase(Estimators.begin()+i); break; } }
}
string temp;
temp = validParameter.valid(parameters, "precision"); if (temp == "not found") { temp = "100"; }
util.mothurConvert(temp, precision);
temp = validParameter.valid(parameters, "cutoff"); if (temp == "not found") { temp = "10"; }
util.mothurConvert(temp, cutoff);
cutoff += (5 / (precision * 10.0));
temp = validParameter.valid(parameters, "processors"); if (temp == "not found"){ temp = current->getProcessors(); }
processors = current->setProcessors(temp);
temp = validParameter.valid(parameters, "iters"); if (temp == "not found") { temp = "1000"; }
util.mothurConvert(temp, iters);
temp = validParameter.valid(parameters, "subsample"); if (temp == "not found") { temp = "F"; }
if (util.isNumeric1(temp)) { util.mothurConvert(temp, subsampleSize); subsample = true; }
else {
if (util.isTrue(temp)) { subsample = true; subsampleSize = -1; } //we will set it to smallest group later
else { subsample = false; }
}
if (!subsample) { iters = 1; }
temp = validParameter.valid(parameters, "withreplacement"); if (temp == "not found"){ temp = "f"; }
withReplacement = util.isTrue(temp);
if (subsample && (format != "sharedfile")) { m->mothurOut("[ERROR]: the subsample parameter can only be used with a shared file.\n"); abort=true; }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){
outputDir = "";
outputDir += util.hasPath(inputfile); //if user entered a file with a path then preserve it
}
}
}
catch(exception& e) {
m->errorOut(e, "TreeGroupCommand", "TreeGroupCommand");
exit(1);
}
}
PCOACommand::PCOACommand(string option) {
try {
abort = false; calledHelp = false;
//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();
ValidParameters validParameter;
map<string, string>::iterator it;
//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)) { abort = true; }
}
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("phylip");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["pcoa"] = tempOutNames;
outputTypes["loadings"] = tempOutNames;
//required parameters
phylipfile = validParameter.validFile(parameters, "phylip");
if (phylipfile == "not open") { abort = true; }
else if (phylipfile == "not found") {
//if there is a current phylip file, use it
phylipfile = current->getPhylipFile();
if (phylipfile != "") { m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current phylip file and the phylip parameter is required."); m->mothurOutEndLine(); abort = true; }
}else { current->setPhylipFile(phylipfile); }
filename = phylipfile;
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){
outputDir = "";
outputDir += util.hasPath(phylipfile); //if user entered a file with a path then preserve it
}
string temp = validParameter.valid(parameters, "metric"); if (temp == "not found"){ temp = "T"; }
metric = util.isTrue(temp);
}
}
catch(exception& e) {
m->errorOut(e, "PCOACommand", "PCOACommand");
exit(1);
}
}
//**********************************************************************************************************************
KruskalWallisCommand::KruskalWallisCommand(string option) {
try {
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 {
//valid paramters for this command
vector<string> myArray = setParameters();
OptionParser parser(option);
map<string,string> parameters = parser.getParameters();
ValidParameters validParameter;
map<string,string>::iterator it;
//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)) { abort = true; }
}
vector<string> tempOutNames;
outputTypes["kruskall-wallis"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("design");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["desing"] = inputDir + it->second; }
}
it = parameters.find("shared");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
}
//get shared file, it is required
sharedfile = validParameter.validFile(parameters, "shared");
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") {
//if there is a current shared file, use it
sharedfile = current->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 { current->setSharedFile(sharedfile); }
//get shared file, it is required
designfile = validParameter.validFile(parameters, "design");
if (designfile == "not open") { designfile = ""; abort = true; }
else if (designfile == "not found") {
//if there is a current shared file, use it
designfile = current->getDesignFile();
if (designfile != "") { m->mothurOut("Using " + designfile + " as input file for the design parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current design file and the design parameter is required."); m->mothurOutEndLine(); abort = true; }
}else { current->setDesignFile(designfile); }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){
outputDir = util.hasPath(sharedfile); //if user entered a file with a path then preserve it
}
string label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
mclass = validParameter.valid(parameters, "class");
if (mclass == "not found") { mclass = ""; }
}
}
catch(exception& e) {
m->errorOut(e, "KruskalWallisCommand", "KruskalWallisCommand");
exit(1);
}
}
//**********************************************************************************************************************
RareFactCommand::RareFactCommand(string option) {
try {
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)) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["rarefaction"] = tempOutNames;
outputTypes["r_chao"] = tempOutNames;
outputTypes["r_ace"] = tempOutNames;
outputTypes["r_jack"] = tempOutNames;
outputTypes["r_shannon"] = tempOutNames;
outputTypes["r_shannoneven"] = tempOutNames;
outputTypes["r_shannonrange"] = tempOutNames;
outputTypes["r_heip"] = tempOutNames;
outputTypes["r_smithwilson"] = tempOutNames;
outputTypes["r_npshannon"] = tempOutNames;
outputTypes["r_simpson"] = tempOutNames;
outputTypes["r_simpsoneven"] = tempOutNames;
outputTypes["r_invsimpson"] = tempOutNames;
outputTypes["r_bootstrap"] = tempOutNames;
outputTypes["r_coverage"] = tempOutNames;
outputTypes["r_nseqs"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.valid(parameters, "inputdir");
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("shared");
//user has given a template file
if(it != parameters.end()){
path = util.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; }
}
it = parameters.find("rabund");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["rabund"] = inputDir + it->second; }
}
it = parameters.find("sabund");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["sabund"] = inputDir + it->second; }
}
it = parameters.find("list");
//user has given a template file
if(it != parameters.end()){
path = util.hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["list"] = inputDir + it->second; }
}
}
//check for required parameters
listfile = validParameter.validFile(parameters, "list");
if (listfile == "not open") { listfile = ""; abort = true; }
else if (listfile == "not found") { listfile = ""; }
else { format = "list"; inputfile = listfile; current->setListFile(listfile); }
sabundfile = validParameter.validFile(parameters, "sabund");
if (sabundfile == "not open") { sabundfile = ""; abort = true; }
else if (sabundfile == "not found") { sabundfile = ""; }
else { format = "sabund"; inputfile = sabundfile; current->setSabundFile(sabundfile); }
rabundfile = validParameter.validFile(parameters, "rabund");
if (rabundfile == "not open") { rabundfile = ""; abort = true; }
else if (rabundfile == "not found") { rabundfile = ""; }
else { format = "rabund"; inputfile = rabundfile; current->setRabundFile(rabundfile); }
sharedfile = validParameter.validFile(parameters, "shared");
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") { sharedfile = ""; }
else { format = "sharedfile"; inputfile = sharedfile; current->setSharedFile(sharedfile); }
if ((sharedfile == "") && (listfile == "") && (rabundfile == "") && (sabundfile == "")) {
//is there are current file available for any of these?
//give priority to shared, then list, then rabund, then sabund
//if there is a current shared file, use it
sharedfile = current->getSharedFile();
if (sharedfile != "") { inputfile = sharedfile; format = "sharedfile"; m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); }
else {
listfile = current->getListFile();
if (listfile != "") { inputfile = listfile; format = "list"; m->mothurOut("Using " + listfile + " as input file for the list parameter."); m->mothurOutEndLine(); }
else {
rabundfile = current->getRabundFile();
if (rabundfile != "") { inputfile = rabundfile; format = "rabund"; m->mothurOut("Using " + rabundfile + " as input file for the rabund parameter."); m->mothurOutEndLine(); }
else {
sabundfile = current->getSabundFile();
if (sabundfile != "") { inputfile = sabundfile; format = "sabund"; m->mothurOut("Using " + sabundfile + " as input file for the sabund parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("No valid current files. You must provide a list, sabund, rabund or shared file before you can use the collect.single command."); m->mothurOutEndLine();
abort = true;
}
}
}
}
}
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.valid(parameters, "outputdir"); if (outputDir == "not found"){ outputDir = util.hasPath(inputfile); }
//check for optional parameter and set defaults
// ...at some point should added some additional type checking...
label = validParameter.valid(parameters, "label");
if (label == "not found") { label = ""; }
else {
if(label != "all") { util.splitAtDash(label, labels); allLines = 0; }
else { allLines = 1; }
}
calc = validParameter.valid(parameters, "calc");
if (calc == "not found") { calc = "sobs"; }
else {
if (calc == "default") { calc = "sobs"; }
}
util.splitAtDash(calc, Estimators);
if (util.inUsersGroups("citation", Estimators)) {
ValidCalculators validCalc; validCalc.printCitations(Estimators);
//remove citation from list of calcs
for (int i = 0; i < Estimators.size(); i++) { if (Estimators[i] == "citation") { Estimators.erase(Estimators.begin()+i); break; } }
}
string temp;
temp = validParameter.valid(parameters, "freq"); if (temp == "not found") { temp = "100"; }
util.mothurConvert(temp, freq);
temp = validParameter.valid(parameters, "abund"); if (temp == "not found") { temp = "10"; }
util.mothurConvert(temp, abund);
temp = validParameter.valid(parameters, "iters"); if (temp == "not found") { temp = "1000"; }
util.mothurConvert(temp, nIters);
temp = validParameter.valid(parameters, "alpha"); if (temp == "not found") { temp = "1"; }
util.mothurConvert(temp, alpha);
if ((alpha != 0) && (alpha != 1) && (alpha != 2)) { m->mothurOut("[ERROR]: Not a valid alpha value. Valid values are 0, 1 and 2."); m->mothurOutEndLine(); abort=true; }
temp = validParameter.valid(parameters, "groupmode"); if (temp == "not found") { temp = "T"; }
groupMode = util.isTrue(temp);
temp = validParameter.valid(parameters, "processors"); if (temp == "not found"){ temp = current->getProcessors(); }
processors = current->setProcessors(temp);
string groups = validParameter.valid(parameters, "groups");
if (groups == "not found") { groups = ""; }
else { util.splitAtDash(groups, Groups);
if (Groups.size() != 0) { if (Groups[0]== "all") { Groups.clear(); } } }
}
}
catch(exception& e) {
m->errorOut(e, "RareFactCommand", "RareFactCommand");
exit(1);
}
}
