//**********************************************************************************************************************
string SummarySharedCommand::getHelpString(){
try {
string helpString = "";
ValidCalculators validCalculator;
helpString += "The summary.shared command parameters are shared, label, calc, distance, processors, subsample, iters and all. shared is required if there is no current sharedfile.\n";
helpString += "The summary.shared command should be in the following format: \n";
helpString += "summary.shared(label=yourLabel, calc=yourEstimators, groups=yourGroups).\n";
helpString += "Example summary.shared(label=unique-.01-.03, groups=B-C, calc=sharedchao-sharedace-jabund-sorensonabund-jclass-sorclass-jest-sorest-thetayc-thetan).\n";
helpString += validCalculator.printCalc("sharedsummary");
helpString += "The iters parameter allows you to choose the number of times you would like to run the subsample.\n";
helpString += "The subsample parameter allows you to enter the size pergroup of the sample or you can set subsample=T and mothur will use the size of your smallest group.\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 += "The default value for calc is sharedsobs-sharedchao-sharedace-jabund-sorensonabund-jclass-sorclass-jest-sorest-thetayc-thetan\n";
helpString += "The default value for groups is all the groups in your groupfile.\n";
helpString += "The distance parameter allows you to indicate you would like a distance file created for each calculator for each label, default=f.\n";
helpString += "The label parameter is used to analyze specific labels in your input.\n";
helpString += "The all parameter is used to specify if you want the estimate of all your groups together. This estimate can only be made for sharedsobs and sharedchao calculators. The default is false.\n";
helpString += "If you use sharedchao and run into memory issues, set all to false. \n";
helpString += "The groups parameter allows you to specify which of the groups in your groupfile you would like analyzed. You must enter at least 2 valid groups.\n";
helpString += "Note: No spaces between parameter labels (i.e. label), '=' and parameters (i.e.yourLabel).\n";
return helpString;
}
catch(exception& e) {
m->errorOut(e, "SummarySharedCommand", "getHelpString");
exit(1);
}
}
//**********************************************************************************************************************
string MatrixOutputCommand::getHelpString(){
try {
string helpString = "";
ValidCalculators validCalculator;
helpString += "The dist.shared command parameters are shared, groups, calc, output, processors, subsample, iters, mode, 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 iters parameter allows you to choose the number of times you would like to run the subsample.\n";
helpString += "The subsample parameter allows you to enter the size pergroup of the sample or you can set subsample=T and mothur will use the size of your smallest group.\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, column and square. The default is lt.\n";
helpString += "The mode parameter allows you to specify if you want the average or the median values reported when subsampling. Options are average, and median. The default is average.\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);
}
}
//**********************************************************************************************************************
string TreeGroupCommand::getHelpString(){
try {
string helpString = "";
ValidCalculators validCalculator;
helpString += "The tree.shared command creates a .tre to represent the similiarity between groups or sequences.\n";
helpString += "The tree.shared command parameters are shared, groups, calc, phylip, column, name, cutoff, precision, processors, subsample, iters and label.\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 allow you to select what distance levels you would like trees created for, and are also separated by dashes.\n";
helpString += "The phylip or column parameter are required if you do not provide a sharedfile, and only one may be used. If you use a column file the name filename is required. \n";
helpString += "If you do not provide a cutoff value 10.00 is assumed. If you do not provide a precision value then 100 is assumed.\n";
helpString += "The tree.shared command should be in the following format: tree.shared(groups=yourGroups, calc=yourCalcs, label=yourLabels).\n";
helpString += "The iters parameter allows you to choose the number of times you would like to run the subsample.\n";
helpString += "The subsample parameter allows you to enter the size pergroup of the sample or you can set subsample=T and mothur will use the size of your smallest group. The subsample parameter may only be used with a shared file.\n";
helpString += "Example tree.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-thetayc.\n";
helpString += "The tree.shared command outputs a .tre file for each calculator you specify at each distance you choose.\n";
helpString += validCalculator.printCalc("treegroup");
helpString += "Or the tree.shared command can be in the following format: tree.shared(phylip=yourPhylipFile).\n";
helpString += "Example tree.shared(phylip=abrecovery.dist).\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, "TreeGroupCommand", "getHelpString");
exit(1);
}
}
//**********************************************************************************************************************
string RareFactCommand::getHelpString(){
try {
ValidCalculators validCalculator;
string helpString = "";
helpString += "The rarefaction.single command parameters are list, sabund, rabund, shared, label, iters, freq, calc, groupmode, groups, processors and abund. list, sabund, rabund or shared is required unless you have a valid current file. \n";
helpString += "The freq parameter is used indicate when to output your data, by default it is set to 100. But you can set it to a percentage of the number of sequence. For example freq=0.10, means 10%. \n";
helpString += "The rarefaction.single command should be in the following format: \n";
helpString += "rarefaction.single(label=yourLabel, iters=yourIters, freq=yourFreq, calc=yourEstimators).\n";
helpString += "Example rarefaction.single(label=unique-.01-.03, iters=10000, freq=10, calc=sobs-rchao-race-rjack-rbootstrap-rshannon-rnpshannon-rsimpson).\n";
helpString += "The default values for iters is 1000, freq is 100, and calc is rarefaction which calculates the rarefaction curve for the observed richness.\n";
helpString += "The alpha parameter is used to set the alpha value for the shannonrange calculator.\n";
validCalculator.printCalc("rarefaction");
helpString += "If you are running rarefaction.single with a shared file and would like your results collated in one file, set groupmode=t. (Default=true).\n";
helpString += "The label parameter is used to analyze specific labels in your input.\n";
return helpString;
}
catch(exception& e) {
m->errorOut(e, "RareFactCommand", "getHelpString");
exit(1);
}
}
//**********************************************************************************************************************
string SummaryCommand::getHelpString() {
try {
string helpString = "";
ValidCalculators validCalculator;
helpString += "The summary.single command parameters are list, sabund, rabund, shared, subsample, iters, label, calc, abund and groupmode. list, sabund, rabund or shared is required unless you have a valid current file.\n";
helpString += "The summary.single command should be in the following format: \n";
helpString += "summary.single(label=yourLabel, calc=yourEstimators).\n";
helpString += "Example summary.single(label=unique-.01-.03, calc=sobs-chao-ace-jack-bootstrap-shannon-npshannon-simpson).\n";
helpString += validCalculator.printCalc("summary");
helpString += "The subsample parameter allows you to enter the size of the sample or you can set subsample=T and mothur will use the size of your smallest group in the case of a shared file. With a list, sabund or rabund file you must provide a subsample size.\n";
helpString += "The iters parameter allows you to choose the number of times you would like to run the subsample.\n";
helpString += "The default value calc is sobs-chao-ace-jack-shannon-npshannon-simpson\n";
helpString += "If you are running summary.single with a shared file and would like your summary results collated in one file, set groupmode=t. (Default=true).\n";
helpString += "The label parameter is used to analyze specific labels in your input.\n";
helpString += "Note: No spaces between parameter labels (i.e. label), '=' and parameters (i.e.yourLabels).\n";
return helpString;
}
catch(exception& e) {
m->errorOut(e, "SummaryCommand", "getHelpString");
exit(1);
}
}
//**********************************************************************************************************************
string CollectSharedCommand::getHelpString(){
try {
string helpString = "";
ValidCalculators validCalculator;
helpString += "The collect.shared command parameters are shared, label, freq, calc and groups. shared is required if there is no current sharedfile. \n";
helpString += "The collect.shared command should be in the following format: \n";
helpString += "collect.shared(label=yourLabel, freq=yourFreq, calc=yourEstimators, groups=yourGroups).\n";
helpString += "Example collect.shared(label=unique-.01-.03, freq=10, groups=B-C, calc=sharedchao-sharedace-jabund-sorensonabund-jclass-sorclass-jest-sorest-thetayc-thetan).\n";
helpString += "The default values for freq is 100 and calc are sharedsobs-sharedchao-sharedace-jabund-sorensonabund-jclass-sorclass-jest-sorest-thetayc-thetan.\n";
helpString += "The default value for groups is all the groups in your groupfile.\n";
helpString += "The freq parameter is used indicate when to output your data, by default it is set to 100. But you can set it to a percentage of the number of sequence. For example freq=0.10, means 10%. \n";
helpString += validCalculator.printCalc("shared");
helpString += "The label parameter is used to analyze specific labels in your input.\n";
helpString += "The all parameter is used to specify if you want the estimate of all your groups together. This estimate can only be made for sharedsobs and sharedchao calculators. The default is false.\n";
helpString += "If you use sharedchao and run into memory issues, set all to false. \n";
helpString += "The groups parameter allows you to specify which of the groups in your groupfile you would like analyzed. You must enter at least 2 valid groups.\n";
helpString += "Note: No spaces between parameter labels (i.e. list), '=' and parameters (i.e.yourListfile).\n";
return helpString;
}
catch(exception& e) {
m->errorOut(e, "CollectSharedCommand", "getHelpString");
exit(1);
}
}
MatrixOutputCommand::MatrixOutputCommand(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) != 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; }
else { m->setSharedFile(sharedfile); }
//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") && (output != "column")) { m->mothurOut(output + " is not a valid output form. Options are lt, column and square. I will use lt."); m->mothurOutEndLine(); output = "lt"; }
mode = validParameter.validFile(parameters, "mode", false); if(mode == "not found"){ mode = "average"; }
if ((mode != "average") && (mode != "median")) { m->mothurOut(mode + " is not a valid mode. Options are average and medina. I will use average."); m->mothurOutEndLine(); output = "average"; }
groups = validParameter.validFile(parameters, "groups", false);
if (groups == "not found") { groups = ""; }
else {
m->splitAtDash(groups, Groups);
m->setGroups(Groups);
}
string temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); }
m->setProcessors(temp);
m->mothurConvert(temp, processors);
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 (m->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; } }
}
temp = validParameter.validFile(parameters, "iters", false); if (temp == "not found") { temp = "1000"; }
m->mothurConvert(temp, iters);
temp = validParameter.validFile(parameters, "subsample", false); if (temp == "not found") { temp = "F"; }
if (m->isNumeric1(temp)) { m->mothurConvert(temp, subsampleSize); subsample = true; }
else {
if (m->isTrue(temp)) { subsample = true; subsampleSize = -1; } //we will set it to smallest group later
else { subsample = false; }
}
if (subsample == false) { iters = 0; }
if (abort == false) {
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());
}else if (Estimators[i] == "jsd") {
matrixCalculators.push_back(new JSD());
}else if (Estimators[i] == "rjsd") {
matrixCalculators.push_back(new RJSD());
}
}
}
}
}
}
catch(exception& e) {
m->errorOut(e, "MatrixOutputCommand", "MatrixOutputCommand");
exit(1);
}
}
/////// need to fix to work with calcs and sequencedb
int DistanceCommand::driver(int startLine, int endLine, string dFileName, float cutoff){
try {
ValidCalculators validCalculator;
Dist* distCalculator;
if (m->isTrue(countends) == true) {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap") { distCalculator = new eachGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapDist(); }
}
}
}else {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap"){ distCalculator = new eachGapIgnoreTermGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapIgnoreTermGapDist(); }
}
}
}
int startTime = time(NULL);
//column file
ofstream outFile(dFileName.c_str(), ios::trunc);
outFile.setf(ios::fixed, ios::showpoint);
outFile << setprecision(4);
if((output == "lt") && startLine == 0){ outFile << alignDB.getNumSeqs() << endl; }
for(int i=startLine;i<endLine;i++){
if(output == "lt") {
string name = alignDB.get(i).getName();
if (name.length() < 10) { //pad with spaces to make compatible
while (name.length() < 10) { name += " "; }
}
outFile << name;
}
for(int j=0;j<i;j++){
if (m->control_pressed) { delete distCalculator; outFile.close(); return 0; }
//if there was a column file given and we are appending, we don't want to calculate the distances that are already in the column file
//the alignDB contains the new sequences and then the old, so if i an oldsequence and j is an old sequence then break out of this loop
if ((i >= numNewFasta) && (j >= numNewFasta)) { break; }
distCalculator->calcDist(alignDB.get(i), alignDB.get(j));
double dist = distCalculator->getDist();
if(dist <= cutoff){
if (output == "column") { outFile << alignDB.get(i).getName() << ' ' << alignDB.get(j).getName() << ' ' << dist << endl; }
}
if (output == "lt") { outFile << '\t' << dist; }
}
if (output == "lt") { outFile << endl; }
if(i % 100 == 0){
m->mothurOutJustToScreen(toString(i) + "\t" + toString(time(NULL) - startTime)+"\n");
}
}
m->mothurOutJustToScreen(toString(endLine-1) + "\t" + toString(time(NULL) - startTime)+"\n");
outFile.close();
delete distCalculator;
return 1;
}
catch(exception& e) {
m->errorOut(e, "DistanceCommand", "driver");
exit(1);
}
}
//**********************************************************************************************************************
CollectSharedCommand::CollectSharedCommand(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) != true) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["sharedchao"] = tempOutNames;
outputTypes["sharedsobs"] = tempOutNames;
outputTypes["sharedace"] = tempOutNames;
outputTypes["jabund"] = tempOutNames;
outputTypes["sorabund"] = tempOutNames;
outputTypes["jclass"] = tempOutNames;
outputTypes["sorclass"] = tempOutNames;
outputTypes["jest"] = tempOutNames;
outputTypes["sorest"] = tempOutNames;
outputTypes["thetayc"] = tempOutNames;
outputTypes["thetan"] = tempOutNames;
outputTypes["kstest"] = tempOutNames;
outputTypes["whittaker"] = tempOutNames;
outputTypes["sharednseqs"] = tempOutNames;
outputTypes["ochiai"] = tempOutNames;
outputTypes["anderberg"] = tempOutNames;
outputTypes["kulczynski"] = tempOutNames;
outputTypes["kulczynskicody"] = tempOutNames;
outputTypes["lennon"] = tempOutNames;
outputTypes["morisitahorn"] = tempOutNames;
outputTypes["braycurtis"] = tempOutNames;
outputTypes["odum"] = tempOutNames;
outputTypes["canberra"] = tempOutNames;
outputTypes["structeuclidean"] = tempOutNames;
outputTypes["structchord"] = tempOutNames;
outputTypes["hellinger"] = tempOutNames;
outputTypes["manhattan"] = tempOutNames;
outputTypes["structpearson"] = tempOutNames;
outputTypes["soergel"] = tempOutNames;
outputTypes["spearman"] = tempOutNames;
outputTypes["structkulczynski"] = tempOutNames;
outputTypes["speciesprofile"] = tempOutNames;
outputTypes["structchi2"] = tempOutNames;
outputTypes["hamming"] = tempOutNames;
outputTypes["gower"] = tempOutNames;
outputTypes["memchi2"] = tempOutNames;
outputTypes["memchord"] = tempOutNames;
outputTypes["memeuclidean"] = tempOutNames;
outputTypes["mempearson"] = 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; }
}
}
//get shared file
sharedfile = validParameter.validFile(parameters, "shared", true);
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else 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 { m->setSharedFile(sharedfile); }
//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 = m->hasPath(sharedfile); }
//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; }
}
calc = validParameter.validFile(parameters, "calc", false);
if (calc == "not found") { calc = "sharedsobs-sharedchao-sharedace-jabund-sorabund-jclass-sorclass-jest-sorest-thetayc-thetan"; }
else {
if (calc == "default") { calc = "sharedsobs-sharedchao-sharedace-jabund-sorabund-jclass-sorclass-jest-sorest-thetayc-thetan"; }
}
m->splitAtDash(calc, Estimators);
if (m->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; } }
}
groups = validParameter.validFile(parameters, "groups", false);
if (groups == "not found") { groups = ""; }
else {
m->splitAtDash(groups, Groups);
}
m->setGroups(Groups);
string temp;
temp = validParameter.validFile(parameters, "freq", false); if (temp == "not found") { temp = "100"; }
m->mothurConvert(temp, freq);
temp = validParameter.validFile(parameters, "all", false); if (temp == "not found") { temp = "false"; }
all = m->isTrue(temp);
if (abort == false) {
string fileNameRoot = outputDir + m->getRootName(m->getSimpleName(sharedfile));
ValidCalculators validCalculator;
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("shared", Estimators[i]) == true) {
if (Estimators[i] == "sharedchao") {
cDisplays.push_back(new CollectDisplay(new SharedChao1(), new SharedOneColumnFile(fileNameRoot+"shared.chao")));
outputNames.push_back(fileNameRoot+"shared.chao"); outputTypes["sharedchao"].push_back(fileNameRoot+"shared.chao");
}else if (Estimators[i] == "sharedsobs") {
cDisplays.push_back(new CollectDisplay(new SharedSobsCS(), new SharedOneColumnFile(fileNameRoot+"shared.sobs")));
outputNames.push_back(fileNameRoot+"shared.sobs"); outputTypes["sharedsobs"].push_back(fileNameRoot+"shared.sobs");
}else if (Estimators[i] == "sharedace") {
cDisplays.push_back(new CollectDisplay(new SharedAce(), new SharedOneColumnFile(fileNameRoot+"shared.ace")));
outputNames.push_back(fileNameRoot+"shared.ace"); outputTypes["sharedace"].push_back(fileNameRoot+"shared.ace");
}else if (Estimators[i] == "jabund") {
cDisplays.push_back(new CollectDisplay(new JAbund(), new SharedOneColumnFile(fileNameRoot+"jabund")));
outputNames.push_back(fileNameRoot+"jabund"); outputTypes["jabund"].push_back(fileNameRoot+"jabund");
}else if (Estimators[i] == "sorabund") {
cDisplays.push_back(new CollectDisplay(new SorAbund(), new SharedOneColumnFile(fileNameRoot+"sorabund")));
outputNames.push_back(fileNameRoot+"sorabund"); outputTypes["sorabund"].push_back(fileNameRoot+"sorabund");
}else if (Estimators[i] == "jclass") {
cDisplays.push_back(new CollectDisplay(new Jclass(), new SharedOneColumnFile(fileNameRoot+"jclass")));
outputNames.push_back(fileNameRoot+"jclass"); outputTypes["jclass"].push_back(fileNameRoot+"jclass");
}else if (Estimators[i] == "sorclass") {
cDisplays.push_back(new CollectDisplay(new SorClass(), new SharedOneColumnFile(fileNameRoot+"sorclass")));
outputNames.push_back(fileNameRoot+"sorclass"); outputTypes["sorclass"].push_back(fileNameRoot+"sorclass");
}else if (Estimators[i] == "jest") {
cDisplays.push_back(new CollectDisplay(new Jest(), new SharedOneColumnFile(fileNameRoot+"jest")));
outputNames.push_back(fileNameRoot+"jest"); outputTypes["jest"].push_back(fileNameRoot+"jest");
}else if (Estimators[i] == "sorest") {
cDisplays.push_back(new CollectDisplay(new SorEst(), new SharedOneColumnFile(fileNameRoot+"sorest")));
outputNames.push_back(fileNameRoot+"sorest"); outputTypes["sorest"].push_back(fileNameRoot+"sorest");
}else if (Estimators[i] == "thetayc") {
cDisplays.push_back(new CollectDisplay(new ThetaYC(), new SharedOneColumnFile(fileNameRoot+"thetayc")));
outputNames.push_back(fileNameRoot+"thetayc"); outputTypes["thetayc"].push_back(fileNameRoot+"thetayc");
}else if (Estimators[i] == "thetan") {
cDisplays.push_back(new CollectDisplay(new ThetaN(), new SharedOneColumnFile(fileNameRoot+"thetan")));
outputNames.push_back(fileNameRoot+"thetan"); outputTypes["thetan"].push_back(fileNameRoot+"thetan");
}else if (Estimators[i] == "kstest") {
cDisplays.push_back(new CollectDisplay(new KSTest(), new SharedOneColumnFile(fileNameRoot+"kstest")));
outputNames.push_back(fileNameRoot+"kstest"); outputTypes["kstest"].push_back(fileNameRoot+"kstest");
}else if (Estimators[i] == "whittaker") {
cDisplays.push_back(new CollectDisplay(new Whittaker(), new SharedOneColumnFile(fileNameRoot+"whittaker")));
outputNames.push_back(fileNameRoot+"whittaker"); outputTypes["whittaker"].push_back(fileNameRoot+"whittaker");
}else if (Estimators[i] == "sharednseqs") {
cDisplays.push_back(new CollectDisplay(new SharedNSeqs(), new SharedOneColumnFile(fileNameRoot+"shared.nseqs")));
outputNames.push_back(fileNameRoot+"shared.nseqs"); outputTypes["shared.nseqs"].push_back(fileNameRoot+"shared.nseqs");
}else if (Estimators[i] == "ochiai") {
cDisplays.push_back(new CollectDisplay(new Ochiai(), new SharedOneColumnFile(fileNameRoot+"ochiai")));
outputNames.push_back(fileNameRoot+"ochiai"); outputTypes["ochiai"].push_back(fileNameRoot+"ochiai");
}else if (Estimators[i] == "anderberg") {
cDisplays.push_back(new CollectDisplay(new Anderberg(), new SharedOneColumnFile(fileNameRoot+"anderberg")));
outputNames.push_back(fileNameRoot+"anderberg"); outputTypes["anderberg"].push_back(fileNameRoot+"anderberg");
}else if (Estimators[i] == "kulczynski") {
cDisplays.push_back(new CollectDisplay(new Kulczynski(), new SharedOneColumnFile(fileNameRoot+"kulczynski")));
outputNames.push_back(fileNameRoot+"kulczynski"); outputTypes["kulczynski"].push_back(fileNameRoot+"kulczynski");
}else if (Estimators[i] == "kulczynskicody") {
cDisplays.push_back(new CollectDisplay(new KulczynskiCody(), new SharedOneColumnFile(fileNameRoot+"kulczynskicody")));
outputNames.push_back(fileNameRoot+"kulczynskicody"); outputTypes["kulczynskicody"].push_back(fileNameRoot+"kulczynskicody");
}else if (Estimators[i] == "lennon") {
cDisplays.push_back(new CollectDisplay(new Lennon(), new SharedOneColumnFile(fileNameRoot+"lennon")));
outputNames.push_back(fileNameRoot+"lennon"); outputTypes["lennon"].push_back(fileNameRoot+"lennon");
}else if (Estimators[i] == "morisitahorn") {
cDisplays.push_back(new CollectDisplay(new MorHorn(), new SharedOneColumnFile(fileNameRoot+"morisitahorn")));
outputNames.push_back(fileNameRoot+"morisitahorn"); outputTypes["morisitahorn"].push_back(fileNameRoot+"morisitahorn");
}else if (Estimators[i] == "braycurtis") {
cDisplays.push_back(new CollectDisplay(new BrayCurtis(), new SharedOneColumnFile(fileNameRoot+"braycurtis")));
outputNames.push_back(fileNameRoot+"braycurtis"); outputTypes["braycurtis"].push_back(fileNameRoot+"braycurtis");
}else if (Estimators[i] == "odum") {
cDisplays.push_back(new CollectDisplay(new Odum(), new SharedOneColumnFile(fileNameRoot+"odum")));
outputNames.push_back(fileNameRoot+"odum"); outputTypes["odum"].push_back(fileNameRoot+"odum");
}else if (Estimators[i] == "canberra") {
cDisplays.push_back(new CollectDisplay(new Canberra(), new SharedOneColumnFile(fileNameRoot+"canberra")));
outputNames.push_back(fileNameRoot+"canberra"); outputTypes["canberra"].push_back(fileNameRoot+"canberra");
}else if (Estimators[i] == "structeuclidean") {
cDisplays.push_back(new CollectDisplay(new StructEuclidean(), new SharedOneColumnFile(fileNameRoot+"structeuclidean")));
outputNames.push_back(fileNameRoot+"structeuclidean"); outputTypes["structeuclidean"].push_back(fileNameRoot+"structeuclidean");
}else if (Estimators[i] == "structchord") {
cDisplays.push_back(new CollectDisplay(new StructChord(), new SharedOneColumnFile(fileNameRoot+"structchord")));
outputNames.push_back(fileNameRoot+"structchord"); outputTypes["structchord"].push_back(fileNameRoot+"structchord");
}else if (Estimators[i] == "hellinger") {
cDisplays.push_back(new CollectDisplay(new Hellinger(), new SharedOneColumnFile(fileNameRoot+"hellinger")));
outputNames.push_back(fileNameRoot+"hellinger"); outputTypes["hellinger"].push_back(fileNameRoot+"hellinger");
}else if (Estimators[i] == "manhattan") {
cDisplays.push_back(new CollectDisplay(new Manhattan(), new SharedOneColumnFile(fileNameRoot+"manhattan")));
outputNames.push_back(fileNameRoot+"manhattan"); outputTypes["manhattan"].push_back(fileNameRoot+"manhattan");
}else if (Estimators[i] == "structpearson") {
cDisplays.push_back(new CollectDisplay(new StructPearson(), new SharedOneColumnFile(fileNameRoot+"structpearson")));
outputNames.push_back(fileNameRoot+"structpearson"); outputTypes["structpearson"].push_back(fileNameRoot+"structpearson");
}else if (Estimators[i] == "soergel") {
cDisplays.push_back(new CollectDisplay(new Soergel(), new SharedOneColumnFile(fileNameRoot+"soergel")));
outputNames.push_back(fileNameRoot+"soergel"); outputTypes["soergel"].push_back(fileNameRoot+"soergel");
}else if (Estimators[i] == "spearman") {
cDisplays.push_back(new CollectDisplay(new Spearman(), new SharedOneColumnFile(fileNameRoot+"spearman")));
outputNames.push_back(fileNameRoot+"spearman"); outputTypes["spearman"].push_back(fileNameRoot+"spearman");
}else if (Estimators[i] == "structkulczynski") {
cDisplays.push_back(new CollectDisplay(new StructKulczynski(), new SharedOneColumnFile(fileNameRoot+"structkulczynski")));
outputNames.push_back(fileNameRoot+"structkulczynski"); outputTypes["structkulczynski"].push_back(fileNameRoot+"structkulczynski");
}else if (Estimators[i] == "speciesprofile") {
cDisplays.push_back(new CollectDisplay(new SpeciesProfile(), new SharedOneColumnFile(fileNameRoot+"speciesprofile")));
outputNames.push_back(fileNameRoot+"speciesprofile"); outputTypes["speciesprofile"].push_back(fileNameRoot+"speciesprofile");
}else if (Estimators[i] == "hamming") {
cDisplays.push_back(new CollectDisplay(new Hamming(), new SharedOneColumnFile(fileNameRoot+"hamming")));
outputNames.push_back(fileNameRoot+"hamming"); outputTypes["hamming"].push_back(fileNameRoot+"hamming");
}else if (Estimators[i] == "structchi2") {
cDisplays.push_back(new CollectDisplay(new StructChi2(), new SharedOneColumnFile(fileNameRoot+"structchi2")));
outputNames.push_back(fileNameRoot+"structchi2"); outputTypes["structchi2"].push_back(fileNameRoot+"structchi2");
}else if (Estimators[i] == "gower") {
cDisplays.push_back(new CollectDisplay(new Gower(), new SharedOneColumnFile(fileNameRoot+"gower")));
outputNames.push_back(fileNameRoot+"gower"); outputTypes["gower"].push_back(fileNameRoot+"gower");
}else if (Estimators[i] == "memchi2") {
cDisplays.push_back(new CollectDisplay(new MemChi2(), new SharedOneColumnFile(fileNameRoot+"memchi2")));
outputNames.push_back(fileNameRoot+"memchi2"); outputTypes["memchi2"].push_back(fileNameRoot+"memchi2");
}else if (Estimators[i] == "memchord") {
cDisplays.push_back(new CollectDisplay(new MemChord(), new SharedOneColumnFile(fileNameRoot+"memchord")));
outputNames.push_back(fileNameRoot+"memchord"); outputTypes["memchord"].push_back(fileNameRoot+"memchord");
}else if (Estimators[i] == "memeuclidean") {
cDisplays.push_back(new CollectDisplay(new MemEuclidean(), new SharedOneColumnFile(fileNameRoot+"memeuclidean")));
outputNames.push_back(fileNameRoot+"memeuclidean"); outputTypes["memeuclidean"].push_back(fileNameRoot+"memeuclidean");
}else if (Estimators[i] == "mempearson") {
cDisplays.push_back(new CollectDisplay(new MemPearson(), new SharedOneColumnFile(fileNameRoot+"mempearson")));
outputNames.push_back(fileNameRoot+"mempearson"); outputTypes["mempearson"].push_back(fileNameRoot+"mempearson");
}
}
}
}
}
}
catch(exception& e) {
m->errorOut(e, "CollectSharedCommand", "CollectSharedCommand");
exit(1);
}
}
/////// need to fix to work with calcs and sequencedb
int DistanceCommand::driver(int startLine, int endLine, string dFileName, string square){
try {
ValidCalculators validCalculator;
Dist* distCalculator;
if (m->isTrue(countends) == true) {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap") { distCalculator = new eachGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapDist(); }
}
}
}else {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap"){ distCalculator = new eachGapIgnoreTermGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapIgnoreTermGapDist(); }
}
}
}
int startTime = time(NULL);
//column file
ofstream outFile(dFileName.c_str(), ios::trunc);
outFile.setf(ios::fixed, ios::showpoint);
outFile << setprecision(4);
if(startLine == 0){ outFile << alignDB.getNumSeqs() << endl; }
for(int i=startLine;i<endLine;i++){
string name = alignDB.get(i).getName();
//pad with spaces to make compatible
if (name.length() < 10) { while (name.length() < 10) { name += " "; } }
outFile << name << '\t';
for(int j=0;j<alignDB.getNumSeqs();j++){
if (m->control_pressed) { delete distCalculator; outFile.close(); return 0; }
distCalculator->calcDist(alignDB.get(i), alignDB.get(j));
double dist = distCalculator->getDist();
outFile << dist << '\t';
}
outFile << endl;
if(i % 100 == 0){
m->mothurOutJustToScreen(toString(i) + "\t" + toString(time(NULL) - startTime)+"\n");
}
}
m->mothurOutJustToScreen(toString(endLine-1) + "\t" + toString(time(NULL) - startTime)+"\n");
outFile.close();
delete distCalculator;
return 1;
}
catch(exception& e) {
m->errorOut(e, "DistanceCommand", "driver");
exit(1);
}
}
int process(treeSharedData* params) {
try{
ValidCalculators validCalculator;
vector<Calculator*> treeCalculators;
for (int i=0; i<params->Estimators.size(); i++) {
if (validCalculator.isValidCalculator("treegroup", params->Estimators[i]) ) {
if (params->Estimators[i] == "sharedsobs") {
treeCalculators.push_back(new SharedSobsCS());
}else if (params->Estimators[i] == "sharedchao") {
treeCalculators.push_back(new SharedChao1());
}else if (params->Estimators[i] == "sharedace") {
treeCalculators.push_back(new SharedAce());
}else if (params->Estimators[i] == "jabund") {
treeCalculators.push_back(new JAbund());
}else if (params->Estimators[i] == "sorabund") {
treeCalculators.push_back(new SorAbund());
}else if (params->Estimators[i] == "jclass") {
treeCalculators.push_back(new Jclass());
}else if (params->Estimators[i] == "sorclass") {
treeCalculators.push_back(new SorClass());
}else if (params->Estimators[i] == "jest") {
treeCalculators.push_back(new Jest());
}else if (params->Estimators[i] == "sorest") {
treeCalculators.push_back(new SorEst());
}else if (params->Estimators[i] == "thetayc") {
treeCalculators.push_back(new ThetaYC());
}else if (params->Estimators[i] == "thetan") {
treeCalculators.push_back(new ThetaN());
}else if (params->Estimators[i] == "kstest") {
treeCalculators.push_back(new KSTest());
}else if (params->Estimators[i] == "sharednseqs") {
treeCalculators.push_back(new SharedNSeqs());
}else if (params->Estimators[i] == "ochiai") {
treeCalculators.push_back(new Ochiai());
}else if (params->Estimators[i] == "anderberg") {
treeCalculators.push_back(new Anderberg());
}else if (params->Estimators[i] == "kulczynski") {
treeCalculators.push_back(new Kulczynski());
}else if (params->Estimators[i] == "kulczynskicody") {
treeCalculators.push_back(new KulczynskiCody());
}else if (params->Estimators[i] == "lennon") {
treeCalculators.push_back(new Lennon());
}else if (params->Estimators[i] == "morisitahorn") {
treeCalculators.push_back(new MorHorn());
}else if (params->Estimators[i] == "braycurtis") {
treeCalculators.push_back(new BrayCurtis());
}else if (params->Estimators[i] == "whittaker") {
treeCalculators.push_back(new Whittaker());
}else if (params->Estimators[i] == "odum") {
treeCalculators.push_back(new Odum());
}else if (params->Estimators[i] == "canberra") {
treeCalculators.push_back(new Canberra());
}else if (params->Estimators[i] == "structeuclidean") {
treeCalculators.push_back(new StructEuclidean());
}else if (params->Estimators[i] == "structchord") {
treeCalculators.push_back(new StructChord());
}else if (params->Estimators[i] == "hellinger") {
treeCalculators.push_back(new Hellinger());
}else if (params->Estimators[i] == "manhattan") {
treeCalculators.push_back(new Manhattan());
}else if (params->Estimators[i] == "structpearson") {
treeCalculators.push_back(new StructPearson());
}else if (params->Estimators[i] == "soergel") {
treeCalculators.push_back(new Soergel());
}else if (params->Estimators[i] == "spearman") {
treeCalculators.push_back(new Spearman());
}else if (params->Estimators[i] == "structkulczynski") {
treeCalculators.push_back(new StructKulczynski());
}else if (params->Estimators[i] == "speciesprofile") {
treeCalculators.push_back(new SpeciesProfile());
}else if (params->Estimators[i] == "hamming") {
treeCalculators.push_back(new Hamming());
}else if (params->Estimators[i] == "structchi2") {
treeCalculators.push_back(new StructChi2());
}else if (params->Estimators[i] == "gower") {
treeCalculators.push_back(new Gower());
}else if (params->Estimators[i] == "memchi2") {
treeCalculators.push_back(new MemChi2());
}else if (params->Estimators[i] == "memchord") {
treeCalculators.push_back(new MemChord());
}else if (params->Estimators[i] == "memeuclidean") {
treeCalculators.push_back(new MemEuclidean());
}else if (params->Estimators[i] == "mempearson") {
treeCalculators.push_back(new MemPearson());
}else if (params->Estimators[i] == "jsd") {
treeCalculators.push_back(new JSD());
}else if (params->Estimators[i] == "rjsd") {
treeCalculators.push_back(new RJSD());
}
}
}
//if the users entered no valid calculators don't execute command
if (treeCalculators.size() == 0) { params->m->mothurOut("You have given no valid calculators.\n"); return 0; }
params->Estimators.clear();
for (int i=0; i<treeCalculators.size(); i++) { params->Estimators.push_back(treeCalculators[i]->getName()); }
vector< vector<seqDist> > calcDists; calcDists.resize(treeCalculators.size());
SubSample sample;
for (int thisIter = 0; thisIter < params->numIters; thisIter++) {
SharedRAbundVectors* thisItersLookup = new SharedRAbundVectors(*params->thisLookup);
vector<string> namesOfGroups = thisItersLookup->getNamesGroups();
if ((params->subsample && (!params->mainThread)) || (params->mainThread && (thisIter != 0) ) ) {
if (params->withReplacement) { sample.getSampleWithReplacement(thisItersLookup, params->subsampleSize); }
else { sample.getSample(thisItersLookup, params->subsampleSize); }
}
vector<SharedRAbundVector*> thisItersRabunds = thisItersLookup->getSharedRAbundVectors();
vector<string> thisItersGroupNames = params->thisLookup->getNamesGroups();
driverTreeShared(thisItersRabunds, calcDists, treeCalculators, params->m);
for (int i = 0; i < thisItersRabunds.size(); i++) { delete thisItersRabunds[i]; }
if ((params->subsample && (!params->mainThread)) || (params->mainThread && (thisIter != 0) ) ){
if((thisIter+1) % 100 == 0){ params->m->mothurOutJustToScreen(toString(thisIter+1)+"\n"); }
params->calcDistsTotals.push_back(calcDists);
for (int i = 0; i < calcDists.size(); i++) {
for (int j = 0; j < calcDists[i].size(); j++) {
if (params->m->getDebug()) { params->m->mothurOut("[DEBUG]: Results: iter = " + toString(thisIter) + ", " + thisItersGroupNames[calcDists[i][j].seq1] + " - " + thisItersGroupNames[calcDists[i][j].seq2] + " distance = " + toString(calcDists[i][j].dist) + ".\n"); }
}
}
}else { //print results for whole dataset
for (int i = 0; i < calcDists.size(); i++) {
if (params->m->getControl_pressed()) { break; }
//initialize matrix
vector< vector<double> > matrix; //square matrix to represent the distance
matrix.resize(thisItersLookup->size());
for (int k = 0; k < thisItersLookup->size(); k++) { matrix[k].resize(thisItersLookup->size(), 0.0); }
for (int j = 0; j < calcDists[i].size(); j++) {
int row = calcDists[i][j].seq1;
int column = calcDists[i][j].seq2;
double dist = calcDists[i][j].dist;
matrix[row][column] = -(dist-1.0);
matrix[column][row] = -(dist-1.0);
}
params->matrices.push_back(matrix);
}
}
for (int i = 0; i < calcDists.size(); i++) { calcDists[i].clear(); }
delete thisItersLookup;
}
if((params->numIters) % 100 != 0){ params->m->mothurOutJustToScreen(toString(params->numIters)+"\n"); }
for (int i=0; i<treeCalculators.size(); i++) { delete treeCalculators[i]; }
return 0;
}
catch(exception& e) {
params->m->errorOut(e, "TreeGroupCommand", "process");
exit(1);
}
}
int SummaryCommand::execute() {
try {
if (abort == true) {
if (calledHelp) {
return 0;
}
return 2;
}
if ((format != "sharedfile")) {
inputFileNames.push_back(inputfile);
}
else {
inputFileNames = parseSharedFile(sharedfile);
format = "rabund";
}
if (m->control_pressed) {
return 0;
}
int numLines = 0;
int numCols = 0;
map<string, string> groupIndex;
for (int p = 0; p < inputFileNames.size(); p++) {
numLines = 0;
numCols = 0;
map<string, string> variables;
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(inputFileNames[p]));
string fileNameRoot = getOutputFileName("summary",variables);
variables["[tag]"] = "ave-std";
string fileNameAve = getOutputFileName("summary",variables);
outputNames.push_back(fileNameRoot);
outputTypes["summary"].push_back(fileNameRoot);
if (inputFileNames.size() > 1) {
m->mothurOutEndLine();
m->mothurOut("Processing group " + groups[p]);
m->mothurOutEndLine();
m->mothurOutEndLine();
groupIndex[fileNameRoot] = groups[p];
}
sumCalculators.clear();
ValidCalculators validCalculator;
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("summary", Estimators[i]) == true) {
if(Estimators[i] == "sobs") {
sumCalculators.push_back(new Sobs());
} else if(Estimators[i] == "chao") {
sumCalculators.push_back(new Chao1());
} else if(Estimators[i] == "coverage") {
sumCalculators.push_back(new Coverage());
} else if(Estimators[i] == "geometric") {
sumCalculators.push_back(new Geom());
} else if(Estimators[i] == "logseries") {
sumCalculators.push_back(new LogSD());
} else if(Estimators[i] == "qstat") {
sumCalculators.push_back(new QStat());
} else if(Estimators[i] == "bergerparker") {
sumCalculators.push_back(new BergerParker());
} else if(Estimators[i] == "bstick") {
sumCalculators.push_back(new BStick());
} else if(Estimators[i] == "ace") {
if(abund < 5)
abund = 10;
sumCalculators.push_back(new Ace(abund));
} else if(Estimators[i] == "jack") {
sumCalculators.push_back(new Jackknife());
} else if(Estimators[i] == "shannon") {
sumCalculators.push_back(new Shannon());
} else if(Estimators[i] == "shannoneven") {
sumCalculators.push_back(new ShannonEven());
} else if(Estimators[i] == "npshannon") {
sumCalculators.push_back(new NPShannon());
} else if(Estimators[i] == "heip") {
sumCalculators.push_back(new Heip());
} else if(Estimators[i] == "smithwilson") {
sumCalculators.push_back(new SmithWilson());
} else if(Estimators[i] == "simpson") {
sumCalculators.push_back(new Simpson());
} else if(Estimators[i] == "simpsoneven") {
sumCalculators.push_back(new SimpsonEven());
} else if(Estimators[i] == "invsimpson") {
sumCalculators.push_back(new InvSimpson());
} else if(Estimators[i] == "bootstrap") {
sumCalculators.push_back(new Bootstrap());
} else if (Estimators[i] == "nseqs") {
sumCalculators.push_back(new NSeqs());
} else if (Estimators[i] == "goodscoverage") {
sumCalculators.push_back(new GoodsCoverage());
} else if (Estimators[i] == "efron") {
sumCalculators.push_back(new Efron(size));
} else if (Estimators[i] == "boneh") {
sumCalculators.push_back(new Boneh(size));
} else if (Estimators[i] == "solow") {
sumCalculators.push_back(new Solow(size));
} else if (Estimators[i] == "shen") {
sumCalculators.push_back(new Shen(size, abund));
}
}
}
//if the users entered no valid calculators don't execute command
if (sumCalculators.size() == 0) {
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
return 0;
}
ofstream outputFileHandle;
m->openOutputFile(fileNameRoot, outputFileHandle);
outputFileHandle << "label";
ofstream outAve;
if (subsample) {
m->openOutputFile(fileNameAve, outAve);
outputNames.push_back(fileNameAve);
outputTypes["summary"].push_back(fileNameAve);
outAve << "label\tmethod";
outAve.setf(ios::fixed, ios::floatfield);
outAve.setf(ios::showpoint);
if (inputFileNames.size() > 1) {
groupIndex[fileNameAve] = groups[p];
}
}
input = new InputData(inputFileNames[p], format);
sabund = input->getSAbundVector();
string lastLabel = sabund->getLabel();
for(int i=0; i<sumCalculators.size(); i++) {
if(sumCalculators[i]->getCols() == 1) {
outputFileHandle << '\t' << sumCalculators[i]->getName();
if (subsample) {
outAve << '\t' << sumCalculators[i]->getName();
}
numCols++;
}
else {
outputFileHandle << '\t' << sumCalculators[i]->getName() << "\t" << sumCalculators[i]->getName() << "_lci\t" << sumCalculators[i]->getName() << "_hci";
if (subsample) {
outAve << '\t' << sumCalculators[i]->getName() << "\t" << sumCalculators[i]->getName() << "_lci\t" << sumCalculators[i]->getName() << "_hci";
}
numCols += 3;
}
}
outputFileHandle << endl;
if (subsample) {
outAve << endl;
}
//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 = labels;
if (m->control_pressed) {
outputFileHandle.close();
outAve.close();
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
delete sabund;
delete input;
return 0;
}
while((sabund != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
if (m->control_pressed) {
outputFileHandle.close();
outAve.close();
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
delete sabund;
delete input;
return 0;
}
if(allLines == 1 || labels.count(sabund->getLabel()) == 1) {
m->mothurOut(sabund->getLabel());
m->mothurOutEndLine();
processedLabels.insert(sabund->getLabel());
userLabels.erase(sabund->getLabel());
process(sabund, outputFileHandle, outAve);
if (m->control_pressed) {
outputFileHandle.close();
outAve.close();
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
delete sabund;
delete input;
return 0;
}
numLines++;
}
if ((m->anyLabelsToProcess(sabund->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
string saveLabel = sabund->getLabel();
delete sabund;
sabund = input->getSAbundVector(lastLabel);
m->mothurOut(sabund->getLabel());
m->mothurOutEndLine();
processedLabels.insert(sabund->getLabel());
userLabels.erase(sabund->getLabel());
process(sabund, outputFileHandle, outAve);
if (m->control_pressed) {
outputFileHandle.close();
outAve.close();
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
delete sabund;
delete input;
return 0;
}
numLines++;
//restore real lastlabel to save below
sabund->setLabel(saveLabel);
}
lastLabel = sabund->getLabel();
delete sabund;
sabund = input->getSAbundVector();
}
if (m->control_pressed) {
outputFileHandle.close();
outAve.close();
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
delete input;
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++) {
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 {
m->mothurOut(". Please refer to " + lastLabel + ".");
m->mothurOutEndLine();
}
}
//run last label if you need to
if (needToRun == true) {
if (sabund != NULL) {
delete sabund;
}
sabund = input->getSAbundVector(lastLabel);
m->mothurOut(sabund->getLabel());
m->mothurOutEndLine();
process(sabund, outputFileHandle, outAve);
if (m->control_pressed) {
outputFileHandle.close();
outAve.close();
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
delete sabund;
delete input;
return 0;
}
numLines++;
delete sabund;
}
outputFileHandle.close();
if (subsample) {
outAve.close();
}
if (m->control_pressed) {
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
delete input;
return 0;
}
delete input;
for(int i=0; i<sumCalculators.size(); i++) {
delete sumCalculators[i];
}
}
if (m->control_pressed) {
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
return 0;
}
//create summary file containing all the groups data for each label - this function just combines the info from the files already created.
if ((sharedfile != "") && (groupMode)) {
vector<string> comboNames = createGroupSummaryFile(numLines, numCols, outputNames, groupIndex);
for (int i = 0; i < comboNames.size(); i++) {
outputNames.push_back(comboNames[i]);
}
}
if (m->control_pressed) {
for (int i = 0; i < outputNames.size(); i++) {
m->mothurRemove(outputNames[i]);
}
return 0;
}
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) {
m->errorOut(e, "SummaryCommand", "execute");
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) != true) { 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.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; }
}
it = parameters.find("rabund");
//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["rabund"] = inputDir + it->second; }
}
it = parameters.find("sabund");
//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["sabund"] = inputDir + it->second; }
}
it = parameters.find("list");
//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["list"] = inputDir + it->second; }
}
}
//check for required parameters
listfile = validParameter.validFile(parameters, "list", true);
if (listfile == "not open") { listfile = ""; abort = true; }
else if (listfile == "not found") { listfile = ""; }
else { format = "list"; inputfile = listfile; m->setListFile(listfile); }
sabundfile = validParameter.validFile(parameters, "sabund", true);
if (sabundfile == "not open") { sabundfile = ""; abort = true; }
else if (sabundfile == "not found") { sabundfile = ""; }
else { format = "sabund"; inputfile = sabundfile; m->setSabundFile(sabundfile); }
rabundfile = validParameter.validFile(parameters, "rabund", true);
if (rabundfile == "not open") { rabundfile = ""; abort = true; }
else if (rabundfile == "not found") { rabundfile = ""; }
else { format = "rabund"; inputfile = rabundfile; m->setRabundFile(rabundfile); }
sharedfile = validParameter.validFile(parameters, "shared", true);
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") { sharedfile = ""; }
else { format = "sharedfile"; inputfile = sharedfile; m->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 = m->getSharedFile();
if (sharedfile != "") { inputfile = sharedfile; format = "sharedfile"; m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); }
else {
listfile = m->getListFile();
if (listfile != "") { inputfile = listfile; format = "list"; m->mothurOut("Using " + listfile + " as input file for the list parameter."); m->mothurOutEndLine(); }
else {
rabundfile = m->getRabundFile();
if (rabundfile != "") { inputfile = rabundfile; format = "rabund"; m->mothurOut("Using " + rabundfile + " as input file for the rabund parameter."); m->mothurOutEndLine(); }
else {
sabundfile = m->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.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = m->hasPath(inputfile); }
//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; }
}
calc = validParameter.validFile(parameters, "calc", false);
if (calc == "not found") { calc = "sobs"; }
else {
if (calc == "default") { calc = "sobs"; }
}
m->splitAtDash(calc, Estimators);
if (m->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.validFile(parameters, "freq", false); if (temp == "not found") { temp = "100"; }
m->mothurConvert(temp, freq);
temp = validParameter.validFile(parameters, "abund", false); if (temp == "not found") { temp = "10"; }
m->mothurConvert(temp, abund);
temp = validParameter.validFile(parameters, "iters", false); if (temp == "not found") { temp = "1000"; }
m->mothurConvert(temp, nIters);
temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); }
m->setProcessors(temp);
m->mothurConvert(temp, processors);
temp = validParameter.validFile(parameters, "alpha", false); if (temp == "not found") { temp = "1"; }
m->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.validFile(parameters, "groupmode", false); if (temp == "not found") { temp = "T"; }
groupMode = m->isTrue(temp);
}
}
catch(exception& e) {
m->errorOut(e, "RareFactCommand", "RareFactCommand");
exit(1);
}
}
int TreeGroupCommand::execute(){
try {
if (abort == true) { if (calledHelp) { return 0; } return 2; }
if (format == "sharedfile") {
ValidCalculators validCalculator;
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("treegroup", Estimators[i]) == true) {
if (Estimators[i] == "sharedsobs") {
treeCalculators.push_back(new SharedSobsCS());
}else if (Estimators[i] == "sharedchao") {
treeCalculators.push_back(new SharedChao1());
}else if (Estimators[i] == "sharedace") {
treeCalculators.push_back(new SharedAce());
}else if (Estimators[i] == "jabund") {
treeCalculators.push_back(new JAbund());
}else if (Estimators[i] == "sorabund") {
treeCalculators.push_back(new SorAbund());
}else if (Estimators[i] == "jclass") {
treeCalculators.push_back(new Jclass());
}else if (Estimators[i] == "sorclass") {
treeCalculators.push_back(new SorClass());
}else if (Estimators[i] == "jest") {
treeCalculators.push_back(new Jest());
}else if (Estimators[i] == "sorest") {
treeCalculators.push_back(new SorEst());
}else if (Estimators[i] == "thetayc") {
treeCalculators.push_back(new ThetaYC());
}else if (Estimators[i] == "thetan") {
treeCalculators.push_back(new ThetaN());
}else if (Estimators[i] == "kstest") {
treeCalculators.push_back(new KSTest());
}else if (Estimators[i] == "sharednseqs") {
treeCalculators.push_back(new SharedNSeqs());
}else if (Estimators[i] == "ochiai") {
treeCalculators.push_back(new Ochiai());
}else if (Estimators[i] == "anderberg") {
treeCalculators.push_back(new Anderberg());
}else if (Estimators[i] == "kulczynski") {
treeCalculators.push_back(new Kulczynski());
}else if (Estimators[i] == "kulczynskicody") {
treeCalculators.push_back(new KulczynskiCody());
}else if (Estimators[i] == "lennon") {
treeCalculators.push_back(new Lennon());
}else if (Estimators[i] == "morisitahorn") {
treeCalculators.push_back(new MorHorn());
}else if (Estimators[i] == "braycurtis") {
treeCalculators.push_back(new BrayCurtis());
}else if (Estimators[i] == "whittaker") {
treeCalculators.push_back(new Whittaker());
}else if (Estimators[i] == "odum") {
treeCalculators.push_back(new Odum());
}else if (Estimators[i] == "canberra") {
treeCalculators.push_back(new Canberra());
}else if (Estimators[i] == "structeuclidean") {
treeCalculators.push_back(new StructEuclidean());
}else if (Estimators[i] == "structchord") {
treeCalculators.push_back(new StructChord());
}else if (Estimators[i] == "hellinger") {
treeCalculators.push_back(new Hellinger());
}else if (Estimators[i] == "manhattan") {
treeCalculators.push_back(new Manhattan());
}else if (Estimators[i] == "structpearson") {
treeCalculators.push_back(new StructPearson());
}else if (Estimators[i] == "soergel") {
treeCalculators.push_back(new Soergel());
}else if (Estimators[i] == "spearman") {
treeCalculators.push_back(new Spearman());
}else if (Estimators[i] == "structkulczynski") {
treeCalculators.push_back(new StructKulczynski());
}else if (Estimators[i] == "speciesprofile") {
treeCalculators.push_back(new SpeciesProfile());
}else if (Estimators[i] == "hamming") {
treeCalculators.push_back(new Hamming());
}else if (Estimators[i] == "structchi2") {
treeCalculators.push_back(new StructChi2());
}else if (Estimators[i] == "gower") {
treeCalculators.push_back(new Gower());
}else if (Estimators[i] == "memchi2") {
treeCalculators.push_back(new MemChi2());
}else if (Estimators[i] == "memchord") {
treeCalculators.push_back(new MemChord());
}else if (Estimators[i] == "memeuclidean") {
treeCalculators.push_back(new MemEuclidean());
}else if (Estimators[i] == "mempearson") {
treeCalculators.push_back(new MemPearson());
}else if (Estimators[i] == "jsd") {
treeCalculators.push_back(new JSD());
}else if (Estimators[i] == "rjsd") {
treeCalculators.push_back(new RJSD());
}
}
}
//if the users entered no valid calculators don't execute command
if (treeCalculators.size() == 0) { m->mothurOut("You have given no valid calculators."); m->mothurOutEndLine(); return 0; }
input = new InputData(sharedfile, "sharedfile");
lookup = input->getSharedRAbundVectors();
lastLabel = lookup[0]->getLabel();
if (lookup.size() < 2) { m->mothurOut("You have not provided enough valid groups. I cannot run the command."); m->mothurOutEndLine(); return 0; }
//used in tree constructor
m->runParse = false;
//create treemap class from groupmap for tree class to use
ct = new CountTable();
set<string> nameMap;
map<string, string> groupMap;
set<string> gps;
for (int i = 0; i < m->getAllGroups().size(); i++) {
nameMap.insert(m->getAllGroups()[i]);
gps.insert(m->getAllGroups()[i]);
groupMap[m->getAllGroups()[i]] = m->getAllGroups()[i];
}
ct->createTable(nameMap, groupMap, gps);
//clear globaldatas old tree names if any
m->Treenames.clear();
//fills globaldatas tree names
//m->Treenames = m->getGroups();
for (int k = 0; k < lookup.size(); k++) {
m->Treenames.push_back(lookup[k]->getGroup());
}
if (m->control_pressed) { return 0; }
//create tree file
makeSimsShared();
if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
}else{
//read in dist file
filename = inputfile;
ReadMatrix* readMatrix;
if (format == "column") { readMatrix = new ReadColumnMatrix(filename); }
else if (format == "phylip") { readMatrix = new ReadPhylipMatrix(filename); }
readMatrix->setCutoff(cutoff);
ct = NULL;
nameMap = NULL;
if(namefile != ""){
nameMap = new NameAssignment(namefile);
nameMap->readMap();
readMatrix->read(nameMap);
}else if (countfile != "") {
ct = new CountTable();
ct->readTable(countfile, true, false);
readMatrix->read(ct);
}else {
readMatrix->read(nameMap);
}
list = readMatrix->getListVector();
SparseDistanceMatrix* dMatrix = readMatrix->getDMatrix();
//clear globaldatas old tree names if any
m->Treenames.clear();
//make treemap
if (ct != NULL) { delete ct; }
ct = new CountTable();
set<string> nameMap;
map<string, string> groupMap;
set<string> gps;
for (int i = 0; i < list->getNumBins(); i++) {
string bin = list->get(i);
nameMap.insert(bin);
gps.insert(bin);
groupMap[bin] = bin;
m->Treenames.push_back(bin);
}
ct->createTable(nameMap, groupMap, gps);
vector<string> namesGroups = ct->getNamesOfGroups();
m->setGroups(namesGroups);
//used in tree constructor
m->runParse = false;
if (m->control_pressed) { return 0; }
vector< vector<double> > matrix = makeSimsDist(dMatrix);
delete readMatrix;
delete dMatrix;
if (m->control_pressed) { return 0; }
//create a new filename
map<string, string> variables;
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(inputfile));
string outputFile = getOutputFileName("tree",variables);
outputNames.push_back(outputFile); outputTypes["tree"].push_back(outputFile);
Tree* newTree = createTree(matrix);
if (newTree != NULL) { writeTree(outputFile, newTree); delete newTree; }
if (m->control_pressed) { return 0; }
m->mothurOut("Tree complete. "); m->mothurOutEndLine();
}
//reset groups parameter
m->clearGroups();
//set tree file as new current treefile
string current = "";
itTypes = outputTypes.find("tree");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setTreeFile(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) {
m->errorOut(e, "TreeGroupCommand", "execute");
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) != true) { abort = true; }
}
//initialize outputTypes
vector<string> tempOutNames;
outputTypes["tree"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.validFile(parameters, "inputdir", false);
if (inputDir == "not found"){ inputDir = ""; }
else {
string path;
it = parameters.find("phylip");
//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["phylip"] = inputDir + it->second; }
}
it = parameters.find("column");
//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["column"] = inputDir + it->second; }
}
it = parameters.find("name");
//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["name"] = inputDir + it->second; }
}
it = parameters.find("count");
//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["count"] = inputDir + it->second; }
}
}
//check for required parameters
phylipfile = validParameter.validFile(parameters, "phylip", true);
if (phylipfile == "not open") { phylipfile = ""; abort = true; }
else if (phylipfile == "not found") { phylipfile = ""; }
else { inputfile = phylipfile; format = "phylip"; m->setPhylipFile(phylipfile); }
columnfile = validParameter.validFile(parameters, "column", true);
if (columnfile == "not open") { columnfile = ""; abort = true; }
else if (columnfile == "not found") { columnfile = ""; }
else { inputfile = columnfile; format = "column"; m->setColumnFile(columnfile); }
sharedfile = validParameter.validFile(parameters, "shared", true);
if (sharedfile == "not open") { sharedfile = ""; abort = true; }
else if (sharedfile == "not found") { sharedfile = ""; }
else { inputfile = sharedfile; format = "sharedfile"; m->setSharedFile(sharedfile); }
namefile = validParameter.validFile(parameters, "name", true);
if (namefile == "not open") { abort = true; }
else if (namefile == "not found") { namefile = ""; }
else { m->setNameFile(namefile); }
countfile = validParameter.validFile(parameters, "count", true);
if (countfile == "not open") { abort = true; countfile = ""; }
else if (countfile == "not found") { countfile = ""; }
else { m->setCountTableFile(countfile); }
if ((phylipfile == "") && (columnfile == "") && (sharedfile == "")) {
//is there are current file available for either of these?
//give priority to shared, then column, then phylip
sharedfile = m->getSharedFile();
if (sharedfile != "") { inputfile = sharedfile; format = "sharedfile"; m->mothurOut("Using " + sharedfile + " as input file for the shared parameter."); m->mothurOutEndLine(); }
else {
columnfile = m->getColumnFile();
if (columnfile != "") { inputfile = columnfile; format = "column"; m->mothurOut("Using " + columnfile + " as input file for the column parameter."); m->mothurOutEndLine(); }
else {
phylipfile = m->getPhylipFile();
if (phylipfile != "") { inputfile = phylipfile; format = "phylip"; m->mothurOut("Using " + phylipfile + " as input file for the phylip parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("No valid current files. You must provide a shared, phylip or column file."); m->mothurOutEndLine();
abort = true;
}
}
}
}
else if ((phylipfile != "") && (columnfile != "")) { m->mothurOut("When running the tree.shared command with a distance file you may not use both the column and the phylip parameters."); m->mothurOutEndLine(); abort = true; }
if (columnfile != "") {
if ((namefile == "") && (countfile == "")){
namefile = m->getNameFile();
if (namefile != "") { m->mothurOut("Using " + namefile + " as input file for the name parameter."); m->mothurOutEndLine(); }
else {
countfile = m->getCountTableFile();
if (countfile != "") { m->mothurOut("Using " + countfile + " as input file for the count parameter."); m->mothurOutEndLine(); }
else {
m->mothurOut("You need to provide a namefile or countfile if you are going to use the column format."); m->mothurOutEndLine();
abort = true;
}
}
}
}
//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; }
}
groups = validParameter.validFile(parameters, "groups", false);
if (groups == "not found") { groups = ""; }
else {
m->splitAtDash(groups, Groups);
m->setGroups(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 (m->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.validFile(parameters, "precision", false); if (temp == "not found") { temp = "100"; }
m->mothurConvert(temp, precision);
temp = validParameter.validFile(parameters, "cutoff", false); if (temp == "not found") { temp = "10"; }
m->mothurConvert(temp, cutoff);
cutoff += (5 / (precision * 10.0));
temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); }
m->setProcessors(temp);
m->mothurConvert(temp, processors);
temp = validParameter.validFile(parameters, "iters", false); if (temp == "not found") { temp = "1000"; }
m->mothurConvert(temp, iters);
temp = validParameter.validFile(parameters, "subsample", false); if (temp == "not found") { temp = "F"; }
if (m->isNumeric1(temp)) { m->mothurConvert(temp, subsampleSize); subsample = true; }
else {
if (m->isTrue(temp)) { subsample = true; subsampleSize = -1; } //we will set it to smallest group later
else { subsample = false; }
}
if (subsample == false) { iters = 1; }
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.validFile(parameters, "outputdir", false); if (outputDir == "not found"){
outputDir = "";
outputDir += m->hasPath(inputfile); //if user entered a file with a path then preserve it
}
}
}
catch(exception& e) {
m->errorOut(e, "TreeGroupCommand", "TreeGroupCommand");
exit(1);
}
}
/////// need to fix to work with calcs and sequencedb
int DistanceCommand::driverMPI(int startLine, int endLine, string file, unsigned long long& size, string square){
try {
ValidCalculators validCalculator;
Dist* distCalculator;
if (m->isTrue(countends) == true) {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap") { distCalculator = new eachGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapDist(); }
}
}
}else {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap"){ distCalculator = new eachGapIgnoreTermGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapIgnoreTermGapDist(); }
}
}
}
MPI_Status status;
MPI_File outMPI;
int amode=MPI_MODE_CREATE|MPI_MODE_WRONLY;
//char* filename = new char[file.length()];
//memcpy(filename, file.c_str(), file.length());
char filename[1024];
strcpy(filename, file.c_str());
MPI_File_open(MPI_COMM_SELF, filename, amode, MPI_INFO_NULL, &outMPI);
//delete filename;
int startTime = time(NULL);
string outputString = "";
size = 0;
if(startLine == 0){ outputString += toString(alignDB.getNumSeqs()) + "\n"; }
for(int i=startLine;i<endLine;i++){
string name = alignDB.get(i).getName();
if (name.length() < 10) { //pad with spaces to make compatible
while (name.length() < 10) { name += " "; }
}
outputString += name;
for(int j=0;j<alignDB.getNumSeqs();j++){
if (m->control_pressed) { delete distCalculator; return 0; }
distCalculator->calcDist(alignDB.get(i), alignDB.get(j));
double dist = distCalculator->getDist();
outputString += "\t" + toString(dist);
}
outputString += "\n";
if(i % 100 == 0){
m->mothurOutJustToScreen(toString(i) + "\t" + toString(time(NULL) - startTime)+"\n");
}
//send results to parent
int length = outputString.length();
char* buf = new char[length];
memcpy(buf, outputString.c_str(), length);
MPI_File_write(outMPI, buf, length, MPI_CHAR, &status);
size += outputString.length();
outputString = "";
delete buf;
}
m->mothurOutJustToScreen(toString(endLine-1) + "\t" + toString(time(NULL) - startTime)+"\n");
MPI_File_close(&outMPI);
delete distCalculator;
return 1;
}
catch(exception& e) {
m->errorOut(e, "DistanceCommand", "driverMPI");
exit(1);
}
}
/////// need to fix to work with calcs and sequencedb
int DistanceCommand::driverMPI(int startLine, int endLine, MPI_File& outMPI, float cutoff){
try {
ValidCalculators validCalculator;
Dist* distCalculator;
if (m->isTrue(countends) == true) {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap") { distCalculator = new eachGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapDist(); }
}
}
}else {
for (int i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("distance", Estimators[i]) == true) {
if (Estimators[i] == "nogaps") { distCalculator = new ignoreGaps(); }
else if (Estimators[i] == "eachgap"){ distCalculator = new eachGapIgnoreTermGapDist(); }
else if (Estimators[i] == "onegap") { distCalculator = new oneGapIgnoreTermGapDist(); }
}
}
}
MPI_Status status;
int startTime = time(NULL);
string outputString = "";
for(int i=startLine;i<endLine;i++){
for(int j=0;j<i;j++){
if (m->control_pressed) { delete distCalculator; return 0; }
//if there was a column file given and we are appending, we don't want to calculate the distances that are already in the column file
//the alignDB contains the new sequences and then the old, so if i an oldsequence and j is an old sequence then break out of this loop
if ((i >= numNewFasta) && (j >= numNewFasta)) { break; }
distCalculator->calcDist(alignDB.get(i), alignDB.get(j));
double dist = distCalculator->getDist();
if(dist <= cutoff){
outputString += (alignDB.get(i).getName() + ' ' + alignDB.get(j).getName() + ' ' + toString(dist) + '\n');
}
}
if(i % 100 == 0){
m->mothurOutJustToScreen(toString(i) + "\t" + toString(time(NULL) - startTime)+"\n");
}
//send results to parent
int length = outputString.length();
char* buf = new char[length];
memcpy(buf, outputString.c_str(), length);
MPI_File_write_shared(outMPI, buf, length, MPI_CHAR, &status);
outputString = "";
delete buf;
}
m->mothurOutJustToScreen(toString(endLine-1) + "\t" + toString(time(NULL) - startTime)+"\n");
delete distCalculator;
return 1;
}
catch(exception& e) {
m->errorOut(e, "DistanceCommand", "driverMPI");
exit(1);
}
}
int RareFactCommand::execute(){
try {
if (abort == true) { if (calledHelp) { return 0; } return 2; }
map<string, set<int> > labelToEnds;
if ((format != "sharedfile")) { inputFileNames.push_back(inputfile); }
else { inputFileNames = parseSharedFile(sharedfile, labelToEnds); format = "rabund"; }
if (m->control_pressed) { return 0; }
map<int, string> file2Group; //index in outputNames[i] -> group
for (int p = 0; p < inputFileNames.size(); p++) {
string fileNameRoot = outputDir + m->getRootName(m->getSimpleName(inputFileNames[p]));
if (m->control_pressed) { outputTypes.clear(); for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } m->clearGroups(); return 0; }
if (inputFileNames.size() > 1) {
m->mothurOutEndLine(); m->mothurOut("Processing group " + groups[p]); m->mothurOutEndLine(); m->mothurOutEndLine();
}
int i;
ValidCalculators validCalculator;
map<string, string> variables;
variables["[filename]"] = fileNameRoot;
for (i=0; i<Estimators.size(); i++) {
if (validCalculator.isValidCalculator("rarefaction", Estimators[i]) == true) {
if (Estimators[i] == "sobs") {
rDisplays.push_back(new RareDisplay(new Sobs(), new ThreeColumnFile(getOutputFileName("rarefaction",variables))));
outputNames.push_back(getOutputFileName("rarefaction",variables)); outputTypes["rarefaction"].push_back(getOutputFileName("rarefaction",variables));
}else if (Estimators[i] == "chao") {
rDisplays.push_back(new RareDisplay(new Chao1(), new ThreeColumnFile(getOutputFileName("r_chao",variables))));
outputNames.push_back(getOutputFileName("r_chao",variables)); outputTypes["r_chao"].push_back(getOutputFileName("r_chao",variables));
}else if (Estimators[i] == "ace") {
if(abund < 5)
abund = 10;
rDisplays.push_back(new RareDisplay(new Ace(abund), new ThreeColumnFile(getOutputFileName("r_ace",variables))));
outputNames.push_back(getOutputFileName("r_ace",variables)); outputTypes["r_ace"].push_back(getOutputFileName("r_ace",variables));
}else if (Estimators[i] == "jack") {
rDisplays.push_back(new RareDisplay(new Jackknife(), new ThreeColumnFile(getOutputFileName("r_jack",variables))));
outputNames.push_back(getOutputFileName("r_jack",variables)); outputTypes["r_jack"].push_back(getOutputFileName("r_jack",variables));
}else if (Estimators[i] == "shannon") {
rDisplays.push_back(new RareDisplay(new Shannon(), new ThreeColumnFile(getOutputFileName("r_shannon",variables))));
outputNames.push_back(getOutputFileName("r_shannon",variables)); outputTypes["r_shannon"].push_back(getOutputFileName("r_shannon",variables));
}else if (Estimators[i] == "shannoneven") {
rDisplays.push_back(new RareDisplay(new ShannonEven(), new ThreeColumnFile(getOutputFileName("r_shannoneven",variables))));
outputNames.push_back(getOutputFileName("r_shannoneven",variables)); outputTypes["r_shannoneven"].push_back(getOutputFileName("r_shannoneven",variables));
}else if (Estimators[i] == "heip") {
rDisplays.push_back(new RareDisplay(new Heip(), new ThreeColumnFile(getOutputFileName("r_heip",variables))));
outputNames.push_back(getOutputFileName("r_heip",variables)); outputTypes["r_heip"].push_back(getOutputFileName("r_heip",variables));
}else if (Estimators[i] == "r_shannonrange") {
rDisplays.push_back(new RareDisplay(new RangeShannon(alpha), new ThreeColumnFile(getOutputFileName("r_shannonrange", variables))));
outputNames.push_back(getOutputFileName("r_shannonrange", variables)); outputTypes["r_shannoneven"].push_back(getOutputFileName("r_shannonrange", variables));
}else if (Estimators[i] == "smithwilson") {
rDisplays.push_back(new RareDisplay(new SmithWilson(), new ThreeColumnFile(getOutputFileName("r_smithwilson",variables))));
outputNames.push_back(getOutputFileName("r_smithwilson",variables)); outputTypes["r_smithwilson"].push_back(getOutputFileName("r_smithwilson",variables));
}else if (Estimators[i] == "npshannon") {
rDisplays.push_back(new RareDisplay(new NPShannon(), new ThreeColumnFile(getOutputFileName("r_npshannon",variables))));
outputNames.push_back(getOutputFileName("r_npshannon",variables)); outputTypes["r_npshannon"].push_back(getOutputFileName("r_npshannon",variables));
}else if (Estimators[i] == "simpson") {
rDisplays.push_back(new RareDisplay(new Simpson(), new ThreeColumnFile(getOutputFileName("r_simpson",variables))));
outputNames.push_back(getOutputFileName("r_simpson",variables)); outputTypes["r_simpson"].push_back(getOutputFileName("r_simpson",variables));
}else if (Estimators[i] == "simpsoneven") {
rDisplays.push_back(new RareDisplay(new SimpsonEven(), new ThreeColumnFile(getOutputFileName("r_simpsoneven",variables))));
outputNames.push_back(getOutputFileName("r_simpsoneven",variables)); outputTypes["r_simpsoneven"].push_back(getOutputFileName("r_simpsoneven",variables));
}else if (Estimators[i] == "invsimpson") {
rDisplays.push_back(new RareDisplay(new InvSimpson(), new ThreeColumnFile(getOutputFileName("r_invsimpson",variables))));
outputNames.push_back(getOutputFileName("r_invsimpson",variables)); outputTypes["r_invsimpson"].push_back(getOutputFileName("r_invsimpson",variables));
}else if (Estimators[i] == "bootstrap") {
rDisplays.push_back(new RareDisplay(new Bootstrap(), new ThreeColumnFile(getOutputFileName("r_bootstrap",variables))));
outputNames.push_back(getOutputFileName("r_bootstrap",variables)); outputTypes["r_bootstrap"].push_back(getOutputFileName("r_bootstrap",variables));
}else if (Estimators[i] == "coverage") {
rDisplays.push_back(new RareDisplay(new Coverage(), new ThreeColumnFile(getOutputFileName("r_coverage",variables))));
outputNames.push_back(getOutputFileName("r_coverage",variables)); outputTypes["r_coverage"].push_back(getOutputFileName("r_coverage",variables));
}else if (Estimators[i] == "nseqs") {
rDisplays.push_back(new RareDisplay(new NSeqs(), new ThreeColumnFile(getOutputFileName("r_nseqs",variables))));
outputNames.push_back(getOutputFileName("r_nseqs",variables)); outputTypes["r_nseqs"].push_back(getOutputFileName("r_nseqs",variables));
}
if (inputFileNames.size() > 1) { file2Group[outputNames.size()-1] = groups[p]; }
}
}
//if the users entered no valid calculators don't execute command
if (rDisplays.size() == 0) { for(int i=0;i<rDisplays.size();i++){ delete rDisplays[i]; } return 0; }
input = new InputData(inputFileNames[p], format);
order = input->getOrderVector();
string lastLabel = order->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 = labels;
if (m->control_pressed) { for(int i=0;i<rDisplays.size();i++){ delete rDisplays[i]; } delete input; delete order; for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
//as long as you are not at the end of the file or done wih the lines you want
while((order != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
if (m->control_pressed) { for(int i=0;i<rDisplays.size();i++){ delete rDisplays[i]; } delete input; delete order; for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
if(allLines == 1 || labels.count(order->getLabel()) == 1){
m->mothurOut(order->getLabel()); m->mothurOutEndLine();
map<string, set<int> >::iterator itEndings = labelToEnds.find(order->getLabel());
set<int> ends;
if (itEndings != labelToEnds.end()) { ends = itEndings->second; }
rCurve = new Rarefact(order, rDisplays, processors, ends);
rCurve->getCurve(freq, nIters);
delete rCurve;
processedLabels.insert(order->getLabel());
userLabels.erase(order->getLabel());
}
if ((m->anyLabelsToProcess(order->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
string saveLabel = order->getLabel();
delete order;
order = (input->getOrderVector(lastLabel));
m->mothurOut(order->getLabel()); m->mothurOutEndLine();
map<string, set<int> >::iterator itEndings = labelToEnds.find(order->getLabel());
set<int> ends;
if (itEndings != labelToEnds.end()) { ends = itEndings->second; }
rCurve = new Rarefact(order, rDisplays, processors, ends);
rCurve->getCurve(freq, nIters);
delete rCurve;
processedLabels.insert(order->getLabel());
userLabels.erase(order->getLabel());
//restore real lastlabel to save below
order->setLabel(saveLabel);
}
lastLabel = order->getLabel();
delete order;
order = (input->getOrderVector());
}
if (m->control_pressed) { for(int i=0;i<rDisplays.size();i++){ delete rDisplays[i]; } delete input; for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } 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++) {
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 {
m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine();
}
}
if (m->control_pressed) { for(int i=0;i<rDisplays.size();i++){ delete rDisplays[i]; } delete input; for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
//run last label if you need to
if (needToRun == true) {
if (order != NULL) { delete order; }
order = (input->getOrderVector(lastLabel));
m->mothurOut(order->getLabel()); m->mothurOutEndLine();
map<string, set<int> >::iterator itEndings = labelToEnds.find(order->getLabel());
set<int> ends;
if (itEndings != labelToEnds.end()) { ends = itEndings->second; }
rCurve = new Rarefact(order, rDisplays, processors, ends);
rCurve->getCurve(freq, nIters);
delete rCurve;
delete order;
}
for(int i=0;i<rDisplays.size();i++){ delete rDisplays[i]; }
rDisplays.clear();
delete input;
}
if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
//create summary file containing all the groups data for each label - this function just combines the info from the files already created.
if ((sharedfile != "") && (groupMode)) { outputNames = createGroupFile(outputNames, file2Group); }
if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
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) {
m->errorOut(e, "RareFactCommand", "execute");
exit(1);
}
}
SummaryCommand::SummaryCommand(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 (map<string,string>::iterator it = parameters.begin(); it != parameters.end(); it++) {
if (validParameter.isValidParameter(it->first, myArray, it->second) != true) {
abort = true;
}
}
//initialize outputTypes
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.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;
}
}
it = parameters.find("rabund");
//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["rabund"] = inputDir + it->second;
}
}
it = parameters.find("sabund");
//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["sabund"] = inputDir + it->second;
}
}
it = parameters.find("list");
//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["list"] = inputDir + it->second;
}
}
}
//check for required parameters
listfile = validParameter.validFile(parameters, "list", true);
if (listfile == "not open") {
listfile = "";
abort = true;
}
else if (listfile == "not found") {
listfile = "";
}
else {
format = "list";
inputfile = listfile;
m->setListFile(listfile);
}
sabundfile = validParameter.validFile(parameters, "sabund", true);
if (sabundfile == "not open") {
sabundfile = "";
abort = true;
}
else if (sabundfile == "not found") {
sabundfile = "";
}
else {
format = "sabund";
inputfile = sabundfile;
m->setSabundFile(sabundfile);
}
rabundfile = validParameter.validFile(parameters, "rabund", true);
if (rabundfile == "not open") {
rabundfile = "";
abort = true;
}
else if (rabundfile == "not found") {
rabundfile = "";
}
else {
format = "rabund";
inputfile = rabundfile;
m->setRabundFile(rabundfile);
}
sharedfile = validParameter.validFile(parameters, "shared", true);
if (sharedfile == "not open") {
sharedfile = "";
abort = true;
}
else if (sharedfile == "not found") {
sharedfile = "";
}
else {
format = "sharedfile";
inputfile = sharedfile;
m->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 = m->getSharedFile();
if (sharedfile != "") {
inputfile = sharedfile;
format = "sharedfile";
m->mothurOut("Using " + sharedfile + " as input file for the shared parameter.");
m->mothurOutEndLine();
}
else {
listfile = m->getListFile();
if (listfile != "") {
inputfile = listfile;
format = "list";
m->mothurOut("Using " + listfile + " as input file for the list parameter.");
m->mothurOutEndLine();
}
else {
rabundfile = m->getRabundFile();
if (rabundfile != "") {
inputfile = rabundfile;
format = "rabund";
m->mothurOut("Using " + rabundfile + " as input file for the rabund parameter.");
m->mothurOutEndLine();
}
else {
sabundfile = m->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.validFile(parameters, "outputdir", false);
if (outputDir == "not found") {
outputDir = m->hasPath(inputfile);
}
//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;
}
}
calc = validParameter.validFile(parameters, "calc", false);
if (calc == "not found") {
calc = "sobs-chao-ace-jack-shannon-npshannon-simpson";
}
else {
if (calc == "default") {
calc = "sobs-chao-ace-jack-shannon-npshannon-simpson";
}
}
m->splitAtDash(calc, Estimators);
if (m->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.validFile(parameters, "abund", false);
if (temp == "not found") {
temp = "10";
}
m->mothurConvert(temp, abund);
temp = validParameter.validFile(parameters, "size", false);
if (temp == "not found") {
temp = "0";
}
m->mothurConvert(temp, size);
temp = validParameter.validFile(parameters, "groupmode", false);
if (temp == "not found") {
temp = "T";
}
groupMode = m->isTrue(temp);
temp = validParameter.validFile(parameters, "iters", false);
if (temp == "not found") {
temp = "1000";
}
m->mothurConvert(temp, iters);
temp = validParameter.validFile(parameters, "subsample", false);
if (temp == "not found") {
temp = "F";
}
if (m->isNumeric1(temp)) {
m->mothurConvert(temp, subsampleSize);
subsample = true;
}
else {
if (m->isTrue(temp)) {
subsample = true; //we will set it to smallest group later
subsampleSize = -1;
}
else {
subsample = false;
subsampleSize = -1;
}
}
if (subsample == false) {
iters = 0;
}
else {
//if you did not set a samplesize and are not using a sharedfile
if ((subsampleSize == -1) && (format != "sharedfile")) {
m->mothurOut("[ERROR]: If you want to subsample with a list, rabund or sabund file, you must provide the sample size. You can do this by setting subsample=yourSampleSize.\n");
abort=true;
}
}
}
}
catch(exception& e) {
m->errorOut(e, "SummaryCommand", "SummaryCommand");
exit(1);
}
}