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