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"
18 /***********************************************************/
20 class ChimeraUchimeCommand : public Command {
22 ChimeraUchimeCommand(string);
23 ChimeraUchimeCommand();
24 ~ChimeraUchimeCommand() {}
26 vector<string> setParameters();
27 string getCommandName() { return "chimera.uchime"; }
28 string getCommandCategory() { return "Sequence Processing"; }
29 string getHelpString();
30 string getCitation() { return "uchime by Robert C. Edgar\nhttp://drive5.com/uchime\nThis code is donated to the public domain.\nhttp://www.mothur.org/wiki/Chimera.uchime\nEdgar,R.C., Haas,B.J., Clemente,J.C., Quince,C. and Knight,R. (2011), UCHIME improves sensitivity and speed of chimera detection, Bioinformatics, in press.\n"; }
31 string getDescription() { return "detect chimeric sequences"; }
34 void help() { m->mothurOut(getHelpString()); }
40 linePair(int i, int j) : start(i), end(j) {}
43 vector<int> processIDS; //processid
44 int driver(string, string, string, string, int&);
45 int createProcesses(string, string, string, string, int&);
47 bool abort, useAbskew, chimealns, useMinH, useMindiv, useXn, useDn, useXa, useChunks, useMinchunk, useIdsmoothwindow, useMinsmoothid, useMaxp, skipgaps, skipgaps2, useMinlen, useMaxlen, ucl, useQueryfract;
48 string fastafile, groupfile, templatefile, outputDir, namefile, abskew, minh, mindiv, xn, dn, xa, chunks, minchunk, idsmoothwindow, minsmoothid, maxp, minlen, maxlen, queryfract;
52 vector<string> outputNames;
53 vector<string> fastaFileNames;
54 vector<string> nameFileNames;
55 vector<string> groupFileNames;
57 string getNamesFile(string&);
58 int readFasta(string, map<string, string>&);
59 int printFile(vector<seqPriorityNode>&, string);
60 int deconvoluteResults(SequenceParser&, string, string, string);
61 int driverGroups(SequenceParser&, string, string, string, string, int, int, vector<string>);
62 int createProcessesGroups(SequenceParser&, string, string, string, string, vector<string>, string, string, string);
67 /***********************************************************/
68 /**************************************************************************************************/
69 //custom data structure for threads to use.
70 // This is passed by void pointer so it can be any data type
71 // that can be passed using a single void pointer (LPVOID).
77 string accnos, alns, filename, templatefile;
81 int threadID, count, numChimeras;
82 vector<string> groups;
83 bool useAbskew, chimealns, useMinH, useMindiv, useXn, useDn, useXa, useChunks, useMinchunk, useIdsmoothwindow, useMinsmoothid, useMaxp, skipgaps, skipgaps2, useMinlen, useMaxlen, ucl, useQueryfract;
84 string abskew, minh, mindiv, xn, dn, xa, chunks, minchunk, idsmoothwindow, minsmoothid, maxp, minlen, maxlen, queryfract;
87 uchimeData(string o, 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) {
104 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) {
113 useMinchunk = Minchunk;
114 useIdsmoothwindow = Idsmoothwindow;
115 useMinsmoothid = Minsmoothid;
118 skipgaps2 = skipgap2;
122 useQueryfract = Queryfract;
125 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) {
134 idsmoothwindow = idsmoothwindo;
135 minsmoothid = minsmoothi;
139 queryfract = queryfrac;
143 /**************************************************************************************************/
144 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
146 static DWORD WINAPI MyUchimeThreadFunction(LPVOID lpParam){
147 uchimeData* pDataArray;
148 pDataArray = (uchimeData*)lpParam;
152 pDataArray->outputFName = pDataArray->m->getFullPathName(pDataArray->outputFName);
153 pDataArray->filename = pDataArray->m->getFullPathName(pDataArray->filename);
154 pDataArray->alns = pDataArray->m->getFullPathName(pDataArray->alns);
157 ofstream out, out1, out2;
158 pDataArray->m->openOutputFile(pDataArray->outputFName, out); out.close();
159 pDataArray->m->openOutputFile(pDataArray->accnos, out1); out1.close();
160 if (pDataArray->chimealns) { pDataArray->m->openOutputFile(pDataArray->alns, out2); out2.close(); }
162 //parse fasta and name file by group
163 SequenceParser* parser;
164 if (pDataArray->namefile != "") { parser = new SequenceParser(pDataArray->groupfile, pDataArray->fastafile, pDataArray->namefile); }
165 else { parser = new SequenceParser(pDataArray->groupfile, pDataArray->fastafile); }
170 for (int i = pDataArray->start; i < pDataArray->end; i++) {
171 int start = time(NULL); if (pDataArray->m->control_pressed) { delete parser; return 0; }
173 int error = parser->getSeqs(pDataArray->groups[i], pDataArray->filename, true); if ((error == 1) || pDataArray->m->control_pressed) { delete parser; return 0; }
175 //int numSeqs = driver((outputFName + groups[i]), filename, (accnos+ groups[i]), (alns+ groups[i]), numChimeras);
176 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
178 //to allow for spaces in the path
179 string outputFName = "\"" + pDataArray->outputFName+pDataArray->groups[i] + "\"";
180 string filename = "\"" + pDataArray->filename + "\"";
181 string alns = "\"" + pDataArray->alns+pDataArray->groups[i] + "\"";
182 string accnos = pDataArray->accnos+pDataArray->groups[i];
186 string path = pDataArray->m->argv;
187 string tempPath = path;
188 for (int j = 0; j < path.length(); j++) { tempPath[j] = tolower(path[j]); }
189 path = path.substr(0, (tempPath.find_last_of('m')));
191 string uchimeCommand = path;
192 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
193 uchimeCommand += "uchime ";
195 uchimeCommand += "uchime";
196 uchimeCommand = "\"" + uchimeCommand + "\"";
200 tempUchime= new char[uchimeCommand.length()+1];
202 strncat(tempUchime, uchimeCommand.c_str(), uchimeCommand.length());
203 cPara.push_back(tempUchime);
205 char* tempIn = new char[8];
206 *tempIn = '\0'; strncat(tempIn, "--input", 7);
207 //strcpy(tempIn, "--input");
208 cPara.push_back(tempIn);
209 char* temp = new char[filename.length()+1];
210 *temp = '\0'; strncat(temp, filename.c_str(), filename.length());
211 //strcpy(temp, filename.c_str());
212 cPara.push_back(temp);
214 char* tempO = new char[12];
215 *tempO = '\0'; strncat(tempO, "--uchimeout", 11);
216 //strcpy(tempO, "--uchimeout");
217 cPara.push_back(tempO);
218 char* tempout = new char[outputFName.length()+1];
219 //strcpy(tempout, outputFName.c_str());
220 *tempout = '\0'; strncat(tempout, outputFName.c_str(), outputFName.length());
221 cPara.push_back(tempout);
223 if (pDataArray->chimealns) {
224 char* tempA = new char[13];
225 *tempA = '\0'; strncat(tempA, "--uchimealns", 12);
226 //strcpy(tempA, "--uchimealns");
227 cPara.push_back(tempA);
228 char* tempa = new char[alns.length()+1];
229 //strcpy(tempa, alns.c_str());
230 *tempa = '\0'; strncat(tempa, alns.c_str(), alns.length());
231 cPara.push_back(tempa);
234 if (pDataArray->useAbskew) {
235 char* tempskew = new char[9];
236 *tempskew = '\0'; strncat(tempskew, "--abskew", 8);
237 //strcpy(tempskew, "--abskew");
238 cPara.push_back(tempskew);
239 char* tempSkew = new char[pDataArray->abskew.length()+1];
240 //strcpy(tempSkew, abskew.c_str());
241 *tempSkew = '\0'; strncat(tempSkew, pDataArray->abskew.c_str(), pDataArray->abskew.length());
242 cPara.push_back(tempSkew);
245 if (pDataArray->useMinH) {
246 char* tempminh = new char[7];
247 *tempminh = '\0'; strncat(tempminh, "--minh", 6);
248 //strcpy(tempminh, "--minh");
249 cPara.push_back(tempminh);
250 char* tempMinH = new char[pDataArray->minh.length()+1];
251 *tempMinH = '\0'; strncat(tempMinH, pDataArray->minh.c_str(), pDataArray->minh.length());
252 //strcpy(tempMinH, minh.c_str());
253 cPara.push_back(tempMinH);
256 if (pDataArray->useMindiv) {
257 char* tempmindiv = new char[9];
258 *tempmindiv = '\0'; strncat(tempmindiv, "--mindiv", 8);
259 //strcpy(tempmindiv, "--mindiv");
260 cPara.push_back(tempmindiv);
261 char* tempMindiv = new char[pDataArray->mindiv.length()+1];
262 *tempMindiv = '\0'; strncat(tempMindiv, pDataArray->mindiv.c_str(), pDataArray->mindiv.length());
263 //strcpy(tempMindiv, mindiv.c_str());
264 cPara.push_back(tempMindiv);
267 if (pDataArray->useXn) {
268 char* tempxn = new char[5];
269 //strcpy(tempxn, "--xn");
270 *tempxn = '\0'; strncat(tempxn, "--xn", 4);
271 cPara.push_back(tempxn);
272 char* tempXn = new char[pDataArray->xn.length()+1];
273 //strcpy(tempXn, xn.c_str());
274 *tempXn = '\0'; strncat(tempXn, pDataArray->xn.c_str(), pDataArray->xn.length());
275 cPara.push_back(tempXn);
278 if (pDataArray->useDn) {
279 char* tempdn = new char[5];
280 //strcpy(tempdn, "--dn");
281 *tempdn = '\0'; strncat(tempdn, "--dn", 4);
282 cPara.push_back(tempdn);
283 char* tempDn = new char[pDataArray->dn.length()+1];
284 *tempDn = '\0'; strncat(tempDn, pDataArray->dn.c_str(), pDataArray->dn.length());
285 //strcpy(tempDn, dn.c_str());
286 cPara.push_back(tempDn);
289 if (pDataArray->useXa) {
290 char* tempxa = new char[5];
291 //strcpy(tempxa, "--xa");
292 *tempxa = '\0'; strncat(tempxa, "--xa", 4);
293 cPara.push_back(tempxa);
294 char* tempXa = new char[pDataArray->xa.length()+1];
295 *tempXa = '\0'; strncat(tempXa, pDataArray->xa.c_str(), pDataArray->xa.length());
296 //strcpy(tempXa, xa.c_str());
297 cPara.push_back(tempXa);
300 if (pDataArray->useChunks) {
301 char* tempchunks = new char[9];
302 //strcpy(tempchunks, "--chunks");
303 *tempchunks = '\0'; strncat(tempchunks, "--chunks", 8);
304 cPara.push_back(tempchunks);
305 char* tempChunks = new char[pDataArray->chunks.length()+1];
306 *tempChunks = '\0'; strncat(tempChunks, pDataArray->chunks.c_str(), pDataArray->chunks.length());
307 //strcpy(tempChunks, chunks.c_str());
308 cPara.push_back(tempChunks);
311 if (pDataArray->useMinchunk) {
312 char* tempminchunk = new char[11];
313 //strcpy(tempminchunk, "--minchunk");
314 *tempminchunk = '\0'; strncat(tempminchunk, "--minchunk", 10);
315 cPara.push_back(tempminchunk);
316 char* tempMinchunk = new char[pDataArray->minchunk.length()+1];
317 *tempMinchunk = '\0'; strncat(tempMinchunk, pDataArray->minchunk.c_str(), pDataArray->minchunk.length());
318 //strcpy(tempMinchunk, minchunk.c_str());
319 cPara.push_back(tempMinchunk);
322 if (pDataArray->useIdsmoothwindow) {
323 char* tempidsmoothwindow = new char[17];
324 *tempidsmoothwindow = '\0'; strncat(tempidsmoothwindow, "--idsmoothwindow", 16);
325 //strcpy(tempidsmoothwindow, "--idsmoothwindow");
326 cPara.push_back(tempidsmoothwindow);
327 char* tempIdsmoothwindow = new char[pDataArray->idsmoothwindow.length()+1];
328 *tempIdsmoothwindow = '\0'; strncat(tempIdsmoothwindow, pDataArray->idsmoothwindow.c_str(), pDataArray->idsmoothwindow.length());
329 //strcpy(tempIdsmoothwindow, idsmoothwindow.c_str());
330 cPara.push_back(tempIdsmoothwindow);
333 if (pDataArray->useMaxp) {
334 char* tempmaxp = new char[7];
335 //strcpy(tempmaxp, "--maxp");
336 *tempmaxp = '\0'; strncat(tempmaxp, "--maxp", 6);
337 cPara.push_back(tempmaxp);
338 char* tempMaxp = new char[pDataArray->maxp.length()+1];
339 *tempMaxp = '\0'; strncat(tempMaxp, pDataArray->maxp.c_str(), pDataArray->maxp.length());
340 //strcpy(tempMaxp, maxp.c_str());
341 cPara.push_back(tempMaxp);
344 if (!pDataArray->skipgaps) {
345 char* tempskipgaps = new char[13];
346 //strcpy(tempskipgaps, "--[no]skipgaps");
347 *tempskipgaps = '\0'; strncat(tempskipgaps, "--noskipgaps", 12);
348 cPara.push_back(tempskipgaps);
351 if (!pDataArray->skipgaps2) {
352 char* tempskipgaps2 = new char[14];
353 //strcpy(tempskipgaps2, "--[no]skipgaps2");
354 *tempskipgaps2 = '\0'; strncat(tempskipgaps2, "--noskipgaps2", 13);
355 cPara.push_back(tempskipgaps2);
358 if (pDataArray->useMinlen) {
359 char* tempminlen = new char[9];
360 *tempminlen = '\0'; strncat(tempminlen, "--minlen", 8);
361 //strcpy(tempminlen, "--minlen");
362 cPara.push_back(tempminlen);
363 char* tempMinlen = new char[pDataArray->minlen.length()+1];
364 //strcpy(tempMinlen, minlen.c_str());
365 *tempMinlen = '\0'; strncat(tempMinlen, pDataArray->minlen.c_str(), pDataArray->minlen.length());
366 cPara.push_back(tempMinlen);
369 if (pDataArray->useMaxlen) {
370 char* tempmaxlen = new char[9];
371 //strcpy(tempmaxlen, "--maxlen");
372 *tempmaxlen = '\0'; strncat(tempmaxlen, "--maxlen", 8);
373 cPara.push_back(tempmaxlen);
374 char* tempMaxlen = new char[pDataArray->maxlen.length()+1];
375 *tempMaxlen = '\0'; strncat(tempMaxlen, pDataArray->maxlen.c_str(), pDataArray->maxlen.length());
376 //strcpy(tempMaxlen, maxlen.c_str());
377 cPara.push_back(tempMaxlen);
380 if (pDataArray->ucl) {
381 char* tempucl = new char[5];
382 strcpy(tempucl, "--ucl");
383 cPara.push_back(tempucl);
386 if (pDataArray->useQueryfract) {
387 char* tempqueryfract = new char[13];
388 *tempqueryfract = '\0'; strncat(tempqueryfract, "--queryfract", 12);
389 //strcpy(tempqueryfract, "--queryfract");
390 cPara.push_back(tempqueryfract);
391 char* tempQueryfract = new char[pDataArray->queryfract.length()+1];
392 *tempQueryfract = '\0'; strncat(tempQueryfract, pDataArray->queryfract.c_str(), pDataArray->queryfract.length());
393 //strcpy(tempQueryfract, queryfract.c_str());
394 cPara.push_back(tempQueryfract);
398 char** uchimeParameters;
399 uchimeParameters = new char*[cPara.size()];
400 string commandString = "";
401 for (int j = 0; j < cPara.size(); j++) { uchimeParameters[j] = cPara[j]; commandString += toString(cPara[j]) + " "; }
402 //int numArgs = cPara.size();
404 //uchime_main(numArgs, uchimeParameters);
405 //cout << "commandString = " << commandString << endl;
406 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
408 commandString = "\"" + commandString + "\"";
410 system(commandString.c_str());
413 for(int j = 0; j < cPara.size(); j++) { delete cPara[j]; }
414 delete[] uchimeParameters;
416 //remove "" from filenames
417 outputFName = outputFName.substr(1, outputFName.length()-2);
418 filename = filename.substr(1, filename.length()-2);
419 alns = alns.substr(1, alns.length()-2);
421 if (pDataArray->m->control_pressed) { delete parser; return 0; }
423 //create accnos file from uchime results
425 pDataArray->m->openInputFile(outputFName, in);
428 pDataArray->m->openOutputFile(accnos, out);
434 if (pDataArray->m->control_pressed) { break; }
437 string chimeraFlag = "";
438 in >> chimeraFlag >> name;
441 name = name.substr(0, name.length()-1); //rip off last /
442 name = name.substr(0, name.find_last_of('/'));
444 for (int j = 0; j < 15; j++) { in >> chimeraFlag; }
445 pDataArray->m->gobble(in);
447 if (chimeraFlag == "Y") { out << name << endl; numChimeras++; }
454 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
456 pDataArray->numChimeras += numChimeras;
458 if (pDataArray->m->control_pressed) { delete parser; return 0; }
460 //remove file made for uchime
461 pDataArray->m->mothurRemove(filename);
464 pDataArray->m->appendFiles(outputFName, pDataArray->outputFName); pDataArray->m->mothurRemove(outputFName);
465 pDataArray->m->appendFiles(accnos, pDataArray->accnos); pDataArray->m->mothurRemove(accnos);
466 if (pDataArray->chimealns) { pDataArray->m->appendFiles(alns, pDataArray->alns); pDataArray->m->mothurRemove(alns); }
468 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();
472 pDataArray->count = totalSeqs;
477 catch(exception& e) {
478 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeThreadFunction");
482 /**************************************************************************************************/
484 static DWORD WINAPI MyUchimeSeqsThreadFunction(LPVOID lpParam){
485 uchimeData* pDataArray;
486 pDataArray = (uchimeData*)lpParam;
490 pDataArray->outputFName = pDataArray->m->getFullPathName(pDataArray->outputFName);
491 pDataArray->filename = pDataArray->m->getFullPathName(pDataArray->filename);
492 pDataArray->alns = pDataArray->m->getFullPathName(pDataArray->alns);
497 int start = time(NULL); if (pDataArray->m->control_pressed) { return 0; }
499 //to allow for spaces in the path
500 string outputFName = "\"" + pDataArray->outputFName + "\"";
501 string filename = "\"" + pDataArray->filename + "\"";
502 string alns = "\"" + pDataArray->alns+ "\"";
503 string templatefile = "\"" + pDataArray->templatefile + "\"";
504 string accnos = pDataArray->accnos;
509 tempUchime= new char[8];
511 strncat(tempUchime, "uchime ", 7);
512 cPara.push_back(tempUchime);
514 char* tempIn = new char[8];
515 *tempIn = '\0'; strncat(tempIn, "--input", 7);
516 //strcpy(tempIn, "--input");
517 cPara.push_back(tempIn);
518 char* temp = new char[filename.length()+1];
519 *temp = '\0'; strncat(temp, filename.c_str(), filename.length());
520 //strcpy(temp, filename.c_str());
521 cPara.push_back(temp);
524 char* tempRef = new char[5];
525 //strcpy(tempRef, "--db");
526 *tempRef = '\0'; strncat(tempRef, "--db", 4);
527 cPara.push_back(tempRef);
528 char* tempR = new char[templatefile.length()+1];
529 //strcpy(tempR, templatefile.c_str());
530 *tempR = '\0'; strncat(tempR, templatefile.c_str(), templatefile.length());
531 cPara.push_back(tempR);
533 char* tempO = new char[12];
534 *tempO = '\0'; strncat(tempO, "--uchimeout", 11);
535 //strcpy(tempO, "--uchimeout");
536 cPara.push_back(tempO);
537 char* tempout = new char[outputFName.length()+1];
538 //strcpy(tempout, outputFName.c_str());
539 *tempout = '\0'; strncat(tempout, outputFName.c_str(), outputFName.length());
540 cPara.push_back(tempout);
542 if (pDataArray->chimealns) {
543 char* tempA = new char[13];
544 *tempA = '\0'; strncat(tempA, "--uchimealns", 12);
545 //strcpy(tempA, "--uchimealns");
546 cPara.push_back(tempA);
547 char* tempa = new char[alns.length()+1];
548 //strcpy(tempa, alns.c_str());
549 *tempa = '\0'; strncat(tempa, alns.c_str(), alns.length());
550 cPara.push_back(tempa);
553 if (pDataArray->useAbskew) {
554 char* tempskew = new char[9];
555 *tempskew = '\0'; strncat(tempskew, "--abskew", 8);
556 //strcpy(tempskew, "--abskew");
557 cPara.push_back(tempskew);
558 char* tempSkew = new char[pDataArray->abskew.length()+1];
559 //strcpy(tempSkew, abskew.c_str());
560 *tempSkew = '\0'; strncat(tempSkew, pDataArray->abskew.c_str(), pDataArray->abskew.length());
561 cPara.push_back(tempSkew);
564 if (pDataArray->useMinH) {
565 char* tempminh = new char[7];
566 *tempminh = '\0'; strncat(tempminh, "--minh", 6);
567 //strcpy(tempminh, "--minh");
568 cPara.push_back(tempminh);
569 char* tempMinH = new char[pDataArray->minh.length()+1];
570 *tempMinH = '\0'; strncat(tempMinH, pDataArray->minh.c_str(), pDataArray->minh.length());
571 //strcpy(tempMinH, minh.c_str());
572 cPara.push_back(tempMinH);
575 if (pDataArray->useMindiv) {
576 char* tempmindiv = new char[9];
577 *tempmindiv = '\0'; strncat(tempmindiv, "--mindiv", 8);
578 //strcpy(tempmindiv, "--mindiv");
579 cPara.push_back(tempmindiv);
580 char* tempMindiv = new char[pDataArray->mindiv.length()+1];
581 *tempMindiv = '\0'; strncat(tempMindiv, pDataArray->mindiv.c_str(), pDataArray->mindiv.length());
582 //strcpy(tempMindiv, mindiv.c_str());
583 cPara.push_back(tempMindiv);
586 if (pDataArray->useXn) {
587 char* tempxn = new char[5];
588 //strcpy(tempxn, "--xn");
589 *tempxn = '\0'; strncat(tempxn, "--xn", 4);
590 cPara.push_back(tempxn);
591 char* tempXn = new char[pDataArray->xn.length()+1];
592 //strcpy(tempXn, xn.c_str());
593 *tempXn = '\0'; strncat(tempXn, pDataArray->xn.c_str(), pDataArray->xn.length());
594 cPara.push_back(tempXn);
597 if (pDataArray->useDn) {
598 char* tempdn = new char[5];
599 //strcpy(tempdn, "--dn");
600 *tempdn = '\0'; strncat(tempdn, "--dn", 4);
601 cPara.push_back(tempdn);
602 char* tempDn = new char[pDataArray->dn.length()+1];
603 *tempDn = '\0'; strncat(tempDn, pDataArray->dn.c_str(), pDataArray->dn.length());
604 //strcpy(tempDn, dn.c_str());
605 cPara.push_back(tempDn);
608 if (pDataArray->useXa) {
609 char* tempxa = new char[5];
610 //strcpy(tempxa, "--xa");
611 *tempxa = '\0'; strncat(tempxa, "--xa", 4);
612 cPara.push_back(tempxa);
613 char* tempXa = new char[pDataArray->xa.length()+1];
614 *tempXa = '\0'; strncat(tempXa, pDataArray->xa.c_str(), pDataArray->xa.length());
615 //strcpy(tempXa, xa.c_str());
616 cPara.push_back(tempXa);
619 if (pDataArray->useChunks) {
620 char* tempchunks = new char[9];
621 //strcpy(tempchunks, "--chunks");
622 *tempchunks = '\0'; strncat(tempchunks, "--chunks", 8);
623 cPara.push_back(tempchunks);
624 char* tempChunks = new char[pDataArray->chunks.length()+1];
625 *tempChunks = '\0'; strncat(tempChunks, pDataArray->chunks.c_str(), pDataArray->chunks.length());
626 //strcpy(tempChunks, chunks.c_str());
627 cPara.push_back(tempChunks);
630 if (pDataArray->useMinchunk) {
631 char* tempminchunk = new char[11];
632 //strcpy(tempminchunk, "--minchunk");
633 *tempminchunk = '\0'; strncat(tempminchunk, "--minchunk", 10);
634 cPara.push_back(tempminchunk);
635 char* tempMinchunk = new char[pDataArray->minchunk.length()+1];
636 *tempMinchunk = '\0'; strncat(tempMinchunk, pDataArray->minchunk.c_str(), pDataArray->minchunk.length());
637 //strcpy(tempMinchunk, minchunk.c_str());
638 cPara.push_back(tempMinchunk);
641 if (pDataArray->useIdsmoothwindow) {
642 char* tempidsmoothwindow = new char[17];
643 *tempidsmoothwindow = '\0'; strncat(tempidsmoothwindow, "--idsmoothwindow", 16);
644 //strcpy(tempidsmoothwindow, "--idsmoothwindow");
645 cPara.push_back(tempidsmoothwindow);
646 char* tempIdsmoothwindow = new char[pDataArray->idsmoothwindow.length()+1];
647 *tempIdsmoothwindow = '\0'; strncat(tempIdsmoothwindow, pDataArray->idsmoothwindow.c_str(), pDataArray->idsmoothwindow.length());
648 //strcpy(tempIdsmoothwindow, idsmoothwindow.c_str());
649 cPara.push_back(tempIdsmoothwindow);
652 if (pDataArray->useMaxp) {
653 char* tempmaxp = new char[7];
654 //strcpy(tempmaxp, "--maxp");
655 *tempmaxp = '\0'; strncat(tempmaxp, "--maxp", 6);
656 cPara.push_back(tempmaxp);
657 char* tempMaxp = new char[pDataArray->maxp.length()+1];
658 *tempMaxp = '\0'; strncat(tempMaxp, pDataArray->maxp.c_str(), pDataArray->maxp.length());
659 //strcpy(tempMaxp, maxp.c_str());
660 cPara.push_back(tempMaxp);
663 if (!pDataArray->skipgaps) {
664 char* tempskipgaps = new char[13];
665 //strcpy(tempskipgaps, "--[no]skipgaps");
666 *tempskipgaps = '\0'; strncat(tempskipgaps, "--noskipgaps", 12);
667 cPara.push_back(tempskipgaps);
670 if (!pDataArray->skipgaps2) {
671 char* tempskipgaps2 = new char[14];
672 //strcpy(tempskipgaps2, "--[no]skipgaps2");
673 *tempskipgaps2 = '\0'; strncat(tempskipgaps2, "--noskipgaps2", 13);
674 cPara.push_back(tempskipgaps2);
677 if (pDataArray->useMinlen) {
678 char* tempminlen = new char[9];
679 *tempminlen = '\0'; strncat(tempminlen, "--minlen", 8);
680 //strcpy(tempminlen, "--minlen");
681 cPara.push_back(tempminlen);
682 char* tempMinlen = new char[pDataArray->minlen.length()+1];
683 //strcpy(tempMinlen, minlen.c_str());
684 *tempMinlen = '\0'; strncat(tempMinlen, pDataArray->minlen.c_str(), pDataArray->minlen.length());
685 cPara.push_back(tempMinlen);
688 if (pDataArray->useMaxlen) {
689 char* tempmaxlen = new char[9];
690 //strcpy(tempmaxlen, "--maxlen");
691 *tempmaxlen = '\0'; strncat(tempmaxlen, "--maxlen", 8);
692 cPara.push_back(tempmaxlen);
693 char* tempMaxlen = new char[pDataArray->maxlen.length()+1];
694 *tempMaxlen = '\0'; strncat(tempMaxlen, pDataArray->maxlen.c_str(), pDataArray->maxlen.length());
695 //strcpy(tempMaxlen, maxlen.c_str());
696 cPara.push_back(tempMaxlen);
699 if (pDataArray->ucl) {
700 char* tempucl = new char[5];
701 strcpy(tempucl, "--ucl");
702 cPara.push_back(tempucl);
705 if (pDataArray->useQueryfract) {
706 char* tempqueryfract = new char[13];
707 *tempqueryfract = '\0'; strncat(tempqueryfract, "--queryfract", 12);
708 //strcpy(tempqueryfract, "--queryfract");
709 cPara.push_back(tempqueryfract);
710 char* tempQueryfract = new char[pDataArray->queryfract.length()+1];
711 *tempQueryfract = '\0'; strncat(tempQueryfract, pDataArray->queryfract.c_str(), pDataArray->queryfract.length());
712 //strcpy(tempQueryfract, queryfract.c_str());
713 cPara.push_back(tempQueryfract);
717 char** uchimeParameters;
718 uchimeParameters = new char*[cPara.size()];
719 string commandString = "";
720 for (int j = 0; j < cPara.size(); j++) { uchimeParameters[j] = cPara[j]; commandString += toString(cPara[j]) + " "; }
721 //int numArgs = cPara.size();
723 //uchime_main(numArgs, uchimeParameters);
724 //cout << "commandString = " << commandString << endl;
725 system(commandString.c_str());
728 for(int j = 0; j < cPara.size(); j++) { delete cPara[j]; }
729 delete[] uchimeParameters;
731 //remove "" from filenames
732 outputFName = outputFName.substr(1, outputFName.length()-2);
733 filename = filename.substr(1, filename.length()-2);
734 alns = alns.substr(1, alns.length()-2);
736 if (pDataArray->m->control_pressed) { return 0; }
738 //create accnos file from uchime results
740 pDataArray->m->openInputFile(outputFName, in);
743 pDataArray->m->openOutputFile(accnos, out);
748 if (pDataArray->m->control_pressed) { break; }
751 string chimeraFlag = "";
752 in >> chimeraFlag >> name;
754 for (int j = 0; j < 15; j++) { in >> chimeraFlag; }
755 pDataArray->m->gobble(in);
757 if (chimeraFlag == "Y") { out << name << endl; numChimeras++; }
763 if (pDataArray->m->control_pressed) { return 0; }
765 pDataArray->m->mothurOutEndLine(); pDataArray->m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(totalSeqs) + " sequences."); pDataArray->m->mothurOutEndLine();
767 pDataArray->count = totalSeqs;
768 pDataArray->numChimeras = numChimeras;
772 catch(exception& e) {
773 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeSeqsThreadFunction");
780 /**************************************************************************************************/