X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=mothurout.cpp;h=dc77490e4b9bba1bc9bf6e4c16b0f402985c73d1;hb=eb71e28b7b7afd82540f4a8f0bac9429c5b9d713;hp=6ecb86f94e5533165551ed5ae571f0c51f3c9ff9;hpb=791f42d21a85f794529fd4c912dcc27d873c25e8;p=mothur.git diff --git a/mothurout.cpp b/mothurout.cpp index 6ecb86f..dc77490 100644 --- a/mothurout.cpp +++ b/mothurout.cpp @@ -18,8 +18,46 @@ MothurOut* MothurOut::getInstance() { return _uniqueInstance; } /*********************************************************************************************/ +set MothurOut::getCurrentTypes() { + try { + + set types; + types.insert("fasta"); + types.insert("accnos"); + types.insert("column"); + types.insert("design"); + types.insert("group"); + types.insert("list"); + types.insert("name"); + types.insert("oligos"); + types.insert("order"); + types.insert("ordergroup"); + types.insert("phylip"); + types.insert("qfile"); + types.insert("relabund"); + types.insert("sabund"); + types.insert("rabund"); + types.insert("sff"); + types.insert("shared"); + types.insert("taxonomy"); + types.insert("tree"); + types.insert("flow"); + types.insert("biom"); + types.insert("count"); + types.insert("processors"); + + return types; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getCurrentTypes"); + exit(1); + } +} +/*********************************************************************************************/ void MothurOut::printCurrentFiles() { try { + + if (accnosfile != "") { mothurOut("accnos=" + accnosfile); mothurOutEndLine(); } if (columnfile != "") { mothurOut("column=" + columnfile); mothurOutEndLine(); } if (designfile != "") { mothurOut("design=" + designfile); mothurOutEndLine(); } @@ -41,6 +79,7 @@ void MothurOut::printCurrentFiles() { if (treefile != "") { mothurOut("tree=" + treefile); mothurOutEndLine(); } if (flowfile != "") { mothurOut("flow=" + flowfile); mothurOutEndLine(); } if (biomfile != "") { mothurOut("biom=" + biomfile); mothurOutEndLine(); } + if (counttablefile != "") { mothurOut("count=" + counttablefile); mothurOutEndLine(); } if (processors != "1") { mothurOut("processors=" + processors); mothurOutEndLine(); } } @@ -75,6 +114,7 @@ bool MothurOut::hasCurrentFiles() { if (treefile != "") { return true; } if (flowfile != "") { return true; } if (biomfile != "") { return true; } + if (counttablefile != "") { return true; } if (processors != "1") { return true; } return hasCurrent; @@ -110,6 +150,7 @@ void MothurOut::clearCurrentFiles() { taxonomyfile = ""; flowfile = ""; biomfile = ""; + counttablefile = ""; processors = "1"; } catch(exception& e) { @@ -399,10 +440,22 @@ void MothurOut::errorOut(exception& e, string object, string function) { //double vm, rss; //mem_usage(vm, rss); - mothurOut("[ERROR]: "); - mothurOut(toString(e.what())); - mothurOut(" has occurred in the " + object + " class function " + function + ". Please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry."); - mothurOutEndLine(); + string errorType = toString(e.what()); + + int pos = errorType.find("bad_alloc"); + mothurOut("[ERROR]: "); + mothurOut(errorType); + + if (pos == string::npos) { //not bad_alloc + mothurOut(" has occurred in the " + object + " class function " + function + ". Please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry."); + mothurOutEndLine(); + }else { //bad alloc + if (object == "cluster"){ + mothurOut(" has occurred in the " + object + " class function " + function + ". This error indicates your computer is running out of memory. There are two common causes for this, file size and format.\n\nFile Size:\nThe cluster command loads your distance matrix into RAM, and your distance file is most likely too large to fit in RAM. There are two options to help with this. The first is to use a cutoff. By using a cutoff mothur will only load distances that are below the cutoff. If that is still not enough, there is a command called cluster.split, http://www.mothur.org/wiki/cluster.split which divides the distance matrix, and clusters the smaller pieces separately. You may also be able to reduce the size of the original distance matrix by using the commands outlined in the Schloss SOP, http://www.mothur.org/wiki/Schloss_SOP. \n\nWrong Format:\nThis error can be caused by trying to read a column formatted distance matrix using the phylip parameter. By default, the dist.seqs command generates a column formatted distance matrix. To make a phylip formatted matrix set the dist.seqs command parameter output to lt. \n\nIf you are uable to resolve the issue, please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry."); + }else { + mothurOut(" has occurred in the " + object + " class function " + function + ". This error indicates your computer is running out of memory. This is most commonly caused by trying to process a dataset too large, or a file format issue. If you are running our 32bit version, your memory usage is limited to 4G. If you have more than 4G of RAM and are running a 64bit OS, using our 64bit version may resolve your issue. Also, you may be able to reduce the size of your dataset by using the commands outlined in the Schloss SOP, http://www.mothur.org/wiki/Schloss_SOP. If you are uable to resolve the issue, please contact Pat Schloss at mothur.bugs@gmail.com, and be sure to include the mothur.logFile with your inquiry."); + } + } } /*********************************************************************************************/ //The following was originally from http://stackoverflow.com/questions/669438/how-to-get-memory-usage-at-run-time-in-c @@ -898,7 +951,7 @@ string MothurOut::getFullPathName(string fileName){ } for (int i = index; i >= 0; i--) { - newFileName = dirs[i] + "\\" + newFileName; + newFileName = dirs[i] + "\\\\" + newFileName; } return newFileName; @@ -1011,6 +1064,9 @@ int MothurOut::openInputFile(string fileName, ifstream& fileHandle){ int MothurOut::renameFile(string oldName, string newName){ try { + + if (oldName == newName) { return 0; } + ifstream inTest; int exist = openInputFile(newName, inTest, ""); inTest.close(); @@ -1092,11 +1148,14 @@ int MothurOut::appendFiles(string temp, string filename) { int numLines = 0; if (ableToOpen == 0) { //you opened it - while(!input.eof()){ - char c = input.get(); - if(input.eof()) { break; } - else { output << c; if (c == '\n') {numLines++;} } - } + + char buffer[4096]; + while (!input.eof()) { + input.read(buffer, 4096); + output.write(buffer, input.gcount()); + //count number of lines + for (int i = 0; i < input.gcount(); i++) { if (buffer[i] == '\n') {numLines++;} } + } input.close(); } @@ -1136,7 +1195,7 @@ string MothurOut::sortFile(string distFile, string outputDir){ string firstName, secondName; float dist; - while (input) { + while (!input.eof()) { input >> firstName >> secondName >> dist; output << dist << '\t' << firstName << '\t' << secondName << endl; gobble(input); @@ -1152,16 +1211,17 @@ string MothurOut::sortFile(string distFile, string outputDir){ //read in sorted file and put distance at end again ifstream input2; + ofstream output2; openInputFile(tempOutfile, input2); - openOutputFile(outfile, output); + openOutputFile(outfile, output2); - while (input2) { + while (!input2.eof()) { input2 >> dist >> firstName >> secondName; - output << firstName << '\t' << secondName << '\t' << dist << endl; + output2 << firstName << '\t' << secondName << '\t' << dist << endl; gobble(input2); } input2.close(); - output.close(); + output2.close(); //remove temp files mothurRemove(tempDistFile); @@ -1251,16 +1311,6 @@ vector MothurOut::setFilePosEachLine(string filename, int& n positions.push_back(0); while(!in.eof()){ - //unsigned long long lastpos = in.tellg(); - //input = getline(in); - //if (input.length() != 0) { - //unsigned long long pos = in.tellg(); - //if (pos != -1) { positions.push_back(pos - input.length() - 1); } - //else { positions.push_back(lastpos); } - //} - //gobble(in); //has to be here since windows line endings are 2 characters and mess up the positions - - //getline counting reads char d = in.get(); count++; while ((d != '\n') && (d != '\r') && (d != '\f') && (d != in.eof())) { @@ -1380,6 +1430,83 @@ vector MothurOut::divideFile(string filename, int& proc) { } } /**************************************************************************************************/ + +vector MothurOut::divideFilePerLine(string filename, int& proc) { + try{ + vector filePos; + filePos.push_back(0); + + FILE * pFile; + unsigned long long size; + + filename = getFullPathName(filename); + + //get num bytes in file + pFile = fopen (filename.c_str(),"rb"); + if (pFile==NULL) perror ("Error opening file"); + else{ + fseek (pFile, 0, SEEK_END); + size=ftell (pFile); + fclose (pFile); + } + +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + + //estimate file breaks + unsigned long long chunkSize = 0; + chunkSize = size / proc; + + //file to small to divide by processors + if (chunkSize == 0) { proc = 1; filePos.push_back(size); return filePos; } + + //for each process seekg to closest file break and search for next '>' char. make that the filebreak + for (int i = 0; i < proc; i++) { + unsigned long long spot = (i+1) * chunkSize; + + ifstream in; + openInputFile(filename, in); + in.seekg(spot); + + //look for next line break + unsigned long long newSpot = spot; + while (!in.eof()) { + char c = in.get(); + + if ((c == '\n') || (c == '\r') || (c == '\f')) { gobble(in); newSpot = in.tellg(); break; } + else if (int(c) == -1) { break; } + } + + //there was not another line before the end of the file + unsigned long long sanityPos = in.tellg(); + + if (sanityPos == -1) { break; } + else { filePos.push_back(newSpot); } + + in.close(); + } + + //save end pos + filePos.push_back(size); + + //sanity check filePos + for (int i = 0; i < (filePos.size()-1); i++) { + if (filePos[(i+1)] <= filePos[i]) { filePos.erase(filePos.begin()+(i+1)); i--; } + } + + proc = (filePos.size() - 1); +#else + mothurOut("[ERROR]: Windows version should not be calling the divideFile function."); mothurOutEndLine(); + proc=1; + filePos.push_back(size); +#endif + return filePos; + } + catch(exception& e) { + errorOut(e, "MothurOut", "divideFile"); + exit(1); + } +} +/**************************************************************************************************/ int MothurOut::divideFile(string filename, int& proc, vector& files) { try{ @@ -1454,23 +1581,232 @@ float MothurOut::ceilDist(float dist, int precision){ exit(1); } } -/**********************************************************************************************************************/ -int MothurOut::readNames(string namefile, map& nameMap) { +/***********************************************************************/ + +vector MothurOut::splitWhiteSpace(string& rest, char buffer[], int size){ + try { + vector pieces; + + for (int i = 0; i < size; i++) { + if (!isspace(buffer[i])) { rest += buffer[i]; } + else { + if (rest != "") { pieces.push_back(rest); rest = ""; } + while (i < size) { //gobble white space + if (isspace(buffer[i])) { i++; } + else { rest = buffer[i]; break; } //cout << "next piece buffer = " << nextPiece << endl; + } + } + } + + return pieces; + } + catch(exception& e) { + errorOut(e, "MothurOut", "splitWhiteSpace"); + exit(1); + } +} +/***********************************************************************/ +vector MothurOut::splitWhiteSpace(string input){ + try { + vector pieces; + string rest = ""; + + for (int i = 0; i < input.length(); i++) { + if (!isspace(input[i])) { rest += input[i]; } + else { + if (rest != "") { pieces.push_back(rest); rest = ""; } + while (i < input.length()) { //gobble white space + if (isspace(input[i])) { i++; } + else { rest = input[i]; break; } //cout << "next piece buffer = " << nextPiece << endl; + } + } + } + + if (rest != "") { pieces.push_back(rest); } + + return pieces; + } + catch(exception& e) { + errorOut(e, "MothurOut", "splitWhiteSpace"); + exit(1); + } +} +/***********************************************************************/ +vector MothurOut::splitWhiteSpaceWithQuotes(string input){ + try { + vector pieces; + string rest = ""; + + int pos = input.find('\''); + int pos2 = input.find('\"'); + + if ((pos == string::npos) && (pos2 == string::npos)) { return splitWhiteSpace(input); } //no quotes to worry about + else { + for (int i = 0; i < input.length(); i++) { + if ((input[i] == '\'') || (input[i] == '\"') || (rest == "\'") || (rest == "\"")) { //grab everything til end or next ' or " + rest += input[i]; + for (int j = i+1; j < input.length(); j++) { + if ((input[j] == '\'') || (input[j] == '\"')) { //then quit + rest += input[j]; + i = j+1; + j+=input.length(); + }else { rest += input[j]; } + } + }else if (!isspace(input[i])) { rest += input[i]; } + else { + if (rest != "") { pieces.push_back(rest); rest = ""; } + while (i < input.length()) { //gobble white space + if (isspace(input[i])) { i++; } + else { rest = input[i]; break; } //cout << "next piece buffer = " << nextPiece << endl; + } + } + } + + if (rest != "") { pieces.push_back(rest); } + } + return pieces; + } + catch(exception& e) { + errorOut(e, "MothurOut", "splitWhiteSpace"); + exit(1); + } +} +//********************************************************************************************************************** +int MothurOut::readTax(string namefile, map& taxMap) { try { + //open input file + ifstream in; + openInputFile(namefile, in); + + string rest = ""; + char buffer[4096]; + bool pairDone = false; + bool columnOne = true; + string firstCol, secondCol; + + while (!in.eof()) { + if (control_pressed) { break; } + + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + //are there confidence scores, if so remove them + if (secondCol.find_first_of('(') != -1) { removeConfidences(secondCol); } + map::iterator itTax = taxMap.find(firstCol); + + if(itTax == taxMap.end()) { + bool ignore = false; + if (secondCol != "") { if (secondCol[secondCol.length()-1] != ';') { mothurOut("[ERROR]: " + firstCol + " is missing the final ';', ignoring.\n"); ignore=true; } + } + if (!ignore) { taxMap[firstCol] = secondCol; } + if (debug) { mothurOut("[DEBUG]: name = '" + firstCol + "' tax = '" + secondCol + "'\n"); } + }else { + mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique./n"); control_pressed = true; + } + pairDone = false; + } + } + } + in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + //are there confidence scores, if so remove them + if (secondCol.find_first_of('(') != -1) { removeConfidences(secondCol); } + map::iterator itTax = taxMap.find(firstCol); + + if(itTax == taxMap.end()) { + bool ignore = false; + if (secondCol != "") { if (secondCol[secondCol.length()-1] != ';') { mothurOut("[ERROR]: " + firstCol + " is missing the final ';', ignoring.\n"); ignore=true; } + } + if (!ignore) { taxMap[firstCol] = secondCol; } + if (debug) { mothurOut("[DEBUG]: name = '" + firstCol + "' tax = '" + secondCol + "'\n"); } + }else { + mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique./n"); control_pressed = true; + } + + pairDone = false; + } + } + } + return taxMap.size(); + + } + catch(exception& e) { + errorOut(e, "MothurOut", "readTax"); + exit(1); + } +} +/**********************************************************************************************************************/ +int MothurOut::readNames(string namefile, map& nameMap, bool redund) { + try { //open input file ifstream in; openInputFile(namefile, in); - + + string rest = ""; + char buffer[4096]; + bool pairDone = false; + bool columnOne = true; + string firstCol, secondCol; + while (!in.eof()) { if (control_pressed) { break; } - string firstCol, secondCol; - in >> firstCol >> secondCol; gobble(in); - - nameMap[firstCol] = secondCol; + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + + //parse names into vector + vector theseNames; + splitAtComma(secondCol, theseNames); + for (int i = 0; i < theseNames.size(); i++) { nameMap[theseNames[i]] = firstCol; } + pairDone = false; + } + } } in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + + //parse names into vector + vector theseNames; + splitAtComma(secondCol, theseNames); + for (int i = 0; i < theseNames.size(); i++) { nameMap[theseNames[i]] = firstCol; } + pairDone = false; + } + } + } return nameMap.size(); @@ -1481,25 +1817,53 @@ int MothurOut::readNames(string namefile, map& nameMap) { } } /**********************************************************************************************************************/ -int MothurOut::readNames(string namefile, map >& nameMap) { +int MothurOut::readNames(string namefile, map& nameMap, int flip) { try { - //open input file ifstream in; openInputFile(namefile, in); - + + string rest = ""; + char buffer[4096]; + bool pairDone = false; + bool columnOne = true; + string firstCol, secondCol; + while (!in.eof()) { if (control_pressed) { break; } - string firstCol, secondCol; - in >> firstCol >> secondCol; gobble(in); - - vector temp; - splitAtComma(secondCol, temp); - - nameMap[firstCol] = temp; + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + nameMap[secondCol] = firstCol; + pairDone = false; + } + } } in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + nameMap[secondCol] = firstCol; + pairDone = false; + } + } + } return nameMap.size(); @@ -1510,29 +1874,64 @@ int MothurOut::readNames(string namefile, map >& nameMap) } } /**********************************************************************************************************************/ -map MothurOut::readNames(string namefile) { +int MothurOut::readNames(string namefile, map& nameMap, map& nameCount) { try { - - map nameMap; - + nameMap.clear(); nameCount.clear(); //open input file ifstream in; openInputFile(namefile, in); - + + string rest = ""; + char buffer[4096]; + bool pairDone = false; + bool columnOne = true; + string firstCol, secondCol; + while (!in.eof()) { if (control_pressed) { break; } - string firstCol, secondCol; - in >> firstCol; gobble(in); - in >> secondCol; gobble(in); - - int num = getNumNames(secondCol); - - nameMap[firstCol] = num; + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + //parse names into vector + vector theseNames; + splitAtComma(secondCol, theseNames); + for (int i = 0; i < theseNames.size(); i++) { nameMap[theseNames[i]] = firstCol; } + nameCount[firstCol] = theseNames.size(); + pairDone = false; + } + } } in.close(); - return nameMap; + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + //parse names into vector + vector theseNames; + splitAtComma(secondCol, theseNames); + for (int i = 0; i < theseNames.size(); i++) { nameMap[theseNames[i]] = firstCol; } + nameCount[firstCol] = theseNames.size(); + pairDone = false; + } + } + + } + return nameMap.size(); } catch(exception& e) { @@ -1541,34 +1940,51 @@ map MothurOut::readNames(string namefile) { } } /**********************************************************************************************************************/ -int MothurOut::readNames(string namefile, vector& nameVector, map& fastamap) { +int MothurOut::readNames(string namefile, map& nameMap) { try { - int error = 0; - //open input file ifstream in; openInputFile(namefile, in); - + + string rest = ""; + char buffer[4096]; + bool pairDone = false; + bool columnOne = true; + string firstCol, secondCol; + while (!in.eof()) { if (control_pressed) { break; } - string firstCol, secondCol; - in >> firstCol >> secondCol; gobble(in); - - int num = getNumNames(secondCol); - - map::iterator it = fastamap.find(firstCol); - if (it == fastamap.end()) { - error = 1; - mothurOut("[ERROR]: " + firstCol + " is not in your fastafile, but is in your namesfile, please correct."); mothurOutEndLine(); - }else { - seqPriorityNode temp(num, it->second, firstCol); - nameVector.push_back(temp); - } + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + nameMap[firstCol] = secondCol; pairDone = false; } + } } in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + nameMap[firstCol] = secondCol; pairDone = false; } + } + } - return error; + return nameMap.size(); } catch(exception& e) { @@ -1576,42 +1992,379 @@ int MothurOut::readNames(string namefile, vector& nameVector, m exit(1); } } - -/***********************************************************************/ - -int MothurOut::getNumNames(string names){ - try { - int count = 0; +/**********************************************************************************************************************/ +int MothurOut::readNames(string namefile, map >& nameMap) { + try { + //open input file + ifstream in; + openInputFile(namefile, in); - if(names != ""){ - count = 1; - for(int i=0;i pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + vector temp; + splitAtComma(secondCol, temp); + nameMap[firstCol] = temp; + pairDone = false; + } + } } - - return count; + in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + vector temp; + splitAtComma(secondCol, temp); + nameMap[firstCol] = temp; + pairDone = false; + } + } + } + + return nameMap.size(); } catch(exception& e) { - errorOut(e, "MothurOut", "getNumNames"); + errorOut(e, "MothurOut", "readNames"); exit(1); } } -/***********************************************************************/ - -int MothurOut::getNumChar(string line, char c){ +/**********************************************************************************************************************/ +map MothurOut::readNames(string namefile) { try { - int count = 0; + map nameMap; - if(line != ""){ - for(int i=0;i pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + int num = getNumNames(secondCol); + nameMap[firstCol] = num; + pairDone = false; + } + } + } + in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + int num = getNumNames(secondCol); + nameMap[firstCol] = num; + pairDone = false; + } + } + } + + return nameMap; + + } + catch(exception& e) { + errorOut(e, "MothurOut", "readNames"); + exit(1); + } +} +/**********************************************************************************************************************/ +map MothurOut::readNames(string namefile, unsigned long int& numSeqs) { + try { + map nameMap; + numSeqs = 0; + + //open input file + ifstream in; + openInputFile(namefile, in); + + string rest = ""; + char buffer[4096]; + bool pairDone = false; + bool columnOne = true; + string firstCol, secondCol; + + while (!in.eof()) { + if (control_pressed) { break; } + + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + int num = getNumNames(secondCol); + nameMap[firstCol] = num; + pairDone = false; + numSeqs += num; + } + } + } + in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + int num = getNumNames(secondCol); + nameMap[firstCol] = num; + pairDone = false; + numSeqs += num; + } + } + } + + return nameMap; + + } + catch(exception& e) { + errorOut(e, "MothurOut", "readNames"); + exit(1); + } +} +/************************************************************/ +int MothurOut::checkName(string& name) { + try { + for (int i = 0; i < name.length(); i++) { + if (name[i] == ':') { name[i] = '_'; changedSeqNames = true; } + } + return 0; + } + catch(exception& e) { + errorOut(e, "MothurOut", "checkName"); + exit(1); + } +} +/**********************************************************************************************************************/ +int MothurOut::readNames(string namefile, vector& nameVector, map& fastamap) { + try { + int error = 0; + + //open input file + ifstream in; + openInputFile(namefile, in); + + string rest = ""; + char buffer[4096]; + bool pairDone = false; + bool columnOne = true; + string firstCol, secondCol; + + while (!in.eof()) { + if (control_pressed) { break; } + + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + int num = getNumNames(secondCol); + + map::iterator it = fastamap.find(firstCol); + if (it == fastamap.end()) { + error = 1; + mothurOut("[ERROR]: " + firstCol + " is not in your fastafile, but is in your namesfile, please correct."); mothurOutEndLine(); + }else { + seqPriorityNode temp(num, it->second, firstCol); + nameVector.push_back(temp); + } + + pairDone = false; + } + } + } + in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + + for (int i = 0; i < pieces.size(); i++) { + if (columnOne) { firstCol = pieces[i]; columnOne=false; } + else { secondCol = pieces[i]; pairDone = true; columnOne=true; } + + if (pairDone) { + checkName(firstCol); + checkName(secondCol); + int num = getNumNames(secondCol); + + map::iterator it = fastamap.find(firstCol); + if (it == fastamap.end()) { + error = 1; + mothurOut("[ERROR]: " + firstCol + " is not in your fastafile, but is in your namesfile, please correct."); mothurOutEndLine(); + }else { + seqPriorityNode temp(num, it->second, firstCol); + nameVector.push_back(temp); + } + + pairDone = false; + } + } + } + return error; + } + catch(exception& e) { + errorOut(e, "MothurOut", "readNames"); + exit(1); + } +} +//********************************************************************************************************************** +set MothurOut::readAccnos(string accnosfile){ + try { + set names; + ifstream in; + openInputFile(accnosfile, in); + string name; + + string rest = ""; + char buffer[4096]; + + while (!in.eof()) { + if (control_pressed) { break; } + + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { checkName(pieces[i]); names.insert(pieces[i]); } + } + in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + for (int i = 0; i < pieces.size(); i++) { checkName(pieces[i]); names.insert(pieces[i]); } + } + return names; + } + catch(exception& e) { + errorOut(e, "MothurOut", "readAccnos"); + exit(1); + } +} +//********************************************************************************************************************** +int MothurOut::readAccnos(string accnosfile, vector& names){ + try { + names.clear(); + ifstream in; + openInputFile(accnosfile, in); + string name; + + string rest = ""; + char buffer[4096]; + + while (!in.eof()) { + if (control_pressed) { break; } + + in.read(buffer, 4096); + vector pieces = splitWhiteSpace(rest, buffer, in.gcount()); + + for (int i = 0; i < pieces.size(); i++) { checkName(pieces[i]); names.push_back(pieces[i]); } + } + in.close(); + + if (rest != "") { + vector pieces = splitWhiteSpace(rest); + for (int i = 0; i < pieces.size(); i++) { checkName(pieces[i]); names.push_back(pieces[i]); } + } + + return 0; + } + catch(exception& e) { + errorOut(e, "MothurOut", "readAccnos"); + exit(1); + } +} +/***********************************************************************/ + +int MothurOut::getNumNames(string names){ + try { + int count = 0; + + if(names != ""){ + count = 1; + for(int i=0;i bigset, vector subset) { + try { + + + if (subset.size() > bigset.size()) { return false; } + + //check if each guy in suset is also in bigset + for (int i = 0; i < subset.size(); i++) { + bool match = false; + for (int j = 0; j < bigset.size(); j++) { + if (subset[i] == bigset[j]) { match = true; break; } + } + + //you have a guy in subset that had no match in bigset + if (match == false) { return false; } + } + + return true; + + } + catch(exception& e) { + errorOut(e, "MothurOut", "isSubset"); + exit(1); + } +} /***********************************************************************/ int MothurOut::mothurRemove(string filename){ try { @@ -1659,6 +2438,28 @@ bool MothurOut::mothurConvert(string item, int& num){ exit(1); } } +/***********************************************************************/ +bool MothurOut::mothurConvert(string item, intDist& num){ + try { + bool error = false; + + if (isNumeric1(item)) { + convert(item, num); + }else { + num = 0; + error = true; + mothurOut("[ERROR]: cannot convert " + item + " to an integer."); mothurOutEndLine(); + commandInputsConvertError = true; + } + + return error; + } + catch(exception& e) { + errorOut(e, "MothurOut", "mothurConvert"); + exit(1); + } +} + /***********************************************************************/ bool MothurOut::isNumeric1(string stringToCheck){ try { @@ -1888,6 +2689,9 @@ void MothurOut::getNumSeqs(ifstream& file, int& numSeqs){ //This function parses the estimator options and puts them in a vector void MothurOut::splitAtChar(string& estim, vector& container, char symbol) { try { + + if (symbol == '-') { splitAtDash(estim, container); return; } + string individual = ""; int estimLength = estim.size(); for(int i=0;i& container) { try { string individual = ""; int estimLength = estim.size(); - for(int i=0;i& container) { try { string individual = ""; int estimLength = estim.size(); + bool prevEscape = false; for(int i=0;i& container) { //This function parses the line options and puts them in a set void MothurOut::splitAtDash(string& estim, set& container) { try { - string individual; + string individual = ""; int lineNum; - - while (estim.find_first_of('-') != -1) { - individual = estim.substr(0,estim.find_first_of('-')); - if ((estim.find_first_of('-')+1) <= estim.length()) { //checks to make sure you don't have dash at end of string - estim = estim.substr(estim.find_first_of('-')+1, estim.length()); - convert(individual, lineNum); //convert the string to int - container.insert(lineNum); + int estimLength = estim.size(); + bool prevEscape = false; + for(int i=0;i& container) { exit(1); } } + /***********************************************************************/ string MothurOut::makeList(vector& names) { try { @@ -2071,11 +2909,11 @@ void MothurOut::splitAtChar(string& prefix, string& suffix, char c){ string space = " "; while(suffix.at(0) == ' ') suffix = suffix.substr(1, suffix.length()); - } + }else { suffix = ""; } - } + } catch(exception& e) { - errorOut(e, "MothurOut", "splitAtComma"); + errorOut(e, "MothurOut", "splitAtChar"); exit(1); } } @@ -2091,7 +2929,7 @@ void MothurOut::splitAtComma(string& prefix, string& suffix){ string space = " "; while(suffix.at(0) == ' ') suffix = suffix.substr(1, suffix.length()); - } + }else { suffix = ""; } } catch(exception& e) { @@ -2134,6 +2972,35 @@ bool MothurOut::inUsersGroups(string groupname, vector Groups) { exit(1); } } +/**************************************************************************************************/ + +bool MothurOut::inUsersGroups(vector set, vector< vector > sets) { + try { + for (int i = 0; i < sets.size(); i++) { + if (set == sets[i]) { return true; } + } + return false; + } + catch(exception& e) { + errorOut(e, "MothurOut", "inUsersGroups"); + exit(1); + } +} +/**************************************************************************************************/ + +bool MothurOut::inUsersGroups(int groupname, vector Groups) { + try { + for (int i = 0; i < Groups.size(); i++) { + if (groupname == Groups[i]) { return true; } + } + return false; + } + catch(exception& e) { + errorOut(e, "MothurOut", "inUsersGroups"); + exit(1); + } +} + /**************************************************************************************************/ //returns true if any of the strings in first vector are in second vector bool MothurOut::inUsersGroups(vector groupnames, vector Groups) { @@ -2278,6 +3145,253 @@ bool MothurOut::checkReleaseVersion(ifstream& file, string version) { exit(1); } } +/**************************************************************************************************/ +vector MothurOut::getAverages(vector< vector >& dists) { + try{ + vector averages; //averages.resize(numComp, 0.0); + for (int i = 0; i < dists[0].size(); i++) { averages.push_back(0.0); } + + for (int thisIter = 0; thisIter < dists.size(); thisIter++) { + for (int i = 0; i < dists[thisIter].size(); i++) { + averages[i] += dists[thisIter][i]; + } + } + + //finds average. + for (int i = 0; i < averages.size(); i++) { averages[i] /= (double) dists.size(); } + + return averages; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverages"); + exit(1); + } +} +/**************************************************************************************************/ +vector MothurOut::getStandardDeviation(vector< vector >& dists) { + try{ + + vector averages = getAverages(dists); + + //find standard deviation + vector stdDev; //stdDev.resize(numComp, 0.0); + for (int i = 0; i < dists[0].size(); i++) { stdDev.push_back(0.0); } + + for (int thisIter = 0; thisIter < dists.size(); thisIter++) { //compute the difference of each dist from the mean, and square the result of each + for (int j = 0; j < dists[thisIter].size(); j++) { + stdDev[j] += ((dists[thisIter][j] - averages[j]) * (dists[thisIter][j] - averages[j])); + } + } + for (int i = 0; i < stdDev.size(); i++) { + stdDev[i] /= (double) dists.size(); + stdDev[i] = sqrt(stdDev[i]); + } + + return stdDev; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverages"); + exit(1); + } +} +/**************************************************************************************************/ +vector MothurOut::getStandardDeviation(vector< vector >& dists, vector& averages) { + try{ + //find standard deviation + vector stdDev; //stdDev.resize(numComp, 0.0); + for (int i = 0; i < dists[0].size(); i++) { stdDev.push_back(0.0); } + + for (int thisIter = 0; thisIter < dists.size(); thisIter++) { //compute the difference of each dist from the mean, and square the result of each + for (int j = 0; j < dists[thisIter].size(); j++) { + stdDev[j] += ((dists[thisIter][j] - averages[j]) * (dists[thisIter][j] - averages[j])); + } + } + for (int i = 0; i < stdDev.size(); i++) { + stdDev[i] /= (double) dists.size(); + stdDev[i] = sqrt(stdDev[i]); + } + + return stdDev; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverages"); + exit(1); + } +} +/**************************************************************************************************/ +vector< vector > MothurOut::getAverages(vector< vector< vector > >& calcDistsTotals, string mode) { + try{ + + vector< vector > calcAverages; //calcAverages.resize(calcDistsTotals[0].size()); + for (int i = 0; i < calcDistsTotals[0].size(); i++) { //initialize sums to zero. + //calcAverages[i].resize(calcDistsTotals[0][i].size()); + vector temp; + for (int j = 0; j < calcDistsTotals[0][i].size(); j++) { + seqDist tempDist; + tempDist.seq1 = calcDistsTotals[0][i][j].seq1; + tempDist.seq2 = calcDistsTotals[0][i][j].seq2; + tempDist.dist = 0.0; + temp.push_back(tempDist); + } + calcAverages.push_back(temp); + } + + if (mode == "average") { + for (int thisIter = 0; thisIter < calcDistsTotals.size(); thisIter++) { //sum all groups dists for each calculator + for (int i = 0; i < calcAverages.size(); i++) { //initialize sums to zero. + for (int j = 0; j < calcAverages[i].size(); j++) { + calcAverages[i][j].dist += calcDistsTotals[thisIter][i][j].dist; + } + } + } + + for (int i = 0; i < calcAverages.size(); i++) { //finds average. + for (int j = 0; j < calcAverages[i].size(); j++) { + calcAverages[i][j].dist /= (float) calcDistsTotals.size(); + } + } + }else { //find median + for (int i = 0; i < calcAverages.size(); i++) { //for each calc + for (int j = 0; j < calcAverages[i].size(); j++) { //for each comparison + vector dists; + for (int thisIter = 0; thisIter < calcDistsTotals.size(); thisIter++) { //for each subsample + dists.push_back(calcDistsTotals[thisIter][i][j].dist); + } + sort(dists.begin(), dists.end()); + calcAverages[i][j].dist = dists[(calcDistsTotals.size()/2)]; + } + } + } + + return calcAverages; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverages"); + exit(1); + } +} +/**************************************************************************************************/ +vector< vector > MothurOut::getAverages(vector< vector< vector > >& calcDistsTotals) { + try{ + + vector< vector > calcAverages; //calcAverages.resize(calcDistsTotals[0].size()); + for (int i = 0; i < calcDistsTotals[0].size(); i++) { //initialize sums to zero. + //calcAverages[i].resize(calcDistsTotals[0][i].size()); + vector temp; + for (int j = 0; j < calcDistsTotals[0][i].size(); j++) { + seqDist tempDist; + tempDist.seq1 = calcDistsTotals[0][i][j].seq1; + tempDist.seq2 = calcDistsTotals[0][i][j].seq2; + tempDist.dist = 0.0; + temp.push_back(tempDist); + } + calcAverages.push_back(temp); + } + + + for (int thisIter = 0; thisIter < calcDistsTotals.size(); thisIter++) { //sum all groups dists for each calculator + for (int i = 0; i < calcAverages.size(); i++) { //initialize sums to zero. + for (int j = 0; j < calcAverages[i].size(); j++) { + calcAverages[i][j].dist += calcDistsTotals[thisIter][i][j].dist; + } + } + } + + for (int i = 0; i < calcAverages.size(); i++) { //finds average. + for (int j = 0; j < calcAverages[i].size(); j++) { + calcAverages[i][j].dist /= (float) calcDistsTotals.size(); + } + } + + return calcAverages; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverages"); + exit(1); + } +} +/**************************************************************************************************/ +vector< vector > MothurOut::getStandardDeviation(vector< vector< vector > >& calcDistsTotals) { + try{ + + vector< vector > calcAverages = getAverages(calcDistsTotals); + + //find standard deviation + vector< vector > stdDev; + for (int i = 0; i < calcDistsTotals[0].size(); i++) { //initialize sums to zero. + vector temp; + for (int j = 0; j < calcDistsTotals[0][i].size(); j++) { + seqDist tempDist; + tempDist.seq1 = calcDistsTotals[0][i][j].seq1; + tempDist.seq2 = calcDistsTotals[0][i][j].seq2; + tempDist.dist = 0.0; + temp.push_back(tempDist); + } + stdDev.push_back(temp); + } + + for (int thisIter = 0; thisIter < calcDistsTotals.size(); thisIter++) { //compute the difference of each dist from the mean, and square the result of each + for (int i = 0; i < stdDev.size(); i++) { + for (int j = 0; j < stdDev[i].size(); j++) { + stdDev[i][j].dist += ((calcDistsTotals[thisIter][i][j].dist - calcAverages[i][j].dist) * (calcDistsTotals[thisIter][i][j].dist - calcAverages[i][j].dist)); + } + } + } + + for (int i = 0; i < stdDev.size(); i++) { //finds average. + for (int j = 0; j < stdDev[i].size(); j++) { + stdDev[i][j].dist /= (float) calcDistsTotals.size(); + stdDev[i][j].dist = sqrt(stdDev[i][j].dist); + } + } + + return stdDev; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverages"); + exit(1); + } +} +/**************************************************************************************************/ +vector< vector > MothurOut::getStandardDeviation(vector< vector< vector > >& calcDistsTotals, vector< vector >& calcAverages) { + try{ + //find standard deviation + vector< vector > stdDev; + for (int i = 0; i < calcDistsTotals[0].size(); i++) { //initialize sums to zero. + vector temp; + for (int j = 0; j < calcDistsTotals[0][i].size(); j++) { + seqDist tempDist; + tempDist.seq1 = calcDistsTotals[0][i][j].seq1; + tempDist.seq2 = calcDistsTotals[0][i][j].seq2; + tempDist.dist = 0.0; + temp.push_back(tempDist); + } + stdDev.push_back(temp); + } + + for (int thisIter = 0; thisIter < calcDistsTotals.size(); thisIter++) { //compute the difference of each dist from the mean, and square the result of each + for (int i = 0; i < stdDev.size(); i++) { + for (int j = 0; j < stdDev[i].size(); j++) { + stdDev[i][j].dist += ((calcDistsTotals[thisIter][i][j].dist - calcAverages[i][j].dist) * (calcDistsTotals[thisIter][i][j].dist - calcAverages[i][j].dist)); + } + } + } + + for (int i = 0; i < stdDev.size(); i++) { //finds average. + for (int j = 0; j < stdDev[i].size(); j++) { + stdDev[i][j].dist /= (float) calcDistsTotals.size(); + stdDev[i][j].dist = sqrt(stdDev[i][j].dist); + } + } + + return stdDev; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverages"); + exit(1); + } +} + /**************************************************************************************************/ bool MothurOut::isContainingOnlyDigits(string input) { try{ @@ -2336,8 +3450,53 @@ int MothurOut::removeConfidences(string& tax) { } } /**************************************************************************************************/ - - +string MothurOut::removeQuotes(string tax) { + try { + + string taxon; + string newTax = ""; + + for (int i = 0; i < tax.length(); i++) { + + if (control_pressed) { return newTax; } + + if ((tax[i] != '\'') && (tax[i] != '\"')) { newTax += tax[i]; } + + } + + return newTax; + } + catch(exception& e) { + errorOut(e, "MothurOut", "removeQuotes"); + exit(1); + } +} +/**************************************************************************************************/ +// function for calculating standard deviation +double MothurOut::getStandardDeviation(vector& featureVector){ + try { + //finds sum + double average = 0; + for (int i = 0; i < featureVector.size(); i++) { average += featureVector[i]; } + average /= (double) featureVector.size(); + + //find standard deviation + double stdDev = 0; + for (int i = 0; i < featureVector.size(); i++) { //compute the difference of each dist from the mean, and square the result of each + stdDev += ((featureVector[i] - average) * (featureVector[i] - average)); + } + + stdDev /= (double) featureVector.size(); + stdDev = sqrt(stdDev); + + return stdDev; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getStandardDeviation"); + exit(1); + } +} +/**************************************************************************************************/