forked from mothur/mothur
-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathchimerauchimecommand.cpp
1959 lines (1622 loc) · 85.4 KB
/
chimerauchimecommand.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* chimerauchimecommand.cpp
* Mothur
*
* Created by westcott on 5/13/11.
* Copyright 2011 Schloss Lab. All rights reserved.
*
*/
#include "chimerauchimecommand.h"
#include "deconvolutecommand.h"
//#include "uc.h"
#include "sequence.hpp"
#include "referencedb.h"
#include "systemcommand.h"
//**********************************************************************************************************************
vector<string> ChimeraUchimeCommand::setParameters(){
try {
CommandParameter ptemplate("reference", "InputTypes", "", "", "none", "none", "none","",false,true,true); parameters.push_back(ptemplate);
CommandParameter pfasta("fasta", "InputTypes", "", "", "none", "none", "none","chimera-accnos",false,true,true); parameters.push_back(pfasta);
CommandParameter pname("name", "InputTypes", "", "", "NameCount", "none", "none","",false,false,true); parameters.push_back(pname);
CommandParameter pcount("count", "InputTypes", "", "", "NameCount-CountGroup", "none", "none","",false,false,true); parameters.push_back(pcount);
CommandParameter pgroup("group", "InputTypes", "", "", "CountGroup", "none", "none","",false,false,true); parameters.push_back(pgroup);
CommandParameter pprocessors("processors", "Number", "", "1", "", "", "","",false,false,true); parameters.push_back(pprocessors);
CommandParameter pstrand("strand", "String", "", "", "", "", "","",false,false); parameters.push_back(pstrand);
CommandParameter pinputdir("inputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(pinputdir);
CommandParameter poutputdir("outputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(poutputdir);
CommandParameter pabskew("abskew", "Number", "", "1.9", "", "", "","",false,false); parameters.push_back(pabskew);
CommandParameter pchimealns("chimealns", "Boolean", "", "F", "", "", "","alns",false,false); parameters.push_back(pchimealns);
CommandParameter pminh("minh", "Number", "", "0.3", "", "", "","",false,false); parameters.push_back(pminh);
CommandParameter pmindiv("mindiv", "Number", "", "0.5", "", "", "","",false,false); parameters.push_back(pmindiv);
CommandParameter pxn("xn", "Number", "", "8.0", "", "", "","",false,false); parameters.push_back(pxn);
CommandParameter pdn("dn", "Number", "", "1.4", "", "", "","",false,false); parameters.push_back(pdn);
CommandParameter pxa("xa", "Number", "", "1", "", "", "","",false,false); parameters.push_back(pxa);
CommandParameter pchunks("chunks", "Number", "", "4", "", "", "","",false,false); parameters.push_back(pchunks);
CommandParameter pminchunk("minchunk", "Number", "", "64", "", "", "","",false,false); parameters.push_back(pminchunk);
CommandParameter pidsmoothwindow("idsmoothwindow", "Number", "", "32", "", "", "","",false,false); parameters.push_back(pidsmoothwindow);
CommandParameter pdups("dereplicate", "Boolean", "", "F", "", "", "","",false,false); parameters.push_back(pdups);
//CommandParameter pminsmoothid("minsmoothid", "Number", "", "0.95", "", "", "",false,false); parameters.push_back(pminsmoothid);
CommandParameter pmaxp("maxp", "Number", "", "2", "", "", "","",false,false); parameters.push_back(pmaxp);
CommandParameter pskipgaps("skipgaps", "Boolean", "", "T", "", "", "","",false,false); parameters.push_back(pskipgaps);
CommandParameter pskipgaps2("skipgaps2", "Boolean", "", "T", "", "", "","",false,false); parameters.push_back(pskipgaps2);
CommandParameter pminlen("minlen", "Number", "", "10", "", "", "","",false,false); parameters.push_back(pminlen);
CommandParameter pmaxlen("maxlen", "Number", "", "10000", "", "", "","",false,false); parameters.push_back(pmaxlen);
CommandParameter pucl("ucl", "Boolean", "", "F", "", "", "","",false,false); parameters.push_back(pucl);
CommandParameter pqueryfract("queryfract", "Number", "", "0.5", "", "", "","",false,false); parameters.push_back(pqueryfract);
vector<string> myArray;
for (int i = 0; i < parameters.size(); i++) { myArray.push_back(parameters[i].name); }
return myArray;
}
catch(exception& e) {
m->errorOut(e, "ChimeraUchimeCommand", "setParameters");
exit(1);
}
}
//**********************************************************************************************************************
string ChimeraUchimeCommand::getHelpString(){
try {
string helpString = "";
helpString += "The chimera.uchime command reads a fastafile and referencefile and outputs potentially chimeric sequences.\n";
helpString += "This command is a wrapper for uchime written by Robert C. Edgar.\n";
helpString += "The chimera.uchime command parameters are fasta, name, count, reference, processors, dereplicate, abskew, chimealns, minh, mindiv, xn, dn, xa, chunks, minchunk, idsmoothwindow, minsmoothid, maxp, skipgaps, skipgaps2, minlen, maxlen, ucl, strand and queryfact.\n";
helpString += "The fasta parameter allows you to enter the fasta file containing your potentially chimeric sequences, and is required, unless you have a valid current fasta file. \n";
helpString += "The name parameter allows you to provide a name file, if you are using template=self. \n";
helpString += "The count parameter allows you to provide a count file, if you are using template=self. When you use a count file with group info and dereplicate=T, mothur will create a *.pick.count_table file containing seqeunces after chimeras are removed. \n";
helpString += "You may enter multiple fasta files by separating their names with dashes. ie. fasta=abrecovery.fasta-amazon.fasta \n";
helpString += "The group parameter allows you to provide a group file. The group file can be used with a namesfile and reference=self. When checking sequences, only sequences from the same group as the query sequence will be used as the reference. \n";
helpString += "If the dereplicate parameter is false, then if one group finds the seqeunce to be chimeric, then all groups find it to be chimeric, default=f.\n";
helpString += "The reference parameter allows you to enter a reference file containing known non-chimeric sequences, and is required. You may also set template=self, in this case the abundant sequences will be used as potential parents. \n";
helpString += "The processors parameter allows you to specify how many processors you would like to use. The default is 1. \n";
helpString += "The abskew parameter can only be used with template=self. Minimum abundance skew. Default 1.9. Abundance skew is: min [ abund(parent1), abund(parent2) ] / abund(query).\n";
helpString += "The chimealns parameter allows you to indicate you would like a file containing multiple alignments of query sequences to parents in human readable format. Alignments show columns with differences that support or contradict a chimeric model.\n";
helpString += "The minh parameter - mininum score to report chimera. Default 0.3. Values from 0.1 to 5 might be reasonable. Lower values increase sensitivity but may report more false positives. If you decrease xn you may need to increase minh, and vice versa.\n";
helpString += "The mindiv parameter - minimum divergence ratio, default 0.5. Div ratio is 100%% - %%identity between query sequence and the closest candidate for being a parent. If you don't care about very close chimeras, then you could increase mindiv to, say, 1.0 or 2.0, and also decrease minh, say to 0.1, to increase sensitivity. How well this works will depend on your data. Best is to tune parameters on a good benchmark.\n";
helpString += "The xn parameter - weight of a no vote. Default 8.0. Decreasing this weight to around 3 or 4 may give better performance on denoised data.\n";
helpString += "The dn parameter - pseudo-count prior on number of no votes. Default 1.4. Probably no good reason to change this unless you can retune to a good benchmark for your data. Reasonable values are probably in the range from 0.2 to 2.\n";
helpString += "The xa parameter - weight of an abstain vote. Default 1. So far, results do not seem to be very sensitive to this parameter, but if you have a good training set might be worth trying. Reasonable values might range from 0.1 to 2.\n";
helpString += "The chunks parameter is the number of chunks to extract from the query sequence when searching for parents. Default 4.\n";
helpString += "The minchunk parameter is the minimum length of a chunk. Default 64.\n";
helpString += "The idsmoothwindow parameter is the length of id smoothing window. Default 32.\n";
//helpString += "The minsmoothid parameter - minimum factional identity over smoothed window of candidate parent. Default 0.95.\n";
helpString += "The maxp parameter - maximum number of candidate parents to consider. Default 2. In tests so far, increasing maxp gives only a very small improvement in sensivity but tends to increase the error rate quite a bit.\n";
helpString += "The skipgaps parameter controls how gapped columns affect counting of diffs. If skipgaps is set to T, columns containing gaps do not found as diffs. Default = T.\n";
helpString += "The skipgaps2 parameter controls how gapped columns affect counting of diffs. If skipgaps2 is set to T, if column is immediately adjacent to a column containing a gap, it is not counted as a diff. Default = T.\n";
helpString += "The minlen parameter is the minimum unaligned sequence length. Defaults 10. Applies to both query and reference sequences.\n";
helpString += "The maxlen parameter is the maximum unaligned sequence length. Defaults 10000. Applies to both query and reference sequences.\n";
helpString += "The ucl parameter - use local-X alignments. Default is global-X or false. On tests so far, global-X is always better; this option is retained because it just might work well on some future type of data.\n";
helpString += "The queryfract parameter - minimum fraction of the query sequence that must be covered by a local-X alignment. Default 0.5. Applies only when ucl is true.\n";
#ifdef USE_MPI
helpString += "When using MPI, the processors parameter is set to the number of MPI processes running. \n";
#endif
helpString += "The chimera.uchime command should be in the following format: \n";
helpString += "chimera.uchime(fasta=yourFastaFile, reference=yourTemplate) \n";
helpString += "Example: chimera.uchime(fasta=AD.align, reference=silva.gold.align) \n";
helpString += "Note: No spaces between parameter labels (i.e. fasta), '=' and parameters (i.e.yourFastaFile).\n";
return helpString;
}
catch(exception& e) {
m->errorOut(e, "ChimeraUchimeCommand", "getHelpString");
exit(1);
}
}
//**********************************************************************************************************************
string ChimeraUchimeCommand::getOutputPattern(string type) {
try {
string pattern = "";
if (type == "chimera") { pattern = "[filename],uchime.chimeras"; }
else if (type == "accnos") { pattern = "[filename],uchime.accnos"; }
else if (type == "alns") { pattern = "[filename],uchime.alns"; }
else if (type == "count") { pattern = "[filename],uchime.pick.count_table"; }
else { m->mothurOut("[ERROR]: No definition for type " + type + " output pattern.\n"); m->control_pressed = true; }
return pattern;
}
catch(exception& e) {
m->errorOut(e, "ChimeraUchimeCommand", "getOutputPattern");
exit(1);
}
}
//**********************************************************************************************************************
ChimeraUchimeCommand::ChimeraUchimeCommand(){
try {
abort = true; calledHelp = true;
setParameters();
vector<string> tempOutNames;
outputTypes["chimera"] = tempOutNames;
outputTypes["accnos"] = tempOutNames;
outputTypes["alns"] = tempOutNames;
outputTypes["count"] = tempOutNames;
}
catch(exception& e) {
m->errorOut(e, "ChimeraUchimeCommand", "ChimeraUchimeCommand");
exit(1);
}
}
//***************************************************************************************************************
ChimeraUchimeCommand::ChimeraUchimeCommand(string option) {
try {
abort = false; calledHelp = false; hasName=false; hasCount=false;
ReferenceDB* rdb = ReferenceDB::getInstance();
//allow user to run help
if(option == "help") { help(); abort = true; calledHelp = true; }
else if(option == "citation") { citation(); abort = true; calledHelp = true;}
else {
vector<string> myArray = setParameters();
OptionParser parser(option);
map<string,string> parameters = parser.getParameters();
ValidParameters validParameter("chimera.uchime");
map<string,string>::iterator it;
//check to make sure all parameters are valid for command
for (it = parameters.begin(); it != parameters.end(); it++) {
if (validParameter.isValidParameter(it->first, myArray, it->second) != true) { abort = true; }
}
vector<string> tempOutNames;
outputTypes["chimera"] = tempOutNames;
outputTypes["accnos"] = tempOutNames;
outputTypes["alns"] = tempOutNames;
outputTypes["count"] = tempOutNames;
//if the user changes the input directory command factory will send this info to us in the output parameter
string inputDir = validParameter.validFile(parameters, "inputdir", false);
if (inputDir == "not found"){ inputDir = ""; }
//check for required parameters
fastafile = validParameter.validFile(parameters, "fasta", false);
if (fastafile == "not found") {
//if there is a current fasta file, use it
string filename = m->getFastaFile();
if (filename != "") { fastaFileNames.push_back(filename); m->mothurOut("Using " + filename + " as input file for the fasta parameter."); m->mothurOutEndLine(); }
else { m->mothurOut("You have no current fastafile and the fasta parameter is required."); m->mothurOutEndLine(); abort = true; }
}else {
m->splitAtDash(fastafile, fastaFileNames);
//go through files and make sure they are good, if not, then disregard them
for (int i = 0; i < fastaFileNames.size(); i++) {
bool ignore = false;
if (fastaFileNames[i] == "current") {
fastaFileNames[i] = m->getFastaFile();
if (fastaFileNames[i] != "") { m->mothurOut("Using " + fastaFileNames[i] + " as input file for the fasta parameter where you had given current."); m->mothurOutEndLine(); }
else {
m->mothurOut("You have no current fastafile, ignoring current."); m->mothurOutEndLine(); ignore=true;
//erase from file list
fastaFileNames.erase(fastaFileNames.begin()+i);
i--;
}
}
if (!ignore) {
if (inputDir != "") {
string path = m->hasPath(fastaFileNames[i]);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { fastaFileNames[i] = inputDir + fastaFileNames[i]; }
}
int ableToOpen;
ifstream in;
ableToOpen = m->openInputFile(fastaFileNames[i], in, "noerror");
//if you can't open it, try default location
if (ableToOpen == 1) {
if (m->getDefaultPath() != "") { //default path is set
string tryPath = m->getDefaultPath() + m->getSimpleName(fastaFileNames[i]);
m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
fastaFileNames[i] = tryPath;
}
}
if (ableToOpen == 1) {
if (m->getOutputDir() != "") { //default path is set
string tryPath = m->getOutputDir() + m->getSimpleName(fastaFileNames[i]);
m->mothurOut("Unable to open " + fastaFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
fastaFileNames[i] = tryPath;
}
}
in.close();
if (ableToOpen == 1) {
m->mothurOut("Unable to open " + fastaFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine();
//erase from file list
fastaFileNames.erase(fastaFileNames.begin()+i);
i--;
}else {
m->setFastaFile(fastaFileNames[i]);
}
}
}
//make sure there is at least one valid file left
if (fastaFileNames.size() == 0) { m->mothurOut("[ERROR]: no valid files."); m->mothurOutEndLine(); abort = true; }
}
//check for required parameters
namefile = validParameter.validFile(parameters, "name", false);
if (namefile == "not found") { namefile = ""; }
else {
m->splitAtDash(namefile, nameFileNames);
//go through files and make sure they are good, if not, then disregard them
for (int i = 0; i < nameFileNames.size(); i++) {
bool ignore = false;
if (nameFileNames[i] == "current") {
nameFileNames[i] = m->getNameFile();
if (nameFileNames[i] != "") { m->mothurOut("Using " + nameFileNames[i] + " as input file for the name parameter where you had given current."); m->mothurOutEndLine(); }
else {
m->mothurOut("You have no current namefile, ignoring current."); m->mothurOutEndLine(); ignore=true;
//erase from file list
nameFileNames.erase(nameFileNames.begin()+i);
i--;
}
}
if (!ignore) {
if (inputDir != "") {
string path = m->hasPath(nameFileNames[i]);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { nameFileNames[i] = inputDir + nameFileNames[i]; }
}
int ableToOpen;
ifstream in;
ableToOpen = m->openInputFile(nameFileNames[i], in, "noerror");
//if you can't open it, try default location
if (ableToOpen == 1) {
if (m->getDefaultPath() != "") { //default path is set
string tryPath = m->getDefaultPath() + m->getSimpleName(nameFileNames[i]);
m->mothurOut("Unable to open " + nameFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
nameFileNames[i] = tryPath;
}
}
if (ableToOpen == 1) {
if (m->getOutputDir() != "") { //default path is set
string tryPath = m->getOutputDir() + m->getSimpleName(nameFileNames[i]);
m->mothurOut("Unable to open " + nameFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
nameFileNames[i] = tryPath;
}
}
in.close();
if (ableToOpen == 1) {
m->mothurOut("Unable to open " + nameFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine();
//erase from file list
nameFileNames.erase(nameFileNames.begin()+i);
i--;
}else {
m->setNameFile(nameFileNames[i]);
}
}
}
}
if (nameFileNames.size() != 0) { hasName = true; }
//check for required parameters
vector<string> countfileNames;
countfile = validParameter.validFile(parameters, "count", false);
if (countfile == "not found") {
countfile = "";
}else {
m->splitAtDash(countfile, countfileNames);
//go through files and make sure they are good, if not, then disregard them
for (int i = 0; i < countfileNames.size(); i++) {
bool ignore = false;
if (countfileNames[i] == "current") {
countfileNames[i] = m->getCountTableFile();
if (nameFileNames[i] != "") { m->mothurOut("Using " + countfileNames[i] + " as input file for the count parameter where you had given current."); m->mothurOutEndLine(); }
else {
m->mothurOut("You have no current count file, ignoring current."); m->mothurOutEndLine(); ignore=true;
//erase from file list
countfileNames.erase(countfileNames.begin()+i);
i--;
}
}
if (!ignore) {
if (inputDir != "") {
string path = m->hasPath(countfileNames[i]);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { countfileNames[i] = inputDir + countfileNames[i]; }
}
int ableToOpen;
ifstream in;
ableToOpen = m->openInputFile(countfileNames[i], in, "noerror");
//if you can't open it, try default location
if (ableToOpen == 1) {
if (m->getDefaultPath() != "") { //default path is set
string tryPath = m->getDefaultPath() + m->getSimpleName(countfileNames[i]);
m->mothurOut("Unable to open " + countfileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
countfileNames[i] = tryPath;
}
}
if (ableToOpen == 1) {
if (m->getOutputDir() != "") { //default path is set
string tryPath = m->getOutputDir() + m->getSimpleName(countfileNames[i]);
m->mothurOut("Unable to open " + countfileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
countfileNames[i] = tryPath;
}
}
in.close();
if (ableToOpen == 1) {
m->mothurOut("Unable to open " + countfileNames[i] + ". It will be disregarded."); m->mothurOutEndLine();
//erase from file list
countfileNames.erase(countfileNames.begin()+i);
i--;
}else {
m->setCountTableFile(countfileNames[i]);
}
}
}
}
if (countfileNames.size() != 0) { hasCount = true; }
//make sure there is at least one valid file left
if (hasName && hasCount) { m->mothurOut("[ERROR]: You must enter ONLY ONE of the following: count or name."); m->mothurOutEndLine(); abort = true; }
if (!hasName && hasCount) { nameFileNames = countfileNames; }
if ((hasCount || hasName) && (nameFileNames.size() != fastaFileNames.size())) { m->mothurOut("[ERROR]: The number of name or count files does not match the number of fastafiles, please correct."); m->mothurOutEndLine(); abort=true; }
bool hasGroup = true;
groupfile = validParameter.validFile(parameters, "group", false);
if (groupfile == "not found") { groupfile = ""; hasGroup = false; }
else {
m->splitAtDash(groupfile, groupFileNames);
//go through files and make sure they are good, if not, then disregard them
for (int i = 0; i < groupFileNames.size(); i++) {
bool ignore = false;
if (groupFileNames[i] == "current") {
groupFileNames[i] = m->getGroupFile();
if (groupFileNames[i] != "") { m->mothurOut("Using " + groupFileNames[i] + " as input file for the group parameter where you had given current."); m->mothurOutEndLine(); }
else {
m->mothurOut("You have no current namefile, ignoring current."); m->mothurOutEndLine(); ignore=true;
//erase from file list
groupFileNames.erase(groupFileNames.begin()+i);
i--;
}
}
if (!ignore) {
if (inputDir != "") {
string path = m->hasPath(groupFileNames[i]);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { groupFileNames[i] = inputDir + groupFileNames[i]; }
}
int ableToOpen;
ifstream in;
ableToOpen = m->openInputFile(groupFileNames[i], in, "noerror");
//if you can't open it, try default location
if (ableToOpen == 1) {
if (m->getDefaultPath() != "") { //default path is set
string tryPath = m->getDefaultPath() + m->getSimpleName(groupFileNames[i]);
m->mothurOut("Unable to open " + groupFileNames[i] + ". Trying default " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
groupFileNames[i] = tryPath;
}
}
if (ableToOpen == 1) {
if (m->getOutputDir() != "") { //default path is set
string tryPath = m->getOutputDir() + m->getSimpleName(groupFileNames[i]);
m->mothurOut("Unable to open " + groupFileNames[i] + ". Trying output directory " + tryPath); m->mothurOutEndLine();
ifstream in2;
ableToOpen = m->openInputFile(tryPath, in2, "noerror");
in2.close();
groupFileNames[i] = tryPath;
}
}
in.close();
if (ableToOpen == 1) {
m->mothurOut("Unable to open " + groupFileNames[i] + ". It will be disregarded."); m->mothurOutEndLine();
//erase from file list
groupFileNames.erase(groupFileNames.begin()+i);
i--;
}else {
m->setGroupFile(groupFileNames[i]);
}
}
}
//make sure there is at least one valid file left
if (groupFileNames.size() == 0) { m->mothurOut("[ERROR]: no valid group files."); m->mothurOutEndLine(); abort = true; }
}
if (hasGroup && (groupFileNames.size() != fastaFileNames.size())) { m->mothurOut("[ERROR]: The number of groupfiles does not match the number of fastafiles, please correct."); m->mothurOutEndLine(); abort=true; }
if (hasGroup && hasCount) { m->mothurOut("[ERROR]: You must enter ONLY ONE of the following: count or group."); m->mothurOutEndLine(); abort = true; }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; }
//if the user changes the output directory command factory will send this info to us in the output parameter
outputDir = validParameter.validFile(parameters, "outputdir", false); if (outputDir == "not found"){ outputDir = ""; }
string path;
it = parameters.find("reference");
//user has given a template file
if(it != parameters.end()){
if (it->second == "self") { templatefile = "self"; }
else {
path = m->hasPath(it->second);
//if the user has not given a path then, add inputdir. else leave path alone.
if (path == "") { parameters["reference"] = inputDir + it->second; }
templatefile = validParameter.validFile(parameters, "reference", true);
if (templatefile == "not open") { abort = true; }
else if (templatefile == "not found") { //check for saved reference sequences
if (rdb->getSavedReference() != "") {
templatefile = rdb->getSavedReference();
m->mothurOutEndLine(); m->mothurOut("Using sequences from " + rdb->getSavedReference() + "."); m->mothurOutEndLine();
}else {
m->mothurOut("[ERROR]: You don't have any saved reference sequences and the reference parameter is a required.");
m->mothurOutEndLine();
abort = true;
}
}
}
}else if (hasName) { templatefile = "self"; }
else if (hasCount) { templatefile = "self"; }
else {
if (rdb->getSavedReference() != "") {
templatefile = rdb->getSavedReference();
m->mothurOutEndLine(); m->mothurOut("Using sequences from " + rdb->getSavedReference() + "."); m->mothurOutEndLine();
}else {
m->mothurOut("[ERROR]: You don't have any saved reference sequences and the reference parameter is a required.");
m->mothurOutEndLine();
templatefile = ""; abort = true;
}
}
string temp = validParameter.validFile(parameters, "processors", false); if (temp == "not found"){ temp = m->getProcessors(); }
m->setProcessors(temp);
m->mothurConvert(temp, processors);
abskew = validParameter.validFile(parameters, "abskew", false); if (abskew == "not found"){ useAbskew = false; abskew = "1.9"; }else{ useAbskew = true; }
if (useAbskew && templatefile != "self") { m->mothurOut("The abskew parameter is only valid with template=self, ignoring."); m->mothurOutEndLine(); useAbskew = false; }
temp = validParameter.validFile(parameters, "chimealns", false); if (temp == "not found") { temp = "f"; }
chimealns = m->isTrue(temp);
minh = validParameter.validFile(parameters, "minh", false); if (minh == "not found") { useMinH = false; minh = "0.3"; } else{ useMinH = true; }
mindiv = validParameter.validFile(parameters, "mindiv", false); if (mindiv == "not found") { useMindiv = false; mindiv = "0.5"; } else{ useMindiv = true; }
xn = validParameter.validFile(parameters, "xn", false); if (xn == "not found") { useXn = false; xn = "8.0"; } else{ useXn = true; }
dn = validParameter.validFile(parameters, "dn", false); if (dn == "not found") { useDn = false; dn = "1.4"; } else{ useDn = true; }
xa = validParameter.validFile(parameters, "xa", false); if (xa == "not found") { useXa = false; xa = "1"; } else{ useXa = true; }
chunks = validParameter.validFile(parameters, "chunks", false); if (chunks == "not found") { useChunks = false; chunks = "4"; } else{ useChunks = true; }
minchunk = validParameter.validFile(parameters, "minchunk", false); if (minchunk == "not found") { useMinchunk = false; minchunk = "64"; } else{ useMinchunk = true; }
idsmoothwindow = validParameter.validFile(parameters, "idsmoothwindow", false); if (idsmoothwindow == "not found") { useIdsmoothwindow = false; idsmoothwindow = "32"; } else{ useIdsmoothwindow = true; }
//minsmoothid = validParameter.validFile(parameters, "minsmoothid", false); if (minsmoothid == "not found") { useMinsmoothid = false; minsmoothid = "0.95"; } else{ useMinsmoothid = true; }
maxp = validParameter.validFile(parameters, "maxp", false); if (maxp == "not found") { useMaxp = false; maxp = "2"; } else{ useMaxp = true; }
minlen = validParameter.validFile(parameters, "minlen", false); if (minlen == "not found") { useMinlen = false; minlen = "10"; } else{ useMinlen = true; }
maxlen = validParameter.validFile(parameters, "maxlen", false); if (maxlen == "not found") { useMaxlen = false; maxlen = "10000"; } else{ useMaxlen = true; }
strand = validParameter.validFile(parameters, "strand", false); if (strand == "not found") { strand = ""; }
temp = validParameter.validFile(parameters, "ucl", false); if (temp == "not found") { temp = "f"; }
ucl = m->isTrue(temp);
queryfract = validParameter.validFile(parameters, "queryfract", false); if (queryfract == "not found") { useQueryfract = false; queryfract = "0.5"; } else{ useQueryfract = true; }
if (!ucl && useQueryfract) { m->mothurOut("queryfact may only be used when ucl=t, ignoring."); m->mothurOutEndLine(); useQueryfract = false; }
temp = validParameter.validFile(parameters, "skipgaps", false); if (temp == "not found") { temp = "t"; }
skipgaps = m->isTrue(temp);
temp = validParameter.validFile(parameters, "skipgaps2", false); if (temp == "not found") { temp = "t"; }
skipgaps2 = m->isTrue(temp);
temp = validParameter.validFile(parameters, "dereplicate", false);
if (temp == "not found") { temp = "false"; }
dups = m->isTrue(temp);
if (hasName && (templatefile != "self")) { m->mothurOut("You have provided a namefile and the reference parameter is not set to self. I am not sure what reference you are trying to use, aborting."); m->mothurOutEndLine(); abort=true; }
if (hasGroup && (templatefile != "self")) { m->mothurOut("You have provided a group file and the reference parameter is not set to self. I am not sure what reference you are trying to use, aborting."); m->mothurOutEndLine(); abort=true; }
//look for uchime exe
path = m->argv;
string tempPath = path;
for (int i = 0; i < path.length(); i++) { tempPath[i] = tolower(path[i]); }
path = path.substr(0, (tempPath.find_last_of('m')));
string uchimeCommand;
#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
uchimeCommand = path + "uchime"; // format the database, -o option gives us the ability
if (m->debug) {
m->mothurOut("[DEBUG]: Uchime location using \"which uchime\" = ");
Command* newCommand = new SystemCommand("which uchime"); m->mothurOutEndLine();
newCommand->execute();
delete newCommand;
m->mothurOut("[DEBUG]: Mothur's location using \"which mothur\" = ");
newCommand = new SystemCommand("which mothur"); m->mothurOutEndLine();
newCommand->execute();
delete newCommand;
}
#else
uchimeCommand = path + "uchime.exe";
#endif
//test to make sure uchime exists
ifstream in;
uchimeCommand = m->getFullPathName(uchimeCommand);
int ableToOpen = m->openInputFile(uchimeCommand, in, "no error"); in.close();
if(ableToOpen == 1) {
m->mothurOut(uchimeCommand + " file does not exist. Checking path... \n");
//check to see if uchime is in the path??
string uLocation = m->findProgramPath("uchime");
ifstream in2;
#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) || (__linux__) || (__unix__) || (__unix)
ableToOpen = m->openInputFile(uLocation, in2, "no error"); in2.close();
#else
ableToOpen = m->openInputFile((uLocation + ".exe"), in2, "no error"); in2.close();
#endif
if(ableToOpen == 1) { m->mothurOut("[ERROR]: " + uLocation + " file does not exist. mothur requires the uchime executable."); m->mothurOutEndLine(); abort = true; }
else { m->mothurOut("Found uchime in your path, using " + uLocation + "\n");uchimeLocation = uLocation; }
}else { uchimeLocation = uchimeCommand; }
uchimeLocation = m->getFullPathName(uchimeLocation);
}
}
catch(exception& e) {
m->errorOut(e, "ChimeraSlayerCommand", "ChimeraSlayerCommand");
exit(1);
}
}
//***************************************************************************************************************
int ChimeraUchimeCommand::execute(){
try{
if (abort == true) { if (calledHelp) { return 0; } return 2; }
m->mothurOut("\nuchime by Robert C. Edgar\nhttp://drive5.com/uchime\nThis code is donated to the public domain.\n\n");
for (int s = 0; s < fastaFileNames.size(); s++) {
m->mothurOut("Checking sequences from " + fastaFileNames[s] + " ..." ); m->mothurOutEndLine();
int start = time(NULL);
string nameFile = "";
if (outputDir == "") { outputDir = m->hasPath(fastaFileNames[s]); }//if user entered a file with a path then preserve it
map<string, string> variables;
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(fastaFileNames[s]));
string outputFileName = getOutputFileName("chimera", variables);
string accnosFileName = getOutputFileName("accnos", variables);
string alnsFileName = getOutputFileName("alns", variables);
string newFasta = m->getRootName(fastaFileNames[s]) + "temp";
string newCountFile = "";
//you provided a groupfile
string groupFile = "";
bool hasGroup = false;
if (groupFileNames.size() != 0) { groupFile = groupFileNames[s]; hasGroup = true; }
else if (hasCount) {
CountTable ct;
if (ct.testGroups(nameFileNames[s])) { hasGroup = true; }
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(nameFileNames[s]));
newCountFile = getOutputFileName("count", variables);
}
if ((templatefile == "self") && (!hasGroup)) { //you want to run uchime with a template=self and no groups
if (processors != 1) { m->mothurOut("When using template=self, mothur can only use 1 processor, continuing."); m->mothurOutEndLine(); processors = 1; }
if (nameFileNames.size() != 0) { //you provided a namefile and we don't need to create one
nameFile = nameFileNames[s];
}else { nameFile = getNamesFile(fastaFileNames[s]); }
map<string, string> seqs;
readFasta(fastaFileNames[s], seqs); if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
//read namefile
vector<seqPriorityNode> nameMapCount;
int error;
if (hasCount) {
CountTable ct;
ct.readTable(nameFile, true);
for(map<string, string>::iterator it = seqs.begin(); it != seqs.end(); it++) {
int num = ct.getNumSeqs(it->first);
if (num == 0) { error = 1; }
else {
seqPriorityNode temp(num, it->second, it->first);
nameMapCount.push_back(temp);
}
}
}else {
error = m->readNames(nameFile, nameMapCount, seqs); if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
}
if (error == 1) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
if (seqs.size() != nameMapCount.size()) { m->mothurOut( "The number of sequences in your fastafile does not match the number of sequences in your namefile, aborting."); m->mothurOutEndLine(); for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
printFile(nameMapCount, newFasta);
fastaFileNames[s] = newFasta;
}
if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
if (hasGroup) {
if (nameFileNames.size() != 0) { //you provided a namefile and we don't need to create one
nameFile = nameFileNames[s];
}else { nameFile = getNamesFile(fastaFileNames[s]); }
//Parse sequences by group
vector<string> groups;
map<string, string> uniqueNames;
if (hasCount) {
cparser = new SequenceCountParser(nameFile, fastaFileNames[s]);
groups = cparser->getNamesOfGroups();
uniqueNames = cparser->getAllSeqsMap();
}else{
sparser = new SequenceParser(groupFile, fastaFileNames[s], nameFile);
groups = sparser->getNamesOfGroups();
uniqueNames = sparser->getAllSeqsMap();
}
if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
//clears files
ofstream out, out1, out2;
m->openOutputFile(outputFileName, out); out.close();
m->openOutputFile(accnosFileName, out1); out1.close();
if (chimealns) { m->openOutputFile(alnsFileName, out2); out2.close(); }
int totalSeqs = 0;
if(processors == 1) { totalSeqs = driverGroups(outputFileName, newFasta, accnosFileName, alnsFileName, newCountFile, 0, groups.size(), groups);
if (hasCount && dups) {
CountTable c; c.readTable(nameFile, true);
if (!m->isBlank(newCountFile)) {
ifstream in2;
m->openInputFile(newCountFile, in2);
string name, group;
while (!in2.eof()) {
in2 >> name >> group; m->gobble(in2);
c.setAbund(name, group, 0);
}
in2.close();
}
m->mothurRemove(newCountFile);
c.printTable(newCountFile);
}
}else { totalSeqs = createProcessesGroups(outputFileName, newFasta, accnosFileName, alnsFileName, newCountFile, groups, nameFile, groupFile, fastaFileNames[s]); }
if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
if (!dups) {
int totalChimeras = deconvoluteResults(uniqueNames, outputFileName, accnosFileName, alnsFileName);
m->mothurOutEndLine(); m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(totalSeqs) + " sequences. " + toString(totalChimeras) + " chimeras were found."); m->mothurOutEndLine();
m->mothurOut("The number of sequences checked may be larger than the number of unique sequences because some sequences are found in several samples."); m->mothurOutEndLine();
}else {
if (hasCount) {
set<string> doNotRemove;
CountTable c; c.readTable(newCountFile, true);
vector<string> namesInTable = c.getNamesOfSeqs();
for (int i = 0; i < namesInTable.size(); i++) {
int temp = c.getNumSeqs(namesInTable[i]);
if (temp == 0) { c.remove(namesInTable[i]); }
else { doNotRemove.insert((namesInTable[i])); }
}
//remove names we want to keep from accnos file.
set<string> accnosNames = m->readAccnos(accnosFileName);
ofstream out2;
m->openOutputFile(accnosFileName, out2);
for (set<string>::iterator it = accnosNames.begin(); it != accnosNames.end(); it++) {
if (doNotRemove.count(*it) == 0) { out2 << (*it) << endl; }
}
out2.close();
c.printTable(newCountFile);
outputNames.push_back(newCountFile); outputTypes["count"].push_back(newCountFile);
}
}
if (hasCount) { delete cparser; }
else { delete sparser; }
if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
}else{
if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
int numSeqs = 0;
int numChimeras = 0;
if(processors == 1){ numSeqs = driver(outputFileName, fastaFileNames[s], accnosFileName, alnsFileName, numChimeras); }
else{ numSeqs = createProcesses(outputFileName, fastaFileNames[s], accnosFileName, alnsFileName, numChimeras); }
//add headings
ofstream out;
m->openOutputFile(outputFileName+".temp", out);
out << "Score\tQuery\tParentA\tParentB\tIdQM\tIdQA\tIdQB\tIdAB\tIdQT\tLY\tLN\tLA\tRY\tRN\tRA\tDiv\tYN\n";
out.close();
m->appendFiles(outputFileName, outputFileName+".temp");
m->mothurRemove(outputFileName); rename((outputFileName+".temp").c_str(), outputFileName.c_str());
if (m->control_pressed) { for (int j = 0; j < outputNames.size(); j++) { m->mothurRemove(outputNames[j]); } return 0; }
//remove file made for uchime
if (templatefile == "self") { m->mothurRemove(fastaFileNames[s]); }
m->mothurOutEndLine(); m->mothurOut("It took " + toString(time(NULL) - start) + " secs to check " + toString(numSeqs) + " sequences. " + toString(numChimeras) + " chimeras were found."); m->mothurOutEndLine();
}
outputNames.push_back(outputFileName); outputTypes["chimera"].push_back(outputFileName);
outputNames.push_back(accnosFileName); outputTypes["accnos"].push_back(accnosFileName);
if (chimealns) { outputNames.push_back(alnsFileName); outputTypes["alns"].push_back(alnsFileName); }
}
//set accnos file as new current accnosfile
string current = "";
itTypes = outputTypes.find("accnos");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setAccnosFile(current); }
}
itTypes = outputTypes.find("count");
if (itTypes != outputTypes.end()) {
if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setCountTableFile(current); }
}
m->mothurOutEndLine();
m->mothurOut("Output File Names: "); m->mothurOutEndLine();
for (int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); }
m->mothurOutEndLine();
return 0;
}
catch(exception& e) {
m->errorOut(e, "ChimeraUchimeCommand", "execute");
exit(1);
}
}
//**********************************************************************************************************************
int ChimeraUchimeCommand::deconvoluteResults(map<string, string>& uniqueNames, string outputFileName, string accnosFileName, string alnsFileName){
try {
map<string, string>::iterator itUnique;
int total = 0;
ofstream out2;
m->openOutputFile(accnosFileName+".temp", out2);
string name;
set<string> namesInFile; //this is so if a sequence is found to be chimera in several samples we dont write it to the results file more than once
set<string>::iterator itNames;
set<string> chimerasInFile;
set<string>::iterator itChimeras;
if (!m->isBlank(accnosFileName)) {
//edit accnos file
ifstream in2;
m->openInputFile(accnosFileName, in2);
while (!in2.eof()) {
if (m->control_pressed) { in2.close(); out2.close(); m->mothurRemove(outputFileName); m->mothurRemove((accnosFileName+".temp")); return 0; }
in2 >> name; m->gobble(in2);
//find unique name
itUnique = uniqueNames.find(name);
if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing accnos results. Cannot find " + name + "."); m->mothurOutEndLine(); m->control_pressed = true; }
else {
itChimeras = chimerasInFile.find((itUnique->second));
if (itChimeras == chimerasInFile.end()) {
out2 << itUnique->second << endl;
chimerasInFile.insert((itUnique->second));
total++;
}
}
}
in2.close();
}
out2.close();
m->mothurRemove(accnosFileName);
rename((accnosFileName+".temp").c_str(), accnosFileName.c_str());
//edit chimera file
ifstream in;
m->openInputFile(outputFileName, in);
ofstream out;
m->openOutputFile(outputFileName+".temp", out); out.setf(ios::fixed, ios::floatfield); out.setf(ios::showpoint);
out << "Score\tQuery\tParentA\tParentB\tIdQM\tIdQA\tIdQB\tIdAB\tIdQT\tLY\tLN\tLA\tRY\tRN\tRA\tDiv\tYN\n";
float temp1;
string parent1, parent2, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10, temp11, temp12, temp13, flag;
name = "";
namesInFile.clear();
//assumptions - in file each read will always look like - if uchime source is updated, revisit this code.
/* 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0.000000 F11Fcsw_33372/ab=18/ * * * * * * * * * * * * * * N
0.018300 F11Fcsw_14980/ab=16/ F11Fcsw_1915/ab=35/ F11Fcsw_6032/ab=42/ 79.9 78.7 78.2 78.7 79.2 3 0 5 11 10 20 1.46 N
*/
while (!in.eof()) {
if (m->control_pressed) { in.close(); out.close(); m->mothurRemove((outputFileName+".temp")); return 0; }
bool print = false;
in >> temp1; m->gobble(in);
in >> name; m->gobble(in);
in >> parent1; m->gobble(in);
in >> parent2; m->gobble(in);
in >> temp2 >> temp3 >> temp4 >> temp5 >> temp6 >> temp7 >> temp8 >> temp9 >> temp10 >> temp11 >> temp12 >> temp13 >> flag;
m->gobble(in);
//parse name - name will look like U68590/ab=1/
string restOfName = "";
int pos = name.find_first_of('/');
if (pos != string::npos) {
restOfName = name.substr(pos);
name = name.substr(0, pos);
}
//find unique name
itUnique = uniqueNames.find(name);
if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing chimera results. Cannot find "+ name + "."); m->mothurOutEndLine(); m->control_pressed = true; }
else {
name = itUnique->second;
//is this name already in the file
itNames = namesInFile.find((name));
if (itNames == namesInFile.end()) { //no not in file
if (flag == "N") { //are you really a no??
//is this sequence really not chimeric??
itChimeras = chimerasInFile.find(name);
//then you really are a no so print, otherwise skip
if (itChimeras == chimerasInFile.end()) { print = true; }
}else{ print = true; }
}
}
if (print) {
out << temp1 << '\t' << name << restOfName << '\t';
namesInFile.insert(name);
//parse parent1 names
if (parent1 != "*") {
restOfName = "";
pos = parent1.find_first_of('/');
if (pos != string::npos) {
restOfName = parent1.substr(pos);
parent1 = parent1.substr(0, pos);
}
itUnique = uniqueNames.find(parent1);
if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing chimera results. Cannot find parentA "+ parent1 + "."); m->mothurOutEndLine(); m->control_pressed = true; }
else { out << itUnique->second << restOfName << '\t'; }
}else { out << parent1 << '\t'; }
//parse parent2 names
if (parent2 != "*") {
restOfName = "";
pos = parent2.find_first_of('/');
if (pos != string::npos) {
restOfName = parent2.substr(pos);
parent2 = parent2.substr(0, pos);
}
itUnique = uniqueNames.find(parent2);
if (itUnique == uniqueNames.end()) { m->mothurOut("[ERROR]: trouble parsing chimera results. Cannot find parentB "+ parent2 + "."); m->mothurOutEndLine(); m->control_pressed = true; }
else { out << itUnique->second << restOfName << '\t'; }
}else { out << parent2 << '\t'; }
out << temp2 << '\t' << temp3 << '\t' << temp4 << '\t' << temp5 << '\t' << temp6 << '\t' << temp7 << '\t' << temp8 << '\t' << temp9 << '\t' << temp10 << '\t' << temp11 << '\t' << temp12 << temp13 << '\t' << flag << endl;
}
}
in.close();
out.close();
m->mothurRemove(outputFileName);
rename((outputFileName+".temp").c_str(), outputFileName.c_str());
//edit anls file
//assumptions - in file each read will always look like - if uchime source is updated, revisit this code.
/*
------------------------------------------------------------------------
Query ( 179 nt) F21Fcsw_11639/ab=591/
ParentA ( 179 nt) F11Fcsw_6529/ab=1625/
ParentB ( 181 nt) F21Fcsw_12128/ab=1827/
A 1 AAGgAAGAtTAATACaagATGgCaTCatgAGtccgCATgTtcAcatGATTAAAG--gTaTtcCGGTagacGATGGGGATG 78
Q 1 AAGTAAGACTAATACCCAATGACGTCTCTAGAAGACATCTGAAAGAGATTAAAG--ATTTATCGGTGATGGATGGGGATG 78
B 1 AAGgAAGAtTAATcCaggATGggaTCatgAGttcACATgTccgcatGATTAAAGgtATTTtcCGGTagacGATGGGGATG 80
Diffs N N A N?N N N NNN N?NB N ?NaNNN B B NN NNNN
Votes 0 0 + 000 0 0 000 000+ 0 00!000 + 00 0000
Model AAAAAAAAAAAAAAAAAAAAAAxBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB