#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);
}
}
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);
}
}
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);
}
}
//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);
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "getQuantiles");
+ m->errorOut(e, "DeCalculator", "getQuantiles");
exit(1);
}
}
//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 = db[j];
+ 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 = db[j];
+ 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(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++;
+ }
+
+ 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++) {
+//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) {
- 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);
}
}
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;
+ 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));
+ newAligned = newAligned.substr(frontPos, (rearPos-frontPos+1));
query->setAligned(newAligned);
//trim topMatches
return trimmedPos;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "trimSequences");
+ m->errorOut(e, "DeCalculator", "trimSequences");
exit(1);
}
projects / mothur.git / blobdiff