*/
#include "decalc.h"
+#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();
if (seqMask.length() != 0) {
//whereever there is a base in the mask, save that value is query and subject
for (int i = 0; i < seqMask.length(); i++) {
if (isalpha(seqMask[i])) {
h.insert(i);
+ maskMap[count] = i;
+ count++;
+
}
}
}else {
- for (int i = 0; i < alignLength; i++) { h.insert(i); }
+ for (int i = 0; i < alignLength; i++) {
+ h.insert(i);
+ maskMap[count] = i;
+ count++;
+ }
}
}
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 to 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);
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findWindows");
+ m->errorOut(e, "DeCalculator", "findWindows");
exit(1);
}
}
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);
}
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcExpected");
+ m->errorOut(e, "DeCalculator", "calcExpected");
exit(1);
}
}
//for each window
float sum = 0.0; //sum = sum from 1 to m of (oi-ei)^2
- for (int m = 0; m < obs.size(); m++) { sum += ((obs[m] - exp[m]) * (obs[m] - exp[m])); }
+ int numZeros = 0;
+ for (int m = 0; m < obs.size(); m++) {
- float de = sqrt((sum / (obs.size() - 1)));
+ //if (obs[m] != 0.0) {
+ sum += ((obs[m] - exp[m]) * (obs[m] - exp[m]));
+ //}else { numZeros++; }
+
+ }
+
+ float de = sqrt((sum / (obs.size() - 1 - numZeros)));
return de;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcDE");
+ m->errorOut(e, "DeCalculator", "calcDE");
exit(1);
}
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "calcFreq");
+ m->errorOut(e, "DeCalculator", "calcFreq");
exit(1);
}
}
return averages;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findQav");
+ m->errorOut(e, "DeCalculator", "findQav");
exit(1);
}
}
//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;
dist = ceil(dist);
quanMember newScore(de, i, j);
- //dist-1 because vector indexes start at 0.
- quan[dist-1].push_back(newScore);
+ quan[dist].push_back(newScore);
delete subject;
}
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "getQuantiles");
+ m->errorOut(e, "DeCalculator", "getQuantiles");
exit(1);
}
}
-
+//********************************************************************************************************************
+//sorts lowest to highest
+inline bool compareQuanMembers(quanMember left, quanMember right){
+ return (left.score < right.score);
+}
//***************************************************************************************************************
//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...
-vector< vector<float> > DeCalculator::removeObviousOutliers(vector< vector<quanMember> >& quantiles, int num) {
+void DeCalculator::removeObviousOutliers(vector< vector<quanMember> >& quantiles, int num) {
try {
- vector< vector<float> > quan;
- quan.resize(100);
-
- /*vector<quanMember> contributions;
- vector<int> seen; //seen[0] is the number of outliers that template seqs[0] was part of.
- seen.resize(num,0);
-
- //find contributions
+
for (int i = 0; i < quantiles.size(); i++) {
//find mean of this quantile score
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;
+
//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)) {
-
- }else {
- //add to contributions
- contributions.push_back(quantiles[i][j]);
- seen[quantiles[i][j].member1]++;
- seen[quantiles[i][j].member2]++;
+ temp.push_back(quantiles[i][j]);
}
}
+
+ quantiles[i] = temp;
}
+/*
//find contributer with most offending score related to it
int largestContrib = findLargestContrib(seen);
//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]);
}
}
*/
- return quan;
+
}
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<int>& indexes) {
+ try {
+ indexes.clear();
+
+ vector<Sequence*> seqsMatches;
+ vector<SeqDist> distsLeft;
+ vector<SeqDist> distsRight;
+
+ Dist* distcalculator = new eachGapDist();
+
+ string queryUnAligned = querySeq->getUnaligned();
+ int numBases = int(queryUnAligned.length() * 0.33);
+
+ string leftQuery = ""; //first 1/3 of the sequence
+ string rightQuery = ""; //last 1/3 of the sequence
+ 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++) {
+ //if you are a base
+ 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
+ }
+
+ //right side - count through another 1/3, so you are at last third
+ baseCount = 0;
+ int rightSpot = 0;
+ for (int i = leftSpot; i < queryAligned.length(); i++) {
+ //if you are a base
+ if (isalpha(queryAligned[i])) { baseCount++; }
+ //if you have 1/3
+ if (baseCount >= numBases) { rightSpot = i; break; } //last 1/3
+ }
+
+ //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 << '\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(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(queryLeft, dbLeft);
+ float distLeft = distcalculator->getDist();
+
+ distcalculator->calcDist(queryRight, dbRight);
+ float distRight = distcalculator->getDist();
+
+ SeqDist subjectLeft;
+ subjectLeft.seq = db[j];
+ subjectLeft.dist = distLeft;
+ subjectLeft.index = j;
+
+ distsLeft.push_back(subjectLeft);
+
+ SeqDist subjectRight;
+ subjectRight.seq = db[j];
+ subjectRight.dist = distRight;
+ subjectRight.index = j;
+
+ distsRight.push_back(subjectRight);
+
+ }
+
+ delete distcalculator;
+
+ //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(distsLeft[i].seq->getName());
+ if (it == seen.end()) {
+ dists.push_back(distsLeft[i]);
+ seen[distsLeft[i].seq->getName()] = distsLeft[i].seq->getName();
+ lastLeft = distsLeft[i].dist;
+ }
+
+ //add right if you havent already
+ it = seen.find(distsRight[i].seq->getName());
+ if (it == seen.end()) {
+ dists.push_back(distsRight[i]);
+ seen[distsRight[i].seq->getName()] = distsRight[i].seq->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++;
+ }
+
+//cout << numWanted << endl;
+ for (int i = 0; i < numWanted; i++) {
+//cout << dists[i].seq->getName() << '\t' << dists[i].dist << endl;
+ 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.
+ seqsMatches.push_back(temp);
+ indexes.push_back(dists[i].index);
+ }
+
+ return seqsMatches;
+ }
+ catch(exception& e) {
+ 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);
+ }
+}
+/***************************************************************************************************************/
+map<int, int> DeCalculator::trimSeqs(Sequence* query, vector<Sequence*> topMatches) {
+ try {
+
+ int frontPos = 0; //should contain first position in all seqs that is not a gap character
+ int rearPos = query->getAligned().length();
+
+ //********find first position in topMatches that is a non gap character***********//
+ //find first position all query seqs that is a non gap character
+ for (int i = 0; i < topMatches.size(); i++) {
+
+ string aligned = topMatches[i]->getAligned();
+ int pos = 0;
+
+ //find first spot in this seq
+ for (int j = 0; j < aligned.length(); j++) {
+ if (isalpha(aligned[j])) {
+ pos = j;
+ break;
+ }
+ }
+
+ //save this spot if it is the farthest
+ if (pos > frontPos) { frontPos = pos; }
+ }
+
+
+ string aligned = query->getAligned();
+ int pos = 0;
+
+ //find first position in query that is a non gap character
+ for (int j = 0; j < aligned.length(); j++) {
+ if (isalpha(aligned[j])) {
+ pos = j;
+ break;
+ }
+ }
+
+ //save this spot if it is the farthest
+ if (pos > frontPos) { frontPos = pos; }
+
+
+ //********find last position in topMatches that is a non gap character***********//
+ for (int i = 0; i < topMatches.size(); i++) {
+
+ string aligned = topMatches[i]->getAligned();
+ int pos = aligned.length();
+
+ //find first spot in this seq
+ for (int j = aligned.length()-1; j >= 0; j--) {
+ if (isalpha(aligned[j])) {
+ pos = j;
+ break;
+ }
+ }
+
+ //save this spot if it is the farthest
+ if (pos < rearPos) { rearPos = pos; }
+ }
+
+
+ aligned = query->getAligned();
+ pos = aligned.length();
+
+ //find last position in query that is a non gap character
+ for (int j = aligned.length()-1; j >= 0; j--) {
+ if (isalpha(aligned[j])) {
+ pos = j;
+ break;
+ }
+ }
+
+ //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) { m->mothurOut("Error, when I trim your sequences, the entire sequence is trimmed."); m->mothurOutEndLine(); exit(1); }
+//cout << query->getName() << " front = " << frontPos << " rear = " << rearPos << endl;
+ //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);
+ }
+
+ map<int, int> trimmedPos;
+
+ for (int i = 0; i < newAligned.length(); i++) {
+ trimmedPos[i] = i+frontPos;
+ }
+
+ return trimmedPos;
+ }
+ catch(exception& e) {
+ m->errorOut(e, "DeCalculator", "trimSequences");
+ exit(1);
+ }
+
+}
+//***************************************************************************************************************
+