X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=getlineagecommand.cpp;h=2a5505f149241c88b0591f1622a50d6a2fc89577;hb=a4f05f09c250323132a4b9427f41a3ededaec634;hp=91811fa4687202378585457d0087c2c5db973c52;hpb=df41d90a9611eab75d0516e2654ed8580f8df24c;p=mothur.git

diff --git a/getlineagecommand.cpp b/getlineagecommand.cpp
index 91811fa..2a5505f 100644
--- a/getlineagecommand.cpp
+++ b/getlineagecommand.cpp
@@ -27,7 +27,7 @@ vector<string> GetLineageCommand::getValidParameters(){
 //**********************************************************************************************************************
 GetLineageCommand::GetLineageCommand(){	
 	try {
-		//initialize outputTypes
+		abort = true; calledHelp = true; 
 		vector<string> tempOutNames;
 		outputTypes["fasta"] = tempOutNames;
 		outputTypes["taxonomy"] = tempOutNames;
@@ -67,10 +67,10 @@ vector<string> GetLineageCommand::getRequiredFiles(){
 //**********************************************************************************************************************
 GetLineageCommand::GetLineageCommand(string option)  {
 	try {
-		abort = false;
+		abort = false; calledHelp = false;   
 				
 		//allow user to run help
-		if(option == "help") { help(); abort = true; }
+		if(option == "help") { help(); abort = true; calledHelp = true; }
 		
 		else {
 			//valid paramters for this command
@@ -181,7 +181,11 @@ GetLineageCommand::GetLineageCommand(string option)  {
 			else if (taxfile == "not found") {  taxfile = ""; m->mothurOut("The taxonomy parameter is required for the get.lineage command."); m->mothurOutEndLine();  abort = true; }
 			
 			string usedDups = "true";
-			string temp = validParameter.validFile(parameters, "dups", false);	if (temp == "not found") { temp = "false"; usedDups = ""; }
+			string temp = validParameter.validFile(parameters, "dups", false);	
+			if (temp == "not found") { 
+				if (namefile != "") {  temp = "true";					}
+				else				{  temp = "false"; usedDups = "";	}
+			}
 			dups = m->isTrue(temp);
 			
 			taxons = validParameter.validFile(parameters, "taxon", false);	
@@ -214,6 +218,8 @@ void GetLineageCommand::help(){
 		m->mothurOut("The get.lineage command parameters are taxon, fasta, name, group, list, taxonomy, alignreport and dups.  You must provide taxonomy and taxon.\n");
 		m->mothurOut("The dups parameter allows you to add the entire line from a name file if you add any name from the line. default=false. \n");
 		m->mothurOut("The taxon parameter allows you to select the taxons you would like to get.\n");
+		m->mothurOut("You may enter your taxons with confidence scores, doing so will get only those sequences that belong to the taxonomy and whose cofidence scores is above the scores you give.\n");
+		m->mothurOut("If they belong to the taxonomy and have confidences below those you provide the sequence will not be selected.\n");
 		m->mothurOut("The get.lineage command should be in the following format: get.lineage(taxonomy=yourTaxonomyFile, taxon=yourTaxons).\n");
 		m->mothurOut("Example get.lineage(taxonomy=amazon.silva.taxonomy, taxon=Bacteria;Firmicutes;Bacilli;Lactobacillales;).\n");
 		m->mothurOut("Note: If you are running mothur in script mode you must wrap the taxon in ' characters so mothur will ignore the ; in the taxon.\n");
@@ -231,7 +237,7 @@ void GetLineageCommand::help(){
 int GetLineageCommand::execute(){
 	try {
 		
-		if (abort == true) { return 0; }
+		if (abort == true) { if (calledHelp) { return 0; }  return 2;	}
 		
 		if (m->control_pressed) { return 0; }
 		
@@ -251,6 +257,33 @@ int GetLineageCommand::execute(){
 			m->mothurOut("Output File Names: "); m->mothurOutEndLine();
 			for (int i = 0; i < outputNames.size(); i++) {	m->mothurOut(outputNames[i]); m->mothurOutEndLine();	}
 			m->mothurOutEndLine();
+			
+			//set fasta file as new current fastafile
+			string current = "";
+			itTypes = outputTypes.find("fasta");
+			if (itTypes != outputTypes.end()) {
+				if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setFastaFile(current); }
+			}
+			
+			itTypes = outputTypes.find("name");
+			if (itTypes != outputTypes.end()) {
+				if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setNameFile(current); }
+			}
+			
+			itTypes = outputTypes.find("group");
+			if (itTypes != outputTypes.end()) {
+				if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setGroupFile(current); }
+			}
+			
+			itTypes = outputTypes.find("list");
+			if (itTypes != outputTypes.end()) {
+				if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setListFile(current); }
+			}
+			
+			itTypes = outputTypes.find("taxonomy");
+			if (itTypes != outputTypes.end()) {
+				if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setTaxonomyFile(current); }
+			}			
 		}
 		
 		return 0;		
@@ -535,7 +568,18 @@ int GetLineageCommand::readTax(){
 		m->openInputFile(taxfile, in);
 		string name, tax;
 		
-		bool wroteSomething = false;
+		//bool wroteSomething = false;
+		
+		bool taxonsHasConfidence = false;
+		vector< map<string, float> > searchTaxons;
+		string noConfidenceTaxons = taxons;
+		int hasConPos = taxons.find_first_of('(');
+		if (hasConPos != string::npos) {  
+			taxonsHasConfidence = true; 
+			searchTaxons = getTaxons(taxons); 
+			noConfidenceTaxons = removeConfidences(taxons);
+		}
+		
 		
 		while(!in.eof()){
 
@@ -546,18 +590,89 @@ int GetLineageCommand::readTax(){
 			
 			string newtax = tax;
 			
-			//if the users file contains confidence scores we want to ignore them when searching for the taxons
-			int hasConfidences = tax.find_first_of('(');
-			if (hasConfidences != string::npos) { 
-				newtax = removeConfidences(tax);
+			
+			//if the users file contains confidence scores we want to ignore them when searching for the taxons, unless the taxon has them
+			if (!taxonsHasConfidence) {
+				int hasConfidences = tax.find_first_of('(');
+				if (hasConfidences != string::npos) { 
+					newtax = removeConfidences(tax);
+				}
+				
+				int pos = newtax.find(taxons);
+				
+				if (pos != string::npos) { //this sequence contains the taxon the user wants
+					names.insert(name);
+					out << name << '\t' << tax << endl;
+				}
+				
+			}else{//if taxons has them and you don't them remove taxons
+				int hasConfidences = tax.find_first_of('(');
+				if (hasConfidences == string::npos) { 
+					
+					int pos = newtax.find(noConfidenceTaxons);
+					
+					if (pos != string::npos) { //this sequence contains the taxon the user wants
+						names.insert(name);
+						out << name << '\t' << tax << endl;
+					}
+				}else { //both have confidences so we want to make sure the users confidences are greater then or equal to the taxons
+					//first remove confidences from both and see if the taxonomy exists
+					
+					string noNewTax = tax;
+					int hasConfidences = tax.find_first_of('(');
+					if (hasConfidences != string::npos) { 
+						noNewTax = removeConfidences(tax);
+					}
+					
+					int pos = noNewTax.find(noConfidenceTaxons);
+					
+					if (pos != string::npos) { //if yes, then are the confidences okay
+						
+						bool good = true;
+						vector< map<string, float> > usersTaxon = getTaxons(newtax);
+						
+						//the usersTaxon is most likely longer than the searchTaxons, and searchTaxon[0] may relate to userTaxon[4]
+						//we want to "line them up", so we will find the the index where the searchstring starts
+						int index = 0;
+						for (int i = 0; i < usersTaxon.size(); i++) {
+							
+							if (usersTaxon[i].begin()->first == searchTaxons[0].begin()->first) { 
+								index = i;  
+								int spot = 0;
+								bool goodspot = true;
+								//is this really the start, or are we dealing with a taxon of the same name?
+								while ((spot < searchTaxons.size()) && ((i+spot) < usersTaxon.size())) {
+									if (usersTaxon[i+spot].begin()->first != searchTaxons[spot].begin()->first) { goodspot = false; break; }
+									else { spot++; }
+								}
+								
+								if (goodspot) { break; }
+							}
+						}
+						
+						for (int i = 0; i < searchTaxons.size(); i++) {
+							
+							if ((i+index) < usersTaxon.size()) { //just in case, should never be false
+								if (usersTaxon[i+index].begin()->second < searchTaxons[i].begin()->second) { //is the users cutoff less than the search taxons
+									good = false;
+									break;
+								}
+							}else {
+								good = false;
+								break;
+							}
+						}
+						
+						//passed the test so add you
+						if (good) {
+							names.insert(name);
+							out << name << '\t' << tax << endl;
+						}
+					}
+				}
 			}
 			
-			int pos = newtax.find(taxons);
 			
-			if (pos != string::npos) { //this sequence contains the taxon the user wants
-				names.insert(name);
-				out << name << '\t' << tax << endl;
-			}
 			
 			m->gobble(in);
 		}
@@ -576,6 +691,48 @@ int GetLineageCommand::readTax(){
 	}
 }
 /**************************************************************************************************/
+vector< map<string, float> > GetLineageCommand::getTaxons(string tax) {
+	try {
+		
+		vector< map<string, float> > t;
+		string taxon = "";
+		int taxLength = tax.length();
+		for(int i=0;i<taxLength;i++){
+			if(tax[i] == ';'){
+		
+				int openParen = taxon.find_first_of('(');
+				int closeParen = taxon.find_last_of(')');
+				
+				string newtaxon, confidence;
+				if ((openParen != string::npos) && (closeParen != string::npos)) {
+					newtaxon = taxon.substr(0, openParen); //rip off confidence
+					confidence = taxon.substr((openParen+1), (closeParen-openParen-1));  
+				}else{
+					newtaxon = taxon;
+					confidence = "0";
+				} 
+				float con = 0;
+				convert(confidence, con);
+				
+				map<string, float> temp;
+				temp[newtaxon] = con;
+				t.push_back(temp);
+				
+				taxon = "";
+			}
+			else{
+				taxon += tax[i];
+			}
+		}
+		
+		return t;
+	}
+	catch(exception& e) {
+		m->errorOut(e, "GetLineageCommand", "getTaxons");
+		exit(1);
+	}
+}
+/**************************************************************************************************/
 string GetLineageCommand::removeConfidences(string tax) {
 	try {