X-Git-Url: https://git.donarmstrong.com/?p=mothur.git;a=blobdiff_plain;f=otuhierarchycommand.cpp;h=07e3c1d0146ef521563697fe07deb38d7837b67d;hp=c39a638cf11375644a82e4d56c3c5659c56b35ee;hb=499f4ac6e321f9f03d4c3aa25c3b6880892c8b83;hpb=5a1e62397b91f57d0d3aff635891df04b8999a88 diff --git a/otuhierarchycommand.cpp b/otuhierarchycommand.cpp index c39a638..07e3c1d 100644 --- a/otuhierarchycommand.cpp +++ b/otuhierarchycommand.cpp @@ -10,16 +10,81 @@ #include "otuhierarchycommand.h" //********************************************************************************************************************** -OtuHierarchyCommand::OtuHierarchyCommand(string option){ +vector OtuHierarchyCommand::setParameters(){ try { - abort = false; + CommandParameter poutput("output", "Multiple", "name-number", "name", "", "", "","",false,false); parameters.push_back(poutput); + CommandParameter plist("list", "InputTypes", "", "", "none", "none", "none","otuheirarchy",false,true,true); parameters.push_back(plist); + CommandParameter plabel("label", "String", "", "", "", "", "","",false,false); parameters.push_back(plabel); + CommandParameter pinputdir("inputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(pinputdir); + CommandParameter poutputdir("outputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(poutputdir); + + vector myArray; + for (int i = 0; i < parameters.size(); i++) { myArray.push_back(parameters[i].name); } + return myArray; + } + catch(exception& e) { + m->errorOut(e, "OtuHierarchyCommand", "setParameters"); + exit(1); + } +} +//********************************************************************************************************************** +string OtuHierarchyCommand::getHelpString(){ + try { + string helpString = ""; + helpString += "The otu.hierarchy command is used to see how otus relate at two distances. \n"; + helpString += "The otu.hierarchy command parameters are list, label and output. list and label parameters are required. \n"; + helpString += "The output parameter allows you to output the names of the sequence in the OTUs or the OTU numbers. Options are name and number, default is name. \n"; + helpString += "The otu.hierarchy command should be in the following format: \n"; + helpString += "otu.hierarchy(list=yourListFile, label=yourLabels).\n"; + helpString += "Example otu.hierarchy(list=amazon.fn.list, label=0.01-0.03).\n"; + helpString += "The otu.hierarchy command outputs a .otu.hierarchy file which is described on the wiki.\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, "OtuHierarchyCommand", "getHelpString"); + exit(1); + } +} +//********************************************************************************************************************** +string OtuHierarchyCommand::getOutputPattern(string type) { + try { + string pattern = ""; + + if (type == "otuheirarchy") { pattern = "[filename],[distance1],[tag],[distance2],otu.hierarchy"; } + else { m->mothurOut("[ERROR]: No definition for type " + type + " output pattern.\n"); m->control_pressed = true; } + + return pattern; + } + catch(exception& e) { + m->errorOut(e, "OtuHierarchyCommand", "getOutputPattern"); + exit(1); + } +} +//********************************************************************************************************************** +OtuHierarchyCommand::OtuHierarchyCommand(){ + try { + abort = true; calledHelp = true; + setParameters(); + vector tempOutNames; + outputTypes["otuheirarchy"] = tempOutNames; + } + catch(exception& e) { + m->errorOut(e, "OtuHierarchyCommand", "OtuHierarchyCommand"); + exit(1); + } +} +//********************************************************************************************************************** +OtuHierarchyCommand::OtuHierarchyCommand(string option) { + try { + abort = false; calledHelp = false; + //allow user to run help - if(option == "help") { help(); abort = true; } + if(option == "help") { help(); abort = true; calledHelp = true; } + else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { - //valid paramters for this command - string Array[] = {"list","label","output","outputdir","inputdir"}; - vector myArray (Array, Array+(sizeof(Array)/sizeof(string))); + vector myArray = setParameters(); OptionParser parser(option); map parameters = parser.getParameters(); @@ -32,6 +97,10 @@ OtuHierarchyCommand::OtuHierarchyCommand(string option){ if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; } } + //initialize outputTypes + vector tempOutNames; + outputTypes["otuheirarchy"] = 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 = ""; } @@ -40,75 +109,61 @@ OtuHierarchyCommand::OtuHierarchyCommand(string option){ it = parameters.find("list"); //user has given a template file if(it != parameters.end()){ - path = hasPath(it->second); + path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. if (path == "") { parameters["list"] = inputDir + it->second; } } } listFile = validParameter.validFile(parameters, "list", true); - if (listFile == "not found") { mothurOut("list is a required parameter for the otu.hierarchy command."); mothurOutEndLine(); abort = true; } - else if (listFile == "not open") { abort = true; } + if (listFile == "not found") { + listFile = m->getListFile(); + if (listFile != "") { m->mothurOut("Using " + listFile + " as input file for the list parameter."); m->mothurOutEndLine(); } + else { + m->mothurOut("No valid current list file. You must provide a list file."); m->mothurOutEndLine(); + abort = true; + } + }else if (listFile == "not open") { abort = true; } + else { m->setListFile(listFile); } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; - outputDir += hasPath(listFile); //if user entered a file with a path then preserve it + outputDir += m->hasPath(listFile); //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") { mothurOut("label is a required parameter for the otu.hierarchy command."); mothurOutEndLine(); abort = true; } + if (label == "not found") { m->mothurOut("label is a required parameter for the otu.hierarchy command."); m->mothurOutEndLine(); abort = true; } else { - splitAtDash(label, labels); - if (labels.size() != 2) { mothurOut("You must provide 2 labels."); mothurOutEndLine(); abort = true; } + m->splitAtDash(label, labels); + if (labels.size() != 2) { m->mothurOut("You must provide 2 labels."); m->mothurOutEndLine(); abort = true; } } output = validParameter.validFile(parameters, "output", false); if (output == "not found") { output = "name"; } - if ((output != "name") && (output != "number")) { mothurOut("output options are name and number. I will use name."); mothurOutEndLine(); output = "name"; } + if ((output != "name") && (output != "number")) { m->mothurOut("output options are name and number. I will use name."); m->mothurOutEndLine(); output = "name"; } } } catch(exception& e) { - errorOut(e, "OtuHierarchyCommand", "OtuHierarchyCommand"); + m->errorOut(e, "OtuHierarchyCommand", "OtuHierarchyCommand"); exit(1); } } //********************************************************************************************************************** -void OtuHierarchyCommand::help(){ - try { - mothurOut("The otu.hierarchy command is used to see how otus relate at two distances. \n"); - mothurOut("The otu.hierarchy command parameters are list, label and output. list and label parameters are required. \n"); - mothurOut("The output parameter allows you to output the names of the sequence in the OTUs or the OTU numbers. Options are name and number, default is name. \n"); - mothurOut("The otu.hierarchy command should be in the following format: \n"); - mothurOut("otu.hierarchy(list=yourListFile, label=yourLabels).\n"); - mothurOut("Example otu.hierarchy(list=amazon.fn.list, label=0.01-0.03).\n"); - mothurOut("The otu.hierarchy command outputs a .otu.hierarchy file which is described on the wiki.\n"); - mothurOut("Note: No spaces between parameter labels (i.e. list), '=' and parameters (i.e.yourListFile).\n\n"); - } - catch(exception& e) { - errorOut(e, "OtuHierarchyCommand", "help"); - exit(1); - } -} - -//********************************************************************************************************************** - -OtuHierarchyCommand::~OtuHierarchyCommand(){} - -//********************************************************************************************************************** - int OtuHierarchyCommand::execute(){ try { - if (abort == true) { return 0; } + if (abort == true) { if (calledHelp) { return 0; } return 2; } //get listvectors that correspond to labels requested, (or use smart distancing to get closest listvector) vector lists = getListVectors(); + if (m->control_pressed) { outputTypes.clear(); return 0; } + //determine which is little and which is big, putting little first if (lists.size() == 2) { //if big is first swap them @@ -116,55 +171,52 @@ int OtuHierarchyCommand::execute(){ reverse(lists.begin(), lists.end()); } }else{ - mothurOut("error getting listvectors, unable to read 2 different vectors, check your label inputs."); mothurOutEndLine(); return 0; + m->mothurOut("error getting listvectors, unable to read 2 different vectors, check your label inputs."); m->mothurOutEndLine(); return 0; } //map sequences to bin number in the "little" otu - map littleBins; + map littleBins; + vector binLabels0 = lists[0].getLabels(); for (int i = 0; i < lists[0].getNumBins(); i++) { - string names = lists[0].get(i); - - //parse bin - while (names.find_first_of(',') != -1) { - string name = names.substr(0,names.find_first_of(',')); - names = names.substr(names.find_first_of(',')+1, names.length()); - littleBins[name] = i; - } - - //get last name - littleBins[names] = i; - } + + if (m->control_pressed) { return 0; } + string bin = lists[0].get(i); + vector names; m->splitAtComma(bin, names); + for (int j = 0; j < names.size(); j++) { littleBins[names[j]] = i; } + } ofstream out; - string outputFileName = outputDir + getRootName(getSimpleName(listFile)) + lists[0].getLabel() + "-" + lists[1].getLabel() + ".otu.hierarchy"; - openOutputFile(outputFileName, out); + map variables; + variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(listFile)); + variables["[distance1]"] = lists[0].getLabel(); + variables["[tag]"] = "-"; + variables["[distance2]"] = lists[1].getLabel(); + string outputFileName = getOutputFileName("otuheirarchy",variables); + m->openOutputFile(outputFileName, out); //go through each bin in "big" otu and output the bins in "little" otu which created it + vector binLabels1 = lists[1].getLabels(); for (int i = 0; i < lists[1].getNumBins(); i++) { - string names = lists[1].get(i); + if (m->control_pressed) { outputTypes.clear(); out.close(); m->mothurRemove(outputFileName); return 0; } + + string binnames = lists[1].get(i); + vector names; m->splitAtComma(binnames, names); //output column 1 - if (output == "name") { out << names << '\t'; } - else { out << i << '\t'; } + if (output == "name") { out << binnames << '\t'; } + else { out << binLabels1[i] << '\t'; } map bins; //bin numbers in little that are in this bin in big map::iterator it; //parse bin - while (names.find_first_of(',') != -1) { - string name = names.substr(0,names.find_first_of(',')); - names = names.substr(names.find_first_of(',')+1, names.length()); - bins[littleBins[name]] = littleBins[name]; - } - - //get last name - bins[littleBins[names]] = littleBins[names]; + for (int j = 0; j < names.size(); j++) { bins[littleBins[names[j]]] = littleBins[names[j]]; } string col2 = ""; for (it = bins.begin(); it != bins.end(); it++) { if (output == "name") { col2 += lists[0].get(it->first) + "\t"; } - else { col2 += toString(it->first) + "\t"; } + else { col2 += binLabels0[it->first] + "\t"; } } //output column 2 @@ -173,10 +225,17 @@ int OtuHierarchyCommand::execute(){ out.close(); + if (m->control_pressed) { outputTypes.clear(); m->mothurRemove(outputFileName); return 0; } + + m->mothurOutEndLine(); + m->mothurOut("Output File Names: "); m->mothurOutEndLine(); + m->mothurOut(outputFileName); m->mothurOutEndLine(); outputNames.push_back(outputFileName); outputTypes["otuheirarchy"].push_back(outputFileName); + m->mothurOutEndLine(); + return 0; } catch(exception& e) { - errorOut(e, "OtuHierarchyCommand", "execute"); + m->errorOut(e, "OtuHierarchyCommand", "execute"); exit(1); } } @@ -196,7 +255,7 @@ vector OtuHierarchyCommand::getListVectors() { //open file ifstream in; - openInputFile(listFile, in); + m->openInputFile(listFile, in); //get first list vector in file ListVector* list = NULL; @@ -205,11 +264,13 @@ vector OtuHierarchyCommand::getListVectors() { pos = in.tellg(); lastPos = pos; list = new ListVector(in); - gobble(in); + m->gobble(in); lastLabel = list->getLabel(); } while ((list != NULL) && (userLabels.size() != 0)) { + + if (m->control_pressed) { in.close(); delete list; return lists; } //is this a listvector that we want? if(labels.count(list->getLabel()) == 1){ @@ -223,7 +284,7 @@ vector OtuHierarchyCommand::getListVectors() { } //you have a label the user want that is smaller than this label and the last label has not already been processed - if ((anyLabelsToProcess(list->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) { + if ((m->anyLabelsToProcess(list->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) { string saveLabel = list->getLabel(); int savePos = in.tellg(); @@ -254,25 +315,27 @@ vector OtuHierarchyCommand::getListVectors() { if (!in.eof()) { pos = in.tellg(); list = new ListVector(in); - gobble(in); + m->gobble(in); }else { list = NULL; } } - + if (m->control_pressed) { in.close(); return lists; } //output error messages about any remaining user labels set::iterator it; bool needToRun = false; for (it = userLabels.begin(); it != userLabels.end(); it++) { - mothurOut("Your file does not include the label " + *it); + m->mothurOut("Your file does not include the label " + *it); if (processedLabels.count(lastLabel) != 1) { - mothurOut(". I will use " + lastLabel + "."); mothurOutEndLine(); + m->mothurOut(". I will use " + lastLabel + "."); m->mothurOutEndLine(); needToRun = true; }else { - mothurOut(". Please refer to " + lastLabel + "."); mothurOutEndLine(); + m->mothurOut(". Please refer to " + lastLabel + "."); m->mothurOutEndLine(); } } + if (m->control_pressed) { in.close(); return lists; } + //run last label if you need to if (needToRun == true) { if (list != NULL) { delete list; } @@ -289,11 +352,11 @@ vector OtuHierarchyCommand::getListVectors() { } } - + in.close(); return lists; } catch(exception& e) { - errorOut(e, "OtuHierarchyCommand", "getListVectors"); + m->errorOut(e, "OtuHierarchyCommand", "getListVectors"); exit(1); } }