2 * removegroupscommand.cpp
5 * Created by westcott on 11/10/10.
6 * Copyright 2010 Schloss Lab. All rights reserved.
10 #include "removegroupscommand.h"
11 #include "sequence.hpp"
12 #include "listvector.hpp"
13 #include "sharedutilities.h"
15 //**********************************************************************************************************************
16 vector<string> RemoveGroupsCommand::getValidParameters(){
18 string Array[] = {"fasta","name", "group", "accnos", "groups","list","taxonomy","outputdir","inputdir" };
19 vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
23 m->errorOut(e, "RemoveGroupsCommand", "getValidParameters");
27 //**********************************************************************************************************************
28 RemoveGroupsCommand::RemoveGroupsCommand(){
30 abort = true; calledHelp = true;
31 vector<string> tempOutNames;
32 outputTypes["fasta"] = tempOutNames;
33 outputTypes["taxonomy"] = tempOutNames;
34 outputTypes["name"] = tempOutNames;
35 outputTypes["group"] = tempOutNames;
36 outputTypes["list"] = tempOutNames;
39 m->errorOut(e, "RemoveGroupsCommand", "RemoveGroupsCommand");
43 //**********************************************************************************************************************
44 vector<string> RemoveGroupsCommand::getRequiredParameters(){
46 string Array[] = {"group"};
47 vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
51 m->errorOut(e, "RemoveGroupsCommand", "getRequiredParameters");
55 //**********************************************************************************************************************
56 vector<string> RemoveGroupsCommand::getRequiredFiles(){
58 vector<string> myArray;
62 m->errorOut(e, "RemoveGroupsCommand", "getRequiredFiles");
66 //**********************************************************************************************************************
67 RemoveGroupsCommand::RemoveGroupsCommand(string option) {
69 abort = false; calledHelp = false;
71 //allow user to run help
72 if(option == "help") { help(); abort = true; calledHelp = true; }
75 //valid paramters for this command
76 string Array[] = {"fasta","name", "group", "accnos", "groups", "list","taxonomy","outputdir","inputdir" };
77 vector<string> myArray (Array, Array+(sizeof(Array)/sizeof(string)));
79 OptionParser parser(option);
80 map<string,string> parameters = parser.getParameters();
82 ValidParameters validParameter;
83 map<string,string>::iterator it;
85 //check to make sure all parameters are valid for command
86 for (it = parameters.begin(); it != parameters.end(); it++) {
87 if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; }
90 //initialize outputTypes
91 vector<string> tempOutNames;
92 outputTypes["fasta"] = tempOutNames;
93 outputTypes["taxonomy"] = tempOutNames;
94 outputTypes["name"] = tempOutNames;
95 outputTypes["group"] = tempOutNames;
96 outputTypes["list"] = tempOutNames;
99 //if the user changes the output directory command factory will send this info to us in the output parameter
100 outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; }
102 //if the user changes the input directory command factory will send this info to us in the output parameter
103 string inputDir = validParameter.validFile(parameters, "inputdir", false);
104 if (inputDir == "not found"){ inputDir = ""; }
107 it = parameters.find("fasta");
108 //user has given a template file
109 if(it != parameters.end()){
110 path = m->hasPath(it->second);
111 //if the user has not given a path then, add inputdir. else leave path alone.
112 if (path == "") { parameters["fasta"] = inputDir + it->second; }
115 it = parameters.find("accnos");
116 //user has given a template file
117 if(it != parameters.end()){
118 path = m->hasPath(it->second);
119 //if the user has not given a path then, add inputdir. else leave path alone.
120 if (path == "") { parameters["accnos"] = inputDir + it->second; }
123 it = parameters.find("list");
124 //user has given a template file
125 if(it != parameters.end()){
126 path = m->hasPath(it->second);
127 //if the user has not given a path then, add inputdir. else leave path alone.
128 if (path == "") { parameters["list"] = inputDir + it->second; }
131 it = parameters.find("name");
132 //user has given a template file
133 if(it != parameters.end()){
134 path = m->hasPath(it->second);
135 //if the user has not given a path then, add inputdir. else leave path alone.
136 if (path == "") { parameters["name"] = inputDir + it->second; }
139 it = parameters.find("group");
140 //user has given a template file
141 if(it != parameters.end()){
142 path = m->hasPath(it->second);
143 //if the user has not given a path then, add inputdir. else leave path alone.
144 if (path == "") { parameters["group"] = inputDir + it->second; }
147 it = parameters.find("taxonomy");
148 //user has given a template file
149 if(it != parameters.end()){
150 path = m->hasPath(it->second);
151 //if the user has not given a path then, add inputdir. else leave path alone.
152 if (path == "") { parameters["taxonomy"] = inputDir + it->second; }
157 //check for required parameters
158 accnosfile = validParameter.validFile(parameters, "accnos", true);
159 if (accnosfile == "not open") { abort = true; }
160 else if (accnosfile == "not found") { accnosfile = ""; }
162 fastafile = validParameter.validFile(parameters, "fasta", true);
163 if (fastafile == "not open") { abort = true; }
164 else if (fastafile == "not found") { fastafile = ""; }
166 namefile = validParameter.validFile(parameters, "name", true);
167 if (namefile == "not open") { abort = true; }
168 else if (namefile == "not found") { namefile = ""; }
170 groupfile = validParameter.validFile(parameters, "group", true);
171 if (groupfile == "not open") { abort = true; }
172 else if (groupfile == "not found") { groupfile = ""; m->mothurOut("You must provide a group file."); m->mothurOutEndLine(); abort = true; }
174 listfile = validParameter.validFile(parameters, "list", true);
175 if (listfile == "not open") { abort = true; }
176 else if (listfile == "not found") { listfile = ""; }
178 taxfile = validParameter.validFile(parameters, "taxonomy", true);
179 if (taxfile == "not open") { abort = true; }
180 else if (taxfile == "not found") { taxfile = ""; }
182 groups = validParameter.validFile(parameters, "groups", false);
183 if (groups == "not found") { groups = ""; }
185 m->splitAtDash(groups, Groups);
188 if ((accnosfile == "") && (Groups.size() == 0)) { m->mothurOut("You must provide an accnos file or specify groups using the groups parameter."); m->mothurOutEndLine(); abort = true; }
190 if ((fastafile == "") && (namefile == "") && (groupfile == "") && (listfile == "") && (taxfile == "")) { m->mothurOut("You must provide at least one of the following: fasta, name, taxonomy, group or list."); m->mothurOutEndLine(); abort = true; }
194 catch(exception& e) {
195 m->errorOut(e, "RemoveGroupsCommand", "RemoveGroupsCommand");
199 //**********************************************************************************************************************
201 void RemoveGroupsCommand::help(){
203 m->mothurOut("The remove.groups command removes sequences from a specfic group or set of groups from the following file types: fasta, name, group, list, taxonomy.\n");
204 m->mothurOut("It outputs a file containing the sequences NOT in the those specified groups.\n");
205 m->mothurOut("The remove.groups command parameters are accnos, fasta, name, group, list, taxonomy and groups. The group parameter is required.\n");
206 m->mothurOut("You must also provide an accnos containing the list of groups to remove or set the groups parameter to the groups you wish to remove.\n");
207 m->mothurOut("The groups parameter allows you to specify which of the groups in your groupfile you would like removed. You can separate group names with dashes.\n");
208 m->mothurOut("The remove.groups command should be in the following format: remove.groups(accnos=yourAccnos, fasta=yourFasta, group=yourGroupFile).\n");
209 m->mothurOut("Example remove.seqs(accnos=amazon.accnos, fasta=amazon.fasta, group=amazon.groups).\n");
210 m->mothurOut("or remove.seqs(groups=pasture, fasta=amazon.fasta, amazon.groups).\n");
211 m->mothurOut("Note: No spaces between parameter labels (i.e. fasta), '=' and parameters (i.e.yourFasta).\n\n");
213 catch(exception& e) {
214 m->errorOut(e, "RemoveGroupsCommand", "help");
219 //**********************************************************************************************************************
221 int RemoveGroupsCommand::execute(){
224 if (abort == true) { if (calledHelp) { return 0; } return 2; }
226 groupMap = new GroupMap(groupfile);
229 //get groups you want to remove
230 if (accnosfile != "") { readAccnos(); }
232 //make sure groups are valid
233 //takes care of user setting groupNames that are invalid or setting groups=all
234 SharedUtil* util = new SharedUtil();
235 util->setGroups(Groups, groupMap->namesOfGroups);
238 //fill names with names of sequences that are from the groups we want to remove
241 if (m->control_pressed) { delete groupMap; return 0; }
243 //read through the correct file and output lines you want to keep
244 if (namefile != "") { readName(); }
245 if (fastafile != "") { readFasta(); }
246 if (groupfile != "") { readGroup(); }
247 if (listfile != "") { readList(); }
248 if (taxfile != "") { readTax(); }
250 if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { remove(outputNames[i].c_str()); } return 0; }
252 m->mothurOut("Removed " + toString(names.size()) + " sequences. From the groups: "); m->mothurOutEndLine();
253 for (int i = 0; i < Groups.size(); i++) { m->mothurOut(Groups[i]); m->mothurOut(" contains " + toString(groupMap->getNumSeqs(Groups[i])) + " sequences."); m->mothurOutEndLine(); }
254 m->mothurOutEndLine();
256 if (outputNames.size() != 0) {
257 m->mothurOutEndLine();
258 m->mothurOut("Output File names: "); m->mothurOutEndLine();
259 for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); }
260 m->mothurOutEndLine();
262 //set fasta file as new current fastafile
264 itTypes = outputTypes.find("fasta");
265 if (itTypes != outputTypes.end()) {
266 if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setFastaFile(current); }
269 itTypes = outputTypes.find("name");
270 if (itTypes != outputTypes.end()) {
271 if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setNameFile(current); }
274 itTypes = outputTypes.find("group");
275 if (itTypes != outputTypes.end()) {
276 if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setGroupFile(current); }
279 itTypes = outputTypes.find("list");
280 if (itTypes != outputTypes.end()) {
281 if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setListFile(current); }
284 itTypes = outputTypes.find("taxonomy");
285 if (itTypes != outputTypes.end()) {
286 if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setTaxonomyFile(current); }
293 catch(exception& e) {
294 m->errorOut(e, "RemoveGroupsCommand", "execute");
299 //**********************************************************************************************************************
300 int RemoveGroupsCommand::readFasta(){
302 string thisOutputDir = outputDir;
303 if (outputDir == "") { thisOutputDir += m->hasPath(fastafile); }
304 string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(fastafile)) + "pick" + m->getExtension(fastafile);
307 m->openOutputFile(outputFileName, out);
310 m->openInputFile(fastafile, in);
313 bool wroteSomething = false;
316 if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
318 Sequence currSeq(in);
319 name = currSeq.getName();
322 //if this name is in the accnos file
323 if (names.count(name) == 0) {
324 wroteSomething = true;
326 currSeq.printSequence(out);
334 if (wroteSomething == false) { m->mothurOut("Your file contains only sequences from the groups you wish to remove."); m->mothurOutEndLine(); }
335 outputTypes["fasta"].push_back(outputFileName); outputNames.push_back(outputFileName);
340 catch(exception& e) {
341 m->errorOut(e, "RemoveGroupsCommand", "readFasta");
346 //**********************************************************************************************************************
347 int RemoveGroupsCommand::readList(){
349 string thisOutputDir = outputDir;
350 if (outputDir == "") { thisOutputDir += m->hasPath(listfile); }
351 string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(listfile)) + "pick" + m->getExtension(listfile);
354 m->openOutputFile(outputFileName, out);
357 m->openInputFile(listfile, in);
359 bool wroteSomething = false;
362 //read in list vector
365 //make a new list vector
367 newList.setLabel(list.getLabel());
370 for (int i = 0; i < list.getNumBins(); i++) {
371 if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
373 //parse out names that are in accnos file
374 string binnames = list.get(i);
376 string newNames = "";
377 while (binnames.find_first_of(',') != -1) {
378 string name = binnames.substr(0,binnames.find_first_of(','));
379 binnames = binnames.substr(binnames.find_first_of(',')+1, binnames.length());
381 //if that name is in the .accnos file, add it
382 if (names.count(name) == 0) { newNames += name + ","; }
386 if (names.count(binnames) == 0) { newNames += binnames + ","; }
388 //if there are names in this bin add to new list
389 if (newNames != "") {
390 newNames = newNames.substr(0, newNames.length()-1); //rip off extra comma
391 newList.push_back(newNames);
395 //print new listvector
396 if (newList.getNumBins() != 0) {
397 wroteSomething = true;
406 if (wroteSomething == false) { m->mothurOut("Your file contains only sequences from the groups you wish to remove."); m->mothurOutEndLine(); }
407 outputTypes["list"].push_back(outputFileName); outputNames.push_back(outputFileName);
412 catch(exception& e) {
413 m->errorOut(e, "RemoveGroupsCommand", "readList");
417 //**********************************************************************************************************************
418 int RemoveGroupsCommand::readName(){
420 string thisOutputDir = outputDir;
421 if (outputDir == "") { thisOutputDir += m->hasPath(namefile); }
422 string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(namefile)) + "pick" + m->getExtension(namefile);
425 m->openOutputFile(outputFileName, out);
428 m->openInputFile(namefile, in);
429 string name, firstCol, secondCol;
431 bool wroteSomething = false;
434 if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
436 in >> firstCol; m->gobble(in);
439 vector<string> parsedNames;
440 m->splitAtComma(secondCol, parsedNames);
442 vector<string> validSecond; validSecond.clear();
443 for (int i = 0; i < parsedNames.size(); i++) {
444 if (names.count(parsedNames[i]) == 0) {
445 validSecond.push_back(parsedNames[i]);
450 //if the name in the first column is in the set then print it and any other names in second column also in set
451 if (names.count(firstCol) == 0) {
453 wroteSomething = true;
455 out << firstCol << '\t';
457 //you know you have at least one valid second since first column is valid
458 for (int i = 0; i < validSecond.size()-1; i++) { out << validSecond[i] << ','; }
459 out << validSecond[validSecond.size()-1] << endl;
461 //make first name in set you come to first column and then add the remaining names to second column
464 //you want part of this row
465 if (validSecond.size() != 0) {
467 wroteSomething = true;
469 out << validSecond[0] << '\t';
471 //you know you have at least one valid second since first column is valid
472 for (int i = 0; i < validSecond.size()-1; i++) { out << validSecond[i] << ','; }
473 out << validSecond[validSecond.size()-1] << endl;
482 if (wroteSomething == false) { m->mothurOut("Your file contains only sequences from the groups you wish to remove."); m->mothurOutEndLine(); }
483 outputTypes["name"].push_back(outputFileName); outputNames.push_back(outputFileName);
487 catch(exception& e) {
488 m->errorOut(e, "RemoveGroupsCommand", "readName");
493 //**********************************************************************************************************************
494 int RemoveGroupsCommand::readGroup(){
496 string thisOutputDir = outputDir;
497 if (outputDir == "") { thisOutputDir += m->hasPath(groupfile); }
498 string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(groupfile)) + "pick" + m->getExtension(groupfile);
501 m->openOutputFile(outputFileName, out);
504 m->openInputFile(groupfile, in);
507 bool wroteSomething = false;
510 if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
512 in >> name; //read from first column
513 in >> group; //read from second column
515 //if this name is in the accnos file
516 if (names.count(name) == 0) {
517 wroteSomething = true;
518 out << name << '\t' << group << endl;
526 if (wroteSomething == false) { m->mothurOut("Your file contains only sequences from the groups you wish to remove."); m->mothurOutEndLine(); }
527 outputTypes["group"].push_back(outputFileName); outputNames.push_back(outputFileName);
531 catch(exception& e) {
532 m->errorOut(e, "RemoveGroupsCommand", "readGroup");
536 //**********************************************************************************************************************
537 int RemoveGroupsCommand::readTax(){
539 string thisOutputDir = outputDir;
540 if (outputDir == "") { thisOutputDir += m->hasPath(taxfile); }
541 string outputFileName = thisOutputDir + m->getRootName(m->getSimpleName(taxfile)) + "pick" + m->getExtension(taxfile);
543 m->openOutputFile(outputFileName, out);
546 m->openInputFile(taxfile, in);
549 bool wroteSomething = false;
552 if (m->control_pressed) { in.close(); out.close(); remove(outputFileName.c_str()); return 0; }
554 in >> name; //read from first column
555 in >> tax; //read from second column
557 //if this name is in the accnos file
558 if (names.count(name) == 0) {
559 wroteSomething = true;
560 out << name << '\t' << tax << endl;
568 if (wroteSomething == false) { m->mothurOut("Your file contains only sequences from the groups you wish to remove."); m->mothurOutEndLine(); }
569 outputTypes["taxonomy"].push_back(outputFileName); outputNames.push_back(outputFileName);
573 catch(exception& e) {
574 m->errorOut(e, "RemoveGroupsCommand", "readTax");
578 //**********************************************************************************************************************
579 void RemoveGroupsCommand::readAccnos(){
584 m->openInputFile(accnosfile, in);
590 Groups.push_back(name);
597 catch(exception& e) {
598 m->errorOut(e, "RemoveGroupsCommand", "readAccnos");
602 //**********************************************************************************************************************
603 int RemoveGroupsCommand::fillNames(){
605 vector<string> seqs = groupMap->getNamesSeqs();
607 for (int i = 0; i < seqs.size(); i++) {
609 if (m->control_pressed) { return 0; }
611 string group = groupMap->getGroup(seqs[i]);
613 if (m->inUsersGroups(group, Groups)) {
614 names.insert(seqs[i]);
620 catch(exception& e) {
621 m->errorOut(e, "RemoveGroupsCommand", "fillNames");
626 //**********************************************************************************************************************