int PeakList::findPeakWithMaxIntensity(mass_t expectedMass, mass_t tolerance) const { PeakRange pr = findPeaksInRange(expectedMass-tolerance, expectedMass+tolerance); if (pr.num_peaks==0) return -1; if (pr.num_peaks ==1) return pr.low_idx; const float doubleTolerance = tolerance + tolerance; mass_t maxWeightedValue = (doubleTolerance - fabs(peaks_[pr.low_idx].mass - expectedMass)) * peaks_[pr.low_idx].intensity; int maxPeakIdx=pr.low_idx; // find closest peak to exp_pos for (int i=1; i<pr.num_peaks; i++) { const int peakIdx = pr.low_idx + i; const mass_t weightedValue = (doubleTolerance - fabs(peaks_[peakIdx].mass - expectedMass)) * peaks_[peakIdx].intensity; if (weightedValue>maxWeightedValue) { maxWeightedValue=weightedValue; maxPeakIdx = peakIdx; } else break; } return maxPeakIdx; }
// There are fixed magic numbers in this function that should not be changed // (even though actual tolerances or values in config file might differ) // changing these numbers without retraining all models might give unanticipated results void PeakList::calculateLogRandomProbabilities(vector<float>& logIntensities, vector<float>& logRandomProbabilities) const { if (numPeaks_<2) return; const float oneOverSqrt2pi = 1.0 / sqrt(2.0*3.1415927); const float logBias = log(1.2); // to fine tune the zero probabilites const mass_t peakWindowSize = 0.6; // this is fixed and independent of the tolerance!!! const mass_t margin = 25.0; // fixed and independent of values in config file const mass_t windowSize = 100.0; // fixed and independent of values in config file const mass_t minPeakMass = peaks_[0].mass; const mass_t maxPeakMass = peaks_[numPeaks_-1].mass; const mass_t visibleRange = (maxPeakMass - minPeakMass); logRandomProbabilities.resize(numPeaks_); int i; for (i=0; i<numPeaks_; i++) { const mass_t peakMass = peaks_[i].mass; const mass_t relativePosition = (peakMass-minPeakMass)/visibleRange; const mass_t leftWindow = margin + relativePosition * windowSize; const mass_t rightWindow = margin + windowSize - leftWindow; const PeakRange pr = findPeaksInRange(peakMass - leftWindow, peakMass + rightWindow); const float peakWindowProb = peakWindowSize /(leftWindow + rightWindow); // some freak cases have 0 peak counts (only in unix) const int numPeaksInRange = (pr.num_peaks>0 ? pr.num_peaks : 1); const float zeroProbability = pow((1.0 - peakWindowProb),numPeaksInRange); if (numPeaksInRange<5) { logRandomProbabilities[i] = log(1.0-zeroProbability) + logBias; } else // compute special probability based on peak densitiy model { vector<float> windowLogIntensities; int j; for (j=pr.low_idx; j<=pr.high_idx; j++) windowLogIntensities.push_back(logIntensities[j]); float mean=0,sd=1; calc_mean_sd(windowLogIntensities,&mean,&sd); const float e = (logIntensities[i] - mean)/sd; if (e<0) { logRandomProbabilities[i] = log(1 - zeroProbability) + logBias; } else { const float normalizedValue = (oneOverSqrt2pi/ sd) * exp(-0.5*e*e); const float normalizationConstant = (1.0 - zeroProbability) / (oneOverSqrt2pi / sd); // logRandomProbabilities[i] = log(normalizedValue*normalizationConstant); } } } }
/*********************************************************************** calcs for each peak the probability of observing it at random (based on the neighbor's distribution. Assumes the log_intens are distributed according to a normal disribution. ************************************************************************/ void Spectrum::set_log_random_probs() { if (numPeaks_<2) return; const float log_add = log(1.2); const float one_over_sqr_2pi = 1.0 / sqrt(2*3.1415927); const mass_t peak_window_size = 0.6; // this is fixed and independent of the tolerance! const mass_t margin = 25.0; const mass_t window_size = 100.0; const mass_t min_mass = peaks_[0].mass; const mass_t max_mass = peaks_[numPeaks_-1].mass; const mass_t viz_range = (max_mass - min_mass); logRandomProbabilities_.resize(numPeaks_); int i; for (i=0; i<numPeaks_; i++) { const mass_t peak_mass = peaks_[i].mass; const mass_t rel_position = (peak_mass-min_mass)/viz_range; const mass_t left_window = margin + rel_position * window_size; const mass_t right_window = margin + window_size - left_window; const PeakRange pr = findPeaksInRange(peak_mass-left_window,peak_mass+right_window); const float peak_window_prob = peak_window_size /(left_window + right_window); // some freak cases have 0 peak counts (only in unix) const int num_peaks_in_range = (pr.num_peaks>0 ? pr.num_peaks : 1); const float zero_prob = pow((1.0 - peak_window_prob),num_peaks_in_range); if (pr.num_peaks<5) { logRandomProbabilities_[i] = log(1.0-zero_prob) + log_add; } else { vector<float> log_intens; int j; for (j=pr.low_idx; j<=pr.high_idx; j++) log_intens.push_back(logIntensities_[j]); float mean=0,sd=1; calc_mean_sd(log_intens,&mean,&sd); const float e = (logIntensities_[i] - mean)/sd; if (e<0) { logRandomProbabilities_[i] = log(1 - zero_prob) + log_add; } else { const float norm = (one_over_sqr_2pi/ sd) * exp(-0.5*e*e); const float norm_const = (1 - zero_prob) / (one_over_sqr_2pi/ sd); // logRandomProbabilities_[i] = log(norm*norm_const); } } } }
void PeakList::calculateLogLocalRanks(mass_t windowSize, vector<float>& logLocalRanks) const { const mass_t halfWindowSize = windowSize * 0.5; logLocalRanks.resize(numPeaks_); int i; for (i=0; i<numPeaks_; i++) { const PeakRange pr= findPeaksInRange(peaks_[i].mass - halfWindowSize, peaks_[i].mass + halfWindowSize); int above=0; int j; for (j=pr.low_idx; j<=pr.high_idx && j<numPeaks_; j++) if (peaks_[j].intensity>peaks_[i].intensity) above++; logLocalRanks[i] = log(1.0 + static_cast<float>(above)); } }
/********************************************************************* // gives each peak it log local rank // good be done more effciently... **********************************************************************/ void Spectrum::calc_log_local_ranks() { const mass_t half_window_size = config_->get_local_window_size() * 0.5; logLocalRanks_.resize(numPeaks_); int i; for (i=0; i<numPeaks_; i++) { const mass_t peak_mass = peaks_[i].mass; const PeakRange pr= findPeaksInRange(peak_mass - half_window_size, peak_mass + half_window_size); int above=0; int j; for (j=pr.low_idx; j<=pr.high_idx && j<numPeaks_; j++) if (peaks_[j].intensity>peaks_[i].intensity) above++; logLocalRanks_[i] = log(1.0 + static_cast<float>(above)); } }