5 * Created by Sarah Westcott on 7/9/09.
6 * Copyright 2009 Schloss Lab UMASS Amherst. All rights reserved.
11 #include "ignoregaps.h"
13 //***************************************************************************************************************
15 Pintail::Pintail(string filename, string temp) { fastafile = filename; templateFile = temp; }
16 //***************************************************************************************************************
20 for (int i = 0; i < querySeqs.size(); i++) { delete querySeqs[i]; }
21 for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i]; }
22 for (int i = 0; i < bestfit.size(); i++) { delete bestfit[i]; }
25 errorOut(e, "Pintail", "~Pintail");
29 //***************************************************************************************************************
30 void Pintail::print(ostream& out) {
35 for (int i = 0; i < querySeqs.size(); i++) {
37 int index = ceil(deviation[i]);
39 //is your DE value higher than the 95%
41 if (DE[i] > quantiles[index][4]) { chimera = "Yes"; }
42 else { chimera = "No"; }
44 out << querySeqs[i]->getName() << '\t' << "div: " << deviation[i] << "\tstDev: " << DE[i] << "\tchimera flag: " << chimera << endl;
45 if (chimera == "Yes") {
46 mothurOut(querySeqs[i]->getName() + "\tdiv: " + toString(deviation[i]) + "\tstDev: " + toString(DE[i]) + "\tchimera flag: " + chimera); mothurOutEndLine();
50 for (int j = 0; j < obsDistance[i].size(); j++) { out << obsDistance[i][j] << '\t'; }
55 for (int m = 0; m < expectedDistance[i].size(); m++) { out << expectedDistance[i][m] << '\t'; }
61 errorOut(e, "Pintail", "print");
66 //***************************************************************************************************************
67 void Pintail::getChimeras() {
70 //read in query sequences and subject sequences
71 mothurOut("Reading sequences and template file... "); cout.flush();
72 querySeqs = readSeqs(fastafile);
73 templateSeqs = readSeqs(templateFile);
74 mothurOut("Done."); mothurOutEndLine();
76 int numSeqs = querySeqs.size();
78 obsDistance.resize(numSeqs);
79 expectedDistance.resize(numSeqs);
80 seqCoef.resize(numSeqs);
83 bestfit.resize(numSeqs);
84 deviation.resize(numSeqs);
85 trimmed.resize(numSeqs);
86 windowSizes.resize(numSeqs, window);
87 windowSizesTemplate.resize(templateSeqs.size(), window);
88 windowsForeachQuery.resize(numSeqs);
90 quantiles.resize(100); //one for every percent mismatch
91 quantilesMembers.resize(100); //one for every percent mismatch
93 //break up file if needed
94 int linesPerProcess = numSeqs / processors ;
96 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
97 //find breakup of sequences for all times we will Parallelize
98 if (processors == 1) { lines.push_back(new linePair(0, numSeqs)); }
101 for (int i = 0; i < (processors-1); i++) {
102 lines.push_back(new linePair((i*linesPerProcess), ((i*linesPerProcess) + linesPerProcess)));
104 //this is necessary to get remainder of processors / numSeqs so you don't miss any lines at the end
105 int i = processors - 1;
106 lines.push_back(new linePair((i*linesPerProcess), numSeqs));
109 //find breakup of templatefile for quantiles
110 if (processors == 1) { templateLines.push_back(new linePair(0, templateSeqs.size())); }
112 for (int i = 0; i < processors; i++) {
113 templateLines.push_back(new linePair());
114 templateLines[i]->start = int (sqrt(float(i)/float(processors)) * templateSeqs.size());
115 templateLines[i]->end = int (sqrt(float(i+1)/float(processors)) * templateSeqs.size());
119 lines.push_back(new linePair(0, numSeqs));
120 templateLines.push_back(new linePair(0, templateSeqs.size()));
123 distcalculator = new ignoreGaps();
124 decalc = new DeCalculator();
126 //if the user does enter a mask then you want to keep all the spots in the alignment
127 if (seqMask.length() == 0) { decalc->setAlignmentLength(querySeqs[0]->getAligned().length()); }
128 else { decalc->setAlignmentLength(seqMask.length()); }
130 decalc->setMask(seqMask);
133 if (processors == 1) {
134 mothurOut("Finding closest sequence in template to each sequence... "); cout.flush();
135 bestfit = findPairs(lines[0]->start, lines[0]->end);
136 mothurOut("Done."); mothurOutEndLine();
137 }else { createProcessesPairs(); }
140 for (int j = 0; j < bestfit.size(); j++) {
142 //chops off beginning and end of sequences so they both start and end with a base
144 string s = querySeqs[j]->getName();
146 openOutputFile(s, out);
147 out << ">" << querySeqs[j]->getName() << endl;
148 out << querySeqs[j]->getAligned() << endl;
151 string t =querySeqs[j]->getName() + ".ref";
152 openOutputFile(t, out);
153 out << ">" << bestfit[j]->getName() << endl;
154 out << bestfit[j]->getAligned() << endl;
160 mothurOut("Getting conservation... "); cout.flush();
161 if (consfile == "") {
162 mothurOut("Calculating probability of conservation for your template sequences. This can take a while... I will output the frequency of the highest base in each position to a .freq file so that you can input them using the conservation parameter next time you run this command. Providing the .freq file will improve speed. "); cout.flush();
163 probabilityProfile = decalc->calcFreq(templateSeqs, templateFile);
164 mothurOut("Done."); mothurOutEndLine();
165 }else { probabilityProfile = readFreq(); }
168 for (int i = 0; i < probabilityProfile.size(); i++) { probabilityProfile[i] = 1 - probabilityProfile[i]; } //cout << i << '\t' << probabilityProfile[i] << endl;
169 mothurOut("Done."); mothurOutEndLine();
171 //mask sequences if the user wants to
174 for (int i = 0; i < querySeqs.size(); i++) {
175 decalc->runMask(querySeqs[i]);
179 for (int i = 0; i < templateSeqs.size(); i++) {
180 decalc->runMask(templateSeqs[i]);
183 for (int i = 0; i < bestfit.size(); i++) {
184 decalc->runMask(bestfit[i]);
189 if (processors == 1) {
191 for (int j = 0; j < bestfit.size(); j++) {
192 decalc->trimSeqs(querySeqs[j], bestfit[j], trimmed[j]);
195 mothurOut("Finding window breaks... "); cout.flush();
196 for (int i = lines[0]->start; i < lines[0]->end; i++) {
197 it = trimmed[i].begin();
198 vector<int> win = decalc->findWindows(querySeqs[i], it->first, it->second, windowSizes[i], increment);
199 windowsForeachQuery[i] = win;
201 mothurOut("Done."); mothurOutEndLine();
203 }else { createProcessesSpots(); }
205 if (processors == 1) {
207 mothurOut("Calculating observed distance... "); cout.flush();
208 for (int i = lines[0]->start; i < lines[0]->end; i++) {
209 vector<float> obsi = decalc->calcObserved(querySeqs[i], bestfit[i], windowsForeachQuery[i], windowSizes[i]);
211 obsDistance[i] = obsi;
213 mothurOut("Done."); mothurOutEndLine();
216 mothurOut("Finding variability... "); cout.flush();
217 for (int i = lines[0]->start; i < lines[0]->end; i++) {
218 vector<float> q = decalc->findQav(windowsForeachQuery[i], windowSizes[i], probabilityProfile);
222 mothurOut("Done."); mothurOutEndLine();
225 mothurOut("Calculating alpha... "); cout.flush();
226 for (int i = lines[0]->start; i < lines[0]->end; i++) {
227 float alpha = decalc->getCoef(obsDistance[i], Qav[i]);
230 mothurOut("Done."); mothurOutEndLine();
233 mothurOut("Calculating expected distance... "); cout.flush();
234 for (int i = lines[0]->start; i < lines[0]->end; i++) {
235 vector<float> exp = decalc->calcExpected(Qav[i], seqCoef[i]);
236 expectedDistance[i] = exp;
238 mothurOut("Done."); mothurOutEndLine();
241 mothurOut("Finding deviation... "); cout.flush();
242 for (int i = lines[0]->start; i < lines[0]->end; i++) {
243 float de = decalc->calcDE(obsDistance[i], expectedDistance[i]);
246 it = trimmed[i].begin();
247 float dist = decalc->calcDist(querySeqs[i], bestfit[i], it->first, it->second);
250 mothurOut("Done."); mothurOutEndLine();
253 else { createProcesses(); }
255 //quantiles are used to determine whether the de values found indicate a chimera
256 //if you have to calculate them, its time intensive because you are finding the de and deviation values for each
257 //combination of sequences in the template
258 if (quanfile != "") { quantiles = readQuantiles(); }
261 mothurOut("Calculating quantiles for your template. This can take a while... I will output the quantiles to a .quan file that you can input them using the quantiles parameter next time you run this command. Providing the .quan file will dramatically improve speed. "); cout.flush();
262 if (processors == 1) {
263 quantilesMembers = decalc->getQuantiles(templateSeqs, windowSizesTemplate, window, probabilityProfile, increment, 0, templateSeqs.size(), makeCompliant);
264 }else { createProcessesQuan(); }
267 //decided against this because we were having trouble setting the sensitivity... may want to revisit this...
268 //quantiles = decalc->removeObviousOutliers(quantilesMembers, templateSeqs.size());
273 o = getRootName(templateFile) + "quan";
275 openOutputFile(o, out4);
278 for (int i = 0; i < quantiles.size(); i++) {
281 if (quantiles[i].size() == 0) {
282 //in case this is not a distance found in your template files
283 for (int g = 0; g < 6; g++) {
288 sort(quantiles[i].begin(), quantiles[i].end());
291 temp.push_back(quantiles[i][int(quantiles[i].size() * 0.10)]);
293 temp.push_back(quantiles[i][int(quantiles[i].size() * 0.25)]);
295 temp.push_back(quantiles[i][int(quantiles[i].size() * 0.5)]);
297 temp.push_back(quantiles[i][int(quantiles[i].size() * 0.75)]);
299 temp.push_back(quantiles[i][int(quantiles[i].size() * 0.95)]);
301 temp.push_back(quantiles[i][int(quantiles[i].size() * 0.99)]);
307 for (int u = 0; u < temp.size(); u++) { out4 << temp[u] << '\t'; }
316 mothurOut("Done."); mothurOutEndLine();
321 for (int i = 0; i < lines.size(); i++) { delete lines[i]; }
322 for (int i = 0; i < templateLines.size(); i++) { delete templateLines[i]; }
324 delete distcalculator;
327 catch(exception& e) {
328 errorOut(e, "Pintail", "getChimeras");
333 //***************************************************************************************************************
335 vector<float> Pintail::readFreq() {
339 openInputFile(consfile, in);
342 set<int> h = decalc->getPos(); //positions of bases in masking sequence
344 //read in probabilities and store in vector
351 if (h.count(pos) > 0) {
353 Pi = (num - 0.25) / 0.75;
355 //cannot have probability less than 0.
356 if (Pi < 0) { Pi = 0.0; }
358 //do you want this spot
369 catch(exception& e) {
370 errorOut(e, "Pintail", "readFreq");
375 //***************************************************************************************************************
377 vector< vector<float> > Pintail::readQuantiles() {
381 openInputFile(quanfile, in);
383 vector< vector<float> > quan;
385 int num; float ten, twentyfive, fifty, seventyfive, ninetyfive, ninetynine;
389 in >> num >> ten >> twentyfive >> fifty >> seventyfive >> ninetyfive >> ninetynine;
394 temp.push_back(twentyfive);
395 temp.push_back(fifty);
396 temp.push_back(seventyfive);
397 temp.push_back(ninetyfive);
398 temp.push_back(ninetynine);
400 quan.push_back(temp);
409 catch(exception& e) {
410 errorOut(e, "Pintail", "readQuantiles");
414 //***************************************************************************************************************
415 //calculate the distances from each query sequence to all sequences in the template to find the closest sequence
416 vector<Sequence*> Pintail::findPairs(int start, int end) {
419 vector<Sequence*> seqsMatches;
421 for(int i = start; i < end; i++){
423 float smallest = 10000.0;
424 Sequence query = *(querySeqs[i]);
427 for(int j = 0; j < templateSeqs.size(); j++){
429 Sequence temp = *(templateSeqs[j]);
431 distcalculator->calcDist(query, temp);
432 float dist = distcalculator->getDist();
434 if (dist < smallest) {
435 match = templateSeqs[j];
440 //make copy so trimSeqs doesn't overtrim
441 Sequence* copy = new Sequence(match->getName(), match->getAligned());
443 seqsMatches.push_back(copy);
449 catch(exception& e) {
450 errorOut(e, "Pintail", "findPairs");
455 /**************************************************************************************************/
457 void Pintail::createProcessesSpots() {
459 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
461 vector<int> processIDS;
463 //loop through and create all the processes you want
464 while (process != processors) {
468 processIDS.push_back(pid);
472 for (int j = lines[process]->start; j < lines[process]->end; j++) {
474 //chops off beginning and end of sequences so they both start and end with a base
477 decalc->trimSeqs(querySeqs[j], bestfit[j], trim);
482 mothurOut("Finding window breaks for sequences " + toString(lines[process]->start) + " to " + toString(lines[process]->end)); mothurOutEndLine();
483 for (int i = lines[process]->start; i < lines[process]->end; i++) {
484 it = trimmed[i].begin();
485 windowsForeachQuery[i] = decalc->findWindows(querySeqs[i], it->first, it->second, windowSizes[i], increment);
487 mothurOut("Done finding window breaks for sequences " + toString(lines[process]->start) + " to " + toString(lines[process]->end)); mothurOutEndLine();
489 //write out data to file so parent can read it
491 string s = toString(getpid()) + ".temp";
492 openOutputFile(s, out);
494 //output windowsForeachQuery
495 for (int i = lines[process]->start; i < lines[process]->end; i++) {
496 out << windowsForeachQuery[i].size() << '\t';
497 for (int j = 0; j < windowsForeachQuery[i].size(); j++) {
498 out << windowsForeachQuery[i][j] << '\t';
504 for (int i = lines[process]->start; i < lines[process]->end; i++) {
505 out << windowSizes[i] << '\t';
509 //output trimmed values
510 for (int i = lines[process]->start; i < lines[process]->end; i++) {
511 it = trimmed[i].begin();
512 out << it->first << '\t' << it->second << endl;
517 }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); }
520 //force parent to wait until all the processes are done
521 for (int i=0;i<processors;i++) {
522 int temp = processIDS[i];
526 //get data created by processes
527 for (int i=0;i<processors;i++) {
529 string s = toString(processIDS[i]) + ".temp";
530 openInputFile(s, in);
532 int size = lines[i]->end - lines[i]->start;
534 int count = lines[i]->start;
535 for (int m = 0; m < size; m++) {
539 vector<int> win; int w;
540 for (int j = 0; j < num; j++) {
545 windowsForeachQuery[count] = win;
551 count = lines[i]->start;
552 for (int m = 0; m < size; m++) {
556 windowSizes[count] = num;
562 count = lines[i]->start;
563 for (int m = 0; m < size; m++) {
584 for (int j = 0; j < bestfit.size(); j++) {
585 //chops off beginning and end of sequences so they both start and end with a base
586 decalc->trimSeqs(querySeqs[j], bestfit[j], trimmed[j]);
589 for (int i = lines[0]->start; i < lines[0]->end; i++) {
590 it = trimmed[i].begin();
591 vector<int> win = decalc->findWindows(querySeqs[i], it->first, it->second, windowSizes[i], increment);
592 windowsForeachQuery[i] = win;
597 catch(exception& e) {
598 errorOut(e, "Pintail", "createProcessesSpots");
602 /**************************************************************************************************/
604 void Pintail::createProcessesPairs() {
606 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
608 vector<int> processIDS;
610 //loop through and create all the processes you want
611 while (process != processors) {
615 processIDS.push_back(pid);
619 mothurOut("Finding pairs for sequences " + toString(lines[process]->start) + " to " + toString(lines[process]->end)); mothurOutEndLine();
620 bestfit = findPairs(lines[process]->start, lines[process]->end);
621 mothurOut("Done finding pairs for sequences " + toString(lines[process]->start) + " to " + toString(lines[process]->end)); mothurOutEndLine();
623 //write out data to file so parent can read it
625 string s = toString(getpid()) + ".temp";
626 openOutputFile(s, out);
628 //output range and size
629 out << bestfit.size() << endl;
632 for (int i = 0; i < bestfit.size(); i++) {
633 out << ">" << bestfit[i]->getName() << endl << bestfit[i]->getAligned() << endl;
638 }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); }
641 //force parent to wait until all the processes are done
642 for (int i=0;i<processors;i++) {
643 int temp = processIDS[i];
647 //get data created by processes
648 for (int i=0;i<processors;i++) {
650 string s = toString(processIDS[i]) + ".temp";
651 openInputFile(s, in);
654 in >> size; gobble(in);
657 int count = lines[i]->start;
658 for (int m = 0; m < size; m++) {
659 Sequence* temp = new Sequence(in);
660 bestfit[count] = temp;
672 bestfit = findPairs(lines[0]->start, lines[0]->end);
675 catch(exception& e) {
676 errorOut(e, "Pintail", "createProcessesPairs");
680 /**************************************************************************************************/
682 void Pintail::createProcesses() {
684 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
686 vector<int> processIDS;
688 //loop through and create all the processes you want
689 while (process != processors) {
693 processIDS.push_back(pid);
697 mothurOut("Calculating observed, expected and de values for sequences " + toString(lines[process]->start) + " to " + toString(lines[process]->end)); mothurOutEndLine();
698 for (int i = lines[process]->start; i < lines[process]->end; i++) {
700 vector<float> obsi = decalc->calcObserved(querySeqs[i], bestfit[i], windowsForeachQuery[i], windowSizes[i]);
701 obsDistance[i] = obsi;
704 vector<float> q = decalc->findQav(windowsForeachQuery[i], windowSizes[i], probabilityProfile);
707 float alpha = decalc->getCoef(obsDistance[i], q);
710 vector<float> exp = decalc->calcExpected(q, alpha);
711 expectedDistance[i] = exp;
713 //get de and deviation
714 float dei = decalc->calcDE(obsi, exp);
717 it = trimmed[i].begin();
718 float dist = decalc->calcDist(querySeqs[i], bestfit[i], it->first, it->second);
721 mothurOut("Done calculating observed, expected and de values for sequences " + toString(lines[process]->start) + " to " + toString(lines[process]->end)); mothurOutEndLine();
723 //write out data to file so parent can read it
725 string s = toString(getpid()) + ".temp";
726 openOutputFile(s, out);
728 int size = lines[process]->end - lines[process]->start;
731 //output observed distances
732 for (int i = lines[process]->start; i < lines[process]->end; i++) {
733 out << obsDistance[i].size() << '\t';
734 for (int j = 0; j < obsDistance[i].size(); j++) {
735 out << obsDistance[i][j] << '\t';
741 //output expected distances
742 for (int i = lines[process]->start; i < lines[process]->end; i++) {
743 out << expectedDistance[i].size() << '\t';
744 for (int j = 0; j < expectedDistance[i].size(); j++) {
745 out << expectedDistance[i][j] << '\t';
752 for (int i = lines[process]->start; i < lines[process]->end; i++) {
753 out << DE[i] << '\t';
758 for (int i = lines[process]->start; i < lines[process]->end; i++) {
759 out << deviation[i] << '\t';
766 }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); }
769 //force parent to wait until all the processes are done
770 for (int i=0;i<processors;i++) {
771 int temp = processIDS[i];
775 //get data created by processes
776 for (int i=0;i<processors;i++) {
778 string s = toString(processIDS[i]) + ".temp";
779 openInputFile(s, in);
782 in >> size; gobble(in);
784 //get observed distances
785 int count = lines[i]->start;
786 for (int m = 0; m < size; m++) {
790 vector<float> obs; float w;
791 for (int j = 0; j < num; j++) {
796 obsDistance[count] = obs;
803 //get expected distances
804 count = lines[i]->start;
805 for (int m = 0; m < size; m++) {
809 vector<float> exp; float w;
810 for (int j = 0; j < num; j++) {
815 expectedDistance[count] = exp;
822 count = lines[i]->start;
823 for (int m = 0; m < size; m++) {
833 count = lines[i]->start;
834 for (int m = 0; m < size; m++) {
838 deviation[count] = num;
848 mothurOut("Calculating observed distance... "); cout.flush();
849 for (int i = lines[0]->start; i < lines[0]->end; i++) {
850 vector<float> obsi = decalc->calcObserved(querySeqs[i], bestfit[i], windowsForeachQuery[i], windowSizes[i]);
851 obsDistance[i] = obsi;
853 mothurOut("Done."); mothurOutEndLine();
857 mothurOut("Finding variability... "); cout.flush();
858 for (int i = lines[0]->start; i < lines[0]->end; i++) {
859 vector<float> q = decalc->findQav(windowsForeachQuery[i], windowSizes[i], probabilityProfile);
862 mothurOut("Done."); mothurOutEndLine();
866 mothurOut("Calculating alpha... "); cout.flush();
867 for (int i = lines[0]->start; i < lines[0]->end; i++) {
868 float alpha = decalc->getCoef(obsDistance[i], Qav[i]);
869 seqCoef.push_back(alpha);
871 mothurOut("Done."); mothurOutEndLine();
875 mothurOut("Calculating expected distance... "); cout.flush();
876 for (int i = lines[0]->start; i < lines[0]->end; i++) {
877 vector<float> exp = decalc->calcExpected(Qav[i], seqCoef[i]);
878 expectedDistance[i] = exp;
880 mothurOut("Done."); mothurOutEndLine();
884 mothurOut("Finding deviation... "); cout.flush();
885 for (int i = lines[0]->start; i < lines[0]->end; i++) {
886 float de = decalc->calcDE(obsDistance[i], expectedDistance[i]);
889 it = trimmed[i].begin();
890 float dist = decalc->calcDist(querySeqs[i], bestfit[i], it->first, it->second);
893 mothurOut("Done."); mothurOutEndLine();
897 catch(exception& e) {
898 errorOut(e, "Pintail", "createProcesses");
904 /**************************************************************************************************/
906 void Pintail::createProcessesQuan() {
908 #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux)
910 vector<int> processIDS;
912 //loop through and create all the processes you want
913 while (process != processors) {
917 processIDS.push_back(pid);
921 quantilesMembers = decalc->getQuantiles(templateSeqs, windowSizesTemplate, window, probabilityProfile, increment, templateLines[process]->start, templateLines[process]->end, makeCompliant);
923 //write out data to file so parent can read it
925 string s = toString(getpid()) + ".temp";
926 openOutputFile(s, out);
929 //output observed distances
930 for (int i = 0; i < quantilesMembers.size(); i++) {
931 out << quantilesMembers[i].size() << '\t';
932 for (int j = 0; j < quantilesMembers[i].size(); j++) {
933 out << quantilesMembers[i][j].score << '\t' << quantilesMembers[i][j].member1 << '\t' << quantilesMembers[i][j].member2 << '\t';
941 }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); }
944 //force parent to wait until all the processes are done
945 for (int i=0;i<processors;i++) {
946 int temp = processIDS[i];
950 //get data created by processes
951 for (int i=0;i<processors;i++) {
953 string s = toString(processIDS[i]) + ".temp";
954 openInputFile(s, in);
956 vector< vector<quanMember> > quan;
960 for (int m = 0; m < quan.size(); m++) {
966 vector<quanMember> q; float w; int b, n;
967 for (int j = 0; j < num; j++) {
969 //cout << w << '\t' << b << '\t' n << endl;
970 quanMember newMember(w, b, n);
971 q.push_back(newMember);
973 //cout << "here" << endl;
975 //cout << "now here" << endl;
980 //save quan in quantiles
981 for (int j = 0; j < quan.size(); j++) {
982 //put all values of q[i] into quan[i]
983 for (int l = 0; l < quan[j].size(); l++) { quantilesMembers[j].push_back(quan[j][l]); }
984 //quantilesMembers[j].insert(quantilesMembers[j].begin(), quan[j].begin(), quan[j].end());
992 quantilesMembers = decalc->getQuantiles(templateSeqs, windowSizesTemplate, window, probabilityProfile, increment, 0, templateSeqs.size(), makeCompliant);
995 catch(exception& e) {
996 errorOut(e, "Pintail", "createProcessesQuan");
1002 //***************************************************************************************************************