//**********************************************************************************************************************
int ListSeqsCommand::readCount(){
try {
CountTable ct;
ct.readTable(countfile, false, false);
if (m->control_pressed) { return 0; }
names = ct.getNamesOfSeqs();
return 0;
}
catch(exception& e) {
m->errorOut(e, "ListSeqsCommand", "readCount");
exit(1);
}
}
int MergeGroupsCommand::processCountFile(DesignMap*& designMap){
try {
CountTable countTable;
if (!countTable.testGroups(countfile)) { m->mothurOut("[ERROR]: your countfile contains no group information, please correct.\n"); m->setControl_pressed(true); return 0; }
//read countTable
countTable.readTable(countfile, true, false);
//fill Groups - checks for "all" and for any typo groups
vector<string> nameGroups = countTable.getNamesOfGroups();
if (Groups.size() == 0) { Groups = nameGroups; }
vector<string> dnamesGroups = designMap->getNamesGroups();
//sanity check
bool error = false;
if (nameGroups.size() == dnamesGroups.size()) { //at least there are the same number
//is every group in counttable also in designmap
for (int i = 0; i < nameGroups.size(); i++) {
if (m->getControl_pressed()) { break; }
if (!util.inUsersGroups(nameGroups[i], dnamesGroups)) { error = true; break; }
}
}
if (error) { m->mothurOut("[ERROR]: Your countfile does not contain the same groups as your design file, please correct\n"); m->setControl_pressed(true); return 0; }
//user selected groups - remove some groups from table
if (Groups.size() != nameGroups.size()) {
for (int i = 0; i < nameGroups.size(); i++) {
if (!util.inUsersGroups(nameGroups[i], Groups)) { countTable.removeGroup(nameGroups[i]); }
}
}
//ask again in case order changed
nameGroups = countTable.getNamesOfGroups();
int numGroups = nameGroups.size();
//create new table
CountTable newTable;
vector<string> treatments = designMap->getCategory();
map<string, vector<int> > clearedMap;
for (int i = 0; i < treatments.size(); i++) {
newTable.addGroup(treatments[i]);
vector<int> temp;
clearedMap[treatments[i]] = temp;
}
treatments = newTable.getNamesOfGroups();
set<string> namesToRemove;
vector<string> namesOfSeqs = countTable.getNamesOfSeqs();
for (int i = 0; i < namesOfSeqs.size(); i++) {
if (m->getControl_pressed()) { break; }
vector<int> thisSeqsCounts = countTable.getGroupCounts(namesOfSeqs[i]);
map<string, vector<int> > thisSeqsMap = clearedMap;
for (int j = 0; j < numGroups; j++) {
thisSeqsMap[designMap->get(nameGroups[j])].push_back(thisSeqsCounts[j]);
}
//create new counts for seq for new table
vector<int> newCounts; int totalAbund = 0;
for (int j = 0; j < treatments.size(); j++){
int abund = mergeAbund(thisSeqsMap[treatments[j]]);
newCounts.push_back(abund); //order matters, add in count for each treatment in new table.
totalAbund += abund;
}
//add seq to new table
if(totalAbund == 0) {
namesToRemove.insert(namesOfSeqs[i]);
}else { newTable.push_back(namesOfSeqs[i], newCounts); }
}
if (error) { m->setControl_pressed(true); return 0; }
//remove sequences zeroed out by median method
if (namesToRemove.size() != 0) {
//print names
ofstream out;
string accnosFile = "accnosFile.temp";
util.openOutputFile(accnosFile, out);
//output to .accnos file
for (set<string>::iterator it = namesToRemove.begin(); it != namesToRemove.end(); it++) {
if (m->getControl_pressed()) { out.close(); util.mothurRemove(accnosFile); return 0; }
out << *it << endl;
}
out.close();
//run remove.seqs
string inputString = "accnos=" + accnosFile + ", fasta=" + fastafile;
m->mothurOut("/******************************************/"); m->mothurOutEndLine();
m->mothurOut("Running command: remove.seqs(" + inputString + ")"); m->mothurOutEndLine();
current->setMothurCalling(true);
Command* removeCommand = new RemoveSeqsCommand(inputString);
removeCommand->execute();
map<string, vector<string> > filenames = removeCommand->getOutputFiles();
delete removeCommand;
current->setMothurCalling(false);
m->mothurOut("/******************************************/"); m->mothurOutEndLine();
util.mothurRemove(accnosFile);
}
string thisOutputDir = outputDir;
if (outputDir == "") { thisOutputDir += util.hasPath(countfile); }
map<string, string> variables;
variables["[filename]"] = thisOutputDir + util.getRootName(util.getSimpleName(countfile));
variables["[extension]"] = util.getExtension(countfile);
string outputFileName = getOutputFileName("count", variables);
outputTypes["count"].push_back(outputFileName); outputNames.push_back(outputFileName);
newTable.printTable(outputFileName);
return 0;
}
catch(exception& e) {
m->errorOut(e, "MergeGroupsCommand", "processCountFile");
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 SharedCommand::createSharedFromListGroup() {
try {
GroupMap* groupMap = NULL;
CountTable* countTable = NULL;
pickedGroups = false;
if (groupfile != "") {
groupMap = new GroupMap(groupfile);
int groupError = groupMap->readMap();
if (groupError == 1) { delete groupMap; return 0; }
vector<string> allGroups = groupMap->getNamesOfGroups();
if (Groups.size() == 0) { Groups = allGroups; }
else { pickedGroups = true; }
}else{
countTable = new CountTable();
countTable->readTable(countfile, true, false);
vector<string> allGroups = countTable->getNamesOfGroups();
if (Groups.size() == 0) { Groups = allGroups; }
else { pickedGroups = true; }
}
int numGroups = Groups.size();
if (m->getControl_pressed()) { return 0; }
ofstream out;
string filename = "";
if (!pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
util.openOutputFile(filename, out);
}
//set fileroot
fileroot = outputDir + util.getRootName(util.getSimpleName(listfile));
map<string, string> variables;
variables["[filename]"] = fileroot;
string errorOff = "no error";
InputData input(listfile, "shared", Groups);
SharedListVector* SharedList = input.getSharedListVector();
string lastLabel = SharedList->getLabel();
SharedRAbundVectors* lookup;
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
out.close(); if (!pickedGroups) { util.mothurRemove(filename); }
return 0;
}
//sanity check
vector<string> namesSeqs;
int numGroupNames = 0;
if (current->getGroupMode() == "group") { namesSeqs = groupMap->getNamesSeqs(); numGroupNames = groupMap->getNumSeqs(); }
else { namesSeqs = countTable->getNamesOfSeqs(); numGroupNames = countTable->getNumUniqueSeqs(); }
int error = ListGroupSameSeqs(namesSeqs, SharedList);
if ((!pickedGroups) && (SharedList->getNumSeqs() != numGroupNames)) { //if the user has not specified any groups and their files don't match exit with error
m->mothurOut("Your group file contains " + toString(numGroupNames) + " sequences and list file contains " + toString(SharedList->getNumSeqs()) + " sequences. Please correct.\n"); m->setControl_pressed(true);
out.close(); if (!pickedGroups) { util.mothurRemove(filename); } //remove blank shared file you made
//delete memory
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
return 0;
}
if (error == 1) { m->setControl_pressed(true); }
//if user has specified groups make new groupfile for them
if ((pickedGroups) && (current->getGroupMode() == "group")) { //make new group file
string groups = "";
if (numGroups < 4) {
for (int i = 0; i < numGroups-1; i++) {
groups += Groups[i] + ".";
}
groups+=Groups[numGroups-1];
}else { groups = "merge"; }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(listfile));
variables["[group]"] = groups;
string newGroupFile = getOutputFileName("group",variables);
outputTypes["group"].push_back(newGroupFile);
outputNames.push_back(newGroupFile);
ofstream outGroups;
util.openOutputFile(newGroupFile, outGroups);
vector<string> names = groupMap->getNamesSeqs();
string groupName;
for (int i = 0; i < names.size(); i++) {
groupName = groupMap->getGroup(names[i]);
if (isValidGroup(groupName, Groups)) {
outGroups << names[i] << '\t' << groupName << endl;
}
}
outGroups.close();
}
//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;
bool printHeaders = true;
while((SharedList != NULL) && ((allLines == 1) || (userLabels.size() != 0))) {
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
if(allLines == 1 || labels.count(SharedList->getLabel()) == 1){
lookup = SharedList->getSharedRAbundVector();
m->mothurOut(lookup->getLabel()+"\n");
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
delete lookup;
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
//if picked groups must split the shared file by label
if (pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
variables["[distance]"] = lookup->getLabel();
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
ofstream out2;
util.openOutputFile(filename, out2);
lookup->eliminateZeroOTUS();
printSharedData(lookup, out2, printHeaders);
out2.close();
}else {
printSharedData(lookup, out, printHeaders); //prints info to the .shared file
}
delete lookup;
processedLabels.insert(SharedList->getLabel());
userLabels.erase(SharedList->getLabel());
}
if ((util.anyLabelsToProcess(SharedList->getLabel(), userLabels, errorOff) ) && (processedLabels.count(lastLabel) != 1)) {
string saveLabel = SharedList->getLabel();
delete SharedList;
SharedList = input.getSharedListVector(lastLabel); //get new list vector to process
lookup = SharedList->getSharedRAbundVector();
m->mothurOut(lookup->getLabel()+"\n");
if (m->getControl_pressed()) {
delete SharedList; if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
delete lookup;
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
//if picked groups must split the shared file by label
if (pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
variables["[distance]"] = lookup->getLabel();
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
ofstream out2;
util.openOutputFile(filename, out2);
lookup->eliminateZeroOTUS();
printSharedData(lookup, out2, printHeaders);
out2.close();
}else {
printSharedData(lookup, out, printHeaders); //prints info to the .shared file
}
delete lookup;
processedLabels.insert(SharedList->getLabel());
userLabels.erase(SharedList->getLabel());
//restore real lastlabel to save below
SharedList->setLabel(saveLabel);
}
lastLabel = SharedList->getLabel();
delete SharedList;
SharedList = input.getSharedListVector(); //get new list vector to process
}
//output error messages about any remaining user labels
set<string>::iterator it;
bool needToRun = false;
for (it = userLabels.begin(); it != userLabels.end(); it++) {
if (processedLabels.count(lastLabel) != 1) {
needToRun = true;
}
}
//run last label if you need to
if (needToRun ) {
if (SharedList != NULL) { delete SharedList; }
SharedList = input.getSharedListVector(lastLabel); //get new list vector to process
lookup = SharedList->getSharedRAbundVector();
m->mothurOut(lookup->getLabel()+"\n");
if (m->getControl_pressed()) {
if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
if (!pickedGroups) { out.close(); util.mothurRemove(filename); }
return 0;
}
//if picked groups must split the shared file by label
if (pickedGroups) {
string filename = listfile;
if (outputDir == "") { outputDir += util.hasPath(filename); }
map<string, string> variables;
variables["[filename]"] = outputDir + util.getRootName(util.getSimpleName(filename));
variables["[distance]"] = lookup->getLabel();
filename = getOutputFileName("shared",variables);
outputNames.push_back(filename); outputTypes["shared"].push_back(filename);
ofstream out2;
util.openOutputFile(filename, out2);
lookup->eliminateZeroOTUS();
printSharedData(lookup, out2, printHeaders);
out2.close();
}else {
printSharedData(lookup, out, printHeaders); //prints info to the .shared file
}
delete lookup;
delete SharedList;
}
if (!pickedGroups) { out.close(); }
if (groupMap != NULL) { delete groupMap; } if (countTable != NULL) { delete countTable; }
if (m->getControl_pressed()) {
if (!pickedGroups) { util.mothurRemove(filename); }
return 0;
}
return 0;
}
catch(exception& e) {
m->errorOut(e, "SharedCommand", "createSharedFromListGroup");
exit(1);
}
}
