X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=pintail.cpp;h=90c97c5e77d50f478aeb1b4bb7b1fa28713ee468;hb=818dcf9513122fa52616a7722f4893f77685a621;hp=4b812a7c628d2816a0d8215cf0b80862b5471626;hpb=0f297d3c211acbdfd4d941ef193a6702c5046dd1;p=mothur.git diff --git a/pintail.cpp b/pintail.cpp index 4b812a7..90c97c5 100644 --- a/pintail.cpp +++ b/pintail.cpp @@ -9,475 +9,374 @@ #include "pintail.h" #include "ignoregaps.h" +#include "eachgapdist.h" +//******************************************************************************************************************** +//sorts lowest to highest +inline bool compareQuanMembers(quanMember left, quanMember right){ + return (left.score < right.score); +} //*************************************************************************************************************** -Pintail::Pintail(string name) { - try { - fastafile = name; - } - catch(exception& e) { - errorOut(e, "Pintail", "Pintail"); - exit(1); - } +Pintail::Pintail(string filename, string o) { + fastafile = filename; outputDir = o; + distcalculator = new eachGapDist(); + decalc = new DeCalculator(); } //*************************************************************************************************************** Pintail::~Pintail() { try { - for (int i = 0; i < querySeqs.size(); i++) { delete querySeqs[i]; } - for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i]; } - } - catch(exception& e) { - errorOut(e, "Pintail", "~Pintail"); - exit(1); - } -} -//*************************************************************************************************************** -void Pintail::print(ostream& out) { - try { - - for (itCoef = DE.begin(); itCoef != DE.end(); itCoef++) { - - out << itCoef->first->getName() << '\t' << itCoef->second << endl; - out << "Observed\t"; - - itObsDist = obsDistance.find(itCoef->first); - for (int i = 0; i < itObsDist->second.size(); i++) { out << itObsDist->second[i] << '\t'; } - out << endl; - - out << "Expected\t"; - - itExpDist = expectedDistance.find(itCoef->first); - for (int i = 0; i < itExpDist->second.size(); i++) { out << itExpDist->second[i] << '\t'; } - out << endl; - - } - + delete distcalculator; + delete decalc; } catch(exception& e) { - errorOut(e, "Pintail", "print"); + errorOut(e, "Pintail", "~Pintail"); exit(1); } } - //*************************************************************************************************************** -void Pintail::getChimeras() { +void Pintail::doPrep() { try { - distCalculator = new ignoreGaps(); + mergedFilterString = ""; + windowSizesTemplate.resize(templateSeqs.size(), window); + quantiles.resize(100); //one for every percent mismatch + quantilesMembers.resize(100); //one for every percent mismatch + + //if the user does not enter a mask then you want to keep all the spots in the alignment + if (seqMask.length() == 0) { decalc->setAlignmentLength(templateSeqs[0]->getAligned().length()); } + else { decalc->setAlignmentLength(seqMask.length()); } + + decalc->setMask(seqMask); + + #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) + //find breakup of templatefile for quantiles + if (processors == 1) { templateLines.push_back(new linePair(0, templateSeqs.size())); } + else { + for (int i = 0; i < processors; i++) { + templateLines.push_back(new linePair()); + templateLines[i]->start = int (sqrt(float(i)/float(processors)) * templateSeqs.size()); + templateLines[i]->end = int (sqrt(float(i+1)/float(processors)) * templateSeqs.size()); + } + } + #else + templateLines.push_back(new linePair(0, templateSeqs.size())); + #endif + - //read in query sequences and subject sequences - mothurOut("Reading sequences and template file... "); cout.flush(); - querySeqs = readSeqs(fastafile); - templateSeqs = readSeqs(templateFile); - mothurOut("Done."); mothurOutEndLine(); + mothurOut("Getting conservation... "); cout.flush(); + if (consfile == "") { + 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(); + probabilityProfile = decalc->calcFreq(templateSeqs, outputDir + getSimpleName(templateFileName)); + mothurOut("Done."); mothurOutEndLine(); + }else { probabilityProfile = readFreq(); mothurOut("Done."); } + mothurOutEndLine(); - int numSeqs = querySeqs.size(); + //make P into Q + for (int i = 0; i < probabilityProfile.size(); i++) { probabilityProfile[i] = 1 - probabilityProfile[i]; } //cout << i << '\t' << probabilityProfile[i] << endl; - //if window is set to default - if (window == 0) { if (querySeqs[0]->getAligned().length() > 800) { setWindow(200); } - else{ setWindow((querySeqs[0]->getAligned().length() / 4)); } } - else if (window > (querySeqs[0]->getAligned().length() / 4)) { - mothurOut("You have selected to large a window size for you sequences. I will choose a smaller window."); mothurOutEndLine(); - setWindow((querySeqs[0]->getAligned().length() / 4)); - } + bool reRead = false; + //create filter if needed for later + if (filter) { + + //read in all query seqs + ifstream in; + openInputFile(fastafile, in); + + vector tempQuerySeqs; + while(!in.eof()){ + Sequence* s = new Sequence(in); + gobble(in); + + if (s->getName() != "") { tempQuerySeqs.push_back(s); } + } + in.close(); + + vector temp; + //merge query seqs and template seqs + temp = templateSeqs; + for (int i = 0; i < tempQuerySeqs.size(); i++) { temp.push_back(tempQuerySeqs[i]); } - //calculate number of iters - iters = (querySeqs[0]->getAligned().length() - window + 1) / increment; -cout << "length = " << querySeqs[0]->getAligned().length() << " window = " << window << " increment = " << increment << " iters = " << iters << endl; - int linesPerProcess = processors / numSeqs; - - //find breakup of sequences for all times we will Parallelize - if (processors == 1) { lines.push_back(new linePair(0, numSeqs)); } - else { - //fill line pairs - for (int i = 0; i < (processors-1); i++) { - lines.push_back(new linePair((i*linesPerProcess), ((i*linesPerProcess) + linesPerProcess))); + if (seqMask != "") { + reRead = true; + //mask templates + for (int i = 0; i < temp.size(); i++) { + decalc->runMask(temp[i]); + } } - //this is necessary to get remainder of processors / numSeqs so you don't miss any lines at the end - int i = processors - 1; - lines.push_back(new linePair((i*linesPerProcess), numSeqs)); + + mergedFilterString = createFilter(temp, 0.5); + + //reread template seqs + for (int i = 0; i < tempQuerySeqs.size(); i++) { delete tempQuerySeqs[i]; } } - //map query sequences to their most similiar sequences in the template - Parallelized - mothurOut("Finding closest sequence in template to each sequence... "); cout.flush(); - if (processors == 1) { findPairs(lines[0]->start, lines[0]->end); } - else { createProcessesPairs(); } - mothurOut("Done."); mothurOutEndLine(); - - //find Oqs for each sequence - the observed distance in each window - Parallelized - mothurOut("Calculating observed percentage differences for each sequence... "); cout.flush(); - if (processors == 1) { calcObserved(lines[0]->start, lines[0]->end); } - else { createProcessesObserved(); } - mothurOut("Done."); mothurOutEndLine(); - //find P - mothurOut("Calculating expected percentage differences for each sequence... "); cout.flush(); - vector probabilityProfile = calcFreq(templateSeqs); - - //make P into Q - for (int i = 0; i < probabilityProfile.size(); i++) { probabilityProfile[i] = 1 - probabilityProfile[i]; } - - //find Qav - averageProbability = findQav(probabilityProfile); - - //find Coefficient - maps a sequence to its coefficient - seqCoef = getCoef(averageProbability); - - //find Eqs for each sequence - the expected distance in each window - Parallelized - if (processors == 1) { calcExpected(lines[0]->start, lines[0]->end); } - else { createProcessesExpected(); } - mothurOut("Done."); mothurOutEndLine(); - - //find deviation - Parallelized - mothurOut("Finding deviation from expected... "); cout.flush(); - if (processors == 1) { calcDE(lines[0]->start, lines[0]->end); } - else { createProcessesDE(); } - mothurOut("Done."); mothurOutEndLine(); + //quantiles are used to determine whether the de values found indicate a chimera + //if you have to calculate them, its time intensive because you are finding the de and deviation values for each + //combination of sequences in the template + if (quanfile != "") { + quantiles = readQuantiles(); + }else { + if ((!filter) && (seqMask != "")) { //if you didn't filter but you want to mask. if you filtered then you did mask first above. + reRead = true; + //mask templates + for (int i = 0; i < templateSeqs.size(); i++) { + decalc->runMask(templateSeqs[i]); + } + } + + if (filter) { + reRead = true; + for (int i = 0; i < templateSeqs.size(); i++) { + runFilter(templateSeqs[i]); + } + } + + 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(); + if (processors == 1) { + quantilesMembers = decalc->getQuantiles(templateSeqs, windowSizesTemplate, window, probabilityProfile, increment, 0, templateSeqs.size()); + }else { createProcessesQuan(); } - - //free memory - for (int i = 0; i < lines.size(); i++) { delete lines[i]; } - delete distCalculator; + + ofstream out4, out5; + string noOutliers, outliers; + + if ((!filter) && (seqMask == "")) { + noOutliers = outputDir + getRootName(getSimpleName(templateFileName)) + "pintail.quan"; + }else if ((!filter) && (seqMask != "")) { + noOutliers = outputDir + getRootName(getSimpleName(templateFileName)) + "pintail.masked.quan"; + }else if ((filter) && (seqMask != "")) { + noOutliers = outputDir + getRootName(getSimpleName(templateFileName)) + "pintail.filtered." + getSimpleName(getRootName(fastafile)) + "masked.quan"; + }else if ((filter) && (seqMask == "")) { + noOutliers = outputDir + getRootName(getSimpleName(templateFileName)) + "pintail.filtered." + getSimpleName(getRootName(fastafile)) + "quan"; + } - } - catch(exception& e) { - errorOut(e, "Pintail", "getChimeras"); - exit(1); - } -} -//*************************************************************************************************************** -vector Pintail::readSeqs(string file) { - try { - - ifstream in; - openInputFile(file, in); - vector container; - - //read in seqs and store in vector - while(!in.eof()){ - Sequence* current = new Sequence(in); - - if (current->getAligned() == "") { current->setAligned(current->getUnaligned()); } - //takes out stuff is needed - current->setUnaligned(current->getUnaligned()); - - container.push_back(current); + + decalc->removeObviousOutliers(quantilesMembers, templateSeqs.size()); - gobble(in); - } - - in.close(); - return container; - - } - catch(exception& e) { - errorOut(e, "Pintail", "readSeqs"); - exit(1); - } -} - -//*************************************************************************************************************** -//calculate the distances from each query sequence to all sequences in the template to find the closest sequence -void Pintail::findPairs(int start, int end) { - try { - - for(int i = start; i < end; i++){ - - float smallest = 10000.0; - Sequence query = *(querySeqs[i]); - - for(int j = 0; j < templateSeqs.size(); j++){ + openOutputFile(noOutliers, out5); + //adjust quantiles + for (int i = 0; i < quantilesMembers.size(); i++) { + vector temp; - Sequence temp = *(templateSeqs[j]); + if (quantilesMembers[i].size() == 0) { + //in case this is not a distance found in your template files + for (int g = 0; g < 6; g++) { + temp.push_back(0.0); + } + }else{ + + sort(quantilesMembers[i].begin(), quantilesMembers[i].end(), compareQuanMembers); + + //save 10% + temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.10)].score); + //save 25% + temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.25)].score); + //save 50% + temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.5)].score); + //save 75% + temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.75)].score); + //save 95% + temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.95)].score); + //save 99% + temp.push_back(quantilesMembers[i][int(quantilesMembers[i].size() * 0.99)].score); + + } - distCalculator->calcDist(query, temp); - float dist = distCalculator->getDist(); + //output quan value + out5 << i+1 << '\t'; + for (int u = 0; u < temp.size(); u++) { out5 << temp[u] << '\t'; } + out5 << endl; - if (dist < smallest) { + quantiles[i] = temp; - bestfit[querySeqs[i]] = templateSeqs[j]; - smallest = dist; - } } + + mothurOut("Done."); mothurOutEndLine(); + } + + if (reRead) { + for (int i = 0; i < templateSeqs.size(); i++) { delete templateSeqs[i]; } + templateSeqs.clear(); + templateSeqs = readSeqs(templateFileName); } + + + //free memory + for (int i = 0; i < templateLines.size(); i++) { delete templateLines[i]; } } catch(exception& e) { - errorOut(e, "Pintail", "findPairs"); + errorOut(e, "Pintail", "doPrep"); exit(1); } } //*************************************************************************************************************** -void Pintail::calcObserved(int start, int end) { +void Pintail::print(ostream& out, ostream& outAcc) { try { - - - for(int i = start; i < end; i++){ - - itBest = bestfit.find(querySeqs[i]); - Sequence* query; - Sequence* subject; - - if (itBest != bestfit.end()) { - query = itBest->first; - subject = itBest->second; - }else{ mothurOut("Error in calcObserved"); mothurOutEndLine(); } -//cout << query->getName() << '\t' << subject->getName() << endl; - - int startpoint = 0; - for (int m = 0; m < iters; m++) { - - string seqFrag = query->getAligned().substr(startpoint, window); - string seqFragsub = subject->getAligned().substr(startpoint, window); - - int diff = 0; - for (int b = 0; b < seqFrag.length(); b++) { - - //if this is not a gap - if ((isalpha(seqFrag[b])) && (isalpha(seqFragsub[b]))) { - //and they are different - penalize - if (seqFrag[b] != seqFragsub[b]) { diff++; } - } - } - - //percentage of mismatched bases - float dist = diff / (float)seqFrag.length(); - - obsDistance[query].push_back(dist); - - startpoint += increment; + int index = ceil(deviation); + + //is your DE value higher than the 95% + string chimera; + if (index != 0) { //if index is 0 then its an exact match to a template seq + if (quantiles[index][4] == 0.0) { + chimera = "Your template does not include sequences that provide quantile values at distance " + toString(index); + }else { + if (DE > quantiles[index][4]) { chimera = "Yes"; } + else { chimera = "No"; } } + }else{ chimera = "No"; } + + out << querySeq->getName() << '\t' << "div: " << deviation << "\tstDev: " << DE << "\tchimera flag: " << chimera << endl; + if (chimera == "Yes") { + mothurOut(querySeq->getName() + "\tdiv: " + toString(deviation) + "\tstDev: " + toString(DE) + "\tchimera flag: " + chimera); mothurOutEndLine(); + outAcc << querySeq->getName() << endl; } + out << "Observed\t"; + + for (int j = 0; j < obsDistance.size(); j++) { out << obsDistance[j] << '\t'; } + out << endl; + + out << "Expected\t"; + + for (int m = 0; m < expectedDistance.size(); m++) { out << expectedDistance[m] << '\t'; } + out << endl; + } catch(exception& e) { - errorOut(e, "Pintail", "calcObserved"); + errorOut(e, "Pintail", "print"); exit(1); } } //*************************************************************************************************************** -void Pintail::calcExpected(int start, int end) { +int Pintail::getChimeras(Sequence* query) { try { - - - //for each sequence - for(int i = start; i < end; i++){ - - itCoef = seqCoef.find(querySeqs[i]); - float coef = itCoef->second; - - //for each window - vector queryExpected; - for (int m = 0; m < iters; m++) { - float expected = averageProbability[m] * coef; - queryExpected.push_back(expected); -//cout << "average variabilty over window = " << averageProbability[m] << " coef = " << coef << " ei = " << expected << '\t' << "window = " << m << endl; - } - - expectedDistance[querySeqs[i]] = queryExpected; - + querySeq = query; + trimmed.clear(); + windowSizes = window; + + //find pairs has to be done before a mask + bestfit = findPairs(query); + + //if they mask + if (seqMask != "") { + decalc->runMask(query); + decalc->runMask(bestfit); + } + + if (filter) { //must be done after a mask + runFilter(query); + runFilter(bestfit); } + - } - catch(exception& e) { - errorOut(e, "Pintail", "calcExpected"); - exit(1); - } -} -//*************************************************************************************************************** -void Pintail::calcDE(int start, int end) { - try { + //trim seq + decalc->trimSeqs(query, bestfit, trimmed); - - //for each sequence - for(int i = start; i < end; i++){ - - itObsDist = obsDistance.find(querySeqs[i]); - vector obs = itObsDist->second; - - itExpDist = expectedDistance.find(querySeqs[i]); - vector exp = itExpDist->second; -// cout << "difference between obs and exp = " << abs(obs[m] - exp[m]) << endl; - //for each window - float sum = 0.0; //sum = sum from 1 to m of (oi-ei)^2 - for (int m = 0; m < iters; m++) { sum += ((obs[m] - exp[m]) * (obs[m] - exp[m])); } - - float de = sqrt((sum / (iters - 1))); - - DE[querySeqs[i]] = de; - } + //find windows + it = trimmed.begin(); + windowsForeachQuery = decalc->findWindows(query, it->first, it->second, windowSizes, increment); + + //find observed distance + obsDistance = decalc->calcObserved(query, bestfit, windowsForeachQuery, windowSizes); + Qav = decalc->findQav(windowsForeachQuery, windowSizes, probabilityProfile); + + //find alpha + seqCoef = decalc->getCoef(obsDistance, Qav); + + //calculating expected distance + expectedDistance = decalc->calcExpected(Qav, seqCoef); + + //finding de + DE = decalc->calcDE(obsDistance, expectedDistance); + + //find distance between query and closest match + it = trimmed.begin(); + deviation = decalc->calcDist(query, bestfit, it->first, it->second); + + delete bestfit; + + return 0; } catch(exception& e) { - errorOut(e, "Pintail", "calcDE"); + errorOut(e, "Pintail", "getChimeras"); exit(1); } } //*************************************************************************************************************** -vector Pintail::calcFreq(vector seqs) { +vector Pintail::readFreq() { try { - + + ifstream in; + openInputFile(consfile, in); + vector prob; + set h = decalc->getPos(); //positions of bases in masking sequence - //at each position in the sequence - for (int i = 0; i < seqs[0]->getAligned().length(); i++) { + //read in probabilities and store in vector + int pos; float num; - vector freq; freq.resize(4,0); - int gaps = 0; - - //find the frequency of each nucleotide - for (int j = 0; j < seqs.size(); j++) { - - char value = seqs[j]->getAligned()[i]; - - if(toupper(value) == 'A') { freq[0]++; } - else if(toupper(value) == 'T' || toupper(value) == 'U') { freq[1]++; } - else if(toupper(value) == 'G') { freq[2]++; } - else if(toupper(value) == 'C') { freq[3]++; } - else { gaps++; } - } + while(!in.eof()){ - //find base with highest frequency - int highest = 0; - for (int m = 0; m < freq.size(); m++) { if (freq[m] > highest) { highest = freq[m]; } } + in >> pos >> num; - //add in gaps - so you can effectively "ignore them" - highest += gaps; + if (h.count(pos) > 0) { + float Pi; + Pi = (num - 0.25) / 0.75; - float highFreq = highest / (float) seqs.size(); + //cannot have probability less than 0. + if (Pi < 0) { Pi = 0.0; } + + //do you want this spot + prob.push_back(Pi); + } - float Pi; - Pi = (highFreq - 0.25) / 0.75; - - prob.push_back(Pi); + gobble(in); } + in.close(); return prob; - - } - catch(exception& e) { - errorOut(e, "Pintail", "calcFreq"); - exit(1); - } -} -//*************************************************************************************************************** -vector Pintail::findQav(vector prob) { - try { - vector averages; - - //for each window find average - int startpoint = 0; - for (int m = 0; m < iters; m++) { - - float average = 0.0; - for (int i = startpoint; i < (startpoint+window); i++) { average += prob[i]; } - - average = average / window; -//cout << average << endl; - //save this windows average - averages.push_back(average); - startpoint += increment; - } - - return averages; } catch(exception& e) { - errorOut(e, "Pintail", "findQav"); + errorOut(e, "Pintail", "readFreq"); exit(1); } } + //*************************************************************************************************************** -map Pintail::getCoef(vector prob) { +//calculate the distances from each query sequence to all sequences in the template to find the closest sequence +Sequence* Pintail::findPairs(Sequence* q) { try { - map coefs; - - //find average prob - float probAverage = 0.0; - for (int i = 0; i < prob.size(); i++) { probAverage += prob[i]; } - probAverage = probAverage / (float) prob.size(); -cout << "(sum of ai) / m = " << probAverage << endl; - //find a coef for each sequence - map >::iterator it; - for (it = obsDistance.begin(); it != obsDistance.end(); it++) { - - vector temp = it->second; - Sequence* tempSeq = it->first; - - //find observed average - float obsAverage = 0.0; - for (int i = 0; i < temp.size(); i++) { obsAverage += temp[i]; } - obsAverage = obsAverage / (float) temp.size(); -cout << tempSeq->getName() << '\t' << obsAverage << endl; - float coef = obsAverage / probAverage; -cout << tempSeq->getName() << '\t' << "coef = " << coef << endl; - //save this sequences coefficient - coefs[tempSeq] = coef; - } - - return coefs; - } - catch(exception& e) { - errorOut(e, "Pintail", "getCoef"); - exit(1); - } -} - -/**************************************************************************************************/ - -void Pintail::createProcessesPairs() { - try { -#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) - int process = 0; - vector processIDS; - - //loop through and create all the processes you want - while (process != processors) { - int pid = fork(); - - if (pid > 0) { - processIDS.push_back(pid); - process++; - }else if (pid == 0){ - findPairs(lines[process]->start, lines[process]->end); - exit(0); - }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); } - } - - //force parent to wait until all the processes are done - for (int i=0;istart, lines[0]->end); - -#endif + seqsMatches = decalc->findClosest(q, templateSeqs); + return seqsMatches; + } catch(exception& e) { - errorOut(e, "Pintail", "createProcessesPairs"); + errorOut(e, "Pintail", "findPairs"); exit(1); } } - /**************************************************************************************************/ - -void Pintail::createProcessesObserved() { +void Pintail::createProcessesQuan() { try { #if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) int process = 0; vector processIDS; - + //loop through and create all the processes you want while (process != processors) { int pid = fork(); @@ -486,7 +385,26 @@ void Pintail::createProcessesObserved() { processIDS.push_back(pid); process++; }else if (pid == 0){ - calcObserved(lines[process]->start, lines[process]->end); + + quantilesMembers = decalc->getQuantiles(templateSeqs, windowSizesTemplate, window, probabilityProfile, increment, templateLines[process]->start, templateLines[process]->end); + + //write out data to file so parent can read it + ofstream out; + string s = toString(getpid()) + ".temp"; + openOutputFile(s, out); + + + //output observed distances + for (int i = 0; i < quantilesMembers.size(); i++) { + out << quantilesMembers[i].size() << '\t'; + for (int j = 0; j < quantilesMembers[i].size(); j++) { + out << quantilesMembers[i][j].score << '\t' << quantilesMembers[i][j].member1 << '\t' << quantilesMembers[i][j].member2 << '\t'; + } + out << endl; + } + + out.close(); + exit(0); }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); } } @@ -496,94 +414,59 @@ void Pintail::createProcessesObserved() { int temp = processIDS[i]; wait(&temp); } - -#else - calcObserved(lines[0]->start, lines[0]->end); - -#endif - } - catch(exception& e) { - errorOut(e, "Pintail", "createProcessesObserved"); - exit(1); - } -} -//*************************************************************************************************************** - -void Pintail::createProcessesExpected() { - try { -#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) - int process = 0; - vector processIDS; - - //loop through and create all the processes you want - while (process != processors) { - int pid = fork(); - - if (pid > 0) { - processIDS.push_back(pid); - process++; - }else if (pid == 0){ - calcExpected(lines[process]->start, lines[process]->end); - exit(0); - }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); } - } - - //force parent to wait until all the processes are done + //get data created by processes for (int i=0;istart, lines[0]->end); - -#endif - } - catch(exception& e) { - errorOut(e, "Pintail", "createProcessesExpected"); - exit(1); - } -} - -/**************************************************************************************************/ + ifstream in; + string s = toString(processIDS[i]) + ".temp"; + openInputFile(s, in); + + vector< vector > quan; + quan.resize(100); + + //get quantiles + for (int m = 0; m < quan.size(); m++) { + int num; + in >> num; + + gobble(in); -void Pintail::createProcessesDE() { - try { -#if defined (__APPLE__) || (__MACH__) || (linux) || (__linux) - int process = 0; - vector processIDS; - - //loop through and create all the processes you want - while (process != processors) { - int pid = fork(); + vector q; float w; int b, n; + for (int j = 0; j < num; j++) { + in >> w >> b >> n; + //cout << w << '\t' << b << '\t' n << endl; + quanMember newMember(w, b, n); + q.push_back(newMember); + } +//cout << "here" << endl; + quan[m] = q; +//cout << "now here" << endl; + gobble(in); + } - if (pid > 0) { - processIDS.push_back(pid); - process++; - }else if (pid == 0){ - calcDE(lines[process]->start, lines[process]->end); - exit(0); - }else { mothurOut("unable to spawn the necessary processes."); mothurOutEndLine(); exit(0); } - } - - //force parent to wait until all the processes are done - for (int i=0;istart, lines[0]->end); - + quantilesMembers = decalc->getQuantiles(templateSeqs, windowSizesTemplate, window, probabilityProfile, increment, 0, templateSeqs.size()); #endif } catch(exception& e) { - errorOut(e, "Pintail", "createProcessesDE"); + errorOut(e, "Pintail", "createProcessesQuan"); exit(1); } } + //***************************************************************************************************************