void DeCalculator::setMask(string m) {
try {
seqMask = m;
+ 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) {
try {
vector<float> temp;
-
+ //int gaps = 0;
for (int m = 0; m < window.size(); m++) {
string seqFrag = query->getAligned().substr(window[m], size);
for (int b = 0; b < seqFrag.length(); b++) {
//if at least one is a base and they are not equal
if( (isalpha(seqFrag[b]) || isalpha(seqFragsub[b])) && (seqFrag[b] != seqFragsub[b]) ) { diff++; }
+
+ //ignore gaps
+ //if((!isalpha(seqFrag[b])) && (!isalpha(seqFragsub[b]))) { gaps++; }
}
//percentage of mismatched bases
float dist;
//if the whole fragment is 0 distance = 0
+ //if ((seqFrag.length()-gaps) == 0) { dist = 0.0; }
+
+ //percentage of mismatched bases
+ //else { dist = diff / (float) (seqFrag.length()-gaps) * 100; }
+
+ dist = diff / (float) (seqFrag.length()) * 100;
- dist = diff / (float) (seqFrag.length()) * 100;
-
temp.push_back(dist);
}
//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;
}
exit(1);
}
}
-//********************************************************************************************************************
-//sorts lowest to highest
-inline bool compareQuanMembers(quanMember left, quanMember right){
- return (left.score < right.score);
-}
//***************************************************************************************************************
//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<float>& highestDE) {
+vector< vector<quanMember> > DeCalculator::getQuantiles(vector<Sequence*> seqs, vector<int> windowSizesTemplate, int window, vector<float> probProfile, int increment, int start, int end) {
try {
vector< vector<quanMember> > 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 template sequence " + toString(i)); mothurOutEndLine();
+ mothurOut("Processing sequence " + toString(i)); mothurOutEndLine();
Sequence* query = new Sequence(seqs[i]->getName(), seqs[i]->getAligned());
//compare to every other sequence in template
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);
-
- //save highestDE
- if(de > highestDE[i]) { highestDE[i] = de; }
- if(de > highestDE[j]) { highestDE[j] = de; }
+ quan[dist].push_back(newScore);
delete subject;
-
}
delete query;
}
-
return quan;
}
catch(exception& e) {
- errorOut(e, "DeCalculator", "findQav");
+ errorOut(e, "DeCalculator", "getQuantiles");
exit(1);
}
}
-
+//********************************************************************************************************************
+//sorts lowest to highest
+inline bool compareQuanMembers(quanMember left, quanMember right){
+ return (left.score < right.score);
+}
//***************************************************************************************************************
-vector< vector<float> > DeCalculator::removeObviousOutliers(vector< vector<quanMember> >& quantiles, int num) {
+//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) {
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);
//get next largestContrib
largestContrib = findLargestContrib(seen);
}
- */
-
+ABOVE IS ATTEMPT #1
+**************************************************************************************************
+BELOW IS ATTEMPT #2
vector<int> marked = returnObviousOutliers(quantiles, num);
vector<int> copyMarked = marked;
quan[i] = temp;
}
-
- return quan;
- }
- catch(exception& e) {
- errorOut(e, "DeCalculator", "removeObviousOutliers");
- exit(1);
- }
-}
-//***************************************************************************************************************
-//follows Mallard algorythn in paper referenced from mallard class
-vector<int> DeCalculator::returnObviousOutliers(vector< vector<quanMember> > quantiles, int num) {
- try {
- vector< vector<float> > quan;
- quan.resize(100);
-
- map<quanMember*, float> contributions; //map of quanMember to distance from high or low - how bad is it.
- vector<int> marked; //marked[0] is the penalty of template seqs[0]. the higher the penalty the more likely the sequence is chimeric
- marked.resize(num,0);
-
- //find contributions
- 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;
-
- //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 {
- float dist;
- //add to contributions
- if (quantiles[i][j].score < low) {
- dist = low - quantiles[i][j].score;
- contributions[&(quantiles[i][j])] = dist;
- }else { //you are higher than high
- dist = quantiles[i][j].score - high;
- contributions[&(quantiles[i][j])] = dist;
- }
- }
- }
- }
-
- //find contributer with most offending score related to it
- vector<quanMember> outliers = sortContrib(contributions);
-
- //go through the outliers marking the potential chimeras
- for (int i = 0; i < outliers.size(); i++) {
-
- //who is responsible for this outlying score?
- //if member1 has greater score mark him
- //if member2 has greater score mark her
- //if they are the same mark both
- if (marked[outliers[i].member1] > marked[outliers[i].member2]) { marked[outliers[i].member1]++; }
- else if (marked[outliers[i].member2] > marked[outliers[i].member1]) { marked[outliers[i].member2]++; }
- else if (marked[outliers[i].member2] == marked[outliers[i].member1]) { marked[outliers[i].member2]++; marked[outliers[i].member1]++; }
- }
-
- return marked;
}
catch(exception& e) {
errorOut(e, "DeCalculator", "removeObviousOutliers");
}
}
//***************************************************************************************************************
-vector<quanMember> DeCalculator::sortContrib(map<quanMember*, float> quan) {
+//put quanMember in the vector based on how far they are from the 99% or 1%. Biggest offenders in front.
+/*vector<quanMember> DeCalculator::sortContrib(map<quanMember*, float> quan) {
try{
vector<quanMember> newQuan;
for (it = quan.begin(); it != quan.end(); it++) {
if (it->second > largest->second) { largest = it; }
}
-
+cout << largest->second << '\t' << largest->first->score << '\t' << largest->first->member1 << '\t' << largest->first->member2 << endl;
//save it
newQuan.push_back(*(largest->first));
}
//***************************************************************************************************************
+//used by removeObviousOutliers which was attempt to increase sensitivity of chimera detection...not currently used...
int DeCalculator::findLargestContrib(vector<int> seen) {
try{
exit(1);
}
}
-
+*/
//***************************************************************************************************************
float DeCalculator::findAverage(vector<float> myVector) {
try{