added classify.otu command

[mothur.git] / cluster.cpp

diff --git a/cluster.cpp b/cluster.cpp
index bd5986e7d7a2d0bdfe759088c8306e206a4ee9ad..96ca44061436f873ee8b663e248ddcc386c995cb 100644 (file)
--- a/cluster.cpp
+++ b/cluster.cpp
@@ -50,11 +50,17 @@ rabund(rav), list(lv), dMatrix(dm), method(f)
        // a list contains pointers (iterators) to the all distances related
        // to a certain sequence. The Vector is accessed via the index of a 
        // sequence in the distance matrix.
+//ofstream outtemp;
+//string temp = "temp";
+//openOutputFile(temp, outtemp);       
+//cout << lv->size() << endl;
        seqVec = vector<MatVec>(lv->size());
        for (MatData currentCell = dMatrix->begin(); currentCell != dMatrix->end(); currentCell++) {
+//outtemp << currentCell->row << '\t' << currentCell->column  << '\t' << currentCell->dist << endl;
                seqVec[currentCell->row].push_back(currentCell);
                seqVec[currentCell->column].push_back(currentCell);
        }
+//outtemp.close();
        mapWanted = false;  //set to true by mgcluster to speed up overlap merge
        
        //save so you can modify as it changes in average neighbor
@@ -71,11 +77,16 @@ void Cluster::getRowColCells() {
                smallRow = smallCell->row;              // get its row
                smallCol = smallCell->column;   // get its column
                smallDist = smallCell->dist;    // get the smallest distance
-       
+       //cout << "small row = " << smallRow << "small col = " << smallCol << "small dist = " << smallDist << endl;
+        
                rowCells = seqVec[smallRow];    // all distances related to the row index
                colCells = seqVec[smallCol];    // all distances related to the column index
                nRowCells = rowCells.size();
                nColCells = colCells.size();
+//cout << "num rows = " << nRowCells << "num col = " << nColCells << endl;
+               
+               //for (int i = 0; i < nColCells; i++) { cout << colCells[i]->row << '\t' << colCells[i]->column << endl;  }
+               //for (int i = 0; i < nRowCells; i++) { cout << rowCells[i]->row << '\t' << rowCells[i]->column << endl;  }
        }
        catch(exception& e) {
                m->errorOut(e, "Cluster", "getRowColCells");
@@ -86,50 +97,60 @@ void Cluster::getRowColCells() {
 /***********************************************************************/
 // Remove the specified cell from the seqVec and from the sparse
 // matrix
-void Cluster::removeCell(const MatData& cell, int vrow, int vcol, bool rmMatrix)
-{
-       ull drow = cell->row;
-       ull dcol = cell->column;
-       if (((vrow >=0) && (drow != smallRow)) ||
-               ((vcol >=0) && (dcol != smallCol))) {
-               ull dtemp = drow;
-               drow = dcol;
-               dcol = dtemp;
-       }
+void Cluster::removeCell(const MatData& cell, int vrow, int vcol, bool rmMatrix){
+       try {
+       
+               ull drow = cell->row;
+                       ull dcol = cell->column;
+                       if (((vrow >=0) && (drow != smallRow)) ||
+                               ((vcol >=0) && (dcol != smallCol))) {
+                               ull dtemp = drow;
+                               drow = dcol;
+                               dcol = dtemp;
+                       }
 
-       ull crow;
-       ull ccol;
-       int nCells;
-       if (vrow < 0) {
-               nCells = seqVec[drow].size();
-               for (vrow=0; vrow<nCells;vrow++) {
-                       crow = seqVec[drow][vrow]->row;
-                       ccol = seqVec[drow][vrow]->column;
-                       if (((crow == drow) && (ccol == dcol)) ||
-                               ((ccol == drow) && (crow == dcol))) {
-                               break;
+                       ull crow;
+                       ull ccol;
+                       int nCells;
+                       if (vrow < 0) {
+                               nCells = seqVec[drow].size();
+                               for (vrow=0; vrow<nCells;vrow++) {
+                                       crow = seqVec[drow][vrow]->row;
+                                       ccol = seqVec[drow][vrow]->column;
+                                       if (((crow == drow) && (ccol == dcol)) ||
+                                               ((ccol == drow) && (crow == dcol))) {
+                                               break;
+                                       }
+                               }
                        }
-               }
-       }
-       seqVec[drow].erase(seqVec[drow].begin()+vrow);
-       if (vcol < 0) {
-               nCells = seqVec[dcol].size();
-               for (vcol=0; vcol<nCells;vcol++) {
-                       crow = seqVec[dcol][vcol]->row;
-                       ccol = seqVec[dcol][vcol]->column;
-                       if (((crow == drow) && (ccol == dcol)) ||
-                               ((ccol == drow) && (crow == dcol))) {
-                               break;
+
+                       seqVec[drow].erase(seqVec[drow].begin()+vrow);
+                       if (vcol < 0) {
+                               nCells = seqVec[dcol].size();
+                               for (vcol=0; vcol<nCells;vcol++) {
+                                       crow = seqVec[dcol][vcol]->row;
+                                       ccol = seqVec[dcol][vcol]->column;
+                                       if (((crow == drow) && (ccol == dcol)) ||
+                                               ((ccol == drow) && (crow == dcol))) {
+                                               break;
+                                       }
+                               }
                        }
-               }
+               
+                       seqVec[dcol].erase(seqVec[dcol].begin()+vcol);
+               
+                       if (rmMatrix) {
+                       //cout << " removing = " << cell->row << '\t' << cell->column  << '\t' << cell->dist << endl;
+                               dMatrix->rmCell(cell);
+               //      cout << "done" << endl;
+                       }
+               
        }
-       seqVec[dcol].erase(seqVec[dcol].begin()+vcol);
-       if (rmMatrix) {
-               dMatrix->rmCell(cell);
+       catch(exception& e) {
+               m->errorOut(e, "Cluster", "removeCell");
+               exit(1);
        }
 }
-
-
 /***********************************************************************/
 
 void Cluster::clusterBins(){
@@ -177,7 +198,8 @@ void Cluster::clusterNames(){
 void Cluster::update(double& cutOFF){
        try {
                getRowColCells();       
-       
+//cout << "got rowcells" << endl;
+
                vector<int> foundCol(nColCells, 0);
 
                int search;