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>, string, string, 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) || (__linux__) || (__unix__) || (__unix)
 145 #else
 146 static DWORD WINAPI MyUchimeThreadFunction(LPVOID lpParam){
 147         uchimeData* pDataArray;
 148         pDataArray = (uchimeData*)lpParam;
 149
 150         try {
 151
 152                 pDataArray->outputFName = pDataArray->m->getFullPathName(pDataArray->outputFName);
 153                 pDataArray->filename = pDataArray->m->getFullPathName(pDataArray->filename);
 154                 pDataArray->alns = pDataArray->m->getFullPathName(pDataArray->alns);
 155
 156                 //clears files
 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(); }
 161
 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);                                            }
 166
 167                 int totalSeqs = 0;
 168                 int numChimeras = 0;
 169
 170                 for (int i = pDataArray->start; i < pDataArray->end; i++) {
 171                         int start = time(NULL);  if (pDataArray->m->control_pressed) {  delete parser; return 0; }
 172
 173                         int error = parser->getSeqs(pDataArray->groups[i], pDataArray->filename, true); if ((error == 1) || pDataArray->m->control_pressed) {  delete parser; return 0; }
 174
 175                         //int numSeqs = driver((outputFName + groups[i]), filename, (accnos+ groups[i]), (alns+ groups[i]), numChimeras);
 176                         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 177
 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];
 183
 184                         vector<char*> cPara;
 185
 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')));
 190
 191                         string uchimeCommand = path;
 192 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 193                         uchimeCommand += "uchime ";
 194 #else
 195                         uchimeCommand += "uchime";
 196                         uchimeCommand = "\"" + uchimeCommand + "\"";
 197 #endif
 198
 199                         char* tempUchime;
 200                         tempUchime= new char[uchimeCommand.length()+1];
 201                         *tempUchime = '\0';
 202                         strncat(tempUchime, uchimeCommand.c_str(), uchimeCommand.length());
 203                         cPara.push_back(tempUchime);
 204
 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);
 213
 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);
 222
 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);
 232                         }
 233
 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);
 243                         }
 244
 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);
 254                         }
 255
 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);
 265                         }
 266
 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);
 276                         }
 277
 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);
 287                         }
 288
 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);
 298                         }
 299
 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);
 309                         }
 310
 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);
 320                         }
 321
 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);
 331                         }
 332
 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);
 342                         }
 343
 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);
 349                         }
 350
 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);
 356                         }
 357
 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);
 367                         }
 368
 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);
 378                         }
 379
 380                         if (pDataArray->ucl) {
 381                                 char* tempucl = new char[5];
 382                                 strcpy(tempucl, "--ucl");
 383                                 cPara.push_back(tempucl);
 384                         }
 385
 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);
 395                         }
 396
 397
 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();
 403
 404                         //uchime_main(numArgs, uchimeParameters);
 405                         //cout << "commandString = " << commandString << endl;
 406 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
 407 #else
 408                         commandString = "\"" + commandString + "\"";
 409 #endif
 410                         system(commandString.c_str());
 411
 412                         //free memory
 413                         for(int j = 0; j < cPara.size(); j++)  {  delete cPara[j];  }
 414                         delete[] uchimeParameters;
 415
 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);
 420
 421                         if (pDataArray->m->control_pressed) { delete parser; return 0; }
 422
 423                         //create accnos file from uchime results
 424                         ifstream in;
 425                         pDataArray->m->openInputFile(outputFName, in);
 426
 427                         ofstream out;
 428                         pDataArray->m->openOutputFile(accnos, out);
 429
 430                         int num = 0;
 431                         numChimeras = 0;
 432                         while(!in.eof()) {
 433
 434                                 if (pDataArray->m->control_pressed) { break; }
 435
 436                                 string name = "";
 437                                 string chimeraFlag = "";
 438                                 in >> chimeraFlag >> name;
 439
 440                                 //fix name
 441                                 name = name.substr(0, name.length()-1); //rip off last /
 442                                 name = name.substr(0, name.find_last_of('/'));
 443
 444                                 for (int j = 0; j < 15; j++) {  in >> chimeraFlag; }
 445                                 pDataArray->m->gobble(in);
 446
 447                                 if (chimeraFlag == "Y") {  out << name << endl; numChimeras++; }
 448                                 num++;
 449                         }
 450                         in.close();
 451                         out.close();
 452
 453
 454                         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 455                         totalSeqs += num;
 456                         pDataArray->numChimeras += numChimeras;
 457
 458                         if (pDataArray->m->control_pressed) { delete parser; return 0; }
 459
 460                         //remove file made for uchime
 461                         pDataArray->m->mothurRemove(filename);
 462
 463                         //append files
 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); }
 467
 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();
 469
 470                 }
 471
 472                 pDataArray->count = totalSeqs;
 473                 delete parser;
 474                 return totalSeqs;
 475
 476         }
 477         catch(exception& e) {
 478                 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeThreadFunction");
 479                 exit(1);
 480         }
 481 }
 482 /**************************************************************************************************/
 483
 484 static DWORD WINAPI MyUchimeSeqsThreadFunction(LPVOID lpParam){
 485         uchimeData* pDataArray;
 486         pDataArray = (uchimeData*)lpParam;
 487
 488         try {
 489
 490                 pDataArray->outputFName = pDataArray->m->getFullPathName(pDataArray->outputFName);
 491                 pDataArray->filename = pDataArray->m->getFullPathName(pDataArray->filename);
 492                 pDataArray->alns = pDataArray->m->getFullPathName(pDataArray->alns);
 493
 494                 int totalSeqs = 0;
 495                 int numChimeras = 0;
 496
 497                 int start = time(NULL);  if (pDataArray->m->control_pressed) { return 0; }
 498
 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;
 505
 506                 vector<char*> cPara;
 507
 508                 char* tempUchime;
 509                 tempUchime= new char[8];
 510                 *tempUchime = '\0';
 511                 strncat(tempUchime, "uchime ", 7);
 512                 cPara.push_back(tempUchime);
 513
 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);
 522
 523                 //add reference file
 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);
 532
 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);
 541
 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);
 551                 }
 552
 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);
 562                 }
 563
 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);
 573                 }
 574
 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);
 584                 }
 585
 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);
 595                 }
 596
 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);
 606                 }
 607
 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);
 617                 }
 618
 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);
 628                 }
 629
 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);
 639                 }
 640
 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);
 650                 }
 651
 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);
 661                 }
 662
 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);
 668                 }
 669
 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);
 675                 }
 676
 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);
 686                 }
 687
 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);
 697                 }
 698
 699                 if (pDataArray->ucl) {
 700                         char* tempucl = new char[5];
 701                         strcpy(tempucl, "--ucl");
 702                         cPara.push_back(tempucl);
 703                 }
 704
 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);
 714                 }
 715
 716
 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();
 722
 723                 //uchime_main(numArgs, uchimeParameters);
 724                 //cout << "commandString = " << commandString << endl;
 725                 system(commandString.c_str());
 726
 727                 //free memory
 728                 for(int j = 0; j < cPara.size(); j++)  {  delete cPara[j];  }
 729                 delete[] uchimeParameters;
 730
 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);
 735
 736                 if (pDataArray->m->control_pressed) { return 0; }
 737
 738                 //create accnos file from uchime results
 739                 ifstream in;
 740                 pDataArray->m->openInputFile(outputFName, in);
 741
 742                 ofstream out;
 743                 pDataArray->m->openOutputFile(accnos, out);
 744
 745                 numChimeras = 0;
 746                 while(!in.eof()) {
 747
 748                         if (pDataArray->m->control_pressed) { break; }
 749
 750                         string name = "";
 751                         string chimeraFlag = "";
 752                         in >> chimeraFlag >> name;
 753
 754                         for (int j = 0; j < 15; j++) {  in >> chimeraFlag; }
 755                         pDataArray->m->gobble(in);
 756
 757                         if (chimeraFlag == "Y") {  out << name << endl; numChimeras++; }
 758                         totalSeqs++;
 759                 }
 760                 in.close();
 761                 out.close();
 762
 763                 if (pDataArray->m->control_pressed) { return 0; }
 764
 765                 pDataArray->m->mothurOutEndLine(); pDataArray->m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(totalSeqs) + " sequences.");       pDataArray->m->mothurOutEndLine();
 766
 767                 pDataArray->count = totalSeqs;
 768                 pDataArray->numChimeras = numChimeras;
 769                 return totalSeqs;
 770
 771         }
 772         catch(exception& e) {
 773                 pDataArray->m->errorOut(e, "ChimeraUchimeCommand", "MyUchimeSeqsThreadFunction");
 774                 exit(1);
 775         }
 776 }
 777
 778 #endif
 779
 780 /**************************************************************************************************/
 781
 782
 783 #endif
 784
 785