paralellized seq.error and dist.shared added some error checks to libshuff and dist...

[mothur.git] / mothurout.cpp

diff --git a/mothurout.cpp b/mothurout.cpp
index 7309c174c83027437e67026869f53161101e11bc..a56a6217a8c136e1fcb9f3f3078c5418547220fa 100644 (file)
--- a/mothurout.cpp
+++ b/mothurout.cpp
@@ -39,6 +39,8 @@ void MothurOut::printCurrentFiles()  {
                if (sharedfile != "")           {  mothurOut("shared=" + sharedfile); mothurOutEndLine();                       }
                if (taxonomyfile != "")         {  mothurOut("taxonomy=" + taxonomyfile); mothurOutEndLine();           }
                if (treefile != "")                     {  mothurOut("tree=" + treefile); mothurOutEndLine();                           }
+               if (flowfile != "")                     {  mothurOut("flow=" + flowfile); mothurOutEndLine();                           }
+               if (processors != "1")          {  mothurOut("processors=" + processors); mothurOutEndLine();           }
                
        }
        catch(exception& e) {
@@ -46,6 +48,42 @@ void MothurOut::printCurrentFiles()  {
                exit(1);
        }
 }
+/*********************************************************************************************/
+bool MothurOut::hasCurrentFiles()  {
+       try {
+               bool hasCurrent = false;
+               
+               if (accnosfile != "")           {  return true;                 }
+               if (columnfile != "")           {  return true;                 }
+               if (designfile != "")           {  return true;                 }
+               if (fastafile != "")            {  return true;                 }
+               if (groupfile != "")            {  return true;                 }
+               if (listfile != "")                     {  return true;                 }
+               if (namefile != "")                     {  return true;                 }
+               if (oligosfile != "")           {  return true;                 }
+               if (orderfile != "")            {  return true;                 }
+               if (ordergroupfile != "")       {  return true;                 }
+               if (phylipfile != "")           {  return true;                 }
+               if (qualfile != "")                     {  return true;                 }
+               if (rabundfile != "")           {  return true;                 }
+               if (relabundfile != "")         {  return true;                 }
+               if (sabundfile != "")           {  return true;                 }
+               if (sfffile != "")                      {  return true;                 }
+               if (sharedfile != "")           {  return true;                 }
+               if (taxonomyfile != "")         {  return true;                 }
+               if (treefile != "")                     {  return true;                 }
+               if (flowfile != "")                     {  return true;                 }
+               if (processors != "1")          {  return true;                 }
+               
+               return hasCurrent;
+               
+       }
+       catch(exception& e) {
+               errorOut(e, "MothurOut", "hasCurrentFiles");
+               exit(1);
+       }
+}
+
 /*********************************************************************************************/
 void MothurOut::clearCurrentFiles()  {
        try {
@@ -67,7 +105,9 @@ void MothurOut::clearCurrentFiles()  {
                sfffile = "";
                oligosfile = "";
                accnosfile = "";
-               taxonomyfile = "";              
+               taxonomyfile = "";      
+               flowfile = "";
+               processors = "1";
        }
        catch(exception& e) {
                errorOut(e, "MothurOut", "clearCurrentFiles");
@@ -207,6 +247,53 @@ void MothurOut::mothurOutEndLine() {
        }
 }
 /*********************************************************************************************/
+void MothurOut::mothurOut(string output, ofstream& outputFile) {
+       try {
+               
+#ifdef USE_MPI
+               int pid;
+               MPI_Comm_rank(MPI_COMM_WORLD, &pid); 
+               
+               if (pid == 0) { //only one process should output to screen
+#endif
+                       
+                       cout << output;
+                       out << output;
+                       outputFile << output;
+                       
+#ifdef USE_MPI
+               }
+#endif
+       }
+       catch(exception& e) {
+               errorOut(e, "MothurOut", "MothurOut");
+               exit(1);
+       }
+}
+/*********************************************************************************************/
+void MothurOut::mothurOutEndLine(ofstream& outputFile) {
+       try {
+#ifdef USE_MPI
+               int pid;
+               MPI_Comm_rank(MPI_COMM_WORLD, &pid); 
+               
+               if (pid == 0) { //only one process should output to screen
+#endif
+                       
+                       cout << endl;
+                       out << endl;
+                       outputFile << endl;
+                       
+#ifdef USE_MPI
+               }
+#endif
+       }
+       catch(exception& e) {
+               errorOut(e, "MothurOut", "MothurOutEndLine");
+               exit(1);
+       }
+}
+/*********************************************************************************************/
 void MothurOut::mothurOutJustToLog(string output) {
        try {
                #ifdef USE_MPI
@@ -398,12 +485,12 @@ string MothurOut::getline(ifstream& fileHandle) {
        
                string line = "";
                
-               while (!fileHandle.eof())       {
+               while (fileHandle)      {
                        //get next character
                        char c = fileHandle.get(); 
                        
                        //are you at the end of the line
-                       if ((c == '\n') || (c == '\r') || (c == '\f')){  break; }       
+                       if ((c == '\n') || (c == '\r') || (c == '\f') || (c == EOF)){  break;   }       
                        else {          line += c;              }
                }
                
@@ -1114,7 +1201,43 @@ vector<unsigned long int> MothurOut::divideFile(string filename, int& proc) {
                exit(1);
        }
 }
-
+/**************************************************************************************************/
+int MothurOut::divideFile(string filename, int& proc, vector<string>& files) {
+       try{
+               
+               vector<unsigned long int> filePos = divideFile(filename, proc);
+               
+               for (int i = 0; i < (filePos.size()-1); i++) {
+                       
+                       //read file chunk
+                       ifstream in;
+                       openInputFile(filename, in);
+                       in.seekg(filePos[i]);
+                       unsigned long int size = filePos[(i+1)] - filePos[i];
+                       char* chunk = new char[size];
+                       in.read(chunk, size);
+                       in.close();
+                       
+                       //open new file
+                       string fileChunkName = filename + "." + toString(i) + ".tmp";
+                       ofstream out; 
+                       openOutputFile(fileChunkName, out);
+                       
+                       out << chunk << endl;
+                       out.close();
+                       delete[] chunk;
+                       
+                       //save name
+                       files.push_back(fileChunkName);
+               }
+                               
+               return 0;
+       }
+       catch(exception& e) {
+               errorOut(e, "MothurOut", "divideFile");
+               exit(1);
+       }
+}
 /***********************************************************************/
 
 bool MothurOut::isTrue(string f){
@@ -1153,6 +1276,33 @@ float MothurOut::ceilDist(float dist, int precision){
                exit(1);
        }
 }
+/**********************************************************************************************************************/
+int MothurOut::readNames(string namefile, map<string, string>& nameMap) { 
+       try {
+               
+               //open input file
+               ifstream in;
+               openInputFile(namefile, in);
+               
+               while (!in.eof()) {
+                       if (control_pressed) { break; }
+                       
+                       string firstCol, secondCol;
+                       in >> firstCol >> secondCol; gobble(in);
+                       
+                       nameMap[firstCol] = secondCol;
+               }
+               in.close();
+               
+               return 0;
+               
+       }
+       catch(exception& e) {
+               errorOut(e, "MothurOut", "readNames");
+               exit(1);
+       }
+}
+
 /**********************************************************************************************************************/
 map<string, int> MothurOut::readNames(string namefile) { 
        try {
@@ -1183,6 +1333,42 @@ map<string, int> MothurOut::readNames(string namefile) {
                exit(1);
        }
 }
+/**********************************************************************************************************************/
+int MothurOut::readNames(string namefile, vector<seqPriorityNode>& nameVector, map<string, string>& fastamap) { 
+       try {
+               int error = 0;
+               
+               //open input file
+               ifstream in;
+               openInputFile(namefile, in);
+               
+               while (!in.eof()) {
+                       if (control_pressed) { break; }
+                       
+                       string firstCol, secondCol;
+                       in >> firstCol >> secondCol; gobble(in);
+                       
+                       int num = getNumNames(secondCol);
+                       
+                       map<string, string>::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.close();
+               
+               return error;
+               
+       }
+       catch(exception& e) {
+               errorOut(e, "MothurOut", "readNames");
+               exit(1);
+       }
+}
 
 /***********************************************************************/