X-Git-Url: https://git.donarmstrong.com/?p=mothur.git;a=blobdiff_plain;f=mothurout.cpp;h=0f24cb2dc362c679dd16ed0eb7c50444f07e7a6e;hp=f7b0d86bf93ff1c3f1ff6ec4ad62d21d66fc382b;hb=cf9987b67aa49777a4c91c2d21f96e58bf17aa82;hpb=7439a3c94e96c9e0e78ca53f0356415a879f8b80 diff --git a/mothurout.cpp b/mothurout.cpp index f7b0d86..0f24cb2 100644 --- a/mothurout.cpp +++ b/mothurout.cpp @@ -23,6 +23,7 @@ set MothurOut::getCurrentTypes() { set types; types.insert("fasta"); + types.insert("summary"); types.insert("accnos"); types.insert("column"); types.insert("design"); @@ -81,6 +82,7 @@ void MothurOut::printCurrentFiles() { if (biomfile != "") { mothurOut("biom=" + biomfile); mothurOutEndLine(); } if (counttablefile != "") { mothurOut("count=" + counttablefile); mothurOutEndLine(); } if (processors != "1") { mothurOut("processors=" + processors); mothurOutEndLine(); } + if (summaryfile != "") { mothurOut("summary=" + summaryfile); mothurOutEndLine(); } } catch(exception& e) { @@ -115,6 +117,7 @@ bool MothurOut::hasCurrentFiles() { if (flowfile != "") { return true; } if (biomfile != "") { return true; } if (counttablefile != "") { return true; } + if (summaryfile != "") { return true; } if (processors != "1") { return true; } return hasCurrent; @@ -151,6 +154,7 @@ void MothurOut::clearCurrentFiles() { flowfile = ""; biomfile = ""; counttablefile = ""; + summaryfile = ""; processors = "1"; } catch(exception& e) { @@ -344,6 +348,27 @@ void MothurOut::mothurOut(string output) { } } /*********************************************************************************************/ +void MothurOut::mothurOutJustToScreen(string output) { + try { + +#ifdef USE_MPI + int pid; + MPI_Comm_rank(MPI_COMM_WORLD, &pid); + + if (pid == 0) { //only one process should output to screen +#endif + logger() << output; + +#ifdef USE_MPI + } +#endif + } + catch(exception& e) { + errorOut(e, "MothurOut", "MothurOut"); + exit(1); + } +} +/*********************************************************************************************/ void MothurOut::mothurOutEndLine() { try { #ifdef USE_MPI @@ -563,6 +588,26 @@ int MothurOut::openOutputFileAppend(string fileName, ofstream& fileHandle){ exit(1); } } +/***********************************************************************/ +int MothurOut::openOutputFileBinaryAppend(string fileName, ofstream& fileHandle){ + try { + fileName = getFullPathName(fileName); + + fileHandle.open(fileName.c_str(), ios::app | ios::binary); + if(!fileHandle) { + mothurOut("[ERROR]: Could not open " + fileName); mothurOutEndLine(); + return 1; + } + else { + return 0; + } + } + catch(exception& e) { + errorOut(e, "MothurOut", "openOutputFileAppend"); + exit(1); + } +} + /***********************************************************************/ void MothurOut::gobble(istream& f){ try { @@ -734,6 +779,8 @@ string MothurOut::getPathName(string longName){ bool MothurOut::dirCheck(string& dirName){ try { + if (dirName == "") { return false; } + string tag = ""; #ifdef USE_MPI int pid; @@ -752,7 +799,7 @@ bool MothurOut::dirCheck(string& dirName){ //test to make sure directory exists dirName = getFullPathName(dirName); - string outTemp = dirName + tag + "temp"; + string outTemp = dirName + tag + "temp"+ toString(time(NULL)); ofstream out; out.open(outTemp.c_str(), ios::trunc); if(!out) { @@ -771,6 +818,39 @@ bool MothurOut::dirCheck(string& dirName){ } } +//********************************************************************************************************************** + +map > MothurOut::parseClasses(string classes){ + try { + map > parts; + + //treatment-age + vector pieces; splitAtDash(classes, pieces); // -> treatment, age + + for (int i = 0; i < pieces.size(); i++) { + string category = ""; string value = ""; + bool foundOpen = false; + for (int j = 0; j < pieces[i].length(); j++) { + if (control_pressed) { return parts; } + + if (pieces[i][j] == '<') { foundOpen = true; } + else if (pieces[i][j] == '>') { j += pieces[i].length(); } + else { + if (!foundOpen) { category += pieces[i][j]; } + else { value += pieces[i][j]; } + } + } + vector values; splitAtChar(value, values, '|'); + parts[category] = values; + } + + return parts; + } + catch(exception& e) { + errorOut(e, "MothurOut", "parseClasses"); + exit(1); + } +} /***********************************************************************/ string MothurOut::hasPath(string longName){ @@ -1062,6 +1142,105 @@ int MothurOut::openInputFile(string fileName, ifstream& fileHandle){ exit(1); } } +/***********************************************************************/ +int MothurOut::openInputFileBinary(string fileName, ifstream& fileHandle){ + try { + + //get full path name + string completeFileName = getFullPathName(fileName); +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) +#ifdef USE_COMPRESSION + // check for gzipped or bzipped file + if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) { + string tempName = string(tmpnam(0)); + mkfifo(tempName.c_str(), 0666); + int fork_result = fork(); + if (fork_result < 0) { + cerr << "Error forking.\n"; + exit(1); + } else if (fork_result == 0) { + string command = (endsWith(completeFileName, ".gz") ? "zcat " : "bzcat ") + completeFileName + string(" > ") + tempName; + cerr << "Decompressing " << completeFileName << " via temporary named pipe " << tempName << "\n"; + system(command.c_str()); + cerr << "Done decompressing " << completeFileName << "\n"; + mothurRemove(tempName); + exit(EXIT_SUCCESS); + } else { + cerr << "waiting on child process " << fork_result << "\n"; + completeFileName = tempName; + } + } +#endif +#endif + + fileHandle.open(completeFileName.c_str(), ios::binary); + if(!fileHandle) { + mothurOut("[ERROR]: Could not open " + completeFileName); mothurOutEndLine(); + return 1; + } + else { + //check for blank file + gobble(fileHandle); + if (fileHandle.eof()) { mothurOut("[ERROR]: " + completeFileName + " is blank. Please correct."); mothurOutEndLine(); } + + return 0; + } + } + catch(exception& e) { + errorOut(e, "MothurOut", "openInputFileBinary"); + exit(1); + } +} +/***********************************************************************/ +int MothurOut::openInputFileBinary(string fileName, ifstream& fileHandle, string noerror){ + try { + + //get full path name + string completeFileName = getFullPathName(fileName); +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) +#ifdef USE_COMPRESSION + // check for gzipped or bzipped file + if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) { + string tempName = string(tmpnam(0)); + mkfifo(tempName.c_str(), 0666); + int fork_result = fork(); + if (fork_result < 0) { + cerr << "Error forking.\n"; + exit(1); + } else if (fork_result == 0) { + string command = (endsWith(completeFileName, ".gz") ? "zcat " : "bzcat ") + completeFileName + string(" > ") + tempName; + cerr << "Decompressing " << completeFileName << " via temporary named pipe " << tempName << "\n"; + system(command.c_str()); + cerr << "Done decompressing " << completeFileName << "\n"; + mothurRemove(tempName); + exit(EXIT_SUCCESS); + } else { + cerr << "waiting on child process " << fork_result << "\n"; + completeFileName = tempName; + } + } +#endif +#endif + + fileHandle.open(completeFileName.c_str(), ios::binary); + if(!fileHandle) { + //mothurOut("[ERROR]: Could not open " + completeFileName); mothurOutEndLine(); + return 1; + } + else { + //check for blank file + gobble(fileHandle); + //if (fileHandle.eof()) { mothurOut("[ERROR]: " + completeFileName + " is blank. Please correct."); mothurOutEndLine(); } + + return 0; + } + } + catch(exception& e) { + errorOut(e, "MothurOut", "openInputFileBinary - no error"); + exit(1); + } +} + /***********************************************************************/ int MothurOut::renameFile(string oldName, string newName){ @@ -1136,7 +1315,48 @@ int MothurOut::openOutputFile(string fileName, ofstream& fileHandle){ } } +/***********************************************************************/ +int MothurOut::openOutputFileBinary(string fileName, ofstream& fileHandle){ + try { + + string completeFileName = getFullPathName(fileName); +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) +#ifdef USE_COMPRESSION + // check for gzipped file + if (endsWith(completeFileName, ".gz") || endsWith(completeFileName, ".bz2")) { + string tempName = string(tmpnam(0)); + mkfifo(tempName.c_str(), 0666); + cerr << "Compressing " << completeFileName << " via temporary named pipe " << tempName << "\n"; + int fork_result = fork(); + if (fork_result < 0) { + cerr << "Error forking.\n"; + exit(1); + } else if (fork_result == 0) { + string command = string(endsWith(completeFileName, ".gz") ? "gzip" : "bzip2") + " -v > " + completeFileName + string(" < ") + tempName; + system(command.c_str()); + exit(0); + } else { + completeFileName = tempName; + } + } +#endif +#endif + fileHandle.open(completeFileName.c_str(), ios::trunc | ios::binary); + if(!fileHandle) { + mothurOut("[ERROR]: Could not open " + completeFileName); mothurOutEndLine(); + return 1; + } + else { + return 0; + } + } + catch(exception& e) { + errorOut(e, "MothurOut", "openOutputFileBinary"); + exit(1); + } + +} /**************************************************************************************************/ int MothurOut::appendFiles(string temp, string filename) { try{ @@ -1170,7 +1390,72 @@ int MothurOut::appendFiles(string temp, string filename) { exit(1); } } +/**************************************************************************************************/ +int MothurOut::appendBinaryFiles(string temp, string filename) { + try{ + ofstream output; + ifstream input; + + //open output file in append mode + openOutputFileBinaryAppend(filename, output); + int ableToOpen = openInputFileBinary(temp, input, "no error"); + + if (ableToOpen == 0) { //you opened it + + char buffer[4096]; + while (!input.eof()) { + input.read(buffer, 4096); + output.write(buffer, input.gcount()); + } + input.close(); + } + + output.close(); + + return ableToOpen; + } + catch(exception& e) { + errorOut(e, "MothurOut", "appendBinaryFiles"); + exit(1); + } +} +/**************************************************************************************************/ +int MothurOut::appendFilesWithoutHeaders(string temp, string filename) { + try{ + ofstream output; + ifstream input; + + //open output file in append mode + openOutputFileAppend(filename, output); + int ableToOpen = openInputFile(temp, input, "no error"); + //int ableToOpen = openInputFile(temp, input); + + int numLines = 0; + if (ableToOpen == 0) { //you opened it + + string headers = getline(input); gobble(input); + if (debug) { mothurOut("[DEBUG]: skipping headers " + headers +'\n'); } + + 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(); + } + + output.close(); + + return numLines; + } + catch(exception& e) { + errorOut(e, "MothurOut", "appendFiles"); + exit(1); + } +} /**************************************************************************************************/ string MothurOut::sortFile(string distFile, string outputDir){ try { @@ -1257,15 +1542,15 @@ vector MothurOut::setFilePosFasta(string filename, int& num) char c = inFASTA.get(); count++; if (c == '>') { positions.push_back(count-1); - //cout << count << endl; + if (debug) { mothurOut("[DEBUG]: numSeqs = " + toString(positions.size()) + " count = " + toString(count) + ".\n"); } } } inFASTA.close(); num = positions.size(); - - /*FILE * pFile; - long size; + if (debug) { mothurOut("[DEBUG]: num = " + toString(num) + ".\n"); } + FILE * pFile; + unsigned long long size; //get num bytes in file pFile = fopen (filename.c_str(),"rb"); @@ -1274,9 +1559,9 @@ vector MothurOut::setFilePosFasta(string filename, int& num) fseek (pFile, 0, SEEK_END); size=ftell (pFile); fclose (pFile); - }*/ + } - unsigned long long size = positions[(positions.size()-1)]; + /*unsigned long long size = positions[(positions.size()-1)]; ifstream in; openInputFile(filename, in); @@ -1286,8 +1571,10 @@ vector MothurOut::setFilePosFasta(string filename, int& num) if(in.eof()) { break; } else { size++; } } - in.close(); - + in.close();*/ + + if (debug) { mothurOut("[DEBUG]: size = " + toString(size) + ".\n"); } + positions.push_back(size); positions[0] = 0; @@ -1298,6 +1585,67 @@ vector MothurOut::setFilePosFasta(string filename, int& num) exit(1); } } +//********************************************************************************************************************** +vector MothurOut::readConsTax(string inputfile){ + try { + + vector taxes; + + ifstream in; + openInputFile(inputfile, in); + + //read headers + getline(in); + + while (!in.eof()) { + + if (control_pressed) { break; } + + string otu = ""; string tax = "unknown"; + int size = 0; + + in >> otu >> size >> tax; gobble(in); + consTax temp(otu, tax, size); + taxes.push_back(temp); + } + in.close(); + + return taxes; + } + catch(exception& e) { + errorOut(e, "MothurOut", "readConsTax"); + exit(1); + } +} +//********************************************************************************************************************** +int MothurOut::readConsTax(string inputfile, map& taxes){ + try { + ifstream in; + openInputFile(inputfile, in); + + //read headers + getline(in); + + while (!in.eof()) { + + if (control_pressed) { break; } + + string otu = ""; string tax = "unknown"; + int size = 0; + + in >> otu >> size >> tax; gobble(in); + consTax2 temp(tax, size); + taxes[otu] = temp; + } + in.close(); + + return 0; + } + catch(exception& e) { + errorOut(e, "MothurOut", "readConsTax"); + exit(1); + } +} /**************************************************************************************************/ vector MothurOut::setFilePosEachLine(string filename, int& num) { try { @@ -1685,6 +2033,7 @@ int MothurOut::readTax(string namefile, map& taxMap) { bool pairDone = false; bool columnOne = true; string firstCol, secondCol; + bool error = false; while (!in.eof()) { if (control_pressed) { break; } @@ -1709,7 +2058,7 @@ int MothurOut::readTax(string namefile, map& taxMap) { 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; + mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique.\n"); error = true; } pairDone = false; } @@ -1737,7 +2086,7 @@ int MothurOut::readTax(string namefile, map& taxMap) { 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; + mothurOut("[ERROR]: " + firstCol + " is already in your taxonomy file, names must be unique./n"); error = true; } pairDone = false; @@ -1745,6 +2094,8 @@ int MothurOut::readTax(string namefile, map& taxMap) { } } + if (error) { control_pressed = true; } + if (debug) { mothurOut("[DEBUG]: numSeqs saved = '" + toString(taxMap.size()) + "'\n"); } return taxMap.size(); } @@ -2180,9 +2531,11 @@ map MothurOut::readNames(string namefile, unsigned long int& numSeq /************************************************************/ int MothurOut::checkName(string& name) { try { - for (int i = 0; i < name.length(); i++) { - if (name[i] == ':') { name[i] = '_'; changedSeqNames = true; } - } + if (modifyNames) { + for (int i = 0; i < name.length(); i++) { + if (name[i] == ':') { name[i] = '_'; changedSeqNames = true; } + } + } return 0; } catch(exception& e) { @@ -2284,7 +2637,9 @@ set MothurOut::readAccnos(string accnosfile){ 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]); } + for (int i = 0; i < pieces.size(); i++) { checkName(pieces[i]); + names.insert(pieces[i]); + } } in.close(); @@ -2375,6 +2730,65 @@ int MothurOut::getNumChar(string line, char c){ exit(1); } } +/***********************************************************************/ +string MothurOut::getSimpleLabel(string label){ + try { + string simple = ""; + + //remove OTU or phylo tag + string newLabel1 = ""; + for (int i = 0; i < label.length(); i++) { + if(label[i]>47 && label[i]<58) { //is a digit + newLabel1 += label[i]; + } + } + + int num1; + mothurConvert(newLabel1, num1); + + simple = toString(num1); + + return simple; + } + catch(exception& e) { + errorOut(e, "MothurOut", "isLabelEquivalent"); + exit(1); + } +} +/***********************************************************************/ + +bool MothurOut::isLabelEquivalent(string label1, string label2){ + try { + bool same = false; + + //remove OTU or phylo tag + string newLabel1 = ""; + for (int i = 0; i < label1.length(); i++) { + if(label1[i]>47 && label1[i]<58) { //is a digit + newLabel1 += label1[i]; + } + } + + string newLabel2 = ""; + for (int i = 0; i < label2.length(); i++) { + if(label2[i]>47 && label2[i]<58) { //is a digit + newLabel2 += label2[i]; + } + } + + int num1, num2; + mothurConvert(newLabel1, num1); + mothurConvert(newLabel2, num2); + + if (num1 == num2) { same = true; } + + return same; + } + catch(exception& e) { + errorOut(e, "MothurOut", "isLabelEquivalent"); + exit(1); + } +} //********************************************************************************************************************** bool MothurOut::isSubset(vector bigset, vector subset) { try { @@ -2640,7 +3054,50 @@ unsigned int MothurOut::fromBase36(string base36){ } } /***********************************************************************/ - +string MothurOut::findEdianness() { + try { + // find real endian type + unsigned char EndianTest[2] = {1,0}; + short x = *(short *)EndianTest; + + string endianType = "unknown"; + if(x == 1) { endianType = "BIG_ENDIAN"; } + else { endianType = "LITTLE_ENDIAN"; } + + return endianType; + } + catch(exception& e) { + errorOut(e, "MothurOut", "findEdianness"); + exit(1); + } +} +/***********************************************************************/ +double MothurOut::median(vector x) { + try { + double value = 0.0; + + if (x.size() == 0) { } //error + else { + //For example, if a < b < c, then the median of the list {a, b, c} is b, and, if a < b < c < d, then the median of the list {a, b, c, d} is the mean of b and c; i.e., it is (b + c)/2. + sort(x.begin(), x.end()); + //is x.size even? + if ((x.size()%2) == 0) { //size() is even. median = average of 2 midpoints + int midIndex1 = (x.size()/2)-1; + int midIndex2 = (x.size()/2); + value = (x[midIndex1]+ x[midIndex2]) / 2.0; + }else { + int midIndex = (x.size()/2); + value = x[midIndex]; + } + } + return value; + } + catch(exception& e) { + errorOut(e, "MothurOut", "median"); + exit(1); + } +} +/***********************************************************************/ int MothurOut::factorial(int num){ try { int total = 1; @@ -2687,6 +3144,64 @@ void MothurOut::getNumSeqs(ifstream& file, int& numSeqs){ } } /***********************************************************************/ +bool MothurOut::checkLocations(string& filename, string inputDir){ + try { + filename = getFullPathName(filename); + + int ableToOpen; + ifstream in; + ableToOpen = openInputFile(filename, in, "noerror"); + in.close(); + + //if you can't open it, try input location + if (ableToOpen == 1) { + if (inputDir != "") { //default path is set + string tryPath = inputDir + getSimpleName(filename); + mothurOut("Unable to open " + filename + ". Trying input directory " + tryPath); mothurOutEndLine(); + ifstream in2; + ableToOpen = openInputFile(tryPath, in2, "noerror"); + in2.close(); + filename = tryPath; + } + } + + //if you can't open it, try default location + if (ableToOpen == 1) { + if (getDefaultPath() != "") { //default path is set + string tryPath = getDefaultPath() + getSimpleName(filename); + mothurOut("Unable to open " + filename + ". Trying default " + tryPath); mothurOutEndLine(); + ifstream in2; + ableToOpen = openInputFile(tryPath, in2, "noerror"); + in2.close(); + filename = tryPath; + } + } + + //if you can't open it its not in current working directory or inputDir, try mothur excutable location + if (ableToOpen == 1) { + string exepath = argv; + string tempPath = exepath; + for (int i = 0; i < exepath.length(); i++) { tempPath[i] = tolower(exepath[i]); } + exepath = exepath.substr(0, (tempPath.find_last_of('m'))); + + string tryPath = getFullPathName(exepath) + getSimpleName(filename); + mothurOut("Unable to open " + filename + ". Trying mothur's executable location " + tryPath); mothurOutEndLine(); + ifstream in2; + ableToOpen = openInputFile(tryPath, in2, "noerror"); + in2.close(); + filename = tryPath; + } + + if (ableToOpen == 1) { mothurOut("Unable to open " + filename + "."); mothurOutEndLine(); return false; } + + return true; + } + catch(exception& e) { + errorOut(e, "MothurOut", "checkLocations"); + exit(1); + } +} +/***********************************************************************/ //This function parses the estimator options and puts them in a vector void MothurOut::splitAtChar(string& estim, vector& container, char symbol) { @@ -3208,6 +3723,26 @@ vector MothurOut::getAverages(vector< vector >& dists) { exit(1); } } +/**************************************************************************************************/ +double MothurOut::getAverage(vector dists) { + try{ + double average = 0; + + for (int i = 0; i < dists.size(); i++) { + average += dists[i]; + } + + //finds average. + average /= (double) dists.size(); + + return average; + } + catch(exception& e) { + errorOut(e, "MothurOut", "getAverage"); + exit(1); + } +} + /**************************************************************************************************/ vector MothurOut::getStandardDeviation(vector< vector >& dists) { try{ @@ -3255,7 +3790,7 @@ vector MothurOut::getStandardDeviation(vector< vector >& dists, return stdDev; } catch(exception& e) { - errorOut(e, "MothurOut", "getAverages"); + errorOut(e, "MothurOut", "getStandardDeviation"); exit(1); } } @@ -3538,6 +4073,44 @@ double MothurOut::getStandardDeviation(vector& featureVector){ } } /**************************************************************************************************/ +// returns largest value in vector +double MothurOut::max(vector& featureVector){ + try { + if (featureVector.size() == 0) { mothurOut("[ERROR]: vector size = 0!\n"); control_pressed=true; return 0.0; } + + //finds largest + double largest = featureVector[0]; + for (int i = 1; i < featureVector.size(); i++) { + if (featureVector[i] > largest) { largest = featureVector[i]; } + } + + return largest; + } + catch(exception& e) { + errorOut(e, "MothurOut", "max"); + exit(1); + } +} +/**************************************************************************************************/ +// returns smallest value in vector +double MothurOut::min(vector& featureVector){ + try { + if (featureVector.size() == 0) { mothurOut("[ERROR]: vector size = 0!\n"); control_pressed=true; return 0.0; } + + //finds smallest + double smallest = featureVector[0]; + for (int i = 1; i < featureVector.size(); i++) { + if (featureVector[i] < smallest) { smallest = featureVector[i]; } + } + + return smallest; + } + catch(exception& e) { + errorOut(e, "MothurOut", "min"); + exit(1); + } +} +/**************************************************************************************************/