X-Git-Url: https://git.donarmstrong.com/?p=mothur.git;a=blobdiff_plain;f=chimeraslayercommand.cpp;h=e7003c4d88bfe40266dffcf0770e3037cb39f38f;hp=39483b1f37c4a9c547a95b07b66abfc432edb732;hb=c48d91112209b841444923670dca5454da0e2a4d;hpb=4b6e3f7b5543822a2cca4fb076ab6af2ce8ca62d diff --git a/chimeraslayercommand.cpp b/chimeraslayercommand.cpp index 39483b1..e7003c4 100644 --- a/chimeraslayercommand.cpp +++ b/chimeraslayercommand.cpp @@ -8,71 +8,149 @@ */ #include "chimeraslayercommand.h" -#include "chimeraslayer.h" #include "deconvolutecommand.h" +#include "referencedb.h" +#include "sequenceparser.h" +#include "counttable.h" //********************************************************************************************************************** -vector ChimeraSlayerCommand::getValidParameters(){ +vector ChimeraSlayerCommand::setParameters(){ try { - string AlignArray[] = {"fasta", "processors","trim", "name","window", "include","template","numwanted", "ksize", "match","mismatch", - "divergence", "minsim","mincov","minbs", "minsnp","parents", "iters","outputdir","inputdir", "search","realign" }; - vector myArray (AlignArray, AlignArray+(sizeof(AlignArray)/sizeof(string))); + CommandParameter ptemplate("reference", "InputTypes", "", "", "none", "none", "none","",false,true,true); parameters.push_back(ptemplate); + CommandParameter pfasta("fasta", "InputTypes", "", "", "none", "none", "none","chimera-accnos",false,true,true); parameters.push_back(pfasta); + CommandParameter pname("name", "InputTypes", "", "", "NameCount", "none", "none","",false,false,true); parameters.push_back(pname); + CommandParameter pcount("count", "InputTypes", "", "", "NameCount-CountGroup", "none", "none","",false,false,true); parameters.push_back(pcount); + CommandParameter pgroup("group", "InputTypes", "", "", "CountGroup", "none", "none","",false,false,true); parameters.push_back(pgroup); + CommandParameter pwindow("window", "Number", "", "50", "", "", "","",false,false); parameters.push_back(pwindow); + CommandParameter pksize("ksize", "Number", "", "7", "", "", "","",false,false); parameters.push_back(pksize); + CommandParameter pmatch("match", "Number", "", "5.0", "", "", "","",false,false); parameters.push_back(pmatch); + CommandParameter pmismatch("mismatch", "Number", "", "-4.0", "", "", "","",false,false); parameters.push_back(pmismatch); + CommandParameter pminsim("minsim", "Number", "", "90", "", "", "","",false,false); parameters.push_back(pminsim); + CommandParameter pmincov("mincov", "Number", "", "70", "", "", "","",false,false); parameters.push_back(pmincov); + CommandParameter pminsnp("minsnp", "Number", "", "10", "", "", "","",false,false); parameters.push_back(pminsnp); + CommandParameter pminbs("minbs", "Number", "", "90", "", "", "","",false,false); parameters.push_back(pminbs); + CommandParameter psearch("search", "Multiple", "kmer-blast", "blast", "", "", "","",false,false); parameters.push_back(psearch); + CommandParameter pprocessors("processors", "Number", "", "1", "", "", "","",false,false,true); parameters.push_back(pprocessors); + + CommandParameter prealign("realign", "Boolean", "", "T", "", "", "","",false,false); parameters.push_back(prealign); + CommandParameter ptrim("trim", "Boolean", "", "F", "", "", "","fasta",false,false); parameters.push_back(ptrim); + CommandParameter psplit("split", "Boolean", "", "F", "", "", "","",false,false); parameters.push_back(psplit); + CommandParameter pnumwanted("numwanted", "Number", "", "15", "", "", "","",false,false); parameters.push_back(pnumwanted); + CommandParameter piters("iters", "Number", "", "1000", "", "", "","",false,false); parameters.push_back(piters); + CommandParameter pdivergence("divergence", "Number", "", "1.007", "", "", "","",false,false); parameters.push_back(pdivergence); + CommandParameter pdups("dereplicate", "Boolean", "", "F", "", "", "","",false,false); parameters.push_back(pdups); + CommandParameter pparents("parents", "Number", "", "3", "", "", "","",false,false); parameters.push_back(pparents); + CommandParameter pincrement("increment", "Number", "", "5", "", "", "","",false,false); parameters.push_back(pincrement); + CommandParameter pblastlocation("blastlocation", "String", "", "", "", "", "","",false,false); parameters.push_back(pblastlocation); + CommandParameter pinputdir("inputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(pinputdir); + CommandParameter poutputdir("outputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(poutputdir); + CommandParameter psave("save", "Boolean", "", "F", "", "", "","",false,false); parameters.push_back(psave); + + vector myArray; + for (int i = 0; i < parameters.size(); i++) { myArray.push_back(parameters[i].name); } return myArray; } catch(exception& e) { - m->errorOut(e, "ChimeraSlayerCommand", "getValidParameters"); + m->errorOut(e, "ChimeraSlayerCommand", "setParameters"); exit(1); } } //********************************************************************************************************************** -ChimeraSlayerCommand::ChimeraSlayerCommand(){ +string ChimeraSlayerCommand::getHelpString(){ try { - vector tempOutNames; - outputTypes["chimera"] = tempOutNames; - outputTypes["accnos"] = tempOutNames; - outputTypes["fasta"] = tempOutNames; + string helpString = ""; + helpString += "The chimera.slayer command reads a fastafile and referencefile and outputs potentially chimeric sequences.\n"; + helpString += "This command was modeled after the chimeraSlayer written by the Broad Institute.\n"; + helpString += "The chimera.slayer command parameters are fasta, name, group, template, processors, dereplicate, trim, ksize, window, match, mismatch, divergence. minsim, mincov, minbs, minsnp, parents, search, iters, increment, numwanted, blastlocation and realign.\n"; + helpString += "The fasta parameter allows you to enter the fasta file containing your potentially chimeric sequences, and is required, unless you have a valid current fasta file. \n"; + helpString += "The name parameter allows you to provide a name file, if you are using reference=self. \n"; + helpString += "The group parameter allows you to provide a group file. The group file can be used with a namesfile and reference=self. When checking sequences, only sequences from the same group as the query sequence will be used as the reference. \n"; + helpString += "The count parameter allows you to provide a count file. The count file reference=self. If your count file contains group information, when checking sequences, only sequences from the same group as the query sequence will be used as the reference. When you use a count file with group info and dereplicate=T, mothur will create a *.pick.count_table file containing seqeunces after chimeras are removed. \n"; + helpString += "You may enter multiple fasta files by separating their names with dashes. ie. fasta=abrecovery.fasta-amazon.fasta \n"; + helpString += "The reference parameter allows you to enter a reference file containing known non-chimeric sequences, and is required. You may also set template=self, in this case the abundant sequences will be used as potential parents. \n"; + helpString += "The processors parameter allows you to specify how many processors you would like to use. The default is 1. \n"; +#ifdef USE_MPI + helpString += "When using MPI, the processors parameter is set to the number of MPI processes running. \n"; +#endif + helpString += "If the dereplicate parameter is false, then if one group finds the seqeunce to be chimeric, then all groups find it to be chimeric, default=f.\n"; + helpString += "The trim parameter allows you to output a new fasta file containing your sequences with the chimeric ones trimmed to include only their longest piece, default=F. \n"; + helpString += "The split parameter allows you to check both pieces of non-chimeric sequence for chimeras, thus looking for trimeras and quadmeras. default=F. \n"; + helpString += "The window parameter allows you to specify the window size for searching for chimeras, default=50. \n"; + helpString += "The increment parameter allows you to specify how far you move each window while finding chimeric sequences, default=5.\n"; + helpString += "The numwanted parameter allows you to specify how many sequences you would each query sequence compared with, default=15.\n"; + helpString += "The ksize parameter allows you to input kmersize, default is 7, used if search is kmer. \n"; + helpString += "The match parameter allows you to reward matched bases in blast search, default is 5. \n"; + helpString += "The parents parameter allows you to select the number of potential parents to investigate from the numwanted best matches after rating them, default is 3. \n"; + helpString += "The mismatch parameter allows you to penalize mismatched bases in blast search, default is -4. \n"; + helpString += "The divergence parameter allows you to set a cutoff for chimera determination, default is 1.007. \n"; + helpString += "The iters parameter allows you to specify the number of bootstrap iters to do with the chimeraslayer method, default=1000.\n"; + helpString += "The minsim parameter allows you to specify a minimum similarity with the parent fragments, default=90. \n"; + helpString += "The mincov parameter allows you to specify minimum coverage by closest matches found in template. Default is 70, meaning 70%. \n"; + helpString += "The minbs parameter allows you to specify minimum bootstrap support for calling a sequence chimeric. Default is 90, meaning 90%. \n"; + helpString += "The minsnp parameter allows you to specify percent of SNPs to sample on each side of breakpoint for computing bootstrap support (default: 10) \n"; + helpString += "The search parameter allows you to specify search method for finding the closest parent. Choices are blast, and kmer, default blast. \n"; + helpString += "The realign parameter allows you to realign the query to the potential parents. Choices are true or false, default true. \n"; + helpString += "The blastlocation parameter allows you to specify the location of your blast executable. By default mothur will look in ./blast/bin relative to mothur's executable. \n"; + helpString += "If the save parameter is set to true the reference sequences will be saved in memory, to clear them later you can use the clear.memory command. Default=f."; + helpString += "The chimera.slayer command should be in the following format: \n"; + helpString += "chimera.slayer(fasta=yourFastaFile, reference=yourTemplate, search=yourSearch) \n"; + helpString += "Example: chimera.slayer(fasta=AD.align, reference=core_set_aligned.imputed.fasta, search=kmer) \n"; + helpString += "Note: No spaces between parameter labels (i.e. fasta), '=' and parameters (i.e.yourFastaFile).\n"; + return helpString; } catch(exception& e) { - m->errorOut(e, "ChimeraSlayerCommand", "ChimeraSlayerCommand"); + m->errorOut(e, "ChimeraSlayerCommand", "getHelpString"); exit(1); } } //********************************************************************************************************************** -vector ChimeraSlayerCommand::getRequiredParameters(){ - try { - string AlignArray[] = {"template","fasta"}; - vector myArray (AlignArray, AlignArray+(sizeof(AlignArray)/sizeof(string))); - return myArray; - } - catch(exception& e) { - m->errorOut(e, "ChimeraSlayerCommand", "getRequiredParameters"); - exit(1); - } +string ChimeraSlayerCommand::getOutputPattern(string type) { + try { + string pattern = ""; + + if (type == "chimera") { pattern = "[filename],slayer.chimeras"; } + else if (type == "accnos") { pattern = "[filename],slayer.accnos"; } + else if (type == "fasta") { pattern = "[filename],slayer.fasta"; } + else if (type == "count") { pattern = "[filename],slayer.pick.count_table"; } + else { m->mothurOut("[ERROR]: No definition for type " + type + " output pattern.\n"); m->control_pressed = true; } + + return pattern; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "getOutputPattern"); + exit(1); + } } //********************************************************************************************************************** -vector ChimeraSlayerCommand::getRequiredFiles(){ +ChimeraSlayerCommand::ChimeraSlayerCommand(){ try { - vector myArray; - return myArray; + abort = true; calledHelp = true; + setParameters(); + vector tempOutNames; + outputTypes["chimera"] = tempOutNames; + outputTypes["accnos"] = tempOutNames; + outputTypes["fasta"] = tempOutNames; + outputTypes["count"] = tempOutNames; } catch(exception& e) { - m->errorOut(e, "ChimeraSlayerCommand", "getRequiredFiles"); + m->errorOut(e, "ChimeraSlayerCommand", "ChimeraSlayerCommand"); exit(1); } } //*************************************************************************************************************** ChimeraSlayerCommand::ChimeraSlayerCommand(string option) { try { - abort = false; + abort = false; calledHelp = false; + ReferenceDB* rdb = ReferenceDB::getInstance(); + hasCount = false; + hasName = false; //allow user to run help - if(option == "help") { help(); abort = true; } + if(option == "help") { help(); abort = true; calledHelp = true; } + else if(option == "citation") { citation(); abort = true; calledHelp = true;} else { - //valid paramters for this command - string Array[] = {"fasta", "processors","name", "include","trim", "window", "template","numwanted", "ksize", "match","mismatch", - "divergence", "minsim","mincov","minbs", "minsnp","parents", "iters","outputdir","inputdir", "search","realign" }; - vector myArray (Array, Array+(sizeof(Array)/sizeof(string))); + vector myArray = setParameters(); OptionParser parser(option); map parameters = parser.getParameters(); @@ -89,6 +167,7 @@ ChimeraSlayerCommand::ChimeraSlayerCommand(string option) { outputTypes["chimera"] = tempOutNames; outputTypes["accnos"] = tempOutNames; outputTypes["fasta"] = tempOutNames; + outputTypes["count"] = tempOutNames; //if the user changes the input directory command factory will send this info to us in the output parameter string inputDir = validParameter.validFile(parameters, "inputdir", false); @@ -96,53 +175,75 @@ ChimeraSlayerCommand::ChimeraSlayerCommand(string option) { //check for required parameters fastafile = validParameter.validFile(parameters, "fasta", false); - if (fastafile == "not found") { fastafile = ""; m->mothurOut("[ERROR]: fasta is a required parameter for the chimera.slayer command."); m->mothurOutEndLine(); abort = true; } - else { + if (fastafile == "not found") { + //if there is a current fasta file, use it + string filename = m->getFastaFile(); + if (filename != "") { fastaFileNames.push_back(filename); m->mothurOut("Using " + filename + " as input file for the fasta parameter."); m->mothurOutEndLine(); } + else { m->mothurOut("You have no current fastafile and the fasta parameter is required."); m->mothurOutEndLine(); abort = true; } + }else { m->splitAtDash(fastafile, fastaFileNames); //go through files and make sure they are good, if not, then disregard them for (int i = 0; i < fastaFileNames.size(); i++) { - if (inputDir != "") { - string path = m->hasPath(fastaFileNames[i]); - //if the user has not given a path then, add inputdir. else leave path alone. - if (path == "") { fastaFileNames[i] = inputDir + fastaFileNames[i]; } - } - - int ableToOpen; - ifstream in; - ableToOpen = m->openInputFile(fastaFileNames[i], in, "noerror"); - - //if you can't open it, try default location - if (ableToOpen == 1) { - if (m->getDefaultPath() != "") { //default path is set - string tryPath = m->getDefaultPath() + m->getSimpleName(fastaFileNames[i]); - m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); - ifstream in2; - ableToOpen = m->openInputFile(tryPath, in2, "noerror"); - in2.close(); - fastaFileNames[i] = tryPath; + bool ignore = false; + if (fastaFileNames[i] == "current") { + fastaFileNames[i] = m->getFastaFile(); + if (fastaFileNames[i] != "") { m->mothurOut("Using " + fastaFileNames[i] + " as input file for the fasta parameter where you had given current."); m->mothurOutEndLine(); } + else { + m->mothurOut("You have no current fastafile, ignoring current."); m->mothurOutEndLine(); ignore=true; + //erase from file list + fastaFileNames.erase(fastaFileNames.begin()+i); + i--; } } - if (ableToOpen == 1) { - if (m->getOutputDir() != "") { //default path is set - string tryPath = m->getOutputDir() + m->getSimpleName(fastaFileNames[i]); - m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); - ifstream in2; - ableToOpen = m->openInputFile(tryPath, in2, "noerror"); - in2.close(); - fastaFileNames[i] = tryPath; + if (!ignore) { + + if (inputDir != "") { + string path = m->hasPath(fastaFileNames[i]); + //if the user has not given a path then, add inputdir. else leave path alone. + if (path == "") { fastaFileNames[i] = inputDir + fastaFileNames[i]; } } - } - - in.close(); + + int ableToOpen; + ifstream in; + + ableToOpen = m->openInputFile(fastaFileNames[i], in, "noerror"); - if (ableToOpen == 1) { - m->mothurOut("Unable to open " + fastaFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); - //erase from file list - fastaFileNames.erase(fastaFileNames.begin()+i); - i--; + //if you can't open it, try default location + if (ableToOpen == 1) { + if (m->getDefaultPath() != "") { //default path is set + string tryPath = m->getDefaultPath() + m->getSimpleName(fastaFileNames[i]); + m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + fastaFileNames[i] = tryPath; + } + } + + if (ableToOpen == 1) { + if (m->getOutputDir() != "") { //default path is set + string tryPath = m->getOutputDir() + m->getSimpleName(fastaFileNames[i]); + m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + fastaFileNames[i] = tryPath; + } + } + + in.close(); + + if (ableToOpen == 1) { + m->mothurOut("Unable to open " + fastaFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); + //erase from file list + fastaFileNames.erase(fastaFileNames.begin()+i); + i--; + }else { + m->setFastaFile(fastaFileNames[i]); + } } } @@ -152,138 +253,406 @@ ChimeraSlayerCommand::ChimeraSlayerCommand(string option) { //check for required parameters - bool hasName = true; namefile = validParameter.validFile(parameters, "name", false); - if (namefile == "not found") { namefile = ""; hasName = false; } + if (namefile == "not found") { namefile = ""; } else { m->splitAtDash(namefile, nameFileNames); //go through files and make sure they are good, if not, then disregard them for (int i = 0; i < nameFileNames.size(); i++) { - if (inputDir != "") { - string path = m->hasPath(nameFileNames[i]); - //if the user has not given a path then, add inputdir. else leave path alone. - if (path == "") { nameFileNames[i] = inputDir + nameFileNames[i]; } - } - int ableToOpen; - ifstream in; + bool ignore = false; + if (nameFileNames[i] == "current") { + nameFileNames[i] = m->getNameFile(); + if (nameFileNames[i] != "") { m->mothurOut("Using " + nameFileNames[i] + " as input file for the name parameter where you had given current."); m->mothurOutEndLine(); } + else { + m->mothurOut("You have no current namefile, ignoring current."); m->mothurOutEndLine(); ignore=true; + //erase from file list + nameFileNames.erase(nameFileNames.begin()+i); + i--; + } + } - ableToOpen = m->openInputFile(nameFileNames[i], in, "noerror"); + if (!ignore) { + + if (inputDir != "") { + string path = m->hasPath(nameFileNames[i]); + //if the user has not given a path then, add inputdir. else leave path alone. + if (path == "") { nameFileNames[i] = inputDir + nameFileNames[i]; } + } + + int ableToOpen; + ifstream in; + + ableToOpen = m->openInputFile(nameFileNames[i], in, "noerror"); + + //if you can't open it, try default location + if (ableToOpen == 1) { + if (m->getDefaultPath() != "") { //default path is set + string tryPath = m->getDefaultPath() + m->getSimpleName(nameFileNames[i]); + m->mothurOut("Unable to open " + nameFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + nameFileNames[i] = tryPath; + } + } + + if (ableToOpen == 1) { + if (m->getOutputDir() != "") { //default path is set + string tryPath = m->getOutputDir() + m->getSimpleName(nameFileNames[i]); + m->mothurOut("Unable to open " + nameFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + nameFileNames[i] = tryPath; + } + } + + in.close(); + + if (ableToOpen == 1) { + m->mothurOut("Unable to open " + nameFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); + //erase from file list + nameFileNames.erase(nameFileNames.begin()+i); + i--; + }else { + m->setNameFile(nameFileNames[i]); + } + } + } + } + + if (nameFileNames.size() != 0) { hasName = true; } + + //check for required parameters + vector countfileNames; + countfile = validParameter.validFile(parameters, "count", false); + if (countfile == "not found") { + countfile = ""; + }else { + m->splitAtDash(countfile, countfileNames); + + //go through files and make sure they are good, if not, then disregard them + for (int i = 0; i < countfileNames.size(); i++) { - //if you can't open it, try default location - if (ableToOpen == 1) { - if (m->getDefaultPath() != "") { //default path is set - string tryPath = m->getDefaultPath() + m->getSimpleName(nameFileNames[i]); - m->mothurOut("Unable to open " + nameFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); - ifstream in2; - ableToOpen = m->openInputFile(tryPath, in2, "noerror"); - in2.close(); - nameFileNames[i] = tryPath; + bool ignore = false; + if (countfileNames[i] == "current") { + countfileNames[i] = m->getCountTableFile(); + if (nameFileNames[i] != "") { m->mothurOut("Using " + countfileNames[i] + " as input file for the count parameter where you had given current."); m->mothurOutEndLine(); } + else { + m->mothurOut("You have no current count file, ignoring current."); m->mothurOutEndLine(); ignore=true; + //erase from file list + countfileNames.erase(countfileNames.begin()+i); + i--; } } - if (ableToOpen == 1) { - if (m->getOutputDir() != "") { //default path is set - string tryPath = m->getOutputDir() + m->getSimpleName(nameFileNames[i]); - m->mothurOut("Unable to open " + nameFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); - ifstream in2; - ableToOpen = m->openInputFile(tryPath, in2, "noerror"); - in2.close(); - nameFileNames[i] = tryPath; + if (!ignore) { + + if (inputDir != "") { + string path = m->hasPath(countfileNames[i]); + //if the user has not given a path then, add inputdir. else leave path alone. + if (path == "") { countfileNames[i] = inputDir + countfileNames[i]; } + } + + int ableToOpen; + ifstream in; + + ableToOpen = m->openInputFile(countfileNames[i], in, "noerror"); + + //if you can't open it, try default location + if (ableToOpen == 1) { + if (m->getDefaultPath() != "") { //default path is set + string tryPath = m->getDefaultPath() + m->getSimpleName(countfileNames[i]); + m->mothurOut("Unable to open " + countfileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + countfileNames[i] = tryPath; + } + } + + if (ableToOpen == 1) { + if (m->getOutputDir() != "") { //default path is set + string tryPath = m->getOutputDir() + m->getSimpleName(countfileNames[i]); + m->mothurOut("Unable to open " + countfileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + countfileNames[i] = tryPath; + } + } + + in.close(); + + if (ableToOpen == 1) { + m->mothurOut("Unable to open " + countfileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); + //erase from file list + countfileNames.erase(countfileNames.begin()+i); + i--; + }else { + m->setCountTableFile(countfileNames[i]); } } + } + } + + if (countfileNames.size() != 0) { hasCount = true; } + + //make sure there is at least one valid file left + if (hasName && hasCount) { m->mothurOut("[ERROR]: You must enter ONLY ONE of the following: count or name."); m->mothurOutEndLine(); abort = true; } + + if (!hasName && hasCount) { nameFileNames = countfileNames; } + + if ((hasCount || hasName) && (nameFileNames.size() != fastaFileNames.size())) { m->mothurOut("[ERROR]: The number of name or count files does not match the number of fastafiles, please correct."); m->mothurOutEndLine(); abort=true; } + + bool hasGroup = true; + groupfile = validParameter.validFile(parameters, "group", false); + if (groupfile == "not found") { groupfile = ""; hasGroup = false; } + else { + m->splitAtDash(groupfile, groupFileNames); + + //go through files and make sure they are good, if not, then disregard them + for (int i = 0; i < groupFileNames.size(); i++) { - in.close(); + bool ignore = false; + if (groupFileNames[i] == "current") { + groupFileNames[i] = m->getGroupFile(); + if (groupFileNames[i] != "") { m->mothurOut("Using " + groupFileNames[i] + " as input file for the group parameter where you had given current."); m->mothurOutEndLine(); } + else { + m->mothurOut("You have no current namefile, ignoring current."); m->mothurOutEndLine(); ignore=true; + //erase from file list + groupFileNames.erase(groupFileNames.begin()+i); + i--; + } + } - if (ableToOpen == 1) { - m->mothurOut("Unable to open " + nameFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); - //erase from file list - nameFileNames.erase(nameFileNames.begin()+i); - i--; + if (!ignore) { + + if (inputDir != "") { + string path = m->hasPath(groupFileNames[i]); + //if the user has not given a path then, add inputdir. else leave path alone. + if (path == "") { groupFileNames[i] = inputDir + groupFileNames[i]; } + } + + int ableToOpen; + ifstream in; + + ableToOpen = m->openInputFile(groupFileNames[i], in, "noerror"); + + //if you can't open it, try default location + if (ableToOpen == 1) { + if (m->getDefaultPath() != "") { //default path is set + string tryPath = m->getDefaultPath() + m->getSimpleName(groupFileNames[i]); + m->mothurOut("Unable to open " + groupFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + groupFileNames[i] = tryPath; + } + } + + if (ableToOpen == 1) { + if (m->getOutputDir() != "") { //default path is set + string tryPath = m->getOutputDir() + m->getSimpleName(groupFileNames[i]); + m->mothurOut("Unable to open " + groupFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine(); + ifstream in2; + ableToOpen = m->openInputFile(tryPath, in2, "noerror"); + in2.close(); + groupFileNames[i] = tryPath; + } + } + + in.close(); + + if (ableToOpen == 1) { + m->mothurOut("Unable to open " + groupFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine(); + //erase from file list + groupFileNames.erase(groupFileNames.begin()+i); + i--; + }else { + m->setGroupFile(groupFileNames[i]); + } } } //make sure there is at least one valid file left - if (nameFileNames.size() == 0) { m->mothurOut("[ERROR]: no valid name files."); m->mothurOutEndLine(); abort = true; } + if (groupFileNames.size() == 0) { m->mothurOut("[ERROR]: no valid group files."); m->mothurOutEndLine(); abort = true; } } - if (hasName && (nameFileNames.size() != fastaFileNames.size())) { m->mothurOut("[ERROR]: The number of namefiles does not match the number of fastafiles, please correct."); m->mothurOutEndLine(); abort=true; } + if (hasGroup && (groupFileNames.size() != fastaFileNames.size())) { m->mothurOut("[ERROR]: The number of groupfiles does not match the number of fastafiles, please correct."); m->mothurOutEndLine(); abort=true; } + if (hasGroup && hasCount) { m->mothurOut("[ERROR]: You must enter ONLY ONE of the following: count or group."); m->mothurOutEndLine(); abort = true; } //if the user changes the output directory command factory will send this info to us in the output parameter outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; } + string temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); } + m->setProcessors(temp); + m->mothurConvert(temp, processors); + + temp = validParameter.validFile(parameters, "save", false); if (temp == "not found"){ temp = "f"; } + save = m->isTrue(temp); + rdb->save = save; + if (save) { //clear out old references + rdb->clearMemory(); + } string path; - it = parameters.find("template"); + it = parameters.find("reference"); //user has given a template file if(it != parameters.end()){ - if (it->second == "self") { templatefile = "self"; } + if (it->second == "self") { + templatefile = "self"; + if (save) { + m->mothurOut("[WARNING]: You can't save reference=self, ignoring save."); + m->mothurOutEndLine(); + save = false; + } + } else { path = m->hasPath(it->second); //if the user has not given a path then, add inputdir. else leave path alone. - if (path == "") { parameters["template"] = inputDir + it->second; } + if (path == "") { parameters["reference"] = inputDir + it->second; } - templatefile = validParameter.validFile(parameters, "template", true); + templatefile = validParameter.validFile(parameters, "reference", true); if (templatefile == "not open") { abort = true; } - else if (templatefile == "not found") { templatefile = ""; m->mothurOut("template is a required parameter for the chimera.slayer command."); m->mothurOutEndLine(); abort = true; } + else if (templatefile == "not found") { //check for saved reference sequences + if (rdb->referenceSeqs.size() != 0) { + templatefile = "saved"; + }else { + m->mothurOut("[ERROR]: You don't have any saved reference sequences and the reference parameter is a required."); + m->mothurOutEndLine(); + abort = true; + } + }else { if (save) { rdb->setSavedReference(templatefile); } } + } + }else if (hasName) { templatefile = "self"; + if (save) { + m->mothurOut("[WARNING]: You can't save reference=self, ignoring save."); + m->mothurOutEndLine(); + save = false; } + }else if (hasCount) { templatefile = "self"; + if (save) { + m->mothurOut("[WARNING]: You can't save reference=self, ignoring save."); + m->mothurOutEndLine(); + save = false; + } + } + else { + if (rdb->referenceSeqs.size() != 0) { + templatefile = "saved"; + }else { + m->mothurOut("[ERROR]: You don't have any saved reference sequences and the reference parameter is a required."); + m->mothurOutEndLine(); + templatefile = ""; abort = true; + } } - string temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found") { temp = "1"; } - convert(temp, processors); - includeAbunds = validParameter.validFile(parameters, "include", false); if (includeAbunds == "not found") { includeAbunds = "greater"; } - if ((includeAbunds != "greater") && (includeAbunds != "greaterequal") && (includeAbunds != "all")) { includeAbunds = "greater"; m->mothurOut("Invalid include setting. options are greater, greaterequal or all. using greater."); m->mothurOutEndLine(); } temp = validParameter.validFile(parameters, "ksize", false); if (temp == "not found") { temp = "7"; } - convert(temp, ksize); + m->mothurConvert(temp, ksize); temp = validParameter.validFile(parameters, "window", false); if (temp == "not found") { temp = "50"; } - convert(temp, window); + m->mothurConvert(temp, window); temp = validParameter.validFile(parameters, "match", false); if (temp == "not found") { temp = "5"; } - convert(temp, match); + m->mothurConvert(temp, match); temp = validParameter.validFile(parameters, "mismatch", false); if (temp == "not found") { temp = "-4"; } - convert(temp, mismatch); + m->mothurConvert(temp, mismatch); temp = validParameter.validFile(parameters, "divergence", false); if (temp == "not found") { temp = "1.007"; } - convert(temp, divR); + m->mothurConvert(temp, divR); temp = validParameter.validFile(parameters, "minsim", false); if (temp == "not found") { temp = "90"; } - convert(temp, minSimilarity); + m->mothurConvert(temp, minSimilarity); temp = validParameter.validFile(parameters, "mincov", false); if (temp == "not found") { temp = "70"; } - convert(temp, minCoverage); + m->mothurConvert(temp, minCoverage); temp = validParameter.validFile(parameters, "minbs", false); if (temp == "not found") { temp = "90"; } - convert(temp, minBS); + m->mothurConvert(temp, minBS); - temp = validParameter.validFile(parameters, "minsnp", false); if (temp == "not found") { temp = "100"; } - convert(temp, minSNP); + temp = validParameter.validFile(parameters, "minsnp", false); if (temp == "not found") { temp = "10"; } + m->mothurConvert(temp, minSNP); temp = validParameter.validFile(parameters, "parents", false); if (temp == "not found") { temp = "3"; } - convert(temp, parents); + m->mothurConvert(temp, parents); - temp = validParameter.validFile(parameters, "realign", false); if (temp == "not found") { temp = "f"; } + temp = validParameter.validFile(parameters, "realign", false); if (temp == "not found") { temp = "t"; } realign = m->isTrue(temp); temp = validParameter.validFile(parameters, "trim", false); if (temp == "not found") { temp = "f"; } trim = m->isTrue(temp); - search = validParameter.validFile(parameters, "search", false); if (search == "not found") { search = "distance"; } + temp = validParameter.validFile(parameters, "split", false); if (temp == "not found") { temp = "f"; } + trimera = m->isTrue(temp); - temp = validParameter.validFile(parameters, "iters", false); if (temp == "not found") { temp = "100"; } - convert(temp, iters); + search = validParameter.validFile(parameters, "search", false); if (search == "not found") { search = "blast"; } + + temp = validParameter.validFile(parameters, "iters", false); if (temp == "not found") { temp = "1000"; } + m->mothurConvert(temp, iters); temp = validParameter.validFile(parameters, "increment", false); if (temp == "not found") { temp = "5"; } - convert(temp, increment); + m->mothurConvert(temp, increment); temp = validParameter.validFile(parameters, "numwanted", false); if (temp == "not found") { temp = "15"; } - convert(temp, numwanted); + m->mothurConvert(temp, numwanted); + + temp = validParameter.validFile(parameters, "dereplicate", false); + if (temp == "not found") { temp = "false"; } + dups = m->isTrue(temp); + + blastlocation = validParameter.validFile(parameters, "blastlocation", false); + if (blastlocation == "not found") { blastlocation = ""; } + else { + //add / to name if needed + string lastChar = blastlocation.substr(blastlocation.length()-1); +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + if (lastChar != "/") { blastlocation += "/"; } +#else + if (lastChar != "\\") { blastlocation += "\\"; } +#endif + blastlocation = m->getFullPathName(blastlocation); + string formatdbCommand = ""; +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + formatdbCommand = blastlocation + "formatdb"; +#else + formatdbCommand = blastlocation + "formatdb.exe"; +#endif + + //test to make sure formatdb exists + ifstream in; + formatdbCommand = m->getFullPathName(formatdbCommand); + int ableToOpen = m->openInputFile(formatdbCommand, in, "no error"); in.close(); + if(ableToOpen == 1) { m->mothurOut("[ERROR]: " + formatdbCommand + " file does not exist. mothur requires formatdb.exe to run chimera.slayer."); m->mothurOutEndLine(); abort = true; } + + string blastCommand = ""; +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + blastCommand = blastlocation + "megablast"; +#else + blastCommand = blastlocation + "megablast.exe"; +#endif + //test to make sure formatdb exists + ifstream in2; + blastCommand = m->getFullPathName(blastCommand); + ableToOpen = m->openInputFile(blastCommand, in2, "no error"); in2.close(); + if(ableToOpen == 1) { m->mothurOut("[ERROR]: " + blastCommand + " file does not exist. mothur requires blastall.exe to run chimera.slayer."); m->mothurOutEndLine(); abort = true; } + } + + if ((search != "blast") && (search != "kmer")) { m->mothurOut(search + " is not a valid search."); m->mothurOutEndLine(); abort = true; } + + if ((hasName || hasCount) && (templatefile != "self")) { m->mothurOut("You have provided a namefile or countfile and the reference parameter is not set to self. I am not sure what reference you are trying to use, aborting."); m->mothurOutEndLine(); abort=true; } + if (hasGroup && (templatefile != "self")) { m->mothurOut("You have provided a group file and the reference parameter is not set to self. I am not sure what reference you are trying to use, aborting."); m->mothurOutEndLine(); abort=true; } - if ((search != "distance") && (search != "blast") && (search != "kmer")) { m->mothurOut(search + " is not a valid search."); m->mothurOutEndLine(); abort = true; } + //until we resolve the issue 10-18-11 +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) +#else + //processors=1; +#endif } } catch(exception& e) { @@ -291,279 +660,185 @@ ChimeraSlayerCommand::ChimeraSlayerCommand(string option) { exit(1); } } -//********************************************************************************************************************** - -void ChimeraSlayerCommand::help(){ - try { - - m->mothurOut("The chimera.slayer command reads a fastafile and templatefile and outputs potentially chimeric sequences.\n"); - m->mothurOut("This command was modeled after the chimeraSlayer written by the Broad Institute.\n"); - m->mothurOut("The chimera.slayer command parameters are fasta, name, template, processors, trim, ksize, window, match, mismatch, divergence. minsim, mincov, minbs, minsnp, parents, search, iters, increment and numwanted.\n"); //realign, - m->mothurOut("The fasta parameter allows you to enter the fasta file containing your potentially chimeric sequences, and is required. \n"); - m->mothurOut("The name parameter allows you to provide a name file, if you are using template=self. \n"); - m->mothurOut("You may enter multiple fasta files by separating their names with dashes. ie. fasta=abrecovery.fasta-amazon.fasta \n"); - m->mothurOut("The template parameter allows you to enter a template file containing known non-chimeric sequences, and is required. You may also set template=self, in this case the abundant sequences will be used as potential parents. \n"); - m->mothurOut("The processors parameter allows you to specify how many processors you would like to use. The default is 1. \n"); - #ifdef USE_MPI - m->mothurOut("When using MPI, the processors parameter is set to the number of MPI processes running. \n"); - #endif - m->mothurOut("The trim parameter allows you to output a new fasta file containing your sequences with the chimeric ones trimmed to include only their longest peice, default=F. \n"); - m->mothurOut("The window parameter allows you to specify the window size for searching for chimeras, default=50. \n"); - m->mothurOut("The increment parameter allows you to specify how far you move each window while finding chimeric sequences, default=5.\n"); - m->mothurOut("The numwanted parameter allows you to specify how many sequences you would each query sequence compared with, default=15.\n"); - m->mothurOut("The ksize parameter allows you to input kmersize, default is 7, used if search is kmer. \n"); - m->mothurOut("The match parameter allows you to reward matched bases in blast search, default is 5. \n"); - m->mothurOut("The parents parameter allows you to select the number of potential parents to investigate from the numwanted best matches after rating them, default is 3. \n"); - m->mothurOut("The mismatch parameter allows you to penalize mismatched bases in blast search, default is -4. \n"); - m->mothurOut("The divergence parameter allows you to set a cutoff for chimera determination, default is 1.007. \n"); - m->mothurOut("The iters parameter allows you to specify the number of bootstrap iters to do with the chimeraslayer method, default=100.\n"); - m->mothurOut("The minsim parameter allows you to specify a minimum similarity with the parent fragments, default=90. \n"); - m->mothurOut("The mincov parameter allows you to specify minimum coverage by closest matches found in template. Default is 70, meaning 70%. \n"); - m->mothurOut("The minbs parameter allows you to specify minimum bootstrap support for calling a sequence chimeric. Default is 90, meaning 90%. \n"); - m->mothurOut("The minsnp parameter allows you to specify percent of SNPs to sample on each side of breakpoint for computing bootstrap support (default: 100) \n"); - m->mothurOut("The search parameter allows you to specify search method for finding the closest parent. Choices are distance, blast, and kmer, default distance. \n"); - m->mothurOut("The realign parameter allows you to realign the query to the potential parents. Choices are true or false, default false. \n"); - m->mothurOut("The chimera.slayer command should be in the following format: \n"); - m->mothurOut("chimera.slayer(fasta=yourFastaFile, template=yourTemplate, search=yourSearch) \n"); - m->mothurOut("Example: chimera.slayer(fasta=AD.align, template=core_set_aligned.imputed.fasta, search=kmer) \n"); - m->mothurOut("Note: No spaces between parameter labels (i.e. fasta), '=' and parameters (i.e.yourFastaFile).\n\n"); - } - catch(exception& e) { - m->errorOut(e, "ChimeraSlayerCommand", "help"); - exit(1); - } -} - -//*************************************************************************************************************** - -ChimeraSlayerCommand::~ChimeraSlayerCommand(){ /* do nothing */ } - //*************************************************************************************************************** int ChimeraSlayerCommand::execute(){ try{ - - if (abort == true) { return 0; } - + if (abort == true) { if (calledHelp) { return 0; } return 2; } + for (int s = 0; s < fastaFileNames.size(); s++) { m->mothurOut("Checking sequences from " + fastaFileNames[s] + " ..." ); m->mothurOutEndLine(); int start = time(NULL); + if (outputDir == "") { outputDir = m->hasPath(fastaFileNames[s]); }//if user entered a file with a path then preserve it + map variables; + variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])); + string outputFileName = getOutputFileName("chimera", variables); + string accnosFileName = getOutputFileName("accnos", variables); + string trimFastaFileName = getOutputFileName("fasta", variables); + string newCountFile = ""; - if (templatefile != "self") { //you want to run slayer with a refernce template - chimera = new ChimeraSlayer(fastaFileNames[s], templatefile, trim, search, ksize, match, mismatch, window, divR, minSimilarity, minCoverage, minBS, minSNP, parents, iters, increment, numwanted, realign); - }else { - if (nameFileNames.size() != 0) { //you provided a namefile and we don't need to create one - chimera = new ChimeraSlayer(fastaFileNames[s], templatefile, trim, nameFileNames[s], search, includeAbunds, ksize, match, mismatch, window, divR, minSimilarity, minCoverage, minBS, minSNP, parents, iters, increment, numwanted, realign); - }else { - - m->mothurOutEndLine(); m->mothurOut("No namesfile given, running unique.seqs command to generate one."); m->mothurOutEndLine(); m->mothurOutEndLine(); - - //use unique.seqs to create new name and fastafile - string inputString = "fasta=" + fastaFileNames[s]; - m->mothurOut("/******************************************/"); m->mothurOutEndLine(); - m->mothurOut("Running command: unique.seqs(" + inputString + ")"); m->mothurOutEndLine(); - - Command* uniqueCommand = new DeconvoluteCommand(inputString); - uniqueCommand->execute(); - - map > filenames = uniqueCommand->getOutputFiles(); - - delete uniqueCommand; - - m->mothurOut("/******************************************/"); m->mothurOutEndLine(); - - string nameFile = filenames["name"][0]; - fastaFileNames[s] = filenames["fasta"][0]; - - chimera = new ChimeraSlayer(fastaFileNames[s], templatefile, trim, nameFile, search, includeAbunds, ksize, match, mismatch, window, divR, minSimilarity, minCoverage, minBS, minSNP, parents, iters, increment, numwanted, realign); - } - } - - if (outputDir == "") { outputDir = m->hasPath(fastaFileNames[s]); }//if user entered a file with a path then preserve it - string outputFileName = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])) + "slayer.chimera"; - string accnosFileName = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])) + "slayer.accnos"; - string trimFastaFileName = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])) + "slayer.fasta"; - - if (m->control_pressed) { delete chimera; for (int j = 0; j < outputNames.size(); j++) { remove(outputNames[j].c_str()); } return 0; } - - if (chimera->getUnaligned()) { - m->mothurOut("Your template sequences are different lengths, please correct."); m->mothurOutEndLine(); - delete chimera; - return 0; - } - templateSeqsLength = chimera->getLength(); + //clears files + ofstream out, out1, out2; + m->openOutputFile(outputFileName, out); out.close(); + m->openOutputFile(accnosFileName, out1); out1.close(); + if (trim) { m->openOutputFile(trimFastaFileName, out2); out2.close(); } + outputNames.push_back(outputFileName); outputTypes["chimera"].push_back(outputFileName); + outputNames.push_back(accnosFileName); outputTypes["accnos"].push_back(accnosFileName); + if (trim) { outputNames.push_back(trimFastaFileName); outputTypes["fasta"].push_back(trimFastaFileName); } - #ifdef USE_MPI - int pid, numSeqsPerProcessor; - int tag = 2001; - vector MPIPos; - - MPI_Status status; - MPI_Comm_rank(MPI_COMM_WORLD, &pid); //find out who we are - MPI_Comm_size(MPI_COMM_WORLD, &processors); - - MPI_File inMPI; - MPI_File outMPI; - MPI_File outMPIAccnos; - MPI_File outMPIFasta; - - int outMode=MPI_MODE_CREATE|MPI_MODE_WRONLY; - int inMode=MPI_MODE_RDONLY; - - char outFilename[1024]; - strcpy(outFilename, outputFileName.c_str()); - - char outAccnosFilename[1024]; - strcpy(outAccnosFilename, accnosFileName.c_str()); + //maps a filename to priority map. + //if no groupfile this is fastafileNames[s] -> prioirity + //if groupfile then this is each groups seqs -> priority + map > fileToPriority; + map >::iterator itFile; + map fileGroup; + fileToPriority[fastaFileNames[s]] = priority; //default + fileGroup[fastaFileNames[s]] = "noGroup"; + map uniqueNames; + int totalChimeras = 0; + lines.clear(); - char outFastaFilename[1024]; - strcpy(outFastaFilename, trimFastaFileName.c_str()); - - char inFileName[1024]; - strcpy(inFileName, fastaFileNames[s].c_str()); - - MPI_File_open(MPI_COMM_WORLD, inFileName, inMode, MPI_INFO_NULL, &inMPI); //comm, filename, mode, info, filepointer - MPI_File_open(MPI_COMM_WORLD, outFilename, outMode, MPI_INFO_NULL, &outMPI); - MPI_File_open(MPI_COMM_WORLD, outAccnosFilename, outMode, MPI_INFO_NULL, &outMPIAccnos); - if (trim) { MPI_File_open(MPI_COMM_WORLD, outFastaFilename, outMode, MPI_INFO_NULL, &outMPIFasta); } - - if (m->control_pressed) { outputTypes.clear(); MPI_File_close(&inMPI); MPI_File_close(&outMPI); if (trim) { MPI_File_close(&outMPIFasta); } MPI_File_close(&outMPIAccnos); for (int j = 0; j < outputNames.size(); j++) { remove(outputNames[j].c_str()); } delete chimera; return 0; } + if (templatefile == "self") { + if (hasCount) { + SequenceCountParser* parser = NULL; + setUpForSelfReference(parser, fileGroup, fileToPriority, s); + if (parser != NULL) { uniqueNames = parser->getAllSeqsMap(); delete parser; } + }else { + SequenceParser* parser = NULL; + setUpForSelfReference(parser, fileGroup, fileToPriority, s); + if (parser != NULL) { uniqueNames = parser->getAllSeqsMap(); delete parser; } + } + } - if (pid == 0) { //you are the root process - m->mothurOutEndLine(); - m->mothurOut("Only reporting sequence supported by " + toString(minBS) + "% of bootstrapped results."); - m->mothurOutEndLine(); - - string outTemp = "Name\tLeftParent\tRightParent\tDivQLAQRB\tPerIDQLAQRB\tBootStrapA\tDivQLBQRA\tPerIDQLBQRA\tBootStrapB\tFlag\tLeftWindow\tRightWindow\n"; - - //print header - int length = outTemp.length(); - char* buf2 = new char[length]; - memcpy(buf2, outTemp.c_str(), length); - - MPI_File_write_shared(outMPI, buf2, length, MPI_CHAR, &status); - delete buf2; + if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; } - MPIPos = m->setFilePosFasta(fastaFileNames[s], numSeqs); //fills MPIPos, returns numSeqs + if (fileToPriority.size() == 1) { //you running without a groupfile + itFile = fileToPriority.begin(); + string thisFastaName = itFile->first; + map thisPriority = itFile->second; +#ifdef USE_MPI + MPIExecute(thisFastaName, outputFileName, accnosFileName, trimFastaFileName, thisPriority); +#else + //break up file + vector positions; +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + positions = m->divideFile(thisFastaName, processors); + for (int i = 0; i < (positions.size()-1); i++) { lines.push_back(linePair(positions[i], positions[(i+1)])); } +#else + if (processors == 1) { lines.push_back(linePair(0, 1000)); } + else { + positions = m->setFilePosFasta(thisFastaName, numSeqs); + if (positions.size() < processors) { processors = positions.size(); } - //send file positions to all processes - for(int i = 1; i < processors; i++) { - MPI_Send(&numSeqs, 1, MPI_INT, i, tag, MPI_COMM_WORLD); - MPI_Send(&MPIPos[0], (numSeqs+1), MPI_LONG, i, tag, MPI_COMM_WORLD); + //figure out how many sequences you have to process + int numSeqsPerProcessor = numSeqs / processors; + for (int i = 0; i < processors; i++) { + int startIndex = i * numSeqsPerProcessor; + if(i == (processors - 1)){ numSeqsPerProcessor = numSeqs - i * numSeqsPerProcessor; } + lines.push_back(linePair(positions[startIndex], numSeqsPerProcessor)); } - - //figure out how many sequences you have to align - numSeqsPerProcessor = numSeqs / processors; - int startIndex = pid * numSeqsPerProcessor; - if(pid == (processors - 1)){ numSeqsPerProcessor = numSeqs - pid * numSeqsPerProcessor; } - - //do your part - driverMPI(startIndex, numSeqsPerProcessor, inMPI, outMPI, outMPIAccnos, outMPIFasta, MPIPos); - - if (m->control_pressed) { outputTypes.clear(); MPI_File_close(&inMPI); MPI_File_close(&outMPI); if (trim) { MPI_File_close(&outMPIFasta); } MPI_File_close(&outMPIAccnos); for (int j = 0; j < outputNames.size(); j++) { remove(outputNames[j].c_str()); } remove(outputFileName.c_str()); remove(accnosFileName.c_str()); delete chimera; return 0; } - - }else{ //you are a child process - MPI_Recv(&numSeqs, 1, MPI_INT, 0, tag, MPI_COMM_WORLD, &status); - MPIPos.resize(numSeqs+1); - MPI_Recv(&MPIPos[0], (numSeqs+1), MPI_LONG, 0, tag, MPI_COMM_WORLD, &status); - - //figure out how many sequences you have to align - numSeqsPerProcessor = numSeqs / processors; - int startIndex = pid * numSeqsPerProcessor; - if(pid == (processors - 1)){ numSeqsPerProcessor = numSeqs - pid * numSeqsPerProcessor; } - - //do your part - driverMPI(startIndex, numSeqsPerProcessor, inMPI, outMPI, outMPIAccnos, outMPIFasta, MPIPos); - - if (m->control_pressed) { outputTypes.clear(); MPI_File_close(&inMPI); MPI_File_close(&outMPI); if (trim) { MPI_File_close(&outMPIFasta); } MPI_File_close(&outMPIAccnos); for (int j = 0; j < outputNames.size(); j++) { remove(outputNames[j].c_str()); } delete chimera; return 0; } } +#endif + if(processors == 1){ numSeqs = driver(lines[0], outputFileName, thisFastaName, accnosFileName, trimFastaFileName, thisPriority); } + else{ numSeqs = createProcesses(outputFileName, thisFastaName, accnosFileName, trimFastaFileName, thisPriority); } - //close files - MPI_File_close(&inMPI); - MPI_File_close(&outMPI); - MPI_File_close(&outMPIAccnos); - if (trim) { MPI_File_close(&outMPIFasta); } - MPI_Barrier(MPI_COMM_WORLD); //make everyone wait - just in case - - #else - ofstream outHeader; - string tempHeader = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])) + "slayer.chimeras.tempHeader"; - m->openOutputFile(tempHeader, outHeader); - - chimera->printHeader(outHeader); - outHeader.close(); - - vector positions = m->divideFile(fastaFileNames[s], processors); - - for (int i = 0; i < (positions.size()-1); i++) { - lines.push_back(new linePair(positions[i], positions[(i+1)])); - } + if (m->control_pressed) { outputTypes.clear(); if (trim) { m->mothurRemove(trimFastaFileName); } m->mothurRemove(outputFileName); m->mothurRemove(accnosFileName); for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; } +#endif + }else { //you have provided a groupfile + string countFile = ""; + if (hasCount) { + countFile = nameFileNames[s]; + variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(nameFileNames[s])); + newCountFile = getOutputFileName("count", variables); + } +#ifdef USE_MPI + MPIExecuteGroups(outputFileName, accnosFileName, trimFastaFileName, fileToPriority, fileGroup, newCountFile, countFile); +#else + if (processors == 1) { + numSeqs = driverGroups(outputFileName, accnosFileName, trimFastaFileName, fileToPriority, fileGroup, newCountFile); + if (hasCount && dups) { + CountTable c; c.readTable(nameFileNames[s]); + if (!m->isBlank(newCountFile)) { + ifstream in2; + m->openInputFile(newCountFile, in2); + + string name, group; + while (!in2.eof()) { + in2 >> name >> group; m->gobble(in2); + c.setAbund(name, group, 0); + } + in2.close(); + } + m->mothurRemove(newCountFile); + c.printTable(newCountFile); + } - //break up file - #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) - if(processors == 1){ - numSeqs = driver(lines[0], outputFileName, fastaFileNames[s], accnosFileName, trimFastaFileName); - - if (m->control_pressed) { outputTypes.clear(); if (trim) { remove(trimFastaFileName.c_str()); } remove(outputFileName.c_str()); remove(tempHeader.c_str()); remove(accnosFileName.c_str()); for (int j = 0; j < outputNames.size(); j++) { remove(outputNames[j].c_str()); } for (int i = 0; i < lines.size(); i++) { delete lines[i]; } lines.clear(); delete chimera; return 0; } - - }else{ - processIDS.resize(0); - - numSeqs = createProcesses(outputFileName, fastaFileNames[s], accnosFileName, trimFastaFileName); - - rename((outputFileName + toString(processIDS[0]) + ".temp").c_str(), outputFileName.c_str()); - rename((accnosFileName + toString(processIDS[0]) + ".temp").c_str(), accnosFileName.c_str()); - if (trim) { rename((trimFastaFileName + toString(processIDS[0]) + ".temp").c_str(), trimFastaFileName.c_str()); } - - //append output files - for(int i=1;iappendFiles((outputFileName + toString(processIDS[i]) + ".temp"), outputFileName); - remove((outputFileName + toString(processIDS[i]) + ".temp").c_str()); - } - - //append output files - for(int i=1;iappendFiles((accnosFileName + toString(processIDS[i]) + ".temp"), accnosFileName); - remove((accnosFileName + toString(processIDS[i]) + ".temp").c_str()); - } - - if (trim) { - for(int i=1;iappendFiles((trimFastaFileName + toString(processIDS[i]) + ".temp"), trimFastaFileName); - remove((trimFastaFileName + toString(processIDS[i]) + ".temp").c_str()); - } - } - - if (m->control_pressed) { outputTypes.clear(); if (trim) { remove(trimFastaFileName.c_str()); } remove(outputFileName.c_str()); remove(accnosFileName.c_str()); for (int j = 0; j < outputNames.size(); j++) { remove(outputNames[j].c_str()); } for (int i = 0; i < lines.size(); i++) { delete lines[i]; } lines.clear(); delete chimera; return 0; } - } + } + else { numSeqs = createProcessesGroups(outputFileName, accnosFileName, trimFastaFileName, fileToPriority, fileGroup, newCountFile, countFile); } //destroys fileToPriority +#endif - #else - numSeqs = driver(lines[0], outputFileName, fastaFileNames[s], accnosFileName, trimFastaFileName); - - if (m->control_pressed) { outputTypes.clear(); if (trim) { remove(trimFastaFileName.c_str()); } remove(outputFileName.c_str()); remove(tempHeader.c_str()); remove(accnosFileName.c_str()); for (int j = 0; j < outputNames.size(); j++) { remove(outputNames[j].c_str()); } for (int i = 0; i < lines.size(); i++) { delete lines[i]; } lines.clear(); delete chimera; return 0; } +#ifdef USE_MPI + int pid; + MPI_Comm_rank(MPI_COMM_WORLD, &pid); //find out who we are - #endif + if (pid == 0) { +#endif + if (!dups) { + totalChimeras = deconvoluteResults(uniqueNames, outputFileName, accnosFileName, trimFastaFileName); + m->mothurOutEndLine(); m->mothurOut(toString(totalChimeras) + " chimera found."); m->mothurOutEndLine(); + }else { + if (hasCount) { + set doNotRemove; + CountTable c; c.readTable(newCountFile); + vector namesInTable = c.getNamesOfSeqs(); + for (int i = 0; i < namesInTable.size(); i++) { + int temp = c.getNumSeqs(namesInTable[i]); + if (temp == 0) { c.remove(namesInTable[i]); } + else { doNotRemove.insert((namesInTable[i])); } + } + //remove names we want to keep from accnos file. + set accnosNames = m->readAccnos(accnosFileName); + ofstream out2; + m->openOutputFile(accnosFileName, out2); + for (set::iterator it = accnosNames.begin(); it != accnosNames.end(); it++) { + if (doNotRemove.count(*it) == 0) { out2 << (*it) << endl; } + } + out2.close(); + c.printTable(newCountFile); + outputNames.push_back(newCountFile); outputTypes["count"].push_back(newCountFile); + } + } + +#ifdef USE_MPI + } + MPI_Barrier(MPI_COMM_WORLD); //make everyone wait +#endif + } - m->appendFiles(outputFileName, tempHeader); + m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(numSeqs) + " sequences."); m->mothurOutEndLine(); + } - remove(outputFileName.c_str()); - rename(tempHeader.c_str(), outputFileName.c_str()); - - #endif - delete chimera; - - - for (int i = 0; i < lines.size(); i++) { delete lines[i]; } lines.clear(); - - outputNames.push_back(outputFileName); outputTypes["chimera"].push_back(outputFileName); - outputNames.push_back(accnosFileName); outputTypes["accnos"].push_back(accnosFileName); - if (trim) { outputNames.push_back(trimFastaFileName); outputTypes["fasta"].push_back(trimFastaFileName); } - - m->mothurOutEndLine(); m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(numSeqs) + " sequences."); m->mothurOutEndLine(); + //set accnos file as new current accnosfile + string current = ""; + itTypes = outputTypes.find("accnos"); + if (itTypes != outputTypes.end()) { + if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setAccnosFile(current); } + } + + if (trim) { + itTypes = outputTypes.find("fasta"); + if (itTypes != outputTypes.end()) { + if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setFastaFile(current); } + } } + itTypes = outputTypes.find("count"); + if (itTypes != outputTypes.end()) { + if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setCountTableFile(current); } + } + m->mothurOutEndLine(); m->mothurOut("Output File Names: "); m->mothurOutEndLine(); for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); } @@ -578,70 +853,993 @@ int ChimeraSlayerCommand::execute(){ } } //********************************************************************************************************************** - -int ChimeraSlayerCommand::driver(linePair* filePos, string outputFName, string filename, string accnos, string fasta){ +int ChimeraSlayerCommand::MPIExecuteGroups(string outputFileName, string accnosFileName, string trimFastaFileName, map >& fileToPriority, map& fileGroup, string countlist, string countfile){ try { - ofstream out; - m->openOutputFile(outputFName, out); +#ifdef USE_MPI + int pid; + int tag = 2001; - ofstream out2; - m->openOutputFile(accnos, out2); + MPI_Status status; + MPI_Comm_rank(MPI_COMM_WORLD, &pid); //find out who we are + MPI_Comm_size(MPI_COMM_WORLD, &processors); + + //put filenames in a vector, then pass each process a starting and ending point in the vector + //all processes already have the fileToPriority and fileGroup, they just need to know which files to process + map >::iterator itFile; + vector filenames; + for(itFile = fileToPriority.begin(); itFile != fileToPriority.end(); itFile++) { filenames.push_back(itFile->first); } - ofstream out3; - if (trim) { m->openOutputFile(fasta, out3); } + int numGroupsPerProcessor = filenames.size() / processors; + int startIndex = pid * numGroupsPerProcessor; + int endIndex = (pid+1) * numGroupsPerProcessor; + if(pid == (processors - 1)){ endIndex = filenames.size(); } - ifstream inFASTA; - m->openInputFile(filename, inFASTA); - - inFASTA.seekg(filePos->start); - - bool done = false; - int count = 0; - - while (!done) { + vector MPIPos; - if (m->control_pressed) { out.close(); out2.close(); if (trim) { out3.close(); } inFASTA.close(); return 1; } + MPI_File outMPI; + MPI_File outMPIAccnos; + MPI_File outMPIFasta; + MPI_File outMPICount; - Sequence* candidateSeq = new Sequence(inFASTA); m->gobble(inFASTA); - - if (candidateSeq->getName() != "") { //incase there is a commented sequence at the end of a file - - if (candidateSeq->getAligned().length() != templateSeqsLength) { - m->mothurOut(candidateSeq->getName() + " is not the same length as the template sequences. Skipping."); m->mothurOutEndLine(); - }else{ - //find chimeras - chimera->getChimeras(candidateSeq); - - if (m->control_pressed) { delete candidateSeq; return 1; } + int outMode=MPI_MODE_CREATE|MPI_MODE_WRONLY; + int inMode=MPI_MODE_RDONLY; - //print results - Sequence* trimmed = chimera->print(out, out2); - - if (trim) { trimmed->printSequence(out3); delete trimmed; } - } - count++; - } - delete candidateSeq; + char outFilename[1024]; + strcpy(outFilename, outputFileName.c_str()); + + char outAccnosFilename[1024]; + strcpy(outAccnosFilename, accnosFileName.c_str()); + + char outFastaFilename[1024]; + strcpy(outFastaFilename, trimFastaFileName.c_str()); + + char outCountFilename[1024]; + strcpy(outCountFilename, countlist.c_str()); + + MPI_File_open(MPI_COMM_WORLD, outFilename, outMode, MPI_INFO_NULL, &outMPI); + MPI_File_open(MPI_COMM_WORLD, outAccnosFilename, outMode, MPI_INFO_NULL, &outMPIAccnos); + if (trim) { MPI_File_open(MPI_COMM_WORLD, outFastaFilename, outMode, MPI_INFO_NULL, &outMPIFasta); } + if (hasCount && dups) { MPI_File_open(MPI_COMM_WORLD, outCountFilename, outMode, MPI_INFO_NULL, &outMPICount); } + + if (m->control_pressed) { MPI_File_close(&outMPI); if (trim) { MPI_File_close(&outMPIFasta); } MPI_File_close(&outMPIAccnos); if (hasCount && dups) { MPI_File_close(&outMPICount); } return 0; } + + //print headers + if (pid == 0) { //you are the root process + m->mothurOutEndLine(); + m->mothurOut("Only reporting sequence supported by " + toString(minBS) + "% of bootstrapped results."); + m->mothurOutEndLine(); - #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) - unsigned long int pos = inFASTA.tellg(); - if ((pos == -1) || (pos >= filePos->end)) { break; } - #else - if (inFASTA.eof()) { break; } - #endif + string outTemp = "Name\tLeftParent\tRightParent\tDivQLAQRB\tPerIDQLAQRB\tBootStrapA\tDivQLBQRA\tPerIDQLBQRA\tBootStrapB\tFlag\tLeftWindow\tRightWindow\n"; - //report progress - if((count) % 100 == 0){ m->mothurOut("Processing sequence: " + toString(count)); m->mothurOutEndLine(); } + //print header + int length = outTemp.length(); + char* buf2 = new char[length]; + memcpy(buf2, outTemp.c_str(), length); + + MPI_File_write_shared(outMPI, buf2, length, MPI_CHAR, &status); + delete buf2; } - //report progress - if((count) % 100 != 0){ m->mothurOut("Processing sequence: " + toString(count)); m->mothurOutEndLine(); } + MPI_Barrier(MPI_COMM_WORLD); //make everyone wait - out.close(); - out2.close(); - if (trim) { out3.close(); } + for (int i = startIndex; i < endIndex; i++) { + + int start = time(NULL); + int num = 0; + string thisFastaName = filenames[i]; + map thisPriority = fileToPriority[thisFastaName]; + + char inFileName[1024]; + strcpy(inFileName, thisFastaName.c_str()); + MPI_File inMPI; + MPI_File_open(MPI_COMM_SELF, inFileName, inMode, MPI_INFO_NULL, &inMPI); //comm, filename, mode, info, filepointer + + MPIPos = m->setFilePosFasta(thisFastaName, num); //fills MPIPos, returns numSeqs + + cout << endl << "Checking sequences from group: " << fileGroup[thisFastaName] << "." << endl; + + set cnames; + driverMPI(0, num, inMPI, outMPI, outMPIAccnos, outMPIFasta, cnames, MPIPos, thisFastaName, thisPriority, true); + numSeqs += num; + + MPI_File_close(&inMPI); + m->mothurRemove(thisFastaName); + + if (dups) { + if (cnames.size() != 0) { + if (hasCount) { + for (set::iterator it = cnames.begin(); it != cnames.end(); it++) { + string outputString = (*it) + "\t" + fileGroup[thisFastaName] + "\n"; + int length = outputString.length(); + char* buf2 = new char[length]; + memcpy(buf2, outputString.c_str(), length); + MPI_File_write_shared(outMPICount, buf2, length, MPI_CHAR, &status); + delete buf2; + } + }else { + map >::iterator itGroupNameMap = group2NameMap.find(fileGroup[thisFastaName]); + if (itGroupNameMap != group2NameMap.end()) { + map thisnamemap = itGroupNameMap->second; + map::iterator itN; + for (set::iterator it = cnames.begin(); it != cnames.end(); it++) { + itN = thisnamemap.find(*it); + if (itN != thisnamemap.end()) { + vector tempNames; m->splitAtComma(itN->second, tempNames); + for (int j = 0; j < tempNames.size(); j++) { //write to accnos file + string outputString = tempNames[j] + "\n"; + int length = outputString.length(); + char* buf2 = new char[length]; + memcpy(buf2, outputString.c_str(), length); + + MPI_File_write_shared(outMPIAccnos, buf2, length, MPI_CHAR, &status); + delete buf2; + } + + }else { m->mothurOut("[ERROR]: parsing cannot find " + *it + ".\n"); m->control_pressed = true; } + } + }else { m->mothurOut("[ERROR]: parsing cannot find " + fileGroup[thisFastaName] + ".\n"); m->control_pressed = true; } + } + + } + } + + cout << endl << "It took " << toString(time(NULL) - start) << " secs to check " + toString(num) + " sequences from group " << fileGroup[thisFastaName] << "." << endl; + } + + if (pid == 0) { + for(int i = 1; i < processors; i++) { + int temp = 0; + MPI_Recv(&temp, 1, MPI_INT, i, 2001, MPI_COMM_WORLD, &status); + numSeqs += temp; + } + }else{ MPI_Send(&numSeqs, 1, MPI_INT, 0, 2001, MPI_COMM_WORLD); } + + MPI_File_close(&outMPI); + MPI_File_close(&outMPIAccnos); + if (trim) { MPI_File_close(&outMPIFasta); } + if (hasCount && dups) { MPI_File_close(&outMPICount); } + + MPI_Barrier(MPI_COMM_WORLD); //make everyone wait +#endif + return 0; + + }catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "MPIExecuteGroups"); + exit(1); + } +} +//********************************************************************************************************************** +int ChimeraSlayerCommand::MPIExecute(string inputFile, string outputFileName, string accnosFileName, string trimFastaFileName, map& priority){ + try { + +#ifdef USE_MPI + int pid, numSeqsPerProcessor; + int tag = 2001; + vector MPIPos; + + MPI_Status status; + MPI_Comm_rank(MPI_COMM_WORLD, &pid); //find out who we are + MPI_Comm_size(MPI_COMM_WORLD, &processors); + + MPI_File inMPI; + MPI_File outMPI; + MPI_File outMPIAccnos; + MPI_File outMPIFasta; + + int outMode=MPI_MODE_CREATE|MPI_MODE_WRONLY; + int inMode=MPI_MODE_RDONLY; + + char outFilename[1024]; + strcpy(outFilename, outputFileName.c_str()); + + char outAccnosFilename[1024]; + strcpy(outAccnosFilename, accnosFileName.c_str()); + + char outFastaFilename[1024]; + strcpy(outFastaFilename, trimFastaFileName.c_str()); + + char inFileName[1024]; + strcpy(inFileName, inputFile.c_str()); + + MPI_File_open(MPI_COMM_WORLD, inFileName, inMode, MPI_INFO_NULL, &inMPI); //comm, filename, mode, info, filepointer + MPI_File_open(MPI_COMM_WORLD, outFilename, outMode, MPI_INFO_NULL, &outMPI); + MPI_File_open(MPI_COMM_WORLD, outAccnosFilename, outMode, MPI_INFO_NULL, &outMPIAccnos); + if (trim) { MPI_File_open(MPI_COMM_WORLD, outFastaFilename, outMode, MPI_INFO_NULL, &outMPIFasta); } + + if (m->control_pressed) { MPI_File_close(&inMPI); MPI_File_close(&outMPI); if (trim) { MPI_File_close(&outMPIFasta); } MPI_File_close(&outMPIAccnos); return 0; } + + if (pid == 0) { //you are the root process + m->mothurOutEndLine(); + m->mothurOut("Only reporting sequence supported by " + toString(minBS) + "% of bootstrapped results."); + m->mothurOutEndLine(); + + string outTemp = "Name\tLeftParent\tRightParent\tDivQLAQRB\tPerIDQLAQRB\tBootStrapA\tDivQLBQRA\tPerIDQLBQRA\tBootStrapB\tFlag\tLeftWindow\tRightWindow\n"; + + //print header + int length = outTemp.length(); + char* buf2 = new char[length]; + memcpy(buf2, outTemp.c_str(), length); + + MPI_File_write_shared(outMPI, buf2, length, MPI_CHAR, &status); + delete buf2; + + MPIPos = m->setFilePosFasta(inputFile, numSeqs); //fills MPIPos, returns numSeqs + + if (templatefile != "self") { //if template=self we can only use 1 processor + //send file positions to all processes + for(int i = 1; i < processors; i++) { + MPI_Send(&numSeqs, 1, MPI_INT, i, tag, MPI_COMM_WORLD); + MPI_Send(&MPIPos[0], (numSeqs+1), MPI_LONG, i, tag, MPI_COMM_WORLD); + } + } + //figure out how many sequences you have to align + numSeqsPerProcessor = numSeqs / processors; + int startIndex = pid * numSeqsPerProcessor; + if(pid == (processors - 1)){ numSeqsPerProcessor = numSeqs - pid * numSeqsPerProcessor; } + + if (templatefile == "self") { //if template=self we can only use 1 processor + startIndex = 0; + numSeqsPerProcessor = numSeqs; + } + + //do your part + set cnames; + driverMPI(startIndex, numSeqsPerProcessor, inMPI, outMPI, outMPIAccnos, outMPIFasta, cnames, MPIPos, inputFile, priority, false); + + if (m->control_pressed) { MPI_File_close(&inMPI); MPI_File_close(&outMPI); if (trim) { MPI_File_close(&outMPIFasta); } MPI_File_close(&outMPIAccnos); return 0; } + + }else{ //you are a child process + if (templatefile != "self") { //if template=self we can only use 1 processor + MPI_Recv(&numSeqs, 1, MPI_INT, 0, tag, MPI_COMM_WORLD, &status); + MPIPos.resize(numSeqs+1); + MPI_Recv(&MPIPos[0], (numSeqs+1), MPI_LONG, 0, tag, MPI_COMM_WORLD, &status); + + //figure out how many sequences you have to align + numSeqsPerProcessor = numSeqs / processors; + int startIndex = pid * numSeqsPerProcessor; + if(pid == (processors - 1)){ numSeqsPerProcessor = numSeqs - pid * numSeqsPerProcessor; } + + //do your part + set cnames; + driverMPI(startIndex, numSeqsPerProcessor, inMPI, outMPI, outMPIAccnos, outMPIFasta, cnames, MPIPos, inputFile, priority, false); + + if (m->control_pressed) { MPI_File_close(&inMPI); MPI_File_close(&outMPI); if (trim) { MPI_File_close(&outMPIFasta); } MPI_File_close(&outMPIAccnos); return 0; } + + } + } + + //close files + MPI_File_close(&inMPI); + MPI_File_close(&outMPI); + MPI_File_close(&outMPIAccnos); + if (trim) { MPI_File_close(&outMPIFasta); } + MPI_Barrier(MPI_COMM_WORLD); //make everyone wait - just in case + + +#endif + return numSeqs; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "MPIExecute"); + exit(1); + } +} +//********************************************************************************************************************** +int ChimeraSlayerCommand::deconvoluteResults(map& uniqueNames, string outputFileName, string accnosFileName, string trimFileName){ + try { + map::iterator itUnique; + int total = 0; + + if (trimera) { //add in more potential uniqueNames + map newUniqueNames = uniqueNames; + for (map::iterator it = uniqueNames.begin(); it != uniqueNames.end(); it++) { + newUniqueNames[(it->first)+"_LEFT"] = (it->first)+"_LEFT"; + newUniqueNames[(it->first)+"_RIGHT"] = (it->first)+"_RIGHT"; + } + uniqueNames = newUniqueNames; + newUniqueNames.clear(); + } + + //edit accnos file + ifstream in2; + m->openInputFile(accnosFileName, in2, "no error"); + + ofstream out2; + m->openOutputFile(accnosFileName+".temp", out2); + + string name; name = ""; + set chimerasInFile; + set::iterator itChimeras; + + while (!in2.eof()) { + if (m->control_pressed) { in2.close(); out2.close(); m->mothurRemove(outputFileName); m->mothurRemove((accnosFileName+".temp")); return 0; } + + in2 >> name; m->gobble(in2); + + //find unique name + itUnique = uniqueNames.find(name); + + if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing accnos results. Cannot find "+ name + "."); m->mothurOutEndLine(); m->control_pressed = true; } + else { + itChimeras = chimerasInFile.find((itUnique->second)); + + if (itChimeras == chimerasInFile.end()) { + out2 << itUnique->second << endl; + chimerasInFile.insert((itUnique->second)); + total++; + } + } + } + in2.close(); + out2.close(); + + m->mothurRemove(accnosFileName); + rename((accnosFileName+".temp").c_str(), accnosFileName.c_str()); + + + //edit chimera file + ifstream in; + m->openInputFile(outputFileName, in); + + ofstream out; + m->openOutputFile(outputFileName+".temp", out); out.setf(ios::fixed, ios::floatfield); out.setf(ios::showpoint); + + string rest, parent1, parent2, line; + set namesInFile; //this is so if a sequence is found to be chimera in several samples we dont write it to the results file more than once + set::iterator itNames; + + //assumptions - in file each read will always look like... + /* + F11Fcsw_92754 no + F11Fcsw_63104 F11Fcsw_33372 F11Fcsw_37007 0.89441 80.4469 0.2 1.03727 93.2961 52.2 no 0-241 243-369 + */ + + //get header line + if (!in.eof()) { + line = m->getline(in); m->gobble(in); + out << line << endl; + } + + //for the chimera file, we want to make sure if any group finds a sequence to be chimeric then all groups do, + //so if this is a report that did not find it to be chimeric, but it appears in the accnos file, + //then ignore this report and continue until we find the report that found it to be chimeric + + while (!in.eof()) { + + if (m->control_pressed) { in.close(); out.close(); m->mothurRemove((outputFileName+".temp")); return 0; } + + in >> name; m->gobble(in); + in >> parent1; m->gobble(in); + + if (name == "Name") { //name = "Name" because we append the header line each time we add results from the groups + line = m->getline(in); m->gobble(in); + }else { + if (parent1 == "no") { + //find unique name + itUnique = uniqueNames.find(name); + + if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing chimera results. Cannot find "+ name + "."); m->mothurOutEndLine(); m->control_pressed = true; } + else { + //is this sequence really not chimeric?? + itChimeras = chimerasInFile.find(itUnique->second); + + if (itChimeras == chimerasInFile.end()) { + //is this sequence not already in the file + itNames = namesInFile.find((itUnique->second)); + + if (itNames == namesInFile.end()) { out << itUnique->second << '\t' << "no" << endl; namesInFile.insert(itUnique->second); } + } + } + }else { //read the rest of the line + double DivQLAQRB,PerIDQLAQRB,BootStrapA,DivQLBQRA,PerIDQLBQRA,BootStrapB; + string flag, range1, range2; + bool print = false; + in >> parent2 >> DivQLAQRB >> PerIDQLAQRB >> BootStrapA >> DivQLBQRA >> PerIDQLBQRA >> BootStrapB >> flag >> range1 >> range2; m->gobble(in); + + //find unique name + itUnique = uniqueNames.find(name); + + if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing chimera results. Cannot find "+ name + "."); m->mothurOutEndLine(); m->control_pressed = true; } + else { + name = itUnique->second; + //is this name already in the file + itNames = namesInFile.find((name)); + + if (itNames == namesInFile.end()) { //no not in file + if (flag == "no") { //are you really a no?? + //is this sequence really not chimeric?? + itChimeras = chimerasInFile.find(name); + + //then you really are a no so print, otherwise skip + if (itChimeras == chimerasInFile.end()) { print = true; } + + }else{ print = true; } + } + } + + if (print) { + out << name << '\t'; + + namesInFile.insert(name); + + //output parent1's name + itUnique = uniqueNames.find(parent1); + if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing chimera results. Cannot find parentA "+ parent1 + "."); m->mothurOutEndLine(); m->control_pressed = true; } + else { out << itUnique->second << '\t'; } + + //output parent2's name + itUnique = uniqueNames.find(parent2); + if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing chimera results. Cannot find parentA "+ parent2 + "."); m->mothurOutEndLine(); m->control_pressed = true; } + else { out << itUnique->second << '\t'; } + + out << DivQLAQRB << '\t' << PerIDQLAQRB << '\t' << BootStrapA << '\t' << DivQLBQRA << '\t' << PerIDQLBQRA << '\t' << BootStrapB << '\t' << flag << '\t' << range1 << '\t' << range2 << endl; + } + } + } + } + in.close(); + out.close(); + + m->mothurRemove(outputFileName); + rename((outputFileName+".temp").c_str(), outputFileName.c_str()); + + //edit fasta file + if (trim) { + ifstream in3; + m->openInputFile(trimFileName, in3); + + ofstream out3; + m->openOutputFile(trimFileName+".temp", out3); + + namesInFile.clear(); + + while (!in3.eof()) { + if (m->control_pressed) { in3.close(); out3.close(); m->mothurRemove(outputFileName); m->mothurRemove(accnosFileName); m->mothurRemove((trimFileName+".temp")); return 0; } + + Sequence seq(in3); m->gobble(in3); + + if (seq.getName() != "") { + //find unique name + itUnique = uniqueNames.find(seq.getName()); + + if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing accnos results. Cannot find "+ seq.getName() + "."); m->mothurOutEndLine(); m->control_pressed = true; } + else { + itNames = namesInFile.find((itUnique->second)); + + if (itNames == namesInFile.end()) { + seq.printSequence(out3); + } + } + } + } + in3.close(); + out3.close(); + + m->mothurRemove(trimFileName); + rename((trimFileName+".temp").c_str(), trimFileName.c_str()); + } + + return total; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "deconvoluteResults"); + exit(1); + } +} +//********************************************************************************************************************** +int ChimeraSlayerCommand::setUpForSelfReference(SequenceParser*& parser, map& fileGroup, map >& fileToPriority, int s){ + try { + fileGroup.clear(); + fileToPriority.clear(); + + string nameFile = ""; + if (nameFileNames.size() != 0) { //you provided a namefile and we don't need to create one + nameFile = nameFileNames[s]; + }else { nameFile = getNamesFile(fastaFileNames[s]); } + + //you provided a groupfile + string groupFile = ""; + if (groupFileNames.size() != 0) { groupFile = groupFileNames[s]; } + + if (groupFile == "") { + if (processors != 1) { m->mothurOut("When using template=self, mothur can only use 1 processor, continuing."); m->mothurOutEndLine(); processors = 1; } + + //sort fastafile by abundance, returns new sorted fastafile name + m->mothurOut("Sorting fastafile according to abundance..."); cout.flush(); + priority = sortFastaFile(fastaFileNames[s], nameFile); + m->mothurOut("Done."); m->mothurOutEndLine(); + + fileToPriority[fastaFileNames[s]] = priority; + fileGroup[fastaFileNames[s]] = "noGroup"; + }else { + //Parse sequences by group + parser = new SequenceParser(groupFile, fastaFileNames[s], nameFile); + vector groups = parser->getNamesOfGroups(); + + for (int i = 0; i < groups.size(); i++) { + vector thisGroupsSeqs = parser->getSeqs(groups[i]); + map thisGroupsMap = parser->getNameMap(groups[i]); + group2NameMap[groups[i]] = thisGroupsMap; + string newFastaFile = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])) + groups[i] + "-sortedTemp.fasta"; + priority = sortFastaFile(thisGroupsSeqs, thisGroupsMap, newFastaFile); + fileToPriority[newFastaFile] = priority; + fileGroup[newFastaFile] = groups[i]; + } + } + + + return 0; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "setUpForSelfReference"); + exit(1); + } +} +//********************************************************************************************************************** +int ChimeraSlayerCommand::setUpForSelfReference(SequenceCountParser*& parser, map& fileGroup, map >& fileToPriority, int s){ + try { + fileGroup.clear(); + fileToPriority.clear(); + + string nameFile = ""; + if (nameFileNames.size() != 0) { //you provided a namefile and we don't need to create one + nameFile = nameFileNames[s]; + }else { m->control_pressed = true; return 0; } + + CountTable ct; + if (!ct.testGroups(nameFile)) { + if (processors != 1) { m->mothurOut("When using template=self, mothur can only use 1 processor, continuing."); m->mothurOutEndLine(); processors = 1; } + + //sort fastafile by abundance, returns new sorted fastafile name + m->mothurOut("Sorting fastafile according to abundance..."); cout.flush(); + priority = sortFastaFile(fastaFileNames[s], nameFile); + m->mothurOut("Done."); m->mothurOutEndLine(); + + fileToPriority[fastaFileNames[s]] = priority; + fileGroup[fastaFileNames[s]] = "noGroup"; + }else { + //Parse sequences by group + parser = new SequenceCountParser(nameFile, fastaFileNames[s]); + vector groups = parser->getNamesOfGroups(); + + for (int i = 0; i < groups.size(); i++) { + vector thisGroupsSeqs = parser->getSeqs(groups[i]); + map thisGroupsMap = parser->getCountTable(groups[i]); + string newFastaFile = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s])) + groups[i] + "-sortedTemp.fasta"; + sortFastaFile(thisGroupsSeqs, thisGroupsMap, newFastaFile); + fileToPriority[newFastaFile] = thisGroupsMap; + fileGroup[newFastaFile] = groups[i]; + } + } + + + return 0; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "setUpForSelfReference"); + exit(1); + } +} +//********************************************************************************************************************** +string ChimeraSlayerCommand::getNamesFile(string& inputFile){ + try { + string nameFile = ""; + + m->mothurOutEndLine(); m->mothurOut("No namesfile given, running unique.seqs command to generate one."); m->mothurOutEndLine(); m->mothurOutEndLine(); + + //use unique.seqs to create new name and fastafile + string inputString = "fasta=" + inputFile; + m->mothurOut("/******************************************/"); m->mothurOutEndLine(); + m->mothurOut("Running command: unique.seqs(" + inputString + ")"); m->mothurOutEndLine(); + m->mothurCalling = true; + + Command* uniqueCommand = new DeconvoluteCommand(inputString); + uniqueCommand->execute(); + + map > filenames = uniqueCommand->getOutputFiles(); + + delete uniqueCommand; + m->mothurCalling = false; + m->mothurOut("/******************************************/"); m->mothurOutEndLine(); + + nameFile = filenames["name"][0]; + inputFile = filenames["fasta"][0]; + + return nameFile; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "getNamesFile"); + exit(1); + } +} +//********************************************************************************************************************** + +int ChimeraSlayerCommand::driverGroups(string outputFName, string accnos, string fasta, map >& fileToPriority, map& fileGroup, string countlist){ + try { + int totalSeqs = 0; + ofstream outCountList; + + if (hasCount && dups) { m->openOutputFile(countlist, outCountList); } + + for (map >::iterator itFile = fileToPriority.begin(); itFile != fileToPriority.end(); itFile++) { + + if (m->control_pressed) { return 0; } + + int start = time(NULL); + string thisFastaName = itFile->first; + map thisPriority = itFile->second; + string thisoutputFileName = outputDir + m->getRootName(m->getSimpleName(thisFastaName)) + fileGroup[thisFastaName] + "slayer.chimera"; + string thisaccnosFileName = outputDir + m->getRootName(m->getSimpleName(thisFastaName)) + fileGroup[thisFastaName] + "slayer.accnos"; + string thistrimFastaFileName = outputDir + m->getRootName(m->getSimpleName(thisFastaName)) + fileGroup[thisFastaName] + "slayer.fasta"; + + m->mothurOutEndLine(); m->mothurOut("Checking sequences from group: " + fileGroup[thisFastaName] + "."); m->mothurOutEndLine(); + + lines.clear(); +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + int proc = 1; + vector positions = m->divideFile(thisFastaName, proc); + lines.push_back(linePair(positions[0], positions[1])); +#else + lines.push_back(linePair(0, 1000)); +#endif + int numSeqs = driver(lines[0], thisoutputFileName, thisFastaName, thisaccnosFileName, thistrimFastaFileName, thisPriority); + + //if we provided a count file with group info and set dereplicate=t, then we want to create a *.pick.count_table + //This table will zero out group counts for seqs determined to be chimeric by that group. + if (dups) { + if (!m->isBlank(thisaccnosFileName)) { + ifstream in; + m->openInputFile(thisaccnosFileName, in); + string name; + if (hasCount) { + while (!in.eof()) { + in >> name; m->gobble(in); + outCountList << name << '\t' << fileGroup[thisFastaName] << endl; + } + in.close(); + }else { + map >::iterator itGroupNameMap = group2NameMap.find(fileGroup[thisFastaName]); + if (itGroupNameMap != group2NameMap.end()) { + map thisnamemap = itGroupNameMap->second; + map::iterator itN; + ofstream out; + m->openOutputFile(thisaccnosFileName+".temp", out); + while (!in.eof()) { + in >> name; m->gobble(in); + itN = thisnamemap.find(name); + if (itN != thisnamemap.end()) { + vector tempNames; m->splitAtComma(itN->second, tempNames); + for (int j = 0; j < tempNames.size(); j++) { out << tempNames[j] << endl; } + + }else { m->mothurOut("[ERROR]: parsing cannot find " + name + ".\n"); m->control_pressed = true; } + } + out.close(); + in.close(); + m->renameFile(thisaccnosFileName+".temp", thisaccnosFileName); + }else { m->mothurOut("[ERROR]: parsing cannot find " + fileGroup[thisFastaName] + ".\n"); m->control_pressed = true; } + } + + } + } + + //append files + m->appendFiles(thisoutputFileName, outputFName); m->mothurRemove(thisoutputFileName); + m->appendFiles(thisaccnosFileName, accnos); m->mothurRemove(thisaccnosFileName); + if (trim) { m->appendFiles(thistrimFastaFileName, fasta); m->mothurRemove(thistrimFastaFileName); } + m->mothurRemove(thisFastaName); + + totalSeqs += numSeqs; + + m->mothurOutEndLine(); m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(numSeqs) + " sequences from group " + fileGroup[thisFastaName] + "."); m->mothurOutEndLine(); + } + + if (hasCount && dups) { outCountList.close(); } + + return totalSeqs; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "driverGroups"); + exit(1); + } +} +/**************************************************************************************************/ +int ChimeraSlayerCommand::createProcessesGroups(string outputFName, string accnos, string fasta, map >& fileToPriority, map& fileGroup, string countlist, string countFile) { + try { + int process = 1; + int num = 0; + processIDS.clear(); + + if (fileToPriority.size() < processors) { processors = fileToPriority.size(); } + + CountTable newCount; + if (hasCount && dups) { newCount.readTable(countFile); } + + int groupsPerProcessor = fileToPriority.size() / processors; + int remainder = fileToPriority.size() % processors; + + vector< map > > breakUp; + + for (int i = 0; i < processors; i++) { + map > thisFileToPriority; + map >::iterator itFile; + int count = 0; + int enough = groupsPerProcessor; + if (i == 0) { enough = groupsPerProcessor + remainder; } + + for (itFile = fileToPriority.begin(); itFile != fileToPriority.end();) { + thisFileToPriority[itFile->first] = itFile->second; + fileToPriority.erase(itFile++); + count++; + if (count == enough) { break; } + } + breakUp.push_back(thisFileToPriority); + } + +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + //loop through and create all the processes you want + while (process != processors) { + int pid = fork(); + + if (pid > 0) { + processIDS.push_back(pid); //create map from line number to pid so you can append files in correct order later + process++; + }else if (pid == 0){ + num = driverGroups(outputFName + toString(getpid()) + ".temp", accnos + toString(getpid()) + ".temp", fasta + toString(getpid()) + ".temp", breakUp[process], fileGroup, accnos + toString(getpid()) + ".byCount"); + + //pass numSeqs to parent + ofstream out; + string tempFile = outputFName + toString(getpid()) + ".num.temp"; + m->openOutputFile(tempFile, out); + out << num << endl; + out.close(); + exit(0); + }else { + m->mothurOut("[ERROR]: unable to spawn the necessary processes."); m->mothurOutEndLine(); + for (int i = 0; i < processIDS.size(); i++) { kill (processIDS[i], SIGINT); } + exit(0); + } + } + + num = driverGroups(outputFName, accnos, fasta, breakUp[0], fileGroup, accnos + ".byCount"); + + //force parent to wait until all the processes are done + for (int i=0;iopenInputFile(tempFile, in); + if (!in.eof()) { int tempNum = 0; in >> tempNum; num += tempNum; } + in.close(); m->mothurRemove(tempFile); + } +#else + + ////////////////////////////////////////////////////////////////////////////////////////////////////// + //Windows version shared memory, so be careful when passing variables through the slayerData struct. + //Above fork() will clone, so memory is separate, but that's not the case with windows, + ////////////////////////////////////////////////////////////////////////////////////////////////////// + + vector pDataArray; + DWORD dwThreadIdArray[processors-1]; + HANDLE hThreadArray[processors-1]; + + //Create processor worker threads. + for(int i=1; ifileToPriority.size() != pDataArray[i]->end) { + m->mothurOut("[ERROR]: process " + toString(i) + " only processed " + toString(pDataArray[i]->end) + " of " + toString(pDataArray[i]->fileToPriority.size()) + " groups assigned to it, quitting. \n"); m->control_pressed = true; + } + num += pDataArray[i]->count; + CloseHandle(hThreadArray[i]); + delete pDataArray[i]; + } +#endif + //read my own + if (hasCount && dups) { + if (!m->isBlank(accnos + ".byCount")) { + ifstream in2; + m->openInputFile(accnos + ".byCount", in2); + + string name, group; + while (!in2.eof()) { + in2 >> name >> group; m->gobble(in2); + newCount.setAbund(name, group, 0); + } + in2.close(); + } + m->mothurRemove(accnos + ".byCount"); + } + + + //append output files + for(int i=0;iappendFiles((outputFName + toString(processIDS[i]) + ".temp"), outputFName); + m->mothurRemove((outputFName + toString(processIDS[i]) + ".temp")); + + m->appendFiles((accnos + toString(processIDS[i]) + ".temp"), accnos); + m->mothurRemove((accnos + toString(processIDS[i]) + ".temp")); + + if (trim) { + m->appendFiles((fasta + toString(processIDS[i]) + ".temp"), fasta); + m->mothurRemove((fasta + toString(processIDS[i]) + ".temp")); + } + + if (hasCount && dups) { + if (!m->isBlank(accnos + toString(processIDS[i]) + ".byCount")) { + ifstream in2; + m->openInputFile(accnos + toString(processIDS[i]) + ".byCount", in2); + + string name, group; + while (!in2.eof()) { + in2 >> name >> group; m->gobble(in2); + newCount.setAbund(name, group, 0); + } + in2.close(); + } + m->mothurRemove(accnos + toString(processIDS[i]) + ".byCount"); + } + + } + + //print new *.pick.count_table + if (hasCount && dups) { newCount.printTable(countlist); } + + return num; + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "createProcessesGroups"); + exit(1); + } +} +//********************************************************************************************************************** + +int ChimeraSlayerCommand::driver(linePair filePos, string outputFName, string filename, string accnos, string fasta, map& priority){ + try { + + Chimera* chimera; + if (templatefile != "self") { //you want to run slayer with a reference template + chimera = new ChimeraSlayer(filename, templatefile, trim, search, ksize, match, mismatch, window, divR, minSimilarity, minCoverage, minBS, minSNP, parents, iters, increment, numwanted, realign, blastlocation, rand()); + }else { + chimera = new ChimeraSlayer(filename, templatefile, trim, priority, search, ksize, match, mismatch, window, divR, minSimilarity, minCoverage, minBS, minSNP, parents, iters, increment, numwanted, realign, blastlocation, rand()); + } + + if (m->control_pressed) { delete chimera; return 0; } + + if (chimera->getUnaligned()) { delete chimera; m->mothurOut("Your template sequences are different lengths, please correct."); m->mothurOutEndLine(); m->control_pressed = true; return 0; } + templateSeqsLength = chimera->getLength(); + + ofstream out; + m->openOutputFile(outputFName, out); + + ofstream out2; + m->openOutputFile(accnos, out2); + + ofstream out3; + if (trim) { m->openOutputFile(fasta, out3); } + + ifstream inFASTA; + m->openInputFile(filename, inFASTA); + + inFASTA.seekg(filePos.start); + + if (filePos.start == 0) { chimera->printHeader(out); } + + bool done = false; + int count = 0; + + while (!done) { + + if (m->control_pressed) { delete chimera; out.close(); out2.close(); if (trim) { out3.close(); } inFASTA.close(); return 1; } + + Sequence* candidateSeq = new Sequence(inFASTA); m->gobble(inFASTA); + string candidateAligned = candidateSeq->getAligned(); + + if (candidateSeq->getName() != "") { //incase there is a commented sequence at the end of a file + if (candidateSeq->getAligned().length() != templateSeqsLength) { + m->mothurOut(candidateSeq->getName() + " is not the same length as the template sequences. Skipping."); m->mothurOutEndLine(); + }else{ + //find chimeras + chimera->getChimeras(candidateSeq); + + if (m->control_pressed) { delete chimera; delete candidateSeq; return 1; } + + //if you are not chimeric, then check each half + data_results wholeResults = chimera->getResults(); + + //determine if we need to split + bool isChimeric = false; + + if (wholeResults.flag == "yes") { + string chimeraFlag = "no"; + if( (wholeResults.results[0].bsa >= minBS && wholeResults.results[0].divr_qla_qrb >= divR) + || + (wholeResults.results[0].bsb >= minBS && wholeResults.results[0].divr_qlb_qra >= divR) ) { chimeraFlag = "yes"; } + + + if (chimeraFlag == "yes") { + if ((wholeResults.results[0].bsa >= minBS) || (wholeResults.results[0].bsb >= minBS)) { isChimeric = true; } + } + } + + if ((!isChimeric) && trimera) { + + //split sequence in half by bases + string leftQuery, rightQuery; + Sequence tempSeq(candidateSeq->getName(), candidateAligned); + divideInHalf(tempSeq, leftQuery, rightQuery); + + //run chimeraSlayer on each piece + Sequence* left = new Sequence(candidateSeq->getName(), leftQuery); + Sequence* right = new Sequence(candidateSeq->getName(), rightQuery); + + //find chimeras + chimera->getChimeras(left); + data_results leftResults = chimera->getResults(); + + chimera->getChimeras(right); + data_results rightResults = chimera->getResults(); + + //if either piece is chimeric then report + Sequence trimmed = chimera->print(out, out2, leftResults, rightResults); + if (trim) { trimmed.printSequence(out3); } + + delete left; delete right; + + }else { //already chimeric + //print results + Sequence trimmed = chimera->print(out, out2); + if (trim) { trimmed.printSequence(out3); } + } + + + } + count++; + } + + #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) + unsigned long long pos = inFASTA.tellg(); + if ((pos == -1) || (pos >= filePos.end)) { break; } + #else + if (inFASTA.eof()) { break; } + #endif + + delete candidateSeq; + //report progress + if((count) % 100 == 0){ m->mothurOutJustToScreen("Processing sequence: " + toString(count) + "\n"); } + } + //report progress + if((count) % 100 != 0){ m->mothurOutJustToScreen("Processing sequence: " + toString(count)+ "\n"); } + + int numNoParents = chimera->getNumNoParents(); + if (numNoParents == count) { m->mothurOut("[WARNING]: megablast returned 0 potential parents for all your sequences. This could be due to formatdb.exe not being setup properly, please check formatdb.log for errors."); m->mothurOutEndLine(); } + + out.close(); + out2.close(); + if (trim) { out3.close(); } inFASTA.close(); + delete chimera; return count; + + } catch(exception& e) { m->errorOut(e, "ChimeraSlayerCommand", "driver"); @@ -650,15 +1848,27 @@ int ChimeraSlayerCommand::driver(linePair* filePos, string outputFName, string f } //********************************************************************************************************************** #ifdef USE_MPI -int ChimeraSlayerCommand::driverMPI(int start, int num, MPI_File& inMPI, MPI_File& outMPI, MPI_File& outAccMPI, MPI_File& outFastaMPI, vector& MPIPos){ - try { +int ChimeraSlayerCommand::driverMPI(int start, int num, MPI_File& inMPI, MPI_File& outMPI, MPI_File& outAccMPI, MPI_File& outFastaMPI, set& cnames, vector& MPIPos, string filename, map& priority, bool byGroup){ + try { MPI_Status status; int pid; MPI_Comm_rank(MPI_COMM_WORLD, &pid); //find out who we are + Chimera* chimera; + if (templatefile != "self") { //you want to run slayer with a reference template + chimera = new ChimeraSlayer(filename, templatefile, trim, search, ksize, match, mismatch, window, divR, minSimilarity, minCoverage, minBS, minSNP, parents, iters, increment, numwanted, realign, blastlocation, rand()); + }else { + chimera = new ChimeraSlayer(filename, templatefile, trim, priority, search, ksize, match, mismatch, window, divR, minSimilarity, minCoverage, minBS, minSNP, parents, iters, increment, numwanted, realign, blastlocation, rand(), byGroup); + } + + if (m->control_pressed) { delete chimera; return 0; } + + if (chimera->getUnaligned()) { delete chimera; m->mothurOut("Your template sequences are different lengths, please correct."); m->mothurOutEndLine(); m->control_pressed = true; return 0; } + templateSeqsLength = chimera->getLength(); + for(int i=0;icontrol_pressed) { return 1; } + if (m->control_pressed) { delete chimera; return 1; } //read next sequence int length = MPIPos[start+i+1] - MPIPos[start+i]; @@ -673,6 +1883,7 @@ int ChimeraSlayerCommand::driverMPI(int start, int num, MPI_File& inMPI, MPI_Fil delete buf4; Sequence* candidateSeq = new Sequence(iss); m->gobble(iss); + string candidateAligned = candidateSeq->getAligned(); if (candidateSeq->getName() != "") { //incase there is a commented sequence at the end of a file @@ -683,34 +1894,94 @@ int ChimeraSlayerCommand::driverMPI(int start, int num, MPI_File& inMPI, MPI_Fil //find chimeras chimera->getChimeras(candidateSeq); - if (m->control_pressed) { delete candidateSeq; return 1; } - - //print results - Sequence* trimmed = chimera->print(outMPI, outAccMPI); + if (m->control_pressed) { delete chimera; delete candidateSeq; return 1; } + + //if you are not chimeric, then check each half + data_results wholeResults = chimera->getResults(); - if (trim) { - string outputString = ">" + trimmed->getName() + "\n" + trimmed->getAligned() + "\n"; + //determine if we need to split + bool isChimeric = false; + + if (wholeResults.flag == "yes") { + string chimeraFlag = "no"; + if( (wholeResults.results[0].bsa >= minBS && wholeResults.results[0].divr_qla_qrb >= divR) + || + (wholeResults.results[0].bsb >= minBS && wholeResults.results[0].divr_qlb_qra >= divR) ) { chimeraFlag = "yes"; } - //write to accnos file - int length = outputString.length(); - char* buf2 = new char[length]; - memcpy(buf2, outputString.c_str(), length); - MPI_File_write_shared(outFastaMPI, buf2, length, MPI_CHAR, &status); - delete buf2; + if (chimeraFlag == "yes") { + if ((wholeResults.results[0].bsa >= minBS) || (wholeResults.results[0].bsb >= minBS)) { isChimeric = true; } + } } + + if ((!isChimeric) && trimera) { + //split sequence in half by bases + string leftQuery, rightQuery; + Sequence tempSeq(candidateSeq->getName(), candidateAligned); + divideInHalf(tempSeq, leftQuery, rightQuery); + + //run chimeraSlayer on each piece + Sequence* left = new Sequence(candidateSeq->getName(), leftQuery); + Sequence* right = new Sequence(candidateSeq->getName(), rightQuery); + + //find chimeras + chimera->getChimeras(left); + data_results leftResults = chimera->getResults(); + + chimera->getChimeras(right); + data_results rightResults = chimera->getResults(); + + //if either piece is chimeric then report + bool flag = false; + Sequence trimmed = chimera->print(outMPI, outAccMPI, leftResults, rightResults, flag); + if (flag) { cnames.insert(candidateSeq->getName()); } + + if (trim) { + string outputString = ">" + trimmed.getName() + "\n" + trimmed.getAligned() + "\n"; + + //write to accnos file + int length = outputString.length(); + char* buf2 = new char[length]; + memcpy(buf2, outputString.c_str(), length); + + MPI_File_write_shared(outFastaMPI, buf2, length, MPI_CHAR, &status); + delete buf2; + } + + delete left; delete right; + }else { + //print results + Sequence trimmed = chimera->print(outMPI, outAccMPI); + cnames.insert(candidateSeq->getName()); + + if (trim) { + string outputString = ">" + trimmed.getName() + "\n" + trimmed.getAligned() + "\n"; + + //write to accnos file + int length = outputString.length(); + char* buf2 = new char[length]; + memcpy(buf2, outputString.c_str(), length); + + MPI_File_write_shared(outFastaMPI, buf2, length, MPI_CHAR, &status); + delete buf2; + } + } + } } delete candidateSeq; //report progress - if((i+1) % 100 == 0){ cout << "Processing sequence: " << (i+1) << endl; m->mothurOutJustToLog("Processing sequence: " + toString(i+1) + "\n"); } + if((i+1) % 100 == 0){ cout << "Processing sequence: " << (i+1) << endl; } } //report progress - if(num % 100 != 0){ cout << "Processing sequence: " << num << endl; m->mothurOutJustToLog("Processing sequence: " + toString(num) + "\n"); } + if(num % 100 != 0){ cout << "Processing sequence: " << num << endl; } - + int numNoParents = chimera->getNumNoParents(); + if (numNoParents == num) { cout << "[WARNING]: megablast returned 0 potential parents for all your sequences. This could be due to formatdb.exe not being setup properly, please check formatdb.log for errors." << endl; } + + delete chimera; return 0; } catch(exception& e) { @@ -722,12 +1993,13 @@ int ChimeraSlayerCommand::driverMPI(int start, int num, MPI_File& inMPI, MPI_Fil /**************************************************************************************************/ -int ChimeraSlayerCommand::createProcesses(string outputFileName, string filename, string accnos, string fasta) { +int ChimeraSlayerCommand::createProcesses(string outputFileName, string filename, string accnos, string fasta, map& thisPriority) { try { -#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) int process = 0; int num = 0; + processIDS.clear(); +#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix) //loop through and create all the processes you want while (process != processors) { int pid = fork(); @@ -736,7 +2008,7 @@ int ChimeraSlayerCommand::createProcesses(string outputFileName, string filename processIDS.push_back(pid); //create map from line number to pid so you can append files in correct order later process++; }else if (pid == 0){ - num = driver(lines[process], outputFileName + toString(getpid()) + ".temp", filename, accnos + toString(getpid()) + ".temp", fasta + toString(getpid()) + ".temp"); + num = driver(lines[process], outputFileName + toString(getpid()) + ".temp", filename, accnos + toString(getpid()) + ".temp", fasta + toString(getpid()) + ".temp", thisPriority); //pass numSeqs to parent ofstream out; @@ -744,7 +2016,6 @@ int ChimeraSlayerCommand::createProcesses(string outputFileName, string filename m->openOutputFile(tempFile, out); out << num << endl; out.close(); - exit(0); }else { m->mothurOut("[ERROR]: unable to spawn the necessary processes."); m->mothurOutEndLine(); @@ -763,12 +2034,63 @@ int ChimeraSlayerCommand::createProcesses(string outputFileName, string filename ifstream in; string tempFile = outputFileName + toString(processIDS[i]) + ".num.temp"; m->openInputFile(tempFile, in); - if (!in.eof()) { int tempNum = 0; in >> tempNum; num += tempNum; } - in.close(); remove(tempFile.c_str()); + if (!in.eof()) { int tempNum = 0; in >> tempNum; num += tempNum; } + in.close(); m->mothurRemove(tempFile); } +#else + + ////////////////////////////////////////////////////////////////////////////////////////////////////// + //Windows version shared memory, so be careful when passing variables through the slayerData struct. + //Above fork() will clone, so memory is separate, but that's not the case with windows, + ////////////////////////////////////////////////////////////////////////////////////////////////////// + + vector pDataArray; + DWORD dwThreadIdArray[processors]; + HANDLE hThreadArray[processors]; + + //Create processor worker threads. + for( int i=0; icount; + CloseHandle(hThreadArray[i]); + delete pDataArray[i]; + } +#endif + + rename((outputFileName + toString(processIDS[0]) + ".temp").c_str(), outputFileName.c_str()); + rename((accnos + toString(processIDS[0]) + ".temp").c_str(), accnos.c_str()); + if (trim) { rename((fasta + toString(processIDS[0]) + ".temp").c_str(), fasta.c_str()); } + + //append output files + for(int i=1;iappendFiles((outputFileName + toString(processIDS[i]) + ".temp"), outputFileName); + m->mothurRemove((outputFileName + toString(processIDS[i]) + ".temp")); + + m->appendFiles((accnos + toString(processIDS[i]) + ".temp"), accnos); + m->mothurRemove((accnos + toString(processIDS[i]) + ".temp")); + + if (trim) { + m->appendFiles((fasta + toString(processIDS[i]) + ".temp"), fasta); + m->mothurRemove((fasta + toString(processIDS[i]) + ".temp")); + } + } + return num; -#endif } catch(exception& e) { m->errorOut(e, "ChimeraSlayerCommand", "createProcesses"); @@ -778,4 +2100,204 @@ int ChimeraSlayerCommand::createProcesses(string outputFileName, string filename /**************************************************************************************************/ +int ChimeraSlayerCommand::divideInHalf(Sequence querySeq, string& leftQuery, string& rightQuery) { + try { + + string queryUnAligned = querySeq.getUnaligned(); + int numBases = int(queryUnAligned.length() * 0.5); + + string queryAligned = querySeq.getAligned(); + leftQuery = querySeq.getAligned(); + rightQuery = querySeq.getAligned(); + + int baseCount = 0; + int leftSpot = 0; + for (int i = 0; i < queryAligned.length(); i++) { + //if you are a base + if (isalpha(queryAligned[i])) { + baseCount++; + } + + //if you have half + if (baseCount >= numBases) { leftSpot = i; break; } //first half + } + + //blank out right side + for (int i = leftSpot; i < leftQuery.length(); i++) { leftQuery[i] = '.'; } + + //blank out left side + for (int i = 0; i < leftSpot; i++) { rightQuery[i] = '.'; } + + return 0; + + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "divideInHalf"); + exit(1); + } +} +/**************************************************************************************************/ +map ChimeraSlayerCommand::sortFastaFile(string fastaFile, string nameFile) { + try { + map nameAbund; + + //read through fastafile and store info + map seqs; + ifstream in; + m->openInputFile(fastaFile, in); + + while (!in.eof()) { + + if (m->control_pressed) { in.close(); return nameAbund; } + + Sequence seq(in); m->gobble(in); + seqs[seq.getName()] = seq.getAligned(); + } + + in.close(); + + //read namefile or countfile + vector nameMapCount; + int error; + if (hasCount) { + CountTable ct; + ct.readTable(nameFile); + + for(map::iterator it = seqs.begin(); it != seqs.end(); it++) { + int num = ct.getNumSeqs(it->first); + if (num == 0) { error = 1; } + else { + seqPriorityNode temp(num, it->second, it->first); + nameMapCount.push_back(temp); + } + } + }else { error = m->readNames(nameFile, nameMapCount, seqs); } + + if (m->control_pressed) { return nameAbund; } + + if (error == 1) { m->control_pressed = true; return nameAbund; } + if (seqs.size() != nameMapCount.size()) { m->mothurOut( "The number of sequences in your fastafile does not match the number of sequences in your namefile, aborting."); m->mothurOutEndLine(); m->control_pressed = true; return nameAbund; } + + sort(nameMapCount.begin(), nameMapCount.end(), compareSeqPriorityNodes); + + string newFasta = fastaFile + ".temp"; + ofstream out; + m->openOutputFile(newFasta, out); + + //print new file in order of + for (int i = 0; i < nameMapCount.size(); i++) { + out << ">" << nameMapCount[i].name << endl << nameMapCount[i].seq << endl; + nameAbund[nameMapCount[i].name] = nameMapCount[i].numIdentical; + } + out.close(); + + rename(newFasta.c_str(), fastaFile.c_str()); + + return nameAbund; + + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "sortFastaFile"); + exit(1); + } +} +/**************************************************************************************************/ +map ChimeraSlayerCommand::sortFastaFile(vector& thisseqs, map& nameMap, string newFile) { + try { + map nameAbund; + vector nameVector; + + //read through fastafile and store info + map seqs; + + for (int i = 0; i < thisseqs.size(); i++) { + + if (m->control_pressed) { return nameAbund; } + + map::iterator itNameMap = nameMap.find(thisseqs[i].getName()); + + if (itNameMap == nameMap.end()){ + m->control_pressed = true; + m->mothurOut("[ERROR]: " + thisseqs[i].getName() + " is in your fastafile, but is not in your namesfile, please correct."); m->mothurOutEndLine(); + }else { + int num = m->getNumNames(itNameMap->second); + + seqPriorityNode temp(num, thisseqs[i].getAligned(), thisseqs[i].getName()); + nameVector.push_back(temp); + } + } + + //sort by num represented + sort(nameVector.begin(), nameVector.end(), compareSeqPriorityNodes); + + if (m->control_pressed) { return nameAbund; } + + if (thisseqs.size() != nameVector.size()) { m->mothurOut( "The number of sequences in your fastafile does not match the number of sequences in your namefile, aborting."); m->mothurOutEndLine(); m->control_pressed = true; return nameAbund; } + + ofstream out; + m->openOutputFile(newFile, out); + + //print new file in order of + for (int i = 0; i < nameVector.size(); i++) { + out << ">" << nameVector[i].name << endl << nameVector[i].seq << endl; + nameAbund[nameVector[i].name] = nameVector[i].numIdentical; + } + out.close(); + + return nameAbund; + + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "sortFastaFile"); + exit(1); + } +} +/**************************************************************************************************/ +int ChimeraSlayerCommand::sortFastaFile(vector& thisseqs, map& countMap, string newFile) { + try { + vector nameVector; + + //read through fastafile and store info + map seqs; + + for (int i = 0; i < thisseqs.size(); i++) { + + if (m->control_pressed) { return 0; } + + map::iterator itCountMap = countMap.find(thisseqs[i].getName()); + + if (itCountMap == countMap.end()){ + m->control_pressed = true; + m->mothurOut("[ERROR]: " + thisseqs[i].getName() + " is in your fastafile, but is not in your count file, please correct."); m->mothurOutEndLine(); + }else { + seqPriorityNode temp(itCountMap->second, thisseqs[i].getAligned(), thisseqs[i].getName()); + nameVector.push_back(temp); + } + } + + //sort by num represented + sort(nameVector.begin(), nameVector.end(), compareSeqPriorityNodes); + + if (m->control_pressed) { return 0; } + + if (thisseqs.size() != nameVector.size()) { m->mothurOut( "The number of sequences in your fastafile does not match the number of sequences in your count file, aborting."); m->mothurOutEndLine(); m->control_pressed = true; return 0; } + + ofstream out; + m->openOutputFile(newFile, out); + + //print new file in order of + for (int i = 0; i < nameVector.size(); i++) { + out << ">" << nameVector[i].name << endl << nameVector[i].seq << endl; + } + out.close(); + + return 0; + + } + catch(exception& e) { + m->errorOut(e, "ChimeraSlayerCommand", "sortFastaFile"); + exit(1); + } +} +/**************************************************************************************************/