fixed cluster.split with average method

[mothur.git] / readblast.cpp

diff --git a/readblast.cpp b/readblast.cpp
index a6d23e95bfddf71afb20a2d4c2b2d8d1377db71d..4833d0125d8a286e0116be5ae0644c33f5443803 100644 (file)
--- a/readblast.cpp
+++ b/readblast.cpp
@@ -16,12 +16,13 @@ inline bool compareOverlap(seqDist left, seqDist right){
        return (left.dist < right.dist);        
 } 
 /*********************************************************************************************/
-ReadBlast::ReadBlast(string file, float c, float p, int l, bool m, bool h) : blastfile(file), cutoff(c), penalty(p), length(l), minWanted(m), hclusterWanted(h) {
+ReadBlast::ReadBlast(string file, float c, float p, int l, bool ms, bool h) : blastfile(file), cutoff(c), penalty(p), length(l), minWanted(ms), hclusterWanted(h) {
        try {
+               m = MothurOut::getInstance();
                matrix = NULL;
        }
        catch(exception& e) {
-               errorOut(e, "ReadBlast", "ReadBlast");
+               m->errorOut(e, "ReadBlast", "ReadBlast");
                exit(1);
        }
 } 
@@ -29,12 +30,14 @@ ReadBlast::ReadBlast(string file, float c, float p, int l, bool m, bool h) : bla
 //assumptions about the blast file: 
 //1. if duplicate lines occur the first line is always best and is chosen
 //2. blast scores are grouped together, ie. a a .... score, a b .... score, a c ....score...
-void ReadBlast::read(NameAssignment* nameMap) {
+int ReadBlast::read(NameAssignment* nameMap) {
        try {
        
                //if the user has not given a names file read names from blastfile
                if (nameMap->size() == 0) { readNames(nameMap);  }
                int nseqs = nameMap->size();
+               
+               if (m->control_pressed) { return 0; }
 
                ifstream fileHandle;
                openInputFile(blastfile, fileHandle);
@@ -59,7 +62,14 @@ void ReadBlast::read(NameAssignment* nameMap) {
                        openOutputFile(overlapFile, outOverlap);
                        openOutputFile(distFile, outDist);
                }
-       
+               
+               if (m->control_pressed) { 
+                       fileHandle.close();
+                       if (!hclusterWanted) {  delete matrix; }
+                       else { outOverlap.close(); remove(overlapFile.c_str()); outDist.close(); remove(distFile.c_str());  }
+                       return 0;
+               }
+               
                Progress* reading = new Progress("Reading blast:     ", nseqs * nseqs);
                
                //this is used to quickly find if we already have a distance for this combo
@@ -98,11 +108,19 @@ void ReadBlast::read(NameAssignment* nameMap) {
                                        }
                                }
                        }
-               }else { mothurOut("Error in your blast file, cannot read."); mothurOutEndLine(); exit(1); }
+               }else { m->mothurOut("Error in your blast file, cannot read."); m->mothurOutEndLine(); exit(1); }
 
                                
                //read file
                while(!fileHandle.eof()){  
+               
+                       if (m->control_pressed) { 
+                               fileHandle.close();
+                               if (!hclusterWanted) {  delete matrix; }
+                               else { outOverlap.close(); remove(overlapFile.c_str()); outDist.close(); remove(distFile.c_str());  }
+                               delete reading;
+                               return 0;
+                       }
                        
                        //read in line from file
                        fileHandle >> firstName >> secondName >> percentId >> numBases >> mismatch >> gap >> startQuery >> endQuery >> startRef >> endRef >> eScore >> score;
@@ -151,6 +169,7 @@ void ReadBlast::read(NameAssignment* nameMap) {
                                        map<int, float>::iterator itDist;
                                        for(it=thisRowsBlastScores.begin(); it!=thisRowsBlastScores.end(); it++) {  
                                                distance = 1.0 - (it->second / refScore);
+               
                                                
                                                //do we already have the distance calculated for b->a
                                                map<string,int>::iterator itA = nameMap->find(currentRow);
@@ -158,10 +177,12 @@ void ReadBlast::read(NameAssignment* nameMap) {
                                                
                                                //if we have it then compare
                                                if (itDist != dists[it->first].end()) {
+               if (distance < 0.0) { cout << currentRow << '\t' << nameMap->get(it->first) << '\t' << "score = " << it->second << " refscore = " << refScore << " distance = " << distance << " distance = " << itDist->second << endl;        }
+
                                                        //if you want the minimum blast score ratio, then pick max distance
                                                        if(minWanted) {  distance = max(itDist->second, distance);  }
                                                        else{   distance = min(itDist->second, distance);  }
-                                                       
+
                                                        //is this distance below cutoff
                                                        if (distance < cutoff) {
                                                                if (!hclusterWanted) {
@@ -248,6 +269,14 @@ void ReadBlast::read(NameAssignment* nameMap) {
                thisRowsBlastScores.clear();
                dists.clear();
                
+               if (m->control_pressed) { 
+                               fileHandle.close();
+                               if (!hclusterWanted) {  delete matrix; }
+                               else { outOverlap.close(); remove(overlapFile.c_str()); outDist.close(); remove(distFile.c_str());  }
+                               delete reading;
+                               return 0;
+               }
+               
                if (!hclusterWanted) {
                        sort(overlap.begin(), overlap.end(), compareOverlap);
                }else {
@@ -255,19 +284,29 @@ void ReadBlast::read(NameAssignment* nameMap) {
                        outOverlap.close();
                }
                
+               if (m->control_pressed) { 
+                               fileHandle.close();
+                               if (!hclusterWanted) {  delete matrix; }
+                               else {  remove(overlapFile.c_str());  remove(distFile.c_str());  }
+                               delete reading;
+                               return 0;
+               }
+               
                reading->finish();
                delete reading;
                fileHandle.close();
+               
+               return 0;
        }
        catch(exception& e) {
-               errorOut(e, "ReadBlast", "read");
+               m->errorOut(e, "ReadBlast", "read");
                exit(1);
        }
 } 
 /*********************************************************************************************/
-void ReadBlast::readNames(NameAssignment* nameMap) {
+int ReadBlast::readNames(NameAssignment* nameMap) {
        try {
-               mothurOut("Reading names... "); cout.flush();
+               m->mothurOut("Reading names... "); cout.flush();
                
                string name, hold, prevName;
                int num = 1;
@@ -275,18 +314,24 @@ void ReadBlast::readNames(NameAssignment* nameMap) {
                ifstream in;
                openInputFile(blastfile, in);
                
+               ofstream outName;
+               openOutputFile("tempOutNames", outName);
+               
                //read first line
                in >> prevName;
+       
                for (int i = 0; i < 11; i++) {  in >> hold;  }
                gobble(in);
-               
+                               
                //save name in nameMap
                nameMap->push_back(prevName);
                
                while (!in.eof()) {
+                       if (m->control_pressed) { in.close(); return 0; }
                        
                        //read line
                        in >> name;
+       
                        for (int i = 0; i < 11; i++) {  in >> hold;  }
                        gobble(in);
                        
@@ -306,12 +351,15 @@ void ReadBlast::readNames(NameAssignment* nameMap) {
                //openOutputFile(outNames, out);
                //nameMap->print(out);
                //out.close();
+               if (m->control_pressed) { return 0; }
+               
+               m->mothurOut(toString(num) + " names read."); m->mothurOutEndLine();
                
-               mothurOut(toString(num) + " names read."); mothurOutEndLine();
+               return 0;
                
        }
        catch(exception& e) {
-               errorOut(e, "ReadBlast", "readNames");
+               m->errorOut(e, "ReadBlast", "readNames");
                exit(1);
        }
 }