X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=weighted.cpp;h=581078085d4e573ad100dbc48f1ec87d64558efa;hb=cfb66eb46a9678a751a8f21f3ea740dffd525f5e;hp=c43180d53409cf583ce86f3388dc9a8eb709988a;hpb=8062b1d0ef60062809448074066f6b6a0f6619a8;p=mothur.git

diff --git a/weighted.cpp b/weighted.cpp
index c43180d..5810780 100644
--- a/weighted.cpp
+++ b/weighted.cpp
@@ -17,24 +17,14 @@ EstOutput Weighted::getValues(Tree* t) {
 		int numGroups;
 		vector<double> D;
 		
-		//if the user has not entered specific groups to analyze then do them all
-		if (globaldata->Groups.size() == 0) {
-			numGroups = tmap->getNumGroups();
-		}else {
-			numGroups = globaldata->Groups.size();
-		}
+		numGroups = globaldata->Groups.size();
 		
 		//calculate number of comparisons i.e. with groups A,B,C = AB, AC, BC = 3;
-		int n = 1;
 		int count = 0;
-		for (int i=1; i<numGroups; i++) { 
-			for (int l = n; l < numGroups; l++) {	
+		for (int i=0; i<numGroups; i++) { 
+			for (int l = i+1; l < numGroups; l++) {	
 				//initialize weighted scores
-				if (globaldata->Groups.size() == 0) {
-					WScore[tmap->namesOfGroups[i-1]+tmap->namesOfGroups[l]] = 0.0;
-				}else {
-					WScore[globaldata->Groups[i-1]+globaldata->Groups[l]] = 0.0;
-				}
+				WScore[globaldata->Groups[i]+globaldata->Groups[l]] = 0.0;
 				
 				D.push_back(0.0000); //initialize a spot in D for each combination
 				
@@ -49,116 +39,72 @@ EstOutput Weighted::getValues(Tree* t) {
 							
 						//if you have a BL
 						if(t->tree[index].getBranchLength() != -1){
-							sum += t->tree[index].getBranchLength();
+							sum += abs(t->tree[index].getBranchLength());
 						}
 						index = t->tree[index].getParent();
 					}
 						
 					//get last breanch length added
 					if(t->tree[index].getBranchLength() != -1){
-						sum += t->tree[index].getBranchLength();
+						sum += abs(t->tree[index].getBranchLength());
 					}
 						
-					if (globaldata->Groups.size() == 0) {
-						//is this sum from a sequence which is in one of the users groups
-						if (inUsersGroups(t->tree[v].getGroup(), tmap->namesOfGroups) == true) {
-							//is this sum from a sequence which is in this groupCombo
-							if ((t->tree[v].getGroup() == tmap->namesOfGroups[i-1]) || (t->tree[v].getGroup() == tmap->namesOfGroups[l])) {
-								sum /= (double)tmap->seqsPerGroup[t->tree[v].getGroup()];
-								D[count] += sum; 
-							}
-						}
-					}else {
-						//is this sum from a sequence which is in one of the users groups
-						if (inUsersGroups(t->tree[v].getGroup(), globaldata->Groups) == true) {
-							//is this sum from a sequence which is in this groupCombo
-							if ((t->tree[v].getGroup() == globaldata->Groups[i-1]) || (t->tree[v].getGroup() == globaldata->Groups[l])) {
-								sum /= (double)tmap->seqsPerGroup[t->tree[v].getGroup()];
-								D[count] += sum; 
-							}
+					//is this sum from a sequence which is in one of the users groups
+					if (inUsersGroups(t->tree[v].getGroup(), globaldata->Groups) == true) {
+						//is this sum from a sequence which is in this groupCombo
+						if ((t->tree[v].getGroup() == globaldata->Groups[i]) || (t->tree[v].getGroup() == globaldata->Groups[l])) {
+							sum /= (double)tmap->seqsPerGroup[t->tree[v].getGroup()];
+							D[count] += sum; 
 						}
 					}
 				}
 				/*********************************************************/
 				count++;
 			}
-			n++;
 		}
 		
 		data.clear(); //clear out old values
 	
 		for(int i=0;i<t->getNumNodes();i++){
 			//calculate weighted score for each of the group comb i.e. with groups A,B,C = AB, AC, BC.
-			n = 1;
-			for (int b=1; b<numGroups; b++) { 
-				for (int l = n; l < numGroups; l++) {
+			for (int b=0; b<numGroups; b++) { 
+				for (int l = b+1; l < numGroups; l++) {
 					//calculate a u value for each combo
 					double u;
-					//the user has not entered specific groups
-					if (globaldata->Groups.size() == 0) {
-						//does this node have descendants from group b-1
-						it = t->tree[i].pcount.find(tmap->namesOfGroups[b-1]);
-						//if it does u = # of its descendants with a certain group / total number in tree with a certain group
-						if (it != t->tree[i].pcount.end()) {
-							u = (double) t->tree[i].pcount[tmap->namesOfGroups[b-1]] / (double) tmap->seqsPerGroup[tmap->namesOfGroups[b-1]];
-						}else { u = 0.00; }
-		
-						//does this node have descendants from group l
-						it = t->tree[i].pcount.find(tmap->namesOfGroups[l]);
-						//if it does subtract their percentage from u
-						if (it != t->tree[i].pcount.end()) {
-							u -= (double) t->tree[i].pcount[tmap->namesOfGroups[l]] / (double) tmap->seqsPerGroup[tmap->namesOfGroups[l]];
-						}
-						
-						u = abs(u) * t->tree[i].getBranchLength();
-					
-						//save groupcombs u value
-						WScore[tmap->namesOfGroups[b-1]+tmap->namesOfGroups[l]] += u;
-						
-					//the user has entered specific groups	
-					}else {
-						//does this node have descendants from group b-1
-						it = t->tree[i].pcount.find(globaldata->Groups[b-1]);
-						//if it does u = # of its descendants with a certain group / total number in tree with a certain group
-						if (it != t->tree[i].pcount.end()) {
-							u = (double) t->tree[i].pcount[globaldata->Groups[b-1]] / (double) tmap->seqsPerGroup[globaldata->Groups[b-1]];
-						}else { u = 0.00; }
+					//does this node have descendants from group b-1
+					it = t->tree[i].pcount.find(globaldata->Groups[b]);
+					//if it does u = # of its descendants with a certain group / total number in tree with a certain group
+					if (it != t->tree[i].pcount.end()) {
+						u = (double) t->tree[i].pcount[globaldata->Groups[b]] / (double) tmap->seqsPerGroup[globaldata->Groups[b]];
+					}else { u = 0.00; }
 		
-						//does this node have descendants from group l
-						it = t->tree[i].pcount.find(globaldata->Groups[l]);
-						//if it does subtract their percentage from u
-						if (it != t->tree[i].pcount.end()) {
-							u -= (double) t->tree[i].pcount[globaldata->Groups[l]] / (double) tmap->seqsPerGroup[globaldata->Groups[l]];
-						}
+					//does this node have descendants from group l
+					it = t->tree[i].pcount.find(globaldata->Groups[l]);
+					//if it does subtract their percentage from u
+					if (it != t->tree[i].pcount.end()) {
+						u -= (double) t->tree[i].pcount[globaldata->Groups[l]] / (double) tmap->seqsPerGroup[globaldata->Groups[l]];
+					}
 						
-						u = abs(u) * t->tree[i].getBranchLength();
+					u = abs(u * t->tree[i].getBranchLength());
 					
-						//save groupcombs u value
-						WScore[globaldata->Groups[b-1]+globaldata->Groups[l]] += u;
-					}
+					//save groupcombs u value
+					WScore[globaldata->Groups[b]+globaldata->Groups[l]] += u;
 				/*********************************************************/
 				}
-				n++;
 			}
 		}
   
 		//calculate weighted score for each group combination
 		double UN;	
-		n = 1;
 		count = 0;
-		for (int i=1; i<numGroups; i++) { 
-			for (int l = n; l < numGroups; l++) {
-				//the user has not entered specific groups
-				if (globaldata->Groups.size() == 0) {
-					UN = (WScore[tmap->namesOfGroups[i-1]+tmap->namesOfGroups[l]] / D[count]);
-				}else {//they have entered specific groups
-					UN = (WScore[globaldata->Groups[i-1]+globaldata->Groups[l]] / D[count]);
-				}
+		for (int i=0; i<numGroups; i++) { 
+			for (int l = i+1; l < numGroups; l++) {
+				UN = (WScore[globaldata->Groups[i]+globaldata->Groups[l]] / D[count]);
+		
 				if (isnan(UN) || isinf(UN)) { UN = 0; } 
 				data.push_back(UN);
 				count++;
 			}
-			n++;
 		}
 		return data;
 	}
@@ -173,4 +119,97 @@ EstOutput Weighted::getValues(Tree* t) {
 
 }
 
-/**************************************************************************************************/
\ No newline at end of file
+/**************************************************************************************************/
+EstOutput Weighted::getValues(Tree* t, string groupA, string groupB) { 
+ try {
+		globaldata = GlobalData::getInstance();
+		
+		data.clear(); //clear out old values
+		
+		//initialize weighted score
+		WScore[(groupA+groupB)] = 0.0;
+		float D = 0.0;
+		
+						
+		/********************************************************/
+		//calculate a D value for the group combo
+		for(int v=0;v<t->getNumLeaves();v++){
+			int index = v;
+			double sum = 0.0000;
+		
+			//while you aren't at root
+			while(t->tree[index].getParent() != -1){
+							
+				//if you have a BL
+				if(t->tree[index].getBranchLength() != -1){
+					sum += abs(t->tree[index].getBranchLength());
+				}
+				index = t->tree[index].getParent();
+			}
+						
+			//get last breanch length added
+			if(t->tree[index].getBranchLength() != -1){
+				sum += abs(t->tree[index].getBranchLength());
+			}
+						
+			if ((t->tree[v].getGroup() == groupA) || (t->tree[v].getGroup() == groupB)) {
+				sum /= (double)tmap->seqsPerGroup[t->tree[v].getGroup()];
+				D += sum; 
+			}
+		}
+		/********************************************************/				
+		
+		//calculate u for the group comb 
+		for(int i=0;i<t->getNumNodes();i++){
+			double u;
+			//does this node have descendants from groupA
+			it = t->tree[i].pcount.find(groupA);
+			//if it does u = # of its descendants with a certain group / total number in tree with a certain group
+			if (it != t->tree[i].pcount.end()) {
+				u = (double) t->tree[i].pcount[groupA] / (double) tmap->seqsPerGroup[groupA];
+			}else { u = 0.00; }
+		
+						
+			//does this node have descendants from group l
+			it = t->tree[i].pcount.find(groupB);
+			//if it does subtract their percentage from u
+			if (it != t->tree[i].pcount.end()) {
+				u -= (double) t->tree[i].pcount[groupB] / (double) tmap->seqsPerGroup[groupB];
+			}
+						
+			u = abs(u * t->tree[i].getBranchLength());
+					
+			//save groupcombs u value
+			WScore[(groupA+groupB)] += u;
+		}
+		
+		/********************************************************/
+		
+		//calculate weighted score for the group combination
+		double UN;	
+		UN = (WScore[(groupA+groupB)] / D);
+		
+		if (isnan(UN) || isinf(UN)) { UN = 0; } 
+		data.push_back(UN);
+				
+		return data; 
+	}
+	catch(exception& e) {
+		cout << "Standard Error: " << e.what() << " has occurred in the Weighted class Function getValues. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+		exit(1);
+	}
+	catch(...) {
+		cout << "An unknown error has occurred in the Weighted class function getValues. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n";
+		exit(1);
+	}
+
+}
+
+
+
+
+
+
+
+
+