//Visualizing PeptideIdentification object
void MetaDataBrowser::visualize_(PeptideIdentification & meta, QTreeWidgetItem * parent)
{
PeptideIdentificationVisualizer * visualizer = new PeptideIdentificationVisualizer(isEditable(), this, this);
QStringList labels;
int id = ws_->addWidget(visualizer);
labels << QString("PeptideIdentification %1").arg(meta.getScoreType().c_str()) << QString::number(id);
visualizer->load(meta, id);
QTreeWidgetItem * item;
if (parent == nullptr)
{
item = new QTreeWidgetItem(treeview_, labels);
}
else
{
item = new QTreeWidgetItem(parent, labels);
}
//check for proteins and peptides hits
meta.assignRanks();
//list all peptides hits in the tree
for (Size i = 0; i < meta.getHits().size(); ++i)
{
visualize_(const_cast<PeptideHit &>(meta.getHits()[i]), item);
}
visualize_(dynamic_cast<MetaInfoInterface &>(meta), item);
connectVisualizer_(visualizer);
}
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;
}
ProteinIdentification protein_identification2;
IDFilter::filterIdentificationsByProteins(protein_identification, proteins, protein_identification2);
TEST_EQUAL(protein_identification2.getScoreType(), "Mascot")
TEST_EQUAL(protein_identification2.getHits().size(), 2)
TEST_EQUAL(protein_identification2.getHits()[0].getAccession(), "Q824A5")
TEST_EQUAL(protein_identification2.getHits()[1].getAccession(), "Q872T5")
END_SECTION
START_SECTION((void filterIdentificationsByProteins(const PeptideIdentification& identification, const vector<FASTAFile::FASTAEntry>& proteins, PeptideIdentification& filtered_identification, bool no_protein_identifiers = false)))
PeptideIdentification identification2;
IDFilter::filterIdentificationsByProteins(identification, proteins, identification2);
TEST_EQUAL(identification2.getScoreType(), "Mascot")
TEST_EQUAL(identification2.getHits().size(), 2)
TEST_EQUAL(identification2.getHits()[0].getSequence(), AASequence::fromString("LHASGITVTEIPVTATNFK"))
TEST_EQUAL(identification2.getHits()[1].getSequence(), AASequence::fromString("MRSLGYVAVISAVATDTDK"))
END_SECTION
START_SECTION((template <class IdentificationType> void filterIdentificationsByThreshold(const IdentificationType& identification, double threshold_fraction, IdentificationType& filtered_identification)))
PeptideIdentification identification2;
vector<PeptideHit> peptide_hits;
vector<ProteinHit> protein_hits;
TEST_EQUAL(identification.getHits().size(), 11)
IDFilter::filterIdentificationsByThreshold(identification, 1.3, identification2);
peptide_hits = identification2.getHits();
TEST_EQUAL(identification2.getScoreType() , "Mascot")
