SequenceCountParser::SequenceCountParser(string fastafile, CountTable& countTable) {
try {
m = MothurOut::getInstance();
//initialize maps
if (countTable.hasGroupInfo()) {
namesOfGroups = countTable.getNamesOfGroups();
for (int i = 0; i < namesOfGroups.size(); i++) {
vector<Sequence> temp;
map<string, int> tempMap;
seqs[namesOfGroups[i]] = temp;
countTablePerGroup[namesOfGroups[i]] = tempMap;
}
//read fasta file making sure each sequence is in the group file
ifstream in;
m->openInputFile(fastafile, in);
int fastaCount = 0;
while (!in.eof()) {
if (m->control_pressed) { break; }
Sequence seq(in); m->gobble(in);
fastaCount++;
if (m->debug) { if((fastaCount) % 1000 == 0){ m->mothurOut("[DEBUG]: reading seq " + toString(fastaCount) + "\n."); } }
if (seq.getName() != "") {
allSeqsMap[seq.getName()] = seq.getName();
vector<int> groupCounts = countTable.getGroupCounts(seq.getName());
for (int i = 0; i < namesOfGroups.size(); i++) {
if (groupCounts[i] != 0) {
seqs[namesOfGroups[i]].push_back(seq);
countTablePerGroup[namesOfGroups[i]][seq.getName()] = groupCounts[i];
}
}
}
}
in.close();
}else { m->control_pressed = true; m->mothurOut("[ERROR]: cannot parse fasta file by group with a count table that does not include group data, please correct.\n"); }
}
catch(exception& e) {
m->errorOut(e, "SequenceCountParser", "SequenceCountParser");
exit(1);
}
}
//**********************************************************************************************************************
int SplitGroupCommand::runCount(){
try {
CountTable ct;
ct.readTable(countfile, true, false);
if (!ct.hasGroupInfo()) { m->mothurOut("[ERROR]: your count file does not contain group info, cannot split by group.\n"); m->control_pressed = true; }
if (m->control_pressed) { return 0; }
vector<string> namesGroups = ct.getNamesOfGroups();
SharedUtil util; util.setGroups(Groups, namesGroups);
//fill filehandles with neccessary ofstreams
map<string, string> ffiles; //group -> filename
map<string, string> cfiles; //group -> filename
for (int i=0; i<Groups.size(); i++) {
ofstream ftemp, ctemp;
map<string, string> variables;
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(fastafile));
variables["[group]"] = Groups[i];
string newFasta = getOutputFileName("fasta",variables);
outputNames.push_back(newFasta); outputTypes["fasta"].push_back(newFasta);
ffiles[Groups[i]] = newFasta;
m->openOutputFile(newFasta, ftemp); ftemp.close();
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(countfile));
string newCount = getOutputFileName("count",variables);
outputNames.push_back(newCount); outputTypes["count"].push_back(newCount);
cfiles[Groups[i]] = newCount;
m->openOutputFile(newCount, ctemp);
ctemp << "Representative_Sequence\ttotal\t" << Groups[i] << endl; ctemp.close();
}
ifstream in;
m->openInputFile(fastafile, in);
while (!in.eof()) {
Sequence seq(in); m->gobble(in);
if (m->control_pressed) { break; }
if (seq.getName() != "") {
vector<string> thisSeqsGroups = ct.getGroups(seq.getName());
for (int i = 0; i < thisSeqsGroups.size(); i++) {
if (m->inUsersGroups(thisSeqsGroups[i], Groups)) { //if this sequence belongs to a group we want them print
ofstream outf, outc;
m->openOutputFileAppend(ffiles[thisSeqsGroups[i]], outf);
seq.printSequence(outf); outf.close();
int numSeqs = ct.getGroupCount(seq.getName(), thisSeqsGroups[i]);
m->openOutputFileAppend(cfiles[thisSeqsGroups[i]], outc);
outc << seq.getName() << '\t' << numSeqs << '\t' << numSeqs << endl; outc.close();
}
}
}
}
in.close();
return 0;
}
catch(exception& e) {
m->errorOut(e, "SplitGroupCommand", "runCount");
exit(1);
}
}
int RemoveGroupsCommand::execute(){
try {
if (abort == true) { if (calledHelp) { return 0; } return 2; }
//get groups you want to remove
if (accnosfile != "") { m->readAccnos(accnosfile, Groups); m->setGroups(Groups); }
if (groupfile != "") {
groupMap = new GroupMap(groupfile);
groupMap->readMap();
//make sure groups are valid
//takes care of user setting groupNames that are invalid or setting groups=all
vector<string> namesGroups = groupMap->getNamesOfGroups();
vector<string> checkedGroups;
for (int i = 0; i < Groups.size(); i++) {
if (m->inUsersGroups(Groups[i], namesGroups)) { checkedGroups.push_back(Groups[i]); }
else { m->mothurOut("[WARNING]: " + Groups[i] + " is not a valid group in your groupfile, ignoring.\n"); }
}
if (checkedGroups.size() == 0) { m->mothurOut("[ERROR]: no valid groups, aborting.\n"); delete groupMap; return 0; }
else {
Groups = checkedGroups;
m->setGroups(Groups);
}
//fill names with names of sequences that are from the groups we want to remove
fillNames();
delete groupMap;
}else if (countfile != ""){
if ((fastafile != "") || (listfile != "") || (taxfile != "")) {
m->mothurOut("\n[NOTE]: The count file should contain only unique names, so mothur assumes your fasta, list and taxonomy files also contain only uniques.\n\n");
}
CountTable ct;
ct.readTable(countfile, true, false);
if (!ct.hasGroupInfo()) { m->mothurOut("[ERROR]: your count file does not contain group info, aborting.\n"); return 0; }
vector<string> gNamesOfGroups = ct.getNamesOfGroups();
SharedUtil util;
util.setGroups(Groups, gNamesOfGroups);
vector<string> namesOfSeqs = ct.getNamesOfSeqs();
sort(Groups.begin(), Groups.end());
for (int i = 0; i < namesOfSeqs.size(); i++) {
vector<string> thisSeqsGroups = ct.getGroups(namesOfSeqs[i]);
if (m->isSubset(Groups, thisSeqsGroups)) { //you only have seqs from these groups so remove you
names.insert(namesOfSeqs[i]);
}
}
}
if (m->control_pressed) { return 0; }
//read through the correct file and output lines you want to keep
if (namefile != "") { readName(); }
if (fastafile != "") { readFasta(); }
if (groupfile != "") { readGroup(); }
if (countfile != "") { readCount(); }
if (listfile != "") { readList(); }
if (taxfile != "") { readTax(); }
if (sharedfile != "") { readShared(); }
if (designfile != "") { readDesign(); }
if (m->control_pressed) { for (int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; }
if (outputNames.size() != 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();
//set fasta file as new current fastafile
string current = "";
itTypes = outputTypes.find("fasta");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setFastaFile(current); }
}
itTypes = outputTypes.find("name");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setNameFile(current); }
}
itTypes = outputTypes.find("group");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setGroupFile(current); }
}
itTypes = outputTypes.find("list");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setListFile(current); }
}
itTypes = outputTypes.find("taxonomy");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setTaxonomyFile(current); }
}
itTypes = outputTypes.find("shared");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setSharedFile(current); }
}
itTypes = outputTypes.find("design");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setDesignFile(current); }
}
itTypes = outputTypes.find("count");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setCountTableFile(current); }
}
}
return 0;
}
catch(exception& e) {
m->errorOut(e, "RemoveGroupsCommand", "execute");
exit(1);
}
}
//**********************************************************************************************************************
int RemoveRareCommand::processList(){
try {
//you must provide a label because the names in the listfile need to be consistent
string thisLabel = "";
if (allLines) { m->mothurOut("For the listfile you must select one label, using first label in your listfile."); m->mothurOutEndLine(); }
else if (labels.size() > 1) { m->mothurOut("For the listfile you must select one label, using " + (*labels.begin()) + "."); m->mothurOutEndLine(); thisLabel = *labels.begin(); }
else { thisLabel = *labels.begin(); }
InputData input(listfile, "list");
ListVector* list = input.getListVector();
//get first one or the one we want
if (thisLabel != "") {
//use smart distancing
set<string> userLabels; userLabels.insert(thisLabel);
set<string> processedLabels;
string lastLabel = list->getLabel();
while((list != NULL) && (userLabels.size() != 0)) {
if(userLabels.count(list->getLabel()) == 1){
processedLabels.insert(list->getLabel());
userLabels.erase(list->getLabel());
break;
}
if ((m->anyLabelsToProcess(list->getLabel(), userLabels, "") == true) && (processedLabels.count(lastLabel) != 1)) {
processedLabels.insert(list->getLabel());
userLabels.erase(list->getLabel());
delete list;
list = input.getListVector(lastLabel);
break;
}
lastLabel = list->getLabel();
delete list;
list = input.getListVector();
}
if (userLabels.size() != 0) {
m->mothurOut("Your file does not include the label " + thisLabel + ". I will use " + lastLabel + "."); m->mothurOutEndLine();
list = input.getListVector(lastLabel);
}
}
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += m->hasPath(listfile); }
map<string, string> variables;
variables["[filename]"] = thisOutputDir + m->getRootName(m->getSimpleName(listfile));
variables["[extension]"] = m->getExtension(listfile);
variables["[tag]"] = list->getLabel();
string outputFileName = getOutputFileName("list", variables);
variables["[filename]"] = thisOutputDir + m->getRootName(m->getSimpleName(groupfile));
variables["[extension]"] = m->getExtension(groupfile);
string outputGroupFileName = getOutputFileName("group", variables);
variables["[filename]"] = thisOutputDir + m->getRootName(m->getSimpleName(countfile));
variables["[extension]"] = m->getExtension(countfile);
string outputCountFileName = getOutputFileName("count", variables);
ofstream out, outGroup;
m->openOutputFile(outputFileName, out);
bool wroteSomething = false;
//if groupfile is given then use it
GroupMap* groupMap;
CountTable ct;
if (groupfile != "") {
groupMap = new GroupMap(groupfile); groupMap->readMap();
SharedUtil util;
vector<string> namesGroups = groupMap->getNamesOfGroups();
util.setGroups(Groups, namesGroups);
m->openOutputFile(outputGroupFileName, outGroup);
}else if (countfile != "") {
ct.readTable(countfile, true, false);
if (ct.hasGroupInfo()) {
vector<string> namesGroups = ct.getNamesOfGroups();
SharedUtil util;
util.setGroups(Groups, namesGroups);
}
}
if (list != NULL) {
vector<string> binLabels = list->getLabels();
vector<string> newLabels;
//make a new list vector
ListVector newList;
newList.setLabel(list->getLabel());
//for each bin
for (int i = 0; i < list->getNumBins(); i++) {
if (m->control_pressed) { if (groupfile != "") { delete groupMap; outGroup.close(); m->mothurRemove(outputGroupFileName); } out.close(); m->mothurRemove(outputFileName); return 0; }
//parse out names that are in accnos file
string binnames = list->get(i);
vector<string> names;
string saveBinNames = binnames;
m->splitAtComma(binnames, names);
int binsize = names.size();
vector<string> newGroupFile;
if (groupfile != "") {
vector<string> newNames;
saveBinNames = "";
for(int k = 0; k < names.size(); k++) {
string group = groupMap->getGroup(names[k]);
if (m->inUsersGroups(group, Groups)) {
newGroupFile.push_back(names[k] + "\t" + group);
newNames.push_back(names[k]);
saveBinNames += names[k] + ",";
}
}
names = newNames; binsize = names.size();
saveBinNames = saveBinNames.substr(0, saveBinNames.length()-1);
}else if (countfile != "") {
saveBinNames = "";
binsize = 0;
for(int k = 0; k < names.size(); k++) {
if (ct.hasGroupInfo()) {
vector<string> thisSeqsGroups = ct.getGroups(names[k]);
int thisSeqsCount = 0;
for (int n = 0; n < thisSeqsGroups.size(); n++) {
if (m->inUsersGroups(thisSeqsGroups[n], Groups)) {
thisSeqsCount += ct.getGroupCount(names[k], thisSeqsGroups[n]);
}
}
binsize += thisSeqsCount;
//if you don't have any seqs from the groups the user wants, then remove you.
if (thisSeqsCount == 0) { newGroupFile.push_back(names[k]); }
else { saveBinNames += names[k] + ","; }
}else {
binsize += ct.getNumSeqs(names[k]);
saveBinNames += names[k] + ",";
}
}
saveBinNames = saveBinNames.substr(0, saveBinNames.length()-1);
}
if (binsize > nseqs) { //keep bin
newList.push_back(saveBinNames);
newLabels.push_back(binLabels[i]);
if (groupfile != "") { for(int k = 0; k < newGroupFile.size(); k++) { outGroup << newGroupFile[k] << endl; } }
else if (countfile != "") { for(int k = 0; k < newGroupFile.size(); k++) { ct.remove(newGroupFile[k]); } }
}else { if (countfile != "") { for(int k = 0; k < names.size(); k++) { ct.remove(names[k]); } } }
}
//print new listvector
if (newList.getNumBins() != 0) {
wroteSomething = true;
newList.setLabels(newLabels);
newList.printHeaders(out);
newList.print(out);
}
}
out.close();
if (groupfile != "") { outGroup.close(); outputTypes["group"].push_back(outputGroupFileName); outputNames.push_back(outputGroupFileName); }
if (countfile != "") {
if (ct.hasGroupInfo()) {
vector<string> allGroups = ct.getNamesOfGroups();
for (int i = 0; i < allGroups.size(); i++) {
if (!m->inUsersGroups(allGroups[i], Groups)) { ct.removeGroup(allGroups[i]); }
}
}
ct.printTable(outputCountFileName);
outputTypes["count"].push_back(outputCountFileName); outputNames.push_back(outputCountFileName);
}
if (wroteSomething == false) { m->mothurOut("Your file contains only rare sequences."); m->mothurOutEndLine(); }
outputTypes["list"].push_back(outputFileName); outputNames.push_back(outputFileName);
return 0;
}
catch(exception& e) {
m->errorOut(e, "RemoveRareCommand", "processList");
exit(1);
}
}