void predict_fragmentation(AdvancedScoreModel* model, const char* input_file, size_t num_peaks)
{
FILE* stream = fopen(input_file,"r");
if (! stream)
{
cout << "Error: couldn't open file for reading: " << input_file << endl;
exit(1);
}
Config *config = model->get_config();
DeNovoRankScorer *dnv_rank = (DeNovoRankScorer *)model->get_rank_model_ptr(1);
PeakRankModel *prm = dnv_rank->get_peak_prediction_model(3);
char buffer[128];
char pep_str[128];
while (fgets(buffer,128,stream))
{
int charge;
if (sscanf(buffer,"%s %d",pep_str,&charge) != 2)
continue;
cout << ">> " << pep_str << "\t" << charge << endl;
if (charge<1 || charge>=prm->get_size_thresholds().size())
{
cout << "Invalid charge!" << endl;
continue;
}
Peptide pep;
pep.parse_from_string(config,static_cast<string>(pep_str));
PeptideSolution sol;
sol.pep = pep;
sol.reaches_n_terminal=true;
sol.reaches_c_terminal=true;
sol.charge = charge;
sol.pm_with_19 = pep.get_mass_with_19();
PeptidePeakPrediction ppp;
prm->calc_peptide_predicted_scores(sol, ppp);
const size_t num_frags = ppp.frag_idxs.size();
vector< vector<int> > predicted_ranks;
calc_combined_peak_ranks(ppp.rank_scores, predicted_ranks);
vector<PeakTuple> tuples;
for (size_t f=0; f<num_frags; f++)
for (size_t i=0; i<ppp.rank_scores[f].size(); i++)
if (predicted_ranks[f][i]<999)
{
PeakTuple pt;
pt.frag_idx = f;
pt.pos =i;
pt.rank = predicted_ranks[f][i];
pt.score = ppp.rank_scores[f][i];
tuples.push_back(pt);
}
sort(tuples.begin(),tuples.end());
if (tuples.size()<1)
continue;
const size_t num_aas = pep.get_num_aas();
vector<mass_t> breakage_masses;
pep.calc_expected_breakage_masses(config, breakage_masses);
cout << fixed << "Rank\tIon\tm/z\tScore" << endl;
for (size_t i=0; i<num_peaks && i<tuples.size(); i++)
{
PeakTuple pt = tuples[i];
cout << i+1 << "\t";
const FragmentType& ft = config->get_fragment(ppp.frag_idxs[pt.frag_idx]);
cout << ft.label << ":" << (ft.orientation == PREFIX ? pt.pos : num_aas - pt.pos) << "\t";
mass_t mz = ft.calc_expected_mass(breakage_masses[pt.pos],pep.get_mass_with_19());
cout << setprecision(2);
if (mz<100)
cout << " ";
if (mz<1000)
cout << " ";
cout << mz << "\t";
cout << setprecision(3) << pt.score << endl;
}
cout << endl;
}
fclose(stream);
}
void PrmNodeScoreModel::score_peptide_node_combos(void* model_ptr,
PrmGraph *prm, const Peptide& peptide ) const
{
const vector<int>& org_aas = config_->get_org_aa();
const vector<mass_t>& aa2mass = config_->get_aa2mass();
const vector<MultiEdge>& multi_edges = prm->get_multi_edges();
const int num_nodes = prm->get_num_nodes();
const vector<int>& pep_aas = peptide.get_amino_acids();
const int num_pep_aas = pep_aas.size();
mass_t p_mass=0;
int aa_idx=0;
int i;
for (i=0; i<num_nodes; i++)
{
Node& node = prm->get_non_const_node(i);
const RegionalPrmNodeScoreModel& score_model =
RegionalPrmNodeScoreModels_[prm->get_charge()][prm->get_size_idx()][node.breakage.region_idx];
int in_edge_idx=NEG_INF, in_edge_variant=NEG_INF;
int out_edge_idx=NEG_INF, out_edge_variant=NEG_INF;
// cout << "N: " << node.mass << endl;
while (aa_idx<pep_aas.size() && fabs(p_mass-node.mass)>0.1)
{
p_mass += aa2mass[pep_aas[aa_idx]];
aa_idx++;
// cout << aa_idx << "\t" << p_mass << endl;
}
if (aa_idx == pep_aas.size() && i != num_nodes-1)
{
int j;
for (j=0; j<num_nodes; j++)
cout << j << "\t" << prm->get_node(j).mass << endl;
cout << endl << "PEP:" << endl;
vector<mass_t> exp_masses;
peptide.calc_expected_breakage_masses(config_, exp_masses);
for (j=0; j<exp_masses.size(); j++)
cout << j << "\t" << exp_masses[j] << endl;
cout << "Error: mismatch between nodes and peptide!" << endl;
exit(1);
}
if (node.in_edge_idxs.size()>0)
{
int j;
for (j=0; j<node.in_edge_idxs.size(); j++)
{
const int edge_idx = node.in_edge_idxs[j];
const MultiEdge& in_edge = multi_edges[edge_idx];
const int num_aa = in_edge.num_aa;
if (num_aa>aa_idx)
continue;
const int var_idx = in_edge.get_variant_idx(num_aa,&pep_aas[aa_idx-num_aa]);
if (var_idx<0)
continue;
in_edge_idx = edge_idx;
in_edge_variant = var_idx;
break;
}
}
if (node.out_edge_idxs.size()>0)
{
int j;
for (j=0; j<node.out_edge_idxs.size(); j++)
{
const int edge_idx = node.out_edge_idxs[j];
const MultiEdge& out_edge = multi_edges[edge_idx];
const int num_aa = out_edge.num_aa;
if (num_aa + aa_idx >num_pep_aas)
continue;
const int var_idx = out_edge.get_variant_idx(num_aa,&pep_aas[aa_idx]);
if (var_idx<0)
continue;
out_edge_idx = edge_idx;
out_edge_variant = var_idx;
break;
}
}
const AllScoreModels* model = static_cast<AllScoreModels*>(model_ptr);
BreakageInfo info;
prm->fill_breakage_info(model,&info,i,in_edge_idx,in_edge_variant,out_edge_idx,out_edge_variant);
node.score_combos.clear();
// cout << in_edge_idx << " " << in_edge_variant << " " << out_edge_idx << " " << out_edge_variant << "\t";
info.score = score_model.score_a_single_breakage_combo(prm, node, &node.breakage, info);
node.score_combos[ScoreComboLoc(info)]=info.score;
node.score = info.score;
node.breakage.score = node.score;
// cout << node.score << endl;
}
prm->set_has_node_combo_scores(true);
}