void ConsensusIDAlgorithm::apply(vector<PeptideIdentification>& ids,
Size number_of_runs)
{
// abort if no IDs present
if (ids.empty())
{
return;
}
number_of_runs_ = (number_of_runs != 0) ? number_of_runs : ids.size();
// prepare data here, so that it doesn't have to happen in each algorithm:
for (vector<PeptideIdentification>::iterator pep_it = ids.begin();
pep_it != ids.end(); ++pep_it)
{
pep_it->sort();
if ((considered_hits_ > 0) &&
(pep_it->getHits().size() > considered_hits_))
{
pep_it->getHits().resize(considered_hits_);
}
}
// make sure there are no duplicated hits (by sequence):
IDFilter::removeDuplicatePeptideHits(ids, true);
SequenceGrouping results;
apply_(ids, results); // actual (subclass-specific) processing
String score_type = ids[0].getScoreType();
bool higher_better = ids[0].isHigherScoreBetter();
ids.clear();
ids.resize(1);
ids[0].setScoreType(score_type);
ids[0].setHigherScoreBetter(higher_better);
for (SequenceGrouping::iterator res_it = results.begin();
res_it != results.end(); ++res_it)
{
OPENMS_PRECONDITION(!res_it->second.second.empty(),
"Consensus score for peptide required");
PeptideHit hit;
if (res_it->second.second.size() == 2)
{
// filter by "support" value:
double support = res_it->second.second[1];
if (support < min_support_) continue;
hit.setMetaValue("consensus_support", support);
}
hit.setSequence(res_it->first);
hit.setCharge(res_it->second.first);
hit.setScore(res_it->second.second[0]);
ids[0].insertHit(hit);
#ifdef DEBUG_ID_CONSENSUS
LOG_DEBUG << " - Output hit: " << hit.getSequence() << " "
<< hit.getScore() << endl;
#endif
}
ids[0].assignRanks();
}
void CompNovoIdentificationCID::getIdentification(PeptideIdentification & id, const PeakSpectrum & CID_spec)
{
//if (CID_spec.getPrecursors().begin()->getMZ() > 1000.0)
//{
//cerr << "Weight of precursor has been estimated to exceed 2000.0 Da which is the current limit" << endl;
//return;
//}
PeakSpectrum new_CID_spec(CID_spec);
windowMower_(new_CID_spec, 0.3, 1);
Param zhang_param;
zhang_param = zhang_.getParameters();
zhang_param.setValue("tolerance", fragment_mass_tolerance_);
zhang_param.setValue("use_gaussian_factor", "true");
zhang_param.setValue("use_linear_factor", "false");
zhang_.setParameters(zhang_param);
Normalizer normalizer;
Param n_param(normalizer.getParameters());
n_param.setValue("method", "to_one");
normalizer.setParameters(n_param);
normalizer.filterSpectrum(new_CID_spec);
Size charge(2);
double precursor_weight(0); // [M+H]+
if (!CID_spec.getPrecursors().empty())
{
// believe charge of spectrum?
if (CID_spec.getPrecursors().begin()->getCharge() != 0)
{
charge = CID_spec.getPrecursors().begin()->getCharge();
}
else
{
// TODO estimate charge state
}
precursor_weight = CID_spec.getPrecursors().begin()->getMZ() * charge - ((charge - 1) * Constants::PROTON_MASS_U);
}
//cerr << "charge=" << charge << ", [M+H]=" << precursor_weight << endl;
// now delete all peaks that are right of the estimated precursor weight
Size peak_counter(0);
for (PeakSpectrum::ConstIterator it = new_CID_spec.begin(); it != new_CID_spec.end(); ++it, ++peak_counter)
{
if (it->getPosition()[0] > precursor_weight)
{
break;
}
}
if (peak_counter < new_CID_spec.size())
{
new_CID_spec.resize(peak_counter);
}
static double oxonium_mass = EmpiricalFormula("H2O+").getMonoWeight();
Peak1D p;
p.setIntensity(1);
p.setPosition(oxonium_mass);
new_CID_spec.push_back(p);
p.setPosition(precursor_weight);
new_CID_spec.push_back(p);
// add complement to spectrum
/*
for (PeakSpectrum::ConstIterator it1 = CID_spec.begin(); it1 != CID_spec.end(); ++it1)
{
// get m/z of complement
double mz_comp = precursor_weight - it1->getPosition()[0] + Constants::PROTON_MASS_U;
// search if peaks are available that have similar m/z values
Size count(0);
bool found(false);
for (PeakSpectrum::ConstIterator it2 = CID_spec.begin(); it2 != CID_spec.end(); ++it2, ++count)
{
if (fabs(mz_comp - it2->getPosition()[0]) < fragment_mass_tolerance)
{
// add peak intensity to corresponding peak in new_CID_spec
new_CID_spec[count].setIntensity(new_CID_spec[count].getIntensity());
}
}
if (!found)
{
// infer this peak
Peak1D p;
p.setIntensity(it1->getIntensity());
p.setPosition(mz_comp);
new_CID_spec.push_back(p);
}
}*/
CompNovoIonScoringCID ion_scoring;
Param ion_scoring_param(ion_scoring.getParameters());
ion_scoring_param.setValue("fragment_mass_tolerance", fragment_mass_tolerance_);
ion_scoring_param.setValue("precursor_mass_tolerance", precursor_mass_tolerance_);
ion_scoring_param.setValue("decomp_weights_precision", decomp_weights_precision_);
ion_scoring_param.setValue("double_charged_iso_threshold", (double)param_.getValue("double_charged_iso_threshold"));
ion_scoring_param.setValue("max_isotope_to_score", param_.getValue("max_isotope_to_score"));
ion_scoring_param.setValue("max_isotope", max_isotope_);
ion_scoring.setParameters(ion_scoring_param);
Map<double, IonScore> ion_scores;
ion_scoring.scoreSpectrum(ion_scores, new_CID_spec, precursor_weight, charge);
new_CID_spec.sortByPosition();
/*
cerr << "Size of ion_scores " << ion_scores.size() << endl;
for (Map<double, IonScore>::const_iterator it = ion_scores.begin(); it != ion_scores.end(); ++it)
{
cerr << it->first << " " << it->second.score << endl;
}*/
#ifdef WRITE_SCORED_SPEC
PeakSpectrum filtered_spec(new_CID_spec);
filtered_spec.clear();
for (Map<double, CompNovoIonScoringCID::IonScore>::const_iterator it = ion_scores.begin(); it != ion_scores.end(); ++it)
{
Peak1D p;
p.setIntensity(it->second.score);
p.setPosition(it->first);
filtered_spec.push_back(p);
}
DTAFile().store("spec_scored.dta", filtered_spec);
#endif
set<String> sequences;
getDecompositionsDAC_(sequences, 0, new_CID_spec.size() - 1, precursor_weight, new_CID_spec, ion_scores);
#ifdef SPIKE_IN
sequences.insert("AFCVDGEGR");
sequences.insert("APEFAAPWPDFVPR");
sequences.insert("AVKQFEESQGR");
sequences.insert("CCTESLVNR");
sequences.insert("DAFLGSFLYEYSR");
sequences.insert("DAIPENLPPLTADFAEDK");
sequences.insert("DDNKVEDIWSFLSK");
sequences.insert("DDPHACYSTVFDK");
sequences.insert("DEYELLCLDGSR");
sequences.insert("DGAESYKELSVLLPNR");
sequences.insert("DGASCWCVDADGR");
sequences.insert("DLFIPTCLETGEFAR");
sequences.insert("DTHKSEIAHR");
sequences.insert("DVCKNYQEAK");
sequences.insert("EACFAVEGPK");
sequences.insert("ECCHGDLLECADDR");
sequences.insert("EFLGDKFYTVISSLK");
sequences.insert("EFTPVLQADFQK");
sequences.insert("ELFLDSGIFQPMLQGR");
sequences.insert("ETYGDMADCCEK");
sequences.insert("EVGCPSSSVQEMVSCLR");
sequences.insert("EYEATLEECCAK");
sequences.insert("FADLIQSGTFQLHLDSK");
sequences.insert("FFSASCVPGATIEQK");
sequences.insert("FLANVSTVLTSK");
sequences.insert("FLSGSDYAIR");
sequences.insert("FTASCPPSIK");
sequences.insert("GAIEWEGIESGSVEQAVAK");
sequences.insert("GDVAFIQHSTVEENTGGK");
sequences.insert("GEPPSCAEDQSCPSER");
sequences.insert("GEYVPTSLTAR");
sequences.insert("GQEFTITGQKR");
sequences.insert("GTFAALSELHCDK");
sequences.insert("HLVDEPQNLIK");
sequences.insert("HQDCLVTTLQTQPGAVR");
sequences.insert("HTTVNENAPDQK");
sequences.insert("ILDCGSPDTEVR");
sequences.insert("KCPSPCQLQAER");
sequences.insert("KGTEFTVNDLQGK");
sequences.insert("KQTALVELLK");
sequences.insert("KVPQVSTPTLVEVSR");
sequences.insert("LALQFTTNAKR");
sequences.insert("LCVLHEKTPVSEK");
sequences.insert("LFTFHADICTLPDTEK");
sequences.insert("LGEYGFQNALIVR");
sequences.insert("LHVDPENFK");
sequences.insert("LKECCDKPLLEK");
sequences.insert("LKHLVDEPQNLIK");
sequences.insert("LKPDPNTLCDEFK");
sequences.insert("LLGNVLVVVLAR");
sequences.insert("LLVVYPWTQR");
sequences.insert("LRVDPVNFK");
sequences.insert("LTDEELAFPPLSPSR");
sequences.insert("LVNELTEFAK");
sequences.insert("MFLSFPTTK");
sequences.insert("MPCTEDYLSLILNR");
sequences.insert("NAPYSGYSGAFHCLK");
sequences.insert("NECFLSHKDDSPDLPK");
sequences.insert("NEPNKVPACPGSCEEVK");
sequences.insert("NLQMDDFELLCTDGR");
sequences.insert("QAGVQAEPSPK");
sequences.insert("RAPEFAAPWPDFVPR");
sequences.insert("RHPEYAVSVLLR");
sequences.insert("RPCFSALTPDETYVPK");
sequences.insert("RSLLLAPEEGPVSQR");
sequences.insert("SAFPPEPLLCSVQR");
sequences.insert("SAGWNIPIGTLLHR");
sequences.insert("SCWCVDEAGQK");
sequences.insert("SGNPNYPHEFSR");
sequences.insert("SHCIAEVEK");
sequences.insert("SISSGFFECER");
sequences.insert("SKYLASASTMDHAR");
sequences.insert("SLHTLFGDELCK");
sequences.insert("SLLLAPEEGPVSQR");
sequences.insert("SPPQCSPDGAFRPVQCK");
sequences.insert("SREGDPLAVYLK");
sequences.insert("SRQIPQCPTSCER");
sequences.insert("TAGTPVSIPVCDDSSVK");
sequences.insert("TCVADESHAGCEK");
sequences.insert("TQFGCLEGFGR");
sequences.insert("TVMENFVAFVDK");
sequences.insert("TYFPHFDLSHGSAQVK");
sequences.insert("TYMLAFDVNDEK");
sequences.insert("VDEVGGEALGR");
sequences.insert("VDLLIGSSQDDGLINR");
sequences.insert("VEDIWSFLSK");
sequences.insert("VGGHAAEYGAEALER");
sequences.insert("VGTRCCTKPESER");
sequences.insert("VKVDEVGGEALGR");
sequences.insert("VKVDLLIGSSQDDGLINR");
sequences.insert("VLDSFSNGMK");
sequences.insert("VLSAADKGNVK");
sequences.insert("VPQVSTPTLVEVSR");
sequences.insert("VTKCCTESLVNR");
sequences.insert("VVAASDASQDALGCVK");
sequences.insert("VVAGVANALAHR");
sequences.insert("YICDNQDTISSK");
sequences.insert("YLASASTMDHAR");
sequences.insert("YNGVFQECCQAEDK");
#endif
SpectrumAlignmentScore spectra_zhang;
spectra_zhang.setParameters(zhang_param);
vector<PeptideHit> hits;
Size missed_cleavages = param_.getValue("missed_cleavages");
for (set<String>::const_iterator it = sequences.begin(); it != sequences.end(); ++it)
{
Size num_missed = countMissedCleavagesTryptic_(*it);
if (missed_cleavages < num_missed)
{
//cerr << "Two many missed cleavages: " << *it << ", found " << num_missed << ", allowed " << missed_cleavages << endl;
continue;
}
PeakSpectrum CID_sim_spec;
getCIDSpectrum_(CID_sim_spec, *it, charge);
//normalizer.filterSpectrum(CID_sim_spec);
double cid_score = zhang_(CID_sim_spec, CID_spec);
PeptideHit hit;
hit.setScore(cid_score);
hit.setSequence(getModifiedAASequence_(*it));
hit.setCharge((Int)charge); //TODO unify charge interface: int or size?
hits.push_back(hit);
//cerr << getModifiedAASequence_(*it) << " " << cid_score << " " << endl;
}
// rescore the top hits
id.setHits(hits);
id.assignRanks();
hits = id.getHits();
SpectrumAlignmentScore alignment_score;
Param align_param(alignment_score.getParameters());
align_param.setValue("tolerance", fragment_mass_tolerance_);
align_param.setValue("use_linear_factor", "true");
alignment_score.setParameters(align_param);
for (vector<PeptideHit>::iterator it = hits.begin(); it != hits.end(); ++it)
{
//cerr << "Pre: " << it->getRank() << " " << it->getSequence() << " " << it->getScore() << " " << endl;
}
Size number_of_prescoring_hits = param_.getValue("number_of_prescoring_hits");
if (hits.size() > number_of_prescoring_hits)
{
hits.resize(number_of_prescoring_hits);
}
for (vector<PeptideHit>::iterator it = hits.begin(); it != hits.end(); ++it)
{
PeakSpectrum CID_sim_spec;
getCIDSpectrum_(CID_sim_spec, getModifiedStringFromAASequence_(it->getSequence()), charge);
normalizer.filterSpectrum(CID_sim_spec);
//DTAFile().store("sim_specs/" + it->getSequence().toUnmodifiedString() + "_sim_CID.dta", CID_sim_spec);
//double cid_score = spectra_zhang(CID_sim_spec, CID_spec);
double cid_score = alignment_score(CID_sim_spec, CID_spec);
//cerr << "Final: " << it->getSequence() << " " << cid_score << endl;
it->setScore(cid_score);
}
id.setHits(hits);
id.assignRanks();
hits = id.getHits();
for (vector<PeptideHit>::iterator it = hits.begin(); it != hits.end(); ++it)
{
//cerr << "Fin: " << it->getRank() << " " << it->getSequence() << " " << it->getScore() << " " << endl;
}
Size number_of_hits = param_.getValue("number_of_hits");
if (id.getHits().size() > number_of_hits)
{
hits.resize(number_of_hits);
}
id.setHits(hits);
id.assignRanks();
return;
}
void IDDecoyProbability::apply_(vector<PeptideIdentification> & ids, const vector<double> & rev_scores, const vector<double> & fwd_scores, const vector<double> & all_scores)
{
Size number_of_bins(param_.getValue("number_of_bins"));
// normalize distribution to [0, 1]
vector<double> fwd_scores_normalized(number_of_bins, 0.0), rev_scores_normalized(number_of_bins, 0.0), diff_scores(number_of_bins, 0.0), all_scores_normalized(number_of_bins, 0.0);
Transformation_ rev_trafo, fwd_trafo, all_trafo;
normalizeBins_(rev_scores, rev_scores_normalized, rev_trafo);
normalizeBins_(fwd_scores, fwd_scores_normalized, fwd_trafo);
normalizeBins_(all_scores, all_scores_normalized, all_trafo);
// rev scores fitting
vector<DPosition<2> > rev_data;
for (Size i = 0; i < number_of_bins; ++i)
{
DPosition<2> pos;
pos.setX(((double)i) / (double)number_of_bins + 0.0001); // necessary????
pos.setY(rev_scores_normalized[i]);
rev_data.push_back(pos);
#ifdef IDDECOYPROBABILITY_DEBUG
cerr << pos.getX() << " " << pos.getY() << endl;
#endif
}
Math::GammaDistributionFitter gdf;
Math::GammaDistributionFitter::GammaDistributionFitResult result_gamma_1st (1.0, 3.0);
gdf.setInitialParameters(result_gamma_1st);
// TODO heuristic for good start parameters
Math::GammaDistributionFitter::GammaDistributionFitResult result_gamma = gdf.fit(rev_data);
#ifdef IDDECOYPROBABILITY_DEBUG
cerr << gdf.getGnuplotFormula() << endl;
String rev_filename = param_.getValue("rev_filename");
generateDistributionImage_(rev_scores_normalized, gdf.getGnuplotFormula(), rev_filename);
#endif
// generate diffs of distributions
// get the fwd and rev distribution, apply all_trafo and calculate the diff
vector<Size> fwd_bins(number_of_bins, 0), rev_bins(number_of_bins, 0);
double min(all_trafo.min_score), diff(all_trafo.diff_score);
Size max_bin(0);
for (vector<double>::const_iterator it = fwd_scores.begin(); it != fwd_scores.end(); ++it)
{
Size bin = (Size)((*it - min) / diff * (double)(number_of_bins - 1));
++fwd_bins[bin];
if (fwd_bins[bin] > max_bin)
{
max_bin = fwd_bins[bin];
}
}
Size max_reverse_bin(0), max_reverse_bin_value(0);
//min = rev_trafo.min_score;
//diff = rev_trafo.diff_score;
for (vector<double>::const_iterator it = rev_scores.begin(); it != rev_scores.end(); ++it)
{
Size bin = (Size)((*it - min) / diff * (double)number_of_bins);
++rev_bins[bin];
if (rev_bins[bin] > max_bin)
{
max_bin = rev_bins[bin];
}
if (rev_bins[bin] > max_reverse_bin_value)
{
max_reverse_bin = bin;
max_reverse_bin_value = rev_bins[bin];
}
}
#ifdef IDDECOYPROBABILITY_DEBUG
cerr << "Trying to get diff scores" << endl;
#endif
// get diff of fwd and rev
for (Size i = 0; i < number_of_bins; ++i)
{
Size fwd(0), rev(0);
fwd = fwd_bins[i];
rev = rev_bins[i];
if ((double)fwd > (double)(1.3 * rev) && max_reverse_bin < i)
{
diff_scores[i] = (double)(fwd - rev) / (double)max_bin;
}
else
{
diff_scores[i] = 0.0;
}
}
#ifdef IDDECOYPROBABILITY_DEBUG
cerr << "Gauss Fitting values size of diff scores=" << diff_scores.size() << endl;
#endif
// diff scores fitting
vector<DPosition<2> > diff_data;
double gauss_A(0), gauss_x0(0), norm_factor(0);
for (Size i = 0; i < number_of_bins; ++i)
{
DPosition<2> pos;
pos.setX((double)i / (double)number_of_bins);
pos.setY(diff_scores[i]);
if (pos.getY() > gauss_A)
{
gauss_A = pos.getY();
}
gauss_x0 += pos.getX() * pos.getY();
norm_factor += pos.getY();
diff_data.push_back(pos);
}
double gauss_sigma(0);
gauss_x0 /= (double)diff_data.size();
gauss_x0 /= norm_factor;
for (Size i = 0; i <= number_of_bins; ++i)
{
gauss_sigma += fabs(gauss_x0 - (double)i / (double)number_of_bins);
}
gauss_sigma /= (double)diff_data.size();
#ifdef IDDECOYPROBABILITY_DEBUG
cerr << "setting initial parameters: " << endl;
#endif
Math::GaussFitter gf;
Math::GaussFitter::GaussFitResult result_1st(gauss_A, gauss_x0, gauss_sigma);
gf.setInitialParameters(result_1st);
#ifdef IDDECOYPROBABILITY_DEBUG
cerr << "Initial Gauss guess: A=" << gauss_A << ", x0=" << gauss_x0 << ", sigma=" << gauss_sigma << endl;
#endif
//TODO: fail-to-fit correction was done using the GNUPlotFormula. Seemed to be a hack.
//Changed it to try-catch-block but I am not sure if this correction should be made
//at all. Can someone please verify?
Math::GaussFitter::GaussFitResult result_gauss (gauss_A, gauss_x0, gauss_sigma);
try{
result_gauss = gf.fit(diff_data);
}
catch(Exception::UnableToFit& /* e */)
{
result_gauss.A = gauss_A;
result_gauss.x0 = gauss_x0;
result_gauss.sigma = gauss_sigma;
}
// // fit failed?
// if (gf.getGnuplotFormula() == "")
// {
// result_gauss.A = gauss_A;
// result_gauss.x0 = gauss_x0;
// result_gauss.sigma = gauss_sigma;
// }
#ifdef IDDECOYPROBABILITY_DEBUG
cerr << gf.getGnuplotFormula() << endl;
String fwd_filename = param_.getValue("fwd_filename");
if (gf.getGnuplotFormula() == "")
{
String formula("f(x)=" + String(gauss_A) + " * exp(-(x - " + String(gauss_x0) + ") ** 2 / 2 / (" + String(gauss_sigma) + ") ** 2)");
generateDistributionImage_(diff_scores, formula, fwd_filename);
}
else
{
generateDistributionImage_(diff_scores, gf.getGnuplotFormula(), fwd_filename);
}
#endif
#ifdef IDDECOYPROBABILITY_DEBUG
//all_trafo.diff_score + all_trafo.min_score
String gauss_formula("f(x)=" + String(result_gauss.A / all_trafo.max_intensity) + " * exp(-(x - " + String(result_gauss.x0 * all_trafo.diff_score + all_trafo.min_score) + ") ** 2 / 2 / (" + String(result_gauss.sigma * all_trafo.diff_score) + ") ** 2)");
String b_str(result_gamma.b), p_str(result_gamma.p);
String gamma_formula = "g(x)=(" + b_str + " ** " + p_str + ") / gamma(" + p_str + ") * x ** (" + p_str + " - 1) * exp(- " + b_str + " * x)";
generateDistributionImage_(all_scores_normalized, all_trafo, gauss_formula, gamma_formula, (String)param_.getValue("fwd_filename"));
#endif
vector<PeptideIdentification> new_prob_ids;
// calculate the probabilities and write them to the IDs
for (vector<PeptideIdentification>::const_iterator it = ids.begin(); it != ids.end(); ++it)
{
if (it->getHits().size() > 0)
{
vector<PeptideHit> hits;
String score_type = it->getScoreType() + "_score";
for (vector<PeptideHit>::const_iterator pit = it->getHits().begin(); pit != it->getHits().end(); ++pit)
{
PeptideHit hit = *pit;
double score = hit.getScore();
if (!it->isHigherScoreBetter())
{
score = -log10(score);
}
hit.setMetaValue(score_type, hit.getScore());
hit.setScore(getProbability_(result_gamma, rev_trafo, result_gauss, fwd_trafo, score));
hits.push_back(hit);
}
PeptideIdentification id = *it;
id.setHigherScoreBetter(true);
id.setScoreType(id.getScoreType() + "_DecoyProbability");
id.setHits(hits);
new_prob_ids.push_back(id);
}
}
ids = new_prob_ids;
}
ExitCodes main_(int, const char**)
{
//-------------------------------------------------------------
// parameter handling
//-------------------------------------------------------------
StringList in_spec = getStringList_("in");
StringList out = getStringList_("out");
String in_lib = getStringOption_("lib");
String compare_function = getStringOption_("compare_function");
Int precursor_mass_multiplier = getIntOption_("round_precursor_to_integer");
float precursor_mass_tolerance = getDoubleOption_("precursor_mass_tolerance");
//Int min_precursor_charge = getIntOption_("min_precursor_charge");
//Int max_precursor_charge = getIntOption_("max_precursor_charge");
float remove_peaks_below_threshold = getDoubleOption_("filter:remove_peaks_below_threshold");
UInt min_peaks = getIntOption_("filter:min_peaks");
UInt max_peaks = getIntOption_("filter:max_peaks");
Int cut_peaks_below = getIntOption_("filter:cut_peaks_below");
StringList fixed_modifications = getStringList_("fixed_modifications");
StringList variable_modifications = getStringList_("variable_modifications");
Int top_hits = getIntOption_("top_hits");
if (top_hits < -1)
{
writeLog_("top_hits (should be >= -1 )");
return ILLEGAL_PARAMETERS;
}
//-------------------------------------------------------------
// loading input
//-------------------------------------------------------------
if (out.size() != in_spec.size())
{
writeLog_("out (should be as many as input files)");
return ILLEGAL_PARAMETERS;
}
time_t prog_time = time(NULL);
MSPFile spectral_library;
RichPeakMap query, library;
//spectrum which will be identified
MzMLFile spectra;
spectra.setLogType(log_type_);
time_t start_build_time = time(NULL);
//-------------------------------------------------------------
//building map for faster search
//-------------------------------------------------------------
//library containing already identified peptide spectra
vector<PeptideIdentification> ids;
spectral_library.load(in_lib, ids, library);
map<Size, vector<PeakSpectrum> > MSLibrary;
{
RichPeakMap::iterator s;
vector<PeptideIdentification>::iterator i;
ModificationsDB* mdb = ModificationsDB::getInstance();
for (s = library.begin(), i = ids.begin(); s < library.end(); ++s, ++i)
{
double precursor_MZ = (*s).getPrecursors()[0].getMZ();
Size MZ_multi = (Size)precursor_MZ * precursor_mass_multiplier;
map<Size, vector<PeakSpectrum> >::iterator found;
found = MSLibrary.find(MZ_multi);
PeakSpectrum librar;
bool variable_modifications_ok = true;
bool fixed_modifications_ok = true;
const AASequence& aaseq = i->getHits()[0].getSequence();
//variable fixed modifications
if (!fixed_modifications.empty())
{
for (Size i = 0; i < aaseq.size(); ++i)
{
const Residue& mod = aaseq.getResidue(i);
for (Size s = 0; s < fixed_modifications.size(); ++s)
{
if (mod.getOneLetterCode() == mdb->getModification(fixed_modifications[s]).getOrigin() && fixed_modifications[s] != mod.getModification())
{
fixed_modifications_ok = false;
break;
}
}
}
}
//variable modifications
if (aaseq.isModified() && (!variable_modifications.empty()))
{
for (Size i = 0; i < aaseq.size(); ++i)
{
if (aaseq.isModified(i))
{
const Residue& mod = aaseq.getResidue(i);
for (Size s = 0; s < variable_modifications.size(); ++s)
{
if (mod.getOneLetterCode() == mdb->getModification(variable_modifications[s]).getOrigin() && variable_modifications[s] != mod.getModification())
{
variable_modifications_ok = false;
break;
}
}
}
}
}
if (variable_modifications_ok && fixed_modifications_ok)
{
PeptideIdentification& translocate_pid = *i;
librar.getPeptideIdentifications().push_back(translocate_pid);
librar.setPrecursors(s->getPrecursors());
//library entry transformation
for (UInt l = 0; l < s->size(); ++l)
{
Peak1D peak;
if ((*s)[l].getIntensity() > remove_peaks_below_threshold)
{
const String& info = (*s)[l].getMetaValue("MSPPeakInfo");
if (info[0] == '?')
{
peak.setIntensity(sqrt(0.2 * (*s)[l].getIntensity()));
}
else
{
peak.setIntensity(sqrt((*s)[l].getIntensity()));
}
peak.setMZ((*s)[l].getMZ());
peak.setPosition((*s)[l].getPosition());
librar.push_back(peak);
}
}
if (found != MSLibrary.end())
{
found->second.push_back(librar);
}
else
{
vector<PeakSpectrum> tmp;
tmp.push_back(librar);
MSLibrary.insert(make_pair(MZ_multi, tmp));
}
}
}
}
time_t end_build_time = time(NULL);
cout << "Time needed for preprocessing data: " << (end_build_time - start_build_time) << "\n";
//compare function
PeakSpectrumCompareFunctor* comparor = Factory<PeakSpectrumCompareFunctor>::create(compare_function);
//-------------------------------------------------------------
// calculations
//-------------------------------------------------------------
double score;
StringList::iterator in, out_file;
for (in = in_spec.begin(), out_file = out.begin(); in < in_spec.end(); ++in, ++out_file)
{
time_t start_time = time(NULL);
spectra.load(*in, query);
//Will hold valuable hits
vector<PeptideIdentification> peptide_ids;
vector<ProteinIdentification> protein_ids;
// Write parameters to ProteinIdentifcation
ProteinIdentification prot_id;
//Parameters of identificaion
prot_id.setIdentifier("test");
prot_id.setSearchEngineVersion("SpecLibSearcher");
prot_id.setDateTime(DateTime::now());
prot_id.setScoreType(compare_function);
ProteinIdentification::SearchParameters searchparam;
searchparam.precursor_tolerance = precursor_mass_tolerance;
prot_id.setSearchParameters(searchparam);
/***********SEARCH**********/
for (UInt j = 0; j < query.size(); ++j)
{
//Set identifier for each identifications
PeptideIdentification pid;
pid.setIdentifier("test");
pid.setScoreType(compare_function);
ProteinHit pr_hit;
pr_hit.setAccession(j);
prot_id.insertHit(pr_hit);
//RichPeak1D to Peak1D transformation for the compare function query
PeakSpectrum quer;
bool peak_ok = true;
query[j].sortByIntensity(true);
double min_high_intensity = 0;
if (query[j].empty() || query[j].getMSLevel() != 2)
{
continue;
}
if (query[j].getPrecursors().empty())
{
writeLog_("Warning MS2 spectrum without precursor information");
continue;
}
min_high_intensity = (1 / cut_peaks_below) * query[j][0].getIntensity();
query[j].sortByPosition();
for (UInt k = 0; k < query[j].size() && k < max_peaks; ++k)
{
if (query[j][k].getIntensity() > remove_peaks_below_threshold && query[j][k].getIntensity() >= min_high_intensity)
{
Peak1D peak;
peak.setIntensity(sqrt(query[j][k].getIntensity()));
peak.setMZ(query[j][k].getMZ());
peak.setPosition(query[j][k].getPosition());
quer.push_back(peak);
}
}
if (quer.size() >= min_peaks)
{
peak_ok = true;
}
else
{
peak_ok = false;
}
double query_MZ = query[j].getPrecursors()[0].getMZ();
if (peak_ok)
{
bool charge_one = false;
Int percent = (Int) Math::round((query[j].size() / 100.0) * 3.0);
Int margin = (Int) Math::round((query[j].size() / 100.0) * 1.0);
for (vector<RichPeak1D>::iterator peak = query[j].end() - 1; percent >= 0; --peak, --percent)
{
if (peak->getMZ() < query_MZ)
{
break;
}
}
if (percent > margin)
{
charge_one = true;
}
float min_MZ = (query_MZ - precursor_mass_tolerance) * precursor_mass_multiplier;
float max_MZ = (query_MZ + precursor_mass_tolerance) * precursor_mass_multiplier;
for (Size mz = (Size)min_MZ; mz <= ((Size)max_MZ) + 1; ++mz)
{
map<Size, vector<PeakSpectrum> >::iterator found;
found = MSLibrary.find(mz);
if (found != MSLibrary.end())
{
vector<PeakSpectrum>& library = found->second;
for (Size i = 0; i < library.size(); ++i)
{
float this_MZ = library[i].getPrecursors()[0].getMZ() * precursor_mass_multiplier;
if (this_MZ >= min_MZ && max_MZ >= this_MZ && ((charge_one == true && library[i].getPeptideIdentifications()[0].getHits()[0].getCharge() == 1) || charge_one == false))
{
PeptideHit hit = library[i].getPeptideIdentifications()[0].getHits()[0];
PeakSpectrum& librar = library[i];
//Special treatment for SpectraST score as it computes a score based on the whole library
if (compare_function == "SpectraSTSimilarityScore")
{
SpectraSTSimilarityScore* sp = static_cast<SpectraSTSimilarityScore*>(comparor);
BinnedSpectrum quer_bin = sp->transform(quer);
BinnedSpectrum librar_bin = sp->transform(librar);
score = (*sp)(quer, librar); //(*sp)(quer_bin,librar_bin);
double dot_bias = sp->dot_bias(quer_bin, librar_bin, score);
hit.setMetaValue("DOTBIAS", dot_bias);
}
else
{
score = (*comparor)(quer, librar);
}
DataValue RT(library[i].getRT());
DataValue MZ(library[i].getPrecursors()[0].getMZ());
hit.setMetaValue("RT", RT);
hit.setMetaValue("MZ", MZ);
hit.setScore(score);
PeptideEvidence pe;
pe.setProteinAccession(pr_hit.getAccession());
hit.addPeptideEvidence(pe);
pid.insertHit(hit);
}
}
}
}
}
pid.setHigherScoreBetter(true);
pid.sort();
if (compare_function == "SpectraSTSimilarityScore")
{
if (!pid.empty() && !pid.getHits().empty())
{
vector<PeptideHit> final_hits;
final_hits.resize(pid.getHits().size());
SpectraSTSimilarityScore* sp = static_cast<SpectraSTSimilarityScore*>(comparor);
Size runner_up = 1;
for (; runner_up < pid.getHits().size(); ++runner_up)
{
if (pid.getHits()[0].getSequence().toUnmodifiedString() != pid.getHits()[runner_up].getSequence().toUnmodifiedString() || runner_up > 5)
{
break;
}
}
double delta_D = sp->delta_D(pid.getHits()[0].getScore(), pid.getHits()[runner_up].getScore());
for (Size s = 0; s < pid.getHits().size(); ++s)
{
final_hits[s] = pid.getHits()[s];
final_hits[s].setMetaValue("delta D", delta_D);
final_hits[s].setMetaValue("dot product", pid.getHits()[s].getScore());
final_hits[s].setScore(sp->compute_F(pid.getHits()[s].getScore(), delta_D, pid.getHits()[s].getMetaValue("DOTBIAS")));
//final_hits[s].removeMetaValue("DOTBIAS");
}
pid.setHits(final_hits);
pid.sort();
pid.setMZ(query[j].getPrecursors()[0].getMZ());
pid.setRT(query_MZ);
}
}
if (top_hits != -1 && (UInt)top_hits < pid.getHits().size())
{
vector<PeptideHit> hits;
hits.resize(top_hits);
for (Size i = 0; i < (UInt)top_hits; ++i)
{
hits[i] = pid.getHits()[i];
}
pid.setHits(hits);
}
peptide_ids.push_back(pid);
}
protein_ids.push_back(prot_id);
//-------------------------------------------------------------
// writing output
//-------------------------------------------------------------
IdXMLFile id_xml_file;
id_xml_file.store(*out_file, protein_ids, peptide_ids);
time_t end_time = time(NULL);
cout << "Search time: " << difftime(end_time, start_time) << " seconds for " << *in << "\n";
}
time_t end_time = time(NULL);
cout << "Total time: " << difftime(end_time, prog_time) << " secconds\n";
return EXECUTION_OK;
}
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;
}
