void ProteinResolver::buildingISDGroups_(vector<ProteinEntry> & protein_nodes, vector<PeptideEntry> & peptide_nodes,
vector<ISDGroup> & isd_groups)
{
EnzymaticDigestion digestor;
String enzyme_name = param_.getValue("resolver:enzyme");
digestor.setEnzyme(digestor.getEnzymeByName(enzyme_name));
UInt min_size = param_.getValue("resolver:min_length");
UInt missed_cleavages = param_.getValue("resolver:missed_cleavages");
digestor.setMissedCleavages(missed_cleavages);
//-------------------------------------------------------------
// building ISD Groups
//-------------------------------------------------------------
vector<AASequence> temp_peptides;
map<String, set<Size> > peptides;
for (Size i = 0; i < protein_data_.size(); ++i)
{
protein_nodes[i].fasta_entry = &protein_data_[i];
protein_nodes[i].traversed = false;
protein_nodes[i].index = i;
protein_nodes[i].protein_type = ProteinEntry::secondary;
protein_nodes[i].weight = AASequence(protein_data_[i].sequence).getMonoWeight();
protein_nodes[i].coverage = 0.;
protein_nodes[i].number_of_experimental_peptides = 0;
digestor.digest(AASequence(protein_data_[i].sequence), temp_peptides);
for (Size j = 0; j < temp_peptides.size(); ++j)
{
if (temp_peptides[j].size() >= min_size)
{
peptides[temp_peptides[j].toUnmodifiedString()].insert(i);
}
}
}
// important to resize
peptide_nodes.resize(peptides.size());
vector<PeptideEntry>::iterator pep_node = peptide_nodes.begin();
Size peptide_counter = 0;
for (map<String, set<Size> >::iterator i = peptides.begin(); i != peptides.end(); ++i, ++pep_node, ++peptide_counter)
{
pep_node->index = peptide_counter;
pep_node->traversed = false;
pep_node->sequence = (*i).first;
pep_node->experimental = false;
for (set<Size>::iterator j = (*i).second.begin(); j != (*i).second.end(); ++j)
{
pep_node->proteins.push_back(&protein_nodes[*j]);
protein_nodes[*j].peptides.push_back(&*pep_node);
}
}
//ISDGraph constructed
Size isd_group_counter = 0;
Size i = 0;
for (vector<ProteinEntry>::iterator prot_node = protein_nodes.begin(); prot_node != protein_nodes.end(); ++prot_node)
{
++i;
if (!prot_node->traversed)
{
prot_node->traversed = true;
ISDGroup group;
group.index = isd_group_counter;
++isd_group_counter;
traversProtein_(&*prot_node, group);
isd_groups.push_back(group);
}
}
}
void DigestSimulation::digest(SimTypes::FeatureMapSim& feature_map)
{
LOG_INFO << "Digest Simulation ... started" << std::endl;
if ((String)param_.getValue("enzyme") == String("none"))
{
//peptides = proteins;
// convert all proteins into peptides
// for each protein_hit in the FeatureMap
for (std::vector<ProteinHit>::iterator protein_hit = feature_map.getProteinIdentifications()[0].getHits().begin();
protein_hit != feature_map.getProteinIdentifications()[0].getHits().end();
++protein_hit)
{
// generate a PeptideHit hit with the correct link to the protein
PeptideHit pep_hit(1.0, 1, 0, AASequence::fromString(protein_hit->getSequence()));
PeptideEvidence pe;
pe.setProteinAccession(protein_hit->getAccession());
pep_hit.addPeptideEvidence(pe);
// add the PeptideHit to the PeptideIdentification
PeptideIdentification pep_id;
pep_id.insertHit(pep_hit);
// generate Feature with correct Intensity and corresponding PeptideIdentification
Feature f;
f.getPeptideIdentifications().push_back(pep_id);
f.setIntensity(protein_hit->getMetaValue("intensity"));
// copy intensity meta-values and additional annotations from Protein to Feature
StringList keys;
protein_hit->getKeys(keys);
for (StringList::const_iterator it_key = keys.begin(); it_key != keys.end(); ++it_key)
{
f.setMetaValue(*it_key, protein_hit->getMetaValue(*it_key));
}
// add Feature to SimTypes::FeatureMapSim
feature_map.push_back(f);
}
return;
}
UInt min_peptide_length = param_.getValue("min_peptide_length");
bool use_log_model = param_.getValue("model") == "trained" ? true : false;
UInt missed_cleavages = param_.getValue("model_naive:missed_cleavages");
double cleave_threshold = param_.getValue("model_trained:threshold");
EnzymaticDigestion digestion;
digestion.setEnzyme(digestion.getEnzymeByName((String)param_.getValue("enzyme")));
digestion.setLogModelEnabled(use_log_model);
digestion.setLogThreshold(cleave_threshold);
std::vector<AASequence> digestion_products;
// keep track of generated features
std::map<AASequence, Feature> generated_features;
// Iterate through ProteinHits in the FeatureMap and digest them
for (std::vector<ProteinHit>::iterator protein_hit = feature_map.getProteinIdentifications()[0].getHits().begin();
protein_hit != feature_map.getProteinIdentifications()[0].getHits().end();
++protein_hit)
{
// determine abundance of each digestion product (this is quite long now...)
// we assume that each digestion product will have the same abundance
// note: missed cleavages reduce overall abundance as they combine two (or more) single peptides
// how many "atomic"(i.e. non-cleavable) peptides are created?
digestion.setMissedCleavages(0);
Size complete_digest_count = digestion.peptideCount(AASequence::fromString(protein_hit->getSequence()));
// compute average number of "atomic" peptides summed from all digestion products
Size number_atomic_whole = 0;
Size number_of_digestion_products = 0;
for (Size i = 0; (i <= missed_cleavages) && (i < complete_digest_count); ++i)
{
number_atomic_whole += (complete_digest_count - i) * (i + 1);
number_of_digestion_products += (complete_digest_count - i);
}
// mean number of "atomic" peptides per digestion product is now: number_atomic_whole / number_of_digestion_products
// -> thus abundance of a digestion product is: #proteins / avg#of"atomic"peptides
// i.e.: protein->second / (number_atomic_whole / number_of_digestion_products)
Map<String, SimTypes::SimIntensityType> intensities;
StringList keys;
protein_hit->getKeys(keys);
for (StringList::const_iterator it_key = keys.begin(); it_key != keys.end(); ++it_key)
{
if (!it_key->hasPrefix("intensity"))
continue;
intensities[*it_key] = std::max(SimTypes::SimIntensityType(1), SimTypes::SimIntensityType(protein_hit->getMetaValue(*it_key))
* SimTypes::SimIntensityType(number_of_digestion_products)
/ SimTypes::SimIntensityType(number_atomic_whole)); // order changed for numeric stability
}
// do real digest
digestion.setMissedCleavages(missed_cleavages);
digestion.digest(AASequence::fromString(protein_hit->getSequence()), digestion_products);
for (std::vector<AASequence>::const_iterator dp_it = digestion_products.begin();
dp_it != digestion_products.end();
++dp_it)
{
if (dp_it->size() < min_peptide_length)
continue;
// sum equal peptide's intensities
// *dp_it -> peptide
// If we see this Peptide the first time -> generate corresponding feature
if (generated_features.count(*dp_it) == 0)
{
PeptideHit pep_hit(1.0, 1, 0, *dp_it);
PeptideIdentification pep_id;
pep_id.insertHit(pep_hit);
// create feature
Feature f;
f.getPeptideIdentifications().push_back(pep_id);
// set intensity to 0 to avoid problems when summing up
f.setIntensity(0.0);
// copy all non-intensity meta values
StringList lkeys;
protein_hit->getKeys(lkeys);
for (StringList::iterator key = lkeys.begin(); key != lkeys.end(); ++key)
{
if (!key->hasPrefix("intensity"))
{
f.setMetaValue(*key, protein_hit->getMetaValue(*key));
}
}
// insert into map
generated_features.insert(std::make_pair(*dp_it, f));
}
// sum up intensity values
generated_features[*dp_it].setIntensity(generated_features[*dp_it].getIntensity() + intensities["intensity"]);
// ... same for other intensities (iTRAQ...)
for (Map<String, SimTypes::SimIntensityType>::const_iterator it_other = intensities.begin(); it_other != intensities.end(); ++it_other)
{
if (!generated_features[*dp_it].metaValueExists(it_other->first))
{
generated_features[*dp_it].setMetaValue(it_other->first, it_other->second);
}
else
{
generated_features[*dp_it].setMetaValue(it_other->first, SimTypes::SimIntensityType(generated_features[*dp_it].getMetaValue(it_other->first)) + it_other->second);
}
}
// add current protein accession
// existing proteins accessions ...
std::set<String> protein_accessions = generated_features[*dp_it].getPeptideIdentifications()[0].getHits()[0].extractProteinAccessions();
// ... add accession of current protein
protein_accessions.insert(protein_hit->getAccession());
std::vector<PeptideIdentification> pep_idents = generated_features[*dp_it].getPeptideIdentifications();
std::vector<PeptideHit> pep_hits = pep_idents[0].getHits();
for (std::set<String>::const_iterator s_it = protein_accessions.begin(); s_it != protein_accessions.end(); ++s_it)
{
PeptideEvidence pe;
pe.setProteinAccession(*s_it);
pep_hits[0].addPeptideEvidence(pe);
}
pep_idents[0].setHits(pep_hits);
generated_features[*dp_it].setPeptideIdentifications(pep_idents);
}
}
// add generated_features to FeatureMap
for (std::map<AASequence, Feature>::iterator it_gf = generated_features.begin();
it_gf != generated_features.end();
++it_gf)
{
// round up intensity
(it_gf->second).setIntensity(ceil((it_gf->second).getIntensity()));
feature_map.push_back(it_gf->second);
}
}
ExitCodes main_(int, const char **)
{
vector<ProteinIdentification> protein_identifications;
vector<PeptideIdentification> identifications;
PeptideIdentification peptide_identification;
DateTime date_time = DateTime::now();
String date_time_string = date_time.get();
peptide_identification.setIdentifier("In-silico_digestion" + date_time_string);
ProteinIdentification protein_identification;
protein_identifications.push_back(ProteinIdentification());
//-------------------------------------------------------------
// parsing parameters
//-------------------------------------------------------------
String inputfile_name = getStringOption_("in");
String outputfile_name = getStringOption_("out");
//input file type
FileHandler fh;
FileTypes::Type out_type = FileTypes::nameToType(getStringOption_("out_type"));
if (out_type == FileTypes::UNKNOWN)
{
out_type = fh.getTypeByFileName(outputfile_name);
writeDebug_(String("Output file type: ") + FileTypes::typeToName(out_type), 2);
}
if (out_type == FileTypes::UNKNOWN)
{
LOG_ERROR << ("Error: Could not determine output file type!") << std::endl;
return PARSE_ERROR;
}
Size min_size = getIntOption_("min_length");
Size max_size = getIntOption_("max_length");
Size missed_cleavages = getIntOption_("missed_cleavages");
bool has_FASTA_output = (out_type == FileTypes::FASTA);
//-------------------------------------------------------------
// reading input
//-------------------------------------------------------------
std::vector<FASTAFile::FASTAEntry> protein_data;
FASTAFile().load(inputfile_name, protein_data);
//-------------------------------------------------------------
// calculations
//-------------------------------------------------------------
// This should be updated if more cleavage enzymes are available
ProteinIdentification::SearchParameters search_parameters;
String enzyme = getStringOption_("enzyme");
EnzymaticDigestion digestor;
if (enzyme == "Trypsin")
{
digestor.setEnzyme(EnzymaticDigestion::ENZYME_TRYPSIN);
digestor.setMissedCleavages(missed_cleavages);
search_parameters.enzyme = ProteinIdentification::TRYPSIN;
}
else if (enzyme == "none")
{
search_parameters.enzyme = ProteinIdentification::NO_ENZYME;
}
else
{
LOG_ERROR << "Internal error in Digestor, when evaluating enzyme name! Please report this!" << std::endl;
return ILLEGAL_PARAMETERS;
}
vector<String> protein_accessions(1);
PeptideHit temp_peptide_hit;
protein_identifications[0].setSearchParameters(search_parameters);
protein_identifications[0].setDateTime(date_time);
protein_identifications[0].setSearchEngine("In-silico digestion");
protein_identifications[0].setIdentifier("In-silico_digestion" + date_time_string);
std::vector<FASTAFile::FASTAEntry> all_peptides;
Size dropped_bylength(0); // stats for removing candidates
for (Size i = 0; i < protein_data.size(); ++i)
{
if (!has_FASTA_output)
{
protein_accessions[0] = protein_data[i].identifier;
ProteinHit temp_protein_hit;
temp_protein_hit.setSequence(protein_data[i].sequence);
temp_protein_hit.setAccession(protein_accessions[0]);
protein_identifications[0].insertHit(temp_protein_hit);
temp_peptide_hit.setProteinAccessions(protein_accessions);
}
vector<AASequence> temp_peptides;
if (enzyme == "none")
{
temp_peptides.push_back(AASequence(protein_data[i].sequence));
}
else
{
digestor.digest(AASequence(protein_data[i].sequence), temp_peptides);
}
for (Size j = 0; j < temp_peptides.size(); ++j)
{
if ((temp_peptides[j].size() >= min_size) &&
(temp_peptides[j].size() <= max_size))
{
if (!has_FASTA_output)
{
temp_peptide_hit.setSequence(temp_peptides[j]);
peptide_identification.insertHit(temp_peptide_hit);
identifications.push_back(peptide_identification);
peptide_identification.setHits(std::vector<PeptideHit>()); // clear
}
else // for FASTA file output
{
FASTAFile::FASTAEntry pep(protein_data[i].identifier, protein_data[i].description, temp_peptides[j].toString());
all_peptides.push_back(pep);
}
}
else
{
++dropped_bylength;
}
}
}
//-------------------------------------------------------------
// writing output
//-------------------------------------------------------------
if (has_FASTA_output)
{
FASTAFile().store(outputfile_name, all_peptides);
}
else
{
IdXMLFile().store(outputfile_name,
protein_identifications,
identifications);
}
Size pep_remaining_count = (has_FASTA_output ? all_peptides.size() : identifications.size());
LOG_INFO << "Statistics:\n"
<< " total #peptides after digestion: " << pep_remaining_count + dropped_bylength << "\n"
<< " removed #peptides (length restrictions): " << dropped_bylength << "\n"
<< " remaining #peptides: " << pep_remaining_count << std::endl;
return EXECUTION_OK;
}