1 #ifndef CHIMERAUCHIMECOMMAND_H
2 #define CHIMERAUCHIMECOMMAND_H
6 * chimerauchimecommand.h
9 * Created by westcott on 5/13/11.
10 * Copyright 2011 Schloss Lab. All rights reserved.
15 #include "command.hpp"
16 #include "sequenceparser.h"
17 #include "counttable.h"
18 #include "sequencecountparser.h"
20 /***********************************************************/
22 class ChimeraUchimeCommand : public Command {
24 ChimeraUchimeCommand(string);
25 ChimeraUchimeCommand();
26 ~ChimeraUchimeCommand() {}
28 vector<string> setParameters();
29 string getCommandName() { return "chimera.uchime"; }
30 string getCommandCategory() { return "Sequence Processing"; }
32 string getHelpString();
33 string getOutputPattern(string);
34 string getCitation() { return "uchime by Robert C. Edgar\nhttp://drive5.com/uchime\nThis code was donated to the public domain.\nEdgar,R.C., Haas,B.J., Clemente,J.C., Quince,C. and Knight,R. (2011), UCHIME improves sensitivity and speed of chimera detection. Bioinformatics 27:2194.\nhttp://www.mothur.org/wiki/Chimera.uchime\n"; }
35 string getDescription() { return "detect chimeric sequences"; }
38 void help() { m->mothurOut(getHelpString()); }
44 linePair(int i, int j) : start(i), end(j) {}
47 vector<int> processIDS; //processid
48 int driver(string, string, string, string, int&);
49 int createProcesses(string, string, string, string, int&);
51 bool abort, useAbskew, chimealns, useMinH, useMindiv, useXn, useDn, useXa, useChunks, useMinchunk, useIdsmoothwindow, useMinsmoothid, useMaxp, skipgaps, skipgaps2, useMinlen, useMaxlen, ucl, useQueryfract, hasCount, hasName, dups;
52 string fastafile, groupfile, templatefile, outputDir, namefile, countfile, abskew, minh, mindiv, xn, dn, xa, chunks, minchunk, idsmoothwindow, minsmoothid, maxp, minlen, maxlen, queryfract, uchimeLocation, strand;
55 SequenceParser* sparser;
56 SequenceCountParser* cparser;
57 vector<string> outputNames;
58 vector<string> fastaFileNames;
59 vector<string> nameFileNames;
60 vector<string> groupFileNames;
62 string getNamesFile(string&);
63 int readFasta(string, map<string, string>&);
64 int printFile(vector<seqPriorityNode>&, string);
65 int deconvoluteResults(map<string, string>&, string, string, string);
66 int driverGroups(string, string, string, string, int, int, vector<string>);
67 int createProcessesGroups(string, string, string, string, vector<string>, string, string, string);
68 int prepFile(string filename, string);
73 /***********************************************************/
74 /**************************************************************************************************/
75 //custom data structure for threads to use.
76 // This is passed by void pointer so it can be any data type
77 // that can be passed using a single void pointer (LPVOID).
83 string accnos, alns, filename, templatefile, uchimeLocation;
87 int threadID, count, numChimeras;
88 vector<string> groups;
89 bool useAbskew, chimealns, useMinH, useMindiv, useXn, useDn, useXa, useChunks, useMinchunk, useIdsmoothwindow, useMinsmoothid, useMaxp, skipgaps, skipgaps2, useMinlen, useMaxlen, ucl, useQueryfract, hasCount;
90 string abskew, minh, mindiv, xn, dn, xa, chunks, minchunk, idsmoothwindow, minsmoothid, maxp, minlen, maxlen, queryfract, strand;
93 uchimeData(string o, string uloc, string t, string file, string f, string n, string g, string ac, string al, vector<string> gr, MothurOut* mout, int st, int en, int tid) {
109 uchimeLocation = uloc;
111 void setBooleans(bool Abskew, bool calns, bool MinH, bool Mindiv, bool Xn, bool Dn, bool Xa, bool Chunks, bool Minchunk, bool Idsmoothwindow, bool Minsmoothid, bool Maxp, bool skipgap, bool skipgap2, bool Minlen, bool Maxlen, bool uc, bool Queryfract, bool hc) {
120 useMinchunk = Minchunk;
121 useIdsmoothwindow = Idsmoothwindow;
122 useMinsmoothid = Minsmoothid;
125 skipgaps2 = skipgap2;
129 useQueryfract = Queryfract;
133 void setVariables(string abske, string min, string mindi, string x, string d, string xa2, string chunk, string minchun, string idsmoothwindo, string minsmoothi, string max, string minle, string maxle, string queryfrac, string stra) {
143 idsmoothwindow = idsmoothwindo;
144 minsmoothid = minsmoothi;
148 queryfract = queryfrac;
152 /**************************************************************************************************/
153 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
155 static DWORD WINAPI MyUchimeThreadFunction(LPVOID lpParam){
156 uchimeData* pDataArray;
157 pDataArray = (uchimeData*)lpParam;
161 pDataArray->outputFName = pDataArray->m->getFullPathName(pDataArray->outputFName);
162 pDataArray->filename = pDataArray->m->getFullPathName(pDataArray->filename);
163 pDataArray->alns = pDataArray->m->getFullPathName(pDataArray->alns);
166 ofstream out, out1, out2;
167 pDataArray->m->openOutputFile(pDataArray->outputFName, out); out.close();
168 pDataArray->m->openOutputFile(pDataArray->accnos, out1); out1.close();
169 if (pDataArray->chimealns) { pDataArray->m->openOutputFile(pDataArray->alns, out2); out2.close(); }
171 //parse fasta and name file by group
172 SequenceParser* parser;
173 SequenceCountParser* cparser;
174 if (pDataArray->hasCount) {
175 CountTable* ct = new CountTable();
176 ct->readTable(pDataArray->namefile);
177 cparser = new SequenceCountParser(pDataArray->fastafile, *ct);
180 if (pDataArray->namefile != "") { parser = new SequenceParser(pDataArray->groupfile, pDataArray->fastafile, pDataArray->namefile); }
181 else { parser = new SequenceParser(pDataArray->groupfile, pDataArray->fastafile); }
187 for (int i = pDataArray->start; i < pDataArray->end; i++) {
188 int start = time(NULL); if (pDataArray->m->control_pressed) { if (pDataArray->hasCount) { delete cparser; } { delete parser; } return 0; }
192 if (pDataArray->hasCount) {
193 error = cparser->getSeqs(pDataArray->groups[i], pDataArray->filename, true); if ((error == 1) || pDataArray->m->control_pressed) { delete cparser; return 0; }
195 error = parser->getSeqs(pDataArray->groups[i], pDataArray->filename, true); if ((error == 1) || pDataArray->m->control_pressed) { delete parser; return 0; }
198 //int numSeqs = driver((outputFName + groups[i]), filename, (accnos+ groups[i]), (alns+ groups[i]), numChimeras);
199 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
201 //to allow for spaces in the path
202 string outputFName = "\"" + pDataArray->outputFName+pDataArray->groups[i] + "\"";
203 string filename = "\"" + pDataArray->filename + "\"";
204 string alns = "\"" + pDataArray->alns+pDataArray->groups[i] + "\"";
205 string accnos = pDataArray->accnos+pDataArray->groups[i];
209 string uchimeCommand = pDataArray->uchimeLocation;
210 uchimeCommand = "\"" + uchimeCommand + "\"";
213 tempUchime= new char[uchimeCommand.length()+1];
215 strncat(tempUchime, uchimeCommand.c_str(), uchimeCommand.length());
216 cPara.push_back(tempUchime);
218 char* tempIn = new char[8];
219 *tempIn = '\0'; strncat(tempIn, "--input", 7);
220 //strcpy(tempIn, "--input");
221 cPara.push_back(tempIn);
222 char* temp = new char[filename.length()+1];
223 *temp = '\0'; strncat(temp, filename.c_str(), filename.length());
224 //strcpy(temp, filename.c_str());
225 cPara.push_back(temp);
227 char* tempO = new char[12];
228 *tempO = '\0'; strncat(tempO, "--uchimeout", 11);
229 //strcpy(tempO, "--uchimeout");
230 cPara.push_back(tempO);
231 char* tempout = new char[outputFName.length()+1];
232 //strcpy(tempout, outputFName.c_str());
233 *tempout = '\0'; strncat(tempout, outputFName.c_str(), outputFName.length());
234 cPara.push_back(tempout);
236 if (pDataArray->chimealns) {
237 char* tempA = new char[13];
238 *tempA = '\0'; strncat(tempA, "--uchimealns", 12);
239 //strcpy(tempA, "--uchimealns");
240 cPara.push_back(tempA);
241 char* tempa = new char[alns.length()+1];
242 //strcpy(tempa, alns.c_str());
243 *tempa = '\0'; strncat(tempa, alns.c_str(), alns.length());
244 cPara.push_back(tempa);
247 if (pDataArray->strand != "") {
248 char* tempA = new char[9];
249 *tempA = '\0'; strncat(tempA, "--strand", 8);
250 cPara.push_back(tempA);
251 char* tempa = new char[pDataArray->strand.length()+1];
252 *tempa = '\0'; strncat(tempa, pDataArray->strand.c_str(), pDataArray->strand.length());
253 cPara.push_back(tempa);
256 if (pDataArray->useAbskew) {
257 char* tempskew = new char[9];
258 *tempskew = '\0'; strncat(tempskew, "--abskew", 8);
259 //strcpy(tempskew, "--abskew");
260 cPara.push_back(tempskew);
261 char* tempSkew = new char[pDataArray->abskew.length()+1];
262 //strcpy(tempSkew, abskew.c_str());
263 *tempSkew = '\0'; strncat(tempSkew, pDataArray->abskew.c_str(), pDataArray->abskew.length());
264 cPara.push_back(tempSkew);
267 if (pDataArray->useMinH) {
268 char* tempminh = new char[7];
269 *tempminh = '\0'; strncat(tempminh, "--minh", 6);
270 //strcpy(tempminh, "--minh");
271 cPara.push_back(tempminh);
272 char* tempMinH = new char[pDataArray->minh.length()+1];
273 *tempMinH = '\0'; strncat(tempMinH, pDataArray->minh.c_str(), pDataArray->minh.length());
274 //strcpy(tempMinH, minh.c_str());
275 cPara.push_back(tempMinH);
278 if (pDataArray->useMindiv) {
279 char* tempmindiv = new char[9];
280 *tempmindiv = '\0'; strncat(tempmindiv, "--mindiv", 8);
281 //strcpy(tempmindiv, "--mindiv");
282 cPara.push_back(tempmindiv);
283 char* tempMindiv = new char[pDataArray->mindiv.length()+1];
284 *tempMindiv = '\0'; strncat(tempMindiv, pDataArray->mindiv.c_str(), pDataArray->mindiv.length());
285 //strcpy(tempMindiv, mindiv.c_str());
286 cPara.push_back(tempMindiv);
289 if (pDataArray->useXn) {
290 char* tempxn = new char[5];
291 //strcpy(tempxn, "--xn");
292 *tempxn = '\0'; strncat(tempxn, "--xn", 4);
293 cPara.push_back(tempxn);
294 char* tempXn = new char[pDataArray->xn.length()+1];
295 //strcpy(tempXn, xn.c_str());
296 *tempXn = '\0'; strncat(tempXn, pDataArray->xn.c_str(), pDataArray->xn.length());
297 cPara.push_back(tempXn);
300 if (pDataArray->useDn) {
301 char* tempdn = new char[5];
302 //strcpy(tempdn, "--dn");
303 *tempdn = '\0'; strncat(tempdn, "--dn", 4);
304 cPara.push_back(tempdn);
305 char* tempDn = new char[pDataArray->dn.length()+1];
306 *tempDn = '\0'; strncat(tempDn, pDataArray->dn.c_str(), pDataArray->dn.length());
307 //strcpy(tempDn, dn.c_str());
308 cPara.push_back(tempDn);
311 if (pDataArray->useXa) {
312 char* tempxa = new char[5];
313 //strcpy(tempxa, "--xa");
314 *tempxa = '\0'; strncat(tempxa, "--xa", 4);
315 cPara.push_back(tempxa);
316 char* tempXa = new char[pDataArray->xa.length()+1];
317 *tempXa = '\0'; strncat(tempXa, pDataArray->xa.c_str(), pDataArray->xa.length());
318 //strcpy(tempXa, xa.c_str());
319 cPara.push_back(tempXa);
322 if (pDataArray->useChunks) {
323 char* tempchunks = new char[9];
324 //strcpy(tempchunks, "--chunks");
325 *tempchunks = '\0'; strncat(tempchunks, "--chunks", 8);
326 cPara.push_back(tempchunks);
327 char* tempChunks = new char[pDataArray->chunks.length()+1];
328 *tempChunks = '\0'; strncat(tempChunks, pDataArray->chunks.c_str(), pDataArray->chunks.length());
329 //strcpy(tempChunks, chunks.c_str());
330 cPara.push_back(tempChunks);
333 if (pDataArray->useMinchunk) {
334 char* tempminchunk = new char[11];
335 //strcpy(tempminchunk, "--minchunk");
336 *tempminchunk = '\0'; strncat(tempminchunk, "--minchunk", 10);
337 cPara.push_back(tempminchunk);
338 char* tempMinchunk = new char[pDataArray->minchunk.length()+1];
339 *tempMinchunk = '\0'; strncat(tempMinchunk, pDataArray->minchunk.c_str(), pDataArray->minchunk.length());
340 //strcpy(tempMinchunk, minchunk.c_str());
341 cPara.push_back(tempMinchunk);
344 if (pDataArray->useIdsmoothwindow) {
345 char* tempidsmoothwindow = new char[17];
346 *tempidsmoothwindow = '\0'; strncat(tempidsmoothwindow, "--idsmoothwindow", 16);
347 //strcpy(tempidsmoothwindow, "--idsmoothwindow");
348 cPara.push_back(tempidsmoothwindow);
349 char* tempIdsmoothwindow = new char[pDataArray->idsmoothwindow.length()+1];
350 *tempIdsmoothwindow = '\0'; strncat(tempIdsmoothwindow, pDataArray->idsmoothwindow.c_str(), pDataArray->idsmoothwindow.length());
351 //strcpy(tempIdsmoothwindow, idsmoothwindow.c_str());
352 cPara.push_back(tempIdsmoothwindow);
355 if (pDataArray->useMaxp) {
356 char* tempmaxp = new char[7];
357 //strcpy(tempmaxp, "--maxp");
358 *tempmaxp = '\0'; strncat(tempmaxp, "--maxp", 6);
359 cPara.push_back(tempmaxp);
360 char* tempMaxp = new char[pDataArray->maxp.length()+1];
361 *tempMaxp = '\0'; strncat(tempMaxp, pDataArray->maxp.c_str(), pDataArray->maxp.length());
362 //strcpy(tempMaxp, maxp.c_str());
363 cPara.push_back(tempMaxp);
366 if (!pDataArray->skipgaps) {
367 char* tempskipgaps = new char[13];
368 //strcpy(tempskipgaps, "--[no]skipgaps");
369 *tempskipgaps = '\0'; strncat(tempskipgaps, "--noskipgaps", 12);
370 cPara.push_back(tempskipgaps);
373 if (!pDataArray->skipgaps2) {
374 char* tempskipgaps2 = new char[14];
375 //strcpy(tempskipgaps2, "--[no]skipgaps2");
376 *tempskipgaps2 = '\0'; strncat(tempskipgaps2, "--noskipgaps2", 13);
377 cPara.push_back(tempskipgaps2);
380 if (pDataArray->useMinlen) {
381 char* tempminlen = new char[9];
382 *tempminlen = '\0'; strncat(tempminlen, "--minlen", 8);
383 //strcpy(tempminlen, "--minlen");
384 cPara.push_back(tempminlen);
385 char* tempMinlen = new char[pDataArray->minlen.length()+1];
386 //strcpy(tempMinlen, minlen.c_str());
387 *tempMinlen = '\0'; strncat(tempMinlen, pDataArray->minlen.c_str(), pDataArray->minlen.length());
388 cPara.push_back(tempMinlen);
391 if (pDataArray->useMaxlen) {
392 char* tempmaxlen = new char[9];
393 //strcpy(tempmaxlen, "--maxlen");
394 *tempmaxlen = '\0'; strncat(tempmaxlen, "--maxlen", 8);
395 cPara.push_back(tempmaxlen);
396 char* tempMaxlen = new char[pDataArray->maxlen.length()+1];
397 *tempMaxlen = '\0'; strncat(tempMaxlen, pDataArray->maxlen.c_str(), pDataArray->maxlen.length());
398 //strcpy(tempMaxlen, maxlen.c_str());
399 cPara.push_back(tempMaxlen);
402 if (pDataArray->ucl) {
403 char* tempucl = new char[5];
404 strcpy(tempucl, "--ucl");
405 cPara.push_back(tempucl);
408 if (pDataArray->useQueryfract) {
409 char* tempqueryfract = new char[13];
410 *tempqueryfract = '\0'; strncat(tempqueryfract, "--queryfract", 12);
411 //strcpy(tempqueryfract, "--queryfract");
412 cPara.push_back(tempqueryfract);
413 char* tempQueryfract = new char[pDataArray->queryfract.length()+1];
414 *tempQueryfract = '\0'; strncat(tempQueryfract, pDataArray->queryfract.c_str(), pDataArray->queryfract.length());
415 //strcpy(tempQueryfract, queryfract.c_str());
416 cPara.push_back(tempQueryfract);
420 char** uchimeParameters;
421 uchimeParameters = new char*[cPara.size()];
422 string commandString = "";
423 for (int j = 0; j < cPara.size(); j++) { uchimeParameters[j] = cPara[j]; commandString += toString(cPara[j]) + " "; }
424 //int numArgs = cPara.size();
426 //uchime_main(numArgs, uchimeParameters);
427 //cout << "commandString = " << commandString << endl;
428 commandString = "\"" + commandString + "\"";
430 if (pDataArray->m->debug) { pDataArray->m->mothurOut("[DEBUG]: uchime command = " + commandString + ".\n"); }
432 system(commandString.c_str());
435 for(int j = 0; j < cPara.size(); j++) { delete cPara[j]; }
436 delete[] uchimeParameters;
438 //remove "" from filenames
439 outputFName = outputFName.substr(1, outputFName.length()-2);
440 filename = filename.substr(1, filename.length()-2);
441 alns = alns.substr(1, alns.length()-2);
443 if (pDataArray->m->control_pressed) { if (pDataArray->hasCount) { delete cparser; } { delete parser; } return 0; }
445 //create accnos file from uchime results
447 pDataArray->m->openInputFile(outputFName, in);
450 pDataArray->m->openOutputFile(accnos, out);
456 if (pDataArray->m->control_pressed) { break; }
459 string chimeraFlag = "";
460 in >> chimeraFlag >> name;
463 name = name.substr(0, name.length()-1); //rip off last /
464 name = name.substr(0, name.find_last_of('/'));
466 for (int j = 0; j < 15; j++) { in >> chimeraFlag; }
467 pDataArray->m->gobble(in);
469 if (chimeraFlag == "Y") { out << name << endl; numChimeras++; }
476 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
478 pDataArray->numChimeras += numChimeras;
480 if (pDataArray->m->control_pressed) { if (pDataArray->hasCount) { delete cparser; } { delete parser; } return 0; }
482 //remove file made for uchime
483 pDataArray->m->mothurRemove(filename);
486 pDataArray->m->appendFiles(outputFName, pDataArray->outputFName); pDataArray->m->mothurRemove(outputFName);
487 pDataArray->m->appendFiles(accnos, pDataArray->accnos); pDataArray->m->mothurRemove(accnos);
488 if (pDataArray->chimealns) { pDataArray->m->appendFiles(alns, pDataArray->alns); pDataArray->m->mothurRemove(alns); }
490 pDataArray->m->mothurOutEndLine(); pDataArray->m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(num) + " sequences from group " + pDataArray->groups[i] + "."); pDataArray->m->mothurOutEndLine();
494 pDataArray->count = totalSeqs;
495 if (pDataArray->hasCount) { delete cparser; } { delete parser; }
499 catch(exception& e) {
500 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeThreadFunction");
504 /**************************************************************************************************/
506 static DWORD WINAPI MyUchimeSeqsThreadFunction(LPVOID lpParam){
507 uchimeData* pDataArray;
508 pDataArray = (uchimeData*)lpParam;
512 pDataArray->outputFName = pDataArray->m->getFullPathName(pDataArray->outputFName);
513 pDataArray->filename = pDataArray->m->getFullPathName(pDataArray->filename);
514 pDataArray->alns = pDataArray->m->getFullPathName(pDataArray->alns);
519 int start = time(NULL); if (pDataArray->m->control_pressed) { return 0; }
521 //to allow for spaces in the path
522 string outputFName = "\"" + pDataArray->outputFName + "\"";
523 string filename = "\"" + pDataArray->filename + "\"";
524 string alns = "\"" + pDataArray->alns+ "\"";
525 string templatefile = "\"" + pDataArray->templatefile + "\"";
526 string accnos = pDataArray->accnos;
530 string uchimeCommand = pDataArray->uchimeLocation;
531 uchimeCommand = "\"" + uchimeCommand + "\"";
534 tempUchime= new char[uchimeCommand.length()+1];
536 strncat(tempUchime, uchimeCommand.c_str(), uchimeCommand.length());
537 cPara.push_back(tempUchime);
539 string outputFileName = filename.substr(1, filename.length()-2) + ".uchime_formatted";
540 //prepFile(filename.substr(1, filename.length()-2), outputFileName);
541 //prepFile(filename, outputFileName);
542 /******************************************/
544 pDataArray->m->openInputFile((filename.substr(1, filename.length()-2)), in23);
547 pDataArray->m->openOutputFile(outputFileName, out23);
550 while (!in23.eof()) {
551 if (pDataArray->m->control_pressed) { break; }
553 Sequence seq(in23); pDataArray->m->gobble(in23);
555 if (seq.getName() != "") { seq.printSequence(out23); fcount++; }
559 /******************************************/
561 filename = outputFileName;
562 filename = "\"" + filename + "\"";
565 char* tempRef = new char[5];
566 //strcpy(tempRef, "--db");
567 *tempRef = '\0'; strncat(tempRef, "--db", 4);
568 cPara.push_back(tempRef);
569 char* tempR = new char[templatefile.length()+1];
570 //strcpy(tempR, templatefile.c_str());
571 *tempR = '\0'; strncat(tempR, templatefile.c_str(), templatefile.length());
572 cPara.push_back(tempR);
574 char* tempIn = new char[8];
575 *tempIn = '\0'; strncat(tempIn, "--input", 7);
576 //strcpy(tempIn, "--input");
577 cPara.push_back(tempIn);
578 char* temp = new char[filename.length()+1];
579 *temp = '\0'; strncat(temp, filename.c_str(), filename.length());
580 //strcpy(temp, filename.c_str());
581 cPara.push_back(temp);
583 char* tempO = new char[12];
584 *tempO = '\0'; strncat(tempO, "--uchimeout", 11);
585 //strcpy(tempO, "--uchimeout");
586 cPara.push_back(tempO);
587 char* tempout = new char[outputFName.length()+1];
588 //strcpy(tempout, outputFName.c_str());
589 *tempout = '\0'; strncat(tempout, outputFName.c_str(), outputFName.length());
590 cPara.push_back(tempout);
592 if (pDataArray->chimealns) {
593 char* tempA = new char[13];
594 *tempA = '\0'; strncat(tempA, "--uchimealns", 12);
595 //strcpy(tempA, "--uchimealns");
596 cPara.push_back(tempA);
597 char* tempa = new char[alns.length()+1];
598 //strcpy(tempa, alns.c_str());
599 *tempa = '\0'; strncat(tempa, alns.c_str(), alns.length());
600 cPara.push_back(tempa);
603 if (pDataArray->strand != "") {
604 char* tempA = new char[9];
605 *tempA = '\0'; strncat(tempA, "--strand", 8);
606 cPara.push_back(tempA);
607 char* tempa = new char[pDataArray->strand.length()+1];
608 *tempa = '\0'; strncat(tempa, pDataArray->strand.c_str(), pDataArray->strand.length());
609 cPara.push_back(tempa);
612 if (pDataArray->useAbskew) {
613 char* tempskew = new char[9];
614 *tempskew = '\0'; strncat(tempskew, "--abskew", 8);
615 //strcpy(tempskew, "--abskew");
616 cPara.push_back(tempskew);
617 char* tempSkew = new char[pDataArray->abskew.length()+1];
618 //strcpy(tempSkew, abskew.c_str());
619 *tempSkew = '\0'; strncat(tempSkew, pDataArray->abskew.c_str(), pDataArray->abskew.length());
620 cPara.push_back(tempSkew);
623 if (pDataArray->useMinH) {
624 char* tempminh = new char[7];
625 *tempminh = '\0'; strncat(tempminh, "--minh", 6);
626 //strcpy(tempminh, "--minh");
627 cPara.push_back(tempminh);
628 char* tempMinH = new char[pDataArray->minh.length()+1];
629 *tempMinH = '\0'; strncat(tempMinH, pDataArray->minh.c_str(), pDataArray->minh.length());
630 //strcpy(tempMinH, minh.c_str());
631 cPara.push_back(tempMinH);
634 if (pDataArray->useMindiv) {
635 char* tempmindiv = new char[9];
636 *tempmindiv = '\0'; strncat(tempmindiv, "--mindiv", 8);
637 //strcpy(tempmindiv, "--mindiv");
638 cPara.push_back(tempmindiv);
639 char* tempMindiv = new char[pDataArray->mindiv.length()+1];
640 *tempMindiv = '\0'; strncat(tempMindiv, pDataArray->mindiv.c_str(), pDataArray->mindiv.length());
641 //strcpy(tempMindiv, mindiv.c_str());
642 cPara.push_back(tempMindiv);
645 if (pDataArray->useXn) {
646 char* tempxn = new char[5];
647 //strcpy(tempxn, "--xn");
648 *tempxn = '\0'; strncat(tempxn, "--xn", 4);
649 cPara.push_back(tempxn);
650 char* tempXn = new char[pDataArray->xn.length()+1];
651 //strcpy(tempXn, xn.c_str());
652 *tempXn = '\0'; strncat(tempXn, pDataArray->xn.c_str(), pDataArray->xn.length());
653 cPara.push_back(tempXn);
656 if (pDataArray->useDn) {
657 char* tempdn = new char[5];
658 //strcpy(tempdn, "--dn");
659 *tempdn = '\0'; strncat(tempdn, "--dn", 4);
660 cPara.push_back(tempdn);
661 char* tempDn = new char[pDataArray->dn.length()+1];
662 *tempDn = '\0'; strncat(tempDn, pDataArray->dn.c_str(), pDataArray->dn.length());
663 //strcpy(tempDn, dn.c_str());
664 cPara.push_back(tempDn);
667 if (pDataArray->useXa) {
668 char* tempxa = new char[5];
669 //strcpy(tempxa, "--xa");
670 *tempxa = '\0'; strncat(tempxa, "--xa", 4);
671 cPara.push_back(tempxa);
672 char* tempXa = new char[pDataArray->xa.length()+1];
673 *tempXa = '\0'; strncat(tempXa, pDataArray->xa.c_str(), pDataArray->xa.length());
674 //strcpy(tempXa, xa.c_str());
675 cPara.push_back(tempXa);
678 if (pDataArray->useChunks) {
679 char* tempchunks = new char[9];
680 //strcpy(tempchunks, "--chunks");
681 *tempchunks = '\0'; strncat(tempchunks, "--chunks", 8);
682 cPara.push_back(tempchunks);
683 char* tempChunks = new char[pDataArray->chunks.length()+1];
684 *tempChunks = '\0'; strncat(tempChunks, pDataArray->chunks.c_str(), pDataArray->chunks.length());
685 //strcpy(tempChunks, chunks.c_str());
686 cPara.push_back(tempChunks);
689 if (pDataArray->useMinchunk) {
690 char* tempminchunk = new char[11];
691 //strcpy(tempminchunk, "--minchunk");
692 *tempminchunk = '\0'; strncat(tempminchunk, "--minchunk", 10);
693 cPara.push_back(tempminchunk);
694 char* tempMinchunk = new char[pDataArray->minchunk.length()+1];
695 *tempMinchunk = '\0'; strncat(tempMinchunk, pDataArray->minchunk.c_str(), pDataArray->minchunk.length());
696 //strcpy(tempMinchunk, minchunk.c_str());
697 cPara.push_back(tempMinchunk);
700 if (pDataArray->useIdsmoothwindow) {
701 char* tempidsmoothwindow = new char[17];
702 *tempidsmoothwindow = '\0'; strncat(tempidsmoothwindow, "--idsmoothwindow", 16);
703 //strcpy(tempidsmoothwindow, "--idsmoothwindow");
704 cPara.push_back(tempidsmoothwindow);
705 char* tempIdsmoothwindow = new char[pDataArray->idsmoothwindow.length()+1];
706 *tempIdsmoothwindow = '\0'; strncat(tempIdsmoothwindow, pDataArray->idsmoothwindow.c_str(), pDataArray->idsmoothwindow.length());
707 //strcpy(tempIdsmoothwindow, idsmoothwindow.c_str());
708 cPara.push_back(tempIdsmoothwindow);
711 if (pDataArray->useMaxp) {
712 char* tempmaxp = new char[7];
713 //strcpy(tempmaxp, "--maxp");
714 *tempmaxp = '\0'; strncat(tempmaxp, "--maxp", 6);
715 cPara.push_back(tempmaxp);
716 char* tempMaxp = new char[pDataArray->maxp.length()+1];
717 *tempMaxp = '\0'; strncat(tempMaxp, pDataArray->maxp.c_str(), pDataArray->maxp.length());
718 //strcpy(tempMaxp, maxp.c_str());
719 cPara.push_back(tempMaxp);
722 if (!pDataArray->skipgaps) {
723 char* tempskipgaps = new char[13];
724 //strcpy(tempskipgaps, "--[no]skipgaps");
725 *tempskipgaps = '\0'; strncat(tempskipgaps, "--noskipgaps", 12);
726 cPara.push_back(tempskipgaps);
729 if (!pDataArray->skipgaps2) {
730 char* tempskipgaps2 = new char[14];
731 //strcpy(tempskipgaps2, "--[no]skipgaps2");
732 *tempskipgaps2 = '\0'; strncat(tempskipgaps2, "--noskipgaps2", 13);
733 cPara.push_back(tempskipgaps2);
736 if (pDataArray->useMinlen) {
737 char* tempminlen = new char[9];
738 *tempminlen = '\0'; strncat(tempminlen, "--minlen", 8);
739 //strcpy(tempminlen, "--minlen");
740 cPara.push_back(tempminlen);
741 char* tempMinlen = new char[pDataArray->minlen.length()+1];
742 //strcpy(tempMinlen, minlen.c_str());
743 *tempMinlen = '\0'; strncat(tempMinlen, pDataArray->minlen.c_str(), pDataArray->minlen.length());
744 cPara.push_back(tempMinlen);
747 if (pDataArray->useMaxlen) {
748 char* tempmaxlen = new char[9];
749 //strcpy(tempmaxlen, "--maxlen");
750 *tempmaxlen = '\0'; strncat(tempmaxlen, "--maxlen", 8);
751 cPara.push_back(tempmaxlen);
752 char* tempMaxlen = new char[pDataArray->maxlen.length()+1];
753 *tempMaxlen = '\0'; strncat(tempMaxlen, pDataArray->maxlen.c_str(), pDataArray->maxlen.length());
754 //strcpy(tempMaxlen, maxlen.c_str());
755 cPara.push_back(tempMaxlen);
758 if (pDataArray->ucl) {
759 char* tempucl = new char[5];
760 strcpy(tempucl, "--ucl");
761 cPara.push_back(tempucl);
764 if (pDataArray->useQueryfract) {
765 char* tempqueryfract = new char[13];
766 *tempqueryfract = '\0'; strncat(tempqueryfract, "--queryfract", 12);
767 //strcpy(tempqueryfract, "--queryfract");
768 cPara.push_back(tempqueryfract);
769 char* tempQueryfract = new char[pDataArray->queryfract.length()+1];
770 *tempQueryfract = '\0'; strncat(tempQueryfract, pDataArray->queryfract.c_str(), pDataArray->queryfract.length());
771 //strcpy(tempQueryfract, queryfract.c_str());
772 cPara.push_back(tempQueryfract);
776 char** uchimeParameters;
777 uchimeParameters = new char*[cPara.size()];
778 string commandString = "";
779 for (int j = 0; j < cPara.size(); j++) { uchimeParameters[j] = cPara[j]; commandString += toString(cPara[j]) + " "; }
780 //int numArgs = cPara.size();
782 commandString = "\"" + commandString + "\"";
784 //uchime_main(numArgs, uchimeParameters);
785 //cout << "commandString = " << commandString << endl;
786 if (pDataArray->m->debug) { pDataArray->m->mothurOut("[DEBUG]: uchime command = " + commandString + ".\n"); }
787 system(commandString.c_str());
790 for(int j = 0; j < cPara.size(); j++) { delete cPara[j]; }
791 delete[] uchimeParameters;
793 //remove "" from filenames
794 outputFName = outputFName.substr(1, outputFName.length()-2);
795 filename = filename.substr(1, filename.length()-2);
796 alns = alns.substr(1, alns.length()-2);
798 if (pDataArray->m->control_pressed) { return 0; }
800 //create accnos file from uchime results
802 pDataArray->m->openInputFile(outputFName, in);
805 pDataArray->m->openOutputFile(accnos, out);
810 if (pDataArray->m->control_pressed) { break; }
813 string chimeraFlag = "";
814 in >> chimeraFlag >> name;
816 for (int j = 0; j < 15; j++) { in >> chimeraFlag; }
817 pDataArray->m->gobble(in);
819 if (chimeraFlag == "Y") { out << name << endl; numChimeras++; }
825 if (fcount != totalSeqs) { pDataArray->m->mothurOut("[ERROR]: process " + toString(pDataArray->threadID) + " only processed " + toString(pDataArray->count) + " of " + toString(pDataArray->end) + " sequences assigned to it, quitting. \n"); pDataArray->m->control_pressed = true; }
827 if (pDataArray->m->control_pressed) { return 0; }
829 pDataArray->m->mothurOutEndLine(); pDataArray->m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(totalSeqs) + " sequences."); pDataArray->m->mothurOutEndLine();
831 pDataArray->count = totalSeqs;
832 pDataArray->numChimeras = numChimeras;
837 catch(exception& e) {
838 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeSeqsThreadFunction");
845 /**************************************************************************************************/