]> git.donarmstrong.com Git - mothur.git/blobdiff - sharedcommand.cpp
added hcluster command and fixed some bugs, namely one with smart distancing.
[mothur.git] / sharedcommand.cpp
index 6ca1ed63585463d92ac8dc7aa65f921ca1070308..727a04b273fc3ee4b4c9c5882f55e746ad2c0d6a 100644 (file)
@@ -20,65 +20,104 @@ SharedCommand::SharedCommand(){
                filename = getRootName(filename);
                filename = filename + "shared";
                openOutputFile(filename, out);
+               
+               groupMap = globaldata->gGroupmap;
+               
+               //fill filehandles with neccessary ofstreams
+               int i;
+               ofstream* temp;
+               for (i=0; i<groupMap->getNumGroups(); i++) {
+                       temp = new ofstream;
+                       filehandles[groupMap->namesOfGroups[i]] = temp;
+               }
+               
+               //set fileroot
+               fileroot = getRootName(globaldata->getListFile());
+               
+               //clears file before we start to write to it below
+               for (int i=0; i<groupMap->getNumGroups(); i++) {
+                       remove((fileroot + groupMap->namesOfGroups[i] + ".rabund").c_str());
+               }
+
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the SharedCommand class Function SharedCommand. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }
-       catch(...) {
-               cout << "An unknown error has occurred in the SharedCommand class function SharedCommand. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               errorOut(e, "SharedCommand", "SharedCommand");
                exit(1);
        }
-
 }
 //**********************************************************************************************************************
 
 int SharedCommand::execute(){
        try {
                
-               cout << "creating sharedfile...";
                //lookup.clear();
-               int count = 1;
                string errorOff = "no error";
+               //errorOff = "";
                        
                //read in listfile
                read = new ReadOTUFile(globaldata->inputFileName);      
                read->read(&*globaldata); 
+               delete read;
 
                input = globaldata->ginput;
                SharedList = globaldata->gSharedList;
                string lastLabel = SharedList->getLabel();
                vector<SharedRAbundVector*> lookup; 
-                               
+               
+               if (SharedList->getNumSeqs() != groupMap->getNumSeqs()) {  
+                       mothurOut("Your group file contains " + toString(groupMap->getNumSeqs()) + " sequences and list file contains " + toString(SharedList->getNumSeqs()) + " sequences. Please correct."); mothurOutEndLine(); 
+                       
+                       out.close();
+                       remove(filename.c_str()); //remove blank shared file you made
+                       
+                       createMisMatchFile();
+                       
+                       //delete memory
+                       for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) {
+                               delete it3->second;
+                       }
+                       delete SharedList;
+                       globaldata->gSharedList = NULL;
+                       
+                       return 1; 
+               }
+               
                //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 = globaldata->labels;
-               set<int> userLines = globaldata->lines;
+               set<string> userLabels = globaldata->labels;    
                
-               
-               while((SharedList != NULL) && ((globaldata->allLines == 1) || (userLabels.size() != 0) || (userLines.size() != 0))) {
+               while((SharedList != NULL) && ((globaldata->allLines == 1) || (userLabels.size() != 0))) {
                        
 
-                       if(globaldata->allLines == 1 || globaldata->lines.count(count) == 1 || globaldata->labels.count(SharedList->getLabel()) == 1){
+                       if(globaldata->allLines == 1 || globaldata->labels.count(SharedList->getLabel()) == 1){
+                                       
                                        lookup = SharedList->getSharedRAbundVector();
+                                       mothurOut(lookup[0]->getLabel()); mothurOutEndLine();
+                                       
                                        printSharedData(lookup); //prints info to the .shared file
                                        for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  }
                                
                                        processedLabels.insert(SharedList->getLabel());
                                        userLabels.erase(SharedList->getLabel());
-                                       userLines.erase(count);
                        }
                        
                        if ((anyLabelsToProcess(SharedList->getLabel(), userLabels, errorOff) == true) && (processedLabels.count(lastLabel) != 1)) {
+                                       string saveLabel = SharedList->getLabel();
+                                       
                                        delete SharedList;
                                        SharedList = input->getSharedListVector(lastLabel); //get new list vector to process
                                        
                                        lookup = SharedList->getSharedRAbundVector();
+                                       mothurOut(lookup[0]->getLabel()); mothurOutEndLine();
+                                       
                                        printSharedData(lookup); //prints info to the .shared file
                                        for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  }
                                        
                                        processedLabels.insert(SharedList->getLabel());
                                        userLabels.erase(SharedList->getLabel());
+                                       
+                                       //restore real lastlabel to save below
+                                       SharedList->setLabel(saveLabel);
                        }
                        
                
@@ -86,51 +125,45 @@ int SharedCommand::execute(){
                                
                        delete SharedList;
                        SharedList = input->getSharedListVector(); //get new list vector to process
-                       
-                       count++;                
                }
                
                //output error messages about any remaining user labels
                set<string>::iterator it;
                bool needToRun = false;
                for (it = userLabels.begin(); it != userLabels.end(); it++) {  
-                       //cout << "Your file does not include the label "<< *it; 
                        if (processedLabels.count(lastLabel) != 1) {
-                               //cout << ". I will use " << lastList->getLabel() << "." << endl;
                                needToRun = true;
-                       }else {
-                               //cout << ". Please refer to " << lastList->getLabel() << "." << endl;
                        }
                }
                
-               //run last line if you need to
+               //run last label if you need to
                if (needToRun == true)  {
-                       delete SharedList;
+                       if (SharedList != NULL) {       delete SharedList;      }
                        SharedList = input->getSharedListVector(lastLabel); //get new list vector to process
                                        
                        lookup = SharedList->getSharedRAbundVector();
+                       mothurOut(lookup[0]->getLabel()); mothurOutEndLine();
+                       
                        printSharedData(lookup); //prints info to the .shared file
                        for (int i = 0; i < lookup.size(); i++) {  delete lookup[i];  }
                        delete SharedList;
                }
                
                globaldata->gSharedList = NULL;
-               delete read;
                
                out.close();
                
-               cout << "complete." << endl;
+               for (it3 = filehandles.begin(); it3 != filehandles.end(); it3++) {
+                       delete it3->second;
+               }
+
+               
                return 0;
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the SharedCommand class Function execute. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
-               exit(1);
-       }
-       catch(...) {
-               cout << "An unknown error has occurred in the SharedCommand class function execute. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               errorOut(e, "SharedCommand", "execute");
                exit(1);
        }
-
 }
 //**********************************************************************************************************************
 void SharedCommand::printSharedData(vector<SharedRAbundVector*> thislookup) {
@@ -138,20 +171,104 @@ void SharedCommand::printSharedData(vector<SharedRAbundVector*> thislookup) {
                
                //initialize bin values
                for (int i = 0; i < thislookup.size(); i++) {
+//cout << "in printData " << thislookup[i]->getLabel() << '\t' << thislookup[i]->getGroup() <<  endl;
                        out << thislookup[i]->getLabel() << '\t' << thislookup[i]->getGroup() << '\t';
                        thislookup[i]->print(out);
+                       
+                       RAbundVector rav = thislookup[i]->getRAbundVector();
+                       openOutputFileAppend(fileroot + thislookup[i]->getGroup() + ".rabund", *(filehandles[thislookup[i]->getGroup()]));
+                       rav.print(*(filehandles[thislookup[i]->getGroup()]));
+                       (*(filehandles[thislookup[i]->getGroup()])).close();
                }
  
        }
        catch(exception& e) {
-               cout << "Standard Error: " << e.what() << " has occurred in the SharedCommand class Function printSharedData. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+               errorOut(e, "SharedCommand", "printSharedData");
                exit(1);
        }
-       catch(...) {
-               cout << "An unknown error has occurred in the SharedCommand class function printSharedData. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+}
+//**********************************************************************************************************************
+void SharedCommand::createMisMatchFile() {
+       try {
+               ofstream outMisMatch;
+               string outputMisMatchName = getRootName(globaldata->inputFileName);
+               
+               //you have sequences in your list file that are not in your group file
+               if (SharedList->getNumSeqs() > groupMap->getNumSeqs()) { 
+                       outputMisMatchName += "missing.group";
+                       mothurOut("For a list of names that are in your list file and not in your group file, please refer to " + outputMisMatchName + "."); mothurOutEndLine();
+                       
+                       openOutputFile(outputMisMatchName, outMisMatch);
+                       
+                       //go through list and if group returns "not found" output it
+                       for (int i = 0; i < SharedList->getNumBins(); i++) {
+                       
+                               string names = SharedList->get(i); 
+                               
+                               while (names.find_first_of(',') != -1) { 
+                                       string name = names.substr(0,names.find_first_of(','));
+                                       names = names.substr(names.find_first_of(',')+1, names.length());
+                                       string group = groupMap->getGroup(name);
+                                       
+                                       if(group == "not found") {      outMisMatch << name << endl;  }
+                               }
+                               
+                               //get last name
+                               string group = groupMap->getGroup(names);
+                               if(group == "not found") {      outMisMatch << names << endl;  }                                
+                       }
+                       
+                       outMisMatch.close();
+                       
+               
+               }else {//you have sequences in your group file that are not in you list file
+                       
+                       outputMisMatchName += "missing.name";
+                       mothurOut("For a list of names that are in your group file and not in your list file, please refer to " + outputMisMatchName + "."); mothurOutEndLine();
+                       
+                       map<string, string> namesInList;
+                       
+                       //go through listfile and get names
+                       for (int i = 0; i < SharedList->getNumBins(); i++) {
+                               
+                               string names = SharedList->get(i); 
+               
+                               while (names.find_first_of(',') != -1) { 
+                                       string name = names.substr(0,names.find_first_of(','));
+                                       names = names.substr(names.find_first_of(',')+1, names.length());
+                                       
+                                       namesInList[name] = name;
+                               }
+                               
+                               //get last name
+                               namesInList[names] = names;                             
+                       }
+                       
+                       //get names of sequences in groupfile
+                       vector<string> seqNames = groupMap->getNamesSeqs();
+               
+                       map<string, string>::iterator itMatch;
+                       
+                       openOutputFile(outputMisMatchName, outMisMatch);
+                       
+                       //loop through names in seqNames and if they aren't in namesIn list output them
+                       for (int i = 0; i < seqNames.size(); i++) {
+                               
+                               itMatch = namesInList.find(seqNames[i]);
+                               
+                               if (itMatch == namesInList.end()) {
+                               
+                                       outMisMatch << seqNames[i] << endl; 
+                               }
+                       }               
+                       outMisMatch.close();
+               }
+       }
+       catch(exception& e) {
+               errorOut(e, "SharedCommand", "createMisMatchFile");
                exit(1);
        }
-       
 }
 
 //**********************************************************************************************************************