map<Size, PeakSpectrum > PScore::calculatePeakLevelSpectra(const PeakSpectrum& spec, const vector<Size>& ranks, Size min_level, Size max_level)
{
map<Size, MSSpectrum<Peak1D> > peak_level_spectra;
if (spec.empty()) return peak_level_spectra;
// loop over all peaks and associated (zero-based) ranks
for (Size i = 0; i != ranks.size(); ++i)
{
// start at the highest (less restrictive) level
for (int j = static_cast<int>(max_level); j >= static_cast<int>(min_level); --j)
{
// if the current peak is annotated to have lower or equal rank then allowed for this peak level add it
if (static_cast<int>(ranks[i]) <= j)
{
peak_level_spectra[j].push_back(spec[i]);
}
else
{
// if the current peak has higher rank than the current level then all it is also to high for the lower levels
break;
}
}
}
return peak_level_spectra;
}
PeptideHit AScore::compute(const PeptideHit & hit, PeakSpectrum & real_spectrum, double fragment_mass_tolerance, bool fragment_mass_unit_ppm, Size max_peptide_len, Size max_num_perm)
{
PeptideHit phospho = hit;
//reset phospho
phospho.setScore(-1);
if (real_spectrum.empty())
{
return phospho;
}
String sequence_str = phospho.getSequence().toString();
Size number_of_phosphorylation_events = numberOfPhosphoEvents_(sequence_str);
AASequence seq_without_phospho = removePhosphositesFromSequence_(sequence_str);
if (seq_without_phospho.toUnmodifiedString().size() > max_peptide_len)
{
LOG_DEBUG << "\tcalculation aborted: peptide too long: " << seq_without_phospho.toString() << std::endl;
return phospho;
}
// determine all phospho sites
vector<Size> sites(getSites_(seq_without_phospho));
Size number_of_STY = sites.size();
if (number_of_phosphorylation_events == 0 || number_of_STY == 0 || number_of_STY == number_of_phosphorylation_events)
{
return phospho;
}
vector<vector<Size> > permutations(computePermutations_(sites, (Int)number_of_phosphorylation_events));
LOG_DEBUG << "\tnumber of permutations: " << permutations.size() << std::endl;
// TODO: using a heuristic to calculate the best phospho sites if the number of permutations are exceeding the maximum.
// A heuristic could be to calculate the best site for the first phosphorylation and based on this the best site for the second
// phosphorylation and so on until every site is determined
if (permutations.size() > max_num_perm)
{
LOG_DEBUG << "\tcalculation aborted: number of permutations exceeded" << std::endl;
return phospho;
}
vector<PeakSpectrum> th_spectra(createTheoreticalSpectra_(permutations, seq_without_phospho));
// prepare real spectrum windows
if (!real_spectrum.isSorted())
{
real_spectrum.sortByPosition();
}
vector<PeakSpectrum> windows_top10(peakPickingPerWindowsInSpectrum_(real_spectrum));
// calculate peptide score for each possible phospho site permutation
vector<vector<double> > peptide_site_scores(calculatePermutationPeptideScores_(th_spectra, windows_top10, fragment_mass_tolerance, fragment_mass_unit_ppm));
// rank peptide permutations ascending
multimap<double, Size> ranking(rankWeightedPermutationPeptideScores_(peptide_site_scores));
multimap<double, Size>::reverse_iterator rev = ranking.rbegin();
String seq1 = th_spectra[rev->second].getName();
phospho.setSequence(AASequence::fromString(seq1));
phospho.setMetaValue("search_engine_sequence", hit.getSequence().toString());
double peptide1_score = rev->first;
phospho.setMetaValue("AScore_pep_score", peptide1_score); // initialize score with highest peptide score (aka highest weighted score)
++rev;
String seq2 = th_spectra[rev->second].getName();
double peptide2_score = rev->first;
vector<ProbablePhosphoSites> phospho_sites;
determineHighestScoringPermutations_(peptide_site_scores, phospho_sites, permutations, ranking);
Int rank = 1;
double best_Ascore = std::numeric_limits<double>::max(); // the lower the better
for (vector<ProbablePhosphoSites>::iterator s_it = phospho_sites.begin(); s_it != phospho_sites.end(); ++s_it)
{
double Ascore = 0;
if (peptide1_score == peptide2_score) // set Ascore = 0 for each phosphorylation site
{
LOG_DEBUG << "\tscore of best (" << seq1 << ") and second best peptide (" << seq2 << ") are equal (" << peptide1_score << ")" << std::endl;
}
else
{
vector<PeakSpectrum> site_determining_ions;
computeSiteDeterminingIons_(th_spectra, *s_it, site_determining_ions, fragment_mass_tolerance, fragment_mass_unit_ppm);
Size N = site_determining_ions[0].size(); // all possibilities have the same number so take the first one
double p = static_cast<double>(s_it->peak_depth) / 100.0;
Size n_first = 0; // number of matching peaks for first peptide
for (Size window_idx = 0; window_idx != windows_top10.size(); ++window_idx) // for each 100 m/z window
{
n_first += numberOfMatchedIons_(site_determining_ions[0], windows_top10[window_idx], s_it->peak_depth, fragment_mass_tolerance, fragment_mass_unit_ppm);
}
double P_first = computeCumulativeScore_(N, n_first, p);
Size n_second = 0; // number of matching peaks for second peptide
for (Size window_idx = 0; window_idx < windows_top10.size(); ++window_idx) //each 100 m/z window
{
n_second += numberOfMatchedIons_(site_determining_ions[1], windows_top10[window_idx], s_it->peak_depth, fragment_mass_tolerance, fragment_mass_unit_ppm);
}
Size N2 = site_determining_ions[1].size(); // all possibilities have the same number so take the first one
double P_second = computeCumulativeScore_(N2, n_second, p);
//abs is used to avoid -0 score values
double score_first = abs(-10 * log10(P_first));
double score_second = abs(-10 * log10(P_second));
LOG_DEBUG << "\tfirst - N: " << N << ",p: " << p << ",n: " << n_first << ", score: " << score_first << std::endl;
LOG_DEBUG << "\tsecond - N: " << N2 << ",p: " << p << ",n: " << n_second << ", score: " << score_second << std::endl;
Ascore = score_first - score_second;
LOG_DEBUG << "\tAscore_" << rank << ": " << Ascore << std::endl;
}
if (Ascore < best_Ascore)
{
best_Ascore = Ascore;
}
phospho.setMetaValue("AScore_" + String(rank), Ascore);
++rank;
}
phospho.setScore(best_Ascore);
return phospho;
}
