chimerauchimecommand.h

   1 #ifndef CHIMERAUCHIMECOMMAND_H
   2 #define CHIMERAUCHIMECOMMAND_H
   3
   4
   5 /*
   6  *  chimerauchimecommand.h
   7  *  Mothur
   8  *
   9  *  Created by westcott on 5/13/11.
  10  *  Copyright 2011 Schloss Lab. All rights reserved.
  11  *
  12  */
  13
  14 #include "mothur.h"
  15 #include "command.hpp"
  16 #include "sequenceparser.h"
  17
  18 /***********************************************************/
  19
  20 class ChimeraUchimeCommand : public Command {
  21 public:
  22         ChimeraUchimeCommand(string);
  23         ChimeraUchimeCommand();
  24         ~ChimeraUchimeCommand() {}
  25
  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"; }
  32
  33         int execute();
  34         void help() { m->mothurOut(getHelpString()); }
  35
  36 private:
  37         struct linePair {
  38                 int start;
  39                 int end;
  40                 linePair(int i, int j) : start(i), end(j) {}
  41         };
  42
  43         vector<int> processIDS;   //processid
  44         int driver(string, string, string, string, int&);
  45         int createProcesses(string, string, string, string, int&);
  46
  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;
  49         int processors;
  50
  51         vector<string> outputNames;
  52         vector<string> fastaFileNames;
  53         vector<string> nameFileNames;
  54         vector<string> groupFileNames;
  55
  56         string getNamesFile(string&);
  57         int readFasta(string, map<string, string>&);
  58         int printFile(vector<seqPriorityNode>&, string);
  59         int deconvoluteResults(SequenceParser&, string, string, string);
  60         int driverGroups(SequenceParser&, string, string, string, string, int, int, vector<string>);
  61         int createProcessesGroups(SequenceParser&, string, string, string, string, vector<string>);
  62
  63
  64 };
  65
  66 /***********************************************************/
  67 /**************************************************************************************************/
  68 //custom data structure for threads to use.
  69 // This is passed by void pointer so it can be any data type
  70 // that can be passed using a single void pointer (LPVOID).
  71 struct uchimeData {
  72         string fastafile;
  73         string namefile;
  74         string groupfile;
  75         string outputFName;
  76         string accnos, alns, filename, templatefile;
  77         MothurOut* m;
  78         int start;
  79         int end;
  80         int threadID, count, numChimeras;
  81         vector<string> groups;
  82         bool useAbskew, chimealns, useMinH, useMindiv, useXn, useDn, useXa, useChunks, useMinchunk, useIdsmoothwindow, useMinsmoothid, useMaxp, skipgaps, skipgaps2, useMinlen, useMaxlen, ucl, useQueryfract;
  83         string abskew, minh, mindiv, xn, dn, xa, chunks, minchunk, idsmoothwindow, minsmoothid, maxp, minlen, maxlen, queryfract;
  84
  85         uchimeData(){}
  86         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) {
  87                 fastafile = f;
  88                 namefile = n;
  89                 groupfile = g;
  90                 filename = file;
  91                 outputFName = o;
  92                 templatefile = t;
  93                 accnos = ac;
  94                 alns = al;
  95                 m = mout;
  96                 start = st;
  97                 end = en;
  98                 threadID = tid;
  99                 groups = gr;
 100                 count = 0;
 101                 numChimeras = 0;
 102         }
 103         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) {
 104                 useAbskew = Abskew;
 105                 chimealns = calns;
 106                 useMinH = MinH;
 107                 useMindiv = Mindiv;
 108                 useXn = Xn;
 109                 useDn = Dn;
 110                 useXa = Xa;
 111                 useChunks = Chunks;
 112                 useMinchunk = Minchunk;
 113                 useIdsmoothwindow = Idsmoothwindow;
 114                 useMinsmoothid = Minsmoothid;
 115                 useMaxp = Maxp;
 116                 skipgaps = skipgap;
 117                 skipgaps2 = skipgap2;
 118                 useMinlen = Minlen;
 119                 useMaxlen = Maxlen;
 120                 ucl = uc;
 121                 useQueryfract = Queryfract;
 122         }
 123
 124         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) {
 125                 abskew = abske;
 126                 minh = min;
 127                 mindiv = mindi;
 128                 xn = x;
 129                 dn = d;
 130                 xa = xa2;
 131                 chunks = chunk;
 132                 minchunk = minchun;
 133                 idsmoothwindow = idsmoothwindo;
 134                 minsmoothid = minsmoothi;
 135                 maxp = max;
 136                 minlen = minle;
 137                 maxlen = maxle;
 138                 queryfract = queryfrac;
 139         }
 140 };
 141
 142 /**************************************************************************************************/
 143 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
 144 #else
 145 static DWORD WINAPI MyUchimeThreadFunction(LPVOID lpParam){
 146         uchimeData* pDataArray;
 147         pDataArray = (uchimeData*)lpParam;
 148
 149         try {
 150
 151                 //clears files
 152                 ofstream out, out1, out2;
 153                 pDataArray->m->openOutputFile(pDataArray->outputFName, out); out.close();
 154                 pDataArray->m->openOutputFile(pDataArray->accnos, out1); out1.close();
 155                 if (pDataArray->chimealns) { pDataArray->m->openOutputFile(pDataArray->alns, out2); out2.close(); }
 156
 157                 //parse fasta and name file by group
 158                 SequenceParser* parser;
 159                 if (pDataArray->namefile != "") { parser = new SequenceParser(pDataArray->groupfile, pDataArray->fastafile, pDataArray->namefile);      }
 160                 else                                                    { parser = new SequenceParser(pDataArray->groupfile, pDataArray->fastafile);                                            }
 161
 162                 int totalSeqs = 0;
 163                 int numChimeras = 0;
 164
 165                 for (int i = pDataArray->start; i < pDataArray->end; i++) {
 166                         int start = time(NULL);  if (pDataArray->m->control_pressed) {  delete parser; return 0; }
 167
 168                         int error = parser->getSeqs(pDataArray->groups[i], pDataArray->filename, true); if ((error == 1) || pDataArray->m->control_pressed) {  delete parser; return 0; }
 169
 170                         //int numSeqs = driver((outputFName + groups[i]), filename, (accnos+ groups[i]), (alns+ groups[i]), numChimeras);
 171                         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 172
 173                         //to allow for spaces in the path
 174                         string outputFName = "\"" + pDataArray->outputFName+pDataArray->groups[i] + "\"";
 175                         string filename = "\"" + pDataArray->filename + "\"";
 176                         string alns = "\"" + pDataArray->alns+pDataArray->groups[i] + "\"";
 177                         string accnos = pDataArray->accnos+pDataArray->groups[i];
 178
 179                         vector<char*> cPara;
 180
 181                         char* tempUchime;
 182                         tempUchime= new char[8];
 183                         *tempUchime = '\0';
 184                         strncat(tempUchime, "uchime ", 7);
 185                         cPara.push_back(tempUchime);
 186
 187                         char* tempIn = new char[8];
 188                         *tempIn = '\0'; strncat(tempIn, "--input", 7);
 189                         //strcpy(tempIn, "--input");
 190                         cPara.push_back(tempIn);
 191                         char* temp = new char[filename.length()+1];
 192                         *temp = '\0'; strncat(temp, filename.c_str(), filename.length());
 193                         //strcpy(temp, filename.c_str());
 194                         cPara.push_back(temp);
 195
 196                         char* tempO = new char[12];
 197                         *tempO = '\0'; strncat(tempO, "--uchimeout", 11);
 198                         //strcpy(tempO, "--uchimeout");
 199                         cPara.push_back(tempO);
 200                         char* tempout = new char[outputFName.length()+1];
 201                         //strcpy(tempout, outputFName.c_str());
 202                         *tempout = '\0'; strncat(tempout, outputFName.c_str(), outputFName.length());
 203                         cPara.push_back(tempout);
 204
 205                         if (pDataArray->chimealns) {
 206                                 char* tempA = new char[13];
 207                                 *tempA = '\0'; strncat(tempA, "--uchimealns", 12);
 208                                 //strcpy(tempA, "--uchimealns");
 209                                 cPara.push_back(tempA);
 210                                 char* tempa = new char[alns.length()+1];
 211                                 //strcpy(tempa, alns.c_str());
 212                                 *tempa = '\0'; strncat(tempa, alns.c_str(), alns.length());
 213                                 cPara.push_back(tempa);
 214                         }
 215
 216                         if (pDataArray->useAbskew) {
 217                                 char* tempskew = new char[9];
 218                                 *tempskew = '\0'; strncat(tempskew, "--abskew", 8);
 219                                 //strcpy(tempskew, "--abskew");
 220                                 cPara.push_back(tempskew);
 221                                 char* tempSkew = new char[pDataArray->abskew.length()+1];
 222                                 //strcpy(tempSkew, abskew.c_str());
 223                                 *tempSkew = '\0'; strncat(tempSkew, pDataArray->abskew.c_str(), pDataArray->abskew.length());
 224                                 cPara.push_back(tempSkew);
 225                         }
 226
 227                         if (pDataArray->useMinH) {
 228                                 char* tempminh = new char[7];
 229                                 *tempminh = '\0'; strncat(tempminh, "--minh", 6);
 230                                 //strcpy(tempminh, "--minh");
 231                                 cPara.push_back(tempminh);
 232                                 char* tempMinH = new char[pDataArray->minh.length()+1];
 233                                 *tempMinH = '\0'; strncat(tempMinH, pDataArray->minh.c_str(), pDataArray->minh.length());
 234                                 //strcpy(tempMinH, minh.c_str());
 235                                 cPara.push_back(tempMinH);
 236                         }
 237
 238                         if (pDataArray->useMindiv) {
 239                                 char* tempmindiv = new char[9];
 240                                 *tempmindiv = '\0'; strncat(tempmindiv, "--mindiv", 8);
 241                                 //strcpy(tempmindiv, "--mindiv");
 242                                 cPara.push_back(tempmindiv);
 243                                 char* tempMindiv = new char[pDataArray->mindiv.length()+1];
 244                                 *tempMindiv = '\0'; strncat(tempMindiv, pDataArray->mindiv.c_str(), pDataArray->mindiv.length());
 245                                 //strcpy(tempMindiv, mindiv.c_str());
 246                                 cPara.push_back(tempMindiv);
 247                         }
 248
 249                         if (pDataArray->useXn) {
 250                                 char* tempxn = new char[5];
 251                                 //strcpy(tempxn, "--xn");
 252                                 *tempxn = '\0'; strncat(tempxn, "--xn", 4);
 253                                 cPara.push_back(tempxn);
 254                                 char* tempXn = new char[pDataArray->xn.length()+1];
 255                                 //strcpy(tempXn, xn.c_str());
 256                                 *tempXn = '\0'; strncat(tempXn, pDataArray->xn.c_str(), pDataArray->xn.length());
 257                                 cPara.push_back(tempXn);
 258                         }
 259
 260                         if (pDataArray->useDn) {
 261                                 char* tempdn = new char[5];
 262                                 //strcpy(tempdn, "--dn");
 263                                 *tempdn = '\0'; strncat(tempdn, "--dn", 4);
 264                                 cPara.push_back(tempdn);
 265                                 char* tempDn = new char[pDataArray->dn.length()+1];
 266                                 *tempDn = '\0'; strncat(tempDn, pDataArray->dn.c_str(), pDataArray->dn.length());
 267                                 //strcpy(tempDn, dn.c_str());
 268                                 cPara.push_back(tempDn);
 269                         }
 270
 271                         if (pDataArray->useXa) {
 272                                 char* tempxa = new char[5];
 273                                 //strcpy(tempxa, "--xa");
 274                                 *tempxa = '\0'; strncat(tempxa, "--xa", 4);
 275                                 cPara.push_back(tempxa);
 276                                 char* tempXa = new char[pDataArray->xa.length()+1];
 277                                 *tempXa = '\0'; strncat(tempXa, pDataArray->xa.c_str(), pDataArray->xa.length());
 278                                 //strcpy(tempXa, xa.c_str());
 279                                 cPara.push_back(tempXa);
 280                         }
 281
 282                         if (pDataArray->useChunks) {
 283                                 char* tempchunks = new char[9];
 284                                 //strcpy(tempchunks, "--chunks");
 285                                 *tempchunks = '\0'; strncat(tempchunks, "--chunks", 8);
 286                                 cPara.push_back(tempchunks);
 287                                 char* tempChunks = new char[pDataArray->chunks.length()+1];
 288                                 *tempChunks = '\0'; strncat(tempChunks, pDataArray->chunks.c_str(), pDataArray->chunks.length());
 289                                 //strcpy(tempChunks, chunks.c_str());
 290                                 cPara.push_back(tempChunks);
 291                         }
 292
 293                         if (pDataArray->useMinchunk) {
 294                                 char* tempminchunk = new char[11];
 295                                 //strcpy(tempminchunk, "--minchunk");
 296                                 *tempminchunk = '\0'; strncat(tempminchunk, "--minchunk", 10);
 297                                 cPara.push_back(tempminchunk);
 298                                 char* tempMinchunk = new char[pDataArray->minchunk.length()+1];
 299                                 *tempMinchunk = '\0'; strncat(tempMinchunk, pDataArray->minchunk.c_str(), pDataArray->minchunk.length());
 300                                 //strcpy(tempMinchunk, minchunk.c_str());
 301                                 cPara.push_back(tempMinchunk);
 302                         }
 303
 304                         if (pDataArray->useIdsmoothwindow) {
 305                                 char* tempidsmoothwindow = new char[17];
 306                                 *tempidsmoothwindow = '\0'; strncat(tempidsmoothwindow, "--idsmoothwindow", 16);
 307                                 //strcpy(tempidsmoothwindow, "--idsmoothwindow");
 308                                 cPara.push_back(tempidsmoothwindow);
 309                                 char* tempIdsmoothwindow = new char[pDataArray->idsmoothwindow.length()+1];
 310                                 *tempIdsmoothwindow = '\0'; strncat(tempIdsmoothwindow, pDataArray->idsmoothwindow.c_str(), pDataArray->idsmoothwindow.length());
 311                                 //strcpy(tempIdsmoothwindow, idsmoothwindow.c_str());
 312                                 cPara.push_back(tempIdsmoothwindow);
 313                         }
 314
 315                         /*if (useMinsmoothid) {
 316                          char* tempminsmoothid = new char[14];
 317                          //strcpy(tempminsmoothid, "--minsmoothid");
 318                          *tempminsmoothid = '\0'; strncat(tempminsmoothid, "--minsmoothid", 13);
 319                          cPara.push_back(tempminsmoothid);
 320                          char* tempMinsmoothid = new char[minsmoothid.length()+1];
 321                          *tempMinsmoothid = '\0'; strncat(tempMinsmoothid, minsmoothid.c_str(), minsmoothid.length());
 322                          //strcpy(tempMinsmoothid, minsmoothid.c_str());
 323                          cPara.push_back(tempMinsmoothid);
 324                          }*/
 325
 326                         if (pDataArray->useMaxp) {
 327                                 char* tempmaxp = new char[7];
 328                                 //strcpy(tempmaxp, "--maxp");
 329                                 *tempmaxp = '\0'; strncat(tempmaxp, "--maxp", 6);
 330                                 cPara.push_back(tempmaxp);
 331                                 char* tempMaxp = new char[pDataArray->maxp.length()+1];
 332                                 *tempMaxp = '\0'; strncat(tempMaxp, pDataArray->maxp.c_str(), pDataArray->maxp.length());
 333                                 //strcpy(tempMaxp, maxp.c_str());
 334                                 cPara.push_back(tempMaxp);
 335                         }
 336
 337                         if (!pDataArray->skipgaps) {
 338                                 char* tempskipgaps = new char[13];
 339                                 //strcpy(tempskipgaps, "--[no]skipgaps");
 340                                 *tempskipgaps = '\0'; strncat(tempskipgaps, "--noskipgaps", 12);
 341                                 cPara.push_back(tempskipgaps);
 342                         }
 343
 344                         if (!pDataArray->skipgaps2) {
 345                                 char* tempskipgaps2 = new char[14];
 346                                 //strcpy(tempskipgaps2, "--[no]skipgaps2");
 347                                 *tempskipgaps2 = '\0'; strncat(tempskipgaps2, "--noskipgaps2", 13);
 348                                 cPara.push_back(tempskipgaps2);
 349                         }
 350
 351                         if (pDataArray->useMinlen) {
 352                                 char* tempminlen = new char[9];
 353                                 *tempminlen = '\0'; strncat(tempminlen, "--minlen", 8);
 354                                 //strcpy(tempminlen, "--minlen");
 355                                 cPara.push_back(tempminlen);
 356                                 char* tempMinlen = new char[pDataArray->minlen.length()+1];
 357                                 //strcpy(tempMinlen, minlen.c_str());
 358                                 *tempMinlen = '\0'; strncat(tempMinlen, pDataArray->minlen.c_str(), pDataArray->minlen.length());
 359                                 cPara.push_back(tempMinlen);
 360                         }
 361
 362                         if (pDataArray->useMaxlen) {
 363                                 char* tempmaxlen = new char[9];
 364                                 //strcpy(tempmaxlen, "--maxlen");
 365                                 *tempmaxlen = '\0'; strncat(tempmaxlen, "--maxlen", 8);
 366                                 cPara.push_back(tempmaxlen);
 367                                 char* tempMaxlen = new char[pDataArray->maxlen.length()+1];
 368                                 *tempMaxlen = '\0'; strncat(tempMaxlen, pDataArray->maxlen.c_str(), pDataArray->maxlen.length());
 369                                 //strcpy(tempMaxlen, maxlen.c_str());
 370                                 cPara.push_back(tempMaxlen);
 371                         }
 372
 373                         if (pDataArray->ucl) {
 374                                 char* tempucl = new char[5];
 375                                 strcpy(tempucl, "--ucl");
 376                                 cPara.push_back(tempucl);
 377                         }
 378
 379                         if (pDataArray->useQueryfract) {
 380                                 char* tempqueryfract = new char[13];
 381                                 *tempqueryfract = '\0'; strncat(tempqueryfract, "--queryfract", 12);
 382                                 //strcpy(tempqueryfract, "--queryfract");
 383                                 cPara.push_back(tempqueryfract);
 384                                 char* tempQueryfract = new char[pDataArray->queryfract.length()+1];
 385                                 *tempQueryfract = '\0'; strncat(tempQueryfract, pDataArray->queryfract.c_str(), pDataArray->queryfract.length());
 386                                 //strcpy(tempQueryfract, queryfract.c_str());
 387                                 cPara.push_back(tempQueryfract);
 388                         }
 389
 390
 391                         char** uchimeParameters;
 392                         uchimeParameters = new char*[cPara.size()];
 393                         string commandString = "";
 394                         for (int j = 0; j < cPara.size(); j++) {  uchimeParameters[j] = cPara[j];  commandString += toString(cPara[j]) + " "; }
 395                         //int numArgs = cPara.size();
 396
 397                         //uchime_main(numArgs, uchimeParameters);
 398                         //cout << "commandString = " << commandString << endl;
 399                         system(commandString.c_str());
 400
 401                         //free memory
 402                         for(int j = 0; j < cPara.size(); j++)  {  delete cPara[j];  }
 403                         delete[] uchimeParameters;
 404
 405                         //remove "" from filenames
 406                         outputFName = outputFName.substr(1, outputFName.length()-2);
 407                         filename = filename.substr(1, filename.length()-2);
 408                         alns = alns.substr(1, alns.length()-2);
 409
 410                         if (pDataArray->m->control_pressed) { delete parser; return 0; }
 411
 412                         //create accnos file from uchime results
 413                         ifstream in;
 414                         pDataArray->m->openInputFile(outputFName, in);
 415
 416                         ofstream out;
 417                         pDataArray->m->openOutputFile(accnos, out);
 418
 419                         int num = 0;
 420                         numChimeras = 0;
 421                         while(!in.eof()) {
 422
 423                                 if (pDataArray->m->control_pressed) { break; }
 424
 425                                 string name = "";
 426                                 string chimeraFlag = "";
 427                                 in >> chimeraFlag >> name;
 428
 429                                 //fix name
 430                                 name = name.substr(0, name.length()-1); //rip off last /
 431                                 name = name.substr(0, name.find_last_of('/'));
 432
 433                                 for (int j = 0; j < 15; j++) {  in >> chimeraFlag; }
 434                                 pDataArray->m->gobble(in);
 435
 436                                 if (chimeraFlag == "Y") {  out << name << endl; numChimeras++; }
 437                                 num++;
 438                         }
 439                         in.close();
 440                         out.close();
 441
 442
 443                         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 444                         totalSeqs += num;
 445                         pDataArray->numChimeras += numChimeras;
 446
 447                         if (pDataArray->m->control_pressed) { delete parser; return 0; }
 448
 449                         //remove file made for uchime
 450                         pDataArray->m->mothurRemove(filename);
 451
 452                         //append files
 453                         pDataArray->m->appendFiles(outputFName, pDataArray->outputFName); pDataArray->m->mothurRemove(outputFName);
 454                         pDataArray->m->appendFiles(accnos, pDataArray->accnos); pDataArray->m->mothurRemove(accnos);
 455                         if (pDataArray->chimealns) { pDataArray->m->appendFiles(alns, pDataArray->alns); pDataArray->m->mothurRemove(alns); }
 456
 457                         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();
 458
 459                 }
 460
 461                 pDataArray->count = totalSeqs;
 462                 delete parser;
 463                 return totalSeqs;
 464
 465         }
 466         catch(exception& e) {
 467                 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeThreadFunction");
 468                 exit(1);
 469         }
 470 }
 471 /**************************************************************************************************/
 472
 473 static DWORD WINAPI MyUchimeSeqsThreadFunction(LPVOID lpParam){
 474         uchimeData* pDataArray;
 475         pDataArray = (uchimeData*)lpParam;
 476
 477         try {
 478
 479                 int totalSeqs = 0;
 480                 int numChimeras = 0;
 481
 482                 int start = time(NULL);  if (pDataArray->m->control_pressed) { return 0; }
 483
 484                 //to allow for spaces in the path
 485                 string outputFName = "\"" + pDataArray->outputFName + "\"";
 486                 string filename = "\"" + pDataArray->filename + "\"";
 487                 string alns = "\"" + pDataArray->alns+ "\"";
 488                 string templatefile = "\"" + pDataArray->templatefile + "\"";
 489                 string accnos = pDataArray->accnos;
 490
 491                 vector<char*> cPara;
 492
 493                 char* tempUchime;
 494                 tempUchime= new char[8];
 495                 *tempUchime = '\0';
 496                 strncat(tempUchime, "uchime ", 7);
 497                 cPara.push_back(tempUchime);
 498
 499                 char* tempIn = new char[8];
 500                 *tempIn = '\0'; strncat(tempIn, "--input", 7);
 501                 //strcpy(tempIn, "--input");
 502                 cPara.push_back(tempIn);
 503                 char* temp = new char[filename.length()+1];
 504                 *temp = '\0'; strncat(temp, filename.c_str(), filename.length());
 505                 //strcpy(temp, filename.c_str());
 506                 cPara.push_back(temp);
 507
 508                 //add reference file
 509                 char* tempRef = new char[5];
 510                 //strcpy(tempRef, "--db");
 511                 *tempRef = '\0'; strncat(tempRef, "--db", 4);
 512                 cPara.push_back(tempRef);
 513                 char* tempR = new char[templatefile.length()+1];
 514                 //strcpy(tempR, templatefile.c_str());
 515                 *tempR = '\0'; strncat(tempR, templatefile.c_str(), templatefile.length());
 516                 cPara.push_back(tempR);
 517
 518                 char* tempO = new char[12];
 519                 *tempO = '\0'; strncat(tempO, "--uchimeout", 11);
 520                 //strcpy(tempO, "--uchimeout");
 521                 cPara.push_back(tempO);
 522                 char* tempout = new char[outputFName.length()+1];
 523                 //strcpy(tempout, outputFName.c_str());
 524                 *tempout = '\0'; strncat(tempout, outputFName.c_str(), outputFName.length());
 525                 cPara.push_back(tempout);
 526
 527                 if (pDataArray->chimealns) {
 528                         char* tempA = new char[13];
 529                         *tempA = '\0'; strncat(tempA, "--uchimealns", 12);
 530                         //strcpy(tempA, "--uchimealns");
 531                         cPara.push_back(tempA);
 532                         char* tempa = new char[alns.length()+1];
 533                         //strcpy(tempa, alns.c_str());
 534                         *tempa = '\0'; strncat(tempa, alns.c_str(), alns.length());
 535                         cPara.push_back(tempa);
 536                 }
 537
 538                 if (pDataArray->useAbskew) {
 539                         char* tempskew = new char[9];
 540                         *tempskew = '\0'; strncat(tempskew, "--abskew", 8);
 541                         //strcpy(tempskew, "--abskew");
 542                         cPara.push_back(tempskew);
 543                         char* tempSkew = new char[pDataArray->abskew.length()+1];
 544                         //strcpy(tempSkew, abskew.c_str());
 545                         *tempSkew = '\0'; strncat(tempSkew, pDataArray->abskew.c_str(), pDataArray->abskew.length());
 546                         cPara.push_back(tempSkew);
 547                 }
 548
 549                 if (pDataArray->useMinH) {
 550                         char* tempminh = new char[7];
 551                         *tempminh = '\0'; strncat(tempminh, "--minh", 6);
 552                         //strcpy(tempminh, "--minh");
 553                         cPara.push_back(tempminh);
 554                         char* tempMinH = new char[pDataArray->minh.length()+1];
 555                         *tempMinH = '\0'; strncat(tempMinH, pDataArray->minh.c_str(), pDataArray->minh.length());
 556                         //strcpy(tempMinH, minh.c_str());
 557                         cPara.push_back(tempMinH);
 558                 }
 559
 560                 if (pDataArray->useMindiv) {
 561                         char* tempmindiv = new char[9];
 562                         *tempmindiv = '\0'; strncat(tempmindiv, "--mindiv", 8);
 563                         //strcpy(tempmindiv, "--mindiv");
 564                         cPara.push_back(tempmindiv);
 565                         char* tempMindiv = new char[pDataArray->mindiv.length()+1];
 566                         *tempMindiv = '\0'; strncat(tempMindiv, pDataArray->mindiv.c_str(), pDataArray->mindiv.length());
 567                         //strcpy(tempMindiv, mindiv.c_str());
 568                         cPara.push_back(tempMindiv);
 569                 }
 570
 571                 if (pDataArray->useXn) {
 572                         char* tempxn = new char[5];
 573                         //strcpy(tempxn, "--xn");
 574                         *tempxn = '\0'; strncat(tempxn, "--xn", 4);
 575                         cPara.push_back(tempxn);
 576                         char* tempXn = new char[pDataArray->xn.length()+1];
 577                         //strcpy(tempXn, xn.c_str());
 578                         *tempXn = '\0'; strncat(tempXn, pDataArray->xn.c_str(), pDataArray->xn.length());
 579                         cPara.push_back(tempXn);
 580                 }
 581
 582                 if (pDataArray->useDn) {
 583                         char* tempdn = new char[5];
 584                         //strcpy(tempdn, "--dn");
 585                         *tempdn = '\0'; strncat(tempdn, "--dn", 4);
 586                         cPara.push_back(tempdn);
 587                         char* tempDn = new char[pDataArray->dn.length()+1];
 588                         *tempDn = '\0'; strncat(tempDn, pDataArray->dn.c_str(), pDataArray->dn.length());
 589                         //strcpy(tempDn, dn.c_str());
 590                         cPara.push_back(tempDn);
 591                 }
 592
 593                 if (pDataArray->useXa) {
 594                         char* tempxa = new char[5];
 595                         //strcpy(tempxa, "--xa");
 596                         *tempxa = '\0'; strncat(tempxa, "--xa", 4);
 597                         cPara.push_back(tempxa);
 598                         char* tempXa = new char[pDataArray->xa.length()+1];
 599                         *tempXa = '\0'; strncat(tempXa, pDataArray->xa.c_str(), pDataArray->xa.length());
 600                         //strcpy(tempXa, xa.c_str());
 601                         cPara.push_back(tempXa);
 602                 }
 603
 604                 if (pDataArray->useChunks) {
 605                         char* tempchunks = new char[9];
 606                         //strcpy(tempchunks, "--chunks");
 607                         *tempchunks = '\0'; strncat(tempchunks, "--chunks", 8);
 608                         cPara.push_back(tempchunks);
 609                         char* tempChunks = new char[pDataArray->chunks.length()+1];
 610                         *tempChunks = '\0'; strncat(tempChunks, pDataArray->chunks.c_str(), pDataArray->chunks.length());
 611                         //strcpy(tempChunks, chunks.c_str());
 612                         cPara.push_back(tempChunks);
 613                 }
 614
 615                 if (pDataArray->useMinchunk) {
 616                         char* tempminchunk = new char[11];
 617                         //strcpy(tempminchunk, "--minchunk");
 618                         *tempminchunk = '\0'; strncat(tempminchunk, "--minchunk", 10);
 619                         cPara.push_back(tempminchunk);
 620                         char* tempMinchunk = new char[pDataArray->minchunk.length()+1];
 621                         *tempMinchunk = '\0'; strncat(tempMinchunk, pDataArray->minchunk.c_str(), pDataArray->minchunk.length());
 622                         //strcpy(tempMinchunk, minchunk.c_str());
 623                         cPara.push_back(tempMinchunk);
 624                 }
 625
 626                 if (pDataArray->useIdsmoothwindow) {
 627                         char* tempidsmoothwindow = new char[17];
 628                         *tempidsmoothwindow = '\0'; strncat(tempidsmoothwindow, "--idsmoothwindow", 16);
 629                         //strcpy(tempidsmoothwindow, "--idsmoothwindow");
 630                         cPara.push_back(tempidsmoothwindow);
 631                         char* tempIdsmoothwindow = new char[pDataArray->idsmoothwindow.length()+1];
 632                         *tempIdsmoothwindow = '\0'; strncat(tempIdsmoothwindow, pDataArray->idsmoothwindow.c_str(), pDataArray->idsmoothwindow.length());
 633                         //strcpy(tempIdsmoothwindow, idsmoothwindow.c_str());
 634                         cPara.push_back(tempIdsmoothwindow);
 635                 }
 636
 637                 if (pDataArray->useMaxp) {
 638                         char* tempmaxp = new char[7];
 639                         //strcpy(tempmaxp, "--maxp");
 640                         *tempmaxp = '\0'; strncat(tempmaxp, "--maxp", 6);
 641                         cPara.push_back(tempmaxp);
 642                         char* tempMaxp = new char[pDataArray->maxp.length()+1];
 643                         *tempMaxp = '\0'; strncat(tempMaxp, pDataArray->maxp.c_str(), pDataArray->maxp.length());
 644                         //strcpy(tempMaxp, maxp.c_str());
 645                         cPara.push_back(tempMaxp);
 646                 }
 647
 648                 if (!pDataArray->skipgaps) {
 649                         char* tempskipgaps = new char[13];
 650                         //strcpy(tempskipgaps, "--[no]skipgaps");
 651                         *tempskipgaps = '\0'; strncat(tempskipgaps, "--noskipgaps", 12);
 652                         cPara.push_back(tempskipgaps);
 653                 }
 654
 655                 if (!pDataArray->skipgaps2) {
 656                         char* tempskipgaps2 = new char[14];
 657                         //strcpy(tempskipgaps2, "--[no]skipgaps2");
 658                         *tempskipgaps2 = '\0'; strncat(tempskipgaps2, "--noskipgaps2", 13);
 659                         cPara.push_back(tempskipgaps2);
 660                 }
 661
 662                 if (pDataArray->useMinlen) {
 663                         char* tempminlen = new char[9];
 664                         *tempminlen = '\0'; strncat(tempminlen, "--minlen", 8);
 665                         //strcpy(tempminlen, "--minlen");
 666                         cPara.push_back(tempminlen);
 667                         char* tempMinlen = new char[pDataArray->minlen.length()+1];
 668                         //strcpy(tempMinlen, minlen.c_str());
 669                         *tempMinlen = '\0'; strncat(tempMinlen, pDataArray->minlen.c_str(), pDataArray->minlen.length());
 670                         cPara.push_back(tempMinlen);
 671                 }
 672
 673                 if (pDataArray->useMaxlen) {
 674                         char* tempmaxlen = new char[9];
 675                         //strcpy(tempmaxlen, "--maxlen");
 676                         *tempmaxlen = '\0'; strncat(tempmaxlen, "--maxlen", 8);
 677                         cPara.push_back(tempmaxlen);
 678                         char* tempMaxlen = new char[pDataArray->maxlen.length()+1];
 679                         *tempMaxlen = '\0'; strncat(tempMaxlen, pDataArray->maxlen.c_str(), pDataArray->maxlen.length());
 680                         //strcpy(tempMaxlen, maxlen.c_str());
 681                         cPara.push_back(tempMaxlen);
 682                 }
 683
 684                 if (pDataArray->ucl) {
 685                         char* tempucl = new char[5];
 686                         strcpy(tempucl, "--ucl");
 687                         cPara.push_back(tempucl);
 688                 }
 689
 690                 if (pDataArray->useQueryfract) {
 691                         char* tempqueryfract = new char[13];
 692                         *tempqueryfract = '\0'; strncat(tempqueryfract, "--queryfract", 12);
 693                         //strcpy(tempqueryfract, "--queryfract");
 694                         cPara.push_back(tempqueryfract);
 695                         char* tempQueryfract = new char[pDataArray->queryfract.length()+1];
 696                         *tempQueryfract = '\0'; strncat(tempQueryfract, pDataArray->queryfract.c_str(), pDataArray->queryfract.length());
 697                         //strcpy(tempQueryfract, queryfract.c_str());
 698                         cPara.push_back(tempQueryfract);
 699                 }
 700
 701
 702                 char** uchimeParameters;
 703                 uchimeParameters = new char*[cPara.size()];
 704                 string commandString = "";
 705                 for (int j = 0; j < cPara.size(); j++) {  uchimeParameters[j] = cPara[j];  commandString += toString(cPara[j]) + " "; }
 706                 //int numArgs = cPara.size();
 707
 708                 //uchime_main(numArgs, uchimeParameters);
 709                 //cout << "commandString = " << commandString << endl;
 710                 system(commandString.c_str());
 711
 712                 //free memory
 713                 for(int j = 0; j < cPara.size(); j++)  {  delete cPara[j];  }
 714                 delete[] uchimeParameters;
 715
 716                 //remove "" from filenames
 717                 outputFName = outputFName.substr(1, outputFName.length()-2);
 718                 filename = filename.substr(1, filename.length()-2);
 719                 alns = alns.substr(1, alns.length()-2);
 720
 721                 if (pDataArray->m->control_pressed) { return 0; }
 722
 723                 //create accnos file from uchime results
 724                 ifstream in;
 725                 pDataArray->m->openInputFile(outputFName, in);
 726
 727                 ofstream out;
 728                 pDataArray->m->openOutputFile(accnos, out);
 729
 730                 numChimeras = 0;
 731                 while(!in.eof()) {
 732
 733                         if (pDataArray->m->control_pressed) { break; }
 734
 735                         string name = "";
 736                         string chimeraFlag = "";
 737                         in >> chimeraFlag >> name;
 738
 739                         for (int j = 0; j < 15; j++) {  in >> chimeraFlag; }
 740                         pDataArray->m->gobble(in);
 741
 742                         if (chimeraFlag == "Y") {  out << name << endl; numChimeras++; }
 743                         totalSeqs++;
 744                 }
 745                 in.close();
 746                 out.close();
 747
 748                 if (pDataArray->m->control_pressed) { return 0; }
 749
 750                 pDataArray->m->mothurOutEndLine(); pDataArray->m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(totalSeqs) + " sequences.");       pDataArray->m->mothurOutEndLine();
 751
 752                 pDataArray->count = totalSeqs;
 753                 pDataArray->numChimeras = numChimeras;
 754                 return totalSeqs;
 755
 756         }
 757         catch(exception& e) {
 758                 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeSeqsThreadFunction");
 759                 exit(1);
 760         }
 761 }
 762
 763 #endif
 764
 765 /**************************************************************************************************/
 766
 767
 768 #endif
 769
 770