#include "chimera.h"
#include "dist.h"
#include "eachgapdist.h"
+#include "ignoregaps.h"
//***************************************************************************************************************
-void DeCalculator::setMask(string m) {
+void DeCalculator::setMask(string ms) {
try {
- seqMask = m;
+ seqMask = ms;
int count = 0;
maskMap.clear();
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "setMask");
+ m->errorOut(e, "DeCalculator", "setMask");
exit(1);
}
}
seq->setUnaligned(tempQuery);
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "runMask");
+ m->errorOut(e, "DeCalculator", "runMask");
exit(1);
}
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "trimSeqs");
+ m->errorOut(e, "DeCalculator", "trimSeqs");
exit(1);
}
}
if (size == 0) { if (cutoff > 1200) { size = 300; }
else{ size = (cutoff / 4); } }
else if (size > (cutoff / 4)) {
- mothurOut("You have selected too large a window size for sequence " + query->getName() + ". I will choose an appropriate window size."); mothurOutEndLine();
+ m->mothurOut("You have selected too large a window size for sequence " + query->getName() + ". I will choose an appropriate window size."); m->mothurOutEndLine();
size = (cutoff / 4);
}
*/
//this follows wigeon, but we may want to consider that it chops off the end values if the sequence cannot be evenly divided into steps
- for (int m = front; m < (back - size) ; m+=increment) { win.push_back(m); }
+ for (int i = front; i < (back - size) ; i+=increment) { win.push_back(i); }
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findWindows");
+ m->errorOut(e, "DeCalculator", "findWindows");
exit(1);
}
}
vector<float> temp;
//int gaps = 0;
- for (int m = 0; m < window.size(); m++) {
+ for (int i = 0; i < window.size(); i++) {
- string seqFrag = query->getAligned().substr(window[m], size);
- string seqFragsub = subject->getAligned().substr(window[m], size);
+ string seqFrag = query->getAligned().substr(window[i], size);
+ string seqFragsub = subject->getAligned().substr(window[i], size);
int diff = 0;
for (int b = 0; b < seqFrag.length(); b++) {
return temp;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcObserved");
+ m->errorOut(e, "DeCalculator", "calcObserved");
exit(1);
}
}
return dist;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcDist");
+ m->errorOut(e, "DeCalculator", "calcDist");
exit(1);
}
}
//for each window
vector<float> queryExpected;
- for (int m = 0; m < qav.size(); m++) {
+ for (int j = 0; j < qav.size(); j++) {
- float expected = qav[m] * coef;
+ float expected = qav[j] * coef;
queryExpected.push_back(expected);
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcExpected");
+ m->errorOut(e, "DeCalculator", "calcExpected");
exit(1);
}
}
try {
//for each window
- float sum = 0.0; //sum = sum from 1 to m of (oi-ei)^2
+ float sum = 0.0; //sum = sum from 1 to i of (oi-ei)^2
int numZeros = 0;
- for (int m = 0; m < obs.size(); m++) {
+ for (int j = 0; j < obs.size(); j++) {
- //if (obs[m] != 0.0) {
- sum += ((obs[m] - exp[m]) * (obs[m] - exp[m]));
+ //if (obs[j] != 0.0) {
+ sum += ((obs[j] - exp[j]) * (obs[j] - exp[j]));
//}else { numZeros++; }
}
return de;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcDE");
+ m->errorOut(e, "DeCalculator", "calcDE");
exit(1);
}
}
try {
vector<float> prob;
- string freqfile = getRootName(filename) + "freq";
+ string freqfile = m->getRootName(filename) + "freq";
ofstream outFreq;
- openOutputFile(freqfile, outFreq);
+ m->openOutputFile(freqfile, outFreq);
+
+ outFreq << "#" << m->getVersion() << endl;
string length = toString(seqs.size()); //if there are 5000 seqs in the template then set precision to 3
int precision = length.length() - 1;
//find base with highest frequency
int highest = 0;
- for (int m = 0; m < freq.size(); m++) { if (freq[m] > highest) { highest = freq[m]; } }
+ for (int j = 0; j < freq.size(); j++) { if (freq[j] > highest) { highest = freq[j]; } }
float highFreq = highest / (float) (seqs.size());
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcFreq");
+ m->errorOut(e, "DeCalculator", "calcFreq");
exit(1);
}
}
vector<float> averages;
//for each window find average
- for (int m = 0; m < window.size(); m++) {
+ for (int i = 0; i < window.size(); i++) {
float average = 0.0;
//while you are in the window for this sequence
int count = 0;
- for (int j = window[m]; j < (window[m]+size); j++) {
+ for (int j = window[i]; j < (window[i]+size); j++) {
average += probabilityProfile[j];
count++;
}
return averages;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findQav");
+ m->errorOut(e, "DeCalculator", "findQav");
exit(1);
}
}
//***************************************************************************************************************
//seqs have already been masked
-vector< vector<quanMember> > DeCalculator::getQuantiles(vector<Sequence*> seqs, vector<int> windowSizesTemplate, int window, vector<float> probProfile, int increment, int start, int end) {
+vector< vector<float> > DeCalculator::getQuantiles(vector<Sequence*> seqs, vector<int> windowSizesTemplate, int window, vector<float> probProfile, int increment, int start, int end) {
try {
- vector< vector<quanMember> > quan;
+ vector< vector<float> > quan;
//percentage of mismatched pairs 1 to 100
quan.resize(100);
-//ofstream o;
-//string out = "getQuantiles.out";
-//openOutputFile(out, o);
-
+
//for each sequence
for(int i = start; i < end; i++){
- mothurOut("Processing sequence " + toString(i)); mothurOutEndLine();
+ m->mothurOut("Processing sequence " + toString(i)); m->mothurOutEndLine();
Sequence* query = new Sequence(seqs[i]->getName(), seqs[i]->getAligned());
//compare to every other sequence in template
Sequence* subject = new Sequence(seqs[j]->getName(), seqs[j]->getAligned());
+ if (m->control_pressed) { delete query; delete subject; return quan; }
+
map<int, int> trim;
map<int, int>::iterator it;
float de = calcDE(obsi, exp);
float dist = calcDist(query, subject, front, back);
- //o << i << '\t' << j << '\t' << dist << '\t' << de << endl;
+ //cout << i << '\t' << j << '\t' << dist << '\t' << de << endl;
dist = ceil(dist);
- quanMember newScore(de, i, j);
-
- quan[dist].push_back(newScore);
+ //quanMember newScore(de, i, j);
+ quan[dist].push_back(de);
+
delete subject;
}
delete query;
}
+
return quan;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "getQuantiles");
+ m->errorOut(e, "DeCalculator", "getQuantiles");
exit(1);
}
}
}
//***************************************************************************************************************
//this was going to be used by pintail to increase the sensitivity of the chimera detection, but it wasn't quite right. may want to revisit in the future...
-void DeCalculator::removeObviousOutliers(vector< vector<quanMember> >& quantiles, int num) {
+void DeCalculator::removeObviousOutliers(vector< vector<float> >& quantiles, int num) {
try {
for (int i = 0; i < quantiles.size(); i++) {
-
- //find mean of this quantile score
- sort(quantiles[i].begin(), quantiles[i].end(), compareQuanMembers);
-
- float high = quantiles[i][int(quantiles[i].size() * 0.99)].score;
- float low = quantiles[i][int(quantiles[i].size() * 0.01)].score;
- vector<quanMember> temp;
+ //find mean of this quantile score
+ sort(quantiles[i].begin(), quantiles[i].end());
- //look at each value in quantiles to see if it is an outlier
- for (int j = 0; j < quantiles[i].size(); j++) {
- //is this score between 1 and 99%
- if ((quantiles[i][j].score > low) && (quantiles[i][j].score < high)) {
- temp.push_back(quantiles[i][j]);
+ vector<float> temp;
+ if (quantiles[i].size() != 0) {
+ float high = quantiles[i][int(quantiles[i].size() * 0.99)];
+ float low = quantiles[i][int(quantiles[i].size() * 0.01)];
+
+ //look at each value in quantiles to see if it is an outlier
+ for (int j = 0; j < quantiles[i].size(); j++) {
+ //is this score between 1 and 99%
+ if ((quantiles[i][j] > low) && (quantiles[i][j] < high)) {
+ temp.push_back(quantiles[i][j]);
+ }
}
}
-
quantiles[i] = temp;
}
//while you still have guys to eliminate
while (contributions.size() > 0) {
- mothurOut("Removing scores contributed by sequence " + toString(largestContrib) + " in your template file."); mothurOutEndLine();
+ m->mothurOut("Removing scores contributed by sequence " + toString(largestContrib) + " in your template file."); m->mothurOutEndLine();
//remove from quantiles all scores that were made using this largestContrib
for (int i = 0; i < quantiles.size(); i++) {
for(int i = 0; i < marked.size(); i++) {
if (marked[i] > high) {
- mothurOut("Removing scores contributed by sequence " + toString(marked[i]) + " in your template file."); mothurOutEndLine();
+ m->mothurOut("Removing scores contributed by sequence " + toString(marked[i]) + " in your template file."); m->mothurOutEndLine();
for (int i = 0; i < quantiles.size(); i++) {
removeContrib(marked[i], quantiles[i]);
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "removeObviousOutliers");
+ m->errorOut(e, "DeCalculator", "removeObviousOutliers");
exit(1);
}
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "sortContrib");
+ m->errorOut(e, "DeCalculator", "sortContrib");
exit(1);
}
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findLargestContribs");
+ m->errorOut(e, "DeCalculator", "findLargestContribs");
exit(1);
}
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "removeContrib");
+ m->errorOut(e, "DeCalculator", "removeContrib");
exit(1);
}
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findAverage");
+ m->errorOut(e, "DeCalculator", "findAverage");
exit(1);
}
}
return coef;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "getCoef");
+ m->errorOut(e, "DeCalculator", "getCoef");
exit(1);
}
}
//***************************************************************************************************************
//gets closest matches to each end, since chimeras will most likely have different parents on each end
-vector<Sequence*> DeCalculator::findClosest(Sequence* querySeq, vector<Sequence*> db, int numWanted) {
+vector<Sequence*> DeCalculator::findClosest(Sequence* querySeq, vector<Sequence*> db, int& numWanted, vector<int>& indexes) {
try {
+ indexes.clear();
vector<Sequence*> seqsMatches;
- vector<SeqDist> dists;
+
+ vector<SeqDist> distsLeft;
+ vector<SeqDist> distsRight;
Dist* distcalculator = new eachGapDist();
string queryAligned = querySeq->getAligned();
//left side
+ bool foundFirstBase = false;
int baseCount = 0;
int leftSpot = 0;
+ int firstBaseSpot = 0;
for (int i = 0; i < queryAligned.length(); i++) {
- leftQuery += queryAligned[i];
//if you are a base
- if ((queryAligned[i] != '.') && (queryAligned[i] != '-')) { baseCount++; }
+ if (isalpha(queryAligned[i])) {
+ baseCount++;
+ if (!foundFirstBase) { foundFirstBase = true; firstBaseSpot = i; }
+ }
+
+ //eliminate opening .'s
+ if (foundFirstBase) { leftQuery += queryAligned[i]; }
//if you have 1/3
if (baseCount >= numBases) { leftSpot = i; break; } //first 1/3
}
int rightSpot = 0;
for (int i = leftSpot; i < queryAligned.length(); i++) {
//if you are a base
- if ((queryAligned[i] != '.') && (queryAligned[i] != '-')) { baseCount++; }
+ if (isalpha(queryAligned[i])) { baseCount++; }
//if you have 1/3
if (baseCount >= numBases) { rightSpot = i; break; } //last 1/3
}
- rightQuery = queryAligned.substr(rightSpot); //sequence from pos spot to end
+
+ //trim end
+ //find last position in query that is a non gap character
+ int lastBaseSpot = queryAligned.length()-1;
+ for (int j = queryAligned.length()-1; j >= 0; j--) {
+ if (isalpha(queryAligned[j])) {
+ lastBaseSpot = j;
+ break;
+ }
+ }
+ rightQuery = queryAligned.substr(rightSpot, (lastBaseSpot-rightSpot)); //sequence from pos spot to end
Sequence queryLeft(querySeq->getName(), leftQuery);
Sequence queryRight(querySeq->getName(), rightQuery);
-//cout << querySeq->getName() << '\t' << leftSpot << '\t' << rightSpot << endl;
+//cout << querySeq->getName() << '\t' << leftSpot << '\t' << rightSpot << '\t' << firstBaseSpot << '\t' << lastBaseSpot << endl;
//cout << queryUnAligned.length() << '\t' << queryLeft.getUnaligned().length() << '\t' << queryRight.getUnaligned().length() << endl;
for(int j = 0; j < db.size(); j++){
string dbAligned = db[j]->getAligned();
- string leftDB = dbAligned.substr(0, leftSpot+1); //first 1/3 of the sequence
- string rightDB = dbAligned.substr(rightSpot); //last 1/3 of the sequence
+ string leftDB = dbAligned.substr(firstBaseSpot, (leftSpot-firstBaseSpot+1)); //first 1/3 of the sequence
+ string rightDB = dbAligned.substr(rightSpot, (lastBaseSpot-rightSpot)); //last 1/3 of the sequence
Sequence dbLeft(db[j]->getName(), leftDB);
Sequence dbRight(db[j]->getName(), rightDB);
distcalculator->calcDist(queryRight, dbRight);
float distRight = distcalculator->getDist();
- float dist = min(distLeft, distRight); //keep smallest distance
+ SeqDist subjectLeft;
+ subjectLeft.seq = NULL;
+ subjectLeft.dist = distLeft;
+ subjectLeft.index = j;
- SeqDist subject;
- subject.seq = db[j];
- subject.dist = dist;
+ distsLeft.push_back(subjectLeft);
- dists.push_back(subject);
+ SeqDist subjectRight;
+ subjectRight.seq = NULL;
+ subjectRight.dist = distRight;
+ subjectRight.index = j;
+
+ distsRight.push_back(subjectRight);
+
}
delete distcalculator;
- sort(dists.begin(), dists.end(), compareSeqDist);
+ //sort by smallest distance
+ sort(distsRight.begin(), distsRight.end(), compareSeqDist);
+ sort(distsLeft.begin(), distsLeft.end(), compareSeqDist);
+
+ //merge results
+ map<string, string> seen;
+ map<string, string>::iterator it;
+
+ vector<SeqDist> dists;
+ float lastRight = distsRight[0].dist;
+ float lastLeft = distsLeft[0].dist;
+ int lasti = 0;
+ for (int i = 0; i < distsLeft.size(); i++) {
+ //add left if you havent already
+ it = seen.find(db[distsLeft[i].index]->getName());
+ if (it == seen.end()) {
+ dists.push_back(distsLeft[i]);
+ seen[db[distsLeft[i].index]->getName()] = db[distsLeft[i].index]->getName();
+ lastLeft = distsLeft[i].dist;
+ }
+
+ //add right if you havent already
+ it = seen.find(db[distsRight[i].index]->getName());
+ if (it == seen.end()) {
+ dists.push_back(distsRight[i]);
+ seen[db[distsRight[i].index]->getName()] = db[distsRight[i].index]->getName();
+ lastRight = distsRight[i].dist;
+ }
+
+ if (dists.size() > numWanted) { lasti = i; break; } //you have enough results
+ }
+
+ //add in dups
+ lasti++;
+ int i = lasti;
+ while (i < distsLeft.size()) {
+ if (distsLeft[i].dist == lastLeft) { dists.push_back(distsLeft[i]); numWanted++; }
+ else { break; }
+ i++;
+ }
+ i = lasti;
+ while (i < distsRight.size()) {
+ if (distsRight[i].dist == lastRight) { dists.push_back(distsRight[i]); numWanted++; }
+ else { break; }
+ i++;
+ }
+
+ if (numWanted > dists.size()) { m->mothurOut("numwanted is larger than the number of template sequences, adjusting numwanted."); m->mothurOutEndLine(); numWanted = dists.size(); }
+
+//cout << numWanted << endl;
for (int i = 0; i < numWanted; i++) {
- Sequence* temp = new Sequence(dists[i].seq->getName(), dists[i].seq->getAligned()); //have to make a copy so you can trim and filter without stepping on eachother.
+//cout << dists[i].seq->getName() << '\t' << dists[i].dist << endl;
+ Sequence* temp = new Sequence(db[dists[i].index]->getName(), db[dists[i].index]->getAligned()); //have to make a copy so you can trim and filter without stepping on eachother.
seqsMatches.push_back(temp);
+ indexes.push_back(dists[i].index);
}
return seqsMatches;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findClosest");
+ m->errorOut(e, "DeCalculator", "findClosest");
+ exit(1);
+ }
+}
+//***************************************************************************************************************
+Sequence* DeCalculator::findClosest(Sequence* querySeq, vector<Sequence*> db) {
+ try {
+
+ Sequence* seqsMatch;
+
+ Dist* distcalculator = new eachGapDist();
+ int index = 0;
+ int smallest = 1000000;
+
+ for(int j = 0; j < db.size(); j++){
+
+ distcalculator->calcDist(*querySeq, *db[j]);
+ float dist = distcalculator->getDist();
+
+ if (dist < smallest) {
+ smallest = dist;
+ index = j;
+ }
+ }
+
+ delete distcalculator;
+
+ seqsMatch = new Sequence(db[index]->getName(), db[index]->getAligned()); //have to make a copy so you can trim and filter without stepping on eachother.
+
+ return seqsMatch;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "DeCalculator", "findClosest");
exit(1);
}
}
//save this spot if it is the farthest
if (pos < rearPos) { rearPos = pos; }
-
- //check to make sure that is not whole seq
- if ((rearPos - frontPos - 1) <= 0) { mothurOut("Error, when I trim your sequences, the entire sequence is trimmed."); mothurOutEndLine(); exit(1); }
-//cout << "front = " << frontPos << " rear = " << rearPos << endl;
- //trim query
- string newAligned = query->getAligned();
- newAligned = newAligned.substr(frontPos, (rearPos-frontPos));
- query->setAligned(newAligned);
-
- //trim topMatches
- for (int i = 0; i < topMatches.size(); i++) {
- newAligned = topMatches[i]->getAligned();
- newAligned = newAligned.substr(frontPos, (rearPos-frontPos+1));
- topMatches[i]->setAligned(newAligned);
- }
map<int, int> trimmedPos;
-
- for (int i = 0; i < newAligned.length(); i++) {
- trimmedPos[i] = i+frontPos;
+ //check to make sure that is not whole seq
+ if ((rearPos - frontPos - 1) <= 0) {
+ m->mothurOut("[ERROR]: when I trim " + query->getName() + ", the entire sequence is trimmed. Skipping."); m->mothurOutEndLine();
+ query->setAligned("");
+ //trim topMatches
+ for (int i = 0; i < topMatches.size(); i++) {
+ topMatches[i]->setAligned("");
+ }
+
+ }else {
+
+ //trim query
+ string newAligned = query->getAligned();
+ newAligned = newAligned.substr(frontPos, (rearPos-frontPos+1));
+ query->setAligned(newAligned);
+
+ //trim topMatches
+ for (int i = 0; i < topMatches.size(); i++) {
+ newAligned = topMatches[i]->getAligned();
+ newAligned = newAligned.substr(frontPos, (rearPos-frontPos+1));
+ topMatches[i]->setAligned(newAligned);
+ }
+
+ for (int i = 0; i < newAligned.length(); i++) {
+ trimmedPos[i] = i+frontPos;
+ }
}
-
return trimmedPos;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "trimSequences");
+ m->errorOut(e, "DeCalculator", "trimSequences");
exit(1);
}